sbin/gpt/recover.c

   1 /*-
   2  * Copyright (c) 2002 Marcel Moolenaar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sbin/gpt/recover.c,v 1.8 2005/08/31 01:47:19 marcel Exp $
  27  * $DragonFly: src/sbin/gpt/recover.c,v 1.1 2007/06/16 22:29:27 dillon Exp $
  28  */
  29
  30 #include <sys/types.h>
  31
  32 #include <err.h>
  33 #include <stddef.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <unistd.h>
  38
  39 #include "map.h"
  40 #include "gpt.h"
  41
  42 static int recoverable;
  43
  44 static void
  45 usage_recover(void)
  46 {
  47
  48         fprintf(stderr,
  49             "usage: %s device ...\n", getprogname());
  50         exit(1);
  51 }
  52
  53 static void
  54 recover(int fd)
  55 {
  56         off_t last;
  57         map_t *gpt, *tpg;
  58         map_t *tbl, *lbt;
  59         struct gpt_hdr *hdr;
  60
  61         if (map_find(MAP_TYPE_MBR) != NULL) {
  62                 warnx("%s: error: device contains a MBR", device_name);
  63                 return;
  64         }
  65
  66         gpt = map_find(MAP_TYPE_PRI_GPT_HDR);
  67         tpg = map_find(MAP_TYPE_SEC_GPT_HDR);
  68         tbl = map_find(MAP_TYPE_PRI_GPT_TBL);
  69         lbt = map_find(MAP_TYPE_SEC_GPT_TBL);
  70
  71         if (gpt == NULL && tpg == NULL) {
  72                 warnx("%s: no primary or secondary GPT headers, can't recover",
  73                     device_name);
  74                 return;
  75         }
  76         if (tbl == NULL && lbt == NULL) {
  77                 warnx("%s: no primary or secondary GPT tables, can't recover",
  78                     device_name);
  79                 return;
  80         }
  81
  82         last = mediasz / secsz - 1LL;
  83
  84         if (tbl != NULL && lbt == NULL) {
  85                 lbt = map_add(last - tbl->map_size, tbl->map_size,
  86                     MAP_TYPE_SEC_GPT_TBL, tbl->map_data);
  87                 if (lbt == NULL) {
  88                         warnx("%s: adding secondary GPT table failed",
  89                             device_name);
  90                         return;
  91                 }
  92                 gpt_write(fd, lbt);
  93                 warnx("%s: recovered secondary GPT table from primary",
  94                     device_name);
  95         } else if (tbl == NULL && lbt != NULL) {
  96                 tbl = map_add(2LL, lbt->map_size, MAP_TYPE_PRI_GPT_TBL,
  97                     lbt->map_data);
  98                 if (tbl == NULL) {
  99                         warnx("%s: adding primary GPT table failed",
 100                             device_name);
 101                         return;
 102                 }
 103                 gpt_write(fd, tbl);
 104                 warnx("%s: recovered primary GPT table from secondary",
 105                     device_name);
 106         }
 107
 108         if (gpt != NULL && tpg == NULL) {
 109                 tpg = map_add(last, 1LL, MAP_TYPE_SEC_GPT_HDR,
 110                     calloc(1, secsz));
 111                 if (tpg == NULL) {
 112                         warnx("%s: adding secondary GPT header failed",
 113                             device_name);
 114                         return;
 115                 }
 116                 memcpy(tpg->map_data, gpt->map_data, secsz);
 117                 hdr = tpg->map_data;
 118                 hdr->hdr_lba_self = htole64(tpg->map_start);
 119                 hdr->hdr_lba_alt = htole64(gpt->map_start);
 120                 hdr->hdr_lba_table = htole64(lbt->map_start);
 121                 hdr->hdr_crc_self = 0;
 122                 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
 123                 gpt_write(fd, tpg);
 124                 warnx("%s: recovered secondary GPT header from primary",
 125                     device_name);
 126         } else if (gpt == NULL && tpg != NULL) {
 127                 gpt = map_add(1LL, 1LL, MAP_TYPE_PRI_GPT_HDR,
 128                     calloc(1, secsz));
 129                 if (gpt == NULL) {
 130                         warnx("%s: adding primary GPT header failed",
 131                             device_name);
 132                         return;
 133                 }
 134                 memcpy(gpt->map_data, tpg->map_data, secsz);
 135                 hdr = gpt->map_data;
 136                 hdr->hdr_lba_self = htole64(gpt->map_start);
 137                 hdr->hdr_lba_alt = htole64(tpg->map_start);
 138                 hdr->hdr_lba_table = htole64(tbl->map_start);
 139                 hdr->hdr_crc_self = 0;
 140                 hdr->hdr_crc_self = htole32(crc32(hdr, le32toh(hdr->hdr_size)));
 141                 gpt_write(fd, gpt);
 142                 warnx("%s: recovered primary GPT header from secondary",
 143                     device_name);
 144         }
 145 }
 146
 147 int
 148 cmd_recover(int argc, char *argv[])
 149 {
 150         int ch, fd;
 151
 152         while ((ch = getopt(argc, argv, "r")) != -1) {
 153                 switch(ch) {
 154                 case 'r':
 155                         recoverable = 1;
 156                         break;
 157                 default:
 158                         usage_recover();
 159                 }
 160         }
 161
 162         if (argc == optind)
 163                 usage_recover();
 164
 165         while (optind < argc) {
 166                 fd = gpt_open(argv[optind++]);
 167                 if (fd == -1) {
 168                         warn("unable to open device '%s'", device_name);
 169                         continue;
 170                 }
 171
 172                 recover(fd);
 173
 174                 gpt_close(fd);
 175         }
 176
 177         return (0);
 178 }