Home | History | Annotate | Line # | Download | only in disklabel
interact.c revision 1.35 
      1 /*	$NetBSD: interact.c,v 1.35 2011/01/06 21:39:01 apb Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1997 Christos Zoulas.  All rights reserved.
      5  *
      6  * Redistribution and use in source and binary forms, with or without
      7  * modification, are permitted provided that the following conditions
      8  * are met:
      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 #ifndef lint
     33 __RCSID("$NetBSD: interact.c,v 1.35 2011/01/06 21:39:01 apb Exp $");
     34 #endif /* lint */
     35 
     36 #include <sys/param.h>
     37 #define FSTYPENAMES
     38 #define DKTYPENAMES
     39 
     40 #include <err.h>
     41 #include <stdio.h>
     42 #include <string.h>
     43 #include <stdlib.h>
     44 
     45 #if HAVE_NBTOOL_CONFIG_H
     46 #define	getmaxpartitions()	MAXPARTITIONS
     47 #include <nbinclude/sys/disklabel.h>
     48 #else
     49 #include <util.h>
     50 #include <sys/disklabel.h>
     51 #endif /* HAVE_NBTOOL_CONFIG_H */
     52 
     53 #include "extern.h"
     54 
     55 static void	cmd_help(struct disklabel *, char *, int);
     56 static void	cmd_chain(struct disklabel *, char *, int);
     57 static void	cmd_print(struct disklabel *, char *, int);
     58 static void	cmd_printall(struct disklabel *, char *, int);
     59 static void	cmd_info(struct disklabel *, char *, int);
     60 static void	cmd_part(struct disklabel *, char *, int);
     61 static void	cmd_label(struct disklabel *, char *, int);
     62 static void	cmd_round(struct disklabel *, char *, int);
     63 static void	cmd_name(struct disklabel *, char *, int);
     64 static void	cmd_listfstypes(struct disklabel *, char *, int);
     65 static int	runcmd(struct disklabel *, char *, int);
     66 static int	getinput(const char *, const char *, const char *, char *);
     67 static int	alphacmp(const void *, const void *);
     68 static void	defnum(struct disklabel *, char *, uint32_t);
     69 static void	dumpnames(const char *, const char * const *, size_t);
     70 static intmax_t	getnum(struct disklabel *, char *, intmax_t);
     71 
     72 static int rounding = 0;	/* sector rounding */
     73 static int chaining = 0;	/* make partitions contiguous */
     74 
     75 static struct cmds {
     76 	const char *name;
     77 	void (*func)(struct disklabel *, char *, int);
     78 	const char *help;
     79 } cmds[] = {
     80 	{ "?",	cmd_help,	"print this menu" },
     81 	{ "C",	cmd_chain,	"make partitions contiguous" },
     82 	{ "E",	cmd_printall,	"print disk label and current partition table"},
     83 	{ "I",	cmd_info,	"change label information" },
     84 	{ "L",	cmd_listfstypes,"list all known file system types" },
     85 	{ "N",	cmd_name,	"name the label" },
     86 	{ "P",	cmd_print,	"print current partition table" },
     87 	{ "Q",	NULL,		"quit" },
     88 	{ "R",	cmd_round,	"rounding (c)ylinders (s)ectors" },
     89 	{ "W",	cmd_label,	"write the current partition table" },
     90 	{ NULL, NULL,		NULL }
     91 };
     92 
     93 
     94 
     95 static void
     96 cmd_help(struct disklabel *lp, char *s, int fd)
     97 {
     98 	struct cmds *cmd;
     99 
    100 	for (cmd = cmds; cmd->name != NULL; cmd++)
    101 		printf("%s\t%s\n", cmd->name, cmd->help);
    102 	printf("[a-%c]\tdefine named partition\n",
    103 	    'a' + getmaxpartitions() - 1);
    104 }
    105 
    106 
    107 static void
    108 cmd_chain(struct disklabel *lp, char *s, int fd)
    109 {
    110 	int	i;
    111 	char	line[BUFSIZ];
    112 
    113 	i = getinput(":", "Automatically adjust partitions",
    114 	    chaining ? "yes" : "no", line);
    115 	if (i <= 0)
    116 		return;
    117 
    118 	switch (line[0]) {
    119 	case 'y':
    120 		chaining = 1;
    121 		return;
    122 	case 'n':
    123 		chaining = 0;
    124 		return;
    125 	default:
    126 		printf("Invalid answer\n");
    127 		return;
    128 	}
    129 }
    130 
    131 
    132 static void
    133 cmd_printall(struct disklabel *lp, char *s, int fd)
    134 {
    135 
    136 	showinfo(stdout, lp, specname);
    137 	showpartitions(stdout, lp, Cflag);
    138 }
    139 
    140 
    141 static void
    142 cmd_print(struct disklabel *lp, char *s, int fd)
    143 {
    144 
    145 	showpartitions(stdout, lp, Cflag);
    146 }
    147 
    148 
    149 static void
    150 cmd_info(struct disklabel *lp, char *s, int fd)
    151 {
    152 	char	line[BUFSIZ];
    153 	char	def[BUFSIZ];
    154 	int	v, i;
    155 	u_int32_t u;
    156 
    157 	printf("# Current values:\n");
    158 	showinfo(stdout, lp, specname);
    159 
    160 	/* d_type */
    161 	for (;;) {
    162 		i = lp->d_type;
    163 		if (i < 0 || i >= DKMAXTYPES)
    164 			i = 0;
    165 		snprintf(def, sizeof(def), "%s", dktypenames[i]);
    166 		i = getinput(":", "Disk type [?]", def, line);
    167 		if (i == -1)
    168 			return;
    169 		else if (i == 0)
    170 			break;
    171 		if (!strcmp(line, "?")) {
    172 			dumpnames("Supported disk types", dktypenames,
    173 			    DKMAXTYPES);
    174 			continue;
    175 		}
    176 		for (i = 0; i < DKMAXTYPES; i++) {
    177 			if (!strcasecmp(dktypenames[i], line)) {
    178 				lp->d_type = i;
    179 				goto done_typename;
    180 			}
    181 		}
    182 		v = atoi(line);
    183 		if ((unsigned)v >= DKMAXTYPES) {
    184 			warnx("Unknown disk type: %s", line);
    185 			continue;
    186 		}
    187 		lp->d_type = v;
    188  done_typename:
    189 		break;
    190 	}
    191 
    192 	/* d_typename */
    193 	snprintf(def, sizeof(def), "%.*s",
    194 	    (int) sizeof(lp->d_typename), lp->d_typename);
    195 	i = getinput(":", "Disk name", def, line);
    196 	if (i == -1)
    197 		return;
    198 	else if (i == 1)
    199 		(void) strncpy(lp->d_typename, line, sizeof(lp->d_typename));
    200 
    201 	/* d_packname */
    202 	cmd_name(lp, s, fd);
    203 
    204 	/* d_npartitions */
    205 	for (;;) {
    206 		snprintf(def, sizeof(def), "%" PRIu16, lp->d_npartitions);
    207 		i = getinput(":", "Number of partitions", def, line);
    208 		if (i == -1)
    209 			return;
    210 		else if (i == 0)
    211 			break;
    212 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    213 			printf("Invalid number of partitions `%s'\n", line);
    214 			continue;
    215 		}
    216 		lp->d_npartitions = u;
    217 		break;
    218 	}
    219 
    220 	/* d_secsize */
    221 	for (;;) {
    222 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_secsize);
    223 		i = getinput(":", "Sector size (bytes)", def, line);
    224 		if (i == -1)
    225 			return;
    226 		else if (i == 0)
    227 			break;
    228 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    229 			printf("Invalid sector size `%s'\n", line);
    230 			continue;
    231 		}
    232 		lp->d_secsize = u;
    233 		break;
    234 	}
    235 
    236 	/* d_nsectors */
    237 	for (;;) {
    238 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_nsectors);
    239 		i = getinput(":", "Number of sectors per track", def, line);
    240 		if (i == -1)
    241 			return;
    242 		else if (i == 0)
    243 			break;
    244 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    245 			printf("Invalid number of sectors `%s'\n", line);
    246 			continue;
    247 		}
    248 		lp->d_nsectors = u;
    249 		break;
    250 	}
    251 
    252 	/* d_ntracks */
    253 	for (;;) {
    254 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_ntracks);
    255 		i = getinput(":", "Number of tracks per cylinder", def, line);
    256 		if (i == -1)
    257 			return;
    258 		else if (i == 0)
    259 			break;
    260 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    261 			printf("Invalid number of tracks `%s'\n", line);
    262 			continue;
    263 		}
    264 		lp->d_ntracks = u;
    265 		break;
    266 	}
    267 
    268 	/* d_secpercyl */
    269 	for (;;) {
    270 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_secpercyl);
    271 		i = getinput(":", "Number of sectors/cylinder", def, line);
    272 		if (i == -1)
    273 			return;
    274 		else if (i == 0)
    275 			break;
    276 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    277 			printf("Invalid number of sector/cylinder `%s'\n",
    278 			    line);
    279 			continue;
    280 		}
    281 		lp->d_secpercyl = u;
    282 		break;
    283 	}
    284 
    285 	/* d_ncylinders */
    286 	for (;;) {
    287 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_ncylinders);
    288 		i = getinput(":", "Total number of cylinders", def, line);
    289 		if (i == -1)
    290 			return;
    291 		else if (i == 0)
    292 			break;
    293 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    294 			printf("Invalid sector size `%s'\n", line);
    295 			continue;
    296 		}
    297 		lp->d_ncylinders = u;
    298 		break;
    299 	}
    300 
    301 	/* d_secperunit */
    302 	for (;;) {
    303 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_secperunit);
    304 		i = getinput(":", "Total number of sectors", def, line);
    305 		if (i == -1)
    306 			return;
    307 		else if (i == 0)
    308 			break;
    309 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    310 			printf("Invalid number of sectors `%s'\n", line);
    311 			continue;
    312 		}
    313 		lp->d_secperunit = u;
    314 		break;
    315 	}
    316 
    317 	/* d_rpm */
    318 
    319 	/* d_interleave */
    320 	for (;;) {
    321 		snprintf(def, sizeof(def), "%" PRIu16, lp->d_interleave);
    322 		i = getinput(":", "Hardware sectors interleave", def, line);
    323 		if (i == -1)
    324 			return;
    325 		else if (i == 0)
    326 			break;
    327 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    328 			printf("Invalid sector interleave `%s'\n", line);
    329 			continue;
    330 		}
    331 		lp->d_interleave = u;
    332 		break;
    333 	}
    334 
    335 	/* d_trackskew */
    336 	for (;;) {
    337 		snprintf(def, sizeof(def), "%" PRIu16, lp->d_trackskew);
    338 		i = getinput(":", "Sector 0 skew, per track", def, line);
    339 		if (i == -1)
    340 			return;
    341 		else if (i == 0)
    342 			break;
    343 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    344 			printf("Invalid track sector skew `%s'\n", line);
    345 			continue;
    346 		}
    347 		lp->d_trackskew = u;
    348 		break;
    349 	}
    350 
    351 	/* d_cylskew */
    352 	for (;;) {
    353 		snprintf(def, sizeof(def), "%" PRIu16, lp->d_cylskew);
    354 		i = getinput(":", "Sector 0 skew, per cylinder", def, line);
    355 		if (i == -1)
    356 			return;
    357 		else if (i == 0)
    358 			break;
    359 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    360 			printf("Invalid cylinder sector `%s'\n", line);
    361 			continue;
    362 		}
    363 		lp->d_cylskew = u;
    364 		break;
    365 	}
    366 
    367 	/* d_headswitch */
    368 	for (;;) {
    369 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_headswitch);
    370 		i = getinput(":", "Head switch time (usec)", def, line);
    371 		if (i == -1)
    372 			return;
    373 		else if (i == 0)
    374 			break;
    375 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    376 			printf("Invalid head switch time `%s'\n", line);
    377 			continue;
    378 		}
    379 		lp->d_headswitch = u;
    380 		break;
    381 	}
    382 
    383 	/* d_trkseek */
    384 	for (;;) {
    385 		snprintf(def, sizeof(def), "%" PRIu32, lp->d_trkseek);
    386 		i = getinput(":", "Track seek time (usec)", def, line);
    387 		if (i == -1)
    388 			return;
    389 		else if (i == 0)
    390 			break;
    391 		if (sscanf(line, "%" SCNu32, &u) != 1) {
    392 			printf("Invalid track seek time `%s'\n", line);
    393 			continue;
    394 		}
    395 		lp->d_trkseek = u;
    396 		break;
    397 	}
    398 }
    399 
    400 
    401 static void
    402 cmd_name(struct disklabel *lp, char *s, int fd)
    403 {
    404 	char	line[BUFSIZ];
    405 	char	def[BUFSIZ];
    406 	int	i;
    407 
    408 	snprintf(def, sizeof(def), "%.*s",
    409 	    (int) sizeof(lp->d_packname), lp->d_packname);
    410 	i = getinput(":", "Label name", def, line);
    411 	if (i <= 0)
    412 		return;
    413 	(void) strncpy(lp->d_packname, line, sizeof(lp->d_packname));
    414 }
    415 
    416 
    417 static void
    418 cmd_round(struct disklabel *lp, char *s, int fd)
    419 {
    420 	int	i;
    421 	char	line[BUFSIZ];
    422 
    423 	i = getinput(":", "Rounding", rounding ? "cylinders" : "sectors", line);
    424 	if (i <= 0)
    425 		return;
    426 
    427 	switch (line[0]) {
    428 	case 'c':
    429 	case 'C':
    430 		rounding = 1;
    431 		return;
    432 	case 's':
    433 	case 'S':
    434 		rounding = 0;
    435 		return;
    436 	default:
    437 		printf("Rounding can be (c)ylinders or (s)ectors\n");
    438 		return;
    439 	}
    440 }
    441 
    442 
    443 static void
    444 cmd_part(struct disklabel *lp, char *s, int fd)
    445 {
    446 	int	i;
    447 	intmax_t im;
    448 	char	line[BUFSIZ];
    449 	char	def[BUFSIZ];
    450 	int	part;
    451 	struct partition *p, ps;
    452 
    453 	part = s[0] - 'a';
    454 	p = &lp->d_partitions[part];
    455 	if (part >= lp->d_npartitions)
    456 		lp->d_npartitions = part + 1;
    457 
    458 	(void)memcpy(&ps, p, sizeof(ps));
    459 
    460 	for (;;) {
    461 		i = p->p_fstype;
    462 		if (i < 0 || i >= FSMAXTYPES)
    463 			i = 0;
    464 		snprintf(def, sizeof(def), "%s", fstypenames[i]);
    465 		i = getinput(":", "Filesystem type [?]", def, line);
    466 		if (i == -1)
    467 			return;
    468 		else if (i == 0)
    469 			break;
    470 		if (!strcmp(line, "?")) {
    471 			dumpnames("Supported file system types",
    472 			    fstypenames, FSMAXTYPES);
    473 			continue;
    474 		}
    475 		for (i = 0; i < FSMAXTYPES; i++)
    476 			if (!strcasecmp(line, fstypenames[i])) {
    477 				p->p_fstype = i;
    478 				goto done_typename;
    479 			}
    480 		printf("Invalid file system typename `%s'\n", line);
    481 		continue;
    482  done_typename:
    483 		break;
    484 	}
    485 	for (;;) {
    486 		defnum(lp, def, p->p_offset);
    487 		i = getinput(":",
    488 		    "Start offset ('x' to start after partition 'x')",
    489 		    def, line);
    490 		if (i == -1)
    491 			return;
    492 		else if (i == 0)
    493 			break;
    494 		if (line[1] == '\0' &&
    495 	    		line[0] >= 'a' && line[0] < 'a' + getmaxpartitions()) {
    496 			struct partition *cp = lp->d_partitions;
    497 
    498 			if ((cp[line[0] - 'a'].p_offset +
    499 			    cp[line[0] - 'a'].p_size) >= lp->d_secperunit) {
    500 				printf("Bad offset `%s'\n", line);
    501 				continue;
    502 			} else {
    503 				p->p_offset = cp[line[0] - 'a'].p_offset +
    504 				    cp[line[0] - 'a'].p_size;
    505 			}
    506 		} else {
    507 			if ((im = getnum(lp, line, 0)) == -1 || im < 0) {
    508 				printf("Bad offset `%s'\n", line);
    509 				continue;
    510 			} else if (im > 0xffffffffLL ||
    511 				   (uint32_t)im > lp->d_secperunit) {
    512 				printf("Offset `%s' out of range\n", line);
    513 				continue;
    514 			}
    515 			p->p_offset = (uint32_t)im;
    516 		}
    517 		break;
    518 	}
    519 	for (;;) {
    520 		defnum(lp, def, p->p_size);
    521 		i = getinput(":", "Partition size ('$' for all remaining)",
    522 		    def, line);
    523 		if (i == -1)
    524 			return;
    525 		else if (i == 0)
    526 			break;
    527 		if ((im = getnum(lp, line, lp->d_secperunit - p->p_offset))
    528 		    == -1) {
    529 			printf("Bad size `%s'\n", line);
    530 			continue;
    531 		} else if (im > 0xffffffffLL ||
    532 			   (im + p->p_offset) > lp->d_secperunit) {
    533 			printf("Size `%s' out of range\n", line);
    534 			continue;
    535 		}
    536 		p->p_size = im;
    537 		break;
    538 	}
    539 
    540 	if (memcmp(&ps, p, sizeof(ps)))
    541 		showpartition(stdout, lp, part, Cflag);
    542 	if (chaining) {
    543 		int offs = -1;
    544 		struct partition *cp = lp->d_partitions;
    545 		for (i = 0; i < lp->d_npartitions; i++) {
    546 			if (cp[i].p_fstype != FS_UNUSED) {
    547 				if (offs != -1 && cp[i].p_offset != (uint32_t)offs) {
    548 					cp[i].p_offset = offs;
    549 					showpartition(stdout, lp, i, Cflag);
    550 					}
    551 				offs = cp[i].p_offset + cp[i].p_size;
    552 			}
    553 		}
    554 	}
    555 }
    556 
    557 
    558 static void
    559 cmd_label(struct disklabel *lp, char *s, int fd)
    560 {
    561 	char	line[BUFSIZ];
    562 	int	i;
    563 
    564 	i = getinput("?", "Label disk", "n", line);
    565 	if (i <= 0 || (*line != 'y' && *line != 'Y') )
    566 		return;
    567 
    568 	if (checklabel(lp) != 0) {
    569 		printf("Label not written\n");
    570 		return;
    571 	}
    572 
    573 	if (writelabel(fd, lp) != 0) {
    574 		printf("Label not written\n");
    575 		return;
    576 	}
    577 	printf("Label written\n");
    578 }
    579 
    580 
    581 static void
    582 cmd_listfstypes(struct disklabel *lp, char *s, int fd)
    583 {
    584 
    585 	(void)list_fs_types();
    586 }
    587 
    588 
    589 static int
    590 runcmd(struct disklabel *lp, char *line, int fd)
    591 {
    592 	struct cmds *cmd;
    593 
    594 	for (cmd = cmds; cmd->name != NULL; cmd++)
    595 		if (strncmp(line, cmd->name, strlen(cmd->name)) == 0) {
    596 			if (cmd->func == NULL)
    597 				return -1;
    598 			(*cmd->func)(lp, line, fd);
    599 			return 0;
    600 		}
    601 
    602 	if (line[1] == '\0' &&
    603 	    line[0] >= 'a' && line[0] < 'a' + getmaxpartitions()) {
    604 		cmd_part(lp, line, fd);
    605 		return 0;
    606 	}
    607 
    608 	printf("Unknown command %s\n", line);
    609 	return 1;
    610 }
    611 
    612 
    613 static int
    614 getinput(const char *sep, const char *prompt, const char *def, char *line)
    615 {
    616 
    617 	for (;;) {
    618 		printf("%s", prompt);
    619 		if (def)
    620 			printf(" [%s]", def);
    621 		printf("%s ", sep);
    622 
    623 		if (fgets(line, BUFSIZ, stdin) == NULL)
    624 			return -1;
    625 		if (line[0] == '\n' || line[0] == '\0') {
    626 			if (def)
    627 				return 0;
    628 		}
    629 		else {
    630 			char *p;
    631 
    632 			if ((p = strrchr(line, '\n')) != NULL)
    633 				*p = '\0';
    634 			return 1;
    635 		}
    636 	}
    637 }
    638 
    639 static int
    640 alphacmp(const void *a, const void *b)
    641 {
    642 
    643 	return (strcasecmp(*(const char * const*)a, *(const char * const*)b));
    644 }
    645 
    646 
    647 static void
    648 dumpnames(const char *prompt, const char * const *olist, size_t numentries)
    649 {
    650 	int	w;
    651 	size_t	i, entry, lines;
    652 	int	columns, width;
    653 	const char *p;
    654 	const char **list;
    655 
    656 	if ((list = (const char **)malloc(sizeof(char *) * numentries)) == NULL)
    657 		err(1, "malloc");
    658 	width = 0;
    659 	printf("%s:\n", prompt);
    660 	for (i = 0; i < numentries; i++) {
    661 		list[i] = olist[i];
    662 		w = strlen(list[i]);
    663 		if (w > width)
    664 			width = w;
    665 	}
    666 #if 0
    667 	for (i = 0; i < numentries; i++)
    668 		printf("%s%s", i == 0 ? "" : ", ", list[i]);
    669 	puts("");
    670 #endif
    671 	(void)qsort(list, numentries, sizeof(char *), alphacmp);
    672 	width++;		/* want two spaces between items */
    673 	width = (width + 8) &~ 7;
    674 
    675 #define ttywidth 72
    676 	columns = ttywidth / width;
    677 #undef ttywidth
    678 	if (columns == 0)
    679 		columns = 1;
    680 	lines = (numentries + columns - 1) / columns;
    681 	/* Output sorted by columns */
    682 	for (i = 0; i < lines; i++) {
    683 		putc('\t', stdout);
    684 		entry = i;
    685 		for (;;) {
    686 			p = list[entry];
    687 			fputs(p, stdout);
    688 			entry += lines;
    689 			if (entry >= numentries)
    690 				break;
    691 			w = strlen(p);
    692 			while (w < width) {
    693 				w = (w + 8) & ~7;
    694 				putc('\t', stdout);
    695 			}
    696 		}
    697 		putc('\n', stdout);
    698 	}
    699 	free(list);
    700 }
    701 
    702 
    703 static void
    704 defnum(struct disklabel *lp, char *buf, uint32_t size)
    705 {
    706 
    707 	(void) snprintf(buf, BUFSIZ, "%.40gc, %" PRIu32 "s, %.40gM",
    708 	    size / (float) lp->d_secpercyl,
    709 	    size, size  * (lp->d_secsize / (float) (1024 * 1024)));
    710 }
    711 
    712 
    713 static intmax_t
    714 getnum(struct disklabel *lp, char *buf, intmax_t defaultval)
    715 {
    716 	char	*ep;
    717 	double	 d;
    718 	intmax_t rv;
    719 
    720 	if (defaultval && buf[0] == '$' && buf[1] == 0)
    721 		return defaultval;
    722 
    723 	d = strtod(buf, &ep);
    724 	if (buf == ep)
    725 		return -1;
    726 
    727 #define ROUND(a)	((((a) / lp->d_secpercyl) + \
    728 		 	 (((a) % lp->d_secpercyl) ? 1 : 0)) * lp->d_secpercyl)
    729 
    730 	switch (*ep) {
    731 	case '\0':
    732 	case 's':
    733 	case 'S':
    734 		rv = (intmax_t) d;
    735 		break;
    736 
    737 	case 'c':
    738 	case 'C':
    739 		rv = (intmax_t) (d * lp->d_secpercyl);
    740 		break;
    741 
    742 	case 'k':
    743 	case 'K':
    744 		rv =  (intmax_t) (d * 1024 / lp->d_secsize);
    745 		break;
    746 
    747 	case 'm':
    748 	case 'M':
    749 		rv =  (intmax_t) (d * 1024 * 1024 / lp->d_secsize);
    750 		break;
    751 
    752 	case 'g':
    753 	case 'G':
    754 		rv =  (intmax_t) (d * 1024 * 1024 * 1024 / lp->d_secsize);
    755 		break;
    756 
    757 	case 't':
    758 	case 'T':
    759 		rv =  (intmax_t) (d * 1024 * 1024 * 1024 * 1024 / lp->d_secsize);
    760 		break;
    761 
    762 	default:
    763 		printf("Unit error %c\n", *ep);
    764 		printf("Valid units: (S)ectors, (C)ylinders, (K)ilo, (M)ega, "
    765 		    "(G)iga, (T)era");
    766 		return -1;
    767 	}
    768 
    769 	if (rounding)
    770 		return ROUND(rv);
    771 	else
    772 		return rv;
    773 }
    774 
    775 
    776 void
    777 interact(struct disklabel *lp, int fd)
    778 {
    779 	char	line[BUFSIZ];
    780 
    781 	puts("Enter '?' for help");
    782 	for (;;) {
    783 		if (getinput(">", "partition", NULL, line) == -1)
    784 			return;
    785 		if (runcmd(lp, line, fd) == -1)
    786 			return;
    787 	}
    788 }
    789