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