![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disklabel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / disklabel|
Return to disklabel.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / disklabel |
1.1 root 1: /*
2: * Copyright (c) 1987 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Symmetric Computer Systems.
7: *
8: * Redistribution and use in source and binary forms are permitted
9: * provided that: (1) source distributions retain this entire copyright
10: * notice and comment, and (2) distributions including binaries display
11: * the following acknowledgement: ``This product includes software
12: * developed by the University of California, Berkeley and its contributors''
13: * in the documentation or other materials provided with the distribution
14: * and in all advertising materials mentioning features or use of this
15: * software. Neither the name of the University nor the names of its
16: * contributors may be used to endorse or promote products derived
17: * from this software without specific prior written permission.
18: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21: */
22:
23: #ifndef lint
24: char copyright[] =
25: "@(#) Copyright (c) 1987 The Regents of the University of California.\n\
26: All rights reserved.\n";
27: #endif /* not lint */
28:
29: #ifndef lint
30: static char sccsid[] = "@(#)disklabel.c 5.19 (Berkeley) 6/1/90";
31: /* from static char sccsid[] = "@(#)disklabel.c 1.2 (Symmetric) 11/28/85"; */
32: #endif /* not lint */
33:
34: #include <sys/param.h>
35: #include <sys/signal.h>
36: #include <sys/errno.h>
37: #include <sys/file.h>
38: #include <sys/ioctl.h>
39: #include <ufs/fs.h>
40: #include <string.h>
41: #define DKTYPENAMES
42: #include <sys/disklabel.h>
43: #include <stdio.h>
44: #include <ctype.h>
45: #include "pathnames.h"
46:
47: /*
48: * Disklabel: read and write disklabels.
49: * The label is usually placed on one of the first sectors of the disk.
50: * Many machines (VAX 11/750) also place a bootstrap in the same area,
51: * in which case the label is embedded in the bootstrap.
52: * The bootstrap source must leave space at the proper offset
53: * for the label on such machines.
54: */
55:
56: #ifdef vax
57: #define RAWPARTITION 'c'
58: #else
59: #define RAWPARTITION 'a'
60: #endif
61:
62: #ifndef BBSIZE
63: #define BBSIZE 8192 /* size of boot area, with label */
64: #endif
65:
66: #ifdef vax
67: #define BOOT /* also have bootstrap in "boot area" */
68: #define BOOTDIR _PATH_BOOTDIR /* source of boot binaries */
69: #else
70: #ifdef lint
71: #define BOOT
72: #endif
73: #endif
74:
75: #define DEFEDITOR _PATH_VI
76: #define streq(a,b) (strcmp(a,b) == 0)
77:
78: #ifdef BOOT
79: char *xxboot;
80: char *bootxx;
81: #endif
82:
83: char *dkname;
84: char *specname;
85: char tmpfil[] = _PATH_TMP;
86:
87: extern int errno;
88: char namebuf[BBSIZE], *np = namebuf;
89: struct disklabel lab;
90: struct disklabel *readlabel(), *makebootarea();
91: char bootarea[BBSIZE];
92: char boot0[MAXPATHLEN];
93: char boot1[MAXPATHLEN];
94:
95: enum { UNSPEC, EDIT, NOWRITE, READ, RESTORE, WRITE, WRITEABLE } op = UNSPEC;
96:
97: int rflag;
98:
99: #ifdef DEBUG
100: int debug;
101: #endif
102:
103: main(argc, argv)
104: int argc;
105: char *argv[];
106: {
107: extern int optind;
108: register struct disklabel *lp;
109: FILE *t;
110: int ch, f, error = 0;
111: char *name = 0, *type;
112:
113: while ((ch = getopt(argc, argv, "NRWerw")) != EOF)
114: switch (ch) {
115: case 'N':
116: if (op != UNSPEC)
117: usage();
118: op = NOWRITE;
119: break;
120: case 'R':
121: if (op != UNSPEC)
122: usage();
123: op = RESTORE;
124: break;
125: case 'W':
126: if (op != UNSPEC)
127: usage();
128: op = WRITEABLE;
129: break;
130: case 'e':
131: if (op != UNSPEC)
132: usage();
133: op = EDIT;
134: break;
135: case 'r':
136: ++rflag;
137: break;
138: case 'w':
139: if (op != UNSPEC)
140: usage();
141: op = WRITE;
142: break;
143: #ifdef DEBUG
144: case 'd':
145: debug++;
146: break;
147: #endif
148: case '?':
149: default:
150: usage();
151: }
152: argc -= optind;
153: argv += optind;
154: if (op == UNSPEC)
155: op = READ;
156: if (argc < 1)
157: usage();
158:
159: dkname = argv[0];
160: if (dkname[0] != '/') {
161: (void)sprintf(np, "%s/r%s%c", _PATH_DEV, dkname, RAWPARTITION);
162: specname = np;
163: np += strlen(specname) + 1;
164: } else
165: specname = dkname;
166: f = open(specname, op == READ ? O_RDONLY : O_RDWR);
167: if (f < 0 && errno == ENOENT && dkname[0] != '/') {
168: (void)sprintf(specname, "%s/r%s", _PATH_DEV, dkname);
169: np = namebuf + strlen(specname) + 1;
170: f = open(specname, op == READ ? O_RDONLY : O_RDWR);
171: }
172: if (f < 0)
173: Perror(specname);
174:
175: switch(op) {
176: case EDIT:
177: if (argc != 1)
178: usage();
179: lp = readlabel(f);
180: error = edit(lp, f);
181: break;
182: case NOWRITE: {
183: int flag = 0;
184: if (ioctl(f, DIOCWLABEL, (char *)&flag) < 0)
185: Perror("ioctl DIOCWLABEL");
186: break;
187: }
188: case READ:
189: if (argc != 1)
190: usage();
191: lp = readlabel(f);
192: display(stdout, lp);
193: error = checklabel(lp);
194: break;
195: case RESTORE:
196: #ifdef BOOT
197: if (rflag) {
198: if (argc == 4) { /* [ priboot secboot ] */
199: xxboot = argv[2];
200: bootxx = argv[3];
201: lab.d_secsize = DEV_BSIZE; /* XXX */
202: lab.d_bbsize = BBSIZE; /* XXX */
203: }
204: else if (argc == 3) /* [ disktype ] */
205: makelabel(argv[2], (char *)NULL, &lab);
206: else {
207: fprintf(stderr,
208: "Must specify either disktype or bootfiles with -r flag of RESTORE option\n");
209: exit(1);
210: }
211: }
212: else
213: #endif
214: if (argc != 2)
215: usage();
216: lp = makebootarea(bootarea, &lab);
217: if (!(t = fopen(argv[1],"r")))
218: Perror(argv[1]);
219: if (getasciilabel(t, lp))
220: error = writelabel(f, bootarea, lp);
221: break;
222: case WRITE:
223: type = argv[1];
224: #ifdef BOOT
225: if (argc > 5 || argc < 2)
226: usage();
227: if (argc > 3) {
228: bootxx = argv[--argc];
229: xxboot = argv[--argc];
230: }
231: #else
232: if (argc > 3 || argc < 2)
233: usage();
234: #endif
235: if (argc > 2)
236: name = argv[--argc];
237: makelabel(type, name, &lab);
238: lp = makebootarea(bootarea, &lab);
239: *lp = lab;
240: if (checklabel(lp) == 0)
241: error = writelabel(f, bootarea, lp);
242: break;
243: case WRITEABLE: {
244: int flag = 1;
245: if (ioctl(f, DIOCWLABEL, (char *)&flag) < 0)
246: Perror("ioctl DIOCWLABEL");
247: break;
248: }
249: }
250: exit(error);
251: }
252:
253: /*
254: * Construct a prototype disklabel from /etc/disktab. As a side
255: * effect, set the names of the primary and secondary boot files
256: * if specified.
257: */
258: makelabel(type, name, lp)
259: char *type, *name;
260: register struct disklabel *lp;
261: {
262: register struct disklabel *dp;
263: char *strcpy();
264:
265: dp = getdiskbyname(type);
266: if (dp == NULL) {
267: fprintf(stderr, "%s: unknown disk type\n", type);
268: exit(1);
269: }
270: *lp = *dp;
271: #ifdef BOOT
272: /*
273: * Check if disktab specifies the bootstraps (b0 or b1).
274: */
275: if (!xxboot && lp->d_boot0) {
276: if (*lp->d_boot0 != '/')
277: (void)sprintf(boot0, "%s/%s", BOOTDIR, lp->d_boot0);
278: else
279: (void)strcpy(boot0, lp->d_boot0);
280: xxboot = boot0;
281: }
282: if (!bootxx && lp->d_boot1) {
283: if (*lp->d_boot1 != '/')
284: (void)sprintf(boot1, "%s/%s", BOOTDIR, lp->d_boot1);
285: else
286: (void)strcpy(boot1, lp->d_boot1);
287: bootxx = boot1;
288: }
289: /*
290: * If bootstraps not specified anywhere, makebootarea()
291: * will choose ones based on the name of the disk special
292: * file. E.g. /dev/ra0 -> raboot, bootra
293: */
294: #endif /*BOOT*/
295: /* d_packname is union d_boot[01], so zero */
296: bzero(lp->d_packname, sizeof(lp->d_packname));
297: if (name)
298: (void)strncpy(lp->d_packname, name, sizeof(lp->d_packname));
299: }
300:
301: writelabel(f, boot, lp)
302: int f;
303: char *boot;
304: register struct disklabel *lp;
305: {
306: register int i;
307: int flag;
308: off_t lseek();
309:
310: lp->d_magic = DISKMAGIC;
311: lp->d_magic2 = DISKMAGIC;
312: lp->d_checksum = 0;
313: lp->d_checksum = dkcksum(lp);
314: if (rflag) {
315: /*
316: * First set the kernel disk label,
317: * then write a label to the raw disk.
318: * If the SDINFO ioctl fails because it is unimplemented,
319: * keep going; otherwise, the kernel consistency checks
320: * may prevent us from changing the current (in-core)
321: * label.
322: */
323: if (ioctl(f, DIOCSDINFO, lp) < 0 &&
324: errno != ENODEV && errno != ENOTTY) {
325: l_perror("ioctl DIOCSDINFO");
326: return (1);
327: }
328: (void)lseek(f, (off_t)0, L_SET);
329: /*
330: * write enable label sector before write (if necessary),
331: * disable after writing.
332: */
333: flag = 1;
334: if (ioctl(f, DIOCWLABEL, &flag) < 0)
335: perror("ioctl DIOCWLABEL");
336: if (write(f, boot, lp->d_bbsize) != lp->d_bbsize) {
337: perror("write");
338: return (1);
339: }
340: flag = 0;
341: (void) ioctl(f, DIOCWLABEL, &flag);
342: } else if (ioctl(f, DIOCWDINFO, lp) < 0) {
343: l_perror("ioctl DIOCWDINFO");
344: return (1);
345: }
346: #ifdef vax
347: if (lp->d_type == DTYPE_SMD && lp->d_flags & D_BADSECT) {
348: daddr_t alt;
349:
350: alt = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors;
351: for (i = 1; i < 11 && i < lp->d_nsectors; i += 2) {
352: (void)lseek(f, (off_t)((alt + i) * lp->d_secsize), L_SET);
353: if (write(f, boot, lp->d_secsize) < lp->d_secsize) {
354: int oerrno = errno;
355: fprintf(stderr, "alternate label %d ", i/2);
356: errno = oerrno;
357: perror("write");
358: }
359: }
360: }
361: #endif
362: return (0);
363: }
364:
365: l_perror(s)
366: char *s;
367: {
368: int saverrno = errno;
369:
370: fprintf(stderr, "disklabel: %s: ", s);
371:
372: switch (saverrno) {
373:
374: case ESRCH:
375: fprintf(stderr, "No disk label on disk;\n");
376: fprintf(stderr,
377: "use \"disklabel -r\" to install initial label\n");
378: break;
379:
380: case EINVAL:
381: fprintf(stderr, "Label magic number or checksum is wrong!\n");
382: fprintf(stderr, "(disklabel or kernel is out of date?)\n");
383: break;
384:
385: case EBUSY:
386: fprintf(stderr, "Open partition would move or shrink\n");
387: break;
388:
389: case EXDEV:
390: fprintf(stderr,
391: "Labeled partition or 'a' partition must start at beginning of disk\n");
392: break;
393:
394: default:
395: errno = saverrno;
396: perror((char *)NULL);
397: break;
398: }
399: }
400:
401: /*
402: * Fetch disklabel for disk.
403: * Use ioctl to get label unless -r flag is given.
404: */
405: struct disklabel *
406: readlabel(f)
407: int f;
408: {
409: register struct disklabel *lp;
410:
411: if (rflag) {
412: if (read(f, bootarea, BBSIZE) < BBSIZE)
413: Perror(specname);
414: for (lp = (struct disklabel *)bootarea;
415: lp <= (struct disklabel *)(bootarea + BBSIZE - sizeof(*lp));
416: lp = (struct disklabel *)((char *)lp + 16))
417: if (lp->d_magic == DISKMAGIC &&
418: lp->d_magic2 == DISKMAGIC)
419: break;
420: if (lp > (struct disklabel *)(bootarea+BBSIZE-sizeof(*lp)) ||
421: lp->d_magic != DISKMAGIC || lp->d_magic2 != DISKMAGIC ||
422: dkcksum(lp) != 0) {
423: fprintf(stderr,
424: "Bad pack magic number (label is damaged, or pack is unlabeled)\n");
425: /* lp = (struct disklabel *)(bootarea + LABELOFFSET); */
426: exit (1);
427: }
428: } else {
429: lp = &lab;
430: if (ioctl(f, DIOCGDINFO, lp) < 0)
431: Perror("ioctl DIOCGDINFO");
432: }
433: return (lp);
434: }
435:
436: struct disklabel *
437: makebootarea(boot, dp)
438: char *boot;
439: register struct disklabel *dp;
440: {
441: struct disklabel *lp;
442: register char *p;
443: int b;
444: #ifdef BOOT
445: char *dkbasename;
446: #endif /*BOOT*/
447:
448: lp = (struct disklabel *)(boot + (LABELSECTOR * dp->d_secsize) +
449: LABELOFFSET);
450: #ifdef BOOT
451: if (!rflag)
452: return (lp);
453:
454: if (xxboot == NULL || bootxx == NULL) {
455: dkbasename = np;
456: if ((p = rindex(dkname, '/')) == NULL)
457: p = dkname;
458: else
459: p++;
460: while (*p && !isdigit(*p))
461: *np++ = *p++;
462: *np++ = '\0';
463:
464: if (xxboot == NULL) {
465: (void)sprintf(np, "%s/%sboot", BOOTDIR, dkbasename);
466: if (access(np, F_OK) < 0 && dkbasename[0] == 'r')
467: dkbasename++;
468: xxboot = np;
469: (void)sprintf(xxboot, "%s/%sboot", BOOTDIR, dkbasename);
470: np += strlen(xxboot) + 1;
471: }
472: if (bootxx == NULL) {
473: (void)sprintf(np, "%s/boot%s", BOOTDIR, dkbasename);
474: if (access(np, F_OK) < 0 && dkbasename[0] == 'r')
475: dkbasename++;
476: bootxx = np;
477: (void)sprintf(bootxx, "%s/boot%s", BOOTDIR, dkbasename);
478: np += strlen(bootxx) + 1;
479: }
480: }
481: #ifdef DEBUG
482: if (debug)
483: fprintf(stderr, "bootstraps: xxboot = %s, bootxx = %s\n",
484: xxboot, bootxx);
485: #endif
486:
487: b = open(xxboot, O_RDONLY);
488: if (b < 0)
489: Perror(xxboot);
490: if (read(b, boot, (int)dp->d_secsize) < 0)
491: Perror(xxboot);
492: close(b);
493: b = open(bootxx, O_RDONLY);
494: if (b < 0)
495: Perror(bootxx);
496: if (read(b, &boot[dp->d_secsize], (int)(dp->d_bbsize-dp->d_secsize)) < 0)
497: Perror(bootxx);
498: (void)close(b);
499: #endif /*BOOT*/
500:
501: for (p = (char *)lp; p < (char *)lp + sizeof(struct disklabel); p++)
502: if (*p) {
503: fprintf(stderr,
504: "Bootstrap doesn't leave room for disk label\n");
505: exit(2);
506: }
507: return (lp);
508: }
509:
510: display(f, lp)
511: FILE *f;
512: register struct disklabel *lp;
513: {
514: register int i, j;
515: register struct partition *pp;
516:
517: fprintf(f, "# %s:\n", specname);
518: if ((unsigned) lp->d_type < DKMAXTYPES)
519: fprintf(f, "type: %s\n", dktypenames[lp->d_type]);
520: else
521: fprintf(f, "type: %d\n", lp->d_type);
522: fprintf(f, "disk: %.*s\n", sizeof(lp->d_typename), lp->d_typename);
523: fprintf(f, "label: %.*s\n", sizeof(lp->d_packname), lp->d_packname);
524: fprintf(f, "flags:");
525: if (lp->d_flags & D_REMOVABLE)
526: fprintf(f, " removeable");
527: if (lp->d_flags & D_ECC)
528: fprintf(f, " ecc");
529: if (lp->d_flags & D_BADSECT)
530: fprintf(f, " badsect");
531: fprintf(f, "\n");
532: fprintf(f, "bytes/sector: %d\n", lp->d_secsize);
533: fprintf(f, "sectors/track: %d\n", lp->d_nsectors);
534: fprintf(f, "tracks/cylinder: %d\n", lp->d_ntracks);
535: fprintf(f, "sectors/cylinder: %d\n", lp->d_secpercyl);
536: fprintf(f, "cylinders: %d\n", lp->d_ncylinders);
537: fprintf(f, "rpm: %d\n", lp->d_rpm);
538: fprintf(f, "interleave: %d\n", lp->d_interleave);
539: fprintf(f, "trackskew: %d\n", lp->d_trackskew);
540: fprintf(f, "cylinderskew: %d\n", lp->d_cylskew);
541: fprintf(f, "headswitch: %d\t\t# milliseconds\n", lp->d_headswitch);
542: fprintf(f, "track-to-track seek: %d\t# milliseconds\n", lp->d_trkseek);
543: fprintf(f, "drivedata: ");
544: for (i = NDDATA - 1; i >= 0; i--)
545: if (lp->d_drivedata[i])
546: break;
547: if (i < 0)
548: i = 0;
549: for (j = 0; j <= i; j++)
550: fprintf(f, "%d ", lp->d_drivedata[j]);
551: fprintf(f, "\n\n%d partitions:\n", lp->d_npartitions);
552: fprintf(f,
553: "# size offset fstype [fsize bsize cpg]\n");
554: pp = lp->d_partitions;
555: for (i = 0; i < lp->d_npartitions; i++, pp++) {
556: if (pp->p_size) {
557: fprintf(f, " %c: %8d %8d ", 'a' + i,
558: pp->p_size, pp->p_offset);
559: if ((unsigned) pp->p_fstype < FSMAXTYPES)
560: fprintf(f, "%8.8s", fstypenames[pp->p_fstype]);
561: else
562: fprintf(f, "%8d", pp->p_fstype);
563: switch (pp->p_fstype) {
564:
565: case FS_UNUSED: /* XXX */
566: fprintf(f, " %5d %5d %5.5s ",
567: pp->p_fsize, pp->p_fsize * pp->p_frag, "");
568: break;
569:
570: case FS_BSDFFS:
571: fprintf(f, " %5d %5d %5d ",
572: pp->p_fsize, pp->p_fsize * pp->p_frag,
573: pp->p_cpg);
574: break;
575:
576: default:
577: fprintf(f, "%20.20s", "");
578: break;
579: }
580: fprintf(f, "\t# (Cyl. %4d",
581: pp->p_offset / lp->d_secpercyl);
582: if (pp->p_offset % lp->d_secpercyl)
583: putc('*', f);
584: else
585: putc(' ', f);
586: fprintf(f, "- %d",
587: (pp->p_offset +
588: pp->p_size + lp->d_secpercyl - 1) /
589: lp->d_secpercyl - 1);
590: if (pp->p_size % lp->d_secpercyl)
591: putc('*', f);
592: fprintf(f, ")\n");
593: }
594: }
595: fflush(f);
596: }
597:
598: edit(lp, f)
599: struct disklabel *lp;
600: int f;
601: {
602: register int c;
603: struct disklabel label;
604: FILE *fd;
605: char *mktemp();
606:
607: (void) mktemp(tmpfil);
608: fd = fopen(tmpfil, "w");
609: if (fd == NULL) {
610: fprintf(stderr, "%s: Can't create\n", tmpfil);
611: return (1);
612: }
613: (void)fchmod(fd, 0600);
614: display(fd, lp);
615: fclose(fd);
616: for (;;) {
617: if (!editit())
618: break;
619: fd = fopen(tmpfil, "r");
620: if (fd == NULL) {
621: fprintf(stderr, "%s: Can't reopen for reading\n",
622: tmpfil);
623: break;
624: }
625: bzero((char *)&label, sizeof(label));
626: if (getasciilabel(fd, &label)) {
627: *lp = label;
628: if (writelabel(f, bootarea, lp) == 0) {
629: (void) unlink(tmpfil);
630: return (0);
631: }
632: }
633: printf("re-edit the label? [y]: "); fflush(stdout);
634: c = getchar();
635: if (c != EOF && c != (int)'\n')
636: while (getchar() != (int)'\n')
637: ;
638: if (c == (int)'n')
639: break;
640: }
641: (void) unlink(tmpfil);
642: return (1);
643: }
644:
645: editit()
646: {
647: register int pid, xpid;
648: int stat, omask;
649: extern char *getenv();
650:
651: omask = sigblock(sigmask(SIGINT)|sigmask(SIGQUIT)|sigmask(SIGHUP));
652: while ((pid = fork()) < 0) {
653: extern int errno;
654:
655: if (errno == EPROCLIM) {
656: fprintf(stderr, "You have too many processes\n");
657: return(0);
658: }
659: if (errno != EAGAIN) {
660: perror("fork");
661: return(0);
662: }
663: sleep(1);
664: }
665: if (pid == 0) {
666: register char *ed;
667:
668: sigsetmask(omask);
669: setgid(getgid());
670: setuid(getuid());
671: if ((ed = getenv("EDITOR")) == (char *)0)
672: ed = DEFEDITOR;
673: execlp(ed, ed, tmpfil, 0);
674: perror(ed);
675: exit(1);
676: }
677: while ((xpid = wait(&stat)) >= 0)
678: if (xpid == pid)
679: break;
680: sigsetmask(omask);
681: return(!stat);
682: }
683:
684: char *
685: skip(cp)
686: register char *cp;
687: {
688:
689: while (*cp != '\0' && isspace(*cp))
690: cp++;
691: if (*cp == '\0' || *cp == '#')
692: return ((char *)NULL);
693: return (cp);
694: }
695:
696: char *
697: word(cp)
698: register char *cp;
699: {
700: register char c;
701:
702: while (*cp != '\0' && !isspace(*cp) && *cp != '#')
703: cp++;
704: if ((c = *cp) != '\0') {
705: *cp++ = '\0';
706: if (c != '#')
707: return (skip(cp));
708: }
709: return ((char *)NULL);
710: }
711:
712: /*
713: * Read an ascii label in from fd f,
714: * in the same format as that put out by display(),
715: * and fill in lp.
716: */
717: getasciilabel(f, lp)
718: FILE *f;
719: register struct disklabel *lp;
720: {
721: register char **cpp, *cp;
722: register struct partition *pp;
723: char *tp, *s, line[BUFSIZ];
724: int v, lineno = 0, errors = 0;
725:
726: lp->d_bbsize = BBSIZE; /* XXX */
727: lp->d_sbsize = SBSIZE; /* XXX */
728: while (fgets(line, sizeof(line) - 1, f)) {
729: lineno++;
730: if (cp = index(line,'\n'))
731: *cp = '\0';
732: cp = skip(line);
733: if (cp == NULL)
734: continue;
735: tp = index(cp, ':');
736: if (tp == NULL) {
737: fprintf(stderr, "line %d: syntax error\n", lineno);
738: errors++;
739: continue;
740: }
741: *tp++ = '\0', tp = skip(tp);
742: if (streq(cp, "type")) {
743: if (tp == NULL)
744: tp = "unknown";
745: cpp = dktypenames;
746: for (; cpp < &dktypenames[DKMAXTYPES]; cpp++)
747: if ((s = *cpp) && streq(s, tp)) {
748: lp->d_type = cpp - dktypenames;
749: goto next;
750: }
751: v = atoi(tp);
752: if ((unsigned)v >= DKMAXTYPES)
753: fprintf(stderr, "line %d:%s %d\n", lineno,
754: "Warning, unknown disk type", v);
755: lp->d_type = v;
756: continue;
757: }
758: if (streq(cp, "flags")) {
759: for (v = 0; (cp = tp) && *cp != '\0';) {
760: tp = word(cp);
761: if (streq(cp, "removeable"))
762: v |= D_REMOVABLE;
763: else if (streq(cp, "ecc"))
764: v |= D_ECC;
765: else if (streq(cp, "badsect"))
766: v |= D_BADSECT;
767: else {
768: fprintf(stderr,
769: "line %d: %s: bad flag\n",
770: lineno, cp);
771: errors++;
772: }
773: }
774: lp->d_flags = v;
775: continue;
776: }
777: if (streq(cp, "drivedata")) {
778: register int i;
779:
780: for (i = 0; (cp = tp) && *cp != '\0' && i < NDDATA;) {
781: lp->d_drivedata[i++] = atoi(cp);
782: tp = word(cp);
783: }
784: continue;
785: }
786: if (sscanf(cp, "%d partitions", &v) == 1) {
787: if (v == 0 || (unsigned)v > MAXPARTITIONS) {
788: fprintf(stderr,
789: "line %d: bad # of partitions\n", lineno);
790: lp->d_npartitions = MAXPARTITIONS;
791: errors++;
792: } else
793: lp->d_npartitions = v;
794: continue;
795: }
796: if (tp == NULL)
797: tp = "";
798: if (streq(cp, "disk")) {
799: strncpy(lp->d_typename, tp, sizeof (lp->d_typename));
800: continue;
801: }
802: if (streq(cp, "label")) {
803: strncpy(lp->d_packname, tp, sizeof (lp->d_packname));
804: continue;
805: }
806: if (streq(cp, "bytes/sector")) {
807: v = atoi(tp);
808: if (v <= 0 || (v % 512) != 0) {
809: fprintf(stderr,
810: "line %d: %s: bad sector size\n",
811: lineno, tp);
812: errors++;
813: } else
814: lp->d_secsize = v;
815: continue;
816: }
817: if (streq(cp, "sectors/track")) {
818: v = atoi(tp);
819: if (v <= 0) {
820: fprintf(stderr, "line %d: %s: bad %s\n",
821: lineno, tp, cp);
822: errors++;
823: } else
824: lp->d_nsectors = v;
825: continue;
826: }
827: if (streq(cp, "sectors/cylinder")) {
828: v = atoi(tp);
829: if (v <= 0) {
830: fprintf(stderr, "line %d: %s: bad %s\n",
831: lineno, tp, cp);
832: errors++;
833: } else
834: lp->d_secpercyl = v;
835: continue;
836: }
837: if (streq(cp, "tracks/cylinder")) {
838: v = atoi(tp);
839: if (v <= 0) {
840: fprintf(stderr, "line %d: %s: bad %s\n",
841: lineno, tp, cp);
842: errors++;
843: } else
844: lp->d_ntracks = v;
845: continue;
846: }
847: if (streq(cp, "cylinders")) {
848: v = atoi(tp);
849: if (v <= 0) {
850: fprintf(stderr, "line %d: %s: bad %s\n",
851: lineno, tp, cp);
852: errors++;
853: } else
854: lp->d_ncylinders = v;
855: continue;
856: }
857: if (streq(cp, "rpm")) {
858: v = atoi(tp);
859: if (v <= 0) {
860: fprintf(stderr, "line %d: %s: bad %s\n",
861: lineno, tp, cp);
862: errors++;
863: } else
864: lp->d_rpm = v;
865: continue;
866: }
867: if (streq(cp, "interleave")) {
868: v = atoi(tp);
869: if (v <= 0) {
870: fprintf(stderr, "line %d: %s: bad %s\n",
871: lineno, tp, cp);
872: errors++;
873: } else
874: lp->d_interleave = v;
875: continue;
876: }
877: if (streq(cp, "trackskew")) {
878: v = atoi(tp);
879: if (v < 0) {
880: fprintf(stderr, "line %d: %s: bad %s\n",
881: lineno, tp, cp);
882: errors++;
883: } else
884: lp->d_trackskew = v;
885: continue;
886: }
887: if (streq(cp, "cylinderskew")) {
888: v = atoi(tp);
889: if (v < 0) {
890: fprintf(stderr, "line %d: %s: bad %s\n",
891: lineno, tp, cp);
892: errors++;
893: } else
894: lp->d_cylskew = v;
895: continue;
896: }
897: if (streq(cp, "headswitch")) {
898: v = atoi(tp);
899: if (v < 0) {
900: fprintf(stderr, "line %d: %s: bad %s\n",
901: lineno, tp, cp);
902: errors++;
903: } else
904: lp->d_headswitch = v;
905: continue;
906: }
907: if (streq(cp, "track-to-track seek")) {
908: v = atoi(tp);
909: if (v < 0) {
910: fprintf(stderr, "line %d: %s: bad %s\n",
911: lineno, tp, cp);
912: errors++;
913: } else
914: lp->d_trkseek = v;
915: continue;
916: }
917: if ('a' <= *cp && *cp <= 'z' && cp[1] == '\0') {
918: unsigned part = *cp - 'a';
919:
920: if (part > lp->d_npartitions) {
921: fprintf(stderr,
922: "line %d: bad partition name\n", lineno);
923: errors++;
924: continue;
925: }
926: pp = &lp->d_partitions[part];
927: #define NXTNUM(n) { \
928: cp = tp, tp = word(cp); \
929: if (tp == NULL) \
930: tp = cp; \
931: (n) = atoi(cp); \
932: }
933:
934: NXTNUM(v);
935: if (v < 0) {
936: fprintf(stderr,
937: "line %d: %s: bad partition size\n",
938: lineno, cp);
939: errors++;
940: } else
941: pp->p_size = v;
942: NXTNUM(v);
943: if (v < 0) {
944: fprintf(stderr,
945: "line %d: %s: bad partition offset\n",
946: lineno, cp);
947: errors++;
948: } else
949: pp->p_offset = v;
950: cp = tp, tp = word(cp);
951: cpp = fstypenames;
952: for (; cpp < &fstypenames[FSMAXTYPES]; cpp++)
953: if ((s = *cpp) && streq(s, cp)) {
954: pp->p_fstype = cpp - fstypenames;
955: goto gottype;
956: }
957: if (isdigit(*cp))
958: v = atoi(cp);
959: else
960: v = FSMAXTYPES;
961: if ((unsigned)v >= FSMAXTYPES) {
962: fprintf(stderr, "line %d: %s %s\n", lineno,
963: "Warning, unknown filesystem type", cp);
964: v = FS_UNUSED;
965: }
966: pp->p_fstype = v;
967: gottype:
968:
969: switch (pp->p_fstype) {
970:
971: case FS_UNUSED: /* XXX */
972: NXTNUM(pp->p_fsize);
973: if (pp->p_fsize == 0)
974: break;
975: NXTNUM(v);
976: pp->p_frag = v / pp->p_fsize;
977: break;
978:
979: case FS_BSDFFS:
980: NXTNUM(pp->p_fsize);
981: if (pp->p_fsize == 0)
982: break;
983: NXTNUM(v);
984: pp->p_frag = v / pp->p_fsize;
985: NXTNUM(pp->p_cpg);
986: break;
987:
988: default:
989: break;
990: }
991: continue;
992: }
993: fprintf(stderr, "line %d: %s: Unknown disklabel field\n",
994: lineno, cp);
995: errors++;
996: next:
997: ;
998: }
999: errors += checklabel(lp);
1000: return (errors == 0);
1001: }
1002:
1003: /*
1004: * Check disklabel for errors and fill in
1005: * derived fields according to supplied values.
1006: */
1007: checklabel(lp)
1008: register struct disklabel *lp;
1009: {
1010: register struct partition *pp;
1011: int i, errors = 0;
1012: char part;
1013:
1014: if (lp->d_secsize == 0) {
1015: fprintf(stderr, "sector size %d\n", lp->d_secsize);
1016: return (1);
1017: }
1018: if (lp->d_nsectors == 0) {
1019: fprintf(stderr, "sectors/track %d\n", lp->d_nsectors);
1020: return (1);
1021: }
1022: if (lp->d_ntracks == 0) {
1023: fprintf(stderr, "tracks/cylinder %d\n", lp->d_ntracks);
1024: return (1);
1025: }
1026: if (lp->d_ncylinders == 0) {
1027: fprintf(stderr, "cylinders/unit %d\n", lp->d_ncylinders);
1028: errors++;
1029: }
1030: if (lp->d_rpm == 0)
1031: Warning("revolutions/minute %d\n", lp->d_rpm);
1032: if (lp->d_secpercyl == 0)
1033: lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
1034: if (lp->d_secperunit == 0)
1035: lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
1036: if (lp->d_bbsize == 0) {
1037: fprintf(stderr, "boot block size %d\n", lp->d_bbsize);
1038: errors++;
1039: } else if (lp->d_bbsize % lp->d_secsize)
1040: Warning("boot block size %% sector-size != 0\n");
1041: if (lp->d_sbsize == 0) {
1042: fprintf(stderr, "super block size %d\n", lp->d_sbsize);
1043: errors++;
1044: } else if (lp->d_sbsize % lp->d_secsize)
1045: Warning("super block size %% sector-size != 0\n");
1046: if (lp->d_npartitions > MAXPARTITIONS)
1047: Warning("number of partitions (%d) > MAXPARTITIONS (%d)\n",
1048: lp->d_npartitions, MAXPARTITIONS);
1049: for (i = 0; i < lp->d_npartitions; i++) {
1050: part = 'a' + i;
1051: pp = &lp->d_partitions[i];
1052: if (pp->p_size == 0 && pp->p_offset != 0)
1053: Warning("partition %c: size 0, but offset %d\n",
1054: part, pp->p_offset);
1055: #ifdef notdef
1056: if (pp->p_size % lp->d_secpercyl)
1057: Warning("partition %c: size %% cylinder-size != 0\n",
1058: part);
1059: if (pp->p_offset % lp->d_secpercyl)
1060: Warning("partition %c: offset %% cylinder-size != 0\n",
1061: part);
1062: #endif
1063: if (pp->p_offset > lp->d_secperunit) {
1064: fprintf(stderr,
1065: "partition %c: offset past end of unit\n", part);
1066: errors++;
1067: }
1068: if (pp->p_offset + pp->p_size > lp->d_secperunit) {
1069: fprintf(stderr,
1070: "partition %c: partition extends past end of unit\n",
1071: part);
1072: errors++;
1073: }
1074: }
1075: for (; i < MAXPARTITIONS; i++) {
1076: part = 'a' + i;
1077: pp = &lp->d_partitions[i];
1078: if (pp->p_size || pp->p_offset)
1079: Warning("unused partition %c: size %d offset %d\n",
1080: 'a' + i, pp->p_size, pp->p_offset);
1081: }
1082: return (errors);
1083: }
1084:
1085: /*VARARGS1*/
1086: Warning(fmt, a1, a2, a3, a4, a5)
1087: char *fmt;
1088: {
1089:
1090: fprintf(stderr, "Warning, ");
1091: fprintf(stderr, fmt, a1, a2, a3, a4, a5);
1092: fprintf(stderr, "\n");
1093: }
1094:
1095: Perror(str)
1096: char *str;
1097: {
1098: fputs("disklabel: ", stderr); perror(str);
1099: exit(4);
1100: }
1101:
1102: usage()
1103: {
1104: #ifdef BOOT
1105: fprintf(stderr, "%-62s%s\n%-62s%s\n%-62s%s\n%-62s%s\n%-62s%s\n",
1106: "usage: disklabel [-r] disk", "(to read label)",
1107: "or disklabel -w [-r] disk type [ packid ] [ xxboot bootxx ]", "(to write label)",
1108: "or disklabel -e [-r] disk", "(to edit label)",
1109: "or disklabel -R [-r] disk protofile [ type | xxboot bootxx ]", "(to restore label)",
1110: "or disklabel [-NW] disk", "(to write disable/enable label)");
1111: #else
1112: fprintf(stderr, "%-43s%s\n%-43s%s\n%-43s%s\n%-43s%s\n%-43s%s\n",
1113: "usage: disklabel [-r] disk", "(to read label)",
1114: "or disklabel -w [-r] disk type [ packid ]", "(to write label)",
1115: "or disklabel -e [-r] disk", "(to edit label)",
1116: "or disklabel -R [-r] disk protofile", "(to restore label)",
1117: "or disklabel [-NW] disk", "(to write disable/enable label)");
1118: #endif
1119: exit(1);
1120: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.