[BACK]Return to remove.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sbin / gpt

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sbin/gpt/remove.c between version 1.19 and 1.20

version 1.19, 2015/12/01 16:32:19 version 1.20, 2015/12/01 19:25:24
Line 49  __RCSID("$NetBSD$");
Line 49  __RCSID("$NetBSD$");
 #include "gpt.h"  #include "gpt.h"
 #include "gpt_private.h"  #include "gpt_private.h"
   
 static int all;  
 static gpt_uuid_t type;  
 static off_t block, size;  
 static unsigned int entry;  
 static uint8_t *label;  
   
 static int cmd_remove(gpt_t, int, char *[]);  static int cmd_remove(gpt_t, int, char *[]);
   
 static const char *removehelp[] = {  static const char *removehelp[] = {
Line 71  struct gpt_cmd c_remove = {
Line 65  struct gpt_cmd c_remove = {
   
 #define usage() gpt_usage(NULL, &c_remove)  #define usage() gpt_usage(NULL, &c_remove)
   
 static int  static void
 rem(gpt_t gpt)  change(struct gpt_ent *ent, void *v)
 {  {
         map_t m;          /* Remove the primary entry by clearing the partition type. */
         struct gpt_ent *ent;          gpt_uuid_copy(ent->ent_type, gpt_uuid_nil);
         unsigned int i;  
   
         if (gpt_hdr(gpt) == NULL)  
                 return -1;  
   
         /* Remove all matching entries in the map. */  
         for (m = map_first(gpt); m != NULL; m = m->map_next) {  
                 if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)  
                         continue;  
                 if (entry > 0 && entry != m->map_index)  
                         continue;  
                 if (block > 0 && block != m->map_start)  
                         continue;  
                 if (size > 0 && size != m->map_size)  
                         continue;  
   
                 i = m->map_index - 1;  
   
                 ent = gpt_ent_primary(gpt, i);  
   
                 if (label != NULL)  
                         if (strcmp((char *)label,  
                             (char *)utf16_to_utf8(ent->ent_name)) != 0)  
                                 continue;  
   
                 if (!gpt_uuid_is_nil(type) &&  
                     !gpt_uuid_equal(type, ent->ent_type))  
                         continue;  
   
                 /* Remove the primary entry by clearing the partition type. */  
                 gpt_uuid_copy(ent->ent_type, gpt_uuid_nil);  
   
                 if (gpt_write_primary(gpt) == -1)  
                         return -1;  
   
                 ent = gpt_ent_backup(gpt, i);  
   
                 /* Remove the secondary entry. */  
                 gpt_uuid_copy(ent->ent_type, gpt_uuid_nil);  
   
                 if (gpt_write_backup(gpt) == -1)  
                         return -1;  
                 gpt_msg(gpt, "partition %d removed", m->map_index);  
         }  
         return 0;  
 }  }
   
 static int  static int
 cmd_remove(gpt_t gpt, int argc, char *argv[])  cmd_remove(gpt_t gpt, int argc, char *argv[])
 {  {
         char *p;  
         int ch;          int ch;
         int64_t human_num;          struct gpt_find find;
   
           memset(&find, 0, sizeof(find));
           find.msg = "removed";
   
         /* Get the remove options */          /* Get the remove options */
         while ((ch = getopt(argc, argv, "ab:i:L:s:t:")) != -1) {          while ((ch = getopt(argc, argv, GPT_FIND)) != -1)
                 switch(ch) {                  if (gpt_add_find(gpt, &find, ch) == -1)
                 case 'a':  
                         if (all > 0)  
                                 return usage();  
                         all = 1;  
                         break;  
                 case 'b':  
                         if (block > 0)  
                                 return usage();  
                         if (dehumanize_number(optarg, &human_num) < 0)  
                                 return usage();  
                         block = human_num;  
                         if (block < 1)  
                                 return usage();  
                         break;  
                 case 'i':  
                         if (entry > 0)  
                                 return usage();  
                         entry = strtoul(optarg, &p, 10);  
                         if (*p != 0 || entry < 1)  
                                 return usage();  
                         break;  
                 case 'L':  
                         if (label != NULL)  
                                 return usage();  
                         label = (uint8_t *)strdup(optarg);  
                         break;  
                 case 's':  
                         if (size > 0)  
                                 usage();  
                         size = strtoll(optarg, &p, 10);  
                         if (*p != 0 || size < 1)  
                                 return usage();  
                         break;  
                 case 't':  
                         if (!gpt_uuid_is_nil(type))  
                                 return usage();  
                         if (gpt_uuid_parse(optarg, type) != 0)  
                                 return usage();  
                         break;  
                 default:  
                         return usage();                          return usage();
                 }  
         }  
   
         if (!all ^  
             (block > 0 || entry > 0 || label != NULL || size > 0 ||  
             !gpt_uuid_is_nil(type)))  
                 return usage();  
   
         if (argc != optind)          if (argc != optind)
                 return usage();                  return usage();
   
         return rem(gpt);          return gpt_change_ent(gpt, &find, change, NULL);
 }  }

Legend:
Removed from v.1.19  
changed lines
  Added in v.1.20

CVSweb <webmaster@jp.NetBSD.org>