Home | History | Annotate | Line # | Download | only in gpt
show.c revision 1.46 
      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.46 2024/11/04 18:36:16 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 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 *
     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 *
    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
    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
    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
    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
    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
    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
    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