main.c revision 1.59 1 /* $NetBSD: main.c,v 1.59 2025/01/19 04:37:15 tsutsui Exp $ */
2
3 /*
4 * Copyright (c) 2006 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Julio M. Merino Vidal.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * Copyright (c) 1987, 1993
34 * The Regents of the University of California. All rights reserved.
35 *
36 * This code is derived from software contributed to Berkeley by
37 * Symmetric Computer Systems.
38 *
39 * Redistribution and use in source and binary forms, with or without
40 * modification, are permitted provided that the following conditions
41 * are met:
42 * 1. Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * 2. Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in the
46 * documentation and/or other materials provided with the distribution.
47 * 3. Neither the name of the University nor the names of its contributors
48 * may be used to endorse or promote products derived from this software
49 * without specific prior written permission.
50 *
51 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
54 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
61 * SUCH DAMAGE.
62 */
63
64 #if HAVE_NBTOOL_CONFIG_H
65 #include "nbtool_config.h"
66 #endif
67
68 #include <sys/cdefs.h>
69 #ifndef lint
70 __COPYRIGHT("@(#) Copyright (c) 1987, 1993\
71 The Regents of the University of California. All rights reserved.");
72 #endif /* not lint */
73
74 #ifndef lint
75 #if 0
76 static char sccsid[] = "@(#)disklabel.c 8.4 (Berkeley) 5/4/95";
77 /* from static char sccsid[] = "@(#)disklabel.c 1.2 (Symmetric) 11/28/85"; */
78 #else
79 __RCSID("$NetBSD: main.c,v 1.59 2025/01/19 04:37:15 tsutsui Exp $");
80 #endif
81 #endif /* not lint */
82
83 #include <sys/param.h>
84 #include <sys/file.h>
85 #include <sys/stat.h>
86 #include <sys/wait.h>
87 #define DKTYPENAMES
88 #define FSTYPENAMES
89
90 #include <ctype.h>
91 #include <err.h>
92 #include <errno.h>
93 #include <signal.h>
94 #include <string.h>
95 #include <stdio.h>
96 #include <stdlib.h>
97 #include <limits.h>
98 #include <unistd.h>
99
100 #include <ufs/ufs/dinode.h>
101 #include <ufs/ffs/fs.h>
102
103 #if HAVE_NBTOOL_CONFIG_H
104 #include <nbinclude/sys/disklabel.h>
105 #include <nbinclude/sys/disklabel_acorn.h>
106 #include <nbinclude/sys/bootblock.h>
107 #include "../../include/disktab.h"
108 #else
109 #include <sys/ioctl.h>
110 #include <sys/disklabel.h>
111 #include <sys/disklabel_acorn.h>
112 #include <sys/bootblock.h>
113 #include <util.h>
114 #include <disktab.h>
115 #endif /* HAVE_NBTOOL_CONFIG_H */
116
117 #include "pathnames.h"
118 #include "extern.h"
119 #include "dkcksum.h"
120 #include "bswap.h"
121
122 /*
123 * Disklabel: read and write disklabels.
124 * The label is usually placed on one of the first sectors of the disk.
125 * Many machines also place a bootstrap in the same area,
126 * in which case the label is embedded in the bootstrap.
127 * The bootstrap source must leave space at the proper offset
128 * for the label on such machines.
129 */
130
131 #ifndef BBSIZE
132 #define BBSIZE 8192 /* size of boot area, with label */
133 #endif
134
135 #define DISKMAGIC_REV bswap32(DISKMAGIC)
136 /* To delete a label, we just invert the magic numbers */
137 #define DISKMAGIC_DELETED (~DISKMAGIC)
138 #define DISKMAGIC_DELETED_REV bswap32(~DISKMAGIC)
139
140 #define DEFEDITOR _PATH_VI
141
142 char specname[MAXPATHLEN];
143
144 /* Some global data, all too hard to pass about */
145 char bootarea[BBSIZE]; /* Buffer matching part of disk */
146 int bootarea_len; /* Number of bytes we actually read */
147 static struct disklabel lab; /* The label we have updated */
148
149 static int Aflag; /* Action all labels */
150 static int Fflag; /* Read/write from file */
151 static int rflag; /* Read/write direct from disk */
152 static int tflag; /* Format output as disktab */
153 int Cflag; /* CHS format output */
154 static int Dflag; /* Delete old labels (use with write) */
155 static int Iflag; /* Read/write direct, but default if absent */
156 static int lflag; /* List all known file system types and exit */
157 static int verbose;
158 static int read_all; /* set if op = READ && Aflag */
159
160 static int write_label(int);
161 static int readlabel_direct(int);
162 static void writelabel_direct(int);
163 static int update_label(int, u_int, u_int);
164 static struct disklabel *find_label(int, u_int);
165 #if !defined(NATIVELABEL_ONLY)
166 static void getmachineparams(const char *);
167 #endif
168
169 static void makedisktab(FILE *, struct disklabel *);
170 static void makelabel(const char *, const char *);
171 static void l_perror(const char *);
172 static void readlabel(int);
173 static int edit(int);
174 static int editit(const char *);
175 static char *skip(char *);
176 static char *word(char *);
177 static int getasciilabel(FILE *, struct disklabel *);
178 __dead static void usage(void);
179 static int qsort_strcmp(const void *, const void *);
180 static int getulong(const char *, char, char **,
181 unsigned long *, unsigned long);
182 #define GETNUM32(a, v) getulong(a, '\0', NULL, v, UINT32_MAX)
183 #define GETNUM16(a, v) getulong(a, '\0', NULL, v, UINT16_MAX)
184 #define GETNUM8(a, v) getulong(a, '\0', NULL, v, UINT8_MAX)
185
186 static int set_writable_fd = -1;
187
188 #if !defined(NATIVELABEL_ONLY)
189 static u_int labeloffset;
190 static u_int labelsector;
191 static int labelusesmbr;
192 u_int maxpartitions;
193 static int byteorder;
194
195 static int biendian_p;
196 #ifndef HAVE_NBTOOL_CONFIG_H
197 static int native_p = 1;
198 #endif
199 int bswap_p;
200
201 static const struct disklabel_params {
202 const char *machine;
203 u_char labelusesmbr : 1;
204 u_char labelsector : 7;
205 u_char maxpartitions;
206 u_char raw_part;
207 u_char oldmaxpartitions;
208 u_short labeloffset;
209 u_short byteorder;
210 } disklabel_params[] = {
211 { "mvme68k", 0, 0, 8, 2, 0, 0, BIG_ENDIAN }, /* m68k */
212 { "next68k", 0, 0, 8, 2, 0, 0, BIG_ENDIAN }, /* m68k */
213
214 { "algor", 0, 0, 8, 2, 0, 64, LITTLE_ENDIAN }, /* mips */
215 { "alpha", 0, 0, 8, 2, 0, 64, LITTLE_ENDIAN }, /* alpha */
216 { "luna68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
217 { "mac68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
218 { "news68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
219 { "newsmips", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* mips */
220 { "pmax", 0, 0, 8, 2, 0, 64, LITTLE_ENDIAN }, /* mips */
221 { "sun2", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
222 { "sun68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68010 */
223 { "virt68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
224 { "x68k", 0, 0, 8, 2, 0, 64, BIG_ENDIAN }, /* m68k */
225
226 { "vax", 0, 0, 12, 2, 8, 64, LITTLE_ENDIAN }, /* vax */
227
228 { "amiga", 0, 0, 16, 2, 0, 64, BIG_ENDIAN }, /* m68k */
229 { "amigappc", 0, 0, 16, 2, 0, 64, BIG_ENDIAN }, /* powerpc */
230 { "evbmips", 0, 0, 16, 2, 0, 64, 0 }, /* mips */
231 { "evbppc", 0, 0, 16, 2, 0, 64, BIG_ENDIAN }, /* powerpc */
232
233 { "sparc", 0, 0, 8, 2, 0, 128, BIG_ENDIAN }, /* sun */
234 { "sparc64", 0, 0, 8, 2, 0, 128, BIG_ENDIAN }, /* sun */
235 { "sun3", 0, 0, 8, 2, 0, 128, BIG_ENDIAN }, /* sun */
236
237 { "atari", 0, 0, 16, 2, 0, 516, BIG_ENDIAN }, /* m68k */
238
239 { "mipsco", 0, 1, 8, 2, 0, 0, BIG_ENDIAN }, /* mips */
240 { "mvmeppc", 0, 1, 8, 3, 0, 0, BIG_ENDIAN }, /* powerpc */
241
242 { "bebox", 0, 1, 8, 3, 0, 0, BIG_ENDIAN }, /* powerpc */
243
244 { "emips", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* mips */
245 { "hppa", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* hppa */
246 { "ibmnws", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
247 { "ofppc", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
248 { "rs6000", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
249 { "sandpoint", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
250 { "sgimips", 0, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* mips */
251
252 { "sbmips", 0, 1, 16, 3, 0, 0, 0 }, /* mips */
253
254 { "cesfic", 0, 2, 8, 2, 0, 0, BIG_ENDIAN }, /* m68k */
255 { "hp300", 0, 2, 8, 2, 0, 0, BIG_ENDIAN }, /* m68k */
256
257 { "ews4800mips",0, 9, 16, 15, 0, 0, BIG_ENDIAN }, /* mips */
258
259 { "macppc", 1, 0, 16, 2, 0, 64, BIG_ENDIAN }, /* powerpc */
260 { "pmon", 1, 0, 16, 2, 0, 64, 0 }, /* evbmips */
261
262 { "prep", 1, 1, 8, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
263
264 { "dreamcast", 1, 1, 16, 2, 0, 0, LITTLE_ENDIAN }, /* sh3 */
265 { "evbcf", 1, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* coldfire */
266 { "evbppc-mbr", 1, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* powerpc */
267 { "evbsh3", 1, 1, 16, 2, 0, 0, 0 }, /* sh3 */
268 { "hpcsh", 1, 1, 16, 2, 0, 0, LITTLE_ENDIAN }, /* sh3 */
269 { "mmeye", 1, 1, 16, 2, 0, 0, 0 }, /* sh3 */
270 { "or1k", 1, 1, 16, 2, 0, 0, BIG_ENDIAN }, /* or1k */
271 { "riscv", 1, 1, 16, 2, 0, 0, LITTLE_ENDIAN }, /* riscv */
272
273 { "acorn32", 1, 1, 16, 2, 8, 0, LITTLE_ENDIAN }, /* arm */
274 { "cats", 1, 1, 16, 2, 8, 0, LITTLE_ENDIAN }, /* arm */
275 { "evbarm", 1, 1, 16, 2, 8, 0, 0 }, /* arm */
276 { "iyonix", 1, 1, 16, 2, 8, 0, LITTLE_ENDIAN }, /* arm */
277 { "netwinder", 1, 1, 16, 2, 8, 0, LITTLE_ENDIAN }, /* arm */
278 { "shark", 1, 1, 16, 2, 8, 0, LITTLE_ENDIAN }, /* arm */
279
280 { "amd64", 1, 1, 16, 3, 0, 0, LITTLE_ENDIAN }, /* x86 */
281 { "arc", 1, 1, 16, 3, 0, 0, LITTLE_ENDIAN }, /* mips */
282 { "cobalt", 1, 1, 16, 3, 0, 0, LITTLE_ENDIAN }, /* mips */
283 { "landisk", 1, 1, 16, 3, 0, 0, LITTLE_ENDIAN }, /* sh3 */
284
285 { "epoc32", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* arm */
286 { "hpcarm", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* arm */
287 { "hpcmips", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* mips */
288 { "i386", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* x86 */
289 { "ia64", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* x86 */
290 { "zaurus", 1, 1, 16, 3, 8, 0, LITTLE_ENDIAN }, /* arm */
291
292 { NULL, 0, 0, 0, 0, 0, 0, 0 }, /* must be last */
293 };
294
295 #ifndef HAVE_NBTOOL_CONFIG_H
296 static struct disklabel_params native_params;
297 #endif
298
299 static const struct arch_endian {
300 int byteorder;
301 const char *arch;
302 } arch_endians[] = {
303 { LITTLE_ENDIAN, "aarch64" },
304 { LITTLE_ENDIAN, "alpha" },
305 { LITTLE_ENDIAN, "arm" },
306 { LITTLE_ENDIAN, "earm" },
307 { LITTLE_ENDIAN, "earmhf" },
308 { LITTLE_ENDIAN, "earmv4" },
309 { LITTLE_ENDIAN, "earmv5" },
310 { LITTLE_ENDIAN, "earmv6" },
311 { LITTLE_ENDIAN, "earmv6hf" },
312 { LITTLE_ENDIAN, "earmv7" },
313 { LITTLE_ENDIAN, "earmv7hf" },
314 { LITTLE_ENDIAN, "i386" },
315 { LITTLE_ENDIAN, "ia64" },
316 { LITTLE_ENDIAN, "mipsel" },
317 { LITTLE_ENDIAN, "mips64el" },
318 { LITTLE_ENDIAN, "riscv32" },
319 { LITTLE_ENDIAN, "riscv64" },
320 { LITTLE_ENDIAN, "sh3el" },
321 { LITTLE_ENDIAN, "vax" },
322 { LITTLE_ENDIAN, "x86_64" },
323
324 { BIG_ENDIAN, "aarch64eb" },
325 { BIG_ENDIAN, "armeb" },
326 { BIG_ENDIAN, "coldfire" },
327 { BIG_ENDIAN, "earmeb" },
328 { BIG_ENDIAN, "earmhfeb" },
329 { BIG_ENDIAN, "earmv4eb" },
330 { BIG_ENDIAN, "earmv5eb" },
331 { BIG_ENDIAN, "earmv6eb" },
332 { BIG_ENDIAN, "earmv6hfeb" },
333 { BIG_ENDIAN, "earmv7eb" },
334 { BIG_ENDIAN, "earmv7hfeb" },
335 { BIG_ENDIAN, "hppa" },
336 { BIG_ENDIAN, "m68000" },
337 { BIG_ENDIAN, "m68k" },
338 { BIG_ENDIAN, "mipseb" },
339 { BIG_ENDIAN, "mips64eb" },
340 { BIG_ENDIAN, "or1k" },
341 { BIG_ENDIAN, "powerpc" },
342 { BIG_ENDIAN, "sh3eb" },
343 { BIG_ENDIAN, "sparc" },
344 { BIG_ENDIAN, "sparc64" },
345
346 { 0, NULL },
347 };
348
349 /* Default location for label - only used if we don't find one to update */
350 #define LABEL_OFFSET (dklabel_getlabelsector() * DEV_BSIZE + dklabel_getlabeloffset())
351 #else
352 #define labeloffset LABELOFFSET
353 #define labelsector LABELSECTOR
354 #define labelusesmbr LABELUSESMBR
355 #define maxpartitions MAXPARTITIONS
356 #define LABEL_OFFSET (LABELSECTOR * DEV_BSIZE + LABELOFFSET)
357 #endif /* !NATIVELABEL_ONLY */
358
359 /*
360 * For portability it doesn't make sense to use any other value....
361 * Except, maybe, the size of a physical sector.
362 * This value is used if we have to write a label to the start of an mbr ptn.
363 */
364 #ifndef LABELOFFSET_MBR
365 #define LABELOFFSET_MBR 512
366 #endif
367
368 #if HAVE_NBTOOL_CONFIG_H
369 static int
370 opendisk(const char *path, int flags, char *buf, int buflen, int cooked)
371 {
372 int f;
373 f = open(path, flags, 0);
374 strlcpy(buf, path, buflen);
375 return f;
376 }
377 #endif /* HAVE_NBTOOL_CONFIG_H */
378
379 #if !defined(NATIVELABEL_ONLY)
380 static void
381 setbyteorder(int new_byteorder)
382 {
383 static int set_p;
384
385 if ((!biendian_p || set_p)
386 && byteorder != 0
387 && byteorder != new_byteorder) {
388 warnx("changing %s byteorder to %s",
389 byteorder == LITTLE_ENDIAN ? "le" : "be",
390 new_byteorder == LITTLE_ENDIAN ? "le" : "be");
391 }
392 byteorder = new_byteorder;
393 biendian_p = 0;
394 set_p = 1;
395 }
396
397 static void
398 getmachineparams(const char *mach)
399 {
400 const struct disklabel_params *dp = disklabel_params;
401 for (; dp->machine != NULL; dp++) {
402 if (!strcmp(mach, dp->machine)) {
403 labelusesmbr = dp->labelusesmbr;
404 labelsector = dp->labelsector;
405 labeloffset = dp->labeloffset;
406 maxpartitions = dp->maxpartitions;
407 biendian_p = (dp->byteorder == 0);
408 if (!biendian_p)
409 setbyteorder(dp->byteorder);
410 return;
411 }
412 }
413 errx(1, "%s: unknown machine type", mach);
414 }
415
416 static void
417 getarchbyteorder(const char *arch)
418 {
419 const struct arch_endian *p = arch_endians;
420 for (; p->arch != NULL; p++) {
421 if (!strcmp(arch, p->arch)) {
422 setbyteorder(p->byteorder);
423 return;
424 }
425 }
426 errx(1, "%s: unknown arch", arch);
427 }
428
429 static daddr_t
430 dklabel_getlabelsector(void)
431 {
432 unsigned long int nval;
433 char *end;
434 const char *val;
435
436 if ((val = getenv("DISKLABELSECTOR")) == NULL)
437 return labelsector;
438 if ((nval = strtoul(val, &end, 10)) == ULONG_MAX && errno == ERANGE)
439 err(EXIT_FAILURE, "DISKLABELSECTOR in environment");
440 return nval;
441 }
442
443 static off_t
444 dklabel_getlabeloffset(void)
445 {
446 unsigned long int nval;
447 char *end;
448 const char *val;
449
450 if ((val = getenv("DISKLABELOFFSET")) == NULL)
451 return labeloffset;
452 if ((nval = strtoul(val, &end, 10)) == ULONG_MAX && errno == ERANGE)
453 err(EXIT_FAILURE, "DISKLABELOFFSET in environment");
454 return nval;
455 }
456 #endif /* !NATIVELABEL_ONLY */
457
458 static void
459 clear_writable(void)
460 {
461 static int zero = 0;
462 dk_ioctl(set_writable_fd, DIOCWLABEL, &zero);
463 }
464
465 int
466 main(int argc, char *argv[])
467 {
468 FILE *t;
469 int ch, f, error;
470 char *dkname;
471 #if !defined(NATIVELABEL_ONLY)
472 char *cp;
473 #endif
474 struct stat sb;
475 int writable;
476 enum {
477 UNSPEC, EDIT, READ, RESTORE, SETWRITABLE, SETREADONLY,
478 WRITE,
479 #if !defined(NO_INTERACT)
480 INTERACT,
481 #endif
482 DELETE
483 } op = UNSPEC, old_op;
484 #if !defined(NATIVELABEL_ONLY)
485 unsigned long val;
486 #endif
487
488 #ifndef HAVE_NBTOOL_CONFIG_H
489 #if !defined(NATIVELABEL_ONLY)
490 labeloffset = native_params.labeloffset = getlabeloffset();
491 labelsector = native_params.labelsector = getlabelsector();
492 labelusesmbr = native_params.labelusesmbr = getlabelusesmbr();
493 maxpartitions = native_params.maxpartitions = getmaxpartitions();
494 byteorder = native_params.byteorder = BYTE_ORDER;
495 #endif
496 #endif
497
498 #if !defined(NATIVELABEL_ONLY)
499 if ((cp = getenv("MACHINE")) != NULL) {
500 getmachineparams(cp);
501 }
502
503 if ((cp = getenv("MACHINE_ARCH")) != NULL) {
504 getarchbyteorder(cp);
505 }
506 #endif
507
508 #if HAVE_NBTOOL_CONFIG_H
509 /* We must avoid doing any ioctl requests */
510 Fflag = rflag = 1;
511 #endif
512
513 error = 0;
514 #if !defined(NATIVELABEL_ONLY)
515 while ((ch = getopt(argc, argv, "AB:CDFIL:M:NO:P:RWef:ilmnrtvw")) != -1) {
516 #else
517 while ((ch = getopt(argc, argv, "ACDFINRWef:ilrtvw")) != -1) {
518 #endif
519 old_op = op;
520 switch (ch) {
521 case 'A': /* Action all labels */
522 Aflag = 1;
523 rflag = 1;
524 break;
525 case 'C': /* Display in CHS format */
526 Cflag = 1;
527 break;
528 case 'D': /* Delete all existing labels */
529 Dflag = 1;
530 rflag = 1;
531 break;
532 case 'F': /* Treat 'disk' as a regular file */
533 Fflag = 1;
534 rflag = 1; /* Force direct access */
535 break;
536 case 'I': /* Use default label if none found */
537 Iflag = 1;
538 rflag = 1; /* Implies direct access */
539 break;
540 case 'R': /* Restore label from text file */
541 op = RESTORE;
542 break;
543 #if !defined(NATIVELABEL_ONLY)
544 case 'B': /* byteorder */
545 if (!strcmp(optarg, "be")) {
546 setbyteorder(BIG_ENDIAN);
547 } else if (!strcmp(optarg, "le")) {
548 setbyteorder(LITTLE_ENDIAN);
549 } else {
550 errx(1, "%s: not be or le", optarg);
551 }
552 break;
553 case 'M': /* machine type */
554 getmachineparams(optarg);
555 break;
556 #endif
557 case 'N': /* Disallow writes to label sector */
558 op = SETREADONLY;
559 break;
560 #if !defined(NATIVELABEL_ONLY)
561 case 'L': /* Label sector */
562 val = strtoul(optarg, NULL, 10);
563 if ((val == ULONG_MAX && errno == ERANGE) || val > UINT_MAX)
564 err(EXIT_FAILURE, "invalid label sector: %s", optarg);
565 labelsector = val;
566 break;
567 case 'O': /* Label offset */
568 val = strtoul(optarg, NULL, 10);
569 if ((val == ULONG_MAX && errno == ERANGE) || val > UINT_MAX)
570 err(EXIT_FAILURE, "invalid label offset: %s", optarg);
571 labeloffset = val;
572 break;
573 case 'P': /* Max partitions */
574 val = strtoul(optarg, NULL, 10);
575 if ((val == ULONG_MAX && errno == ERANGE) || val < 1 || val > UINT_MAX)
576 err(EXIT_FAILURE, "invalid max partitions: %s", optarg);
577 maxpartitions = val;
578 break;
579 #endif
580 case 'W': /* Allow writes to label sector */
581 op = SETWRITABLE;
582 break;
583 case 'e': /* Edit label with $EDITOR */
584 op = EDIT;
585 break;
586 case 'f': /* Name of disktab file */
587 if (setdisktab(optarg) == -1)
588 usage();
589 break;
590 #if !defined(NO_INTERACT)
591 case 'i': /* Edit using built-in editor */
592 op = INTERACT;
593 break;
594 #endif /* !NO_INTERACT */
595 case 'l': /* List all known file system types and exit */
596 lflag = 1;
597 break;
598 #if !defined(NATIVELABEL_ONLY)
599 case 'm': /* Expect disk to have an MBR */
600 labelusesmbr = 1;
601 break;
602 case 'n': /* Expect disk to not have an MBR */
603 labelusesmbr = 0;
604 break;
605 #endif
606 case 'r': /* Read/write label directly from disk */
607 rflag = 1;
608 break;
609 case 't': /* Format output as a disktab entry */
610 tflag = 1;
611 break;
612 case 'v': /* verbose/diag output */
613 verbose++;
614 break;
615 case 'w': /* Write label based on disktab entry */
616 op = WRITE;
617 break;
618 case '?':
619 default:
620 usage();
621 }
622 if (old_op != UNSPEC && old_op != op)
623 usage();
624 }
625
626 if (maxpartitions > MAXPARTITIONS) {
627 errx(1, "too large maxpartitions > %u\n", MAXPARTITIONS);
628 }
629
630 #if !defined(NATIVELABEL_ONLY)
631 if (maxpartitions == 0) {
632 errx(1, "unknown label: use -M/-B and $MACHINE/$MACHINE_ARCH");
633 }
634 if (byteorder != BIG_ENDIAN && byteorder != LITTLE_ENDIAN) {
635 errx(1, "unknown byteorder");
636 }
637 bswap_p = (byteorder != BYTE_ORDER);
638 #ifdef DEBUG
639 printf("labelusesmbr=%d labelsector=%u labeloffset=%u maxpartitions=%u\n",
640 labelusesmbr, labelsector, labeloffset, maxpartitions);
641 printf("byteorder=%d bswap_p=%d\n", byteorder, bswap_p);
642 #endif
643 #ifndef HAVE_NBTOOL_CONFIG_H
644 /*
645 * If the disklabel has the same location as the native disklabel and
646 * fewer or equal partitions, we can use the native ioctls. Otherwise
647 * force file/raw access.
648 */
649 native_p = native_params.labelusesmbr == labelusesmbr
650 && native_params.labelsector == labelsector
651 && native_params.labeloffset == labeloffset
652 && maxpartitions <= native_params.maxpartitions
653 && !bswap_p;
654 if (!native_p)
655 Fflag = rflag = 1;
656 #endif
657 #endif /* !NATIVELABEL_ONLY */
658
659 argc -= optind;
660 argv += optind;
661
662 if (lflag)
663 exit(list_fs_types() ? EXIT_SUCCESS : EXIT_FAILURE);
664
665 if (op == UNSPEC)
666 op = Dflag ? DELETE : READ;
667
668 if (argc < 1)
669 usage();
670
671 if (Iflag && op != EDIT
672 #if !defined(NO_INTERACT)
673 && op != INTERACT
674 #endif
675 )
676 usage();
677
678 dkname = argv[0];
679 f = opendisk(dkname, op == READ ? O_RDONLY : O_RDWR,
680 specname, sizeof specname, 0);
681 if (f < 0)
682 err(4, "%s", specname);
683
684 if (!Fflag && fstat(f, &sb) == 0 && S_ISREG(sb.st_mode))
685 Fflag = rflag = 1;
686
687 switch (op) {
688
689 case DELETE: /* Remove all existing labels */
690 if (argc != 1)
691 usage();
692 Dflag = 2;
693 writelabel_direct(f);
694 break;
695
696 case EDIT:
697 if (argc != 1)
698 usage();
699 readlabel(f);
700 error = edit(f);
701 break;
702
703 #if !defined(NO_INTERACT)
704 case INTERACT:
705 if (argc != 1)
706 usage();
707 readlabel(f);
708 /*
709 * XXX: Fill some default values so checklabel does not fail
710 */
711 if (lab.d_bbsize == 0)
712 lab.d_bbsize = BBSIZE;
713 if (lab.d_sbsize == 0)
714 lab.d_sbsize = SBLOCKSIZE;
715 interact(&lab, f);
716 break;
717 #endif /* !NO_INTERACT */
718
719 case READ:
720 if (argc != 1)
721 usage();
722 read_all = Aflag;
723 readlabel(f);
724 if (read_all)
725 /* Label got printed in the bowels of readlabel */
726 break;
727 if (tflag)
728 makedisktab(stdout, &lab);
729 else {
730 showinfo(stdout, &lab, specname);
731 showpartitions(stdout, &lab, Cflag);
732 }
733 error = checklabel(&lab);
734 if (error)
735 error += 100;
736 break;
737
738 case RESTORE:
739 if (argc != 2)
740 usage();
741 if (!(t = fopen(argv[1], "r")))
742 err(4, "%s", argv[1]);
743 if (getasciilabel(t, &lab))
744 error = write_label(f);
745 else
746 error = 1;
747 break;
748
749 case SETREADONLY:
750 writable = 0;
751 goto do_diocwlabel;
752 case SETWRITABLE:
753 writable = 1;
754 do_diocwlabel:
755 if (argc != 1)
756 usage();
757 if (dk_ioctl(f, DIOCWLABEL, &writable) < 0)
758 err(4, "ioctl DIOCWLABEL");
759 break;
760
761 case WRITE: /* Create label from /etc/disktab entry & write */
762 if (argc < 2 || argc > 3)
763 usage();
764 makelabel(argv[1], argv[2]);
765 if (checklabel(&lab) == 0)
766 error = write_label(f);
767 else
768 error = 1;
769 break;
770
771 case UNSPEC:
772 usage();
773
774 }
775 exit(error);
776 }
777
778 /*
779 * Construct a prototype disklabel from /etc/disktab.
780 */
781 static void
782 makelabel(const char *type, const char *name)
783 {
784 struct disklabel *dp;
785
786 dp = getdiskbyname(type);
787 if (dp == NULL)
788 errx(1, "unknown disk type: %s", type);
789 lab = *dp;
790
791 /* d_packname is union d_boot[01], so zero */
792 (void)memset(lab.d_packname, 0, sizeof(lab.d_packname));
793 if (name)
794 (void)strncpy(lab.d_packname, name, sizeof(lab.d_packname));
795 }
796
797 static int
798 write_label(int f)
799 {
800 int writable;
801
802 lab.d_magic = DISKMAGIC;
803 lab.d_magic2 = DISKMAGIC;
804 lab.d_checksum = 0;
805 lab.d_checksum = dkcksum(&lab);
806
807 if (rflag) {
808 /* Write the label directly to the disk */
809
810 /*
811 * First set the kernel disk label,
812 * then write a label to the raw disk.
813 * If the SDINFO ioctl fails because it is unimplemented,
814 * keep going; otherwise, the kernel consistency checks
815 * may prevent us from changing the current (in-core)
816 * label.
817 */
818 if (!Fflag && dk_ioctl(f, DIOCSDINFO, &lab) < 0 &&
819 errno != ENODEV && errno != ENOTTY) {
820 l_perror("ioctl DIOCSDINFO");
821 return (1);
822 }
823 /*
824 * write enable label sector before write (if necessary),
825 * disable after writing.
826 */
827 writable = 1;
828 if (!Fflag) {
829 if (dk_ioctl(f, DIOCWLABEL, &writable) < 0)
830 perror("ioctl DIOCWLABEL");
831 set_writable_fd = f;
832 atexit(clear_writable);
833 }
834
835 writelabel_direct(f);
836
837 /*
838 * Now issue a DIOCWDINFO. This will let the kernel convert the
839 * disklabel to some machdep format if needed.
840 */
841 /* XXX: This is stupid! */
842 if (!Fflag && dk_ioctl(f, DIOCWDINFO, &lab) < 0) {
843 l_perror("ioctl DIOCWDINFO");
844 return (1);
845 }
846 } else {
847 /* Get the kernel to write the label */
848 if (dk_ioctl(f, DIOCWDINFO, &lab) < 0) {
849 l_perror("ioctl DIOCWDINFO");
850 return (1);
851 }
852 }
853
854 #ifdef VAX_ALTLABELS
855 if (lab.d_type == DKTYPE_SMD && lab.d_flags & D_BADSECT &&
856 lab.d_secsize == 512) {
857 /* Write the label to the odd sectors of the last track! */
858 daddr_t alt;
859 int i;
860 uint8_t sec0[512];
861
862 if (pread(f, sec0, 512, 0) < 512) {
863 warn("read master label to write alternates");
864 return 0;
865 }
866
867 alt = lab.d_ncylinders * lab.d_secpercyl - lab.d_nsectors;
868 for (i = 1; i < 11 && (uint32_t)i < lab.d_nsectors; i += 2) {
869 if (pwrite(f, sec0, 512, (off_t)(alt + i) * 512) < 512)
870 warn("alternate label %d write", i/2);
871 }
872 }
873 #endif /* VAX_ALTLABELS */
874
875 return 0;
876 }
877
878 int
879 writelabel(int f, struct disklabel *lp)
880 {
881 if (lp != &lab)
882 lab = *lp;
883 return write_label(f);
884 }
885
886 static void
887 l_perror(const char *s)
888 {
889
890 switch (errno) {
891
892 case ESRCH:
893 warnx("%s: No disk label on disk;\n"
894 "use \"disklabel -I\" to install initial label", s);
895 break;
896
897 case EINVAL:
898 warnx("%s: Label magic number or checksum is wrong!\n"
899 "(disklabel or kernel is out of date?)", s);
900 break;
901
902 case EBUSY:
903 warnx("%s: Open partition would move or shrink", s);
904 break;
905
906 case EXDEV:
907 warnx("%s: Labeled partition or 'a' partition must start"
908 " at beginning of disk", s);
909 break;
910
911 default:
912 warn("%s", s);
913 break;
914 }
915 }
916
917 #ifdef NO_MBR_SUPPORT
918 #define process_mbr(f, action) 1
919 #else
920 /*
921 * Scan DOS/MBR partition table and extended partition list for NetBSD ptns.
922 */
923 static int
924 process_mbr(int f, int (*action)(int, u_int))
925 {
926 struct mbr_partition *dp;
927 struct mbr_sector mbr;
928 int rval = 1, res;
929 int part;
930 u_int ext_base, next_ext, this_ext, start;
931
932 ext_base = 0;
933 next_ext = 0;
934 for (;;) {
935 this_ext = next_ext;
936 next_ext = 0;
937 if (verbose > 1)
938 warnx("reading mbr sector %u", this_ext);
939 if (pread(f, &mbr, sizeof mbr, this_ext * (off_t)DEV_BSIZE)
940 != sizeof(mbr)) {
941 if (verbose)
942 warn("Can't read master boot record %u",
943 this_ext);
944 break;
945 }
946
947 /* Check if table is valid. */
948 if (mbr.mbr_magic != htole16(MBR_MAGIC)) {
949 if (verbose)
950 warnx("Invalid signature in mbr record %u",
951 this_ext);
952 break;
953 }
954
955 dp = &mbr.mbr_parts[0];
956
957 /* Find NetBSD partition(s). */
958 for (part = 0; part < MBR_PART_COUNT; dp++, part++) {
959 start = le32toh(dp->mbrp_start);
960 switch (dp->mbrp_type) {
961 #ifdef COMPAT_386BSD_MBRPART
962 case MBR_PTYPE_386BSD:
963 if (ext_base != 0)
964 break;
965 /* FALLTHROUGH */
966 #endif
967 case MBR_PTYPE_NETBSD:
968 res = action(f, this_ext + start);
969 if (res <= 0)
970 /* Found or failure */
971 return res;
972 if (res > rval)
973 /* Keep largest value */
974 rval = res;
975 break;
976 case MBR_PTYPE_EXT:
977 case MBR_PTYPE_EXT_LBA:
978 case MBR_PTYPE_EXT_LNX:
979 next_ext = start;
980 break;
981 default:
982 break;
983 }
984 }
985 if (next_ext == 0)
986 /* No more extended partitions */
987 break;
988 next_ext += ext_base;
989 if (ext_base == 0)
990 ext_base = next_ext;
991
992 if (next_ext <= this_ext) {
993 if (verbose)
994 warnx("Invalid extended chain %x <= %x",
995 next_ext, this_ext);
996 break;
997 }
998 /* Maybe we should check against the disk size... */
999 }
1000
1001 return rval;
1002 }
1003
1004 static int
1005 readlabel_mbr(int f, u_int sector)
1006 {
1007 struct disklabel *disk_lp;
1008
1009 disk_lp = find_label(f, sector);
1010 if (disk_lp == NULL)
1011 return 1;
1012 targettohlabel(&lab, disk_lp);
1013 return 0;
1014 }
1015
1016 static int
1017 writelabel_mbr(int f, u_int sector)
1018 {
1019 return update_label(f, sector, labelusesmbr ? LABELOFFSET_MBR : ~0U) ? 2 : 0;
1020 }
1021
1022 #endif /* !NO_MBR_SUPPORT */
1023
1024 #ifndef USE_ACORN
1025 #define get_filecore_partition(f) 0
1026 #else
1027 /*
1028 * static int filecore_checksum(u_char *bootblock)
1029 *
1030 * Calculates the filecore boot block checksum. This is used to validate
1031 * a filecore boot block on the disk. If a boot block is validated then
1032 * it is used to locate the partition table. If the boot block is not
1033 * validated, it is assumed that the whole disk is NetBSD.
1034 *
1035 * The basic algorithm is:
1036 *
1037 * for (each byte in block, excluding checksum) {
1038 * sum += byte;
1039 * if (sum > 255)
1040 * sum -= 255;
1041 * }
1042 *
1043 * That's equivalent to summing all of the bytes in the block
1044 * (excluding the checksum byte, of course), then calculating the
1045 * checksum as "cksum = sum - ((sum - 1) / 255) * 255)". That
1046 * expression may or may not yield a faster checksum function,
1047 * but it's easier to reason about.
1048 *
1049 * Note that if you have a block filled with bytes of a single
1050 * value "X" (regardless of that value!) and calculate the cksum
1051 * of the block (excluding the checksum byte), you will _always_
1052 * end up with a checksum of X. (Do the math; that can be derived
1053 * from the checksum calculation function!) That means that
1054 * blocks which contain bytes which all have the same value will
1055 * always checksum properly. That's a _very_ unlikely occurrence
1056 * (probably impossible, actually) for a valid filecore boot block,
1057 * so we treat such blocks as invalid.
1058 */
1059 static int
1060 filecore_checksum(u_char *bootblock)
1061 {
1062 u_char byte0, accum_diff;
1063 u_int sum;
1064 int i;
1065
1066 sum = 0;
1067 accum_diff = 0;
1068 byte0 = bootblock[0];
1069
1070 /*
1071 * Sum the contents of the block, keeping track of whether
1072 * or not all bytes are the same. If 'accum_diff' ends up
1073 * being zero, all of the bytes are, in fact, the same.
1074 */
1075 for (i = 0; i < 511; ++i) {
1076 sum += bootblock[i];
1077 accum_diff |= bootblock[i] ^ byte0;
1078 }
1079
1080 /*
1081 * Check to see if the checksum byte is the same as the
1082 * rest of the bytes, too. (Note that if all of the bytes
1083 * are the same except the checksum, a checksum compare
1084 * won't succeed, but that's not our problem.)
1085 */
1086 accum_diff |= bootblock[i] ^ byte0;
1087
1088 /* All bytes in block are the same; call it invalid. */
1089 if (accum_diff == 0)
1090 return (-1);
1091
1092 return (sum - ((sum - 1) / 255) * 255);
1093 }
1094
1095 /*
1096 * Check for the presence of a RiscOS filecore boot block
1097 * indicating an ADFS file system on the disc.
1098 * Return the offset to the NetBSD part of the disc if
1099 * this can be determined.
1100 * This routine will terminate disklabel if the disc
1101 * is found to be ADFS only.
1102 */
1103 static u_int
1104 get_filecore_partition(int f)
1105 {
1106 struct filecore_bootblock *fcbb;
1107 static u_char bb[DEV_BSIZE];
1108 u_int offset;
1109 struct riscix_partition_table *riscix_part;
1110 int loop;
1111
1112 if (pread(f, bb, sizeof(bb), (off_t)FILECORE_BOOT_SECTOR * DEV_BSIZE) != sizeof(bb))
1113 err(4, "can't read filecore boot block");
1114 fcbb = (struct filecore_bootblock *)bb;
1115
1116 /* Check if table is valid. */
1117 if (filecore_checksum(bb) != fcbb->checksum)
1118 return (0);
1119
1120 /*
1121 * Check for NetBSD/arm32 (RiscBSD) partition marker.
1122 * If found the NetBSD disklabel location is easy.
1123 */
1124 offset = (fcbb->partition_cyl_low + (fcbb->partition_cyl_high << 8))
1125 * fcbb->heads * fcbb->secspertrack;
1126
1127 switch (fcbb->partition_type) {
1128
1129 case PARTITION_FORMAT_RISCBSD:
1130 return (offset);
1131
1132 case PARTITION_FORMAT_RISCIX:
1133 /*
1134 * Read the RISCiX partition table and search for the
1135 * first partition named "RiscBSD", "NetBSD", or "Empty:"
1136 *
1137 * XXX is use of 'Empty:' really desirable?! -- cgd
1138 */
1139
1140 if (pread(f, bb, sizeof(bb), (off_t)offset * DEV_BSIZE) != sizeof(bb))
1141 err(4, "can't read riscix partition table");
1142 riscix_part = (struct riscix_partition_table *)bb;
1143
1144 for (loop = 0; loop < NRISCIX_PARTITIONS; ++loop) {
1145 if (strcmp((char *)riscix_part->partitions[loop].rp_name,
1146 "RiscBSD") == 0 ||
1147 strcmp((char *)riscix_part->partitions[loop].rp_name,
1148 "NetBSD") == 0 ||
1149 strcmp((char *)riscix_part->partitions[loop].rp_name,
1150 "Empty:") == 0) {
1151 return riscix_part->partitions[loop].rp_start;
1152 break;
1153 }
1154 }
1155 /*
1156 * Valid filecore boot block, RISCiX partition table
1157 * but no NetBSD partition. We should leave this
1158 * disc alone.
1159 */
1160 errx(4, "cannot label: no NetBSD partition found"
1161 " in RISCiX partition table");
1162
1163 default:
1164 /*
1165 * Valid filecore boot block and no non-ADFS partition.
1166 * This means that the whole disc is allocated for ADFS
1167 * so do not trash ! If the user really wants to put a
1168 * NetBSD disklabel on the disc then they should remove
1169 * the filecore boot block first with dd.
1170 */
1171 errx(4, "cannot label: filecore-only disk"
1172 " (no non-ADFS partition)");
1173 }
1174 return (0);
1175 }
1176 #endif /* USE_ACORN */
1177
1178 /*
1179 * Fetch disklabel for disk to 'lab'.
1180 * Use ioctl to get label unless -r flag is given.
1181 */
1182 static void
1183 readlabel(int f)
1184 {
1185 if (rflag) {
1186 /* Get label directly from disk */
1187 if (readlabel_direct(f) == 0)
1188 return;
1189 /*
1190 * There was no label on the disk. Get the fictious one
1191 * as a basis for initialisation.
1192 */
1193 if (!Fflag && Iflag && (dk_ioctl(f, DIOCGDINFO, &lab) == 0 ||
1194 dk_ioctl(f, DIOCGDEFLABEL, &lab) == 0))
1195 return;
1196 } else {
1197 /* Get label from kernel. */
1198 if (dk_ioctl(f, DIOCGDINFO, &lab) < 0)
1199 err(4, "ioctl DIOCGDINFO");
1200 return;
1201 }
1202
1203 if (read_all == 2)
1204 /* We actually found one, and printed it... */
1205 exit(0);
1206 errx(1, "could not read existing label");
1207 }
1208
1209 /*
1210 * Reading the label from the disk is largely a case of 'hunt the label'.
1211 * and since different architectures default to different places there
1212 * could even be more than one label that contradict each other!
1213 * For now we look in the expected place, then search through likely
1214 * other locations.
1215 */
1216 static struct disklabel *
1217 find_label(int f, u_int sector)
1218 {
1219 struct disklabel *disk_lp, hlp, tlp;
1220 int i;
1221 off_t offset;
1222 const char *is_deleted;
1223
1224 bootarea_len = pread(f, bootarea, sizeof bootarea,
1225 sector * (off_t)DEV_BSIZE);
1226 if (bootarea_len <= 0) {
1227 if (verbose)
1228 warn("failed to read bootarea from sector %u", sector);
1229 return NULL;
1230 }
1231
1232 if (verbose > 2)
1233 warnx("read sector %u len %d looking for label",
1234 sector, bootarea_len);
1235
1236 /* Check expected offset first */
1237 for (offset = LABEL_OFFSET, i = -4;; offset = i += 4) {
1238 is_deleted = "";
1239 if (i == LABEL_OFFSET)
1240 continue;
1241 disk_lp = (void *)(bootarea + offset);
1242 if ((char *)(disk_lp + 1) > bootarea + bootarea_len)
1243 break;
1244 memcpy(&tlp, disk_lp, sizeof(tlp));
1245 if (tlp.d_magic2 != tlp.d_magic)
1246 continue;
1247 if (read_all && (tlp.d_magic == DISKMAGIC_DELETED ||
1248 tlp.d_magic == DISKMAGIC_DELETED_REV)) {
1249 tlp.d_magic ^= ~0u;
1250 tlp.d_magic2 ^= ~0u;
1251 is_deleted = "deleted ";
1252 }
1253 if (target32toh(tlp.d_magic) != DISKMAGIC) {
1254 /* XXX: Do something about byte-swapped labels ? */
1255 if (target32toh(tlp.d_magic) == DISKMAGIC_REV &&
1256 target32toh(tlp.d_magic2) == DISKMAGIC_REV)
1257 warnx("ignoring %sbyteswapped label"
1258 " at offset %jd from sector %u",
1259 is_deleted, (intmax_t)offset, sector);
1260 continue;
1261 }
1262 if (target16toh(tlp.d_npartitions) > maxpartitions ||
1263 dkcksum_target(&tlp) != 0) {
1264 if (verbose > 0)
1265 warnx("corrupt label found at offset %jd in "
1266 "sector %u", (intmax_t)offset, sector);
1267 continue;
1268 }
1269 if (verbose > 1)
1270 warnx("%slabel found at offset %jd from sector %u",
1271 is_deleted, (intmax_t)offset, sector);
1272 if (!read_all)
1273 return disk_lp;
1274
1275 /* To print all the labels we have to do it here */
1276 /* XXX: maybe we should compare them? */
1277 targettohlabel(&hlp, &tlp);
1278 printf("# %ssector %u offset %jd bytes\n",
1279 is_deleted, sector, (intmax_t)offset);
1280 if (tflag)
1281 makedisktab(stdout, &hlp);
1282 else {
1283 showinfo(stdout, &hlp, specname);
1284 showpartitions(stdout, &hlp, Cflag);
1285 }
1286 checklabel(&hlp);
1287 htotargetlabel(&tlp, &hlp);
1288 memcpy(disk_lp, &tlp, sizeof(tlp));
1289 /* Remember we've found a label */
1290 read_all = 2;
1291 }
1292 return NULL;
1293 }
1294
1295 static void
1296 write_bootarea(int f, u_int sector)
1297 {
1298 int wlen;
1299
1300 if (bootarea_len <= 0)
1301 errx(1, "attempting to write after failed read");
1302
1303 #ifdef ALPHA_BOOTBLOCK_CKSUM
1304 /*
1305 * The Alpha requires that the boot block be checksummed.
1306 * <sys/bootblock.h> provides a macro to do it.
1307 */
1308 if (sector == 0) {
1309 struct alpha_boot_block *bb;
1310
1311 bb = (struct alpha_boot_block *)(void *)bootarea;
1312 bb->bb_cksum = 0;
1313 ALPHA_BOOT_BLOCK_CKSUM(bb, &bb->bb_cksum);
1314 }
1315 #endif /* ALPHA_BOOTBLOCK_CKSUM */
1316
1317 wlen = pwrite(f, bootarea, bootarea_len, sector * (off_t)DEV_BSIZE);
1318 if (wlen == bootarea_len)
1319 return;
1320 if (wlen == -1)
1321 err(1, "disklabel write (sector %u) size %d failed",
1322 sector, bootarea_len);
1323 errx(1, "disklabel write (sector %u) size %d truncated to %d",
1324 sector, bootarea_len, wlen);
1325 }
1326
1327 static int
1328 update_label(int f, u_int label_sector, u_int label_offset)
1329 {
1330 struct disklabel *disk_lp;
1331
1332 disk_lp = find_label(f, label_sector);
1333
1334 if (disk_lp && Dflag) {
1335 /* Invalidate the existing label */
1336 disk_lp->d_magic ^= ~0u;
1337 disk_lp->d_magic2 ^= ~0u;
1338 if (Dflag == 2)
1339 write_bootarea(f, label_sector);
1340 /* Force label to default location */
1341 disk_lp = NULL;
1342 }
1343
1344 if (Dflag == 2)
1345 /* We are just deleting the label */
1346 return 0;
1347
1348 if (disk_lp == NULL) {
1349 if (label_offset == ~0u)
1350 return 0;
1351 /* Nothing on the disk - we need to add it */
1352 disk_lp = (void *)(bootarea + label_offset);
1353 if ((char *)(disk_lp + 1) > bootarea + bootarea_len)
1354 errx(1, "no space in bootarea (sector %u) "
1355 "to create label", label_sector);
1356 }
1357
1358 htotargetlabel(disk_lp, &lab);
1359 write_bootarea(f, label_sector);
1360 return 1;
1361 }
1362
1363 static void
1364 writelabel_direct(int f)
1365 {
1366 u_int label_sector;
1367 int written = 0;
1368 int rval;
1369
1370 label_sector = get_filecore_partition(f);
1371 if (label_sector != 0)
1372 /* The offset needs to be that from the acorn ports... */
1373 written = update_label(f, label_sector, DEV_BSIZE);
1374
1375 rval = process_mbr(f, writelabel_mbr);
1376
1377 if (rval == 2 || written)
1378 /* Don't add a label to sector 0, but update one if there */
1379 update_label(f, 0, ~0u);
1380 else
1381 update_label(f, 0, LABEL_OFFSET);
1382 }
1383
1384 static int
1385 readlabel_direct(int f)
1386 {
1387 struct disklabel *disk_lp;
1388 u_int filecore_partition_offset;
1389
1390 filecore_partition_offset = get_filecore_partition(f);
1391 if (filecore_partition_offset != 0) {
1392 disk_lp = find_label(f, filecore_partition_offset);
1393 if (disk_lp != NULL) {
1394 targettohlabel(&lab, disk_lp);
1395 return 0;
1396 }
1397 }
1398
1399 if (labelusesmbr && process_mbr(f, readlabel_mbr) == 0)
1400 return 0;
1401
1402 disk_lp = find_label(f, 0);
1403 if (disk_lp != NULL) {
1404 targettohlabel(&lab, disk_lp);
1405 return 0;
1406 }
1407
1408 if (!labelusesmbr && process_mbr(f, readlabel_mbr) == 0)
1409 return 0;
1410
1411 return 1;
1412 }
1413
1414 static void
1415 makedisktab(FILE *f, struct disklabel *lp)
1416 {
1417 int i;
1418 const char *did;
1419 struct partition *pp;
1420
1421 did = "\\\n\t:";
1422 (void) fprintf(f, "%.*s|Automatically generated label:\\\n\t:dt=",
1423 (int) sizeof(lp->d_typename), lp->d_typename);
1424 if ((unsigned) lp->d_type < DKMAXTYPES)
1425 (void) fprintf(f, "%s:", dktypenames[lp->d_type]);
1426 else
1427 (void) fprintf(f, "unknown%" PRIu16 ":", lp->d_type);
1428
1429 (void) fprintf(f, "se#%" PRIu32 ":", lp->d_secsize);
1430 (void) fprintf(f, "ns#%" PRIu32 ":", lp->d_nsectors);
1431 (void) fprintf(f, "nt#%" PRIu32 ":", lp->d_ntracks);
1432 (void) fprintf(f, "sc#%" PRIu32 ":", lp->d_secpercyl);
1433 (void) fprintf(f, "nc#%" PRIu32 ":", lp->d_ncylinders);
1434
1435 if ((lp->d_secpercyl * lp->d_ncylinders) != lp->d_secperunit) {
1436 (void) fprintf(f, "%ssu#%" PRIu32 ":", did, lp->d_secperunit);
1437 did = "";
1438 }
1439 if (lp->d_rpm != 3600) {
1440 (void) fprintf(f, "%srm#%" PRIu16 ":", did, lp->d_rpm);
1441 did = "";
1442 }
1443 if (lp->d_interleave != 1) {
1444 (void) fprintf(f, "%sil#%" PRIu16 ":", did, lp->d_interleave);
1445 did = "";
1446 }
1447 if (lp->d_trackskew != 0) {
1448 (void) fprintf(f, "%ssk#%" PRIu16 ":", did, lp->d_trackskew);
1449 did = "";
1450 }
1451 if (lp->d_cylskew != 0) {
1452 (void) fprintf(f, "%scs#%" PRIu16 ":", did, lp->d_cylskew);
1453 did = "";
1454 }
1455 if (lp->d_headswitch != 0) {
1456 (void) fprintf(f, "%shs#%" PRIu32 ":", did, lp->d_headswitch);
1457 did = "";
1458 }
1459 if (lp->d_trkseek != 0) {
1460 (void) fprintf(f, "%sts#%" PRIu32 ":", did, lp->d_trkseek);
1461 did = "";
1462 }
1463 #ifdef notyet
1464 (void) fprintf(f, "drivedata: ");
1465 for (i = NDDATA - 1; i >= 0; i--)
1466 if (lp->d_drivedata[i])
1467 break;
1468 if (i < 0)
1469 i = 0;
1470 for (j = 0; j <= i; j++)
1471 (void) fprintf(f, "%" PRIu32 " ", lp->d_drivedata[j]);
1472 #endif /* notyet */
1473 pp = lp->d_partitions;
1474 for (i = 0; i < lp->d_npartitions; i++, pp++) {
1475 if (pp->p_size) {
1476 char c = 'a' + i;
1477 (void) fprintf(f, "\\\n\t:");
1478 (void) fprintf(f, "p%c#%" PRIu32 ":", c, pp->p_size);
1479 (void) fprintf(f, "o%c#%" PRIu32 ":", c, pp->p_offset);
1480 if (pp->p_fstype != FS_UNUSED) {
1481 if ((unsigned) pp->p_fstype < FSMAXTYPES)
1482 (void) fprintf(f, "t%c=%s:", c,
1483 fstypenames[pp->p_fstype]);
1484 else
1485 (void) fprintf(f,
1486 "t%c=unknown%" PRIu8 ":",
1487 c, pp->p_fstype);
1488 }
1489 switch (pp->p_fstype) {
1490
1491 case FS_UNUSED:
1492 break;
1493
1494 case FS_BSDFFS:
1495 case FS_BSDLFS:
1496 case FS_EX2FS:
1497 case FS_ADOS:
1498 case FS_APPLEUFS:
1499 (void) fprintf(f, "b%c#%" PRIu64 ":", c,
1500 (uint64_t)pp->p_fsize * pp->p_frag);
1501 (void) fprintf(f, "f%c#%" PRIu32 ":", c,
1502 pp->p_fsize);
1503 break;
1504 default:
1505 break;
1506 }
1507 }
1508 }
1509 (void) fprintf(f, "\n");
1510 (void) fflush(f);
1511 }
1512
1513 static int
1514 edit(int f)
1515 {
1516 const char *tmpdir;
1517 char tmpfil[MAXPATHLEN];
1518 int first, ch, fd;
1519 int get_ok;
1520 FILE *fp;
1521
1522 if ((tmpdir = getenv("TMPDIR")) == NULL)
1523 tmpdir = _PATH_TMP;
1524 (void)snprintf(tmpfil, sizeof(tmpfil), "%s/%s", tmpdir, TMPFILE);
1525 if ((fd = mkstemp(tmpfil)) == -1 || (fp = fdopen(fd, "w")) == NULL) {
1526 warn("%s", tmpfil);
1527 return (1);
1528 }
1529 (void)fchmod(fd, 0600);
1530 showinfo(fp, &lab, specname);
1531 showpartitions(fp, &lab, Cflag);
1532 (void) fclose(fp);
1533 for (;;) {
1534 if (!editit(tmpfil))
1535 break;
1536 fp = fopen(tmpfil, "r");
1537 if (fp == NULL) {
1538 warn("%s", tmpfil);
1539 break;
1540 }
1541 (void) memset(&lab, 0, sizeof(lab));
1542 get_ok = getasciilabel(fp, &lab);
1543 fclose(fp);
1544 if (get_ok && write_label(f) == 0) {
1545 (void) unlink(tmpfil);
1546 return (0);
1547 }
1548 (void) printf("re-edit the label? [y]: ");
1549 (void) fflush(stdout);
1550 first = ch = getchar();
1551 while (ch != '\n' && ch != EOF)
1552 ch = getchar();
1553 if (first == 'n' || first == 'N')
1554 break;
1555 }
1556 (void)unlink(tmpfil);
1557 return (1);
1558 }
1559
1560 static int
1561 editit(const char *tmpfil)
1562 {
1563 int pid, xpid;
1564 int status;
1565 sigset_t nsigset, osigset;
1566
1567 sigemptyset(&nsigset);
1568 sigaddset(&nsigset, SIGINT);
1569 sigaddset(&nsigset, SIGQUIT);
1570 sigaddset(&nsigset, SIGHUP);
1571 sigprocmask(SIG_BLOCK, &nsigset, &osigset);
1572 while ((pid = fork()) < 0) {
1573 if (errno != EAGAIN) {
1574 sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0);
1575 warn("fork");
1576 return (0);
1577 }
1578 sleep(1);
1579 }
1580 if (pid == 0) {
1581 const char *ed;
1582 char *buf;
1583 int retval;
1584
1585 sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0);
1586 setgid(getgid());
1587 setuid(getuid());
1588 if ((ed = getenv("EDITOR")) == (char *)0)
1589 ed = DEFEDITOR;
1590 /*
1591 * Jump through a few extra hoops in case someone's editor
1592 * is "editor arg1 arg2".
1593 */
1594 asprintf(&buf, "%s %s", ed, tmpfil);
1595 if (!buf)
1596 err(1, "malloc");
1597 retval = execlp(_PATH_BSHELL, _PATH_BSHELL, "-c", buf, NULL);
1598 if (retval == -1)
1599 perror(ed);
1600 exit(retval);
1601 }
1602 while ((xpid = wait(&status)) >= 0)
1603 if (xpid == pid)
1604 break;
1605 sigprocmask(SIG_SETMASK, &osigset, (sigset_t *)0);
1606 return (!status);
1607 }
1608
1609 static char *
1610 skip(char *cp)
1611 {
1612
1613 cp += strspn(cp, " \t");
1614 if (*cp == '\0')
1615 return (NULL);
1616 return (cp);
1617 }
1618
1619 static char *
1620 word(char *cp)
1621 {
1622
1623 if (cp == NULL || *cp == '\0')
1624 return (NULL);
1625
1626 cp += strcspn(cp, " \t");
1627 if (*cp == '\0')
1628 return (NULL);
1629 *cp++ = '\0';
1630 cp += strspn(cp, " \t");
1631 if (*cp == '\0')
1632 return (NULL);
1633 return (cp);
1634 }
1635
1636 #define _CHECKLINE \
1637 if (tp == NULL || *tp == '\0') { \
1638 warnx("line %d: too few fields", lineno); \
1639 errors++; \
1640 break; \
1641 }
1642
1643 #define __CHECKLINE \
1644 if (*tp == NULL || **tp == '\0') { \
1645 warnx("line %d: too few fields", lineno); \
1646 *tp = _error_; \
1647 return 0; \
1648 }
1649
1650 static char _error_[] = "";
1651 #define NXTNUM(n) if ((n = nxtnum(&tp, lineno),0) + tp != _error_) \
1652 ; else goto error
1653 #define NXTXNUM(n) if ((n = nxtxnum(&tp, lp, lineno),0) + tp != _error_) \
1654 ; else goto error
1655
1656 static unsigned long
1657 nxtnum(char **tp, int lineno)
1658 {
1659 char *cp;
1660 unsigned long v;
1661
1662 __CHECKLINE
1663 if (getulong(*tp, '\0', &cp, &v, UINT32_MAX) != 0) {
1664 warnx("line %d: syntax error", lineno);
1665 *tp = _error_;
1666 return 0;
1667 }
1668 *tp = cp;
1669 return v;
1670 }
1671
1672 static unsigned long
1673 nxtxnum(char **tp, struct disklabel *lp, int lineno)
1674 {
1675 char *cp, *ncp;
1676 unsigned long n, v;
1677
1678 __CHECKLINE
1679 cp = *tp;
1680 if (getulong(cp, '/', &ncp, &n, UINT32_MAX) != 0)
1681 goto bad;
1682
1683 if (*ncp == '/') {
1684 n *= lp->d_secpercyl;
1685 cp = ncp + 1;
1686 if (getulong(cp, '/', &ncp, &v, UINT32_MAX) != 0)
1687 goto bad;
1688 n += v * lp->d_nsectors;
1689 cp = ncp + 1;
1690 if (getulong(cp, '\0', &ncp, &v, UINT32_MAX) != 0)
1691 goto bad;
1692 n += v;
1693 }
1694 *tp = ncp;
1695 return n;
1696 bad:
1697 warnx("line %d: invalid format", lineno);
1698 *tp = _error_;
1699 return 0;
1700 }
1701
1702 /*
1703 * Read an ascii label in from fd f,
1704 * in the same format as that put out by showinfo() and showpartitions(),
1705 * and fill in lp.
1706 */
1707 static int
1708 getasciilabel(FILE *f, struct disklabel *lp)
1709 {
1710 const char *const *cpp, *s;
1711 struct partition *pp;
1712 char *cp, *tp, line[BUFSIZ], tbuf[15];
1713 int lineno, errors;
1714 unsigned long v;
1715 unsigned int part;
1716
1717 lineno = 0;
1718 errors = 0;
1719 lp->d_bbsize = BBSIZE; /* XXX */
1720 lp->d_sbsize = SBLOCKSIZE; /* XXX */
1721 while (fgets(line, sizeof(line) - 1, f)) {
1722 lineno++;
1723 if ((cp = strpbrk(line, "#\r\n")) != NULL)
1724 *cp = '\0';
1725 cp = skip(line);
1726 if (cp == NULL) /* blank line or comment line */
1727 continue;
1728 tp = strchr(cp, ':'); /* everything has a colon in it */
1729 if (tp == NULL) {
1730 warnx("line %d: syntax error", lineno);
1731 errors++;
1732 continue;
1733 }
1734 *tp++ = '\0', tp = skip(tp);
1735 if (!strcmp(cp, "type")) {
1736 if (tp == NULL) {
1737 strlcpy(tbuf, "unknown", sizeof(tbuf));
1738 tp = tbuf;
1739 }
1740 cpp = dktypenames;
1741 for (; cpp < &dktypenames[DKMAXTYPES]; cpp++)
1742 if ((s = *cpp) && !strcasecmp(s, tp)) {
1743 lp->d_type = cpp - dktypenames;
1744 goto next;
1745 }
1746 if (GETNUM16(tp, &v) != 0) {
1747 warnx("line %d: syntax error", lineno);
1748 errors++;
1749 continue;
1750 }
1751 if (v >= DKMAXTYPES)
1752 warnx("line %d: warning, unknown disk type: %s",
1753 lineno, tp);
1754 lp->d_type = v;
1755 continue;
1756 }
1757 if (!strcmp(cp, "flags")) {
1758 for (v = 0; (cp = tp) && *cp != '\0';) {
1759 tp = word(cp);
1760 if (!strcasecmp(cp, "removable"))
1761 v |= D_REMOVABLE;
1762 else if (!strcasecmp(cp, "ecc"))
1763 v |= D_ECC;
1764 else if (!strcasecmp(cp, "badsect"))
1765 v |= D_BADSECT;
1766 else {
1767 warnx("line %d: bad flag: %s",
1768 lineno, cp);
1769 errors++;
1770 }
1771 }
1772 lp->d_flags = v;
1773 continue;
1774 }
1775 if (!strcmp(cp, "drivedata")) {
1776 int i;
1777
1778 for (i = 0; (cp = tp) && *cp != '\0' && i < NDDATA;) {
1779 if (GETNUM32(cp, &v) != 0) {
1780 warnx("line %d: bad drive data",
1781 lineno);
1782 errors++;
1783 } else
1784 lp->d_drivedata[i] = v;
1785 i++;
1786 tp = word(cp);
1787 }
1788 continue;
1789 }
1790 if (sscanf(cp, "%lu partitions", &v) == 1) {
1791 if (v == 0 || v > maxpartitions) {
1792 warnx("line %d: bad # of partitions", lineno);
1793 lp->d_npartitions = maxpartitions;
1794 errors++;
1795 } else
1796 lp->d_npartitions = v;
1797 continue;
1798 }
1799 if (tp == NULL) {
1800 tbuf[0] = '\0';
1801 tp = tbuf;
1802 }
1803 if (!strcmp(cp, "disk")) {
1804 strncpy(lp->d_typename, tp, sizeof(lp->d_typename));
1805 continue;
1806 }
1807 if (!strcmp(cp, "label")) {
1808 strncpy(lp->d_packname, tp, sizeof(lp->d_packname));
1809 continue;
1810 }
1811 if (!strcmp(cp, "bytes/sector")) {
1812 if (GETNUM32(tp, &v) != 0 || v <= 0 || (v % 512) != 0) {
1813 warnx("line %d: bad %s: %s", lineno, cp, tp);
1814 errors++;
1815 } else
1816 lp->d_secsize = v;
1817 continue;
1818 }
1819 if (!strcmp(cp, "sectors/track")) {
1820 if (GETNUM32(tp, &v) != 0) {
1821 warnx("line %d: bad %s: %s", lineno, cp, tp);
1822 errors++;
1823 } else
1824 lp->d_nsectors = v;
1825 continue;
1826 }
1827 if (!strcmp(cp, "sectors/cylinder")) {
1828 if (GETNUM32(tp, &v) != 0) {
1829 warnx("line %d: bad %s: %s", lineno, cp, tp);
1830 errors++;
1831 } else
1832 lp->d_secpercyl = v;
1833 continue;
1834 }
1835 if (!strcmp(cp, "tracks/cylinder")) {
1836 if (GETNUM32(tp, &v) != 0) {
1837 warnx("line %d: bad %s: %s", lineno, cp, tp);
1838 errors++;
1839 } else
1840 lp->d_ntracks = v;
1841 continue;
1842 }
1843 if (!strcmp(cp, "cylinders")) {
1844 if (GETNUM32(tp, &v) != 0) {
1845 warnx("line %d: bad %s: %s", lineno, cp, tp);
1846 errors++;
1847 } else
1848 lp->d_ncylinders = v;
1849 continue;
1850 }
1851 if (!strcmp(cp, "total sectors") ||
1852 !strcmp(cp, "sectors/unit")) {
1853 if (GETNUM32(tp, &v) != 0) {
1854 warnx("line %d: bad %s: %s", lineno, cp, tp);
1855 errors++;
1856 } else
1857 lp->d_secperunit = v;
1858 continue;
1859 }
1860 if (!strcmp(cp, "rpm")) {
1861 if (GETNUM16(tp, &v) != 0) {
1862 warnx("line %d: bad %s: %s", lineno, cp, tp);
1863 errors++;
1864 } else
1865 lp->d_rpm = v;
1866 continue;
1867 }
1868 if (!strcmp(cp, "interleave")) {
1869 if (GETNUM16(tp, &v) != 0) {
1870 warnx("line %d: bad %s: %s", lineno, cp, tp);
1871 errors++;
1872 } else
1873 lp->d_interleave = v;
1874 continue;
1875 }
1876 if (!strcmp(cp, "trackskew")) {
1877 if (GETNUM16(tp, &v) != 0) {
1878 warnx("line %d: bad %s: %s", lineno, cp, tp);
1879 errors++;
1880 } else
1881 lp->d_trackskew = v;
1882 continue;
1883 }
1884 if (!strcmp(cp, "cylinderskew")) {
1885 if (GETNUM16(tp, &v) != 0) {
1886 warnx("line %d: bad %s: %s", lineno, cp, tp);
1887 errors++;
1888 } else
1889 lp->d_cylskew = v;
1890 continue;
1891 }
1892 if (!strcmp(cp, "headswitch")) {
1893 if (GETNUM32(tp, &v) != 0) {
1894 warnx("line %d: bad %s: %s", lineno, cp, tp);
1895 errors++;
1896 } else
1897 lp->d_headswitch = v;
1898 continue;
1899 }
1900 if (!strcmp(cp, "track-to-track seek")) {
1901 if (GETNUM32(tp, &v) != 0) {
1902 warnx("line %d: bad %s: %s", lineno, cp, tp);
1903 errors++;
1904 } else
1905 lp->d_trkseek = v;
1906 continue;
1907 }
1908 if ('a' > *cp || *cp > 'z' || cp[1] != '\0') {
1909 warnx("line %d: unknown field: %s", lineno, cp);
1910 errors++;
1911 continue;
1912 }
1913
1914 /* We have a partition entry */
1915 part = *cp - 'a';
1916
1917 if (part >= maxpartitions) {
1918 warnx("line %d: bad partition name: %s", lineno, cp);
1919 errors++;
1920 continue;
1921 }
1922 if (part >= __arraycount(lp->d_partitions)) {
1923 warnx("line %d: partition id %s, >= %zu", lineno,
1924 cp, __arraycount(lp->d_partitions));
1925 errors++;
1926 continue;
1927 }
1928 pp = &lp->d_partitions[part];
1929
1930 NXTXNUM(pp->p_size);
1931 NXTXNUM(pp->p_offset);
1932 /* can't use word() here because of blanks in fstypenames[] */
1933 tp += strspn(tp, " \t");
1934 _CHECKLINE
1935 cp = tp;
1936 cpp = fstypenames;
1937 for (; cpp < &fstypenames[FSMAXTYPES]; cpp++) {
1938 s = *cpp;
1939 if (s == NULL ||
1940 (cp[strlen(s)] != ' ' &&
1941 cp[strlen(s)] != '\t' &&
1942 cp[strlen(s)] != '\0'))
1943 continue;
1944 if (!memcmp(s, cp, strlen(s))) {
1945 pp->p_fstype = cpp - fstypenames;
1946 tp += strlen(s);
1947 if (*tp == '\0')
1948 tp = NULL;
1949 else {
1950 tp += strspn(tp, " \t");
1951 if (*tp == '\0')
1952 tp = NULL;
1953 }
1954 goto gottype;
1955 }
1956 }
1957 tp = word(cp);
1958 if (isdigit(*cp & 0xff)) {
1959 if (GETNUM8(cp, &v) != 0) {
1960 warnx("line %d: syntax error", lineno);
1961 errors++;
1962 }
1963 } else
1964 v = FSMAXTYPES;
1965 if ((unsigned)v >= FSMAXTYPES) {
1966 warnx("line %d: warning, unknown file system type: %s",
1967 lineno, cp);
1968 warnx("tip: use -l to see all valid file system "
1969 "types");
1970 v = FS_UNUSED;
1971 }
1972 pp->p_fstype = v;
1973 gottype:
1974 switch (pp->p_fstype) {
1975
1976 case FS_UNUSED: /* XXX */
1977 NXTNUM(pp->p_fsize);
1978 if (pp->p_fsize == 0)
1979 break;
1980 NXTNUM(v);
1981 pp->p_frag = v / pp->p_fsize;
1982 break;
1983
1984 case FS_BSDFFS:
1985 case FS_ADOS:
1986 case FS_APPLEUFS:
1987 NXTNUM(pp->p_fsize);
1988 if (pp->p_fsize == 0)
1989 break;
1990 NXTNUM(v);
1991 pp->p_frag = v / pp->p_fsize;
1992 NXTNUM(pp->p_cpg);
1993 break;
1994 case FS_BSDLFS:
1995 NXTNUM(pp->p_fsize);
1996 if (pp->p_fsize == 0)
1997 break;
1998 NXTNUM(v);
1999 pp->p_frag = v / pp->p_fsize;
2000 NXTNUM(pp->p_sgs);
2001 break;
2002 case FS_EX2FS:
2003 NXTNUM(pp->p_fsize);
2004 if (pp->p_fsize == 0)
2005 break;
2006 NXTNUM(v);
2007 pp->p_frag = v / pp->p_fsize;
2008 break;
2009 case FS_ISO9660:
2010 NXTNUM(pp->p_cdsession);
2011 break;
2012 default:
2013 break;
2014 }
2015 continue;
2016 error:
2017 errors++;
2018 next:
2019 ;
2020 }
2021 errors += checklabel(lp);
2022 return (errors == 0);
2023 }
2024
2025 /*
2026 * Check disklabel for errors and fill in
2027 * derived fields according to supplied values.
2028 */
2029 int
2030 checklabel(struct disklabel *lp)
2031 {
2032 struct partition *pp, *qp;
2033 int i, j, errors;
2034 char part;
2035
2036 errors = 0;
2037 if (lp->d_secsize == 0) {
2038 warnx("sector size %" PRIu32, lp->d_secsize);
2039 return (1);
2040 }
2041 if (lp->d_nsectors == 0) {
2042 warnx("sectors/track %" PRIu32, lp->d_nsectors);
2043 return (1);
2044 }
2045 if (lp->d_ntracks == 0) {
2046 warnx("tracks/cylinder %" PRIu32, lp->d_ntracks);
2047 return (1);
2048 }
2049 if (lp->d_ncylinders == 0) {
2050 warnx("cylinders/unit %" PRIu32, lp->d_ncylinders);
2051 errors++;
2052 }
2053 if (lp->d_rpm == 0)
2054 warnx("warning, revolutions/minute %" PRIu16, lp->d_rpm);
2055 if (lp->d_secpercyl == 0)
2056 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
2057 if (lp->d_secperunit == 0)
2058 lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
2059 if (lp->d_bbsize == 0) {
2060 warnx("boot block size %" PRIu32, lp->d_bbsize);
2061 errors++;
2062 } else if (lp->d_bbsize % lp->d_secsize)
2063 warnx("warning, boot block size %% sector-size != 0");
2064 if (lp->d_sbsize == 0) {
2065 warnx("super block size %" PRIu32, lp->d_sbsize);
2066 errors++;
2067 } else if (lp->d_sbsize % lp->d_secsize)
2068 warnx("warning, super block size %% sector-size != 0");
2069 if (lp->d_npartitions > maxpartitions)
2070 warnx("warning, number of partitions (%" PRIu16 ") > "
2071 "MAXPARTITIONS (%d)",
2072 lp->d_npartitions, maxpartitions);
2073 else
2074 for (i = maxpartitions - 1; i >= lp->d_npartitions; i--) {
2075 part = 'a' + i;
2076 pp = &lp->d_partitions[i];
2077 if (pp->p_size || pp->p_offset) {
2078 warnx("warning, partition %c increased "
2079 "number of partitions from %" PRIu16
2080 " to %d",
2081 part, lp->d_npartitions, i + 1);
2082 lp->d_npartitions = i + 1;
2083 break;
2084 }
2085 }
2086 for (i = 0; i < lp->d_npartitions; i++) {
2087 part = 'a' + i;
2088 pp = &lp->d_partitions[i];
2089 if (pp->p_size == 0 && pp->p_offset != 0)
2090 warnx("warning, partition %c: size 0, but "
2091 "offset %" PRIu32,
2092 part, pp->p_offset);
2093 #ifdef STRICT_CYLINDER_ALIGNMENT
2094 if (pp->p_offset % lp->d_secpercyl) {
2095 warnx("warning, partition %c:"
2096 " not starting on cylinder boundary",
2097 part);
2098 errors++;
2099 }
2100 #endif /* STRICT_CYLINDER_ALIGNMENT */
2101 if (pp->p_offset > lp->d_secperunit) {
2102 warnx("partition %c: offset past end of unit", part);
2103 errors++;
2104 }
2105 if (pp->p_offset + pp->p_size > lp->d_secperunit) {
2106 warnx("partition %c: partition extends"
2107 " past end of unit",
2108 part);
2109 errors++;
2110 }
2111 if (pp->p_fstype != FS_UNUSED)
2112 for (j = i + 1; j < lp->d_npartitions; j++) {
2113 qp = &lp->d_partitions[j];
2114 if (qp->p_fstype == FS_UNUSED)
2115 continue;
2116 if (pp->p_offset < qp->p_offset + qp->p_size &&
2117 qp->p_offset < pp->p_offset + pp->p_size)
2118 warnx("partitions %c and %c overlap",
2119 part, 'a' + j);
2120 }
2121 }
2122 return (errors);
2123 }
2124
2125 static void
2126 usage(void)
2127 {
2128 static const struct {
2129 const char *name;
2130 const char *expn;
2131 } usages[] = {
2132 { "[-ABCFMrtv] disk", "(to read label)" },
2133 { "-w [-BDFMrv] [-f disktab] disk disktype [packid]", "(to write label)" },
2134 { "-e [-BCDFMIrv] disk", "(to edit label)" },
2135 #if !defined(NO_INTERACT)
2136 { "-i [-BDFMIrv] disk", "(to create a label interactively)" },
2137 #endif
2138 { "-D [-v] disk", "(to delete existing label(s))" },
2139 { "-R [-BDFMrv] disk protofile", "(to restore label)" },
2140 { "[-NW] disk", "(to write disable/enable label)" },
2141 { "-l", "(to show all known file system types)" },
2142 { NULL, NULL }
2143 };
2144 int i;
2145 const char *pn = getprogname();
2146 const char *t = "usage:";
2147
2148 for (i = 0; usages[i].name != NULL; i++) {
2149 (void)fprintf(stderr, "%s %s %s\n\t%s\n",
2150 t, pn, usages[i].name, usages[i].expn);
2151 t = "or";
2152 }
2153 exit(1);
2154 }
2155
2156 static int
2157 getulong(const char *str, char sep, char **epp, unsigned long *ul,
2158 unsigned long max)
2159 {
2160 char *ep;
2161
2162 if (epp == NULL)
2163 epp = &ep;
2164
2165 *ul = strtoul(str, epp, 10);
2166
2167 if ((*ul == ULONG_MAX && errno == ERANGE) || *ul > max)
2168 return ERANGE;
2169
2170 if (*str == '\0' || (**epp != '\0' && **epp != sep &&
2171 !isspace((unsigned char)**epp)))
2172 return EFTYPE;
2173
2174 return 0;
2175 }
2176
2177 /*
2178 * This is a wrapper over the standard strcmp function to be used with
2179 * qsort on an array of pointers to strings.
2180 */
2181 static int
2182 qsort_strcmp(const void *v1, const void *v2)
2183 {
2184 const char *const *sp1 = (const char *const *)v1;
2185 const char *const *sp2 = (const char *const *)v2;
2186
2187 return strcmp(*sp1, *sp2);
2188 }
2189
2190 /*
2191 * Prints all know file system types for a partition.
2192 * Returns 1 on success, 0 on failure.
2193 */
2194 int
2195 list_fs_types(void)
2196 {
2197 int ret;
2198 size_t nelems;
2199
2200 nelems = 0;
2201 {
2202 const char *const *namep;
2203
2204 namep = fstypenames;
2205 while (*namep++ != NULL)
2206 nelems++;
2207 }
2208
2209 ret = 1;
2210 if (nelems > 0) {
2211 const char **list = NULL;
2212 size_t i;
2213
2214 if (reallocarr(&list, nelems, sizeof(char *)) != 0) {
2215 warnx("sorry, could not allocate memory for list");
2216 ret = 0;
2217 } else {
2218 for (i = 0; i < nelems; i++)
2219 list[i] = fstypenames[i];
2220
2221 qsort(list, nelems, sizeof(char *), qsort_strcmp);
2222
2223 for (i = 0; i < nelems; i++)
2224 (void)printf("%s\n", list[i]);
2225
2226 free(list);
2227 }
2228 }
2229
2230 return ret;
2231 }
2232
2233 #ifndef HAVE_NBTOOL_CONFIG_H
2234 int
2235 dk_ioctl(int f, u_long cmd, void *arg)
2236 {
2237 #if !defined(NATIVELABEL_ONLY)
2238 if (!native_p) {
2239 errno = ENOTTY;
2240 return -1;
2241 }
2242 #endif
2243 return ioctl(f, cmd, arg);
2244 }
2245 #endif
2246