[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.3.4.1 and 1.19

version 1.3.4.1, 2008/01/09 01:38:07 version 1.19, 2015/12/01 16:32:19
Line 24 
Line 24 
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */   */
   
   #if HAVE_NBTOOL_CONFIG_H
   #include "nbtool_config.h"
   #endif
   
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 #ifdef __FBSDID  #ifdef __FBSDID
 __FBSDID("$FreeBSD: src/sbin/gpt/remove.c,v 1.10 2006/10/04 18:20:25 marcel Exp $");  __FBSDID("$FreeBSD: src/sbin/gpt/remove.c,v 1.10 2006/10/04 18:20:25 marcel Exp $");
Line 43  __RCSID("$NetBSD$");
Line 47  __RCSID("$NetBSD$");
   
 #include "map.h"  #include "map.h"
 #include "gpt.h"  #include "gpt.h"
   #include "gpt_private.h"
   
 static int all;  static int all;
 static uuid_t type;  static gpt_uuid_t type;
 static off_t block, size;  static off_t block, size;
 static unsigned int entry;  static unsigned int entry;
   static uint8_t *label;
   
 const char removemsg1[] = "remove -a device ...";  static int cmd_remove(gpt_t, int, char *[]);
 const char removemsg2[] = "remove [-b lba] [-i index] [-s lba] "  
         "[-t uuid] device ...";  
   
 static void  static const char *removehelp[] = {
 usage_remove(void)      "-a",
 {      "[-b blocknr] [-i index] [-L label] [-s sectors] [-t type]",
   };
   
   struct gpt_cmd c_remove = {
           "remove",
           cmd_remove,
           removehelp, __arraycount(removehelp),
           0,
   };
   
         fprintf(stderr,  #define usage() gpt_usage(NULL, &c_remove)
             "usage: %s %s\n"  
             "       %s %s\n",  
             getprogname(), removemsg1, getprogname(), removemsg2);  
         exit(1);  
 }  
   
 static void  static int
 rem(int fd)  rem(gpt_t gpt)
 {  {
         uuid_t uuid;          map_t m;
         map_t *gpt, *tpg;  
         map_t *tbl, *lbt;  
         map_t *m;  
         struct gpt_hdr *hdr;  
         struct gpt_ent *ent;          struct gpt_ent *ent;
         unsigned int i;          unsigned int i;
   
         gpt = map_find(MAP_TYPE_PRI_GPT_HDR);          if (gpt_hdr(gpt) == NULL)
         if (gpt == NULL) {                  return -1;
                 warnx("%s: error: no primary GPT header; run create or recover",  
                     device_name);  
                 return;  
         }  
   
         tpg = map_find(MAP_TYPE_SEC_GPT_HDR);  
         if (tpg == NULL) {  
                 warnx("%s: error: no secondary GPT header; run recover",  
                     device_name);  
                 return;  
         }  
   
         tbl = map_find(MAP_TYPE_PRI_GPT_TBL);  
         lbt = map_find(MAP_TYPE_SEC_GPT_TBL);  
         if (tbl == NULL || lbt == NULL) {  
                 warnx("%s: error: run recover -- trust me", device_name);  
                 return;  
         }  
   
         /* Remove all matching entries in the map. */          /* Remove all matching entries in the map. */
         for (m = map_first(); m != NULL; m = m->map_next) {          for (m = map_first(gpt); m != NULL; m = m->map_next) {
                 if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)                  if (m->map_type != MAP_TYPE_GPT_PART || m->map_index < 1)
                         continue;                          continue;
                 if (entry > 0 && entry != m->map_index)                  if (entry > 0 && entry != m->map_index)
Line 109  rem(int fd)
Line 94  rem(int fd)
   
                 i = m->map_index - 1;                  i = m->map_index - 1;
   
                 hdr = gpt->map_data;                  ent = gpt_ent_primary(gpt, i);
                 ent = (void*)((char*)tbl->map_data + i *  
                     le32toh(hdr->hdr_entsz));                  if (label != NULL)
                 le_uuid_dec(&ent->ent_type, &uuid);                          if (strcmp((char *)label,
                 if (!uuid_is_nil(&type, NULL) &&                              (char *)utf16_to_utf8(ent->ent_name)) != 0)
                     !uuid_equal(&type, &uuid, NULL))                                  continue;
   
                   if (!gpt_uuid_is_nil(type) &&
                       !gpt_uuid_equal(type, ent->ent_type))
                         continue;                          continue;
   
                 /* Remove the primary entry by clearing the partition type. */                  /* Remove the primary entry by clearing the partition type. */
                 uuid_create_nil((uuid_t *)&ent->ent_type, NULL);                  gpt_uuid_copy(ent->ent_type, gpt_uuid_nil);
   
                 hdr->hdr_crc_table = htole32(crc32(tbl->map_data,                  if (gpt_write_primary(gpt) == -1)
                     le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));                          return -1;
                 hdr->hdr_crc_self = 0;  
                 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));                  ent = gpt_ent_backup(gpt, i);
   
                 gpt_write(fd, gpt);                  /* Remove the secondary entry. */
                 gpt_write(fd, tbl);                  gpt_uuid_copy(ent->ent_type, gpt_uuid_nil);
   
                 hdr = tpg->map_data;                  if (gpt_write_backup(gpt) == -1)
                 ent = (void*)((char*)lbt->map_data + i *                          return -1;
                     le32toh(hdr->hdr_entsz));                  gpt_msg(gpt, "partition %d removed", m->map_index);
   
                 /* Remove the secundary entry. */  
                 uuid_create_nil((uuid_t *)&ent->ent_type, NULL);  
   
                 hdr->hdr_crc_table = htole32(crc32(lbt->map_data,  
                     le32toh(hdr->hdr_entries) * le32toh(hdr->hdr_entsz)));  
                 hdr->hdr_crc_self = 0;  
                 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));  
   
                 gpt_write(fd, lbt);  
                 gpt_write(fd, tpg);  
 #ifdef __FreeBSD__  
                 printf("%sp%u removed\n", device_name, m->map_index);  
 #endif  
 #ifdef __NetBSD__  
                 printf("partition %d removed from %s\n", m->map_index,  
                     device_name);  
 #endif  
         }          }
           return 0;
 }  }
   
 int  static int
 cmd_remove(int argc, char *argv[])  cmd_remove(gpt_t gpt, int argc, char *argv[])
 {  {
         char *p;          char *p;
         int ch, fd;          int ch;
           int64_t human_num;
   
         /* Get the remove options */          /* Get the remove options */
         while ((ch = getopt(argc, argv, "ab:i:s:t:")) != -1) {          while ((ch = getopt(argc, argv, "ab:i:L:s:t:")) != -1) {
                 switch(ch) {                  switch(ch) {
                 case 'a':                  case 'a':
                         if (all > 0)                          if (all > 0)
                                 usage_remove();                                  return usage();
                         all = 1;                          all = 1;
                         break;                          break;
                 case 'b':                  case 'b':
                         if (block > 0)                          if (block > 0)
                                 usage_remove();                                  return usage();
                         block = strtoll(optarg, &p, 10);                          if (dehumanize_number(optarg, &human_num) < 0)
                         if (*p != 0 || block < 1)                                  return usage();
                                 usage_remove();                          block = human_num;
                           if (block < 1)
                                   return usage();
                         break;                          break;
                 case 'i':                  case 'i':
                         if (entry > 0)                          if (entry > 0)
                                 usage_remove();                                  return usage();
                         entry = strtoul(optarg, &p, 10);                          entry = strtoul(optarg, &p, 10);
                         if (*p != 0 || entry < 1)                          if (*p != 0 || entry < 1)
                                 usage_remove();                                  return usage();
                           break;
                   case 'L':
                           if (label != NULL)
                                   return usage();
                           label = (uint8_t *)strdup(optarg);
                         break;                          break;
                 case 's':                  case 's':
                         if (size > 0)                          if (size > 0)
                                 usage_remove();                                  usage();
                         size = strtoll(optarg, &p, 10);                          size = strtoll(optarg, &p, 10);
                         if (*p != 0 || size < 1)                          if (*p != 0 || size < 1)
                                 usage_remove();                                  return usage();
                         break;                          break;
                 case 't':                  case 't':
                         if (!uuid_is_nil(&type, NULL))                          if (!gpt_uuid_is_nil(type))
                                 usage_remove();                                  return usage();
                         if (parse_uuid(optarg, &type) != 0)                          if (gpt_uuid_parse(optarg, type) != 0)
                                 usage_remove();                                  return usage();
                         break;                          break;
                 default:                  default:
                         usage_remove();                          return usage();
                 }                  }
         }          }
   
         if (!all ^          if (!all ^
             (block > 0 || entry > 0 || size > 0 || !uuid_is_nil(&type, NULL)))              (block > 0 || entry > 0 || label != NULL || size > 0 ||
                 usage_remove();              !gpt_uuid_is_nil(type)))
                   return usage();
         if (argc == optind)  
                 usage_remove();  
   
         while (optind < argc) {          if (argc != optind)
                 fd = gpt_open(argv[optind++]);                  return usage();
                 if (fd == -1) {  
                         warn("unable to open device '%s'", device_name);  
                         continue;  
                 }  
   
                 rem(fd);  
   
                 gpt_close(fd);  
         }  
   
         return (0);          return rem(gpt);
 }  }

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

CVSweb <webmaster@jp.NetBSD.org>