1 /* $NetBSD: edlabel.c,v 1.1 2010/03/10 23:16:16 abs 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 */ 47 int rawpartition, maxpartitions; 48 49 /* 50 * This is a data-driven program 51 */ 52 struct 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) 60 struct 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 75 void check_divisors(struct disklabel *); 76 u_short dkcksum(struct disklabel *); 77 void edit_geo(struct disklabel *); 78 void edit_head_all(struct disklabel *, int); 79 void edit_head_field(void *, struct field *, int); 80 void edit_partition(struct disklabel *, int, int); 81 void get_fstype(char *, u_int8_t *); 82 void get_val_cts(struct disklabel *, char *, u_int32_t *); 83 void label_modify(struct disklabel *, char *); 84 void label_print(struct disklabel *, char *); 85 void label_quit(struct disklabel *, char *); 86 void label_read(struct disklabel *, char *); 87 void label_write(struct disklabel *, char *); 88 void menu(void); 89 void print_val_cts(struct disklabel *, u_long val); 90 91 char tmpbuf[64]; 92 93 void 94 edit_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 168 void 169 edit_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 178 void 179 edit_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 208 void 209 print_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 225 void 226 get_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 244 void 245 get_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 260 void 261 edit_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 322 void 323 check_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 344 u_short 345 dkcksum(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 357 void 358 label_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 378 void 379 label_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 404 void 405 label_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 419 char modify_cmds[] = "modify subcommands:\n\ 420 @ : modify disk parameters\n\ 421 a-%c : modify partition\n%s\ 422 q : quit this subcommand\n"; 423 424 void 425 label_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 471 void 472 label_quit(struct disklabel *dl, char *dn) 473 { 474 exit(0); 475 } 476 477 struct 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 489 void 490 menu(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 499 int 500 main(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