1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright (c) 2016 by Delphix. All rights reserved. 25 */ 26 27 /* 28 * This file contains the main entry point of the program and other 29 * routines relating to the general flow. 30 */ 31 #include "global.h" 32 #include <stdio.h> 33 #include <unistd.h> 34 #include <stdlib.h> 35 #include <signal.h> 36 #include <memory.h> 37 #include <string.h> 38 #include <errno.h> 39 40 #ifdef sparc 41 #include <sys/hdio.h> 42 #include <sys/dkbad.h> 43 #endif 44 45 #include <sys/time.h> 46 #include "main.h" 47 #include "analyze.h" 48 #include "menu.h" 49 #include "param.h" 50 #include "misc.h" 51 #include "startup.h" 52 #include "menu_command.h" 53 #include "menu_partition.h" 54 #include "prompts.h" 55 #include "checkdev.h" 56 #include "label.h" 57 58 extern struct menu_item menu_command[]; 59 60 #ifdef __STDC__ 61 62 /* 63 * Local prototypes for ANSI C compilers 64 */ 65 static void get_disk_characteristics(void); 66 67 68 #else /* __STDC__ */ 69 70 /* 71 * Local prototypes for non-ANSI C compilers 72 */ 73 static void get_disk_characteristics(); 74 75 #endif /* __STDC__ */ 76 77 /* 78 * This is the main entry point. 79 */ 80 int 81 main(int argc, char *argv[]) 82 { 83 int i; 84 int ret_code = 1; 85 char **arglist; 86 struct disk_info *disk = NULL; 87 struct disk_type *type, *oldtype; 88 struct partition_info *parts; 89 struct sigaction act; 90 91 solaris_offset = 0; 92 /* 93 * Initialize cur_ctype to avoid null pointer dereference 94 * in auto_efi_sense(). 95 */ 96 cur_ctype = (struct ctlr_type *)NULL; 97 /* 98 * Decode the command line options. 99 */ 100 i = do_options(argc, argv); 101 /* 102 * If we are to run from a command file, open it up. 103 */ 104 if (option_f) { 105 if (freopen(option_f, "r", stdin) == NULL) { 106 err_print("Unable to open command file '%s'.\n", 107 option_f); 108 fullabort(); 109 } 110 } 111 /* 112 * If we are logging, open the log file. 113 */ 114 if (option_l) { 115 if ((log_file = fopen(option_l, "w")) == NULL) { 116 err_print("Unable to open log file '%s'.\n", 117 option_l); 118 fullabort(); 119 } 120 } 121 /* 122 * Read in the data file and initialize the hardware structs. 123 */ 124 sup_init(); 125 /* 126 * If there are no disks on the command line, search the 127 * appropriate device directory for character devices that 128 * look like disks. 129 */ 130 if (i < 0) { 131 arglist = (char **)NULL; 132 /* 133 * There were disks on the command line. They comprise the 134 * search list. 135 */ 136 } else { 137 arglist = &argv[i]; 138 } 139 /* 140 * Perform the search for disks. 141 */ 142 do_search(arglist); 143 /* 144 * Catch ctrl-C and ctrl-Z so critical sections can be 145 * implemented. We use sigaction, as this sets up the 146 * signal handler permanently, and also automatically 147 * restarts any interrupted system call. 148 */ 149 act.sa_handler = cmdabort; 150 (void) memset(&act.sa_mask, 0, sizeof (sigset_t)); 151 act.sa_flags = SA_RESTART | SA_NODEFER; 152 if (sigaction(SIGINT, &act, (struct sigaction *)NULL) == -1) { 153 err_print("sigaction(SIGINT) failed - %s\n", 154 strerror(errno)); 155 fullabort(); 156 } 157 158 act.sa_handler = onsusp; 159 (void) memset(&act.sa_mask, 0, sizeof (sigset_t)); 160 act.sa_flags = SA_RESTART | SA_NODEFER; 161 if (sigaction(SIGTSTP, &act, (struct sigaction *)NULL) == -1) { 162 err_print("sigaction(SIGTSTP) failed - %s\n", 163 strerror(errno)); 164 fullabort(); 165 } 166 167 act.sa_handler = onalarm; 168 (void) memset(&act.sa_mask, 0, sizeof (sigset_t)); 169 act.sa_flags = SA_RESTART; 170 if (sigaction(SIGALRM, &act, (struct sigaction *)NULL) == -1) { 171 err_print("sigaction(SIGALRM) failed - %s\n", 172 strerror(errno)); 173 fullabort(); 174 } 175 176 /* 177 * If there was only 1 disk on the command line, mark it 178 * to be the current disk. If it wasn't found, it's an error. 179 */ 180 if (i == argc - 1) { 181 disk = disk_list; 182 if (disk == NULL) { 183 err_print("Unable to find specified disk '%s'.\n", 184 argv[i]); 185 fullabort(); 186 } 187 } 188 /* 189 * A disk was forced on the command line. 190 */ 191 if (option_d) { 192 /* 193 * Find it in the list of found disks and mark it to 194 * be the current disk. 195 */ 196 for (disk = disk_list; disk != NULL; disk = disk->disk_next) 197 if (diskname_match(option_d, disk)) 198 break; 199 /* 200 * If it wasn't found, it's an error. 201 */ 202 if (disk == NULL) { 203 err_print("Unable to find specified disk '%s'.\n", 204 option_d); 205 fullabort(); 206 } 207 } 208 /* 209 * A disk type was forced on the command line. 210 */ 211 if (option_t != NULL) { 212 /* 213 * Only legal if a disk was also forced. 214 */ 215 if (disk == NULL) { 216 err_print("Must specify disk as well as type.\n"); 217 fullabort(); 218 } 219 oldtype = disk->disk_type; 220 /* 221 * Find the specified type in the list of legal types 222 * for the disk. 223 */ 224 for (type = disk->disk_ctlr->ctlr_ctype->ctype_dlist; 225 type != NULL; type = type->dtype_next) 226 if (strcmp(option_t, type->dtype_asciilabel) == 0) 227 break; 228 /* 229 * If it wasn't found, it's an error. 230 */ 231 if (type == NULL) { 232 err_print( 233 "Specified type '%s' is not a known type.\n", option_t); 234 fullabort(); 235 } 236 /* 237 * If the specified type is not the same as the type 238 * in the disk label, update the type and nullify the 239 * partition map. 240 */ 241 if (type != oldtype) { 242 disk->disk_type = type; 243 disk->disk_parts = NULL; 244 } 245 } 246 /* 247 * A partition map was forced on the command line. 248 */ 249 if (option_p) { 250 /* 251 * Only legal if both disk and type were also forced. 252 */ 253 if (disk == NULL || disk->disk_type == NULL) { 254 err_print("Must specify disk and type as well "); 255 err_print("as partitiion.\n"); 256 fullabort(); 257 } 258 /* 259 * Find the specified map in the list of legal maps 260 * for the type. 261 */ 262 for (parts = disk->disk_type->dtype_plist; parts != NULL; 263 parts = parts->pinfo_next) 264 if (strcmp(option_p, parts->pinfo_name) == 0) 265 break; 266 /* 267 * If it wasn't found, it's an error. 268 */ 269 if (parts == NULL) { 270 err_print( 271 "Specified table '%s' is not a known table.\n", option_p); 272 fullabort(); 273 } 274 /* 275 * Update the map. 276 */ 277 disk->disk_parts = parts; 278 } 279 /* 280 * If a disk was marked to become current, initialize the state 281 * to make it current. If not, ask user to pick one. 282 */ 283 if (disk != NULL) { 284 init_globals(disk); 285 } else if (option_f == 0 && option_d == 0) { 286 while (ret_code) { 287 ret_code = c_disk(); 288 } 289 } 290 291 #ifdef BUG1134748 292 /* 293 * if -f command-file is specified, check for disk and disktype 294 * input also. For SCSI disks, the type input may not be needed 295 * since format would have figured that using inquiry information. 296 */ 297 if (option_f) { 298 if (cur_disk == NULL) { 299 err_print("Must specify a disk using -d option.\n"); 300 fullabort(); 301 } 302 if (cur_dtype == NULL) { 303 err_print("Must specify disk as well as type.\n"); 304 fullabort(); 305 } 306 } 307 #endif /* BUG1134748 */ 308 309 /* 310 * Run the command menu. 311 */ 312 cur_menu = last_menu = 0; 313 run_menu(menu_command, "FORMAT", "format", 1); 314 315 /* 316 * normal ending. Explicitly return(0); 317 */ 318 return (0); 319 } 320 321 /* 322 * This routine initializes the internal state to ready it for a new 323 * current disk. There are a zillion state variables that store 324 * information on the current disk, and they must all be updated. 325 * We also tell SunOS about the disk, since it may not know if the 326 * disk wasn't labeled at boot time. 327 */ 328 void 329 init_globals(disk) 330 struct disk_info *disk; 331 { 332 int status; 333 int found_mount; 334 int found_inuse; 335 #ifdef sparc 336 int i; 337 caddr_t bad_ptr = (caddr_t)&badmap; 338 #endif 339 340 /* 341 * If there was an old current disk, close the file for it. 342 */ 343 if (cur_disk != NULL) 344 (void) close(cur_file); 345 /* 346 * Kill off any defect lists still lying around. 347 */ 348 kill_deflist(&cur_list); 349 kill_deflist(&work_list); 350 /* 351 * If there were any buffers, free them up. 352 */ 353 if ((char *)cur_buf != NULL) { 354 destroy_data((char *)cur_buf); 355 cur_buf = NULL; 356 } 357 if ((char *)pattern_buf != NULL) { 358 destroy_data((char *)pattern_buf); 359 pattern_buf = NULL; 360 } 361 /* 362 * Fill in the hardware struct pointers for the new disk. 363 */ 364 cur_disk = disk; 365 cur_dtype = cur_disk->disk_type; 366 cur_label = cur_disk->label_type; 367 cur_ctlr = cur_disk->disk_ctlr; 368 cur_parts = cur_disk->disk_parts; 369 cur_blksz = cur_disk->disk_lbasize; 370 cur_ctype = cur_ctlr->ctlr_ctype; 371 cur_ops = cur_ctype->ctype_ops; 372 cur_flags = 0; 373 /* 374 * Open a file for the new disk. 375 */ 376 if ((cur_file = open_disk(cur_disk->disk_path, 377 O_RDWR | O_NDELAY)) < 0) { 378 err_print( 379 "Error: can't open selected disk '%s'.\n", cur_disk->disk_name); 380 fullabort(); 381 } 382 #ifdef sparc 383 /* 384 * If the new disk uses bad-144, initialize the bad block table. 385 */ 386 if (cur_ctlr->ctlr_flags & DKI_BAD144) { 387 badmap.bt_mbz = badmap.bt_csn = badmap.bt_flag = 0; 388 for (i = 0; i < NDKBAD; i++) { 389 badmap.bt_bad[i].bt_cyl = -1; 390 badmap.bt_bad[i].bt_trksec = -1; 391 } 392 } 393 #endif 394 /* 395 * If the type of the new disk is known... 396 */ 397 if (cur_dtype != NULL) { 398 /* 399 * Initialize the physical characteristics. 400 * If need disk specs, prompt for undefined disk 401 * characteristics. If running from a file, 402 * use defaults. 403 */ 404 if (cur_dtype->dtype_flags & DT_NEED_SPEFS) { 405 get_disk_characteristics(); 406 cur_dtype->dtype_flags &= ~DT_NEED_SPEFS; 407 } 408 409 ncyl = cur_dtype->dtype_ncyl; 410 acyl = cur_dtype->dtype_acyl; 411 pcyl = cur_dtype->dtype_pcyl; 412 nhead = cur_dtype->dtype_nhead; 413 nsect = cur_dtype->dtype_nsect; 414 phead = cur_dtype->dtype_phead; 415 psect = cur_dtype->dtype_psect; 416 /* 417 * Alternates per cylinder are forced to 0 or 1, 418 * independent of what the label says. This works 419 * because we know which ctlr we are dealing with. 420 */ 421 if (cur_ctype->ctype_flags & CF_APC) 422 apc = 1; 423 else 424 apc = 0; 425 /* 426 * Initialize the surface analysis info. We always start 427 * out with scan set for the whole disk. Note, 428 * for SCSI disks, we can only scan the data area. 429 */ 430 scan_lower = 0; 431 scan_size = BUF_SECTS; 432 if ((cur_ctype->ctype_flags & CF_SCSI) && 433 (cur_disk->label_type == L_TYPE_SOLARIS)) { 434 scan_upper = datasects() - 1; 435 } else if (cur_disk->label_type == L_TYPE_SOLARIS) { 436 scan_upper = physsects() - 1; 437 } else if (cur_disk->label_type == L_TYPE_EFI) { 438 scan_upper = cur_parts->etoc->efi_last_lba; 439 } 440 441 /* 442 * Allocate the buffers. 443 */ 444 cur_buf = (void *) zalloc(BUF_SECTS * cur_blksz); 445 pattern_buf = (void *) zalloc(BUF_SECTS * cur_blksz); 446 447 /* 448 * Tell the user which disk they selected. 449 */ 450 if (chk_volname(cur_disk)) { 451 fmt_print("selecting %s: ", cur_disk->disk_name); 452 print_volname(cur_disk); 453 fmt_print("\n"); 454 } else { 455 fmt_print("selecting %s\n", cur_disk->disk_name); 456 } 457 458 /* 459 * If the drive is formatted... 460 */ 461 if ((*cur_ops->op_ck_format)()) { 462 /* 463 * Mark it formatted. 464 */ 465 cur_flags |= DISK_FORMATTED; 466 /* 467 * Read the defect list, if we have one. 468 */ 469 if (!EMBEDDED_SCSI) { 470 read_list(&cur_list); 471 } 472 #ifdef sparc 473 /* 474 * If the disk does BAD-144, we do an ioctl to 475 * tell SunOS about the bad block table. 476 */ 477 if (cur_ctlr->ctlr_flags & DKI_BAD144) { 478 if (ioctl(cur_file, HDKIOCSBAD, &bad_ptr)) { 479 err_print( 480 "Warning: error telling SunOS bad block map table.\n"); 481 } 482 } 483 #endif 484 fmt_print("[disk formatted"); 485 if (!EMBEDDED_SCSI) { 486 if (cur_list.list != NULL) { 487 fmt_print(", defect list found"); 488 } else { 489 fmt_print(", no defect list found"); 490 } 491 } 492 fmt_print("]"); 493 /* 494 * Drive wasn't formatted. Tell the user in case they 495 * disagree. 496 */ 497 } else if (EMBEDDED_SCSI) { 498 fmt_print("[disk unformatted]"); 499 } else { 500 /* 501 * Make sure the user is serious. Note, for 502 * SCSI disks since this is instantaneous, we 503 * will just do it and not ask for confirmation. 504 */ 505 status = 0; 506 if (!(cur_ctype->ctype_flags & CF_CONFIRM)) { 507 if (check("\n\ 508 Ready to get manufacturer's defect list from unformatted drive.\n\ 509 This cannot be interrupted and takes a long while.\n\ 510 Continue")) 511 status = 1; 512 else 513 fmt_print( 514 "Extracting manufacturer's defect list..."); 515 } 516 /* 517 * Extract manufacturer's defect list. 518 */ 519 if ((status == 0) && (cur_ops->op_ex_man != NULL)) { 520 status = (*cur_ops->op_ex_man)(&cur_list); 521 } else { 522 status = 1; 523 } 524 fmt_print("[disk unformatted"); 525 if (status != 0) { 526 fmt_print(", no defect list found]"); 527 } else { 528 fmt_print(", defect list found]"); 529 } 530 } 531 } else { 532 /* 533 * Disk type is not known. 534 * Initialize physical characteristics to 0 and tell the 535 * user we don't know what type the disk is. 536 */ 537 ncyl = acyl = nhead = nsect = psect = 0; 538 } 539 540 fmt_print("\n"); 541 542 /* 543 * Check to see if there are any mounted file systems on the 544 * disk. If there are, print a warning. 545 */ 546 if ((found_mount = checkmount((diskaddr_t)-1, (diskaddr_t)-1)) != 0) 547 err_print("Warning: Current Disk has mounted partitions.\n"); 548 549 /* 550 * If any part of this device is also part of an SVM, VxVM or 551 * Live Upgrade device, print a warning. 552 */ 553 found_inuse = checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1, 554 (diskaddr_t)-1, 1, 0); 555 556 /* 557 * Get the Solaris Fdisk Partition information 558 */ 559 (void) copy_solaris_part(&cur_disk->fdisk_part); 560 561 if (!found_mount && !found_inuse && 562 cur_disk->label_type == L_TYPE_EFI) { 563 564 /* 565 * If alter_lba is 1, we are using the backup label. 566 * Since we can locate the backup label by disk capacity, 567 * there must be no space expanded after backup label. 568 */ 569 if ((cur_parts->etoc->efi_altern_lba != 1) && 570 (cur_parts->etoc->efi_altern_lba < 571 cur_parts->etoc->efi_last_lba)) { 572 573 /* 574 * Lun expansion detected. Prompt user now and actually 575 * adjust the label in <partition> command. 576 */ 577 fmt_print( 578 "Note: capacity in disk label is smaller than the real disk capacity.\n\ 579 Select <partition> <expand> to adjust the label capacity. \n"); 580 } 581 } 582 } 583 584 585 /* 586 * Prompt for some undefined disk characteristics. 587 * Used when there is no disk definition, but the 588 * disk has a valid label, so basically we're 589 * prompting for everything that isn't in the label. 590 */ 591 static void 592 get_disk_characteristics() 593 { 594 /* 595 * The need_spefs flag is used to tell us that this disk 596 * is not a known type and the ctlr specific info must 597 * be prompted for. We only prompt for the info that applies 598 * to this ctlr. 599 */ 600 assert(cur_dtype->dtype_flags & DT_NEED_SPEFS); 601 602 /* 603 * If we're running with input from a file, use 604 * reasonable defaults, since prompting for the 605 * information will probably mess things up. 606 */ 607 if (option_f) { 608 cur_dtype->dtype_pcyl = ncyl + acyl; 609 cur_dtype->dtype_rpm = AVG_RPM; 610 cur_dtype->dtype_bpt = INFINITY; 611 cur_dtype->dtype_phead = 0; 612 cur_dtype->dtype_psect = 0; 613 cur_dtype->dtype_cyl_skew = 0; 614 cur_dtype->dtype_trk_skew = 0; 615 cur_dtype->dtype_trks_zone = 0; 616 cur_dtype->dtype_atrks = 0; 617 cur_dtype->dtype_asect = 0; 618 cur_dtype->dtype_cache = 0; 619 cur_dtype->dtype_threshold = 0; 620 cur_dtype->dtype_prefetch_min = 0; 621 cur_dtype->dtype_prefetch_max = 0; 622 623 if (cur_ctype->ctype_flags & CF_SMD_DEFS) { 624 cur_dtype->dtype_bps = AVG_BPS; 625 } 626 } else { 627 628 cur_dtype->dtype_pcyl = get_pcyl(ncyl, cur_dtype->dtype_acyl); 629 cur_dtype->dtype_bpt = get_bpt(cur_dtype->dtype_nsect, 630 &cur_dtype->dtype_options); 631 cur_dtype->dtype_rpm = get_rpm(); 632 cur_dtype->dtype_fmt_time = 633 get_fmt_time(&cur_dtype->dtype_options); 634 cur_dtype->dtype_cyl_skew = 635 get_cyl_skew(&cur_dtype->dtype_options); 636 cur_dtype->dtype_trk_skew = 637 get_trk_skew(&cur_dtype->dtype_options); 638 cur_dtype->dtype_trks_zone = 639 get_trks_zone(&cur_dtype->dtype_options); 640 cur_dtype->dtype_atrks = get_atrks(&cur_dtype->dtype_options); 641 cur_dtype->dtype_asect = get_asect(&cur_dtype->dtype_options); 642 cur_dtype->dtype_cache = get_cache(&cur_dtype->dtype_options); 643 cur_dtype->dtype_threshold = 644 get_threshold(&cur_dtype->dtype_options); 645 cur_dtype->dtype_prefetch_min = 646 get_min_prefetch(&cur_dtype->dtype_options); 647 cur_dtype->dtype_prefetch_max = 648 get_max_prefetch(cur_dtype->dtype_prefetch_min, 649 &cur_dtype->dtype_options); 650 cur_dtype->dtype_phead = 651 get_phead(nhead, &cur_dtype->dtype_options); 652 cur_dtype->dtype_psect = get_psect(&cur_dtype->dtype_options); 653 cur_dtype->dtype_bps = get_bps(); 654 #ifdef sparc 655 cur_dtype->dtype_dr_type = 0; 656 #endif 657 } 658 } 659