arch/all-pc/boot/grub2-aros/util/grub-probe.c

   1 /* grub-probe.c - probe device information for a given path */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2005,2006,2007,2008,2009,2010  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 #include <grub/types.h>
  22 #include <grub/emu/misc.h>
  23 #include <grub/util/misc.h>
  24 #include <grub/device.h>
  25 #include <grub/disk.h>
  26 #include <grub/file.h>
  27 #include <grub/fs.h>
  28 #include <grub/partition.h>
  29 #include <grub/msdos_partition.h>
  30 #include <grub/emu/hostdisk.h>
  31 #include <grub/emu/getroot.h>
  32 #include <grub/term.h>
  33 #include <grub/env.h>
  34 #include <grub/diskfilter.h>
  35 #include <grub/i18n.h>
  36 #include <grub/emu/misc.h>
  37 #include <grub/util/ofpath.h>
  38 #include <grub/crypto.h>
  39 #include <grub/cryptodisk.h>
  40
  41 #include <stdio.h>
  42 #include <unistd.h>
  43 #include <string.h>
  44 #include <stdlib.h>
  45 #include <sys/stat.h>
  46 #include <assert.h>
  47
  48 #define _GNU_SOURCE     1
  49 #include <argp.h>
  50
  51 #include "progname.h"
  52
  53 enum {
  54   PRINT_FS,
  55   PRINT_FS_UUID,
  56   PRINT_FS_LABEL,
  57   PRINT_DRIVE,
  58   PRINT_DEVICE,
  59   PRINT_PARTMAP,
  60   PRINT_ABSTRACTION,
  61   PRINT_CRYPTODISK_UUID,
  62   PRINT_HINT_STR,
  63   PRINT_BIOS_HINT,
  64   PRINT_IEEE1275_HINT,
  65   PRINT_BAREMETAL_HINT,
  66   PRINT_EFI_HINT,
  67   PRINT_ARC_HINT,
  68   PRINT_COMPATIBILITY_HINT,
  69   PRINT_MSDOS_PARTTYPE,
  70   PRINT_ZERO_CHECK,
  71   PRINT_DISK
  72 };
  73
  74 static int print = PRINT_FS;
  75 static unsigned int argument_is_device = 0;
  76
  77 static void
  78 probe_partmap (grub_disk_t disk)
  79 {
  80   grub_partition_t part;
  81   grub_disk_memberlist_t list = NULL, tmp;
  82
  83   if (disk->partition == NULL)
  84     {
  85       grub_util_info ("no partition map found for %s", disk->name);
  86     }
  87
  88   for (part = disk->partition; part; part = part->parent)
  89     printf ("%s ", part->partmap->name);
  90
  91   if (disk->dev->id == GRUB_DISK_DEVICE_DISKFILTER_ID)
  92     grub_diskfilter_print_partmap (disk);
  93
  94   /* In case of LVM/RAID, check the member devices as well.  */
  95   if (disk->dev->memberlist)
  96     {
  97       list = disk->dev->memberlist (disk);
  98     }
  99   while (list)
 100     {
 101       probe_partmap (list->disk);
 102       tmp = list->next;
 103       free (list);
 104       list = tmp;
 105     }
 106 }
 107
 108 static void
 109 probe_cryptodisk_uuid (grub_disk_t disk)
 110 {
 111   grub_disk_memberlist_t list = NULL, tmp;
 112
 113   /* In case of LVM/RAID, check the member devices as well.  */
 114   if (disk->dev->memberlist)
 115     {
 116       list = disk->dev->memberlist (disk);
 117     }
 118   while (list)
 119     {
 120       probe_cryptodisk_uuid (list->disk);
 121       tmp = list->next;
 122       free (list);
 123       list = tmp;
 124     }
 125   if (disk->dev->id == GRUB_DISK_DEVICE_CRYPTODISK_ID)
 126     grub_util_cryptodisk_print_uuid (disk);
 127 }
 128
 129 static int
 130 probe_raid_level (grub_disk_t disk)
 131 {
 132   /* disk might be NULL in the case of a LVM physical volume with no LVM
 133      signature.  Ignore such cases here.  */
 134   if (!disk)
 135     return -1;
 136
 137   if (disk->dev->id != GRUB_DISK_DEVICE_DISKFILTER_ID)
 138     return -1;
 139
 140   if (disk->name[0] != 'm' || disk->name[1] != 'd')
 141     return -1;
 142
 143   if (!((struct grub_diskfilter_lv *) disk->data)->segments)
 144     return -1;
 145   return ((struct grub_diskfilter_lv *) disk->data)->segments->type;
 146 }
 147
 148 /* Since OF path names can have "," characters in them, and GRUB
 149    internally uses "," to indicate partitions (unlike OF which uses
 150    ":" for this purpose) we escape such commas.  */
 151 static char *
 152 escape_of_path (const char *orig_path)
 153 {
 154   char *new_path, *d, c;
 155   const char *p;
 156
 157   if (!strchr (orig_path, ','))
 158     return (char *) xstrdup (orig_path);
 159
 160   new_path = xmalloc (strlen (orig_path) * 2 + 1);
 161
 162   p = orig_path;
 163   d = new_path;
 164   while ((c = *p++) != '\0')
 165     {
 166       if (c == ',')
 167         *d++ = '\\';
 168       *d++ = c;
 169     }
 170   *d = 0;
 171
 172   return new_path;
 173 }
 174
 175 static char *
 176 guess_bios_drive (const char *orig_path)
 177 {
 178   char *canon;
 179   char *ptr;
 180   canon = canonicalize_file_name (orig_path);
 181   if (!canon)
 182     return NULL;
 183   ptr = strrchr (orig_path, '/');
 184   if (ptr)
 185     ptr++;
 186   else
 187     ptr = canon;
 188   if ((ptr[0] == 's' || ptr[0] == 'h') && ptr[1] == 'd')
 189     {
 190       int num = ptr[2] - 'a';
 191       free (canon);
 192       return xasprintf ("hd%d", num);
 193     }
 194   if (ptr[0] == 'f' && ptr[1] == 'd')
 195     {
 196       int num = atoi (ptr + 2);
 197       free (canon);
 198       return xasprintf ("fd%d", num);
 199     }
 200   free (canon);
 201   return NULL;
 202 }
 203
 204 static char *
 205 guess_efi_drive (const char *orig_path)
 206 {
 207   char *canon;
 208   char *ptr;
 209   canon = canonicalize_file_name (orig_path);
 210   if (!canon)
 211     return NULL;
 212   ptr = strrchr (orig_path, '/');
 213   if (ptr)
 214     ptr++;
 215   else
 216     ptr = canon;
 217   if ((ptr[0] == 's' || ptr[0] == 'h') && ptr[1] == 'd')
 218     {
 219       int num = ptr[2] - 'a';
 220       free (canon);
 221       return xasprintf ("hd%d", num);
 222     }
 223   if (ptr[0] == 'f' && ptr[1] == 'd')
 224     {
 225       int num = atoi (ptr + 2);
 226       free (canon);
 227       return xasprintf ("fd%d", num);
 228     }
 229   free (canon);
 230   return NULL;
 231 }
 232
 233 static char *
 234 guess_baremetal_drive (const char *orig_path)
 235 {
 236   char *canon;
 237   char *ptr;
 238   canon = canonicalize_file_name (orig_path);
 239   if (!canon)
 240     return NULL;
 241   ptr = strrchr (orig_path, '/');
 242   if (ptr)
 243     ptr++;
 244   else
 245     ptr = canon;
 246   if (ptr[0] == 'h' && ptr[1] == 'd')
 247     {
 248       int num = ptr[2] - 'a';
 249       free (canon);
 250       return xasprintf ("ata%d", num);
 251     }
 252   if (ptr[0] == 's' && ptr[1] == 'd')
 253     {
 254       int num = ptr[2] - 'a';
 255       free (canon);
 256       return xasprintf ("ahci%d", num);
 257     }
 258   free (canon);
 259   return NULL;
 260 }
 261
 262 static void
 263 print_full_name (const char *drive, grub_device_t dev)
 264 {
 265   char *dname = escape_of_path (drive);
 266   if (dev->disk->partition)
 267     {
 268       char *pname = grub_partition_get_name (dev->disk->partition);
 269       printf ("%s,%s", dname, pname);
 270       free (pname);
 271     }
 272   else
 273     printf ("%s", dname);
 274   free (dname);
 275 }
 276
 277 static void
 278 probe_abstraction (grub_disk_t disk)
 279 {
 280   grub_disk_memberlist_t list = NULL, tmp;
 281   int raid_level;
 282
 283   if (disk->dev->memberlist)
 284     list = disk->dev->memberlist (disk);
 285   while (list)
 286     {
 287       probe_abstraction (list->disk);
 288
 289       tmp = list->next;
 290       free (list);
 291       list = tmp;
 292     }
 293
 294   if (disk->dev->id == GRUB_DISK_DEVICE_DISKFILTER_ID
 295       && grub_memcmp (disk->name, "lvm/", sizeof ("lvm/") - 1) == 0)
 296     printf ("lvm ");
 297
 298   if (disk->dev->id == GRUB_DISK_DEVICE_DISKFILTER_ID
 299       && grub_memcmp (disk->name, "ldm/", sizeof ("ldm/") - 1) == 0)
 300     printf ("ldm ");
 301
 302   if (disk->dev->id == GRUB_DISK_DEVICE_CRYPTODISK_ID)
 303     grub_util_cryptodisk_print_abstraction (disk);
 304
 305   raid_level = probe_raid_level (disk);
 306   if (raid_level >= 0)
 307     {
 308       printf ("diskfilter ");
 309       if (disk->dev->raidname)
 310         printf ("%s ", disk->dev->raidname (disk));
 311     }
 312   if (raid_level == 5)
 313     printf ("raid5rec ");
 314   if (raid_level == 6)
 315     printf ("raid6rec ");
 316 }
 317
 318 static void
 319 probe (const char *path, char **device_names, char delim)
 320 {
 321   char **drives_names = NULL;
 322   char **curdev, **curdrive;
 323   char *grub_path = NULL;
 324   int ndev = 0;
 325
 326   if (path != NULL)
 327     {
 328       grub_path = canonicalize_file_name (path);
 329       if (! grub_path)
 330         grub_util_error (_("failed to get canonical path of %s"), path);
 331       device_names = grub_guess_root_devices (grub_path);
 332       free (grub_path);
 333     }
 334
 335   if (! device_names)
 336     grub_util_error (_("cannot find a device for %s (is /dev mounted?)"), path);
 337
 338   if (print == PRINT_DEVICE)
 339     {
 340       for (curdev = device_names; *curdev; curdev++)
 341         {
 342           printf ("%s", *curdev);
 343           putchar (delim);
 344         }
 345       return;
 346     }
 347
 348   if (print == PRINT_DISK)
 349     {
 350       for (curdev = device_names; *curdev; curdev++)
 351         {
 352           char *disk;
 353           disk = grub_util_get_os_disk (*curdev);
 354           if (!disk)
 355             {
 356               grub_print_error ();
 357               continue;
 358             }
 359           printf ("%s", disk);
 360           putchar (delim);
 361         }
 362       return;
 363     }
 364
 365   for (curdev = device_names; *curdev; curdev++)
 366     {
 367       grub_util_pull_device (*curdev);
 368       ndev++;
 369     }
 370
 371   drives_names = xmalloc (sizeof (drives_names[0]) * (ndev + 1));
 372
 373   for (curdev = device_names, curdrive = drives_names; *curdev; curdev++,
 374        curdrive++)
 375     {
 376       *curdrive = grub_util_get_grub_dev (*curdev);
 377       if (! *curdrive)
 378         grub_util_error (_("cannot find a GRUB drive for %s.  Check your device.map"),
 379                          *curdev);
 380     }
 381   *curdrive = 0;
 382
 383   if (print == PRINT_DRIVE)
 384     {
 385       for (curdrive = drives_names; *curdrive; curdrive++)
 386         {
 387           printf ("(%s)", *curdrive);
 388           putchar (delim);
 389         }
 390       goto end;
 391     }
 392
 393   if (print == PRINT_ZERO_CHECK)
 394     {
 395       for (curdev = drives_names; *curdev; curdev++)
 396         {
 397           grub_device_t dev = NULL;
 398           grub_uint32_t buffer[32768];
 399           grub_disk_addr_t addr;
 400           grub_disk_addr_t dsize;
 401
 402           grub_util_info ("opening %s", *curdev);
 403           dev = grub_device_open (*curdev);
 404           if (! dev || !dev->disk)
 405             grub_util_error ("%s", grub_errmsg);
 406
 407           dsize = grub_disk_get_size (dev->disk);
 408           for (addr = 0; addr < dsize;
 409                addr += sizeof (buffer) / GRUB_DISK_SECTOR_SIZE)
 410             {
 411               grub_size_t sz = sizeof (buffer);
 412               grub_uint32_t *ptr;
 413
 414               if (sizeof (buffer) / GRUB_DISK_SECTOR_SIZE > dsize - addr)
 415                 sz = (dsize - addr) * GRUB_DISK_SECTOR_SIZE;
 416               grub_disk_read (dev->disk, addr, 0, sz, buffer);
 417
 418               for (ptr = buffer; ptr < buffer + sz / sizeof (*buffer); ptr++)
 419                 if (*ptr)
 420                   {
 421                     grub_printf ("false\n");
 422                     grub_device_close (dev);
 423                     goto end;
 424                   }
 425             }
 426
 427           grub_device_close (dev);
 428         }
 429       grub_printf ("true\n");
 430     }
 431
 432   if (print == PRINT_FS || print == PRINT_FS_UUID
 433       || print == PRINT_FS_LABEL)
 434     {
 435       grub_device_t dev = NULL;
 436       grub_fs_t fs;
 437
 438       grub_util_info ("opening %s", drives_names[0]);
 439       dev = grub_device_open (drives_names[0]);
 440       if (! dev)
 441         grub_util_error ("%s", grub_errmsg);
 442
 443       fs = grub_fs_probe (dev);
 444       if (! fs)
 445         grub_util_error ("%s", grub_errmsg);
 446
 447       if (print == PRINT_FS)
 448         {
 449           printf ("%s", fs->name);
 450           putchar (delim);
 451         }
 452       else if (print == PRINT_FS_UUID)
 453         {
 454           char *uuid;
 455           if (! fs->uuid)
 456             grub_util_error (_("%s does not support UUIDs"), fs->name);
 457
 458           if (fs->uuid (dev, &uuid) != GRUB_ERR_NONE)
 459             grub_util_error ("%s", grub_errmsg);
 460
 461           printf ("%s", uuid);
 462           putchar (delim);
 463         }
 464       else if (print == PRINT_FS_LABEL)
 465         {
 466           char *label;
 467           if (! fs->label)
 468             grub_util_error (_("filesystem `%s' does not support labels"),
 469                              fs->name);
 470
 471           if (fs->label (dev, &label) != GRUB_ERR_NONE)
 472             grub_util_error ("%s", grub_errmsg);
 473
 474           printf ("%s", label);
 475           putchar (delim);
 476         }
 477       goto end;
 478     }
 479
 480   for (curdrive = drives_names, curdev = device_names; *curdrive;
 481        curdrive++, curdev++)
 482     {
 483       grub_device_t dev = NULL;
 484
 485       grub_util_info ("opening %s", *curdrive);
 486       dev = grub_device_open (*curdrive);
 487       if (! dev)
 488         grub_util_error ("%s", grub_errmsg);
 489
 490       if (print == PRINT_HINT_STR)
 491         {
 492           const char *osdev = grub_util_biosdisk_get_osdev (dev->disk);
 493           const char *ofpath = osdev ? grub_util_devname_to_ofpath (osdev) : 0;
 494           char *biosname, *bare, *efi;
 495           const char *map;
 496
 497           if (ofpath)
 498             {
 499               char *tmp = xmalloc (strlen (ofpath) + sizeof ("ieee1275/"));
 500               char *p;
 501               p = stpcpy (tmp, "ieee1275/");
 502               strcpy (p, ofpath);
 503               printf ("--hint-ieee1275='");
 504               print_full_name (tmp, dev);
 505               printf ("' ");
 506               free (tmp);
 507             }
 508
 509           biosname = guess_bios_drive (*curdev);
 510           if (biosname)
 511             {
 512               printf ("--hint-bios=");
 513               print_full_name (biosname, dev);
 514               printf (" ");
 515             }
 516           free (biosname);
 517
 518           efi = guess_efi_drive (*curdev);
 519           if (efi)
 520             {
 521               printf ("--hint-efi=");
 522               print_full_name (efi, dev);
 523               printf (" ");
 524             }
 525           free (efi);
 526
 527           bare = guess_baremetal_drive (*curdev);
 528           if (bare)
 529             {
 530               printf ("--hint-baremetal=");
 531               print_full_name (bare, dev);
 532               printf (" ");
 533             }
 534           free (bare);
 535
 536           /* FIXME: Add ARC hint.  */
 537
 538           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 539           if (map)
 540             {
 541               printf ("--hint='");
 542               print_full_name (map, dev);
 543               printf ("' ");
 544             }
 545           printf ("\n");
 546
 547           grub_device_close (dev);
 548           continue;
 549         }
 550
 551       if ((print == PRINT_COMPATIBILITY_HINT || print == PRINT_BIOS_HINT
 552            || print == PRINT_IEEE1275_HINT || print == PRINT_BAREMETAL_HINT
 553            || print == PRINT_EFI_HINT || print == PRINT_ARC_HINT)
 554           && dev->disk->dev->id != GRUB_DISK_DEVICE_HOSTDISK_ID)
 555         {
 556           print_full_name (dev->disk->name, dev);
 557           putchar (delim);
 558           continue;
 559         }
 560
 561       if (print == PRINT_COMPATIBILITY_HINT)
 562         {
 563           const char *map;
 564           char *biosname;
 565           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 566           if (map)
 567             {
 568               print_full_name (map, dev);
 569               putchar (delim);
 570               grub_device_close (dev);
 571               /* Compatibility hint is one device only.  */
 572               break;
 573             }
 574           biosname = guess_bios_drive (*curdev);
 575           if (biosname)
 576             {
 577               print_full_name (biosname, dev);
 578               putchar (delim);
 579             }
 580           free (biosname);
 581           grub_device_close (dev);
 582           /* Compatibility hint is one device only.  */
 583           if (biosname)
 584             break;
 585           continue;
 586         }
 587
 588       if (print == PRINT_BIOS_HINT)
 589         {
 590           char *biosname;
 591           biosname = guess_bios_drive (*curdev);
 592           if (biosname)
 593             {
 594               print_full_name (biosname, dev);
 595               putchar (delim);
 596             }
 597           free (biosname);
 598           grub_device_close (dev);
 599           continue;
 600         }
 601       if (print == PRINT_IEEE1275_HINT)
 602         {
 603           const char *osdev = grub_util_biosdisk_get_osdev (dev->disk);
 604           const char *ofpath = grub_util_devname_to_ofpath (osdev);
 605           const char *map;
 606
 607           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 608           if (map)
 609             {
 610               print_full_name (map, dev);
 611               putchar (delim);
 612             }
 613
 614           if (ofpath)
 615             {
 616               char *tmp = xmalloc (strlen (ofpath) + sizeof ("ieee1275/"));
 617               char *p;
 618               p = stpcpy (tmp, "ieee1275/");
 619               strcpy (p, ofpath);
 620               print_full_name (tmp, dev);
 621               free (tmp);
 622               putchar (delim);
 623             }
 624
 625           grub_device_close (dev);
 626           continue;
 627         }
 628       if (print == PRINT_EFI_HINT)
 629         {
 630           char *biosname;
 631           const char *map;
 632           biosname = guess_efi_drive (*curdev);
 633
 634           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 635           if (map)
 636             {
 637               print_full_name (map, dev);
 638               putchar (delim);
 639             }
 640           if (biosname)
 641             {
 642               print_full_name (biosname, dev);
 643               putchar (delim);
 644             }
 645
 646           free (biosname);
 647           grub_device_close (dev);
 648           continue;
 649         }
 650
 651       if (print == PRINT_BAREMETAL_HINT)
 652         {
 653           char *biosname;
 654           const char *map;
 655
 656           biosname = guess_baremetal_drive (*curdev);
 657
 658           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 659           if (map)
 660             {
 661               print_full_name (map, dev);
 662               putchar (delim);
 663             }
 664           if (biosname)
 665             {
 666               print_full_name (biosname, dev);
 667               putchar (delim);
 668             }
 669
 670           free (biosname);
 671           grub_device_close (dev);
 672           continue;
 673         }
 674
 675       if (print == PRINT_ARC_HINT)
 676         {
 677           const char *map;
 678
 679           map = grub_util_biosdisk_get_compatibility_hint (dev->disk);
 680           if (map)
 681             {
 682               print_full_name (map, dev);
 683               putchar (delim);
 684             }
 685
 686           /* FIXME */
 687           grub_device_close (dev);
 688           continue;
 689         }
 690
 691       if (print == PRINT_ABSTRACTION)
 692         {
 693           probe_abstraction (dev->disk);
 694           putchar (delim);
 695           grub_device_close (dev);
 696           continue;
 697         }
 698
 699       if (print == PRINT_CRYPTODISK_UUID)
 700         {
 701           probe_cryptodisk_uuid (dev->disk);
 702           putchar (delim);
 703           grub_device_close (dev);
 704           continue;
 705         }
 706
 707       if (print == PRINT_PARTMAP)
 708         {
 709           /* Check if dev->disk itself is contained in a partmap.  */
 710           probe_partmap (dev->disk);
 711           putchar (delim);
 712           grub_device_close (dev);
 713           continue;
 714         }
 715
 716       if (print == PRINT_MSDOS_PARTTYPE)
 717         {
 718           if (dev->disk->partition
 719               && strcmp(dev->disk->partition->partmap->name, "msdos") == 0)
 720             printf ("%02x", dev->disk->partition->msdostype);
 721
 722           putchar (delim);
 723           grub_device_close (dev);
 724           continue;
 725         }
 726     }
 727
 728  end:
 729   for (curdrive = drives_names; *curdrive; curdrive++)
 730     free (*curdrive);
 731   free (drives_names);
 732 }
 733
 734 static struct argp_option options[] = {
 735   {"device",  'd', 0, 0,
 736    N_("given argument is a system device, not a path"), 0},
 737   {"device-map",  'm', N_("FILE"), 0,
 738    N_("use FILE as the device map [default=%s]"), 0},
 739   {"target",  't', "(fs|fs_uuid|fs_label|drive|device|partmap|abstraction|cryptodisk_uuid|msdos_parttype)", 0,
 740    N_("print filesystem module, GRUB drive, system device, partition map module, abstraction module or cryptographic container UUID [default=fs]"), 0},
 741   {"verbose",     'v', 0,      0, N_("print verbose messages."), 0},
 742   { 0, 0, 0, 0, 0, 0 }
 743 };
 744
 745 static char *
 746 help_filter (int key, const char *text, void *input __attribute__ ((unused)))
 747 {
 748   switch (key)
 749     {
 750       case 'm':
 751         return xasprintf (text, DEFAULT_DEVICE_MAP);
 752
 753       default:
 754         return (char *) text;
 755     }
 756 }
 757
 758 struct arguments
 759 {
 760   char **devices;
 761   size_t device_max;
 762   size_t ndevices;
 763   char *dev_map;
 764   int zero_delim;
 765 };
 766
 767 static error_t
 768 argp_parser (int key, char *arg, struct argp_state *state)
 769 {
 770   /* Get the input argument from argp_parse, which we
 771      know is a pointer to our arguments structure. */
 772   struct arguments *arguments = state->input;
 773
 774   switch (key)
 775     {
 776     case 'd':
 777       argument_is_device = 1;
 778       break;
 779
 780     case 'm':
 781       if (arguments->dev_map)
 782         free (arguments->dev_map);
 783
 784       arguments->dev_map = xstrdup (arg);
 785       break;
 786
 787     case 't':
 788       if (!strcmp (arg, "fs"))
 789         print = PRINT_FS;
 790       else if (!strcmp (arg, "fs_uuid"))
 791         print = PRINT_FS_UUID;
 792       else if (!strcmp (arg, "fs_label"))
 793         print = PRINT_FS_LABEL;
 794       else if (!strcmp (arg, "drive"))
 795         print = PRINT_DRIVE;
 796       else if (!strcmp (arg, "device"))
 797         print = PRINT_DEVICE;
 798       else if (!strcmp (arg, "partmap"))
 799         print = PRINT_PARTMAP;
 800       else if (!strcmp (arg, "abstraction"))
 801         print = PRINT_ABSTRACTION;
 802       else if (!strcmp (arg, "cryptodisk_uuid"))
 803         print = PRINT_CRYPTODISK_UUID;
 804       else if (!strcmp (arg, "msdos_parttype"))
 805         print = PRINT_MSDOS_PARTTYPE;
 806       else if (!strcmp (arg, "hints_string"))
 807         print = PRINT_HINT_STR;
 808       else if (!strcmp (arg, "bios_hints"))
 809         print = PRINT_BIOS_HINT;
 810       else if (!strcmp (arg, "ieee1275_hints"))
 811         print = PRINT_IEEE1275_HINT;
 812       else if (!strcmp (arg, "baremetal_hints"))
 813         print = PRINT_BAREMETAL_HINT;
 814       else if (!strcmp (arg, "efi_hints"))
 815         print = PRINT_EFI_HINT;
 816       else if (!strcmp (arg, "arc_hints"))
 817         print = PRINT_ARC_HINT;
 818       else if (!strcmp (arg, "compatibility_hint"))
 819         print = PRINT_COMPATIBILITY_HINT;
 820       else if (strcmp (arg, "zero_check") == 0)
 821         print = PRINT_ZERO_CHECK;
 822       else if (!strcmp (arg, "disk"))
 823         print = PRINT_DISK;
 824       else
 825         argp_usage (state);
 826       break;
 827
 828     case '0':
 829       arguments->zero_delim = 1;
 830       break;
 831
 832     case 'v':
 833       verbosity++;
 834       break;
 835
 836     case ARGP_KEY_NO_ARGS:
 837       fprintf (stderr, "%s", _("No path or device is specified.\n"));
 838       argp_usage (state);
 839       break;
 840
 841     case ARGP_KEY_ARG:
 842       assert (arguments->ndevices < arguments->device_max);
 843       arguments->devices[arguments->ndevices++] = xstrdup(arg);
 844       break;
 845
 846     default:
 847       return ARGP_ERR_UNKNOWN;
 848     }
 849   return 0;
 850 }
 851
 852 static struct argp argp = {
 853   options, argp_parser, N_("[OPTION]... [PATH|DEVICE]"),
 854   N_("\
 855 Probe device information for a given path (or device, if the -d option is given)."),
 856   NULL, help_filter, NULL
 857 };
 858
 859 int
 860 main (int argc, char *argv[])
 861 {
 862   char delim;
 863   struct arguments arguments;
 864
 865   set_program_name (argv[0]);
 866
 867   grub_util_init_nls ();
 868
 869   memset (&arguments, 0, sizeof (struct arguments));
 870   arguments.device_max = argc + 1;
 871   arguments.devices = xmalloc ((arguments.device_max + 1)
 872                                * sizeof (arguments.devices[0]));
 873   memset (arguments.devices, 0, (arguments.device_max + 1)
 874           * sizeof (arguments.devices[0]));
 875
 876   /* Parse our arguments */
 877   if (argp_parse (&argp, argc, argv, 0, 0, &arguments) != 0)
 878     {
 879       fprintf (stderr, "%s", _("Error in parsing command line arguments\n"));
 880       exit(1);
 881     }
 882
 883   if (verbosity > 1)
 884     grub_env_set ("debug", "all");
 885
 886   /* Obtain ARGUMENT.  */
 887   if (arguments.ndevices != 1 && !argument_is_device)
 888     {
 889       char *program = xstrdup(program_name);
 890       fprintf (stderr, _("Unknown extra argument `%s'."), arguments.devices[1]);
 891       fprintf (stderr, "\n");
 892       argp_help (&argp, stderr, ARGP_HELP_STD_USAGE, program);
 893       free (program);
 894       exit(1);
 895     }
 896
 897   /* Initialize the emulated biosdisk driver.  */
 898   grub_util_biosdisk_init (arguments.dev_map ? : DEFAULT_DEVICE_MAP);
 899
 900   /* Initialize all modules. */
 901   grub_init_all ();
 902   grub_gcry_init_all ();
 903
 904   grub_lvm_fini ();
 905   grub_mdraid09_fini ();
 906   grub_mdraid1x_fini ();
 907   grub_diskfilter_fini ();
 908   grub_diskfilter_init ();
 909   grub_mdraid09_init ();
 910   grub_mdraid1x_init ();
 911   grub_lvm_init ();
 912
 913   if (print == PRINT_BIOS_HINT
 914       || print == PRINT_IEEE1275_HINT || print == PRINT_BAREMETAL_HINT
 915       || print == PRINT_EFI_HINT || print == PRINT_ARC_HINT)
 916     delim = ' ';
 917   else
 918     delim = '\n';
 919
 920   if (arguments.zero_delim)
 921     delim = '\0';
 922
 923   /* Do it.  */
 924   if (argument_is_device)
 925     probe (NULL, arguments.devices, delim);
 926   else
 927     probe (arguments.devices[0], NULL, delim);
 928
 929   if (!arguments.zero_delim && (print == PRINT_BIOS_HINT
 930                                 || print == PRINT_IEEE1275_HINT
 931                                 || print == PRINT_BAREMETAL_HINT
 932                                 || print == PRINT_EFI_HINT
 933                                 || print == PRINT_ARC_HINT))
 934     putchar ('\n');
 935
 936   /* Free resources.  */
 937   grub_gcry_fini_all ();
 938   grub_fini_all ();
 939   grub_util_biosdisk_fini ();
 940
 941   {
 942     size_t i;
 943     for (i = 0; i < arguments.ndevices; i++)
 944       free (arguments.devices[i]);
 945   }
 946   free (arguments.devices);
 947
 948   free (arguments.dev_map);
 949
 950   return 0;
 951 }