1/*	$NetBSD: edlabel.c,v 1.17 2009/10/21 23:12:09 snj Exp $	*/
2
3/*
4 * Copyright (c) 1995 Gordon W. Ross
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <sys/cdefs.h>
29#include <sys/types.h>
30#include <sys/param.h>
31#include <sys/ioctl.h>
32#define FSTYPENAMES
33#include <sys/disklabel.h>
34
35#include <fcntl.h>
36#include <stdio.h>
37#include <ctype.h>
38#include <string.h>
39#include <errno.h>
40#include <unistd.h>
41#include <util.h>
42#include <stdlib.h>
43
44/*
45 * Machine dependent constants you want to retrieve only once...
46 */
47int rawpartition, maxpartitions;
48
49/*
50 * This is a data-driven program
51 */
52struct field {
53	const char *f_name;
54	int f_offset;
55	int f_type;	/* 1:char, 2:short, 4:int, >4:string */
56};
57
58/* Table describing fields in the head of a disklabel. */
59#define	dloff(f) (int)(&((struct disklabel *)0)->f)
60struct field label_head[] = {
61  { "        type_num", dloff(d_type), 2 },
62  { "        sub_type", dloff(d_subtype), 2 },
63  { "       type_name", dloff(d_typename), 16 },
64  { "       pack_name", dloff(d_packname),  16 },
65  { "    bytes/sector", dloff(d_secsize), 4 },
66  { "   sectors/track", dloff(d_nsectors), 4 },
67  { " tracks/cylinder", dloff(d_ntracks),  4 },
68  { "       cylinders", dloff(d_ncylinders), 4 },
69  { "sectors/cylinder", dloff(d_secpercyl), 4 },
70  /* Don't care about the others until later... */
71  { .f_name = NULL },
72};
73#undef dloff
74
75void	check_divisors(struct disklabel *);
76u_short	dkcksum(struct disklabel *);
77void	edit_geo(struct disklabel *);
78void	edit_head_all(struct disklabel *, int);
79void	edit_head_field(void *, struct field *, int);
80void	edit_partition(struct disklabel *, int, int);
81void	get_fstype(char *, u_int8_t *);
82void	get_val_cts(struct disklabel *, char *, u_int32_t *);
83void	label_modify(struct disklabel *, char *);
84void	label_print(struct disklabel *, char *);
85void	label_quit(struct disklabel *, char *);
86void	label_read(struct disklabel *, char *);
87void	label_write(struct disklabel *, char *);
88void	menu(void);
89void	print_val_cts(struct disklabel *, u_long val);
90
91char	tmpbuf[64];
92
93void
94edit_head_field(void *v, struct field *f, int modify /* also modify */)
95{
96	u_int8_t  *cp;
97	u_int tmp;
98
99	cp = v;
100	cp += f->f_offset;
101
102	printf("%s: ", f->f_name);
103
104	/* Print current value... */
105	switch (f->f_type) {
106	case 1:
107		tmp = *cp;
108		printf("%d", tmp);
109		break;
110	case 2:
111		tmp = *((u_int16_t *)cp);
112		printf("%d", tmp);
113		break;
114	case 4:
115		tmp = *((u_int32_t *)cp);
116		printf("%d", tmp);
117		break;
118
119	default:
120		/* must be a string. */
121		strlcpy(tmpbuf, (char*)cp, sizeof(tmpbuf));
122		printf("%s", tmpbuf);
123		break;
124	}
125
126	if (modify == 0) {
127		printf("\n");
128		return;
129	}
130	printf(" ? ");
131	fflush(stdout);
132
133	tmpbuf[0] = '\0';
134	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
135		return;
136	if ((tmpbuf[0] == '\0') || (tmpbuf[0] == '\n')) {
137		/* no new value supplied. */
138		return;
139	}
140
141	/* store new value */
142	if (f->f_type <= 4)
143		if (sscanf(tmpbuf, "%d", &tmp) != 1)
144			return;
145
146	switch (f->f_type) {
147	case 1:
148		*cp = tmp;
149		break;
150	case 2:
151		*((u_int16_t *)cp) = tmp;
152		break;
153	case 4:
154		*((u_int32_t *)cp) = tmp;
155		break;
156	default:
157		/* Get rid of the trailing newline. */
158		tmp = strlen(tmpbuf);
159		if (tmp < 1)
160			break;
161		if (tmpbuf[tmp-1] == '\n')
162			tmpbuf[tmp-1] = '\0';
163		strncpy((char*)cp, tmpbuf, f->f_type);
164		break;
165	}
166}
167
168void
169edit_head_all(struct disklabel *d, int modify)
170{
171	struct field *f;
172
173	/* Edit head stuff. */
174	for (f = label_head; f->f_name; f++)
175		edit_head_field(d, f, modify);
176}
177
178void
179edit_geo(struct disklabel *d)
180{
181	int nsect, ntrack, ncyl, spc;
182
183	nsect = ntrack = ncyl = spc = 0;
184
185	printf("Sectors/track: ");
186	fflush(stdout);
187	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
188		return;
189	if (sscanf(tmpbuf, "%d", &nsect) != 1)
190		nsect = d->d_nsectors;
191	printf("Track/cyl: ");
192	fflush(stdout);
193	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
194		return;
195	if (sscanf(tmpbuf, "%d", &ntrack) != 1)
196		ntrack = d->d_ntracks;
197	if (!nsect || !ntrack)
198		return;
199	spc = nsect * ntrack;
200	if (!(ncyl = d->d_secperunit / spc))
201		return;
202	d->d_nsectors   = nsect;
203	d->d_ntracks    = ntrack;
204	d->d_ncylinders = ncyl;
205	d->d_secpercyl  = spc;
206}
207
208void
209print_val_cts(struct disklabel *d, u_long val)
210{
211	int	sects, trks, cyls;
212	char	marker;
213	char	buf[80];
214
215	marker = (val % d->d_secpercyl) ? '*' : ' ';
216	sects  = val % d->d_nsectors;
217	cyls   = val / d->d_nsectors;
218	trks   = cyls % d->d_ntracks;
219	cyls  /= d->d_ntracks;
220	snprintf(buf, sizeof(buf), "(%d/%02d/%02d)%c", cyls, trks, sects,
221	    marker);
222	printf(" %9ld %16s", val, buf);
223}
224
225void
226get_val_cts(struct disklabel *d, char *buf, u_int32_t *result)
227{
228	u_long tmp;
229	int	cyls, trks, sects;
230
231	tmp = sscanf(buf, "%d/%d/%d", &cyls, &trks, &sects);
232	if (tmp == 1)
233		*result = cyls;	/* really nblks! */
234	if (tmp == 3) {
235		tmp = cyls;
236		tmp *= d->d_ntracks;
237		tmp += trks;
238		tmp *= d->d_nsectors;
239		tmp += sects;
240		*result = tmp;
241	}
242}
243
244void
245get_fstype(char *buf, u_int8_t *fstype)
246{
247	int	i, len;
248
249	/* An empty response retains previous value */
250	if (buf[0] == '\n')
251		return;
252	for (i = 0, len = strlen(buf) - 1; i < FSMAXTYPES; i++) {
253		if (!strncasecmp(buf, fstypenames[i], len)) {
254			*fstype = i;
255			return;
256		}
257	}
258}
259
260void
261edit_partition(struct disklabel *d, int idx, int modify)
262{
263	struct partition *p;
264	char letter;
265	const char *comment;
266
267	if ((idx < 0) || (idx >= maxpartitions)) {
268		printf("bad partition index\n");
269		return;
270	}
271
272	p = &d->d_partitions[idx];
273	letter = 'a' + idx;
274
275	/* Set hint about partition type */
276	if (idx == rawpartition)
277		comment = "disk";
278	else {
279		comment = "user";
280		switch(idx) {
281			case 0:
282				comment = "root";
283			break;
284			case 1:
285				comment = "swap";
286				break;
287		}
288	}
289
290	/* Print current value... */
291	printf(" %c (%s) ", letter, comment);
292	print_val_cts(d, p->p_offset);
293	print_val_cts(d, p->p_size);
294	printf(" %s\n", fstypenames[p->p_fstype]);
295
296	if (modify == 0)
297		return;
298
299	/* starting block, or cyls/trks/sects */
300	printf("start as <blkno> or <cyls/trks/sects> : ");
301	fflush(stdout);
302	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
303		return;
304	get_val_cts(d, tmpbuf, &p->p_offset);
305
306	/* number of blocks, or cyls/trks/sects */
307	printf("length as <nblks> or <cyls/trks/sects> : ");
308	fflush(stdout);
309	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
310		return;
311	get_val_cts(d, tmpbuf, &p->p_size);
312	/* partition type */
313	printf("type: ");
314	fflush(stdout);
315	if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
316		return;
317	get_fstype(tmpbuf, &p->p_fstype);
318}
319
320/*****************************************************************/
321
322void
323check_divisors(struct disklabel *d)
324{
325	if (d->d_nsectors == 0) {
326		d->d_nsectors = 1;
327		printf("bad sect/trk, set to 1\n");
328	}
329	if (d->d_ntracks == 0) {
330		d->d_ntracks = 1;
331		printf("bad trks/cyl, set to 1\n");
332	}
333	if (d->d_ncylinders == 0) {
334		d->d_ncylinders = 1;
335		printf("bad cyls, set to 1\n");
336	}
337	if (d->d_secpercyl == 0) {
338		d->d_secpercyl = (d->d_nsectors * d->d_ntracks);
339		printf("bad sect/cyl, set to %d\n", d->d_secpercyl);
340	}
341
342}
343
344u_short
345dkcksum(struct disklabel *d)
346{
347	u_short *start, *end;
348	u_short sum = 0;
349
350	start = (u_short *)d;
351	end = (u_short *)&d->d_partitions[d->d_npartitions];
352	while (start < end)
353		sum ^= *start++;
354	return (sum);
355}
356
357void
358label_write(struct disklabel *d, char *dn)
359{
360	int fd;
361
362	d->d_magic = DISKMAGIC;
363	d->d_magic2 = DISKMAGIC;
364	d->d_checksum = 0;
365	d->d_checksum = dkcksum(d);
366
367	fd = open(dn, O_RDWR, 0);
368	if (fd < 0) {
369		perror(dn);
370		return;
371	}
372	if (ioctl(fd, DIOCWDINFO, d) < 0) {
373		perror("ioctl DIOCWDINFO");
374	}
375	close(fd);
376}
377
378void
379label_read(struct disklabel *dl, char *dn)
380{
381	int fd;
382
383	fd = open(dn, O_RDONLY, 0);
384	if (fd < 0) {
385		perror(dn);
386		exit(1);
387	}
388	if (ioctl(fd, DIOCGDINFO, dl) < 0) {
389		if (errno == ESRCH)
390			fprintf(stderr, "edlabel: No disk label on disk\n");
391		else
392		    	perror("ioctl DIOCGDINFO");
393		exit(1);
394	}
395
396	/* Make sure divisors are non-zero. */
397	check_divisors(dl);
398
399	close(fd);
400}
401
402/*****************************************************************/
403
404void
405label_print(struct disklabel *dl, char *dn)
406{
407	int i;
408
409	/* Print out head stuff. */
410	edit_head_all(dl, 0);
411
412	/* And the partition header. */
413	printf("partition%6sstart%9s(c/t/s)%6snblks%9s(c/t/s)  type\n\n"
414							"", "", "", "", "");
415	for (i = 0; i < dl->d_npartitions; i++)
416		edit_partition(dl, i, 0);
417}
418
419char modify_cmds[] = "modify subcommands:\n\
420 @   : modify disk parameters\n\
421 a-%c : modify partition\n%s\
422 q   : quit this subcommand\n";
423
424void
425label_modify(struct disklabel *dl, char *dn)
426{
427	int c, i;
428	int scsi_fict = 0;
429
430	if (!strcmp(dl->d_typename, "SCSI disk")
431	     && !strcmp(dl->d_packname, "fictitious"))
432		scsi_fict = 1;
433
434	printf(modify_cmds, 'a' + maxpartitions - 1,
435		scsi_fict ? " s   : standardize geometry\n" : "");
436	for (;;) {
437		printf("edlabel/modify> ");
438		fflush(stdout);
439		if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
440			break;
441		c = tmpbuf[0];
442		if ((c == '\0') || (c == '\n'))
443			continue;	/* blank line */
444		if (c == 'q')
445			break;
446		if (c == '@') {
447			edit_head_all(dl, 1);
448			check_divisors(dl);
449			continue;
450		}
451		if ((c == 's') && scsi_fict) {
452			edit_geo(dl);
453			continue;
454		}
455		if ((c < 'a') || (c > 'q')) {
456			printf("bad input.  ");
457			printf(modify_cmds, 'a' + maxpartitions - 1,
458			    scsi_fict ? " s   : standardize geometry\n" : "");
459			continue;
460		}
461		edit_partition(dl, c - 'a', 1);
462	}
463	/* Set the d_npartitions field correctly */
464	for (i = 0; i < maxpartitions; i++) {
465		if (dl->d_partitions[i].p_size)
466			dl->d_npartitions = i + 1;
467	}
468
469}
470
471void
472label_quit(struct disklabel *dl, char *dn)
473{
474	exit(0);
475}
476
477struct cmd {
478	void (*cmd_func)(struct disklabel *, char *);
479	const char *cmd_name;
480	const char *cmd_descr;
481} cmds[] = {
482	{ label_print,  "print",  "display the current disk label" },
483	{ label_modify, "modify", "prompt for changes to the label" },
484	{ label_write,  "write",  "write the new label to disk" },
485	{ label_quit,   "quit",   "terminate program" },
486	{ .cmd_func = 0 },
487};
488
489void
490menu(void)
491{
492	struct cmd *cmd;
493
494	printf("edlabel menu:\n");
495	for (cmd = cmds; cmd->cmd_func; cmd++)
496		printf("%s\t- %s\n", cmd->cmd_name, cmd->cmd_descr);
497}
498
499int
500main(int argc, char **argv)
501{
502	struct disklabel dl;
503	struct cmd *cmd;
504	char *dev_name;
505
506	if (argc != 2) {
507		fprintf(stderr, "usage: edlabel RAWDISK\n");
508		exit(1);
509	}
510	dev_name = argv[1];
511
512	rawpartition = getrawpartition();
513	maxpartitions = getmaxpartitions();
514
515	label_read(&dl, dev_name);
516
517	menu();
518
519	for (;;) {
520		printf("edlabel> ");
521		fflush(stdout);
522		if (fgets(tmpbuf, sizeof(tmpbuf), stdin) == NULL)
523			break;
524		for (cmd = cmds; cmd->cmd_func; cmd++)
525			if (cmd->cmd_name[0] == tmpbuf[0])
526				goto found;
527		printf("Invalid command.  ");
528		menu();
529		continue;
530
531	found:
532		cmd->cmd_func(&dl, dev_name);
533	}
534	exit(0);
535}
536