1 /* $NetBSD: sunlabel.c,v 1.25 2017/05/04 16:29:08 sevan Exp $ */
2
3 /*-
4 * Copyright (c) 2002 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by der Mouse.
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 #if HAVE_NBTOOL_CONFIG_H
33 #include "nbtool_config.h"
34 #endif
35
36 #include <sys/cdefs.h>
37 #if defined(__RCSID) && !defined(lint)
38 __RCSID("$NetBSD: sunlabel.c,v 1.25 2017/05/04 16:29:08 sevan Exp $");
39 #endif
40
41 #include <stdio.h>
42 #include <errno.h>
43 #include <fcntl.h>
44 #include <ctype.h>
45 #include <stdlib.h>
46 #include <unistd.h>
47 #ifndef NO_TERMCAP_WIDTH
48 #include <termcap.h>
49 #endif
50 #include <string.h>
51 #include <strings.h>
52 #include <inttypes.h>
53 #include <err.h>
54
55 #include <sys/ioctl.h>
56
57 /* If neither S_COMMAND nor NO_S_COMMAND is defined, guess. */
58 #if !defined(S_COMMAND) && !defined(NO_S_COMMAND)
59 #define S_COMMAND
60 #include <util.h>
61 #include <sys/disklabel.h>
62 #endif
63
64 /*
65 * NPART is the total number of partitions. This must be <= 43, given the
66 * amount of space available to store extended partitions. It also must be
67 * <=26, given the use of single letters to name partitions. The 8 is the
68 * number of `standard' partitions; this arguably should be a #define, since
69 * it occurs not only here but scattered throughout the code.
70 */
71 #define NPART 16
72 #define NXPART (NPART - 8)
73 #define PARTLETTER(i) ((i) + 'a')
74 #define LETTERPART(i) ((i) - 'a')
75
76 /*
77 * A partition. We keep redundant information around, making sure
78 * that whenever we change one, we keep another constant and update
79 * the third. Which one is which depends. Arguably a partition
80 * should also know its partition number; here, if we need that we
81 * cheat, using (effectively) ptr-&label.partitions[0].
82 */
83 struct part {
84 uint32_t startcyl;
85 uint32_t nblk;
86 uint32_t endcyl;
87 };
88
89 /*
90 * A label. As the embedded comments indicate, much of this structure
91 * corresponds directly to Sun's struct dk_label. Some of the values
92 * here are historical holdovers. Apparently really old Suns did
93 * their own sparing in software, so a sector or two per cylinder,
94 * plus a whole cylinder or two at the end, got set aside as spares.
95 * acyl and apc count those spares, and this is also why ncyl and pcyl
96 * both exist. These days the spares generally are hidden from the
97 * host by the disk, and there's no reason not to set
98 * ncyl=pcyl=ceil(device size/spc) and acyl=apc=0.
99 *
100 * Note also that the geometry assumptions behind having nhead and
101 * nsect assume that the sect/trk and trk/cyl values are constant
102 * across the whole drive. The latter is still usually true; the
103 * former isn't. In my experience, you can just put fixed values
104 * here; the basis for software knowing the drive geometry is also
105 * mostly invalid these days anyway. (I just use nhead=32 nsect=64,
106 * which gives me 1M "cylinders", a convenient size.)
107 */
108 struct label {
109 /* BEGIN fields taken directly from struct dk_label */
110 char asciilabel[128];
111 uint32_t rpm; /* Spindle rotation speed - useless now */
112 uint32_t pcyl; /* Physical cylinders */
113 uint32_t apc; /* Alternative sectors per cylinder */
114 uint32_t obs1; /* Obsolete? */
115 uint32_t obs2; /* Obsolete? */
116 uint32_t intrlv; /* Interleave - never anything but 1 IME */
117 uint32_t ncyl; /* Number of usable cylinders */
118 uint32_t acyl; /* Alternative cylinders - pcyl minus ncyl */
119 uint32_t nhead; /* Tracks-per-cylinder (usually # of heads) */
120 uint32_t nsect; /* Sectors-per-track */
121 uint32_t obs3; /* Obsolete? */
122 uint32_t obs4; /* Obsolete? */
123 /* END fields taken directly from struct dk_label */
124 uint32_t spc; /* Sectors per cylinder - nhead*nsect */
125 uint32_t dirty:1;/* Modified since last read */
126 struct part partitions[NPART];/* The partitions themselves */
127 };
128
129 /*
130 * Describes a field in the label.
131 *
132 * tag is a short name for the field, like "apc" or "nsect". loc is a
133 * pointer to the place in the label where it's stored. print is a
134 * function to print the value; the second argument is the current
135 * column number, and the return value is the new current column
136 * number. (This allows print functions to do proper line wrapping.)
137 * chval is called to change a field; the first argument is the
138 * command line portion that contains the new value (in text form).
139 * The chval function is responsible for parsing and error-checking as
140 * well as doing the modification. changed is a function which does
141 * field-specific actions necessary when the field has been changed.
142 * This could be rolled into the chval function, but I believe this
143 * way provides better code sharing.
144 *
145 * Note that while the fields in the label vary in size (8, 16, or 32
146 * bits), we store everything as ints in the label struct, above, and
147 * convert when packing and unpacking. This allows us to have only
148 * one numeric chval function.
149 */
150 struct field {
151 const char *tag;
152 void *loc;
153 int (*print)(struct field *, int);
154 void (*chval)(const char *, struct field *);
155 void (*changed)(void);
156 int taglen;
157 };
158
159 /* LABEL_MAGIC was chosen by Sun and cannot be trivially changed. */
160 #define LABEL_MAGIC 0xdabe
161 /*
162 * LABEL_XMAGIC needs to agree between here and any other code that uses
163 * extended partitions (mainly the kernel).
164 */
165 #define LABEL_XMAGIC (0x199d1fe2+8)
166
167 static int diskfd; /* fd on the disk */
168 static const char *diskname; /* name of the disk, for messages */
169 static int readonly; /* true iff it's open RO */
170 static unsigned char labelbuf[512]; /* Buffer holding the label sector */
171 static struct label label; /* The label itself. */
172 static int fixmagic; /* -m, ignore bad magic #s */
173 static int fixcksum; /* -s, ignore bad cksums */
174 static int newlabel; /* -n, ignore all on-disk values */
175 static int quiet; /* -q, don't print chatter */
176
177 /*
178 * The various functions that go in the field function pointers. The
179 * _ascii functions are for 128-byte string fields (the ASCII label);
180 * the _int functions are for int-valued fields (everything else).
181 * update_spc is a `changed' function for updating the spc value when
182 * changing one of the two values that make it up.
183 */
184 static int print_ascii(struct field *, int);
185 static void chval_ascii(const char *, struct field *);
186 static int print_int(struct field *, int);
187 static void chval_int(const char *, struct field *);
188 static void update_spc(void);
189
190 /* The fields themselves. */
191 static struct field fields[] =
192 {
193 {"ascii", &label.asciilabel[0], print_ascii, chval_ascii, 0, 0 },
194 {"rpm", &label.rpm, print_int, chval_int, 0, 0 },
195 {"pcyl", &label.pcyl, print_int, chval_int, 0, 0 },
196 {"apc", &label.apc, print_int, chval_int, 0, 0 },
197 {"obs1", &label.obs1, print_int, chval_int, 0, 0 },
198 {"obs2", &label.obs2, print_int, chval_int, 0, 0 },
199 {"intrlv", &label.intrlv, print_int, chval_int, 0, 0 },
200 {"ncyl", &label.ncyl, print_int, chval_int, 0, 0 },
201 {"acyl", &label.acyl, print_int, chval_int, 0, 0 },
202 {"nhead", &label.nhead, print_int, chval_int, update_spc, 0 },
203 {"nsect", &label.nsect, print_int, chval_int, update_spc, 0 },
204 {"obs3", &label.obs3, print_int, chval_int, 0, 0 },
205 {"obs4", &label.obs4, print_int, chval_int, 0, 0 },
206 {NULL, NULL, NULL, NULL, 0, 0 }
207 };
208
209 /*
210 * We'd _like_ to use howmany() from the include files, but can't count
211 * on its being present or working.
212 */
213 static inline uint32_t how_many(uint32_t amt, uint32_t unit)
214 __attribute__((const));
215 static inline uint32_t
how_many(uint32_t amt,uint32_t unit)216 how_many(uint32_t amt, uint32_t unit)
217 {
218 return ((amt + unit - 1) / unit);
219 }
220
221 /*
222 * Try opening the disk, given a name. If mustsucceed is true, we
223 * "cannot fail"; failures produce gripe-and-exit, and if we return,
224 * our return value is 1. Otherwise, we return 1 on success and 0 on
225 * failure.
226 */
227 static int
trydisk(const char * s,int mustsucceed)228 trydisk(const char *s, int mustsucceed)
229 {
230 int ro = 0;
231
232 diskname = s;
233 if ((diskfd = open(s, O_RDWR)) == -1 ||
234 (diskfd = open(s, O_RDWR | O_NONBLOCK)) == -1) {
235 if ((diskfd = open(s, O_RDONLY)) == -1) {
236 if (mustsucceed)
237 err(1, "Cannot open `%s'", s);
238 else
239 return 0;
240 }
241 ro = 1;
242 }
243 if (ro && !quiet)
244 warnx("No write access, label is readonly");
245 readonly = ro;
246 return 1;
247 }
248
249 /*
250 * Set the disk device, given the user-supplied string. Note that even
251 * if we malloc, we never free, because either trydisk eventually
252 * succeeds, in which case the string is saved in diskname, or it
253 * fails, in which case we exit and freeing is irrelevant.
254 */
255 static void
setdisk(const char * s)256 setdisk(const char *s)
257 {
258 char *tmp;
259
260 if (strchr(s, '/')) {
261 trydisk(s, 1);
262 return;
263 }
264 if (trydisk(s, 0))
265 return;
266 #ifndef DISTRIB /* native tool: search in /dev */
267 asprintf(&tmp, "/dev/%s", s);
268 if (!tmp)
269 err(1, "malloc");
270 if (trydisk(tmp, 0)) {
271 free(tmp);
272 return;
273 }
274 free(tmp);
275 asprintf(&tmp, "/dev/%s%c", s, getrawpartition() + 'a');
276 if (!tmp)
277 err(1, "malloc");
278 if (trydisk(tmp, 0)) {
279 free(tmp);
280 return;
281 }
282 #endif
283 errx(1, "Can't find device for disk `%s'", s);
284 }
285
286 static void usage(void) __dead;
287 static void
usage(void)288 usage(void)
289 {
290 (void)fprintf(stderr, "usage: %s [-mnqs] disk\n", getprogname());
291 exit(1);
292 }
293
294 /*
295 * Command-line arguments. We can have at most one non-flag
296 * argument, which is the disk name; we can also have flags
297 *
298 * -m
299 * Turns on fixmagic, which causes bad magic numbers to be
300 * ignored (though a complaint is still printed), rather
301 * than being fatal errors.
302 *
303 * -s
304 * Turns on fixcksum, which causes bad checksums to be
305 * ignored (though a complaint is still printed), rather
306 * than being fatal errors.
307 *
308 * -n
309 * Turns on newlabel, which means we're creating a new
310 * label and anything in the label sector should be
311 * ignored. This is a bit like -m -s, except that it
312 * doesn't print complaints and it ignores possible
313 * garbage on-disk.
314 *
315 * -q
316 * Turns on quiet, which suppresses printing of prompts
317 * and other irrelevant chatter. If you're trying to use
318 * sunlabel in an automated way, you probably want this.
319 */
320 static void
handleargs(int ac,char ** av)321 handleargs(int ac, char **av)
322 {
323 int c;
324
325 while ((c = getopt(ac, av, "mnqs")) != -1) {
326 switch (c) {
327 case 'm':
328 fixmagic++;
329 break;
330 case 'n':
331 newlabel++;
332 break;
333 case 'q':
334 quiet++;
335 break;
336 case 's':
337 fixcksum++;
338 break;
339 case '?':
340 warnx("Illegal option `%c'", c);
341 usage();
342 }
343 }
344 ac -= optind;
345 av += optind;
346 if (ac != 1)
347 usage();
348 setdisk(av[0]);
349 }
350
351 /*
352 * Sets the ending cylinder for a partition. This exists mainly to
353 * centralize the check. (If spc is zero, cylinder numbers make
354 * little sense, and the code would otherwise die on divide-by-0 if we
355 * barged blindly ahead.) We need to call this on a partition
356 * whenever we change it; we need to call it on all partitions
357 * whenever we change spc.
358 */
359 static void
set_endcyl(struct part * p)360 set_endcyl(struct part *p)
361 {
362 if (label.spc == 0) {
363 p->endcyl = p->startcyl;
364 } else {
365 p->endcyl = p->startcyl + how_many(p->nblk, label.spc);
366 }
367 }
368
369 /*
370 * Unpack a label from disk into the in-core label structure. If
371 * newlabel is set, we don't actually do so; we just synthesize a
372 * blank label instead. This is where knowledge of the Sun label
373 * format is kept for read; pack_label is the corresponding routine
374 * for write. We are careful to use labelbuf, l_s, or l_l as
375 * appropriate to avoid byte-sex issues, so we can work on
376 * little-endian machines.
377 *
378 * Note that a bad magic number for the extended partition information
379 * is not considered an error; it simply indicates there is no
380 * extended partition information. Arguably this is the Wrong Thing,
381 * and we should take zero as meaning no info, and anything other than
382 * zero or LABEL_XMAGIC as reason to gripe.
383 */
384 static const char *
unpack_label(void)385 unpack_label(void)
386 {
387 unsigned short int l_s[256];
388 unsigned long int l_l[128];
389 int i;
390 unsigned long int sum;
391 int have_x;
392
393 if (newlabel) {
394 bzero(&label.asciilabel[0], 128);
395 label.rpm = 0;
396 label.pcyl = 0;
397 label.apc = 0;
398 label.obs1 = 0;
399 label.obs2 = 0;
400 label.intrlv = 0;
401 label.ncyl = 0;
402 label.acyl = 0;
403 label.nhead = 0;
404 label.nsect = 0;
405 label.obs3 = 0;
406 label.obs4 = 0;
407 for (i = 0; i < NPART; i++) {
408 label.partitions[i].startcyl = 0;
409 label.partitions[i].nblk = 0;
410 set_endcyl(&label.partitions[i]);
411 }
412 label.spc = 0;
413 label.dirty = 1;
414 return (0);
415 }
416 for (i = 0; i < 256; i++)
417 l_s[i] = (labelbuf[i + i] << 8) | labelbuf[i + i + 1];
418 for (i = 0; i < 128; i++)
419 l_l[i] = (l_s[i + i] << 16) | l_s[i + i + 1];
420 if (l_s[254] != LABEL_MAGIC) {
421 if (fixmagic) {
422 label.dirty = 1;
423 warnx("ignoring incorrect magic number.");
424 } else {
425 return "bad magic number";
426 }
427 }
428 sum = 0;
429 for (i = 0; i < 256; i++)
430 sum ^= l_s[i];
431 label.dirty = 0;
432 if (sum != 0) {
433 if (fixcksum) {
434 label.dirty = 1;
435 warnx("ignoring incorrect checksum.");
436 } else {
437 return "checksum wrong";
438 }
439 }
440 (void)memcpy(&label.asciilabel[0], &labelbuf[0], 128);
441 label.rpm = l_s[210];
442 label.pcyl = l_s[211];
443 label.apc = l_s[212];
444 label.obs1 = l_s[213];
445 label.obs2 = l_s[214];
446 label.intrlv = l_s[215];
447 label.ncyl = l_s[216];
448 label.acyl = l_s[217];
449 label.nhead = l_s[218];
450 label.nsect = l_s[219];
451 label.obs3 = l_s[220];
452 label.obs4 = l_s[221];
453 label.spc = label.nhead * label.nsect;
454 for (i = 0; i < 8; i++) {
455 label.partitions[i].startcyl = (uint32_t)l_l[i + i + 111];
456 label.partitions[i].nblk = (uint32_t)l_l[i + i + 112];
457 set_endcyl(&label.partitions[i]);
458 }
459 have_x = 0;
460 if (l_l[33] == LABEL_XMAGIC) {
461 sum = 0;
462 for (i = 0; i < ((NXPART * 2) + 1); i++)
463 sum += l_l[33 + i];
464 if (sum != l_l[32]) {
465 if (fixcksum) {
466 label.dirty = 1;
467 warnx("Ignoring incorrect extended-partition checksum.");
468 have_x = 1;
469 } else {
470 warnx("Extended-partition magic right but checksum wrong.");
471 }
472 } else {
473 have_x = 1;
474 }
475 }
476 if (have_x) {
477 for (i = 0; i < NXPART; i++) {
478 int j = i + i + 34;
479 label.partitions[i + 8].startcyl = (uint32_t)l_l[j++];
480 label.partitions[i + 8].nblk = (uint32_t)l_l[j++];
481 set_endcyl(&label.partitions[i + 8]);
482 }
483 } else {
484 for (i = 0; i < NXPART; i++) {
485 label.partitions[i + 8].startcyl = 0;
486 label.partitions[i + 8].nblk = 0;
487 set_endcyl(&label.partitions[i + 8]);
488 }
489 }
490 return 0;
491 }
492
493 /*
494 * Pack a label from the in-core label structure into on-disk format.
495 * This is where knowledge of the Sun label format is kept for write;
496 * unpack_label is the corresponding routine for read. If all
497 * partitions past the first 8 are size=0 cyl=0, we store all-0s in
498 * the extended partition space, to be fully compatible with Sun
499 * labels. Since AFIAK nothing works in that case that would break if
500 * we put extended partition info there in the same format we'd use if
501 * there were real info there, this is arguably unnecessary, but it's
502 * easy to do.
503 *
504 * We are careful to avoid endianness issues by constructing everything
505 * in an array of shorts. We do this rather than using chars or longs
506 * because the checksum is defined in terms of shorts; using chars or
507 * longs would simplify small amounts of code at the price of
508 * complicating more.
509 */
510 static void
pack_label(void)511 pack_label(void)
512 {
513 unsigned short int l_s[256];
514 int i;
515 unsigned short int sum;
516
517 memset(&l_s[0], 0, 512);
518 memcpy(&labelbuf[0], &label.asciilabel[0], 128);
519 for (i = 0; i < 64; i++)
520 l_s[i] = (labelbuf[i + i] << 8) | labelbuf[i + i + 1];
521 l_s[210] = label.rpm;
522 l_s[211] = label.pcyl;
523 l_s[212] = label.apc;
524 l_s[213] = label.obs1;
525 l_s[214] = label.obs2;
526 l_s[215] = label.intrlv;
527 l_s[216] = label.ncyl;
528 l_s[217] = label.acyl;
529 l_s[218] = label.nhead;
530 l_s[219] = label.nsect;
531 l_s[220] = label.obs3;
532 l_s[221] = label.obs4;
533 for (i = 0; i < 8; i++) {
534 l_s[(i * 4) + 222] = label.partitions[i].startcyl >> 16;
535 l_s[(i * 4) + 223] = label.partitions[i].startcyl & 0xffff;
536 l_s[(i * 4) + 224] = label.partitions[i].nblk >> 16;
537 l_s[(i * 4) + 225] = label.partitions[i].nblk & 0xffff;
538 }
539 for (i = 0; i < NXPART; i++) {
540 if (label.partitions[i + 8].startcyl ||
541 label.partitions[i + 8].nblk)
542 break;
543 }
544 if (i < NXPART) {
545 unsigned long int xsum;
546 l_s[66] = LABEL_XMAGIC >> 16;
547 l_s[67] = LABEL_XMAGIC & 0xffff;
548 for (i = 0; i < NXPART; i++) {
549 int j = (i * 4) + 68;
550 l_s[j++] = label.partitions[i + 8].startcyl >> 16;
551 l_s[j++] = label.partitions[i + 8].startcyl & 0xffff;
552 l_s[j++] = label.partitions[i + 8].nblk >> 16;
553 l_s[j++] = label.partitions[i + 8].nblk & 0xffff;
554 }
555 xsum = 0;
556 for (i = 0; i < ((NXPART * 2) + 1); i++)
557 xsum += (l_s[i + i + 66] << 16) | l_s[i + i + 67];
558 l_s[64] = (int32_t)(xsum >> 16);
559 l_s[65] = (int32_t)(xsum & 0xffff);
560 }
561 l_s[254] = LABEL_MAGIC;
562 sum = 0;
563 for (i = 0; i < 255; i++)
564 sum ^= l_s[i];
565 l_s[255] = sum;
566 for (i = 0; i < 256; i++) {
567 labelbuf[i + i] = ((uint32_t)l_s[i]) >> 8;
568 labelbuf[i + i + 1] = l_s[i] & 0xff;
569 }
570 }
571
572 /*
573 * Get the label. Read it off the disk and unpack it. This function
574 * is nothing but lseek, read, unpack_label, and error checking.
575 */
576 static void
getlabel(void)577 getlabel(void)
578 {
579 int rv;
580 const char *lerr;
581
582 if (lseek(diskfd, (off_t)0, SEEK_SET) == (off_t)-1)
583 err(1, "lseek to 0 on `%s' failed", diskname);
584
585 if ((rv = read(diskfd, &labelbuf[0], 512)) == -1)
586 err(1, "read label from `%s' failed", diskname);
587
588 if (rv != 512)
589 errx(1, "short read from `%s' wanted %d, got %d.", diskname,
590 512, rv);
591
592 lerr = unpack_label();
593 if (lerr)
594 errx(1, "bogus label on `%s' (%s)", diskname, lerr);
595 }
596
597 /*
598 * Put the label. Pack it and write it to the disk. This function is
599 * little more than pack_label, lseek, write, and error checking.
600 */
601 static void
putlabel(void)602 putlabel(void)
603 {
604 int rv;
605
606 if (readonly) {
607 warnx("No write access to `%s'", diskname);
608 return;
609 }
610
611 if (lseek(diskfd, (off_t)0, SEEK_SET) < (off_t)-1)
612 err(1, "lseek to 0 on `%s' failed", diskname);
613
614 pack_label();
615
616 if ((rv = write(diskfd, &labelbuf[0], 512)) == -1) {
617 err(1, "write label to `%s' failed", diskname);
618 exit(1);
619 }
620
621 if (rv != 512)
622 errx(1, "short write to `%s': wanted %d, got %d",
623 diskname, 512, rv);
624
625 label.dirty = 0;
626 }
627
628 /*
629 * Skip whitespace. Used several places in the command-line parsing
630 * code.
631 */
632 static void
skipspaces(const char ** cpp)633 skipspaces(const char **cpp)
634 {
635 const char *cp = *cpp;
636 while (*cp && isspace((unsigned char)*cp))
637 cp++;
638 *cpp = cp;
639 }
640
641 /*
642 * Scan a number. The first arg points to the char * that's moving
643 * along the string. The second arg points to where we should store
644 * the result. The third arg says what we're scanning, for errors.
645 * The return value is 0 on error, or nonzero if all goes well.
646 */
647 static int
scannum(const char ** cpp,uint32_t * np,const char * tag)648 scannum(const char **cpp, uint32_t *np, const char *tag)
649 {
650 uint32_t v;
651 int nd;
652 const char *cp;
653
654 skipspaces(cpp);
655 v = 0;
656 nd = 0;
657
658 cp = *cpp;
659 while (*cp && isdigit((unsigned char)*cp)) {
660 v = (10 * v) + (*cp++ - '0');
661 nd++;
662 }
663 *cpp = cp;
664
665 if (nd == 0) {
666 printf("Missing/invalid %s: %s\n", tag, cp);
667 return (0);
668 }
669 *np = v;
670 return (1);
671 }
672
673 /*
674 * Change a partition. pno is the number of the partition to change;
675 * numbers is a pointer to the string containing the specification for
676 * the new start and size. This always takes the form "start size",
677 * where start can be
678 *
679 * a number
680 * The partition starts at the beginning of that cylinder.
681 *
682 * start-X
683 * The partition starts at the same place partition X does.
684 *
685 * end-X
686 * The partition starts at the place partition X ends. If
687 * partition X does not exactly on a cylinder boundary, it
688 * is effectively rounded up.
689 *
690 * and size can be
691 *
692 * a number
693 * The partition is that many sectors long.
694 *
695 * num/num/num
696 * The three numbers are cyl/trk/sect counts. n1/n2/n3 is
697 * equivalent to specifying a single number
698 * ((n1*label.nhead)+n2)*label.nsect)+n3. In particular,
699 * if label.nhead or label.nsect is zero, this has limited
700 * usefulness.
701 *
702 * end-X
703 * The partition ends where partition X ends. It is an
704 * error for partition X to end before the specified start
705 * point. This always goes to exactly where partition X
706 * ends, even if that's partway through a cylinder.
707 *
708 * start-X
709 * The partition extends to end exactly where partition X
710 * begins. It is an error for partition X to begin before
711 * the specified start point.
712 *
713 * size-X
714 * The partition has the same size as partition X.
715 *
716 * If label.spc is nonzero but the partition size is not a multiple of
717 * it, a warning is printed, since you usually don't want this. Most
718 * often, in my experience, this comes from specifying a cylinder
719 * count as a single number N instead of N/0/0.
720 */
721 static void
chpart(int pno,const char * numbers)722 chpart(int pno, const char *numbers)
723 {
724 uint32_t cyl0;
725 uint32_t size;
726 uint32_t sizec;
727 uint32_t sizet;
728 uint32_t sizes;
729
730 skipspaces(&numbers);
731 if (!memcmp(numbers, "end-", 4) && numbers[4]) {
732 int epno = LETTERPART(numbers[4]);
733 if ((epno >= 0) && (epno < NPART)) {
734 cyl0 = label.partitions[epno].endcyl;
735 numbers += 5;
736 } else {
737 if (!scannum(&numbers, &cyl0, "starting cylinder"))
738 return;
739 }
740 } else if (!memcmp(numbers, "start-", 6) && numbers[6]) {
741 int spno = LETTERPART(numbers[6]);
742 if ((spno >= 0) && (spno < NPART)) {
743 cyl0 = label.partitions[spno].startcyl;
744 numbers += 7;
745 } else {
746 if (!scannum(&numbers, &cyl0, "starting cylinder"))
747 return;
748 }
749 } else {
750 if (!scannum(&numbers, &cyl0, "starting cylinder"))
751 return;
752 }
753 skipspaces(&numbers);
754 if (!memcmp(numbers, "end-", 4) && numbers[4]) {
755 int epno = LETTERPART(numbers[4]);
756 if ((epno >= 0) && (epno < NPART)) {
757 if (label.partitions[epno].endcyl <= cyl0) {
758 warnx("Partition %c ends before cylinder %u",
759 PARTLETTER(epno), cyl0);
760 return;
761 }
762 size = label.partitions[epno].nblk;
763 /* Be careful of unsigned arithmetic */
764 if (cyl0 > label.partitions[epno].startcyl) {
765 size -= (cyl0 - label.partitions[epno].startcyl)
766 * label.spc;
767 } else if (cyl0 < label.partitions[epno].startcyl) {
768 size += (label.partitions[epno].startcyl - cyl0)
769 * label.spc;
770 }
771 numbers += 5;
772 } else {
773 if (!scannum(&numbers, &size, "partition size"))
774 return;
775 }
776 } else if (!memcmp(numbers, "start-", 6) && numbers[6]) {
777 int spno = LETTERPART(numbers[6]);
778 if ((spno >= 0) && (spno < NPART)) {
779 if (label.partitions[spno].startcyl <= cyl0) {
780 warnx("Partition %c starts before cylinder %u",
781 PARTLETTER(spno), cyl0);
782 return;
783 }
784 size = (label.partitions[spno].startcyl - cyl0)
785 * label.spc;
786 numbers += 7;
787 } else {
788 if (!scannum(&numbers, &size, "partition size"))
789 return;
790 }
791 } else if (!memcmp(numbers, "size-", 5) && numbers[5]) {
792 int spno = LETTERPART(numbers[5]);
793 if ((spno >= 0) && (spno < NPART)) {
794 size = label.partitions[spno].nblk;
795 numbers += 6;
796 } else {
797 if (!scannum(&numbers, &size, "partition size"))
798 return;
799 }
800 } else {
801 if (!scannum(&numbers, &size, "partition size"))
802 return;
803 skipspaces(&numbers);
804 if (*numbers == '/') {
805 sizec = size;
806 numbers++;
807 if (!scannum(&numbers, &sizet,
808 "partition size track value"))
809 return;
810 skipspaces(&numbers);
811 if (*numbers != '/') {
812 warnx("Invalid c/t/s syntax - no second slash");
813 return;
814 }
815 numbers++;
816 if (!scannum(&numbers, &sizes,
817 "partition size sector value"))
818 return;
819 size = sizes + (label.nsect * (sizet
820 + (label.nhead * sizec)));
821 }
822 }
823 if (label.spc && (size % label.spc)) {
824 warnx("Size is not a multiple of cylinder size (is %u/%u/%u)",
825 size / label.spc,
826 (size % label.spc) / label.nsect, size % label.nsect);
827 }
828 label.partitions[pno].startcyl = cyl0;
829 label.partitions[pno].nblk = size;
830 set_endcyl(&label.partitions[pno]);
831 if ((label.partitions[pno].startcyl * label.spc)
832 + label.partitions[pno].nblk > label.spc * label.ncyl) {
833 warnx("Partition extends beyond end of disk");
834 }
835 label.dirty = 1;
836 }
837
838 /*
839 * Change a 128-byte-string field. There's currently only one such,
840 * the ASCII label field.
841 */
842 static void
chval_ascii(const char * cp,struct field * f)843 chval_ascii(const char *cp, struct field *f)
844 {
845 const char *nl;
846
847 skipspaces(&cp);
848 if ((nl = strchr(cp, '\n')) == NULL)
849 nl = cp + strlen(cp);
850 if (nl - cp > 128) {
851 warnx("Ascii label string too long - max 128 characters");
852 } else {
853 memset(f->loc, 0, 128);
854 memcpy(f->loc, cp, (size_t)(nl - cp));
855 label.dirty = 1;
856 }
857 }
858 /*
859 * Change an int-valued field. As noted above, there's only one
860 * function, regardless of the field size in the on-disk label.
861 */
862 static void
chval_int(const char * cp,struct field * f)863 chval_int(const char *cp, struct field *f)
864 {
865 uint32_t v;
866
867 if (!scannum(&cp, &v, "value"))
868 return;
869 *(uint32_t *)f->loc = v;
870 label.dirty = 1;
871 }
872 /*
873 * Change a field's value. The string argument contains the field name
874 * and the new value in text form. Look up the field and call its
875 * chval and changed functions.
876 */
877 static void
chvalue(const char * str)878 chvalue(const char *str)
879 {
880 const char *cp;
881 int i;
882 size_t n;
883
884 if (fields[0].taglen < 1) {
885 for (i = 0; fields[i].tag; i++)
886 fields[i].taglen = strlen(fields[i].tag);
887 }
888 skipspaces(&str);
889 cp = str;
890 while (*cp && !isspace((unsigned char)*cp))
891 cp++;
892 n = cp - str;
893 for (i = 0; fields[i].tag; i++) {
894 if (((int)n == fields[i].taglen) && !memcmp(str, fields[i].tag, n)) {
895 (*fields[i].chval) (cp, &fields[i]);
896 if (fields[i].changed)
897 (*fields[i].changed)();
898 break;
899 }
900 }
901 if (!fields[i].tag)
902 warnx("Bad name %.*s - see L output for names", (int)n, str);
903 }
904
905 /*
906 * `changed' function for the ntrack and nsect fields; update label.spc
907 * and call set_endcyl on all partitions.
908 */
909 static void
update_spc(void)910 update_spc(void)
911 {
912 int i;
913
914 label.spc = label.nhead * label.nsect;
915 for (i = 0; i < NPART; i++)
916 set_endcyl(&label.partitions[i]);
917 }
918
919 /*
920 * Print function for 128-byte-string fields. Currently only the ASCII
921 * label, but we don't depend on that.
922 */
923 static int
print_ascii(struct field * f,int sofar)924 print_ascii(struct field *f, int sofar)
925 {
926 printf("%s: %.128s\n", f->tag, (char *)f->loc);
927 return 0;
928 }
929
930 /*
931 * Print an int-valued field. We are careful to do proper line wrap,
932 * making each value occupy 16 columns.
933 */
934 static int
print_int(struct field * f,int sofar)935 print_int(struct field *f, int sofar)
936 {
937 if (sofar >= 60) {
938 printf("\n");
939 sofar = 0;
940 }
941 printf("%s: %-*u", f->tag, 14 - (int)strlen(f->tag),
942 *(uint32_t *)f->loc);
943 return sofar + 16;
944 }
945
946 /*
947 * Print the whole label. Just call the print function for each field,
948 * then append a newline if necessary.
949 */
950 static void
print_label(void)951 print_label(void)
952 {
953 int i;
954 int c;
955
956 c = 0;
957 for (i = 0; fields[i].tag; i++)
958 c = (*fields[i].print) (&fields[i], c);
959 if (c > 0)
960 printf("\n");
961 }
962
963 /*
964 * Figure out how many columns wide the screen is. We impose a minimum
965 * width of 20 columns; I suspect the output code has some issues if
966 * we have fewer columns than partitions.
967 */
968 static int
screen_columns(void)969 screen_columns(void)
970 {
971 int ncols;
972 #ifndef NO_TERMCAP_WIDTH
973 char *term;
974 char tbuf[1024];
975 #endif
976 #if defined(TIOCGWINSZ)
977 struct winsize wsz;
978 #elif defined(TIOCGSIZE)
979 struct ttysize tsz;
980 #endif
981
982 ncols = 80;
983 #ifndef NO_TERMCAP_WIDTH
984 term = getenv("TERM");
985 if (term && (tgetent(&tbuf[0], term) == 1)) {
986 int n = tgetnum("co");
987 if (n > 1)
988 ncols = n;
989 }
990 #endif
991 #if defined(TIOCGWINSZ)
992 if ((ioctl(1, TIOCGWINSZ, &wsz) == 0) && (wsz.ws_col > 0)) {
993 ncols = wsz.ws_col;
994 }
995 #elif defined(TIOCGSIZE)
996 if ((ioctl(1, TIOCGSIZE, &tsz) == 0) && (tsz.ts_cols > 0)) {
997 ncols = tsz.ts_cols;
998 }
999 #endif
1000 if (ncols < 20)
1001 ncols = 20;
1002 return ncols;
1003 }
1004
1005 /*
1006 * Print the partitions. The argument is true iff we should print all
1007 * partitions, even those set start=0 size=0. We generate one line
1008 * per partition (or, if all==0, per `interesting' partition), plus a
1009 * visually graphic map of partition letters. Most of the hair in the
1010 * visual display lies in ensuring that nothing takes up less than one
1011 * character column, that if two boundaries appear visually identical,
1012 * they _are_ identical. Within that constraint, we try to make the
1013 * number of character columns proportional to the size....
1014 */
1015 static void
print_part(int all)1016 print_part(int all)
1017 {
1018 int i, j, k, n, r, c;
1019 size_t ncols;
1020 uint32_t edges[2 * NPART];
1021 int ce[2 * NPART];
1022 int row[NPART];
1023 unsigned char table[2 * NPART][NPART];
1024 char *line;
1025 struct part *p = label.partitions;
1026
1027 for (i = 0; i < NPART; i++) {
1028 if (all || p[i].startcyl || p[i].nblk) {
1029 printf("%c: start cyl = %6u, size = %8u (",
1030 PARTLETTER(i), p[i].startcyl, p[i].nblk);
1031 if (label.spc) {
1032 printf("%u/%u/%u - ", p[i].nblk / label.spc,
1033 (p[i].nblk % label.spc) / label.nsect,
1034 p[i].nblk % label.nsect);
1035 }
1036 printf("%gMb)\n", p[i].nblk / 2048.0);
1037 }
1038 }
1039
1040 j = 0;
1041 for (i = 0; i < NPART; i++) {
1042 if (p[i].nblk > 0) {
1043 edges[j++] = p[i].startcyl;
1044 edges[j++] = p[i].endcyl;
1045 }
1046 }
1047
1048 do {
1049 n = 0;
1050 for (i = 1; i < j; i++) {
1051 if (edges[i] < edges[i - 1]) {
1052 uint32_t t;
1053 t = edges[i];
1054 edges[i] = edges[i - 1];
1055 edges[i - 1] = t;
1056 n++;
1057 }
1058 }
1059 } while (n > 0);
1060
1061 for (i = 1; i < j; i++) {
1062 if (edges[i] != edges[n]) {
1063 n++;
1064 if (n != i)
1065 edges[n] = edges[i];
1066 }
1067 }
1068
1069 n++;
1070 for (i = 0; i < NPART; i++) {
1071 if (p[i].nblk > 0) {
1072 for (j = 0; j < n; j++) {
1073 if ((p[i].startcyl <= edges[j]) &&
1074 (p[i].endcyl > edges[j])) {
1075 table[j][i] = 1;
1076 } else {
1077 table[j][i] = 0;
1078 }
1079 }
1080 }
1081 }
1082
1083 ncols = screen_columns() - 2;
1084 for (i = 0; i < n; i++)
1085 ce[i] = (edges[i] * ncols) / (double) edges[n - 1];
1086
1087 for (i = 1; i < n; i++)
1088 if (ce[i] <= ce[i - 1])
1089 ce[i] = ce[i - 1] + 1;
1090
1091 if ((size_t)ce[n - 1] > ncols) {
1092 ce[n - 1] = ncols;
1093 for (i = n - 1; (i > 0) && (ce[i] <= ce[i - 1]); i--)
1094 ce[i - 1] = ce[i] - 1;
1095 if (ce[0] < 0)
1096 for (i = 0; i < n; i++)
1097 ce[i] = i;
1098 }
1099
1100 printf("\n");
1101 for (i = 0; i < NPART; i++) {
1102 if (p[i].nblk > 0) {
1103 r = -1;
1104 do {
1105 r++;
1106 for (j = i - 1; j >= 0; j--) {
1107 if (row[j] != r)
1108 continue;
1109 for (k = 0; k < n; k++)
1110 if (table[k][i] && table[k][j])
1111 break;
1112 if (k < n)
1113 break;
1114 }
1115 } while (j >= 0);
1116 row[i] = r;
1117 } else {
1118 row[i] = -1;
1119 }
1120 }
1121 r = row[0];
1122 for (i = 1; i < NPART; i++)
1123 if (row[i] > r)
1124 r = row[i];
1125
1126 if ((line = malloc(ncols + 1)) == NULL)
1127 err(1, "Can't allocate memory");
1128
1129 for (i = 0; i <= r; i++) {
1130 for (j = 0; (size_t)j < ncols; j++)
1131 line[j] = ' ';
1132 for (j = 0; j < NPART; j++) {
1133 if (row[j] != i)
1134 continue;
1135 k = 0;
1136 for (k = 0; k < n; k++) {
1137 if (table[k][j]) {
1138 for (c = ce[k]; c < ce[k + 1]; c++)
1139 line[c] = 'a' + j;
1140 }
1141 }
1142 }
1143 for (j = ncols - 1; (j >= 0) && (line[j] == ' '); j--);
1144 printf("%.*s\n", j + 1, line);
1145 }
1146 free(line);
1147 }
1148
1149 #ifdef S_COMMAND
1150 /*
1151 * This computes an appropriate checksum for an in-core label. It's
1152 * not really related to the S command, except that it's needed only
1153 * by setlabel(), which is #ifdef S_COMMAND.
1154 */
1155 static unsigned short int
dkcksum(const struct disklabel * lp)1156 dkcksum(const struct disklabel *lp)
1157 {
1158 const unsigned short int *start;
1159 const unsigned short int *end;
1160 unsigned short int sum;
1161 const unsigned short int *p;
1162
1163 start = (const void *)lp;
1164 end = (const void *)&lp->d_partitions[lp->d_npartitions];
1165 sum = 0;
1166 for (p = start; p < end; p++)
1167 sum ^= *p;
1168 return (sum);
1169 }
1170
1171 /*
1172 * Set the in-core label. This is basically putlabel, except it builds
1173 * a struct disklabel instead of a Sun label buffer, and uses
1174 * DIOCSDINFO instead of lseek-and-write.
1175 */
1176 static void
setlabel(void)1177 setlabel(void)
1178 {
1179 union {
1180 struct disklabel l;
1181 char pad[sizeof(struct disklabel) -
1182 (MAXPARTITIONS * sizeof(struct partition)) +
1183 (16 * sizeof(struct partition))];
1184 } u;
1185 int i;
1186 struct part *p = label.partitions;
1187
1188 if (ioctl(diskfd, DIOCGDINFO, &u.l) == -1) {
1189 warn("ioctl DIOCGDINFO failed");
1190 return;
1191 }
1192 if (u.l.d_secsize != 512) {
1193 warnx("Disk claims %d-byte sectors", (int)u.l.d_secsize);
1194 }
1195 u.l.d_nsectors = label.nsect;
1196 u.l.d_ntracks = label.nhead;
1197 u.l.d_ncylinders = label.ncyl;
1198 u.l.d_secpercyl = label.nsect * label.nhead;
1199 u.l.d_rpm = label.rpm;
1200 u.l.d_interleave = label.intrlv;
1201 u.l.d_npartitions = getmaxpartitions();
1202 memset(&u.l.d_partitions[0], 0,
1203 u.l.d_npartitions * sizeof(struct partition));
1204 for (i = 0; i < u.l.d_npartitions; i++) {
1205 u.l.d_partitions[i].p_size = p[i].nblk;
1206 u.l.d_partitions[i].p_offset = p[i].startcyl
1207 * label.nsect * label.nhead;
1208 u.l.d_partitions[i].p_fsize = 0;
1209 u.l.d_partitions[i].p_fstype = (i == 1) ? FS_SWAP :
1210 (i == 2) ? FS_UNUSED : FS_BSDFFS;
1211 u.l.d_partitions[i].p_frag = 0;
1212 u.l.d_partitions[i].p_cpg = 0;
1213 }
1214 u.l.d_checksum = 0;
1215 u.l.d_checksum = dkcksum(&u.l);
1216 if (ioctl(diskfd, DIOCSDINFO, &u.l) == -1) {
1217 warn("ioctl DIOCSDINFO failed");
1218 return;
1219 }
1220 }
1221 #endif
1222
1223 static const char *help[] = {
1224 "?\t- print this help",
1225 "L\t- print label, except for partition table",
1226 "P\t- print partition table",
1227 "PP\t- print partition table including size=0 offset=0 entries",
1228 "[abcdefghijklmnop] <cylno> <size> - change partition",
1229 "V <name> <value> - change a non-partition label value",
1230 "W\t- write (possibly modified) label out",
1231 #ifdef S_COMMAND
1232 "S\t- set label in the kernel (orthogonal to W)",
1233 #endif
1234 "Q\t- quit program (error if no write since last change)",
1235 "Q!\t- quit program (unconditionally) [EOF also quits]",
1236 NULL
1237 };
1238
1239 /*
1240 * Read and execute one command line from the user.
1241 */
1242 static void
docmd(void)1243 docmd(void)
1244 {
1245 char cmdline[512];
1246 int i;
1247
1248 if (!quiet)
1249 printf("sunlabel> ");
1250 if (fgets(&cmdline[0], sizeof(cmdline), stdin) != &cmdline[0])
1251 exit(0);
1252 switch (cmdline[0]) {
1253 case '?':
1254 for (i = 0; help[i]; i++)
1255 printf("%s\n", help[i]);
1256 break;
1257 case 'L':
1258 print_label();
1259 break;
1260 case 'P':
1261 print_part(cmdline[1] == 'P');
1262 break;
1263 case 'W':
1264 putlabel();
1265 break;
1266 case 'S':
1267 #ifdef S_COMMAND
1268 setlabel();
1269 #else
1270 printf("This compilation doesn't support S.\n");
1271 #endif
1272 break;
1273 case 'Q':
1274 if ((cmdline[1] == '!') || !label.dirty)
1275 exit(0);
1276 printf("Label is dirty - use w to write it\n");
1277 printf("Use Q! to quit anyway.\n");
1278 break;
1279 case 'a':
1280 case 'b':
1281 case 'c':
1282 case 'd':
1283 case 'e':
1284 case 'f':
1285 case 'g':
1286 case 'h':
1287 case 'i':
1288 case 'j':
1289 case 'k':
1290 case 'l':
1291 case 'm':
1292 case 'n':
1293 case 'o':
1294 case 'p':
1295 chpart(LETTERPART(cmdline[0]), &cmdline[1]);
1296 break;
1297 case 'V':
1298 chvalue(&cmdline[1]);
1299 break;
1300 case '\n':
1301 break;
1302 default:
1303 printf("(Unrecognized command character %c ignored.)\n",
1304 cmdline[0]);
1305 break;
1306 }
1307 }
1308
1309 /*
1310 * main() (duh!). Pretty boring.
1311 */
1312 int
main(int ac,char ** av)1313 main(int ac, char **av)
1314 {
1315 handleargs(ac, av);
1316 getlabel();
1317 for (;;)
1318 docmd();
1319 }
1320