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   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 #if defined(__linux__) || defined(__CYGWIN__)
 837 static int
 838 device_is_wholedisk (const char *os_dev)
 839 {
 840   int len = strlen (os_dev);
 841
 842   if (os_dev[len - 1] < '0' || os_dev[len - 1] > '9')
 843     return 1;
 844   return 0;
 845 }
 846 #endif
 847
 848 static int
 849 find_system_device (const char *os_dev)
 850 {
 851   int i;
 852   char *os_disk;
 853
 854   os_disk = convert_system_partition_to_system_disk (os_dev);
 855   if (! os_disk)
 856     return -1;
 857
 858   for (i = 0; i < (int) (sizeof (map) / sizeof (map[0])); i++)
 859     if (map[i].device && strcmp (map[i].device, os_disk) == 0)
 860       {
 861         free (os_disk);
 862         return i;
 863       }
 864
 865   free (os_disk);
 866   return -1;
 867 }
 868
 869 char *
 870 grub_util_biosdisk_get_grub_dev (const char *os_dev)
 871 {
 872   struct stat st;
 873   int drive;
 874
 875   if (stat (os_dev, &st) < 0)
 876     {
 877       grub_error (GRUB_ERR_BAD_DEVICE, "cannot stat `%s'", os_dev);
 878       return 0;
 879     }
 880
 881   drive = find_system_device (os_dev);
 882   if (drive < 0)
 883     {
 884       grub_error (GRUB_ERR_BAD_DEVICE,
 885                   "no mapping exists for `%s'", os_dev);
 886       return 0;
 887     }
 888
 889   if (grub_strcmp (os_dev, convert_system_partition_to_system_disk (os_dev))
 890       == 0)
 891     return make_device_name (drive, -1, -1);
 892
 893 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 894   if (! S_ISCHR (st.st_mode))
 895 #else
 896   if (! S_ISBLK (st.st_mode))
 897 #endif
 898     return make_device_name (drive, -1, -1);
 899
 900 #if defined(__linux__) || defined(__CYGWIN__)
 901   /* Linux counts partitions uniformly, whether a BSD partition or a DOS
 902      partition, so mapping them to GRUB devices is not trivial.
 903      Here, get the start sector of a partition by HDIO_GETGEO, and
 904      compare it with each partition GRUB recognizes.
 905
 906      Cygwin /dev/sdXN emulation uses Windows partition mapping. It
 907      does not count the extended partition and missing primary
 908      partitions.  Use same method as on Linux here.  */
 909   {
 910     char *name;
 911     grub_disk_t disk;
 912     int fd;
 913     struct hd_geometry hdg;
 914     int dos_part = -1;
 915     int bsd_part = -1;
 916     auto int find_partition (grub_disk_t disk,
 917                              const grub_partition_t partition);
 918
 919     int find_partition (grub_disk_t disk __attribute__ ((unused)),
 920                         const grub_partition_t partition)
 921       {
 922         struct grub_pc_partition *pcdata = NULL;
 923
 924         if (strcmp (partition->partmap->name, "pc_partition_map") == 0)
 925           pcdata = partition->data;
 926
 927         if (pcdata)
 928           {
 929             if (pcdata->bsd_part < 0)
 930               grub_util_info ("DOS partition %d starts from %lu",
 931                               pcdata->dos_part, partition->start);
 932             else
 933               grub_util_info ("BSD partition %d,%c starts from %lu",
 934                               pcdata->dos_part, pcdata->bsd_part + 'a',
 935                               partition->start);
 936           }
 937         else
 938           {
 939               grub_util_info ("Partition %d starts from %lu",
 940                               partition->index, partition->start);
 941           }
 942
 943         if (hdg.start == partition->start)
 944           {
 945             if (pcdata)
 946               {
 947                 dos_part = pcdata->dos_part;
 948                 bsd_part = pcdata->bsd_part;
 949               }
 950             else
 951               {
 952                 dos_part = partition->index;
 953                 bsd_part = -1;
 954               }
 955             return 1;
 956           }
 957
 958         return 0;
 959       }
 960
 961     name = make_device_name (drive, -1, -1);
 962
 963     if (MAJOR (st.st_rdev) == FLOPPY_MAJOR)
 964       return name;
 965
 966     fd = open (os_dev, O_RDONLY);
 967     if (fd == -1)
 968       {
 969         grub_error (GRUB_ERR_BAD_DEVICE, "cannot open `%s' while attempting to get disk geometry", os_dev);
 970         free (name);
 971         return 0;
 972       }
 973
 974     if (ioctl (fd, HDIO_GETGEO, &hdg))
 975       {
 976         grub_error (GRUB_ERR_BAD_DEVICE,
 977                     "cannot get geometry of `%s'", os_dev);
 978         close (fd);
 979         free (name);
 980         return 0;
 981       }
 982
 983     close (fd);
 984
 985     grub_util_info ("%s starts from %lu", os_dev, hdg.start);
 986
 987     if (hdg.start == 0 && device_is_wholedisk (os_dev))
 988       return name;
 989
 990     grub_util_info ("opening the device %s", name);
 991     disk = grub_disk_open (name);
 992     free (name);
 993
 994     if (! disk)
 995       return 0;
 996
 997     grub_partition_iterate (disk, find_partition);
 998     if (grub_errno != GRUB_ERR_NONE)
 999       {
1000         grub_disk_close (disk);
1001         return 0;
1002       }
1003
1004     if (dos_part < 0)
1005       {
1006         grub_disk_close (disk);
1007         grub_error (GRUB_ERR_BAD_DEVICE,
1008                     "cannot find the partition of `%s'", os_dev);
1009         return 0;
1010       }
1011
1012     return make_device_name (drive, dos_part, bsd_part);
1013   }
1014
1015 #elif defined(__GNU__)
1016   /* GNU uses "/dev/[hs]d[0-9]+(s[0-9]+[a-z]?)?".  */
1017   {
1018     char *p;
1019     int dos_part = -1;
1020     int bsd_part = -1;
1021
1022     p = strrchr (os_dev, 's');
1023     if (p)
1024       {
1025         long int n;
1026         char *q;
1027
1028         p++;
1029         n = strtol (p, &q, 10);
1030         if (p != q && n != GRUB_LONG_MIN && n != GRUB_LONG_MAX)
1031           {
1032             dos_part = (int) n;
1033
1034             if (*q >= 'a' && *q <= 'g')
1035               bsd_part = *q - 'a';
1036           }
1037       }
1038
1039     return make_device_name (drive, dos_part, bsd_part);
1040   }
1041
1042 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
1043   /* FreeBSD uses "/dev/[a-z]+[0-9]+(s[0-9]+[a-z]?)?".  */
1044   {
1045     int dos_part = -1;
1046     int bsd_part = -1;
1047
1048     if (strncmp ("/dev/", os_dev, 5) == 0)
1049       {
1050         const char *p;
1051         char *q;
1052         long int n;
1053
1054         for (p = os_dev + 5; *p; ++p)
1055           if (grub_isdigit(*p))
1056             {
1057               p = strchr (p, 's');
1058               if (p)
1059                 {
1060                   p++;
1061                   n = strtol (p, &q, 10);
1062                   if (p != q && n != GRUB_LONG_MIN && n != GRUB_LONG_MAX)
1063                     {
1064                       dos_part = (int) n - 1;
1065
1066                       if (*q >= 'a' && *q <= 'g')
1067                         bsd_part = *q - 'a';
1068                     }
1069                 }
1070               break;
1071             }
1072       }
1073
1074     return make_device_name (drive, dos_part, bsd_part);
1075   }
1076
1077 #else
1078 # warning "The function `grub_util_biosdisk_get_grub_dev' might not work on your OS correctly."
1079   return make_device_name (drive, -1, -1);
1080 #endif
1081 }