1 /*-
2 * Copyright (c) 2002 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #if HAVE_NBTOOL_CONFIG_H
28 #include "nbtool_config.h"
29 #endif
30
31 #include <sys/cdefs.h>
32 #ifdef __FBSDID
33 __FBSDID("$FreeBSD: src/sbin/gpt/show.c,v 1.14 2006/06/22 22:22:32 marcel Exp $");
34 #endif
35 #ifdef __RCSID
36 __RCSID("$NetBSD: show.c,v 1.47 2025/02/23 20:47:19 christos Exp $");
37 #endif
38
39 #include <sys/bootblock.h>
40 #include <sys/types.h>
41
42 #include <err.h>
43 #include <stddef.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <string.h>
47 #include <unistd.h>
48
49
50 #include "map.h"
51 #include "gpt.h"
52 #include "gpt_private.h"
53
54 static int cmd_show(gpt_t, int, char *[]);
55
56 static const char *showhelp[] = {
57 "[-aglux] [-i index]",
58 };
59
60 #define SHOW_UUID 1
61 #define SHOW_GUID 2
62 #define SHOW_LABEL 4
63 #define SHOW_ALL 8
64 #define SHOW_HEX 16
65
66 const struct gpt_cmd c_show = {
67 "show",
68 cmd_show,
69 showhelp, __arraycount(showhelp),
70 GPT_READONLY,
71 };
72
73 #define usage() gpt_usage(NULL, &c_show)
74
75 static const char *
get_mbr_sig(char * b,size_t blen,const uint8_t * bp)76 get_mbr_sig(char *b, size_t blen, const uint8_t *bp)
77 {
78 gpt_uuid_t uuid;
79
80 /*
81 * MBR partitions have a 4 byte signature in the MBR. Table
82 * 10.54 of UEFI Spec 2.10 Errata A states how this is to be
83 * formatted as a GUID.
84 *
85 * XXX: I thought I had seen more on this elsewhere, but I
86 * can't seem to find it now. In particular, the endianness
87 * of this quanity is not clear in the above.
88 *
89 * XXX: The location and size of the MBR signature should be
90 * in 'struct mbr,' e.g.:
91 *
92 * struct mbr {
93 * uint8_t mbr_code[440];
94 * uint32_t mbr_disc_sig;
95 * uint16_t mbr_unknown;
96 * struct mbr_part mbr_part[4];
97 * uint16_t mbr_sig;
98 * };
99 *
100 * For now, we just hardcode it. Ugh!
101 */
102 memset(uuid, 0, sizeof(uuid));
103 memcpy(uuid, bp + 440, 4);
104 gpt_uuid_snprintf(b, blen, "%d", uuid);
105 return b;
106 }
107
108 static const char *
get_gpt_hdr_guid(char * b,size_t blen,struct gpt_hdr * hdr)109 get_gpt_hdr_guid(char *b, size_t blen, struct gpt_hdr *hdr)
110 {
111 gpt_uuid_snprintf(b, blen, "%d", hdr->hdr_guid);
112 return b;
113 }
114
115 static void
print_part_type(int map_type,int flags,void * map_data,off_t map_start)116 print_part_type(int map_type, int flags, void *map_data, off_t map_start)
117 {
118 off_t start;
119 map_t p;
120 struct mbr *mbr;
121 struct gpt_ent *ent;
122 unsigned int i;
123 char buf[128], *b = buf;
124 uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
125
126 switch (map_type) {
127 case MAP_TYPE_UNUSED:
128 printf("Unused");
129 break;
130 case MAP_TYPE_MBR:
131 if (map_start != 0)
132 printf("Extended ");
133 printf("MBR");
134 if (map_start == 0 && flags & SHOW_GUID)
135 printf(" - %s",
136 get_mbr_sig(buf, sizeof(buf), map_data));
137 break;
138 case MAP_TYPE_PRI_GPT_HDR:
139 printf("Pri GPT header");
140 if (flags & SHOW_GUID)
141 printf(" - %s",
142 get_gpt_hdr_guid(buf, sizeof(buf), map_data));
143 break;
144 case MAP_TYPE_SEC_GPT_HDR:
145 printf("Sec GPT header");
146 if (flags & SHOW_GUID)
147 printf(" - %s",
148 get_gpt_hdr_guid(buf, sizeof(buf), map_data));
149 break;
150 case MAP_TYPE_PRI_GPT_TBL:
151 printf("Pri GPT table");
152 break;
153 case MAP_TYPE_SEC_GPT_TBL:
154 printf("Sec GPT table");
155 break;
156 case MAP_TYPE_MBR_PART:
157 p = map_data;
158 if (p->map_start != 0)
159 printf("Extended ");
160 printf("MBR part ");
161 mbr = p->map_data;
162 for (i = 0; i < 4; i++) {
163 start = le16toh(mbr->mbr_part[i].part_start_hi);
164 start = (start << 16) +
165 le16toh(mbr->mbr_part[i].part_start_lo);
166 if (map_start == p->map_start + start)
167 break;
168 }
169 if (i == 4) {
170 /* wasn't there */
171 printf("[partition not found?]");
172 } else {
173 printf("%d%s", mbr->mbr_part[i].part_typ,
174 mbr->mbr_part[i].part_flag == 0x80 ?
175 " (active)" : "");
176 }
177 break;
178 case MAP_TYPE_GPT_PART:
179 printf("GPT part ");
180 ent = map_data;
181 if (flags & SHOW_LABEL) {
182 utf16_to_utf8(ent->ent_name,
183 __arraycount(ent->ent_name), utfbuf,
184 __arraycount(utfbuf));
185 b = (char *)utfbuf;
186 } else if (flags & SHOW_GUID) {
187 gpt_uuid_snprintf( buf, sizeof(buf), "%d",
188 ent->ent_guid);
189 } else if (flags & SHOW_UUID) {
190 gpt_uuid_snprintf(buf, sizeof(buf),
191 "%d", ent->ent_type);
192 } else {
193 gpt_uuid_snprintf(buf, sizeof(buf), "%ls",
194 ent->ent_type);
195 }
196 printf("- %s", b);
197 break;
198 case MAP_TYPE_PMBR:
199 printf("PMBR");
200 mbr = map_data;
201 if (mbr->mbr_part[0].part_typ == MBR_PTYPE_PMBR &&
202 mbr->mbr_part[0].part_flag == 0x80)
203 printf(" (active)");
204 break;
205 default:
206 printf("Unknown %#x", map_type);
207 break;
208 }
209 }
210
211 static int
show(gpt_t gpt,int xshow)212 show(gpt_t gpt, int xshow)
213 {
214 map_t m;
215
216 printf(" %*s", gpt->lbawidth, "start");
217 printf(" %*s", gpt->lbawidth, "size");
218 printf(" index contents\n");
219
220 m = map_first(gpt);
221 while (m != NULL) {
222 #define FMT (xshow & SHOW_HEX) ? " %*jx" : " %*ju"
223 printf(FMT, gpt->lbawidth, (uintmax_t)m->map_start);
224 printf(FMT, gpt->lbawidth, (uintmax_t)m->map_size);
225 putchar(' ');
226 putchar(' ');
227 if (m->map_index > 0)
228 printf("%5d", m->map_index);
229 else
230 printf(" ");
231 putchar(' ');
232 putchar(' ');
233 print_part_type(m->map_type, xshow, m->map_data, m->map_start);
234 putchar('\n');
235 m = m->map_next;
236 }
237 return 0;
238 }
239
240 static void
gpt_show_sec_num(const char * prompt,int64_t secsize,off_t num)241 gpt_show_sec_num(const char *prompt, int64_t secsize, off_t num)
242 {
243 #ifdef HN_AUTOSCALE
244 char human_num[5];
245 if (humanize_number(human_num, sizeof(human_num),
246 (int64_t)num*secsize,
247 "", HN_AUTOSCALE, HN_NOSPACE|HN_B) < 0)
248 human_num[0] = '\0';
249 #endif
250 printf("%s: %" PRIu64, prompt, (uint64_t)num);
251 #ifdef HN_AUTOSCALE
252 if (human_num[0] != '\0')
253 printf(" (%s)", human_num);
254 #endif
255 printf("\n");
256 }
257
258 static int
show_one(gpt_t gpt,unsigned int entry)259 show_one(gpt_t gpt, unsigned int entry)
260 {
261 map_t m;
262 struct gpt_ent *ent;
263 char s1[128], s2[128];
264 uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
265
266 for (m = map_first(gpt); m != NULL; m = m->map_next)
267 if (entry == m->map_index)
268 break;
269 if (m == NULL) {
270 gpt_warnx(gpt, "Could not find index %d", entry);
271 return -1;
272 }
273 ent = m->map_data;
274
275 printf("Details for index %d:\n", entry);
276 gpt_show_sec_num("Start", gpt->secsz, m->map_start);
277 gpt_show_sec_num("Size", gpt->secsz, m->map_size);
278
279 gpt_uuid_snprintf(s1, sizeof(s1), "%s", ent->ent_type);
280 gpt_uuid_snprintf(s2, sizeof(s2), "%d", ent->ent_type);
281 if (strcmp(s1, s2) == 0)
282 strlcpy(s1, "unknown", sizeof(s1));
283 printf("Type: %s (%s)\n", s1, s2);
284
285 gpt_uuid_snprintf(s2, sizeof(s1), "%d", ent->ent_guid);
286 printf("GUID: %s\n", s2);
287
288 utf16_to_utf8(ent->ent_name, __arraycount(ent->ent_name), utfbuf,
289 __arraycount(utfbuf));
290 printf("Label: %s\n", (char *)utfbuf);
291
292 printf("Attributes: ");
293 if (ent->ent_attr == 0) {
294 printf("None\n");
295 } else {
296 char buf[1024];
297 printf("%s\n", gpt_attr_list(buf, sizeof(buf), ent->ent_attr));
298 }
299
300 return 0;
301 }
302
303 static int
show_all(gpt_t gpt,int xshow)304 show_all(gpt_t gpt, int xshow)
305 {
306 map_t m;
307 struct gpt_ent *ent;
308 char s1[128], s2[128];
309 #ifdef HN_AUTOSCALE
310 char human_num[8];
311 #endif
312 uint8_t utfbuf[__arraycount(ent->ent_name) * 3 + 1];
313 #define PFX " "
314
315 printf(" %*s", gpt->lbawidth, "start");
316 printf(" %*s", gpt->lbawidth, "size");
317 printf(" index contents\n");
318
319 m = map_first(gpt);
320 while (m != NULL) {
321 printf(FMT, gpt->lbawidth, (uintmax_t)m->map_start);
322 printf(FMT, gpt->lbawidth, (uintmax_t)m->map_size);
323 putchar(' ');
324 putchar(' ');
325 if (m->map_index > 0) {
326 printf("%5d ", m->map_index);
327 print_part_type(m->map_type, 0, m->map_data,
328 m->map_start);
329 putchar('\n');
330
331 ent = m->map_data;
332
333 gpt_uuid_snprintf(s1, sizeof(s1), "%s", ent->ent_type);
334 gpt_uuid_snprintf(s2, sizeof(s2), "%d", ent->ent_type);
335 if (strcmp(s1, s2) == 0)
336 strlcpy(s1, "unknown", sizeof(s1));
337 printf(PFX "Type: %s\n", s1);
338 if (m->map_type == MAP_TYPE_MBR_PART) {
339 static uint8_t unused_uuid[sizeof(gpt_uuid_t)];
340 /*
341 * MBR part partitions don't have
342 * GUIDs, so don't create a bogus one!
343 *
344 * We could get the TypeID from the
345 * partition type (the one byte OSType
346 * field in the partition structure),
347 * perhaps borrowing info from fdisk.
348 * However, some OSTypes have multiple
349 * OSes assigned to them and many may
350 * not have official UUIDs.
351 *
352 * Should we even print anything for
353 * these, in particular the GUID?
354 */
355 gpt_uuid_snprintf(s2, sizeof(s2), "%d",
356 unused_uuid);
357 printf(PFX "TypeID: %s\n", s2); /* XXX: show this? */
358 printf(PFX "GUID: %s\n", s2); /* XXX: show this? */
359 }
360 else {
361 printf(PFX "TypeID: %s\n", s2);
362 gpt_uuid_snprintf(s2, sizeof(s2), "%d", ent->ent_guid);
363 printf(PFX "GUID: %s\n", s2);
364 }
365
366 printf(PFX "Size: ");
367 #ifdef HN_AUTOSCALE
368 if (humanize_number(human_num, sizeof(human_num),
369 (int64_t)(m->map_size * gpt->secsz),
370 "", HN_AUTOSCALE, HN_B) < 0) {
371 #endif
372 printf("%ju",
373 (int64_t)(m->map_size * gpt->secsz));
374 #ifdef HN_AUTOSCALE
375 } else {
376 printf("%s", human_num);
377 }
378 #endif
379 putchar('\n');
380
381 utf16_to_utf8(ent->ent_name,
382 __arraycount(ent->ent_name), utfbuf,
383 __arraycount(utfbuf));
384 printf(PFX "Label: %s\n", (char *)utfbuf);
385
386 printf(PFX "Attributes: ");
387 if (ent->ent_attr == 0) {
388 printf("None\n");
389 } else {
390 char buf[1024];
391
392 printf("%s\n", gpt_attr_list(buf, sizeof(buf),
393 ent->ent_attr));
394 }
395 } else {
396 printf(" ");
397 print_part_type(m->map_type, 0, m->map_data,
398 m->map_start);
399 putchar('\n');
400
401 switch (m->map_type) {
402 case MAP_TYPE_PRI_GPT_HDR:
403 case MAP_TYPE_SEC_GPT_HDR:
404 printf(PFX "GUID: %s\n",
405 get_gpt_hdr_guid(s1, sizeof(s1),
406 m->map_data));
407 break;
408 case MAP_TYPE_MBR:
409 printf(PFX "GUID: %s\n",
410 get_mbr_sig(s1, sizeof(s1), m->map_data));
411 break;
412 default:
413 break;
414 }
415 }
416 m = m->map_next;
417 }
418 return 0;
419 }
420
421 static int
cmd_show(gpt_t gpt,int argc,char * argv[])422 cmd_show(gpt_t gpt, int argc, char *argv[])
423 {
424 int ch;
425 int xshow = 0;
426 unsigned int entry = 0;
427 off_t start = 0;
428 map_t m;
429
430 while ((ch = getopt(argc, argv, "gi:b:luax")) != -1) {
431 switch(ch) {
432 case 'a':
433 xshow |= SHOW_ALL;
434 break;
435 case 'g':
436 xshow |= SHOW_GUID;
437 break;
438 case 'i':
439 if (gpt_uint_get(gpt, &entry) == -1)
440 return usage();
441 break;
442 case 'b':
443 if (gpt_human_get(gpt, &start) == -1)
444 return usage();
445 break;
446 case 'l':
447 xshow |= SHOW_LABEL;
448 break;
449 case 'u':
450 xshow |= SHOW_UUID;
451 break;
452 case 'x':
453 xshow |= SHOW_HEX;
454 break;
455 default:
456 return usage();
457 }
458 }
459
460 if (argc != optind)
461 return usage();
462
463 if (map_find(gpt, MAP_TYPE_PRI_GPT_HDR) == NULL)
464 printf("GPT not found, displaying data from MBR.\n\n");
465
466 if (xshow & SHOW_ALL)
467 return show_all(gpt, xshow);
468
469 if (start > 0) {
470 for (m = map_first(gpt); m != NULL; m = m->map_next) {
471 if (m->map_type != MAP_TYPE_GPT_PART ||
472 m->map_index < 1)
473 continue;
474 if (start != m->map_start)
475 continue;
476 entry = m->map_index;
477 break;
478 }
479 }
480
481 return entry > 0 ? show_one(gpt, entry) : show(gpt, xshow);
482 }
483