commands/gptsync.c

   1 /* gptsync.c - fill the mbr based on gpt entries  */
   2 /* XXX: I don't know what to do if sector size isn't 512 bytes */
   3 /*
   4  *  GRUB  --  GRand Unified Bootloader
   5  *  Copyright (C) 2009  Free Software Foundation, Inc.
   6  *
   7  *  GRUB is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  GRUB is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include <grub/command.h>
  22 #include <grub/dl.h>
  23 #include <grub/device.h>
  24 #include <grub/disk.h>
  25 #include <grub/pc_partition.h>
  26 #include <grub/partition.h>
  27 #include <grub/misc.h>
  28 #include <grub/mm.h>
  29 #include <grub/fs.h>
  30
  31 /* Convert a LBA address to a CHS address in the INT 13 format.  */
  32 /* Taken from grub1. */
  33 /* XXX: use hardcoded geometry of C = 1024, H = 255, S = 63.
  34    Is it a problem?
  35 */
  36 static void
  37 lba_to_chs (int lba, grub_uint8_t *cl, grub_uint8_t *ch,
  38             grub_uint8_t *dh)
  39 {
  40   int cylinder, head, sector;
  41   int sectors = 63, heads = 255, cylinders = 1024;
  42
  43   sector = lba % sectors + 1;
  44   head = (lba / sectors) % heads;
  45   cylinder = lba / (sectors * heads);
  46
  47   if (cylinder >= cylinders)
  48     {
  49       *cl = *ch = *dh = 0xff;
  50       return;
  51     }
  52
  53   *cl = sector | ((cylinder & 0x300) >> 2);
  54   *ch = cylinder & 0xFF;
  55   *dh = head;
  56 }
  57
  58 static grub_err_t
  59 grub_cmd_gptsync (grub_command_t cmd __attribute__ ((unused)),
  60                   int argc, char **args)
  61 {
  62   grub_device_t dev;
  63   struct grub_pc_partition_mbr mbr;
  64   struct grub_partition *partition;
  65   grub_disk_addr_t first_sector;
  66   int numactive = 0;
  67   int i;
  68
  69   if (argc < 1)
  70     return grub_error (GRUB_ERR_BAD_ARGUMENT, "device name required");
  71   if (argc > 4)
  72     return grub_error (GRUB_ERR_BAD_ARGUMENT, "only 3 partitions can be "
  73                        "in hybrid MBR");
  74
  75   if (args[0][0] == '(' && args[0][grub_strlen (args[0]) - 1] == ')')
  76     {
  77       args[0][grub_strlen (args[0]) - 1] = 0;
  78       dev = grub_device_open (args[0] + 1);
  79       args[0][grub_strlen (args[0])] = ')';
  80     }
  81   else
  82     dev = grub_device_open (args[0]);
  83
  84   if (! dev)
  85     return grub_errno;
  86
  87   if (! dev->disk)
  88     {
  89       grub_device_close (dev);
  90       return grub_error (GRUB_ERR_BAD_ARGUMENT, "not a disk");
  91     }
  92
  93   /* Read the protective MBR.  */
  94   if (grub_disk_read (dev->disk, 0, 0, sizeof (mbr), &mbr))
  95     {
  96       grub_device_close (dev);
  97       return grub_errno;
  98     }
  99
 100   /* Check if it is valid.  */
 101   if (mbr.signature != grub_cpu_to_le16 (GRUB_PC_PARTITION_SIGNATURE))
 102     {
 103       grub_device_close (dev);
 104       return grub_error (GRUB_ERR_BAD_PART_TABLE, "no signature");
 105     }
 106
 107   /* Make sure the MBR is a protective MBR and not a normal MBR.  */
 108   if (mbr.entries[0].type != GRUB_PC_PARTITION_TYPE_GPT_DISK)
 109     {
 110       grub_device_close (dev);
 111       return grub_error (GRUB_ERR_BAD_PART_TABLE, "no GPT partition map found");
 112     }
 113
 114   first_sector = dev->disk->total_sectors;
 115   for (i = 1; i < argc; i++)
 116     {
 117       char *separator, csep = 0;
 118       grub_uint8_t type;
 119       separator = grub_strchr (args[i], '+');
 120       if (! separator)
 121         separator = grub_strchr (args[i], '-');
 122       if (separator)
 123         {
 124           csep = *separator;
 125           *separator = 0;
 126         }
 127       partition = grub_partition_probe (dev->disk, args[i]);
 128       if (separator)
 129         *separator = csep;
 130       if (! partition)
 131         {
 132           grub_device_close (dev);
 133           return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such partition");
 134         }
 135
 136       if (partition->start + partition->len > 0xffffffff)
 137         {
 138           grub_device_close (dev);
 139           return grub_error (GRUB_ERR_OUT_OF_RANGE,
 140                              "only partitions resding in the first 2TB "
 141                              "can be presen in hybrid MBR");
 142         }
 143
 144
 145       if (first_sector > partition->start)
 146         first_sector = partition->start;
 147
 148       if (separator && *(separator + 1))
 149         type = grub_strtoul (separator + 1, 0, 0);
 150       else
 151         {
 152           grub_fs_t fs = 0;
 153           dev->disk->partition = partition;
 154           fs = grub_fs_probe (dev);
 155
 156           /* Unknown filesystem isn't fatal. */
 157           if (grub_errno == GRUB_ERR_UNKNOWN_FS)
 158             {
 159               fs = 0;
 160               grub_errno = GRUB_ERR_NONE;
 161             }
 162
 163           if (fs && grub_strcmp (fs->name, "ntfs") == 0)
 164             type = GRUB_PC_PARTITION_TYPE_NTFS;
 165           else if (fs && grub_strcmp (fs->name, "fat") == 0)
 166             /* FIXME: detect FAT16. */
 167             type = GRUB_PC_PARTITION_TYPE_FAT32_LBA;
 168           else if (fs && (grub_strcmp (fs->name, "hfsplus") == 0
 169                           || grub_strcmp (fs->name, "hfs") == 0))
 170             type = GRUB_PC_PARTITION_TYPE_HFS;
 171           else
 172             /* FIXME: detect more types. */
 173             type = GRUB_PC_PARTITION_TYPE_EXT2FS;
 174
 175           dev->disk->partition = 0;
 176         }
 177
 178       mbr.entries[i].flag = (csep == '+') ? 0x80 : 0;
 179       if (csep == '+')
 180         {
 181           numactive++;
 182           if (numactive == 2)
 183             {
 184               grub_device_close (dev);
 185               return grub_error (GRUB_ERR_BAD_ARGUMENT,
 186                                  "only one partition can be active");
 187             }
 188         }
 189       mbr.entries[i].type = type;
 190       mbr.entries[i].start = grub_cpu_to_le32 (partition->start);
 191       lba_to_chs (partition->start,
 192                   &(mbr.entries[i].start_sector),
 193                   &(mbr.entries[i].start_cylinder),
 194                   &(mbr.entries[i].start_head));
 195       lba_to_chs (partition->start + partition->len - 1,
 196                   &(mbr.entries[i].end_sector),
 197                   &(mbr.entries[i].end_cylinder),
 198                   &(mbr.entries[i].end_head));
 199       mbr.entries[i].length = grub_cpu_to_le32 (partition->len);
 200       grub_free (partition);
 201     }
 202   for (; i < 4; i++)
 203     grub_memset (&(mbr.entries[i]), 0, sizeof (mbr.entries[i]));
 204
 205   /* The protective partition. */
 206   if (first_sector > 0xffffffff)
 207     first_sector = 0xffffffff;
 208   else
 209     first_sector--;
 210   mbr.entries[0].flag = 0;
 211   mbr.entries[0].type = GRUB_PC_PARTITION_TYPE_GPT_DISK;
 212   mbr.entries[0].start = grub_cpu_to_le32 (1);
 213   lba_to_chs (1,
 214               &(mbr.entries[0].start_sector),
 215               &(mbr.entries[0].start_cylinder),
 216               &(mbr.entries[0].start_head));
 217   lba_to_chs (first_sector,
 218               &(mbr.entries[0].end_sector),
 219               &(mbr.entries[0].end_cylinder),
 220               &(mbr.entries[0].end_head));
 221   mbr.entries[0].length = grub_cpu_to_le32 (first_sector);
 222
 223   mbr.signature = grub_cpu_to_le16 (GRUB_PC_PARTITION_SIGNATURE);
 224
 225   if (grub_disk_write (dev->disk, 0, 0, sizeof (mbr), &mbr))
 226     {
 227       grub_device_close (dev);
 228       return grub_errno;
 229     }
 230
 231   grub_printf ("New MBR is written to '%s'\n", args[0]);
 232
 233   return GRUB_ERR_NONE;
 234 }
 235
 236
 237 static grub_command_t cmd;
 238 \f
 239 GRUB_MOD_INIT(gptsync)
 240 {
 241   (void) mod;                   /* To stop warning. */
 242   cmd = grub_register_command ("gptsync", grub_cmd_gptsync,
 243                                "gptsync DEVICE [PARTITION[+/-[TYPE]]] ...",
 244                                "Fill hybrid MBR of GPT drive DEVICE. "
 245                                "specified partitions will be a part "
 246                                "of hybrid mbr. Up to 3 partitions are "
 247                                "allowed. TYPE is an MBR type. "
 248                                "+ means that partition is active. "
 249                                "Only one partition can be active");
 250 }
 251
 252 GRUB_MOD_FINI(gptsync)
 253 {
 254   grub_unregister_command (cmd);
 255 }