util/grub-mkdevicemap.c

   1 /* grub-mkdevicemap.c - make a device map file automatically */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 1999,2000,2001,2002,2003,2004,2005,2007,2008 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 <config.h>
  21
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <errno.h>
  29 #include <fcntl.h>
  30 #include <limits.h>
  31
  32 #include <grub/util/misc.h>
  33
  34 #define _GNU_SOURCE     1
  35 #include <getopt.h>
  36
  37 #ifdef __linux__
  38 # if !defined(__GLIBC__) || \
  39         ((__GLIBC__ < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ < 1)))
  40 /* Maybe libc doesn't have large file support.  */
  41 #  include <linux/unistd.h>     /* _llseek */
  42 # endif /* (GLIBC < 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR < 1)) */
  43 # include <sys/ioctl.h>         /* ioctl */
  44 # ifndef HDIO_GETGEO
  45 #  define HDIO_GETGEO   0x0301  /* get device geometry */
  46 /* If HDIO_GETGEO is not defined, it is unlikely that hd_geometry is
  47    defined.  */
  48 struct hd_geometry
  49 {
  50   unsigned char heads;
  51   unsigned char sectors;
  52   unsigned short cylinders;
  53   unsigned long start;
  54 };
  55 # endif /* ! HDIO_GETGEO */
  56 # ifndef FLOPPY_MAJOR
  57 #  define FLOPPY_MAJOR  2       /* the major number for floppy */
  58 # endif /* ! FLOPPY_MAJOR */
  59 # ifndef MAJOR
  60 #  define MAJOR(dev)    \
  61   ({ \
  62      unsigned long long __dev = (dev); \
  63      (unsigned) ((__dev >> 8) & 0xfff) \
  64                  | ((unsigned int) (__dev >> 32) & ~0xfff); \
  65   })
  66 # endif /* ! MAJOR */
  67 # ifndef CDROM_GET_CAPABILITY
  68 #  define CDROM_GET_CAPABILITY  0x5331  /* get capabilities */
  69 # endif /* ! CDROM_GET_CAPABILITY */
  70 # ifndef BLKGETSIZE
  71 #  define BLKGETSIZE    _IO(0x12,96)    /* return device size */
  72 # endif /* ! BLKGETSIZE */
  73 #endif /* __linux__ */
  74
  75 /* Use __FreeBSD_kernel__ instead of __FreeBSD__ for compatibility with
  76    kFreeBSD-based non-FreeBSD systems (e.g. GNU/kFreeBSD) */
  77 #if defined(__FreeBSD__) && ! defined(__FreeBSD_kernel__)
  78 # define __FreeBSD_kernel__
  79 #endif
  80 #ifdef __FreeBSD_kernel__
  81   /* Obtain version of kFreeBSD headers */
  82 # include <osreldate.h>
  83 # ifndef __FreeBSD_kernel_version
  84 #  define __FreeBSD_kernel_version __FreeBSD_version
  85 # endif
  86
  87   /* Runtime detection of kernel */
  88 # include <sys/utsname.h>
  89 int
  90 get_kfreebsd_version (void)
  91 {
  92   struct utsname uts;
  93   int major;
  94   int minor;
  95   int v[2];
  96
  97   uname (&uts);
  98   sscanf (uts.release, "%d.%d", &major, &minor);
  99
 100   if (major >= 9)
 101     major = 9;
 102   if (major >= 5)
 103     {
 104       v[0] = minor/10; v[1] = minor%10;
 105     }
 106   else
 107     {
 108       v[0] = minor%10; v[1] = minor/10;
 109     }
 110   return major*100000+v[0]*10000+v[1]*1000;
 111 }
 112 #endif /* __FreeBSD_kernel__ */
 113
 114 #if defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
 115 # include <sys/ioctl.h>         /* ioctl */
 116 # include <sys/disklabel.h>
 117 # include <sys/cdio.h>          /* CDIOCCLRDEBUG */
 118 # if defined(__FreeBSD_kernel__)
 119 #  include <sys/param.h>
 120 #  if __FreeBSD_kernel_version >= 500040
 121 #   include <sys/disk.h>
 122 #  endif
 123 # endif /* __FreeBSD_kernel__ */
 124 #endif /* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ */
 125
 126 #ifdef HAVE_OPENDISK
 127 # include <util.h>
 128 #endif /* HAVE_OPENDISK */
 129
 130 #ifdef __linux__
 131 /* Check if we have devfs support.  */
 132 static int
 133 have_devfs (void)
 134 {
 135   struct stat st;
 136   return stat ("/dev/.devfsd", &st) == 0;
 137 }
 138 #endif /* __linux__ */
 139
 140 /* These three functions are quite different among OSes.  */
 141 static void
 142 get_floppy_disk_name (char *name, int unit)
 143 {
 144 #if defined(__linux__)
 145   /* GNU/Linux */
 146   if (have_devfs ())
 147     sprintf (name, "/dev/floppy/%d", unit);
 148   else
 149     sprintf (name, "/dev/fd%d", unit);
 150 #elif defined(__GNU__)
 151   /* GNU/Hurd */
 152   sprintf (name, "/dev/fd%d", unit);
 153 #elif defined(__FreeBSD_kernel__)
 154   /* kFreeBSD */
 155   if (get_kfreebsd_version () >= 400000)
 156     sprintf (name, "/dev/fd%d", unit);
 157   else
 158     sprintf (name, "/dev/rfd%d", unit);
 159 #elif defined(__NetBSD__)
 160   /* NetBSD */
 161   /* opendisk() doesn't work for floppies.  */
 162   sprintf (name, "/dev/rfd%da", unit);
 163 #elif defined(__OpenBSD__)
 164   /* OpenBSD */
 165   sprintf (name, "/dev/rfd%dc", unit);
 166 #elif defined(__QNXNTO__)
 167   /* QNX RTP */
 168   sprintf (name, "/dev/fd%d", unit);
 169 #elif defined(__CYGWIN__)
 170   /* Cygwin */
 171   sprintf (name, "/dev/fd%d", unit);
 172 #elif defined(__MINGW32__)
 173   (void) unit;
 174   *name = 0;
 175 #else
 176 # warning "BIOS floppy drives cannot be guessed in your operating system."
 177   /* Set NAME to a bogus string.  */
 178   *name = 0;
 179 #endif
 180 }
 181
 182 static void
 183 get_ide_disk_name (char *name, int unit)
 184 {
 185 #if defined(__linux__)
 186   /* GNU/Linux */
 187   sprintf (name, "/dev/hd%c", unit + 'a');
 188 #elif defined(__GNU__)
 189   /* GNU/Hurd */
 190   sprintf (name, "/dev/hd%d", unit);
 191 #elif defined(__FreeBSD_kernel__)
 192   /* kFreeBSD */
 193   if (get_kfreebsd_version () >= 400000)
 194     sprintf (name, "/dev/ad%d", unit);
 195   else
 196     sprintf (name, "/dev/rwd%d", unit);
 197 #elif defined(__NetBSD__) && defined(HAVE_OPENDISK)
 198   /* NetBSD */
 199   char shortname[16];
 200   int fd;
 201
 202   sprintf (shortname, "wd%d", unit);
 203   fd = opendisk (shortname, O_RDONLY, name,
 204                  16,    /* length of NAME */
 205                  0      /* char device */
 206                  );
 207   close (fd);
 208 #elif defined(__OpenBSD__)
 209   /* OpenBSD */
 210   sprintf (name, "/dev/rwd%dc", unit);
 211 #elif defined(__QNXNTO__)
 212   /* QNX RTP */
 213   /* Actually, QNX RTP doesn't distinguish IDE from SCSI, so this could
 214      contain SCSI disks.  */
 215   sprintf (name, "/dev/hd%d", unit);
 216 #elif defined(__CYGWIN__)
 217   /* Cygwin emulates all disks as /dev/sdX.  */
 218   (void) unit;
 219   *name = 0;
 220 #elif defined(__MINGW32__)
 221   sprintf (name, "//./PHYSICALDRIVE%d", unit);
 222 #else
 223 # warning "BIOS IDE drives cannot be guessed in your operating system."
 224   /* Set NAME to a bogus string.  */
 225   *name = 0;
 226 #endif
 227 }
 228
 229 static void
 230 get_scsi_disk_name (char *name, int unit)
 231 {
 232 #if defined(__linux__)
 233   /* GNU/Linux */
 234   sprintf (name, "/dev/sd%c", unit + 'a');
 235 #elif defined(__GNU__)
 236   /* GNU/Hurd */
 237   sprintf (name, "/dev/sd%d", unit);
 238 #elif defined(__FreeBSD_kernel__)
 239   /* kFreeBSD */
 240   if (get_kfreebsd_version () >= 400000)
 241     sprintf (name, "/dev/da%d", unit);
 242   else
 243     sprintf (name, "/dev/rda%d", unit);
 244 #elif defined(__NetBSD__) && defined(HAVE_OPENDISK)
 245   /* NetBSD */
 246   char shortname[16];
 247   int fd;
 248
 249   sprintf (shortname, "sd%d", unit);
 250   fd = opendisk (shortname, O_RDONLY, name,
 251                  16,    /* length of NAME */
 252                  0      /* char device */
 253                  );
 254   close (fd);
 255 #elif defined(__OpenBSD__)
 256   /* OpenBSD */
 257   sprintf (name, "/dev/rsd%dc", unit);
 258 #elif defined(__QNXNTO__)
 259   /* QNX RTP */
 260   /* QNX RTP doesn't distinguish SCSI from IDE, so it is better to
 261      disable the detection of SCSI disks here.  */
 262   *name = 0;
 263 #elif defined(__CYGWIN__)
 264   /* Cygwin emulates all disks as /dev/sdX.  */
 265   sprintf (name, "/dev/sd%c", unit + 'a');
 266 #elif defined(__MINGW32__)
 267   (void) unit;
 268   *name = 0;
 269 #else
 270 # warning "BIOS SCSI drives cannot be guessed in your operating system."
 271   /* Set NAME to a bogus string.  */
 272   *name = 0;
 273 #endif
 274 }
 275
 276 #ifdef __linux__
 277 static void
 278 get_virtio_disk_name (char *name, int unit)
 279 {
 280   sprintf (name, "/dev/vd%c", unit + 'a');
 281 }
 282
 283 static void
 284 get_dac960_disk_name (char *name, int controller, int drive)
 285 {
 286   sprintf (name, "/dev/rd/c%dd%d", controller, drive);
 287 }
 288
 289 static void
 290 get_ataraid_disk_name (char *name, int unit)
 291 {
 292   sprintf (name, "/dev/ataraid/d%c", unit + '0');
 293 }
 294
 295 static void
 296 get_i2o_disk_name (char *name, char unit)
 297 {
 298   sprintf (name, "/dev/i2o/hd%c", unit);
 299 }
 300
 301 static void
 302 get_cciss_disk_name (char *name, int controller, int drive)
 303 {
 304   sprintf (name, "/dev/cciss/c%dd%d", controller, drive);
 305 }
 306
 307 static void
 308 get_ida_disk_name (char *name, int controller, int drive)
 309 {
 310   sprintf (name, "/dev/ida/c%dd%d", controller, drive);
 311 }
 312
 313 static void
 314 get_mmc_disk_name (char *name, int unit)
 315 {
 316   sprintf (name, "/dev/mmcblk%d", unit);
 317 }
 318
 319 static void
 320 get_xvd_disk_name (char *name, int unit)
 321 {
 322   sprintf (name, "/dev/xvd%c", unit + 'a');
 323 }
 324 #endif
 325
 326 /* Check if DEVICE can be read. If an error occurs, return zero,
 327    otherwise return non-zero.  */
 328 static int
 329 check_device (const char *device)
 330 {
 331   char buf[512];
 332   FILE *fp;
 333
 334   /* If DEVICE is empty, just return error.  */
 335   if (*device == 0)
 336     return 0;
 337
 338   fp = fopen (device, "r");
 339   if (! fp)
 340     {
 341       switch (errno)
 342         {
 343 #ifdef ENOMEDIUM
 344         case ENOMEDIUM:
 345 # if 0
 346           /* At the moment, this finds only CDROMs, which can't be
 347              read anyway, so leave it out. Code should be
 348              reactivated if `removable disks' and CDROMs are
 349              supported.  */
 350           /* Accept it, it may be inserted.  */
 351           return 1;
 352 # endif
 353           break;
 354 #endif /* ENOMEDIUM */
 355         default:
 356           /* Break case and leave.  */
 357           break;
 358         }
 359       /* Error opening the device.  */
 360       return 0;
 361     }
 362
 363   /* Make sure CD-ROMs don't get assigned a BIOS disk number
 364      before SCSI disks!  */
 365 #ifdef __linux__
 366 # ifdef CDROM_GET_CAPABILITY
 367   if (ioctl (fileno (fp), CDROM_GET_CAPABILITY, 0) >= 0)
 368     return 0;
 369 # else /* ! CDROM_GET_CAPABILITY */
 370   /* Check if DEVICE is a CD-ROM drive by the HDIO_GETGEO ioctl.  */
 371   {
 372     struct hd_geometry hdg;
 373     struct stat st;
 374
 375     if (fstat (fileno (fp), &st))
 376       return 0;
 377
 378     /* If it is a block device and isn't a floppy, check if HDIO_GETGEO
 379        succeeds.  */
 380     if (S_ISBLK (st.st_mode)
 381         && MAJOR (st.st_rdev) != FLOPPY_MAJOR
 382         && ioctl (fileno (fp), HDIO_GETGEO, &hdg))
 383       return 0;
 384   }
 385 # endif /* ! CDROM_GET_CAPABILITY */
 386 #endif /* __linux__ */
 387
 388 #if defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
 389 # ifdef CDIOCCLRDEBUG
 390   if (ioctl (fileno (fp), CDIOCCLRDEBUG, 0) >= 0)
 391     return 0;
 392 # endif /* CDIOCCLRDEBUG */
 393 #endif /* __FreeBSD_kernel__ || __NetBSD__ || __OpenBSD__ */
 394
 395   /* Attempt to read the first sector.  */
 396   if (fread (buf, 1, 512, fp) != 512)
 397     {
 398       fclose (fp);
 399       return 0;
 400     }
 401
 402   fclose (fp);
 403   return 1;
 404 }
 405
 406 static void
 407 make_device_map (const char *device_map, int floppy_disks)
 408 {
 409   FILE *fp;
 410   int num_hd = 0;
 411   int i;
 412
 413   if (strcmp (device_map, "-") == 0)
 414     fp = stdout;
 415   else
 416     fp = fopen (device_map, "w");
 417
 418   if (! fp)
 419     grub_util_error ("cannot open %s", device_map);
 420
 421   /* Floppies.  */
 422   for (i = 0; i < floppy_disks; i++)
 423     {
 424       char name[16];
 425       struct stat st;
 426
 427       get_floppy_disk_name (name, i);
 428       if (stat (name, &st) < 0)
 429         break;
 430       /* In floppies, write the map, whether check_device succeeds
 431          or not, because the user just may not insert floppies.  */
 432       if (fp)
 433         fprintf (fp, "(fd%d)\t%s\n", i, name);
 434     }
 435
 436 #ifdef __linux__
 437   if (have_devfs ())
 438     {
 439       while (1)
 440         {
 441           char discn[32];
 442           char name[PATH_MAX];
 443           struct stat st;
 444
 445           /* Linux creates symlinks "/dev/discs/discN" for convenience.
 446              The way to number disks is the same as GRUB's.  */
 447           sprintf (discn, "/dev/discs/disc%d", num_hd);
 448           if (stat (discn, &st) < 0)
 449             break;
 450
 451           if (realpath (discn, name))
 452             {
 453               strcat (name, "/disc");
 454               fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 455             }
 456
 457           num_hd++;
 458         }
 459
 460       goto finish;
 461     }
 462 #endif /* __linux__ */
 463
 464   /* IDE disks.  */
 465   for (i = 0; i < 20; i++)
 466     {
 467       char name[16];
 468
 469       get_ide_disk_name (name, i);
 470       if (check_device (name))
 471         {
 472           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 473           num_hd++;
 474         }
 475     }
 476
 477 #ifdef __linux__
 478   /* Virtio disks.  */
 479   for (i = 0; i < 20; i++)
 480     {
 481       char name[16];
 482
 483       get_virtio_disk_name (name, i);
 484       if (check_device (name))
 485         {
 486           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 487           num_hd++;
 488         }
 489     }
 490
 491   /* ATARAID disks.  */
 492   for (i = 0; i < 8; i++)
 493     {
 494       char name[20];
 495
 496       get_ataraid_disk_name (name, i);
 497       if (check_device (name))
 498         {
 499           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 500           num_hd++;
 501         }
 502     }
 503
 504   /* Xen virtual block devices.  */
 505   for (i = 0; i < 16; i++)
 506     {
 507       char name[16];
 508
 509       get_xvd_disk_name (name, i);
 510       if (check_device (name))
 511         {
 512           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 513           num_hd++;
 514         }
 515     }
 516 #endif /* __linux__ */
 517
 518   /* The rest is SCSI disks.  */
 519   for (i = 0; i < 16; i++)
 520     {
 521       char name[16];
 522
 523       get_scsi_disk_name (name, i);
 524       if (check_device (name))
 525         {
 526           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 527           num_hd++;
 528         }
 529     }
 530
 531 #ifdef __linux__
 532   /* This is for DAC960 - we have
 533      /dev/rd/c<controller>d<logical drive>p<partition>.
 534
 535      DAC960 driver currently supports up to 8 controllers, 32 logical
 536      drives, and 7 partitions.  */
 537   {
 538     int controller, drive;
 539
 540     for (controller = 0; controller < 8; controller++)
 541       {
 542         for (drive = 0; drive < 15; drive++)
 543           {
 544             char name[24];
 545
 546             get_dac960_disk_name (name, controller, drive);
 547             if (check_device (name))
 548               {
 549                 fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 550                 num_hd++;
 551               }
 552           }
 553       }
 554   }
 555
 556   /* This is for CCISS - we have
 557      /dev/cciss/c<controller>d<logical drive>p<partition>.  */
 558   {
 559     int controller, drive;
 560
 561     for (controller = 0; controller < 3; controller++)
 562       {
 563         for (drive = 0; drive < 10; drive++)
 564           {
 565             char name[24];
 566
 567             get_cciss_disk_name (name, controller, drive);
 568             if (check_device (name))
 569               {
 570                 fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 571                 num_hd++;
 572               }
 573           }
 574       }
 575   }
 576
 577   /* This is for Compaq Intelligent Drive Array - we have
 578      /dev/ida/c<controller>d<logical drive>p<partition>.  */
 579   {
 580     int controller, drive;
 581
 582     for (controller = 0; controller < 3; controller++)
 583       {
 584         for (drive = 0; drive < 10; drive++)
 585           {
 586             char name[24];
 587
 588             get_ida_disk_name (name, controller, drive);
 589             if (check_device (name))
 590               {
 591                 fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 592                 num_hd++;
 593               }
 594           }
 595       }
 596   }
 597
 598   /* This is for I2O - we have /dev/i2o/hd<logical drive><partition> */
 599   {
 600     char unit;
 601
 602     for (unit = 'a'; unit < 'f'; unit++)
 603       {
 604         char name[24];
 605
 606         get_i2o_disk_name (name, unit);
 607         if (check_device (name))
 608           {
 609             fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 610             num_hd++;
 611           }
 612       }
 613   }
 614
 615   /* MultiMediaCard (MMC).  */
 616   for (i = 0; i < 10; i++)
 617     {
 618       char name[16];
 619
 620       get_mmc_disk_name (name, i);
 621       if (check_device (name))
 622         {
 623           fprintf (fp, "(hd%d)\t%s\n", num_hd, name);
 624           num_hd++;
 625         }
 626     }
 627
 628  finish:
 629 #endif /* __linux__ */
 630
 631   if (fp != stdout)
 632     fclose (fp);
 633 }
 634
 635 static struct option options[] =
 636   {
 637     {"device-map", required_argument, 0, 'm'},
 638     {"probe-second-floppy", no_argument, 0, 's'},
 639     {"no-floppy", no_argument, 0, 'n'},
 640     {"help", no_argument, 0, 'h'},
 641     {"version", no_argument, 0, 'V'},
 642     {"verbose", no_argument, 0, 'v'},
 643     {0, 0, 0, 0}
 644   };
 645
 646 static void
 647 usage (int status)
 648 {
 649   if (status)
 650     fprintf (stderr,
 651              "Try ``grub-mkdevicemap --help'' for more information.\n");
 652   else
 653     printf ("\
 654 Usage: grub-mkdevicemap [OPTION]...\n\
 655 \n\
 656 Generate a device map file automatically.\n\
 657 \n\
 658   -n, --no-floppy           do not probe any floppy drive\n\
 659   -s, --probe-second-floppy probe the second floppy drive\n\
 660   -m, --device-map=FILE     use FILE as the device map [default=%s]\n\
 661   -h, --help                display this message and exit\n\
 662   -V, --version             print version information and exit\n\
 663   -v, --verbose             print verbose messages\n\
 664 \n\
 665 Report bugs to <%s>.\n\
 666 ",
 667             DEFAULT_DEVICE_MAP, PACKAGE_BUGREPORT);
 668
 669   exit (status);
 670 }
 671
 672 int
 673 main (int argc, char *argv[])
 674 {
 675   char *dev_map = 0;
 676   int floppy_disks = 1;
 677
 678   progname = "grub-mkdevicemap";
 679
 680   /* Check for options.  */
 681   while (1)
 682     {
 683       int c = getopt_long (argc, argv, "snm:r:hVv", options, 0);
 684
 685       if (c == -1)
 686         break;
 687       else
 688         switch (c)
 689           {
 690           case 'm':
 691             if (dev_map)
 692               free (dev_map);
 693
 694             dev_map = xstrdup (optarg);
 695             break;
 696
 697           case 'n':
 698             floppy_disks = 0;
 699             break;
 700
 701           case 's':
 702             floppy_disks = 2;
 703             break;
 704
 705           case 'h':
 706             usage (0);
 707             break;
 708
 709           case 'V':
 710             printf ("%s (%s) %s\n", progname, PACKAGE_NAME, PACKAGE_VERSION);
 711             return 0;
 712
 713           case 'v':
 714             verbosity++;
 715             break;
 716
 717           default:
 718             usage (1);
 719             break;
 720           }
 721     }
 722
 723   make_device_map (dev_map ? : DEFAULT_DEVICE_MAP, floppy_disks);
 724
 725   free (dev_map);
 726
 727   return 0;
 728 }