xref: /illumos-gate/usr/src/cmd/prtvtoc/prtvtoc.c (revision d48be21240dfd051b689384ce2b23479d757f2d8) 
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
22 /*	  All Rights Reserved */
23 
24 
25 /*	Copyright (c) 1984 AT&T */
26 /*	  All Rights Reserved   */
27 
28 
29 /*
30  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
31  * Use is subject to license terms.
32  * Copyright 2021 Jason King
33  */
34 
35 /*
36  * Print a disk partition map (volume table of contents, or VTOC).
37  */
38 
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <unistd.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <stdio.h>
45 #include <limits.h>
46 #include <err.h>
47 
48 #include <sys/types.h>
49 #include <sys/stat.h>
50 #include <sys/dkio.h>
51 #include <sys/vtoc.h>
52 #include <sys/mnttab.h>
53 #include <sys/vfstab.h>
54 #include <sys/mkdev.h>
55 
56 #include <sys/efi_partition.h>
57 /*
58  * Assumes V_NUMPAR must be a power of 2.
59  *
60  * for V_NUMPAR = 8, we have
61  *	parttn(x)=(x & 0x07)	noparttn(x)=(x & 0x3fff8)
62  *
63  * for V_NUMPAR = 16, we have
64  *	parttn(x)=(x & 0x0f)	noparttn(x)=(x & 0x3fff0)
65  */
66 #define	parttn(x)	(x % V_NUMPAR)
67 #define	noparttn(x)	(x & (MAXMIN & ~(V_NUMPAR-1)))
68 
69 /*
70  * Disk freespace structure.
71  */
72 typedef struct {
73 	u_longlong_t	fr_start;	/* Start of free space */
74 	u_longlong_t	fr_size;	/* Length of free space */
75 } freemap_t;
76 
77 static	freemap_t	*findfree(struct dk_geom *, struct extvtoc *);
78 static	int	partcmp(const void *, const void *);
79 static	int	partcmp64(const void *, const void *);
80 static	int	prtvtoc(char *);
81 static	void	putfree(struct extvtoc *, freemap_t *);
82 static	void	putfree64(struct dk_gpt *, freemap_t *);
83 static	void	puttable(struct dk_geom *, struct extvtoc *, freemap_t *,
84 			char *, char **);
85 static	void	puttable64(struct dk_gpt *, freemap_t *,
86 			char *, char **);
87 static	int	readgeom(int, char *, struct dk_geom *);
88 static	int	readvtoc(int, char *, struct extvtoc *);
89 static	int	readefi(int, char *, struct dk_gpt **);
90 static	void	usage(void);
91 static	char	*safe_strdup(const char *, const char *);
92 static	void	*safe_calloc(const char *, size_t, size_t);
93 
94 #define	SAFE_STRDUP(a)		safe_strdup(__func__, (a))
95 #define	SAFE_CALLOC(a, b)	safe_calloc(__func__, (a), (b))
96 
97 /*
98  * External variables.
99  */
100 extern char	*getfullrawname();
101 /*
102  * Static variables.
103  */
104 static short	fflag;			/* Print freespace shell assignments */
105 static short	hflag;			/* Omit headers */
106 static short	sflag;			/* Omit all but the column header */
107 static char	*fstab = VFSTAB;	/* Fstab pathname */
108 static char	*mnttab = MNTTAB;	/* mnttab pathname */
109 
110 int
111 main(int argc, char *argv[])
112 {
113 	int status = EXIT_SUCCESS;
114 	int c;
115 
116 	while ((c = getopt(argc, argv, "fhst:m:")) != -1) {
117 		switch (c) {
118 		case 'f':
119 			++fflag;
120 			break;
121 		case 'h':
122 			++hflag;
123 			break;
124 		case 's':
125 			++sflag;
126 			break;
127 		case 't':
128 			fstab = optarg;
129 			break;
130 		case 'm':
131 			mnttab = optarg;
132 			break;
133 		default:
134 			usage();
135 		}
136 	}
137 
138 	if (optind >= argc)
139 		usage();
140 
141 	for (int i = optind; i < argc; i++) {
142 		if (prtvtoc(argv[i]) != 0) {
143 			status = EXIT_FAILURE;
144 		}
145 	}
146 
147 	return (status);
148 }
149 
150 static freemap_t	*freemap;
151 /*
152  * findfree(): Find free space on a disk.
153  */
154 static freemap_t *
155 findfree(struct dk_geom *geom, struct extvtoc *vtoc)
156 {
157 	struct extpartition *part;
158 	struct extpartition **list;
159 	freemap_t *freeidx;
160 	diskaddr_t fullsize;
161 	ulong_t cylsize;
162 	struct extpartition *sorted[V_NUMPAR + 1];
163 
164 	if (vtoc->v_nparts > V_NUMPAR) {
165 		errx(EXIT_FAILURE, "putfree(): Too many partitions on disk!");
166 	}
167 
168 	freemap = SAFE_CALLOC(sizeof (freemap_t), V_NUMPAR + 1);
169 	cylsize = (geom->dkg_nsect) * (geom->dkg_nhead);
170 	fullsize = (diskaddr_t)(geom->dkg_ncyl) * cylsize;
171 	list = sorted;
172 	for (part = vtoc->v_part; part < vtoc->v_part + vtoc->v_nparts;
173 	    ++part) {
174 		if (part->p_size && part->p_tag != V_BACKUP)
175 			*list++ = part;
176 	}
177 	*list = 0;
178 	qsort(sorted, list - sorted, sizeof (*sorted), partcmp);
179 	freeidx = freemap;
180 	freeidx->fr_start = 0;
181 	for (list = sorted; (part = *list) != NULL; ++list) {
182 		if (part->p_start <= freeidx->fr_start) {
183 			freeidx->fr_start += part->p_size;
184 		} else {
185 			freeidx->fr_size = part->p_start - freeidx->fr_start;
186 			(++freeidx)->fr_start = part->p_start + part->p_size;
187 		}
188 	}
189 	if (freeidx->fr_start < fullsize) {
190 		freeidx->fr_size = fullsize - freeidx->fr_start;
191 		++freeidx;
192 	}
193 	freeidx->fr_start = freeidx->fr_size = 0;
194 	return (freemap);
195 }
196 
197 /*
198  * findfree64(): Find free space on a disk.
199  */
200 static freemap_t *
201 findfree64(struct dk_gpt *efi)
202 {
203 	struct dk_part *part;
204 	struct dk_part **list;
205 	freemap_t *freeidx;
206 	diskaddr_t fullsize;
207 	struct dk_part **sorted;
208 
209 	freemap = SAFE_CALLOC(sizeof (freemap_t), efi->efi_nparts + 1);
210 	sorted = SAFE_CALLOC(sizeof (struct dk_part), efi->efi_nparts + 1);
211 	fullsize = efi->efi_last_u_lba;
212 	list = sorted;
213 	for (part = efi->efi_parts; part < efi->efi_parts + efi->efi_nparts;
214 	    ++part) {
215 		if (part->p_size && part->p_tag != V_BACKUP)
216 			*list++ = part;
217 	}
218 	*list = 0;
219 	qsort(sorted, list - sorted, sizeof (*sorted), partcmp64);
220 	freeidx = freemap;
221 	freeidx->fr_start = efi->efi_first_u_lba;
222 	for (list = sorted; (part = *list) != NULL; ++list) {
223 		if (part->p_start == freeidx->fr_start) {
224 			freeidx->fr_start += part->p_size;
225 		} else {
226 			freeidx->fr_size = part->p_start - freeidx->fr_start;
227 			(++freeidx)->fr_start = part->p_start + part->p_size;
228 		}
229 	}
230 	if (freeidx->fr_start < fullsize) {
231 		freeidx->fr_size = fullsize - freeidx->fr_start;
232 		++freeidx;
233 	}
234 	freeidx->fr_start = freeidx->fr_size = 0;
235 	return (freemap);
236 }
237 
238 /*
239  * getmntpt()
240  *
241  * Get the filesystem mountpoint of each partition on the disk
242  * from the fstab or mnttab. Returns a pointer to an array of pointers to
243  * directory names (indexed by partition number).
244  */
245 static char **
246 getmntpt(major_t slot, minor_t nopartminor)
247 {
248 	FILE *file;
249 	char devbuf[PATH_MAX], *item;
250 	static char *list[V_NUMPAR];
251 	struct stat sb;
252 	struct mnttab mtab;
253 	struct vfstab vtab;
254 
255 	for (unsigned idx = 0; idx < V_NUMPAR; ++idx)
256 		list[idx] = NULL;
257 
258 	/* read mnttab for partition mountpoints */
259 	if ((file = fopen(mnttab, "r")) == NULL) {
260 		warn("failed to open %s", mnttab);
261 	} else {
262 		while (getmntent(file, &mtab) == 0) {
263 			item = mtab.mnt_special;
264 			if (item == NULL || mtab.mnt_mountp == NULL)
265 				continue;
266 
267 			/*
268 			 * Is it from /dev?
269 			 */
270 			if (strncmp(item, "/dev/", strlen("/dev/")) != 0)
271 				continue;
272 
273 			/*
274 			 * Is it a character device?
275 			 */
276 			(void) snprintf(devbuf, sizeof (devbuf), "/dev/r%s",
277 			    item + strlen("/dev/"));
278 
279 			if (stat(devbuf, &sb) != 0 ||
280 			    (sb.st_mode & S_IFMT) != S_IFCHR) {
281 				continue;
282 			}
283 
284 			/*
285 			 * device must match input slot and nopartminor
286 			 */
287 			if (major(sb.st_rdev) != slot ||
288 			    noparttn(minor(sb.st_rdev)) != nopartminor) {
289 				continue;
290 			}
291 
292 			list[parttn(minor(sb.st_rdev))] =
293 			    SAFE_STRDUP(mtab.mnt_mountp);
294 		}
295 		(void) fclose(file);
296 	}
297 
298 	if ((file = fopen(fstab, "r")) == NULL) {
299 		warn("failed to open %s", fstab);
300 		return (list);
301 	}
302 
303 	/*
304 	 * Look for the disk in the vfstab so that we can report its mount
305 	 * point even if it isn't currently mounted.
306 	 */
307 	while (getvfsent(file, &vtab) == 0) {
308 		item = vtab.vfs_special;
309 		if (item == NULL || vtab.vfs_mountp == NULL)
310 			continue;
311 
312 		if (strncmp(item, "/dev/", strlen("/dev/")) != 0)
313 			continue;
314 
315 		/*
316 		 * Is it a character device?
317 		 */
318 		(void) snprintf(devbuf, sizeof (devbuf), "/dev/r%s",
319 		    item + strlen("/dev/"));
320 
321 		if (stat(devbuf, &sb) != 0 ||
322 		    (sb.st_mode & S_IFMT) != S_IFCHR) {
323 			continue;
324 		}
325 
326 		/*
327 		 * device must match input slot and nopartminor
328 		 */
329 		if (major(sb.st_rdev) != slot ||
330 		    noparttn(minor(sb.st_rdev)) != nopartminor) {
331 			continue;
332 		}
333 
334 		/*
335 		 * use mnttab entry if both tables have entries
336 		 */
337 		if (list[parttn(minor(sb.st_rdev))] != NULL)
338 			continue;
339 
340 		list[parttn(minor(sb.st_rdev))] = SAFE_STRDUP(vtab.vfs_mountp);
341 	}
342 	(void) fclose(file);
343 
344 	return (list);
345 }
346 
347 /*
348  * partcmp(): Qsort() key comparison of partitions by starting sector numbers.
349  */
350 static int
351 partcmp(const void *one, const void *two)
352 {
353 	struct partition *p1 = *(struct partition **)one;
354 	struct partition *p2 = *(struct partition **)two;
355 
356 	if (p1->p_start > p2->p_start) {
357 		return (1);
358 	} else if (p1->p_start < p2->p_start) {
359 		return (-1);
360 	} else {
361 		return (0);
362 	}
363 }
364 
365 static int
366 partcmp64(const void *one, const void *two)
367 {
368 	dk_part_t *p1 = *(dk_part_t **)one;
369 	dk_part_t *p2 = *(dk_part_t **)two;
370 
371 	if (p1->p_start > p2->p_start) {
372 		return (1);
373 	} else if (p1->p_start < p2->p_start) {
374 		return (-1);
375 	} else {
376 		return (0);
377 	}
378 }
379 
380 /*
381  * prtvtoc(): Read and print a VTOC.
382  */
383 static int
384 prtvtoc(char *devname)
385 {
386 	int fd;
387 	int idx = 0;
388 	freemap_t *freemap;
389 	struct stat sb;
390 	struct extvtoc vtoc;
391 	int geo;
392 	struct dk_geom geom;
393 	char *name;
394 	int newvtoc = 0;
395 	struct dk_gpt *efi;
396 
397 	name = getfullrawname(devname);
398 	if (name == NULL) {
399 		warnx("%s: internal administrative call (getfullrawname) "
400 		    "failed", devname);
401 		return (-1);
402 	}
403 	if (strcmp(name, "") == 0)
404 		name = devname;
405 	if ((fd = open(name, O_NONBLOCK|O_RDONLY)) < 0) {
406 		warn("%s: failed to open device", name);
407 		return (-1);
408 	}
409 	if (fstat(fd, &sb) < 0) {
410 		warn("%s: failed to stat device", name);
411 		return (-1);
412 	}
413 	if ((sb.st_mode & S_IFMT) != S_IFCHR) {
414 		warnx("%s: Not a raw device", name);
415 		return (-1);
416 	}
417 
418 	geo = (readgeom(fd, name, &geom) == 0);
419 	if (geo) {
420 		if ((idx = readvtoc(fd, name, &vtoc)) == VT_ENOTSUP) {
421 			idx = (readefi(fd, name, &efi) == 0);
422 			newvtoc = 1;
423 		} else {
424 			idx = (idx == 0);
425 		}
426 	}
427 	(void) close(fd);
428 	if ((!geo) || (!idx))
429 		return (-1);
430 	if (!newvtoc)
431 		freemap = findfree(&geom, &vtoc);
432 	else
433 		freemap = findfree64(efi);
434 	if (fflag) {
435 		if (!newvtoc)
436 			putfree(&vtoc, freemap);
437 		else
438 			putfree64(efi, freemap);
439 	} else {
440 		if (!newvtoc) {
441 			puttable(&geom, &vtoc, freemap, devname,
442 			    getmntpt(major(sb.st_rdev),
443 			    noparttn(minor(sb.st_rdev))));
444 		} else {
445 			puttable64(efi, freemap, devname,
446 			    getmntpt(major(sb.st_rdev),
447 			    noparttn(minor(sb.st_rdev))));
448 		}
449 	}
450 	if (newvtoc)
451 		efi_free(efi);
452 	return (0);
453 }
454 
455 /*
456  * putfree():
457  *
458  * Print shell assignments for disk free space. FREE_START and FREE_SIZE
459  * represent the starting block and number of blocks of the first chunk
460  * of free space. FREE_PART lists the unassigned partitions.
461  */
462 static void
463 putfree(struct extvtoc *vtoc, freemap_t *freemap)
464 {
465 	freemap_t *freeidx;
466 	ushort_t idx;
467 	int free_count = 0;
468 
469 	for (freeidx = freemap; freeidx->fr_size; ++freeidx)
470 		free_count++;
471 
472 	(void) printf("FREE_START=%llu FREE_SIZE=%llu FREE_COUNT=%d FREE_PART=",
473 	    freemap->fr_start, freemap->fr_size, free_count);
474 
475 	for (idx = 0; idx < vtoc->v_nparts; ++idx) {
476 		if (vtoc->v_part[idx].p_size == 0 && idx != 2)
477 			(void) printf("%x", idx);
478 	}
479 	(void) printf("\n");
480 }
481 
482 static void
483 putfree64(struct dk_gpt *efi, freemap_t *freemap)
484 {
485 	freemap_t *freeidx;
486 	ushort_t idx;
487 	int free_count = 0;
488 
489 	for (freeidx = freemap; freeidx->fr_size; ++freeidx)
490 		free_count++;
491 
492 	(void) printf("FREE_START=%llu FREE_SIZE=%llu FREE_COUNT=%d FREE_PART=",
493 	    freemap->fr_start, freemap->fr_size, free_count);
494 
495 	for (idx = 0; idx < efi->efi_nparts; ++idx) {
496 		if (efi->efi_parts[idx].p_size == 0 && idx != 2)
497 			(void) printf("%x", idx);
498 	}
499 	(void) printf("\n");
500 }
501 
502 static void
503 print_table_header()
504 {
505 	(void) printf("*                            First       Sector"
506 	    "      Last\n");
507 	(void) printf("* Partition  Tag  Flags      Sector       Count"
508 	    "      Sector  Mount Directory\n");
509 }
510 
511 static void
512 print_table_row(uint_t partition, uint_t tag, uint_t flag,
513     u_longlong_t first_sector, u_longlong_t sector_count,
514     u_longlong_t last_sector, const char *mount_dir)
515 {
516 	(void) printf("  %6u   %4u    %02x  %11llu %11llu %11llu",
517 	    partition, tag, flag, first_sector, sector_count, last_sector);
518 	if (mount_dir != NULL) {
519 		(void) printf("   %s", mount_dir);
520 	}
521 	(void) printf("\n");
522 }
523 
524 static void
525 print_freemap(freemap_t *freemap)
526 {
527 	if (freemap->fr_size == 0) {
528 		/*
529 		 * The freemap is completely empty, so do not print the header.
530 		 */
531 		return;
532 	}
533 
534 	(void) printf("* Unallocated space:\n"
535 	    "*         First       Sector      Last\n"
536 	    "*         Sector       Count      Sector\n");
537 
538 	do {
539 		(void) printf("*   %11llu %11llu %11llu\n",
540 		    freemap->fr_start, freemap->fr_size,
541 		    freemap->fr_size + freemap->fr_start - 1);
542 	} while ((++freemap)->fr_size != 0);
543 
544 	(void) printf("*\n");
545 }
546 
547 /*
548  * puttable(): Print a human-readable VTOC.
549  */
550 static void
551 puttable(struct dk_geom *geom, struct extvtoc *vtoc, freemap_t *freemap,
552     char *name, char **mtab)
553 {
554 	ushort_t idx;
555 	ulong_t cylsize;
556 
557 	cylsize = (geom->dkg_nsect) * (geom->dkg_nhead);
558 	if (!hflag && !sflag) {
559 		u_longlong_t asectors = (u_longlong_t)cylsize * geom->dkg_ncyl;
560 		u_longlong_t sectors = (u_longlong_t)cylsize * geom->dkg_pcyl;
561 
562 		(void) printf("* %s", name);
563 		if (vtoc->v_volume[0] != '\0')
564 			(void) printf(" (volume \"%.8s\")", vtoc->v_volume);
565 
566 		(void) printf(" partition map\n");
567 		(void) printf("*\n* Dimensions:\n");
568 		(void) printf("* %11u bytes/sector\n", vtoc->v_sectorsz);
569 		(void) printf("* %11u sectors/track\n", geom->dkg_nsect);
570 		(void) printf("* %11u tracks/cylinder\n", geom->dkg_nhead);
571 		(void) printf("* %11lu sectors/cylinder\n", cylsize);
572 		(void) printf("* %11u cylinders\n", geom->dkg_pcyl);
573 		(void) printf("* %11u accessible cylinders\n", geom->dkg_ncyl);
574 		(void) printf("* %11llu sectors\n", sectors);
575 		(void) printf("* %11llu accessible sectors\n", asectors);
576 		(void) printf("*\n* Flags:\n");
577 		(void) printf("*   1: unmountable\n");
578 		(void) printf("*  10: read-only\n*\n");
579 
580 		print_freemap(freemap);
581 	}
582 
583 	if (!hflag) {
584 		print_table_header();
585 	}
586 
587 	for (idx = 0; idx < vtoc->v_nparts; ++idx) {
588 		const char *mount_dir = NULL;
589 		struct extpartition *p = &vtoc->v_part[idx];
590 
591 		if (p->p_size == 0)
592 			continue;
593 
594 		if (mtab != NULL) {
595 			mount_dir = mtab[idx];
596 		}
597 
598 		print_table_row(idx, p->p_tag, p->p_flag, p->p_start,
599 		    p->p_size, p->p_start + p->p_size - 1, mount_dir);
600 	}
601 }
602 
603 /*
604  * puttable(): Print a human-readable VTOC.
605  */
606 static void
607 puttable64(struct dk_gpt *efi, freemap_t *freemap, char *name, char **mtab)
608 {
609 	if (!hflag && !sflag) {
610 		(void) printf("* %s", name);
611 		for (uint_t idx = 0; idx < efi->efi_nparts; idx++) {
612 			if (efi->efi_parts[idx].p_tag == V_RESERVED &&
613 			    efi->efi_parts[idx].p_name[0] != '\0') {
614 				(void) printf(" (volume \"%.8s\")",
615 				    efi->efi_parts[idx].p_name);
616 			}
617 		}
618 		(void) printf(" partition map\n");
619 		(void) printf("*\n* Dimensions:\n");
620 		(void) printf("* %11u bytes/sector\n", efi->efi_lbasize);
621 		(void) printf("* %11llu sectors\n", efi->efi_last_lba + 1);
622 		(void) printf("* %11llu accessible sectors\n",
623 		    efi->efi_last_u_lba - efi->efi_first_u_lba + 1);
624 		(void) printf("*\n* Flags:\n");
625 		(void) printf("*   1: unmountable\n");
626 		(void) printf("*  10: read-only\n*\n");
627 
628 		print_freemap(freemap);
629 	}
630 
631 	if (!hflag) {
632 		print_table_header();
633 	}
634 
635 	for (uint_t idx = 0; idx < efi->efi_nparts; ++idx) {
636 		const char *mount_dir = NULL;
637 		dk_part_t *p = &efi->efi_parts[idx];
638 
639 		if (p->p_size == 0)
640 			continue;
641 
642 		if (idx < 7 && mtab != NULL) {
643 			mount_dir = mtab[idx];
644 		}
645 
646 		print_table_row(idx, p->p_tag, p->p_flag, p->p_start,
647 		    p->p_size, p->p_start + p->p_size - 1, mount_dir);
648 	}
649 }
650 
651 /*
652  * readgeom(): Read the disk geometry.
653  */
654 static int
655 readgeom(int fd, char *name, struct dk_geom *geom)
656 {
657 	if (ioctl(fd, DKIOCGGEOM, geom) < 0) {
658 		if (errno != ENOTSUP) {
659 			warnx("%s: Unable to read Disk geometry errno = 0x%x",
660 			    name, errno);
661 			return (-1);
662 		}
663 
664 		(void) memset(geom, 0, sizeof (struct dk_geom));
665 	}
666 
667 	return (0);
668 }
669 
670 /*
671  * readvtoc(): Read a partition map.
672  */
673 static int
674 readvtoc(int fd, char *name, struct extvtoc *vtoc)
675 {
676 	int retval;
677 
678 	if ((retval = read_extvtoc(fd, vtoc)) >= 0)
679 		return (0);
680 
681 	switch (retval) {
682 	case VT_EIO:
683 		warnx("%s: Unable to read VTOC", name);
684 		return (-1);
685 	case VT_EINVAL:
686 		warnx("%s: Invalid VTOC", name);
687 		return (-1);
688 	case VT_ERROR:
689 		warnx("%s: Unknown problem reading VTOC", name);
690 		return (-1);
691 	}
692 
693 	return (retval);
694 }
695 
696 /*
697  * readefi(): Read a partition map.
698  */
699 static int
700 readefi(int fd, char *name, struct dk_gpt **efi)
701 {
702 	int	retval;
703 
704 	if ((retval = efi_alloc_and_read(fd, efi)) >= 0)
705 		return (0);
706 
707 	switch (retval) {
708 	case VT_EIO:
709 		warnx("%s: Unable to read VTOC", name);
710 		return (-1);
711 	case VT_EINVAL:
712 		warnx("%s: Invalid VTOC", name);
713 		return (-1);
714 	case VT_ERROR:
715 		warnx("%s: Unknown problem reading VTOC", name);
716 		return (-1);
717 	}
718 
719 	return (retval);
720 }
721 
722 static void
723 memory_err(size_t l, int e, const char *fname)
724 {
725 	const char *reason;
726 
727 	switch (e) {
728 	case EAGAIN:
729 		reason = "not enough memory was available, please try again";
730 		break;
731 	case ENOMEM:
732 		reason = "allocation size was too large";
733 		break;
734 	default:
735 		reason = strerror(e);
736 		break;
737 	}
738 
739 	errx(EXIT_FAILURE, "%s: failed to allocate %llu bytes of memory: %s",
740 	    fname, (u_longlong_t)l, reason);
741 }
742 
743 static void *
744 safe_calloc(const char *fname, size_t nelem, size_t elsize)
745 {
746 	void *r;
747 
748 	if ((r = calloc(nelem, elsize)) == NULL) {
749 		memory_err(nelem * elsize, errno, fname);
750 	}
751 
752 	return (r);
753 }
754 
755 static char *
756 safe_strdup(const char *fname, const char *str)
757 {
758 	size_t l = strlen(str);
759 	char *r;
760 
761 	if ((r = strndup(str, l)) == NULL) {
762 		memory_err(l + 1, errno, fname);
763 	}
764 
765 	return (r);
766 }
767 
768 /*
769  * usage(): Print a helpful message and exit.
770  */
771 static void
772 usage()
773 {
774 	(void) fprintf(stderr, "Usage:\t%s [ -fhs ] [ -t fstab ] [ -m mnttab ] "
775 	    "rawdisk ...\n", getprogname());
776 	exit(1);
777 }
778