util/hostdisk.c

   1 /* biosdisk.c - emulate biosdisk */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2007,2008,2009  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/disk.h>
  21 #include <grub/partition.h>
  22 #include <grub/pc_partition.h>
  23 #include <grub/types.h>
  24 #include <grub/err.h>
  25 #include <grub/util/misc.h>
  26 #include <grub/util/hostdisk.h>
  27 #include <grub/misc.h>
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <assert.h>
  34 #include <unistd.h>
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include <errno.h>
  39 #include <limits.h>
  40
  41 #ifdef __linux__
  42 # include <sys/ioctl.h>         /* ioctl */
  43 # if !defined(__GLIBC__) || \
  44         ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))
  45 /* Maybe libc doesn't have large file support.  */
  46 #  include <linux/unistd.h>     /* _llseek */
  47 # endif /* (GLIBC < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR < 1)) */
  48 # ifndef BLKFLSBUF
  49 #  define BLKFLSBUF     _IO (0x12,97)   /* flush buffer cache */
  50 # endif /* ! BLKFLSBUF */
  51 # include <sys/ioctl.h>         /* ioctl */
  52 # ifndef HDIO_GETGEO
  53 #  define HDIO_GETGEO   0x0301  /* get device geometry */
  54 /* If HDIO_GETGEO is not defined, it is unlikely that hd_geometry is
  55    defined.  */
  56 struct hd_geometry
  57 {
  58   unsigned char heads;
  59   unsigned char sectors;
  60   unsigned short cylinders;
  61   unsigned long start;
  62 };
  63 # endif /* ! HDIO_GETGEO */
  64 # ifndef BLKGETSIZE64
  65 #  define BLKGETSIZE64  _IOR(0x12,114,size_t)    /* return device size */
  66 # endif /* ! BLKGETSIZE64 */
  67 # ifndef MAJOR
  68 #  ifndef MINORBITS
  69 #   define MINORBITS    8
  70 #  endif /* ! MINORBITS */
  71 #  define MAJOR(dev)    ((unsigned) ((dev) >> MINORBITS))
  72 # endif /* ! MAJOR */
  73 # ifndef FLOPPY_MAJOR
  74 #  define FLOPPY_MAJOR  2
  75 # endif /* ! FLOPPY_MAJOR */
  76 # ifndef LOOP_MAJOR
  77 #  define LOOP_MAJOR    7
  78 # endif /* ! LOOP_MAJOR */
  79 #endif /* __linux__ */
  80
  81 #ifdef __CYGWIN__
  82 # include <sys/ioctl.h>
  83 # include <cygwin/fs.h> /* BLKGETSIZE64 */
  84 # include <cygwin/hdreg.h> /* HDIO_GETGEO */
  85 # define MAJOR(dev)     ((unsigned) ((dev) >> 16))
  86 # define FLOPPY_MAJOR   2
  87 #endif
  88
  89 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  90 # include <sys/disk.h> /* DIOCGMEDIASIZE */
  91 # include <sys/param.h>
  92 # include <sys/sysctl.h>
  93 #endif
  94
  95 struct
  96 {
  97   char *drive;
  98   char *device;
  99 } map[256];
 100
 101 #ifdef __linux__
 102 /* Check if we have devfs support.  */
 103 static int
 104 have_devfs (void)
 105 {
 106   static int dev_devfsd_exists = -1;
 107
 108   if (dev_devfsd_exists < 0)
 109     {
 110       struct stat st;
 111
 112       dev_devfsd_exists = stat ("/dev/.devfsd", &st) == 0;
 113     }
 114
 115   return dev_devfsd_exists;
 116 }
 117 #endif /* __linux__ */
 118
 119 static int
 120 find_grub_drive (const char *name)
 121 {
 122   unsigned int i;
 123
 124   if (name)
 125     {
 126       for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
 127         if (map[i].drive && ! strcmp (map[i].drive, name))
 128           return i;
 129     }
 130
 131   return -1;
 132 }
 133
 134 static int
 135 find_free_slot ()
 136 {
 137   unsigned int i;
 138
 139   for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
 140     if (! map[i].drive)
 141       return i;
 142
 143   return -1;
 144 }
 145
 146 static int
 147 grub_util_biosdisk_iterate (int (*hook) (const char *name))
 148 {
 149   unsigned i;
 150
 151   for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
 152     if (map[i].drive && hook (map[i].drive))
 153       return 1;
 154
 155   return 0;
 156 }
 157
 158 static grub_err_t
 159 grub_util_biosdisk_open (const char *name, grub_disk_t disk)
 160 {
 161   int drive;
 162   struct stat st;
 163
 164   drive = find_grub_drive (name);
 165   if (drive < 0)
 166     return grub_error (GRUB_ERR_BAD_DEVICE,
 167                        "no mapping exists for `%s'", name);
 168
 169   disk->has_partitions = 1;
 170   disk->id = drive;
 171
 172   /* Get the size.  */
 173 #if defined(__MINGW32__)
 174   {
 175     grub_uint64_t size;
 176
 177     size = grub_util_get_disk_size (map[drive].device);
 178
 179     if (size % 512)
 180       grub_util_error ("unaligned device size");
 181
 182     disk->total_sectors = size >> 9;
 183
 184     grub_util_info ("the size of %s is %llu", name, disk->total_sectors);
 185
 186     return GRUB_ERR_NONE;
 187   }
 188 #elif defined(__linux__) || defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 189   {
 190     unsigned long long nr;
 191     int fd;
 192
 193     fd = open (map[drive].device, O_RDONLY);
 194     if (fd == -1)
 195       return grub_error (GRUB_ERR_BAD_DEVICE, "cannot open `%s' while attempting to get disk size", map[drive].device);
 196
 197 # if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 198     if (fstat (fd, &st) < 0 || ! S_ISCHR (st.st_mode))
 199 # else
 200     if (fstat (fd, &st) < 0 || ! S_ISBLK (st.st_mode))
 201 # endif
 202       {
 203         close (fd);
 204         goto fail;
 205       }
 206
 207 # if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 208     if (ioctl (fd, DIOCGMEDIASIZE, &nr))
 209 # else
 210     if (ioctl (fd, BLKGETSIZE64, &nr))
 211 # endif
 212       {
 213         close (fd);
 214         goto fail;
 215       }
 216
 217     close (fd);
 218     disk->total_sectors = nr / 512;
 219
 220     if (nr % 512)
 221       grub_util_error ("unaligned device size");
 222
 223     grub_util_info ("the size of %s is %llu", name, disk->total_sectors);
 224
 225     return GRUB_ERR_NONE;
 226   }
 227
 228  fail:
 229   /* In GNU/Hurd, stat() will return the right size.  */
 230 #elif !defined (__GNU__)
 231 # warning "No special routine to get the size of a block device is implemented for your OS. This is not possibly fatal."
 232 #endif
 233   if (stat (map[drive].device, &st) < 0)
 234     return grub_error (GRUB_ERR_BAD_DEVICE, "cannot stat `%s'", map[drive].device);
 235
 236   disk->total_sectors = st.st_size >> GRUB_DISK_SECTOR_BITS;
 237
 238   grub_util_info ("the size of %s is %lu", name, disk->total_sectors);
 239
 240   return GRUB_ERR_NONE;
 241 }
 242
 243 #ifdef __linux__
 244 static int
 245 linux_find_partition (char *dev, unsigned long sector)
 246 {
 247   size_t len = strlen (dev);
 248   const char *format;
 249   char *p;
 250   int i;
 251   char real_dev[PATH_MAX];
 252
 253   strcpy(real_dev, dev);
 254
 255   if (have_devfs () && strcmp (real_dev + len - 5, "/disc") == 0)
 256     {
 257       p = real_dev + len - 4;
 258       format = "part%d";
 259     }
 260   else if (real_dev[len - 1] >= '0' && real_dev[len - 1] <= '9')
 261     {
 262       p = real_dev + len;
 263       format = "p%d";
 264     }
 265   else
 266     {
 267       p = real_dev + len;
 268       format = "%d";
 269     }
 270
 271   for (i = 1; i < 10000; i++)
 272     {
 273       int fd;
 274       struct hd_geometry hdg;
 275
 276       sprintf (p, format, i);
 277       fd = open (real_dev, O_RDONLY);
 278       if (fd == -1)
 279         return 0;
 280
 281       if (ioctl (fd, HDIO_GETGEO, &hdg))
 282         {
 283           close (fd);
 284           return 0;
 285         }
 286
 287       close (fd);
 288
 289       if (hdg.start == sector)
 290         {
 291           strcpy (dev, real_dev);
 292           return 1;
 293         }
 294     }
 295
 296   return 0;
 297 }
 298 #endif /* __linux__ */
 299
 300 static int
 301 open_device (const grub_disk_t disk, grub_disk_addr_t sector, int flags)
 302 {
 303   int fd;
 304
 305 #ifdef O_LARGEFILE
 306   flags |= O_LARGEFILE;
 307 #endif
 308 #ifdef O_SYNC
 309   flags |= O_SYNC;
 310 #endif
 311 #ifdef O_FSYNC
 312   flags |= O_FSYNC;
 313 #endif
 314 #ifdef O_BINARY
 315   flags |= O_BINARY;
 316 #endif
 317
 318 #ifdef __linux__
 319   /* Linux has a bug that the disk cache for a whole disk is not consistent
 320      with the one for a partition of the disk.  */
 321   {
 322     int is_partition = 0;
 323     char dev[PATH_MAX];
 324
 325     strcpy (dev, map[disk->id].device);
 326     if (disk->partition && strncmp (map[disk->id].device, "/dev/", 5) == 0)
 327       is_partition = linux_find_partition (dev, disk->partition->start);
 328
 329     /* Open the partition.  */
 330     grub_dprintf ("hostdisk", "opening the device `%s' in open_device()", dev);
 331     fd = open (dev, flags);
 332     if (fd < 0)
 333       {
 334         grub_error (GRUB_ERR_BAD_DEVICE, "cannot open `%s'", dev);
 335         return -1;
 336       }
 337
 338     /* Make the buffer cache consistent with the physical disk.  */
 339     ioctl (fd, BLKFLSBUF, 0);
 340
 341     if (is_partition)
 342       sector -= disk->partition->start;
 343   }
 344 #else /* ! __linux__ */
 345 #if defined (__FreeBSD__) || defined(__FreeBSD_kernel__)
 346   int sysctl_flags, sysctl_oldflags;
 347   const size_t sysctl_size = sizeof (sysctl_flags);
 348
 349   if (sysctlbyname ("kern.geom.debugflags", &sysctl_oldflags, &sysctl_size, NULL, 0))
 350     {
 351       grub_error (GRUB_ERR_BAD_DEVICE, "cannot get current flags of sysctl kern.geom.debugflags");
 352       return -1;
 353     }
 354   sysctl_flags = sysctl_oldflags | 0x10;
 355   if (! (sysctl_oldflags & 0x10)
 356       && sysctlbyname ("kern.geom.debugflags", NULL , 0, &sysctl_flags, sysctl_size))
 357     {
 358       grub_error (GRUB_ERR_BAD_DEVICE, "cannot set flags of sysctl kern.geom.debugflags");
 359       return -1;
 360     }
 361 #endif
 362
 363   fd = open (map[disk->id].device, flags);
 364
 365 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 366   if (! (sysctl_oldflags & 0x10)
 367       && sysctlbyname ("kern.geom.debugflags", NULL , 0, &sysctl_oldflags, sysctl_size))
 368     {
 369       grub_error (GRUB_ERR_BAD_DEVICE, "cannot set flags back to the old value for sysctl kern.geom.debugflags");
 370       return -1;
 371     }
 372 #endif
 373
 374   if (fd < 0)
 375     {
 376       grub_error (GRUB_ERR_BAD_DEVICE, "cannot open `%s' in open_device()", map[disk->id].device);
 377       return -1;
 378     }
 379 #endif /* ! __linux__ */
 380
 381 #if defined(__linux__) && (!defined(__GLIBC__) || \
 382         ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1))))
 383   /* Maybe libc doesn't have large file support.  */
 384   {
 385     loff_t offset, result;
 386     static int _llseek (uint filedes, ulong hi, ulong lo,
 387                         loff_t *res, uint wh);
 388     _syscall5 (int, _llseek, uint, filedes, ulong, hi, ulong, lo,
 389                loff_t *, res, uint, wh);
 390
 391     offset = (loff_t) sector << GRUB_DISK_SECTOR_BITS;
 392     if (_llseek (fd, offset >> 32, offset & 0xffffffff, &result, SEEK_SET))
 393       {
 394         grub_error (GRUB_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id].device);
 395         close (fd);
 396         return -1;
 397       }
 398   }
 399 #else
 400   {
 401     off_t offset = (off_t) sector << GRUB_DISK_SECTOR_BITS;
 402
 403     if (lseek (fd, offset, SEEK_SET) != offset)
 404       {
 405         grub_error (GRUB_ERR_BAD_DEVICE, "cannot seek `%s'", map[disk->id].device);
 406         close (fd);
 407         return -1;
 408       }
 409   }
 410 #endif
 411
 412   return fd;
 413 }
 414
 415 /* Read LEN bytes from FD in BUF. Return less than or equal to zero if an
 416    error occurs, otherwise return LEN.  */
 417 static ssize_t
 418 nread (int fd, char *buf, size_t len)
 419 {
 420   ssize_t size = len;
 421
 422   while (len)
 423     {
 424       ssize_t ret = read (fd, buf, len);
 425
 426       if (ret <= 0)
 427         {
 428           if (errno == EINTR)
 429             continue;
 430           else
 431             return ret;
 432         }
 433
 434       len -= ret;
 435       buf += ret;
 436     }
 437
 438   return size;
 439 }
 440
 441 /* Write LEN bytes from BUF to FD. Return less than or equal to zero if an
 442    error occurs, otherwise return LEN.  */
 443 static ssize_t
 444 nwrite (int fd, const char *buf, size_t len)
 445 {
 446   ssize_t size = len;
 447
 448   while (len)
 449     {
 450       ssize_t ret = write (fd, buf, len);
 451
 452       if (ret <= 0)
 453         {
 454           if (errno == EINTR)
 455             continue;
 456           else
 457             return ret;
 458         }
 459
 460       len -= ret;
 461       buf += ret;
 462     }
 463
 464   return size;
 465 }
 466
 467 static grub_err_t
 468 grub_util_biosdisk_read (grub_disk_t disk, grub_disk_addr_t sector,
 469                          grub_size_t size, char *buf)
 470 {
 471   int fd;
 472
 473   fd = open_device (disk, sector, O_RDONLY);
 474   if (fd < 0)
 475     return grub_errno;
 476
 477 #ifdef __linux__
 478   if (sector == 0 && size > 1)
 479     {
 480       /* Work around a bug in Linux ez remapping.  Linux remaps all
 481          sectors that are read together with the MBR in one read.  It
 482          should only remap the MBR, so we split the read in two
 483          parts. -jochen  */
 484       if (nread (fd, buf, GRUB_DISK_SECTOR_SIZE) != GRUB_DISK_SECTOR_SIZE)
 485         {
 486           grub_error (GRUB_ERR_READ_ERROR, "cannot read `%s'", map[disk->id].device);
 487           close (fd);
 488           return grub_errno;
 489         }
 490
 491       buf += GRUB_DISK_SECTOR_SIZE;
 492       size--;
 493     }
 494 #endif /* __linux__ */
 495
 496   if (nread (fd, buf, size << GRUB_DISK_SECTOR_BITS)
 497       != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
 498     grub_error (GRUB_ERR_READ_ERROR, "cannot read from `%s'", map[disk->id].device);
 499
 500   close (fd);
 501   return grub_errno;
 502 }
 503
 504 static grub_err_t
 505 grub_util_biosdisk_write (grub_disk_t disk, grub_disk_addr_t sector,
 506                           grub_size_t size, const char *buf)
 507 {
 508   int fd;
 509
 510   fd = open_device (disk, sector, O_WRONLY);
 511   if (fd < 0)
 512     return grub_errno;
 513
 514   if (nwrite (fd, buf, size << GRUB_DISK_SECTOR_BITS)
 515       != (ssize_t) (size << GRUB_DISK_SECTOR_BITS))
 516     grub_error (GRUB_ERR_WRITE_ERROR, "cannot write to `%s'", map[disk->id].device);
 517
 518   close (fd);
 519   return grub_errno;
 520 }
 521
 522 static struct grub_disk_dev grub_util_biosdisk_dev =
 523   {
 524     .name = "biosdisk",
 525     .id = GRUB_DISK_DEVICE_BIOSDISK_ID,
 526     .iterate = grub_util_biosdisk_iterate,
 527     .open = grub_util_biosdisk_open,
 528     .close = 0,
 529     .read = grub_util_biosdisk_read,
 530     .write = grub_util_biosdisk_write,
 531     .next = 0
 532   };
 533
 534 static void
 535 read_device_map (const char *dev_map)
 536 {
 537   FILE *fp;
 538   char buf[1024];       /* XXX */
 539   int lineno = 0;
 540   struct stat st;
 541
 542   auto void show_error (const char *msg);
 543   void show_error (const char *msg)
 544     {
 545       grub_util_error ("%s:%d: %s", dev_map, lineno, msg);
 546     }
 547
 548   fp = fopen (dev_map, "r");
 549   if (! fp)
 550     grub_util_error ("Cannot open `%s'", dev_map);
 551
 552   while (fgets (buf, sizeof (buf), fp))
 553     {
 554       char *p = buf;
 555       char *e;
 556       int drive;
 557
 558       lineno++;
 559
 560       /* Skip leading spaces.  */
 561       while (*p && isspace (*p))
 562         p++;
 563
 564       /* If the first character is `#' or NUL, skip this line.  */
 565       if (*p == '\0' || *p == '#')
 566         continue;
 567
 568       if (*p != '(')
 569         show_error ("No open parenthesis found");
 570
 571       p++;
 572       /* Find a free slot.  */
 573       drive = find_free_slot ();
 574       if (drive < 0)
 575         show_error ("Map table size exceeded");
 576
 577       e = p;
 578       p = strchr (p, ')');
 579       if (! p)
 580         show_error ("No close parenthesis found");
 581
 582       map[drive].drive = xmalloc (p - e + sizeof ('\0'));
 583       strncpy (map[drive].drive, e, p - e + sizeof ('\0'));
 584       map[drive].drive[p - e] = '\0';
 585
 586       p++;
 587       /* Skip leading spaces.  */
 588       while (*p && isspace (*p))
 589         p++;
 590
 591       if (*p == '\0')
 592         show_error ("No filename found");
 593
 594       /* NUL-terminate the filename.  */
 595       e = p;
 596       while (*e && ! isspace (*e))
 597         e++;
 598       *e = '\0';
 599
 600 #ifdef __MINGW32__
 601       (void) st;
 602       if (grub_util_get_disk_size (p) == -1LL)
 603 #else
 604       if (stat (p, &st) == -1)
 605 #endif
 606         {
 607           free (map[drive].drive);
 608           map[drive].drive = NULL;
 609           grub_util_info ("Cannot stat `%s', skipping", p);
 610           continue;
 611         }
 612
 613 #ifdef __linux__
 614       /* On Linux, the devfs uses symbolic links horribly, and that
 615          confuses the interface very much, so use realpath to expand
 616          symbolic links.  */
 617       map[drive].device = xmalloc (PATH_MAX);
 618       if (! realpath (p, map[drive].device))
 619         grub_util_error ("Cannot get the real path of `%s'", p);
 620 #else
 621       map[drive].device = xstrdup (p);
 622 #endif
 623     }
 624
 625   fclose (fp);
 626 }
 627
 628 void
 629 grub_util_biosdisk_init (const char *dev_map)
 630 {
 631   read_device_map (dev_map);
 632   grub_disk_dev_register (&grub_util_biosdisk_dev);
 633 }
 634
 635 void
 636 grub_util_biosdisk_fini (void)
 637 {
 638   unsigned i;
 639
 640   for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
 641     {
 642       if (map[i].drive)
 643         free (map[i].drive);
 644       if (map[i].device)
 645         free (map[i].device);
 646       map[i].drive = map[i].device = NULL;
 647     }
 648
 649   grub_disk_dev_unregister (&grub_util_biosdisk_dev);
 650 }
 651
 652 static char *
 653 make_device_name (int drive, int dos_part, int bsd_part)
 654 {
 655   int len = strlen(map[drive].drive);
 656   char *p;
 657
 658   if (dos_part >= 0)
 659     {
 660       /* Add in char length of dos_part+1 */
 661       int tmp = dos_part + 1;
 662       len++;
 663       while ((tmp /= 10) != 0)
 664         len++;
 665     }
 666   if (bsd_part >= 0)
 667     len += 2;
 668
 669   /* Length to alloc is: char length of map[drive].drive, plus
 670    *                     char length of (dos_part+1) or of bsd_part, plus
 671    *                     2 for the comma and a null/end of string (\0)
 672    */
 673   p = xmalloc (len + 2);
 674   sprintf (p, "%s", map[drive].drive);
 675
 676   if (dos_part >= 0)
 677     sprintf (p + strlen (p), ",%d", dos_part + 1);
 678
 679   if (bsd_part >= 0)
 680     sprintf (p + strlen (p), ",%c", bsd_part + 'a');
 681
 682   return p;
 683 }
 684
 685 static char *
 686 convert_system_partition_to_system_disk (const char *os_dev)
 687 {
 688 #if defined(__linux__)
 689   char *path = xmalloc (PATH_MAX);
 690   if (! realpath (os_dev, path))
 691     return 0;
 692
 693   if (strncmp ("/dev/", path, 5) == 0)
 694     {
 695       char *p = path + 5;
 696
 697       /* If this is an IDE disk.  */
 698       if (strncmp ("ide/", p, 4) == 0)
 699         {
 700           p = strstr (p, "part");
 701           if (p)
 702             strcpy (p, "disc");
 703
 704           return path;
 705         }
 706
 707       /* If this is a SCSI disk.  */
 708       if (strncmp ("scsi/", p, 5) == 0)
 709         {
 710           p = strstr (p, "part");
 711           if (p)
 712             strcpy (p, "disc");
 713
 714           return path;
 715         }
 716
 717       /* If this is a DAC960 disk.  */
 718       if (strncmp ("rd/c", p, 4) == 0)
 719         {
 720           /* /dev/rd/c[0-9]+d[0-9]+(p[0-9]+)? */
 721           p = strchr (p, 'p');
 722           if (p)
 723             *p = '\0';
 724
 725           return path;
 726         }
 727
 728       /* If this is a CCISS disk.  */
 729       if (strncmp ("cciss/c", p, sizeof ("cciss/c") - 1) == 0)
 730         {
 731           /* /dev/cciss/c[0-9]+d[0-9]+(p[0-9]+)? */
 732           p = strchr (p, 'p');
 733           if (p)
 734             *p = '\0';
 735
 736           return path;
 737         }
 738
 739       /* If this is a Compaq Intelligent Drive Array.  */
 740       if (strncmp ("ida/c", p, sizeof ("ida/c") - 1) == 0)
 741         {
 742           /* /dev/ida/c[0-9]+d[0-9]+(p[0-9]+)? */
 743           p = strchr (p, 'p');
 744           if (p)
 745             *p = '\0';
 746
 747           return path;
 748         }
 749
 750       /* If this is an I2O disk.  */
 751       if (strncmp ("i2o/hd", p, sizeof ("i2o/hd") - 1) == 0)
 752         {
 753           /* /dev/i2o/hd[a-z]([0-9]+)? */
 754           p[sizeof ("i2o/hda") - 1] = '\0';
 755           return path;
 756         }
 757
 758       /* If this is a MultiMediaCard (MMC).  */
 759       if (strncmp ("mmcblk", p, sizeof ("mmcblk") - 1) == 0)
 760         {
 761           /* /dev/mmcblk[0-9]+(p[0-9]+)? */
 762           p = strchr (p, 'p');
 763           if (p)
 764             *p = '\0';
 765
 766           return path;
 767         }
 768
 769       /* If this is an IDE, SCSI or Virtio disk.  */
 770       if (strncmp ("vdisk", p, 5) == 0
 771           && p[5] >= 'a' && p[5] <= 'z')
 772         {
 773           /* /dev/vdisk[a-z][0-9]* */
 774           p[6] = '\0';
 775           return path;
 776         }
 777       if ((strncmp ("hd", p, 2) == 0
 778            || strncmp ("vd", p, 2) == 0
 779            || strncmp ("sd", p, 2) == 0)
 780           && p[2] >= 'a' && p[2] <= 'z')
 781         {
 782           /* /dev/[hsv]d[a-z][0-9]* */
 783           p[3] = '\0';
 784           return path;
 785         }
 786
 787       /* If this is a Xen virtual block device.  */
 788       if ((strncmp ("xvd", p, 3) == 0) && p[3] >= 'a' && p[3] <= 'z')
 789         {
 790           /* /dev/xvd[a-z][0-9]* */
 791           p[4] = '\0';
 792           return path;
 793         }
 794     }
 795
 796   return path;
 797
 798 #elif defined(__GNU__)
 799   char *path = xstrdup (os_dev);
 800   if (strncmp ("/dev/sd", path, 7) == 0 || strncmp ("/dev/hd", path, 7) == 0)
 801     {
 802       char *p = strchr (path + 7, 's');
 803       if (p)
 804         *p = '\0';
 805     }
 806   return path;
 807
 808 #elif defined(__CYGWIN__)
 809   char *path = xstrdup (os_dev);
 810   if (strncmp ("/dev/sd", path, 7) == 0 && 'a' <= path[7] && path[7] <= 'z')
 811     path[8] = 0;
 812   return path;
 813
 814 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 815   char *path = xstrdup (os_dev);
 816   if (strncmp ("/dev/", path, 5) == 0)
 817     {
 818       char *p;
 819       for (p = path + 5; *p; ++p)
 820         if (grub_isdigit(*p))
 821           {
 822             p = strchr (p, 's');
 823             if (p)
 824               *p = '\0';
 825             break;
 826           }
 827     }
 828   return path;
 829
 830 #else
 831 # warning "The function `convert_system_partition_to_system_disk' might not work on your OS correctly."
 832   return xstrdup (os_dev);
 833 #endif
 834 }
 835
 836 static int
 837 device_is_wholedisk (const char *os_dev)
 838 {
 839   int len = strlen (os_dev);
 840
 841   if (os_dev[len - 1] < '0' || os_dev[len - 1] > '9')
 842     return 1;
 843   return 0;
 844 }
 845
 846 static int
 847 find_system_device (const char *os_dev)
 848 {
 849   int i;
 850   char *os_disk;
 851
 852   os_disk = convert_system_partition_to_system_disk (os_dev);
 853   if (! os_disk)
 854     return -1;
 855
 856   for (i = 0; i < (int) (sizeof (map) / sizeof (map[0])); i++)
 857     if (map[i].device && strcmp (map[i].device, os_disk) == 0)
 858       {
 859         free (os_disk);
 860         return i;
 861       }
 862
 863   free (os_disk);
 864   return -1;
 865 }
 866
 867 char *
 868 grub_util_biosdisk_get_grub_dev (const char *os_dev)
 869 {
 870   struct stat st;
 871   int drive;
 872
 873   if (stat (os_dev, &st) < 0)
 874     {
 875       grub_error (GRUB_ERR_BAD_DEVICE, "cannot stat `%s'", os_dev);
 876       return 0;
 877     }
 878
 879   drive = find_system_device (os_dev);
 880   if (drive < 0)
 881     {
 882       grub_error (GRUB_ERR_BAD_DEVICE,
 883                   "no mapping exists for `%s'", os_dev);
 884       return 0;
 885     }
 886
 887   if (grub_strcmp (os_dev, convert_system_partition_to_system_disk (os_dev))
 888       == 0)
 889     return make_device_name (drive, -1, -1);
 890
 891 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 892   if (! S_ISCHR (st.st_mode))
 893 #else
 894   if (! S_ISBLK (st.st_mode))
 895 #endif
 896     return make_device_name (drive, -1, -1);
 897
 898 #if defined(__linux__) || defined(__CYGWIN__)
 899   /* Linux counts partitions uniformly, whether a BSD partition or a DOS
 900      partition, so mapping them to GRUB devices is not trivial.
 901      Here, get the start sector of a partition by HDIO_GETGEO, and
 902      compare it with each partition GRUB recognizes.
 903
 904      Cygwin /dev/sdXN emulation uses Windows partition mapping. It
 905      does not count the extended partition and missing primary
 906      partitions.  Use same method as on Linux here.  */
 907   {
 908     char *name;
 909     grub_disk_t disk;
 910     int fd;
 911     struct hd_geometry hdg;
 912     int dos_part = -1;
 913     int bsd_part = -1;
 914     auto int find_partition (grub_disk_t disk,
 915                              const grub_partition_t partition);
 916
 917     int find_partition (grub_disk_t disk __attribute__ ((unused)),
 918                         const grub_partition_t partition)
 919       {
 920         struct grub_pc_partition *pcdata = NULL;
 921
 922         if (strcmp (partition->partmap->name, "pc_partition_map") == 0)
 923           pcdata = partition->data;
 924
 925         if (pcdata)
 926           {
 927             if (pcdata->bsd_part < 0)
 928               grub_util_info ("DOS partition %d starts from %lu",
 929                               pcdata->dos_part, partition->start);
 930             else
 931               grub_util_info ("BSD partition %d,%c starts from %lu",
 932                               pcdata->dos_part, pcdata->bsd_part + 'a',
 933                               partition->start);
 934           }
 935         else
 936           {
 937               grub_util_info ("Partition %d starts from %lu",
 938                               partition->index, partition->start);
 939           }
 940
 941         if (hdg.start == partition->start)
 942           {
 943             if (pcdata)
 944               {
 945                 dos_part = pcdata->dos_part;
 946                 bsd_part = pcdata->bsd_part;
 947               }
 948             else
 949               {
 950                 dos_part = partition->index;
 951                 bsd_part = -1;
 952               }
 953             return 1;
 954           }
 955
 956         return 0;
 957       }
 958
 959     name = make_device_name (drive, -1, -1);
 960
 961     if (MAJOR (st.st_rdev) == FLOPPY_MAJOR)
 962       return name;
 963
 964     fd = open (os_dev, O_RDONLY);
 965     if (fd == -1)
 966       {
 967         grub_error (GRUB_ERR_BAD_DEVICE, "cannot open `%s' while attempting to get disk geometry", os_dev);
 968         free (name);
 969         return 0;
 970       }
 971
 972     if (ioctl (fd, HDIO_GETGEO, &hdg))
 973       {
 974         grub_error (GRUB_ERR_BAD_DEVICE,
 975                     "cannot get geometry of `%s'", os_dev);
 976         close (fd);
 977         free (name);
 978         return 0;
 979       }
 980
 981     close (fd);
 982
 983     grub_util_info ("%s starts from %lu", os_dev, hdg.start);
 984
 985     if (hdg.start == 0 && device_is_wholedisk (os_dev))
 986       return name;
 987
 988     grub_util_info ("opening the device %s", name);
 989     disk = grub_disk_open (name);
 990     free (name);
 991
 992     if (! disk)
 993       return 0;
 994
 995     grub_partition_iterate (disk, find_partition);
 996     if (grub_errno != GRUB_ERR_NONE)
 997       {
 998         grub_disk_close (disk);
 999         return 0;
1000       }
1001
1002     if (dos_part < 0)
1003       {
1004         grub_disk_close (disk);
1005         grub_error (GRUB_ERR_BAD_DEVICE,
1006                     "cannot find the partition of `%s'", os_dev);
1007         return 0;
1008       }
1009
1010     return make_device_name (drive, dos_part, bsd_part);
1011   }
1012
1013 #elif defined(__GNU__)
1014   /* GNU uses "/dev/[hs]d[0-9]+(s[0-9]+[a-z]?)?".  */
1015   {
1016     char *p;
1017     int dos_part = -1;
1018     int bsd_part = -1;
1019
1020     p = strrchr (os_dev, 's');
1021     if (p)
1022       {
1023         long int n;
1024         char *q;
1025
1026         p++;
1027         n = strtol (p, &q, 10);
1028         if (p != q && n != GRUB_LONG_MIN && n != GRUB_LONG_MAX)
1029           {
1030             dos_part = (int) n;
1031
1032             if (*q >= 'a' && *q <= 'g')
1033               bsd_part = *q - 'a';
1034           }
1035       }
1036
1037     return make_device_name (drive, dos_part, bsd_part);
1038   }
1039
1040 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1041   /* FreeBSD uses "/dev/[a-z]+[0-9]+(s[0-9]+[a-z]?)?".  */
1042   {
1043     int dos_part = -1;
1044     int bsd_part = -1;
1045
1046     if (strncmp ("/dev/", os_dev, 5) == 0)
1047       {
1048         char *p, *q;
1049         long int n;
1050
1051         for (p = os_dev + 5; *p; ++p)
1052           if (grub_isdigit(*p))
1053             {
1054               p = strchr (p, 's');
1055               if (p)
1056                 {
1057                   p++;
1058                   n = strtol (p, &q, 10);
1059                   if (p != q && n != GRUB_LONG_MIN && n != GRUB_LONG_MAX)
1060                     {
1061                       dos_part = (int) n - 1;
1062
1063                       if (*q >= 'a' && *q <= 'g')
1064                         bsd_part = *q - 'a';
1065                     }
1066                 }
1067               break;
1068             }
1069       }
1070
1071     return make_device_name (drive, dos_part, bsd_part);
1072   }
1073
1074 #else
1075 # warning "The function `grub_util_biosdisk_get_grub_dev' might not work on your OS correctly."
1076   return make_device_name (drive, -1, -1);
1077 #endif
1078 }