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