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 (c) 1993, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2012 Milan Jurik. All rights reserved.
24 * Copyright 2014 Toomas Soome <tsoome@me.com>
25 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
26 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
27 * Copyright (c) 2016 by Delphix. All rights reserved.
28 */
29
30 /*
31 * This file contains functions that implement the command menu commands.
32 */
33
34 #include "global.h"
35 #include <time.h>
36 #include <sys/time.h>
37 #include <sys/resource.h>
38 #include <sys/wait.h>
39 #include <strings.h>
40 #include <signal.h>
41 #include <stdlib.h>
42 #include <string.h>
43
44 #if defined(sparc)
45 #include <sys/hdio.h>
46 #endif /* defined(sparc) */
47
48 #include "main.h"
49 #include "analyze.h"
50 #include "menu.h"
51 #include "menu_command.h"
52 #include "menu_defect.h"
53 #include "menu_partition.h"
54 #include "param.h"
55 #include "misc.h"
56 #include "label.h"
57 #include "startup.h"
58 #include "partition.h"
59 #include "prompts.h"
60 #include "checkdev.h"
61 #include "io.h"
62 #include "ctlr_scsi.h"
63 #include "auto_sense.h"
64 #include "modify_partition.h"
65
66
67 extern struct menu_item menu_partition[];
68 extern struct menu_item menu_analyze[];
69 extern struct menu_item menu_defect[];
70 int prot_type;
71
72 /*
73 * Choices for the p_tag vtoc field
74 */
75 slist_t ptag_choices[] = {
76 { "unassigned", "", V_UNASSIGNED },
77 { "boot", "", V_BOOT },
78 { "root", "", V_ROOT },
79 { "swap", "", V_SWAP },
80 { "usr", "", V_USR },
81 { "backup", "", V_BACKUP },
82 { "stand", "", V_STAND },
83 { "var", "", V_VAR },
84 { "home", "", V_HOME },
85 { "alternates", "", V_ALTSCTR },
86 { "reserved", "", V_RESERVED },
87 { "system", "", V_SYSTEM },
88 { "BIOS_boot", "", V_BIOS_BOOT },
89 { "FreeBSD boot", "", V_FREEBSD_BOOT },
90 { "FreeBSD swap", "", V_FREEBSD_SWAP },
91 { "FreeBSD UFS", "", V_FREEBSD_UFS },
92 { "FreeBSD ZFS", "", V_FREEBSD_ZFS },
93
94 { NULL }
95 };
96
97
98 /*
99 * Choices for the p_flag vtoc field
100 */
101 slist_t pflag_choices[] = {
102 { "wm", "read-write, mountable", 0 },
103 { "wu", "read-write, unmountable", V_UNMNT },
104 { "rm", "read-only, mountable", V_RONLY },
105 { "ru", "read-only, unmountable", V_RONLY|V_UNMNT },
106 { NULL }
107 };
108
109
110 /*
111 * This routine implements the 'disk' command. It allows the user to
112 * select a disk to be current. The list of choices is the list of
113 * disks that were found at startup time.
114 */
115 int
c_disk(void)116 c_disk(void)
117 {
118 struct disk_info *disk;
119 u_ioparam_t ioparam;
120 int i;
121 int ndisks = 0;
122 int blind_select = 0;
123 int deflt;
124 int index;
125 int *defltptr = NULL;
126 int more = 0;
127 int more_quit = 0;
128 int one_line = 0;
129 int tty_lines;
130
131 /*
132 * This buffer holds the check() prompt that verifies we've got the right
133 * disk when performing a blind selection. The size should be sufficient
134 * to hold the prompt string, plus 256 characters for the disk name -
135 * way more than should ever be necessary. See the #define in misc.h.
136 */
137 char chk_buf[BLIND_SELECT_VER_PROMPT];
138
139 if (istokenpresent()) {
140 /*
141 * disk number to be selected is already in the
142 * input stream .
143 */
144 TOKEN token, cleantoken;
145
146 /*
147 * Get the disk number the user has given.
148 */
149 i = 0;
150 for (disk = disk_list; disk != NULL; disk = disk->disk_next) {
151 i++;
152 }
153
154 ioparam.io_bounds.lower = 0;
155 ioparam.io_bounds.upper = i - 1;
156 (void) gettoken(token);
157 clean_token(cleantoken, token);
158
159 /*
160 * Convert the token into an integer.
161 */
162 if (geti(cleantoken, &index, NULL))
163 return (0);
164
165 /*
166 * Check to be sure it is within the legal bounds.
167 */
168 if ((index < 0) || (index >= i)) {
169 err_print("`%d' is out of range.\n", index);
170 return (0);
171 }
172 goto checkdisk;
173 }
174
175 fmt_print("\n\nAVAILABLE DISK SELECTIONS:\n");
176
177 i = 0;
178 if ((option_f == NULL) && isatty(0) == 1 && isatty(1) == 1) {
179 /*
180 * We have a real terminal for std input and output, enable
181 * more style of output for disk selection list.
182 */
183 more = 1;
184 tty_lines = get_tty_lines();
185 enter_critical();
186 echo_off();
187 charmode_on();
188 exit_critical();
189 }
190
191 /*
192 * Loop through the list of found disks.
193 */
194 for (disk = disk_list; disk != NULL; disk = disk->disk_next) {
195 /*
196 * If using more output, account 2 lines for each disk.
197 */
198 if (more && !more_quit && i && (one_line ||
199 ((2 * i + 1) % (tty_lines - 2) <= 1))) {
200 int c;
201
202 /*
203 * Get the next character.
204 */
205 fmt_print("- hit space for more or s to select - ");
206 c = getchar();
207 fmt_print("\015");
208 one_line = 0;
209 /*
210 * Handle display one line command
211 * (return key)
212 */
213 if (c == '\012') {
214 one_line++;
215 }
216 /* Handle Quit command */
217 if (c == 'q') {
218 fmt_print(
219 " \015");
220 more_quit++;
221 }
222 /* Handle ^D command */
223 if (c == '\004')
224 fullabort();
225 /* or get on with the show */
226 if (c == 's' || c == 'S') {
227 fmt_print("%80s\n", " ");
228 break;
229 }
230 }
231 /*
232 * If this is the current disk, mark it as
233 * the default.
234 */
235 if (cur_disk == disk) {
236 deflt = i;
237 defltptr = &deflt;
238 }
239 if (!more || !more_quit)
240 pr_diskline(disk, i);
241 i++;
242 }
243 if (more) {
244 enter_critical();
245 charmode_off();
246 echo_on();
247 exit_critical();
248 }
249
250 /*
251 * Determine total number of disks, and ask the user which disk they
252 * would like to make current.
253 */
254
255 for (disk = disk_list; disk != NULL; disk = disk->disk_next) {
256 ndisks++;
257 }
258
259 ioparam.io_bounds.lower = 0;
260 ioparam.io_bounds.upper = ndisks - 1;
261 index = input(FIO_INT, "Specify disk (enter its number)", ':',
262 &ioparam, defltptr, DATA_INPUT);
263
264 if (index >= i) {
265 blind_select = 1;
266 }
267
268 /*
269 * Find the disk chosen. Search through controllers/disks
270 * in the same original order, so we match what the user
271 * chose.
272 */
273 checkdisk:
274 i = 0;
275 for (disk = disk_list; disk != NULL; disk = disk->disk_next) {
276 if (i == index)
277 goto found;
278 i++;
279 }
280 /*
281 * Should never happen.
282 */
283 impossible("no disk found");
284
285 found:
286 if (blind_select) {
287 (void) snprintf(chk_buf, sizeof (chk_buf),
288 "Disk %s selected - is this the desired disk? ", disk->disk_name);
289 if (check(chk_buf)) {
290 return (-1);
291 }
292 }
293
294 /*
295 * Update the state. We lock out interrupts so the state can't
296 * get half-updated.
297 */
298
299 enter_critical();
300 init_globals(disk);
301 exit_critical();
302
303 /*
304 * If type unknown and interactive, ask user to specify type.
305 * Also, set partition table (best guess) too.
306 */
307 if (!option_f && ncyl == 0 && nhead == 0 && nsect == 0 &&
308 (disk->label_type != L_TYPE_EFI)) {
309 (void) c_type();
310 }
311
312 /*
313 * Get the Solaris Fdisk Partition information
314 */
315 if (nhead != 0 && nsect != 0)
316 (void) copy_solaris_part(&cur_disk->fdisk_part);
317
318 if ((cur_disk->label_type == L_TYPE_EFI) &&
319 (cur_disk->disk_parts->etoc->efi_flags &
320 EFI_GPT_PRIMARY_CORRUPT)) {
321 err_print("Reading the primary EFI GPT label ");
322 err_print("failed. Using backup label.\n");
323 err_print("Use the 'backup' command to restore ");
324 err_print("the primary label.\n");
325 }
326
327 #if defined(_SUNOS_VTOC_16)
328 /*
329 * If there is no fdisk solaris partition.
330 */
331 if (cur_disk->fdisk_part.numsect == 0) {
332 err_print("No Solaris fdisk partition found.\n");
333 goto exit;
334 }
335 #endif /* defined(_SUNOS_VTOC_16) */
336
337 /*
338 * If the label of the disk is marked dirty,
339 * see if they'd like to label the disk now.
340 */
341 if (cur_disk->disk_flags & DSK_LABEL_DIRTY) {
342 if (check("Disk not labeled. Label it now") == 0) {
343 if (write_label()) {
344 err_print("Write label failed\n");
345 } else {
346 cur_disk->disk_flags &= ~DSK_LABEL_DIRTY;
347 }
348 }
349 }
350 exit:
351 return (0);
352 }
353
354 /*
355 * This routine implements the 'type' command. It allows the user to
356 * specify the type of the current disk. It should be necessary only
357 * if the disk was not labelled or was somehow labelled incorrectly.
358 * The list of legal types for the disk comes from information that was
359 * in the data file.
360 */
361 int
c_type(void)362 c_type(void)
363 {
364 struct disk_type *type, *tptr, *oldtype;
365 u_ioparam_t ioparam;
366 int i, index, deflt, *defltptr = NULL;
367 struct disk_type disk_type;
368 struct disk_type *d = &disk_type;
369 int first_disk;
370 int auto_conf_choice;
371 int other_choice;
372 struct dk_label label;
373 struct efi_info efi_info;
374 uint64_t maxLBA;
375 char volname[LEN_DKL_VVOL];
376 int volinit = 0;
377
378 /*
379 * There must be a current disk.
380 */
381 if (cur_disk == NULL) {
382 err_print("Current Disk is not set.\n");
383 return (-1);
384 }
385 oldtype = cur_disk->disk_type;
386 type = cur_ctype->ctype_dlist;
387 /*
388 * Print out the list of choices.
389 */
390 fmt_print("\n\nAVAILABLE DRIVE TYPES:\n");
391 first_disk = 0;
392 if (cur_ctype->ctype_ctype == DKC_SCSI_CCS) {
393 auto_conf_choice = 0;
394 fmt_print(" %d. Auto configure\n", first_disk++);
395 } else {
396 auto_conf_choice = -1;
397 }
398
399 i = first_disk;
400 for (tptr = type; tptr != NULL; tptr = tptr->dtype_next) {
401 /*
402 * If we pass the current type, mark it to be the default.
403 */
404 if (cur_dtype == tptr) {
405 deflt = i;
406 defltptr = &deflt;
407 }
408 if (cur_disk->label_type == L_TYPE_EFI) {
409 continue;
410 }
411 if (tptr->dtype_asciilabel)
412 fmt_print(" %d. %s\n", i++,
413 tptr->dtype_asciilabel);
414 }
415 other_choice = i;
416 fmt_print(" %d. other\n", i);
417 ioparam.io_bounds.lower = 0;
418 ioparam.io_bounds.upper = i;
419 /*
420 * Ask the user which type the disk is.
421 */
422 index = input(FIO_INT, "Specify disk type (enter its number)", ':',
423 &ioparam, defltptr, DATA_INPUT);
424 /*
425 * Find the type they chose.
426 */
427 if (index == auto_conf_choice) {
428 float scaled;
429 diskaddr_t nblks;
430 int nparts;
431
432 /*
433 * User chose "auto configure".
434 */
435 (void) strcpy(x86_devname, cur_disk->disk_name);
436 switch (cur_disk->label_type) {
437 case L_TYPE_SOLARIS:
438 if ((tptr = auto_sense(cur_file, 1, &label)) == NULL) {
439 err_print("Auto configure failed\n");
440 return (-1);
441 }
442 fmt_print("%s: configured with capacity of ",
443 cur_disk->disk_name);
444 nblks = (diskaddr_t)tptr->dtype_ncyl *
445 tptr->dtype_nhead * tptr->dtype_nsect;
446 scaled = bn2mb(nblks);
447 if (scaled > 1024.0) {
448 fmt_print("%1.2fGB\n", scaled/1024.0);
449 } else {
450 fmt_print("%1.2fMB\n", scaled);
451 }
452 fmt_print("<%s cyl %d alt %d hd %d sec %d>\n",
453 tptr->dtype_asciilabel, tptr->dtype_ncyl,
454 tptr->dtype_acyl, tptr->dtype_nhead,
455 tptr->dtype_nsect);
456 break;
457 case L_TYPE_EFI:
458 if ((tptr = auto_efi_sense(cur_file, &efi_info))
459 == NULL) {
460 err_print("Auto configure failed\n");
461 return (-1);
462 }
463 fmt_print("%s: configured with capacity of ",
464 cur_disk->disk_name);
465 scaled = bn2mb(efi_info.capacity);
466 if (scaled > 1024.0) {
467 fmt_print("%1.2fGB\n", scaled/1024.0);
468 } else {
469 fmt_print("%1.2fMB\n", scaled);
470 }
471 cur_blksz = efi_info.e_parts->efi_lbasize;
472 print_efi_string(efi_info.vendor, efi_info.product,
473 efi_info.revision, efi_info.capacity);
474 fmt_print("\n");
475 for (nparts = 0; nparts < cur_parts->etoc->efi_nparts;
476 nparts++) {
477 if (cur_parts->etoc->efi_parts[nparts].p_tag ==
478 V_RESERVED) {
479 (void) strcpy(volname,
480 cur_parts->etoc->efi_parts
481 [nparts].p_name);
482 volinit = 1;
483 break;
484 }
485 }
486 enter_critical();
487 if (delete_disk_type(cur_disk->disk_type) != 0) {
488 fmt_print("Autoconfiguration failed.\n");
489 return (-1);
490 }
491 cur_disk->disk_type = tptr;
492 cur_disk->disk_parts = tptr->dtype_plist;
493 init_globals(cur_disk);
494 exit_critical();
495 if (volinit) {
496 for (nparts = 0; nparts <
497 cur_parts->etoc->efi_nparts; nparts++) {
498 if (cur_parts->etoc->efi_parts[nparts].p_tag ==
499 V_RESERVED) {
500 (void) strcpy(
501 cur_parts->etoc->efi_parts[nparts].p_name,
502 volname);
503 (void) strlcpy(cur_disk->v_volume, volname,
504 LEN_DKL_VVOL);
505 break;
506 }
507 }
508 }
509 return (0);
510 default:
511 /* Should never happen */
512 return (-1);
513 }
514 } else if ((index == other_choice) && (cur_label == L_TYPE_SOLARIS)) {
515 /*
516 * User chose "other".
517 * Get the standard information on the new type.
518 * Put all information in a tmp structure, in
519 * case user aborts.
520 */
521 bzero((char *)d, sizeof (struct disk_type));
522
523 d->dtype_ncyl = get_ncyl();
524 d->dtype_acyl = get_acyl(d->dtype_ncyl);
525 d->dtype_pcyl = get_pcyl(d->dtype_ncyl, d->dtype_acyl);
526 d->dtype_nhead = get_nhead();
527 d->dtype_phead = get_phead(d->dtype_nhead, &d->dtype_options);
528 d->dtype_nsect = get_nsect();
529 d->dtype_psect = get_psect(&d->dtype_options);
530 d->dtype_bpt = get_bpt(d->dtype_nsect, &d->dtype_options);
531 d->dtype_rpm = get_rpm();
532 d->dtype_fmt_time = get_fmt_time(&d->dtype_options);
533 d->dtype_cyl_skew = get_cyl_skew(&d->dtype_options);
534 d->dtype_trk_skew = get_trk_skew(&d->dtype_options);
535 d->dtype_trks_zone = get_trks_zone(&d->dtype_options);
536 d->dtype_atrks = get_atrks(&d->dtype_options);
537 d->dtype_asect = get_asect(&d->dtype_options);
538 d->dtype_cache = get_cache(&d->dtype_options);
539 d->dtype_threshold = get_threshold(&d->dtype_options);
540 d->dtype_prefetch_min = get_min_prefetch(&d->dtype_options);
541 d->dtype_prefetch_max = get_max_prefetch(d->dtype_prefetch_min,
542 &d->dtype_options);
543 d->dtype_bps = get_bps();
544 #if defined(sparc)
545 d->dtype_dr_type = 0;
546 #endif /* defined(sparc) */
547
548 d->dtype_asciilabel = get_asciilabel();
549 /*
550 * Add the new type to the list of possible types for
551 * this controller. We lock out interrupts so the lists
552 * can't get munged. We put off actually allocating the
553 * structure till here in case the user wanted to
554 * interrupt while still inputting information.
555 */
556 enter_critical();
557 tptr = (struct disk_type *)zalloc(sizeof (struct disk_type));
558 if (type == NULL)
559 cur_ctype->ctype_dlist = tptr;
560 else {
561 while (type->dtype_next != NULL)
562 type = type->dtype_next;
563 type->dtype_next = tptr;
564 }
565 bcopy((char *)d, (char *)tptr, sizeof (disk_type));
566 tptr->dtype_next = NULL;
567 /*
568 * the new disk type does not have any defined
569 * partition table . Hence copy the current partition
570 * table if possible else create a default
571 * paritition table.
572 */
573 new_partitiontable(tptr, oldtype);
574 } else if ((index == other_choice) && (cur_label == L_TYPE_EFI)) {
575 uint64_t start_lba = cur_parts->etoc->efi_first_u_lba;
576 uint64_t reserved;
577
578 reserved = efi_reserved_sectors(cur_parts->etoc);
579 maxLBA = get_mlba();
580 cur_parts->etoc->efi_last_lba = maxLBA;
581 cur_parts->etoc->efi_last_u_lba = maxLBA - start_lba;
582 for (i = 0; i < cur_parts->etoc->efi_nparts; i++) {
583 cur_parts->etoc->efi_parts[i].p_start = 0;
584 cur_parts->etoc->efi_parts[i].p_size = 0;
585 cur_parts->etoc->efi_parts[i].p_tag = V_UNASSIGNED;
586 }
587 cur_parts->etoc->efi_parts[8].p_start =
588 maxLBA - start_lba - reserved;
589 cur_parts->etoc->efi_parts[8].p_size = reserved;
590 cur_parts->etoc->efi_parts[8].p_tag = V_RESERVED;
591 if (write_label()) {
592 err_print("Write label failed\n");
593 } else {
594 cur_disk->disk_flags &= ~DSK_LABEL_DIRTY;
595 }
596 return (0);
597 } else {
598 /*
599 * User picked an existing disk type.
600 */
601 i = first_disk;
602 tptr = type;
603 while (i < index) {
604 if (tptr->dtype_asciilabel) {
605 i++;
606 }
607 tptr = tptr->dtype_next;
608 }
609 if ((tptr->dtype_asciilabel == NULL) &&
610 (tptr->dtype_next != NULL)) {
611 while (tptr->dtype_asciilabel == NULL) {
612 tptr = tptr->dtype_next;
613 }
614 }
615 }
616 /*
617 * Check for mounted file systems in the format zone.
618 * One potential problem with this would be that check()
619 * always returns 'yes' when running out of a file. However,
620 * it is actually ok because we don't let the program get
621 * started if there are mounted file systems and we are
622 * running from a file.
623 */
624 if ((tptr != oldtype) &&
625 checkmount((diskaddr_t)-1, (diskaddr_t)-1)) {
626 err_print(
627 "Cannot set disk type while it has mounted "
628 "partitions.\n\n");
629 return (-1);
630 }
631 /*
632 * check for partitions being used for swapping in format zone
633 */
634 if ((tptr != oldtype) &&
635 checkswap((diskaddr_t)-1, (diskaddr_t)-1)) {
636 err_print("Cannot set disk type while its partition are "
637 "currently being used for swapping.\n");
638 return (-1);
639 }
640
641 /*
642 * Check for partitions being used in SVM, VxVM or LU devices
643 */
644
645 if ((tptr != oldtype) &&
646 checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1,
647 (diskaddr_t)-1, 0, 0)) {
648 err_print("Cannot set disk type while its "
649 "partitions are currently in use.\n");
650 return (-1);
651 }
652 /*
653 * If the type selected is different from the previous type,
654 * mark the disk as not labelled and reload the current
655 * partition info. This is not essential but probably the
656 * right thing to do, since the size of the disk has probably
657 * changed.
658 */
659 enter_critical();
660 if (tptr != oldtype) {
661 cur_disk->disk_type = tptr;
662 cur_disk->disk_parts = NULL;
663 cur_disk->disk_flags &= ~DSK_LABEL;
664 }
665 /*
666 * Initialize the state of the current disk.
667 */
668 init_globals(cur_disk);
669 (void) get_partition();
670 exit_critical();
671
672 /*
673 * If the label of the disk is marked dirty,
674 * see if they'd like to label the disk now.
675 */
676 if (cur_disk->disk_flags & DSK_LABEL_DIRTY) {
677 if (check("Disk not labeled. Label it now") == 0) {
678 if (write_label()) {
679 err_print("Write label failed\n");
680 } else {
681 cur_disk->disk_flags &= ~DSK_LABEL_DIRTY;
682 }
683 }
684 }
685
686 return (0);
687 }
688
689 /*
690 * This routine implements the 'partition' command. It simply runs
691 * the partition menu.
692 */
693 int
c_partition(void)694 c_partition(void)
695 {
696
697 /*
698 * There must be a current disk type and a current disk
699 */
700 if (cur_dtype == NULL) {
701 err_print("Current Disk Type is not set.\n");
702 return (-1);
703 }
704 /*
705 * Check for a valid fdisk table entry for Solaris
706 */
707 if (!good_fdisk()) {
708 return (-1);
709 }
710
711 cur_menu++;
712 last_menu = cur_menu;
713
714 #ifdef not
715 /*
716 * If there is no current partition table, make one. This is
717 * so the commands within the menu never have to check for
718 * a non-existent table.
719 */
720 if (cur_parts == NULL)
721 err_print("making partition.\n");
722 make_partition();
723 #endif /* not */
724
725 /*
726 * Run the menu.
727 */
728 run_menu(menu_partition, "PARTITION", "partition", 0);
729 cur_menu--;
730 return (0);
731 }
732
733 /*
734 * This routine implements the 'current' command. It describes the
735 * current disk.
736 */
737 int
c_current(void)738 c_current(void)
739 {
740
741 /*
742 * If there is no current disk, say so. Note that this is
743 * not an error since it is a legitimate response to the inquiry.
744 */
745 if (cur_disk == NULL) {
746 fmt_print("No Current Disk.\n");
747 return (0);
748 }
749 /*
750 * Print out the info we have on the current disk.
751 */
752 fmt_print("Current Disk = %s", cur_disk->disk_name);
753 if (chk_volname(cur_disk)) {
754 fmt_print(": ");
755 print_volname(cur_disk);
756 }
757 fmt_print("\n");
758 if (cur_disk->devfs_name != NULL) {
759 if (cur_dtype == NULL) {
760 fmt_print("<type unknown>\n");
761 } else if (cur_label == L_TYPE_SOLARIS) {
762 fmt_print("<%s cyl %d alt %d hd %d sec %d>\n",
763 cur_dtype->dtype_asciilabel, ncyl,
764 acyl, nhead, nsect);
765 } else if (cur_label == L_TYPE_EFI) {
766 print_efi_string(cur_dtype->vendor,
767 cur_dtype->product, cur_dtype->revision,
768 cur_dtype->capacity);
769 fmt_print("\n");
770 }
771 fmt_print("%s\n", cur_disk->devfs_name);
772 } else {
773 fmt_print("%s%d: <", cur_ctlr->ctlr_dname,
774 cur_disk->disk_dkinfo.dki_unit);
775 if (cur_dtype == NULL) {
776 fmt_print("type unknown");
777 } else if (cur_label == L_TYPE_SOLARIS) {
778 fmt_print("%s cyl %d alt %d hd %d sec %d",
779 cur_dtype->dtype_asciilabel, ncyl,
780 acyl, nhead, nsect);
781 } else if (cur_label == L_TYPE_EFI) {
782 print_efi_string(cur_dtype->vendor,
783 cur_dtype->product, cur_dtype->revision,
784 cur_dtype->capacity);
785 fmt_print("\n");
786 }
787 fmt_print(">\n");
788 }
789 fmt_print("\n");
790 return (0);
791 }
792 /*
793 * This routine implements the 'format' command. It allows the user
794 * to format and verify any portion of the disk.
795 */
796 int
c_format(void)797 c_format(void)
798 {
799 diskaddr_t start, end;
800 time_t clock;
801 int format_time, format_tracks, format_cyls;
802 int format_interval;
803 diskaddr_t deflt;
804 int status;
805 u_ioparam_t ioparam;
806 struct scsi_inquiry *inq;
807 char rawbuf[MAX_MODE_SENSE_SIZE];
808 struct scsi_capacity_16 capacity;
809 struct vpd_hdr *vpdhdr;
810 uint8_t protect;
811 uint8_t pagecode;
812 uint8_t spt;
813 uint8_t p_type;
814 uint8_t prot_flag[NUM_PROT_TYPE] = {1, 0, 0, 0};
815 int i;
816 char *prot_descriptor[NUM_PROT_TYPE] = {
817 "Protection Information is disabled.",
818 "Protection Information is enabled.",
819 "Protection Information is enabled.",
820 "Protection Information is enabled.", };
821
822 /*
823 * There must be a current disk type and a current disk
824 */
825 if (cur_dtype == NULL) {
826 err_print("Current Disk Type is not set.\n");
827 return (-1);
828 }
829
830 /*
831 * There must be a format routine in cur_ops structure to have
832 * this routine work.
833 */
834 if (cur_ops->op_format == NULL) {
835 err_print(
836 "Cannot format this drive. Please use your Manufacturer supplied formatting "
837 "utility.\n");
838 return (-1);
839 }
840
841 /*
842 * There must be a current defect list. Except for
843 * unformatted SCSI disks. For them the defect list
844 * can only be retrieved after formatting the disk.
845 */
846 if ((cur_ctype->ctype_flags & CF_SCSI) && !EMBEDDED_SCSI &&
847 (cur_ctype->ctype_flags & CF_DEFECTS) &&
848 ! (cur_flags & DISK_FORMATTED)) {
849 cur_list.flags |= LIST_RELOAD;
850
851 } else if (cur_list.list == NULL && !EMBEDDED_SCSI) {
852 err_print("Current Defect List must be initialized.\n");
853 return (-1);
854 }
855 /*
856 * Ask for the bounds of the format. We always use the whole
857 * disk as the default, since that is the most likely case.
858 * Note, for disks which must be formatted accross the whole disk,
859 * don't bother the user.
860 */
861 ioparam.io_bounds.lower = start = 0;
862 if (cur_label == L_TYPE_SOLARIS) {
863 if (cur_ctype->ctype_flags & CF_SCSI) {
864 ioparam.io_bounds.upper = end = datasects() - 1;
865 } else {
866 ioparam.io_bounds.upper = end = physsects() - 1;
867 }
868 } else {
869 ioparam.io_bounds.upper = end = cur_parts->etoc->efi_last_lba;
870 }
871
872 if (! (cur_ctlr->ctlr_flags & DKI_FMTVOL)) {
873 deflt = ioparam.io_bounds.lower;
874 start = input(FIO_BN,
875 "Enter starting block number", ':',
876 &ioparam, (int *)&deflt, DATA_INPUT);
877 ioparam.io_bounds.lower = start;
878 deflt = ioparam.io_bounds.upper;
879 end = input(FIO_BN,
880 "Enter ending block number", ':',
881 &ioparam, (int *)&deflt, DATA_INPUT);
882 }
883 /*
884 * Some disks can format tracks. Make sure the whole track is
885 * specified for them.
886 */
887 if (cur_ctlr->ctlr_flags & DKI_FMTTRK) {
888 if (bn2s(start) != 0 ||
889 bn2s(end) != sectors(bn2h(end)) - 1) {
890 err_print("Controller requires formatting of ");
891 err_print("entire tracks.\n");
892 return (-1);
893 }
894 }
895 /*
896 * Check for mounted file systems in the format zone, and if we
897 * find any, make sure they are really serious. One potential
898 * problem with this would be that check() always returns 'yes'
899 * when running out of a file. However, it is actually ok
900 * because we don't let the program get started if there are
901 * mounted file systems and we are running from a file.
902 */
903 if (checkmount(start, end)) {
904 err_print(
905 "Cannot format disk while it has mounted partitions.\n\n");
906 return (-1);
907 }
908 /*
909 * check for partitions being used for swapping in format zone
910 */
911 if (checkswap(start, end)) {
912 err_print("Cannot format disk while its partition are \
913 currently being used for swapping.\n");
914 return (-1);
915 }
916 /*
917 * Check for partitions being used in SVM, VxVM or LU devices
918 * in this format zone
919 */
920 if (checkdevinuse(cur_disk->disk_name, start, end, 0, 0)) {
921 err_print("Cannot format disk while its partitions "
922 "are currently in use.\n");
923 return (-1);
924 }
925
926 if (cur_disk->disk_lbasize != DEV_BSIZE) {
927 fmt_print("Current disk sector size is %d Byte, format\n"
928 "will change the sector size to 512 Byte. ",
929 cur_disk->disk_lbasize);
930 if (check("Continue")) {
931 return (-1);
932 }
933 }
934
935 /*
936 * set the default protection type
937 */
938 prot_type = PROT_TYPE_0;
939
940 /*
941 * Check if the protect information of this disk is enabled
942 */
943 if (uscsi_inquiry(cur_file, rawbuf, sizeof (rawbuf))) {
944 err_print("Inquiry failed\n");
945 return (-1);
946 }
947 inq = (struct scsi_inquiry *)rawbuf;
948 protect = inq->inq_protect;
949 if (protect == 0) {
950 fmt_print("The protection information is not enabled\n");
951 fmt_print(
952 "The disk will be formatted with protection type 0\n");
953 } else {
954 (void) memset(rawbuf, 0, MAX_MODE_SENSE_SIZE);
955 if (uscsi_inquiry_page_86h(cur_file, rawbuf, sizeof (rawbuf))) {
956 err_print("Inquiry with page 86h failed\n");
957 return (-1);
958 }
959 vpdhdr = (struct vpd_hdr *)rawbuf;
960 pagecode = vpdhdr->page_code;
961 if (pagecode != 0x86) {
962 err_print("Inquiry with page 86h failed\n");
963 return (-1);
964 }
965 spt = (rawbuf[4] << 2) >> 5;
966 fmt_print("This disk can support protection types:\n");
967
968 switch (spt) {
969 case 0:
970 prot_flag[1] = 1;
971 break;
972 case 1:
973 prot_flag[1] = 1;
974 prot_flag[2] = 1;
975 break;
976 case 2:
977 prot_flag[2] = 1;
978 break;
979 case 3:
980 prot_flag[1] = 1;
981 prot_flag[3] = 1;
982 break;
983 case 4:
984 prot_flag[3] = 1;
985 break;
986 case 5:
987 prot_flag[2] = 1;
988 prot_flag[3] = 1;
989 break;
990 case 7:
991 prot_flag[1] = 1;
992 prot_flag[2] = 1;
993 prot_flag[3] = 1;
994 break;
995 default:
996 err_print(
997 "Invalid supported protection types\n");
998 return (-1);
999 }
1000 for (i = 0; i < NUM_PROT_TYPE; i++) {
1001 if (prot_flag[i] == 1) {
1002 fmt_print("[%d] TYPE_%d : ", i, i);
1003 fmt_print("%s\n", prot_descriptor[i]);
1004 }
1005 }
1006
1007 /*
1008 * Get the current protection type
1009 */
1010 if (uscsi_read_capacity_16(cur_file, &capacity)) {
1011 err_print("Read capacity_16 failed\n");
1012 return (-1);
1013 }
1014 p_type = get_cur_protection_type(&capacity);
1015 fmt_print("\nThe disk is currently formatted with TYPE_%d.\n",
1016 p_type);
1017
1018 /*
1019 * Ask user what protection type to use
1020 */
1021 ioparam.io_bounds.lower = PROT_TYPE_0;
1022 ioparam.io_bounds.upper = PROT_TYPE_3;
1023 prot_type = input(FIO_INT, "Specify the New Protection Type",
1024 ':', &ioparam, NULL, DATA_INPUT);
1025 /*
1026 * if get a unsupported protection type, then use the
1027 * current type: p_type.
1028 */
1029 if (prot_flag[prot_type] == 0) {
1030 fmt_print("Unsupported protection type.\n");
1031 prot_type = p_type;
1032 }
1033 fmt_print("The disk will be formatted to type %d\n", prot_type);
1034 }
1035
1036 if (SCSI && (format_time = scsi_format_time()) > 0) {
1037 fmt_print(
1038 "\nReady to format. Formatting cannot be interrupted\n"
1039 "and takes %d minutes (estimated). ", format_time);
1040
1041 } else if (cur_dtype->dtype_options & SUP_FMTTIME) {
1042 /*
1043 * Formatting time is (2 * time of 1 spin * number of
1044 * tracks) + (step rate * number of cylinders) rounded
1045 * up to the nearest minute. Note, a 10% fudge factor
1046 * is thrown in for insurance.
1047 */
1048 if (cur_dtype->dtype_fmt_time == 0)
1049 cur_dtype->dtype_fmt_time = 2;
1050
1051 format_tracks = ((end-start) / cur_dtype->dtype_nsect) + 1;
1052 format_cyls = format_tracks / cur_dtype->dtype_nhead;
1053 format_tracks = format_tracks * cur_dtype->dtype_fmt_time;
1054
1055 /*
1056 * ms.
1057 */
1058 format_time = ((60000 / cur_dtype->dtype_rpm) +1) *
1059 format_tracks + format_cyls * 7;
1060 /*
1061 * 20% done tick (sec)
1062 */
1063 format_interval = format_time / 5000;
1064 /*
1065 * min.
1066 */
1067 format_time = (format_time + 59999) / 60000;
1068
1069 /*
1070 * Check format time values and make adjustments
1071 * to prevent sleeping too long (forever?) or
1072 * too short.
1073 */
1074 if (format_time <= 1) {
1075 /*
1076 * Format time is less than 1 min..
1077 */
1078 format_time = 1;
1079 }
1080
1081 if (format_interval < 11) {
1082 /* Format time is less than 1 minute. */
1083 if (format_interval < 2)
1084 format_interval = 2; /* failsafe */
1085 format_interval = 10;
1086 } else {
1087 /* Format time is greater than 1 minute. */
1088 format_interval -= 10;
1089 }
1090
1091 fmt_print(
1092 "Ready to format. Formatting cannot be interrupted\n"
1093 "and takes %d minutes (estimated). ", format_time);
1094 } else {
1095 fmt_print(
1096 "Ready to format. Formatting cannot be interrupted.\n");
1097 }
1098 if (check("Continue")) {
1099 return (-1);
1100 }
1101
1102 /*
1103 * Print the time so that the user will know when format started.
1104 * Lock out interrupts. This could be a problem, since it could
1105 * cause the user to sit for quite awhile with no control, but we
1106 * don't have any other good way of keeping their gun from going off.
1107 */
1108 clock = time(NULL);
1109 fmt_print("Beginning format. The current time is %s\n",
1110 ctime(&clock));
1111 enter_critical();
1112 /*
1113 * Mark the defect list dirty so it will be rewritten when we are
1114 * done. It is possible to qualify this so it doesn't always
1115 * get rewritten, but it's not worth the trouble.
1116 * Note: no defect lists for embedded scsi drives.
1117 */
1118 if (!EMBEDDED_SCSI) {
1119 cur_list.flags |= LIST_DIRTY;
1120 }
1121 /*
1122 * If we are formatting over any of the labels, mark the label
1123 * dirty so it will be rewritten.
1124 */
1125 if (cur_disk->label_type == L_TYPE_SOLARIS) {
1126 if (start < totalsects() && end >= datasects()) {
1127 if (cur_disk->disk_flags & DSK_LABEL)
1128 cur_flags |= LABEL_DIRTY;
1129 }
1130 } else if (cur_disk->label_type == L_TYPE_EFI) {
1131 if (start < cur_parts->etoc->efi_first_u_lba) {
1132 if (cur_disk->disk_flags & DSK_LABEL)
1133 cur_flags |= LABEL_DIRTY;
1134 }
1135 }
1136 if (start == 0) {
1137 cur_flags |= LABEL_DIRTY;
1138 }
1139 /*
1140 * Do the format. bugid 1009138 removed the use of fork to
1141 * background the format and print a tick.
1142 */
1143
1144 status = (*cur_ops->op_format)(start, end, &cur_list);
1145 if (status) {
1146 exit_critical();
1147 err_print("failed\n");
1148 return (-1);
1149 }
1150 fmt_print("done\n");
1151 if (option_msg && diag_msg) {
1152 clock = time((time_t *)0);
1153 fmt_print("The current time is %s\n", ctime(&clock));
1154 }
1155 cur_flags |= DISK_FORMATTED;
1156 /*
1157 * If the defect list or label is dirty, write them out again.
1158 * Note, for SCSI we have to wait til now to load defect list
1159 * since we can't access it until after formatting a virgin disk.
1160 */
1161 /* enter_critical(); */
1162 if (cur_list.flags & LIST_RELOAD) {
1163 assert(!EMBEDDED_SCSI);
1164 if (*cur_ops->op_ex_man == NULL ||
1165 (*cur_ops->op_ex_man)(&cur_list)) {
1166 err_print("Warning: unable to reload defect list\n");
1167 cur_list.flags &= ~LIST_DIRTY;
1168 return (-1);
1169 }
1170 cur_list.flags |= LIST_DIRTY;
1171 }
1172
1173 if (cur_list.flags & LIST_DIRTY) {
1174 assert(!EMBEDDED_SCSI);
1175 write_deflist(&cur_list);
1176 cur_list.flags = 0;
1177 }
1178 if (cur_flags & LABEL_DIRTY) {
1179 (void) write_label();
1180 cur_flags &= ~LABEL_DIRTY;
1181 }
1182 /*
1183 * Come up for air, since the verify step does not need to
1184 * be atomic (it does it's own lockouts when necessary).
1185 */
1186 exit_critical();
1187 /*
1188 * If we are supposed to verify, we do the 'write' test over
1189 * the format zone. The rest of the analysis parameters are
1190 * left the way they were.
1191 */
1192 if (scan_auto) {
1193 scan_entire = 0;
1194 scan_lower = start;
1195 scan_upper = end;
1196 fmt_print("\nVerifying media...");
1197 status = do_scan(SCAN_PATTERN, F_SILENT);
1198 }
1199 /*
1200 * If the defect list or label is dirty, write them out again.
1201 */
1202 if (cur_list.flags & LIST_DIRTY) {
1203 assert(!EMBEDDED_SCSI);
1204 cur_list.flags = 0;
1205 write_deflist(&cur_list);
1206 }
1207 if (cur_flags & LABEL_DIRTY) {
1208 cur_flags &= ~LABEL_DIRTY;
1209 (void) write_label();
1210 }
1211 return (status);
1212 }
1213
1214 /*
1215 * This routine implements the 'repair' command. It allows the user
1216 * to reallocate sectors on the disk that have gone bad.
1217 */
1218 int
c_repair(void)1219 c_repair(void)
1220 {
1221 diskaddr_t bn;
1222 int status;
1223 u_ioparam_t ioparam;
1224 char *buf;
1225 int buf_is_good;
1226 int block_has_error;
1227 int i;
1228
1229 /*
1230 * There must be a current disk type (and therefore a current disk).
1231 */
1232 if (cur_dtype == NULL) {
1233 err_print("Current Disk Type is not set.\n");
1234 return (-1);
1235 }
1236 /*
1237 * The current disk must be formatted for repair to work.
1238 */
1239 if (!(cur_flags & DISK_FORMATTED)) {
1240 err_print("Current Disk is unformatted.\n");
1241 return (-1);
1242 }
1243 /*
1244 * Check for a valid fdisk table entry for Solaris
1245 */
1246 if (!good_fdisk()) {
1247 return (-1);
1248 }
1249 /*
1250 * Repair is an optional command for controllers, so it may
1251 * not be supported.
1252 */
1253 if (cur_ops->op_repair == NULL) {
1254 err_print("Controller does not support repairing.\n");
1255 err_print("or disk supports automatic defect management.\n");
1256 return (-1);
1257 }
1258 /*
1259 * There must be a defect list for non-embedded scsi devices,
1260 * since we will add to it.
1261 */
1262 if (!EMBEDDED_SCSI && cur_list.list == NULL) {
1263 err_print("Current Defect List must be initialized.\n");
1264 return (-1);
1265 }
1266 /*
1267 * Ask the user which sector has gone bad.
1268 */
1269 ioparam.io_bounds.lower = 0;
1270 if (cur_disk->label_type == L_TYPE_SOLARIS) {
1271 ioparam.io_bounds.upper = physsects() - 1;
1272 } else {
1273 ioparam.io_bounds.upper = cur_parts->etoc->efi_last_lba;
1274 }
1275 bn = input(FIO_BN,
1276 "Enter absolute block number of defect", ':',
1277 &ioparam, NULL, DATA_INPUT);
1278 /*
1279 * Check to see if there is a mounted file system over the
1280 * specified sector. If there is, make sure the user is
1281 * really serious.
1282 */
1283 if (checkmount(bn, bn)) {
1284 if (check("Repair is in a mounted partition, continue"))
1285 return (-1);
1286 }
1287 /*
1288 * check for partitions being used for swapping in format zone
1289 */
1290 if (checkswap(bn, bn)) {
1291 if (check("Repair is in a partition which is currently \
1292 being used for swapping.\ncontinue"))
1293 return (-1);
1294 }
1295
1296 if (checkdevinuse(cur_disk->disk_name, bn, bn, 0, 0)) {
1297 if (check("Repair is in a partition which is currently "
1298 "in use.\ncontinue"))
1299 return (-1);
1300 }
1301
1302 buf = zalloc((cur_disk->disk_lbasize == 0) ?
1303 SECSIZE : cur_disk->disk_lbasize);
1304
1305 /*
1306 * Try to read the sector before repairing it. If we can
1307 * get good data out of it, we can write that data back
1308 * after the repair. If the sector looks ok, ask the
1309 * user to confirm the repair, since it doesn't appear
1310 * necessary. Try reading the block several times to
1311 * see if we can read it consistently.
1312 *
1313 * First, let's see if the block appears to have problems...
1314 */
1315 block_has_error = 1;
1316 for (i = 0; i < 5; i++) {
1317 status = (*cur_ops->op_rdwr)(DIR_READ, cur_file, bn,
1318 1, buf, (F_SILENT | F_ALLERRS), NULL);
1319 if (status)
1320 break; /* one of the tries failed */
1321 }
1322 if (status == 0) {
1323 block_has_error = 0;
1324 if (check("\
1325 This block doesn't appear to be bad. Repair it anyway")) {
1326 free(buf);
1327 return (0);
1328 }
1329 }
1330 /*
1331 * Last chance...
1332 */
1333 if (check("Ready to repair defect, continue")) {
1334 free(buf);
1335 return (-1);
1336 }
1337 /*
1338 * We're committed to repairing it. Try to get any good
1339 * data out of the block if possible. Note that we do
1340 * not set the F_ALLERRS flag.
1341 */
1342 buf_is_good = 0;
1343 for (i = 0; i < 5; i++) {
1344 status = (*cur_ops->op_rdwr)(DIR_READ, cur_file, bn,
1345 1, buf, F_SILENT, NULL);
1346 if (status == 0) {
1347 buf_is_good = 1;
1348 break;
1349 }
1350 }
1351 /*
1352 * Lock out interrupts so the disk can't get out of sync with
1353 * the defect list.
1354 */
1355 enter_critical();
1356
1357 fmt_print("Repairing ");
1358 if (block_has_error) {
1359 fmt_print("%s error on ", buf_is_good ? "soft" : "hard");
1360 }
1361 fmt_print("block %llu (", bn);
1362 pr_dblock(fmt_print, bn);
1363 fmt_print(")...");
1364 /*
1365 * Do the repair.
1366 */
1367 status = (*cur_ops->op_repair)(bn, F_NORMAL);
1368 if (status) {
1369 fmt_print("failed.\n\n");
1370 } else {
1371 /*
1372 * The repair worked. Write the old data to the new
1373 * block if we were able to read it, otherwise
1374 * zero out the new block. If it looks like the
1375 * new block is bad, let the user know that, too.
1376 * Should we attempt auto-repair in this case?
1377 */
1378 fmt_print("ok.\n");
1379 if (!buf_is_good) {
1380 bzero(buf, cur_disk->disk_lbasize);
1381 }
1382 status = (*cur_ops->op_rdwr)(DIR_WRITE, cur_file, bn,
1383 1, buf, (F_SILENT | F_ALLERRS), NULL);
1384 if (status == 0) {
1385 status = (*cur_ops->op_rdwr)(DIR_READ, cur_file,
1386 bn, 1, buf, (F_SILENT | F_ALLERRS), NULL);
1387 }
1388 if (status) {
1389 fmt_print("The new block %llu (", bn);
1390 pr_dblock(fmt_print, bn);
1391 fmt_print(") also appears defective.\n");
1392 }
1393 fmt_print("\n");
1394 /*
1395 * Add the bad sector to the defect list, write out
1396 * the defect list, and kill off the working list so
1397 * it will get synced up with the current defect list
1398 * next time we need it.
1399 *
1400 * For embedded scsi, we don't require a defect list.
1401 * However, if we have one, add the defect if the
1402 * list includes the grown list. If not, kill it
1403 * to force a resync if we need the list later.
1404 */
1405 if (EMBEDDED_SCSI) {
1406 if (cur_list.list != NULL) {
1407 if (cur_list.flags & LIST_PGLIST) {
1408 add_ldef(bn, &cur_list);
1409 } else {
1410 kill_deflist(&cur_list);
1411 }
1412 }
1413 } else if (cur_ctype->ctype_flags & CF_WLIST) {
1414 kill_deflist(&cur_list);
1415 if (*cur_ops->op_ex_cur != NULL) {
1416 (*cur_ops->op_ex_cur)(&cur_list);
1417 fmt_print("Current list updated\n");
1418 }
1419 } else {
1420 add_ldef(bn, &cur_list);
1421 write_deflist(&cur_list);
1422 }
1423 kill_deflist(&work_list);
1424 }
1425 exit_critical();
1426 free(buf);
1427
1428 /*
1429 * Return status.
1430 */
1431 return (status);
1432 }
1433
1434 /*
1435 * This routine implements the 'show' command. It translates a disk
1436 * block given in any format into decimal, hexadecimal, and
1437 * cylinder/head/sector format.
1438 */
1439 int
c_show(void)1440 c_show(void)
1441 {
1442 u_ioparam_t ioparam;
1443 diskaddr_t bn;
1444
1445 /*
1446 * There must be a current disk type, so we will know the geometry.
1447 */
1448 if (cur_dtype == NULL) {
1449 err_print("Current Disk Type is not set.\n");
1450 return (-1);
1451 }
1452 /*
1453 * Ask the user for a disk block.
1454 */
1455 ioparam.io_bounds.lower = 0;
1456 if (cur_disk->label_type == L_TYPE_SOLARIS) {
1457 ioparam.io_bounds.upper = physsects() - 1;
1458 } else {
1459 ioparam.io_bounds.upper = cur_parts->etoc->efi_last_lba;
1460 }
1461 bn = input(FIO_BN, "Enter a disk block", ':',
1462 &ioparam, NULL, DATA_INPUT);
1463 /*
1464 * Echo it back.
1465 */
1466 fmt_print("Disk block = %lld = 0x%llx = (", bn, bn);
1467 pr_dblock(fmt_print, bn);
1468 fmt_print(")\n\n");
1469 return (0);
1470 }
1471
1472 /*
1473 * This routine implements the 'label' command. It writes the
1474 * primary and backup labels onto the current disk.
1475 */
1476 int
c_label(void)1477 c_label(void)
1478 {
1479 int status;
1480 int deflt, *defltptr = NULL;
1481
1482 /*
1483 * There must be a current disk type (and therefore a current disk).
1484 */
1485 if (cur_dtype == NULL) {
1486 err_print("Current Disk Type is not set.\n");
1487 return (-1);
1488 }
1489 /*
1490 * The current disk must be formatted to label it.
1491 */
1492 if (!(cur_flags & DISK_FORMATTED)) {
1493 err_print("Current Disk is unformatted.\n");
1494 return (-1);
1495 }
1496 /*
1497 * Check for a valid fdisk table entry for Solaris
1498 */
1499 if (!good_fdisk()) {
1500 return (-1);
1501 }
1502 /*
1503 * Check to see if there are any mounted file systems anywhere
1504 * on the current disk. If so, refuse to label the disk, but
1505 * only if the partitions would change for the mounted partitions.
1506 *
1507 */
1508 if (checkmount((diskaddr_t)-1, (diskaddr_t)-1)) {
1509 /* Bleagh, too descriptive */
1510 if (check_label_with_mount()) {
1511 err_print("Cannot label disk while it has "
1512 "mounted partitions.\n\n");
1513 return (-1);
1514 }
1515 }
1516
1517 /*
1518 * check to see if there any partitions being used for swapping
1519 * on the current disk. If so, refuse to label the disk, but
1520 * only if the partitions would change for the mounted partitions.
1521 */
1522 if (checkswap((diskaddr_t)-1, (diskaddr_t)-1)) {
1523 if (check_label_with_swap()) {
1524 err_print("Cannot label disk while its "
1525 "partitions are currently being used for "
1526 "swapping.\n");
1527 return (-1);
1528 }
1529 }
1530
1531 /*
1532 * Check to see if any partitions used for svm, vxvm or live upgrade
1533 * are on the disk. If so, refuse to label the disk, but only
1534 * if we are trying to shrink a partition in use.
1535 */
1536 if (checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1,
1537 (diskaddr_t)-1, 0, 1)) {
1538 err_print("Cannot label disk when "
1539 "partitions are in use as described.\n");
1540 return (-1);
1541 }
1542
1543 /*
1544 * If there is not a current partition map, warn the user we
1545 * are going to use the default. The default is the first
1546 * partition map we encountered in the data file. If there is
1547 * no default we give up.
1548 */
1549 if (cur_parts == NULL) {
1550 fmt_print("Current Partition Table is not set, "
1551 "using default.\n");
1552 cur_disk->disk_parts = cur_parts = cur_dtype->dtype_plist;
1553 if (cur_parts == NULL) {
1554 err_print("No default available, cannot label.\n");
1555 return (-1);
1556 }
1557 }
1558 /*
1559 * If expert (-e) mode, then ask user if they wish
1560 * to change the current solaris label into an EFI one
1561 */
1562 if (expert_mode) {
1563 #if defined(_SUNOS_VTOC_8)
1564 int i;
1565 #endif
1566 int choice;
1567 u_ioparam_t ioparam;
1568 struct extvtoc vtoc;
1569 struct dk_label label;
1570 struct dk_gpt *vtoc64;
1571 struct efi_info efinfo;
1572 struct disk_type *dptr;
1573
1574 /* Ask user what label to use */
1575 fmt_print("[0] SMI Label\n");
1576 fmt_print("[1] EFI Label\n");
1577 ioparam.io_bounds.lower = 0;
1578 ioparam.io_bounds.upper = 1;
1579 if ((cur_label == L_TYPE_SOLARIS) &&
1580 (cur_disk->fdisk_part.systid != EFI_PMBR))
1581 deflt = L_TYPE_SOLARIS;
1582 else
1583 deflt = L_TYPE_EFI;
1584 defltptr = &deflt;
1585 choice = input(FIO_INT, "Specify Label type", ':',
1586 &ioparam, defltptr, DATA_INPUT);
1587 if ((choice == L_TYPE_SOLARIS) &&
1588 (cur_label == L_TYPE_SOLARIS) &&
1589 (cur_disk->fdisk_part.systid != EFI_PMBR)) {
1590 goto expert_end;
1591 } else if ((choice == L_TYPE_EFI) &&
1592 (cur_label == L_TYPE_EFI)) {
1593 goto expert_end;
1594 }
1595 switch (choice) {
1596 case L_TYPE_SOLARIS:
1597 /*
1598 * EFI label to SMI label
1599 */
1600 if (cur_dtype->capacity > INFINITY) {
1601 fmt_print("Warning: SMI labels only support up to "
1602 "2 TB.\n");
1603 }
1604
1605 if (cur_disk->fdisk_part.systid == EFI_PMBR) {
1606 fmt_print("Warning: This disk has an EFI label. "
1607 "Changing to SMI label will erase all\n"
1608 "current partitions.\n");
1609 if (check("Continue"))
1610 return (-1);
1611 #if defined(_FIRMWARE_NEEDS_FDISK)
1612 fmt_print("You must use fdisk to delete the current "
1613 "EFI partition and create a new\n"
1614 "Solaris partition before you can convert the "
1615 "label.\n");
1616 return (-1);
1617 #endif
1618 }
1619
1620 #if defined(_FIRMWARE_NEEDS_FDISK)
1621 if (!(((cur_disk->fdisk_part.systid != SUNIXOS) ||
1622 (cur_disk->fdisk_part.systid != SUNIXOS2)) &&
1623 (cur_disk->fdisk_part.numsect > 0))) {
1624 fmt_print("You must use fdisk to create a Solaris "
1625 "partition before you can convert the label.\n");
1626 return (-1);
1627 }
1628 #endif
1629
1630 (void) memset((char *)&label, 0, sizeof (struct dk_label));
1631
1632 (void) strcpy(x86_devname, cur_disk->disk_name);
1633 if (cur_ctype->ctype_ctype == DKC_DIRECT ||
1634 cur_ctype->ctype_ctype == DKC_BLKDEV)
1635 dptr = auto_direct_get_geom_label(cur_file, &label);
1636 else
1637 dptr = auto_sense(cur_file, 1, &label);
1638 if (dptr == NULL) {
1639 fmt_print("Autoconfiguration failed.\n");
1640 return (-1);
1641 }
1642
1643 pcyl = label.dkl_pcyl;
1644 ncyl = label.dkl_ncyl;
1645 acyl = label.dkl_acyl;
1646 nhead = label.dkl_nhead;
1647 nsect = label.dkl_nsect;
1648
1649 if (delete_disk_type(cur_disk->disk_type) == 0) {
1650 cur_label = L_TYPE_SOLARIS;
1651 cur_disk->label_type = L_TYPE_SOLARIS;
1652 cur_disk->disk_type = dptr;
1653 cur_disk->disk_parts = dptr->dtype_plist;
1654 cur_dtype = dptr;
1655 cur_parts = dptr->dtype_plist;
1656
1657 if (status = write_label())
1658 err_print("Label failed.\n");
1659 else
1660 cur_disk->disk_flags &= ~DSK_LABEL_DIRTY;
1661
1662 return (status);
1663 } else {
1664 err_print("Label failed.\n");
1665 return (-1);
1666 }
1667
1668
1669 case L_TYPE_EFI:
1670 /*
1671 * SMI label to EFI label
1672 */
1673
1674 if ((cur_disk->fdisk_part.systid == SUNIXOS) ||
1675 (cur_disk->fdisk_part.systid == SUNIXOS2)) {
1676 fmt_print("Warning: This disk has an SMI label. "
1677 "Changing to EFI label will erase all\ncurrent "
1678 "partitions.\n");
1679 if (check("Continue")) {
1680 return (-1);
1681 }
1682 }
1683
1684 if (get_disk_info(cur_file, &efinfo, cur_disk) != 0) {
1685 return (-1);
1686 }
1687 (void) memset((char *)&label, 0, sizeof (struct dk_label));
1688 label.dkl_pcyl = pcyl;
1689 label.dkl_ncyl = ncyl;
1690 label.dkl_acyl = acyl;
1691 #if defined(_SUNOS_VTOC_16)
1692 label.dkl_bcyl = bcyl;
1693 #endif /* defined(_SUNOC_VTOC_16) */
1694 label.dkl_nhead = nhead;
1695 label.dkl_nsect = nsect;
1696 #if defined(_SUNOS_VTOC_8)
1697 for (i = 0; i < NDKMAP; i++) {
1698 label.dkl_map[i] = cur_parts->pinfo_map[i];
1699 }
1700 #endif /* defined(_SUNOS_VTOC_8) */
1701 label.dkl_magic = DKL_MAGIC;
1702 label.dkl_vtoc = cur_parts->vtoc;
1703 if (label_to_vtoc(&vtoc, &label) == -1) {
1704 return (-1);
1705 }
1706 if (SMI_vtoc_to_EFI(cur_file, &vtoc64) == -1) {
1707 return (-1);
1708 }
1709 if (efi_write(cur_file, vtoc64) != 0) {
1710 efi_err_check(vtoc64);
1711 err_print("Warning: error writing EFI.\n");
1712 return (-1);
1713 } else {
1714 cur_disk->disk_flags &= ~DSK_LABEL_DIRTY;
1715 }
1716 /*
1717 * copy over the EFI vtoc onto the SMI vtoc and return
1718 * okay.
1719 */
1720 dptr = auto_efi_sense(cur_file, &efinfo);
1721 if (dptr == NULL) {
1722 fmt_print("Autoconfiguration failed.\n");
1723 return (-1);
1724 }
1725
1726 cur_label = L_TYPE_EFI;
1727 cur_disk->label_type = L_TYPE_EFI;
1728 cur_disk->disk_type = dptr;
1729 cur_disk->disk_parts = dptr->dtype_plist;
1730 cur_dtype = dptr;
1731 cur_parts = dptr->dtype_plist;
1732 cur_parts->etoc = vtoc64;
1733
1734 ncyl = pcyl = nsect = psect = acyl = phead = 0;
1735
1736 /*
1737 * Get the Solais Fdisk Partition information.
1738 */
1739 (void) copy_solaris_part(&cur_disk->fdisk_part);
1740
1741 return (0);
1742 }
1743 }
1744
1745 expert_end:
1746 /*
1747 * Make sure the user is serious.
1748 */
1749 if (check("Ready to label disk, continue")) {
1750 return (-1);
1751 }
1752 /*
1753 * Write the labels out (this will also notify unix) and
1754 * return status.
1755 */
1756 fmt_print("\n");
1757 if (status = write_label())
1758 err_print("Label failed.\n");
1759 return (status);
1760 }
1761
1762 /*
1763 * This routine implements the 'analyze' command. It simply runs
1764 * the analyze menu.
1765 */
1766 int
c_analyze(void)1767 c_analyze(void)
1768 {
1769
1770 /*
1771 * There must be a current disk type (and therefor a current disk).
1772 */
1773 if (cur_dtype == NULL) {
1774 err_print("Current Disk Type is not set.\n");
1775 return (-1);
1776 }
1777 cur_menu++;
1778 last_menu = cur_menu;
1779
1780 /*
1781 * Run the menu.
1782 */
1783 run_menu(menu_analyze, "ANALYZE", "analyze", 0);
1784 cur_menu--;
1785 return (0);
1786 }
1787
1788 /*
1789 * This routine implements the 'defect' command. It simply runs
1790 * the defect menu.
1791 */
1792 int
c_defect(void)1793 c_defect(void)
1794 {
1795 int i;
1796
1797 /*
1798 * There must be a current disk type (and therefor a current disk).
1799 */
1800 if (cur_dtype == NULL) {
1801 err_print("Current Disk Type is not set.\n");
1802 return (-1);
1803 }
1804
1805 /*
1806 * Check for the defect management and list management ops and
1807 * display appropriate message.
1808 */
1809 if ((cur_ops->op_ex_man == NULL) && (cur_ops->op_ex_cur == NULL) &&
1810 (cur_ops->op_create == NULL) && (cur_ops->op_wr_cur == NULL)) {
1811 err_print("Controller does not support defect management\n");
1812 err_print("or disk supports automatic defect management.\n");
1813 return (-1);
1814 }
1815 cur_menu++;
1816 last_menu = cur_menu;
1817
1818 /*
1819 * Lock out interrupt while we manipulate the defect lists.
1820 */
1821 enter_critical();
1822 /*
1823 * If the working list is null but there is a current list,
1824 * update the working list to be a copy of the current list.
1825 */
1826 if ((work_list.list == NULL) && (cur_list.list != NULL)) {
1827 work_list.header = cur_list.header;
1828 work_list.list = (struct defect_entry *)zalloc(
1829 deflist_size(cur_blksz, work_list.header.count) *
1830 cur_blksz);
1831 for (i = 0; i < work_list.header.count; i++)
1832 *(work_list.list + i) = *(cur_list.list + i);
1833 work_list.flags = cur_list.flags & LIST_PGLIST;
1834 }
1835 exit_critical();
1836 /*
1837 * Run the menu.
1838 */
1839 run_menu(menu_defect, "DEFECT", "defect", 0);
1840 cur_menu--;
1841
1842 /*
1843 * If the user has modified the working list but not committed
1844 * it, warn them that they are probably making a mistake.
1845 */
1846 if (work_list.flags & LIST_DIRTY) {
1847 if (!EMBEDDED_SCSI) {
1848 err_print(
1849 "Warning: working defect list modified; but not committed.\n");
1850 if (!check(
1851 "Do you wish to commit changes to current defect list"))
1852 (void) do_commit();
1853 }
1854 }
1855 return (0);
1856 }
1857
1858 /*
1859 * This routine implements the 'backup' command. It allows the user
1860 * to search for backup labels on the current disk. This is useful
1861 * if the primary label was lost and the user wishes to recover the
1862 * partition information for the disk. The disk is relabeled and
1863 * the current defect list is written out if a backup label is found.
1864 */
1865 int
c_backup(void)1866 c_backup(void)
1867 {
1868 struct dk_label label;
1869 struct disk_type *dtype;
1870 struct partition_info *parts, *plist;
1871 diskaddr_t bn;
1872 int sec, head, i;
1873 char *buf;
1874
1875 /*
1876 * There must be a current disk type (and therefore a current disk).
1877 */
1878 if (cur_dtype == NULL) {
1879 err_print("Current Disk Type is not set.\n");
1880 return (-1);
1881 }
1882 /*
1883 * The disk must be formatted to read backup labels.
1884 */
1885 if (!(cur_flags & DISK_FORMATTED)) {
1886 err_print("Current Disk is unformatted.\n");
1887 return (-1);
1888 }
1889 /*
1890 * Check for a valid fdisk table entry for Solaris
1891 */
1892 if (!good_fdisk()) {
1893 return (-1);
1894 }
1895 /*
1896 * If we found a primary label on this disk, make sure
1897 * the user is serious.
1898 */
1899 if (cur_disk->label_type == L_TYPE_EFI) {
1900 if (((cur_disk->disk_parts->etoc->efi_flags &
1901 EFI_GPT_PRIMARY_CORRUPT) == 0) &&
1902 check("Disk has a primary label, still continue"))
1903 return (-1);
1904 fmt_print("Restoring primary label.\n");
1905 if (write_label()) {
1906 err_print("Failed\n");
1907 return (-1);
1908 }
1909 return (0);
1910 } else if (((cur_disk->disk_flags & (DSK_LABEL | DSK_LABEL_DIRTY)) ==
1911 DSK_LABEL) &&
1912 (check("Disk has a primary label, still continue"))) {
1913 return (-1);
1914 }
1915
1916 buf = zalloc(cur_blksz);
1917 fmt_print("Searching for backup labels...");
1918 (void) fflush(stdout);
1919
1920 /*
1921 * Some disks have the backup labels in a strange place.
1922 */
1923 if (cur_ctype->ctype_flags & CF_BLABEL)
1924 head = 2;
1925 else
1926 head = nhead - 1;
1927 /*
1928 * Loop through each copy of the backup label.
1929 */
1930 for (sec = 1; ((sec < BAD_LISTCNT * 2 + 1) && (sec < nsect));
1931 sec += 2) {
1932 bn = chs2bn(ncyl + acyl - 1, head, sec) + solaris_offset;
1933 /*
1934 * Attempt to read it.
1935 */
1936 if ((*cur_ops->op_rdwr)(DIR_READ, cur_file, bn,
1937 1, buf, F_NORMAL, NULL)) {
1938 continue;
1939 }
1940
1941 (void) memcpy((char *)&label, buf, sizeof (struct dk_label));
1942
1943 /*
1944 * Verify that it is a reasonable label.
1945 */
1946 if (!checklabel(&label))
1947 continue;
1948 if (trim_id(label.dkl_asciilabel))
1949 continue;
1950 /*
1951 * Lock out interrupts while we manipulate lists.
1952 */
1953 enter_critical();
1954 fmt_print("found.\n");
1955 /*
1956 * Find out which disk type the backup label claims.
1957 */
1958 for (dtype = cur_ctype->ctype_dlist; dtype != NULL;
1959 dtype = dtype->dtype_next)
1960 if (dtype_match(&label, dtype))
1961 break;
1962 /*
1963 * If it disagrees with our current type, something
1964 * real bad is happening.
1965 */
1966 if (dtype != cur_dtype) {
1967 if (dtype == NULL) {
1968 fmt_print("\
1969 Unknown disk type in backup label\n");
1970 exit_critical();
1971 free(buf);
1972 return (-1);
1973 }
1974 fmt_print("Backup label claims different type:\n");
1975 fmt_print(" <%s cyl %d alt %d hd %d sec %d>\n",
1976 label.dkl_asciilabel, label.dkl_ncyl,
1977 label.dkl_acyl, label.dkl_nhead,
1978 label.dkl_nsect);
1979 if (check("Continue")) {
1980 exit_critical();
1981 free(buf);
1982 return (-1);
1983 }
1984 cur_dtype = dtype;
1985 }
1986 /*
1987 * Try to match the partition map with a known map.
1988 */
1989 for (parts = dtype->dtype_plist; parts != NULL;
1990 parts = parts->pinfo_next)
1991 if (parts_match(&label, parts))
1992 break;
1993 /*
1994 * If we couldn't match it, allocate space for a new one,
1995 * fill in the info, and add it to the list. The name
1996 * for the new map is derived from the disk name.
1997 */
1998 if (parts == NULL) {
1999 parts = (struct partition_info *)
2000 zalloc(sizeof (struct partition_info));
2001 plist = dtype->dtype_plist;
2002 if (plist == NULL)
2003 dtype->dtype_plist = parts;
2004 else {
2005 while (plist->pinfo_next != NULL)
2006 plist = plist->pinfo_next;
2007 plist->pinfo_next = parts;
2008 }
2009 parts->pinfo_name = alloc_string("original");
2010 for (i = 0; i < NDKMAP; i++) {
2011
2012 #if defined(_SUNOS_VTOC_8)
2013 parts->pinfo_map[i] = label.dkl_map[i];
2014
2015 #elif defined(_SUNOS_VTOC_16)
2016 parts->pinfo_map[i].dkl_cylno =
2017 label.dkl_vtoc.v_part[i].p_start / spc();
2018 parts->pinfo_map[i].dkl_nblk =
2019 label.dkl_vtoc.v_part[i].p_size;
2020 #else
2021 #error No VTOC layout defined.
2022 #endif /* defined(_SUNOS_VTOC_8) */
2023 }
2024 parts->vtoc = label.dkl_vtoc;
2025 }
2026 /*
2027 * We now have a partition map. Make it the current map.
2028 */
2029 cur_disk->disk_parts = cur_parts = parts;
2030 exit_critical();
2031 /*
2032 * Rewrite the labels and defect lists, as appropriate.
2033 */
2034 if (EMBEDDED_SCSI) {
2035 fmt_print("Restoring primary label.\n");
2036 if (write_label()) {
2037 free(buf);
2038 return (-1);
2039 }
2040 } else {
2041 fmt_print("Restoring primary label and defect list.\n");
2042 if (write_label()) {
2043 free(buf);
2044 return (-1);
2045 }
2046 if (cur_list.list != NULL)
2047 write_deflist(&cur_list);
2048 }
2049 fmt_print("\n");
2050 free(buf);
2051 return (0);
2052 }
2053 /*
2054 * If we didn't find any backup labels, say so.
2055 */
2056 fmt_print("not found.\n\n");
2057 free(buf);
2058 return (0);
2059 }
2060
2061 /*
2062 * This routine is called by c_verify() for an EFI labeled disk
2063 */
2064 static int
c_verify_efi(void)2065 c_verify_efi(void)
2066 {
2067 struct efi_info efi_info;
2068 struct partition_info tmp_pinfo;
2069 int status;
2070
2071 status = read_efi_label(cur_file, &efi_info, cur_disk);
2072 if (status != 0) {
2073 err_print("Warning: Could not read label.\n");
2074 return (-1);
2075 }
2076 if (cur_parts->etoc->efi_flags & EFI_GPT_PRIMARY_CORRUPT) {
2077 err_print("Reading the primary EFI GPT label ");
2078 err_print("failed. Using backup label.\n");
2079 err_print("Use the 'backup' command to restore ");
2080 err_print("the primary label.\n");
2081 }
2082 tmp_pinfo.etoc = efi_info.e_parts;
2083 fmt_print("\n");
2084 fmt_print("Volume name = <%8s>\n",
2085 cur_parts->etoc->efi_parts[8].p_name);
2086 fmt_print("ascii name = ");
2087 print_efi_string(efi_info.vendor, efi_info.product,
2088 efi_info.revision, efi_info.capacity);
2089 fmt_print("\n");
2090
2091 fmt_print("bytes/sector = %d\n", cur_blksz);
2092 fmt_print("sectors = %llu\n", cur_parts->etoc->efi_last_lba + 1);
2093 fmt_print("accessible sectors = %llu\n",
2094 cur_parts->etoc->efi_last_u_lba -
2095 cur_parts->etoc->efi_first_u_lba -
2096 efi_reserved_sectors(cur_parts->etoc) + 1);
2097 fmt_print("first usable sector = %llu\n",
2098 cur_parts->etoc->efi_first_u_lba);
2099 fmt_print("last usable sector = %llu\n",
2100 cur_parts->etoc->efi_last_u_lba);
2101
2102 print_map(&tmp_pinfo);
2103
2104 free(efi_info.vendor);
2105 free(efi_info.product);
2106 free(efi_info.revision);
2107 return (0);
2108 }
2109
2110 /*
2111 * This routine implements the 'verify' command. It allows the user
2112 * to read the labels on the current disk.
2113 */
2114 int
c_verify(void)2115 c_verify(void)
2116 {
2117 struct dk_label p_label, b_label, *label;
2118 struct partition_info tmp_pinfo;
2119 diskaddr_t bn;
2120 int sec, head, i, status;
2121 int p_label_bad = 0;
2122 int b_label_bad = 0;
2123 int p_label_found = 0;
2124 int b_label_found = 0;
2125 char id_str[128];
2126 char *buf;
2127
2128 /*
2129 * There must be a current disk type (and therefore a current disk).
2130 */
2131 if (cur_dtype == NULL) {
2132 err_print("Current Disk Type is not set.\n");
2133 return (-1);
2134 }
2135 /*
2136 * The disk must be formatted to read labels.
2137 */
2138 if (!(cur_flags & DISK_FORMATTED)) {
2139 err_print("Current Disk is unformatted.\n");
2140 return (-1);
2141 }
2142 /*
2143 * Check for a valid fdisk table entry for Solaris
2144 */
2145 if (!good_fdisk()) {
2146 return (-1);
2147 }
2148 /*
2149 * Branch off here if the disk is EFI labelled.
2150 */
2151 if (cur_label == L_TYPE_EFI) {
2152 return (c_verify_efi());
2153 }
2154 /*
2155 * Attempt to read the primary label.
2156 */
2157 status = read_label(cur_file, &p_label);
2158 if (status == -1) {
2159 err_print("Warning: Could not read primary label.\n");
2160 p_label_bad = 1;
2161 } else {
2162 /*
2163 * Verify that it is a reasonable label.
2164 */
2165 /*
2166 * Save complete ascii string for printing later.
2167 */
2168 (void) strncpy(id_str, p_label.dkl_asciilabel, 128);
2169
2170 if ((!checklabel((struct dk_label *)&p_label)) ||
2171 (trim_id(p_label.dkl_asciilabel))) {
2172 err_print("\
2173 Warning: Primary label appears to be corrupt.\n");
2174 p_label_bad = 1;
2175 } else {
2176 p_label_found = 1;
2177 /*
2178 * Make sure it matches current label
2179 */
2180 if ((!dtype_match(&p_label, cur_dtype)) ||
2181 (!parts_match(&p_label, cur_parts))) {
2182 err_print("\
2183 Warning: Primary label on disk appears to be different from\ncurrent label.\n");
2184 p_label_bad = 1;
2185 }
2186 }
2187 }
2188
2189 /*
2190 * Read backup labels.
2191 * Some disks have the backup labels in a strange place.
2192 */
2193 if (cur_ctype->ctype_flags & CF_BLABEL)
2194 head = 2;
2195 else
2196 head = nhead - 1;
2197
2198 buf = zalloc(cur_blksz);
2199 /*
2200 * Loop through each copy of the backup label.
2201 */
2202 for (sec = 1; ((sec < BAD_LISTCNT * 2 + 1) && (sec < nsect));
2203 sec += 2) {
2204 bn = chs2bn(ncyl + acyl - 1, head, sec) + solaris_offset;
2205 /*
2206 * Attempt to read it.
2207 */
2208 if ((*cur_ops->op_rdwr)(DIR_READ, cur_file, bn,
2209 1, buf, F_NORMAL, NULL))
2210 continue;
2211
2212 (void) memcpy((char *)&b_label, buf,
2213 sizeof (struct dk_label));
2214
2215 /*
2216 * Verify that it is a reasonable label.
2217 */
2218 if (!checklabel(&b_label))
2219 continue;
2220
2221 /*
2222 * Save complete label only if no primary label exists
2223 */
2224 if (!p_label_found)
2225 (void) strncpy(id_str, b_label.dkl_asciilabel, 128);
2226
2227 if (trim_id(b_label.dkl_asciilabel))
2228 continue;
2229 b_label_found = 1;
2230 /*
2231 * Compare against primary label
2232 */
2233 if (p_label_found) {
2234 if ((strcmp(b_label.dkl_asciilabel,
2235 p_label.dkl_asciilabel) != 0) ||
2236 (b_label.dkl_ncyl != p_label.dkl_ncyl) ||
2237 (b_label.dkl_acyl != p_label.dkl_acyl) ||
2238 (b_label.dkl_nhead != p_label.dkl_nhead) ||
2239 (b_label.dkl_nsect != p_label.dkl_nsect)) {
2240 b_label_bad = 1;
2241 } else {
2242 for (i = 0; i < NDKMAP; i++) {
2243 #if defined(_SUNOS_VTOC_8)
2244 if ((b_label.dkl_map[i].dkl_cylno !=
2245 p_label.dkl_map[i].dkl_cylno) ||
2246 (b_label.dkl_map[i].dkl_nblk !=
2247 p_label.dkl_map[i].dkl_nblk)) {
2248 b_label_bad = 1;
2249 break;
2250 }
2251
2252 #elif defined(_SUNOS_VTOC_16)
2253 if ((b_label.dkl_vtoc.v_part[i].p_tag !=
2254 p_label.dkl_vtoc.v_part[i].p_tag) ||
2255 (b_label.dkl_vtoc.v_part[i].p_flag
2256 != p_label.dkl_vtoc.v_part[i].
2257 p_flag) ||
2258 (b_label.dkl_vtoc.v_part[i].p_start
2259 != p_label.dkl_vtoc.v_part[i].
2260 p_start) ||
2261 (b_label.dkl_vtoc.v_part[i].p_size
2262 != p_label.dkl_vtoc.v_part[i].
2263 p_size)) {
2264 b_label_bad = 1;
2265 break;
2266 }
2267 #else
2268 #error No VTOC layout defined.
2269 #endif /* defined(_SUNOS_VTOC_8) */
2270 }
2271 }
2272 }
2273 if (b_label_bad)
2274 err_print(
2275 "Warning: Primary and backup labels do not match.\n");
2276 break;
2277 }
2278 /*
2279 * If we didn't find any backup labels, say so.
2280 */
2281 if (!b_label_found)
2282 err_print("Warning: Could not read backup labels.\n");
2283
2284 if ((!b_label_found) || (p_label_bad) || (b_label_bad))
2285 err_print("\n\
2286 Warning: Check the current partitioning and 'label' the disk or use the\n\
2287 \t 'backup' command.\n");
2288
2289 /*
2290 * Print label information.
2291 */
2292 if (p_label_found) {
2293 fmt_print("\nPrimary label contents:\n");
2294 label = &p_label;
2295 } else if (b_label_found) {
2296 fmt_print("\nBackup label contents:\n");
2297 label = &b_label;
2298 } else {
2299 free(buf);
2300 return (0);
2301 }
2302
2303 /*
2304 * Must put info into partition_info struct for
2305 * for print routine.
2306 */
2307 bzero(&tmp_pinfo, sizeof (struct partition_info));
2308 for (i = 0; i < NDKMAP; i++) {
2309
2310 #if defined(_SUNOS_VTOC_8)
2311 tmp_pinfo.pinfo_map[i] = label->dkl_map[i];
2312
2313 #elif defined(_SUNOS_VTOC_16)
2314 tmp_pinfo.pinfo_map[i].dkl_cylno =
2315 label->dkl_vtoc.v_part[i].p_start / spc();
2316 tmp_pinfo.pinfo_map[i].dkl_nblk =
2317 label->dkl_vtoc.v_part[i].p_size;
2318 #else
2319 #error No VTOC layout defined.
2320 #endif /* defined(_SUNOS_VTOC_8) */
2321 }
2322 tmp_pinfo.vtoc = label->dkl_vtoc;
2323
2324 fmt_print("\n");
2325 fmt_print("Volume name = <%8s>\n", label->dkl_vtoc.v_volume);
2326 fmt_print("ascii name = <%s>\n", id_str);
2327 fmt_print("pcyl = %4d\n", label->dkl_pcyl);
2328 fmt_print("ncyl = %4d\n", label->dkl_ncyl);
2329 fmt_print("acyl = %4d\n", label->dkl_acyl);
2330
2331 #if defined(_SUNOS_VTOC_16)
2332 fmt_print("bcyl = %4d\n", label->dkl_bcyl);
2333 #endif /* defined(_SUNOS_VTOC_16) */
2334
2335 fmt_print("nhead = %4d\n", label->dkl_nhead);
2336 fmt_print("nsect = %4d\n", label->dkl_nsect);
2337
2338 print_map(&tmp_pinfo);
2339 free(buf);
2340 return (0);
2341 }
2342
2343
2344 /*
2345 * This command implements the inquiry command, for embedded SCSI
2346 * disks only, which issues a SCSI inquiry command, and
2347 * displays the resulting vendor, product id and revision level.
2348 */
2349 int
c_inquiry(void)2350 c_inquiry(void)
2351 {
2352 char inqbuf[255];
2353 struct scsi_inquiry *inq;
2354
2355 assert(SCSI);
2356
2357 inq = (struct scsi_inquiry *)inqbuf;
2358
2359 if (uscsi_inquiry(cur_file, inqbuf, sizeof (inqbuf))) {
2360 err_print("Failed\n");
2361 return (-1);
2362 } else {
2363 fmt_print("Vendor: ");
2364 print_buf(inq->inq_vid, sizeof (inq->inq_vid));
2365 fmt_print("\nProduct: ");
2366 print_buf(inq->inq_pid, sizeof (inq->inq_pid));
2367 fmt_print("\nRevision: ");
2368 print_buf(inq->inq_revision, sizeof (inq->inq_revision));
2369 fmt_print("\n");
2370 }
2371
2372 return (0);
2373 }
2374
2375
2376 /*
2377 * This routine allows the user to set the 8-character
2378 * volume name in the vtoc. It then writes both the
2379 * primary and backup labels onto the current disk.
2380 */
2381 int
c_volname(void)2382 c_volname(void)
2383 {
2384 int status;
2385 char *prompt;
2386 union {
2387 int xfoo;
2388 char defvolname[LEN_DKL_VVOL+1];
2389 } x;
2390 char s1[MAXPATHLEN], nclean[MAXPATHLEN];
2391 char *volname;
2392
2393
2394 /*
2395 * There must be a current disk type (and therefore a current disk).
2396 */
2397 if (cur_dtype == NULL) {
2398 err_print("Current Disk Type is not set.\n");
2399 return (-1);
2400 }
2401 /*
2402 * The current disk must be formatted to label it.
2403 */
2404 if (!(cur_flags & DISK_FORMATTED)) {
2405 err_print("Current Disk is unformatted.\n");
2406 return (-1);
2407 }
2408 /*
2409 * Check for a valid fdisk table entry for Solaris
2410 */
2411 if (!good_fdisk()) {
2412 return (-1);
2413 }
2414 /*
2415 * The current disk must be formatted to label it.
2416 */
2417 if (cur_parts == NULL) {
2418 err_print(
2419 "Please select a partition map for the disk first.\n");
2420 return (-1);
2421 }
2422
2423 /*
2424 * Check to see if there are any mounted file systems anywhere
2425 * on the current disk. If so, refuse to label the disk, but
2426 * only if the partitions would change for the mounted partitions.
2427 *
2428 */
2429 if (checkmount((diskaddr_t)-1, (diskaddr_t)-1)) {
2430 /* Bleagh, too descriptive */
2431 if (check_label_with_mount()) {
2432 err_print(
2433 "Cannot label disk while it has mounted partitions.\n\n");
2434 return (-1);
2435 }
2436 }
2437
2438 /*
2439 * Check to see if there are partitions being used for swapping
2440 * on the current disk. If so, refuse to label the disk, but
2441 * only if the partitions would change for the swap partitions.
2442 *
2443 */
2444 if (checkswap((diskaddr_t)-1, (diskaddr_t)-1)) {
2445 /* Bleagh, too descriptive */
2446 if (check_label_with_swap()) {
2447 err_print(
2448 "Cannot label disk while its partitions are currently \
2449 being used for swapping.\n\n");
2450 return (-1);
2451 }
2452 }
2453
2454 /*
2455 * Check to see if any partitions used for svm, vxvm, ZFS zpool
2456 * or live upgrade are on the disk. If so, refuse to label the
2457 * disk, but only if we are trying to shrink a partition in
2458 * use.
2459 */
2460 if (checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1,
2461 (diskaddr_t)-1, 0, 1)) {
2462 err_print("Cannot label disk while its partitions "
2463 "are in use as described.\n");
2464 return (-1);
2465 }
2466
2467 /*
2468 * Prompt for the disk volume name.
2469 */
2470 prompt = "Enter 8-character volume name (remember quotes)";
2471 bzero(x.defvolname, LEN_DKL_VVOL+1);
2472 bcopy(cur_disk->v_volume, x.defvolname, LEN_DKL_VVOL);
2473 /*
2474 * Get the input using "get_inputline" since
2475 * input would never return null string.
2476 */
2477 fmt_print("%s[\"%s\"]:", prompt, x.defvolname);
2478
2479 /*
2480 * Get input from the user.
2481 */
2482 get_inputline(nclean, MAXPATHLEN);
2483 clean_token(s1, nclean);
2484 /*
2485 * check for return.
2486 */
2487 if (s1[0] == 0) {
2488 volname = x.defvolname;
2489 } else {
2490 /*
2491 * remove the " mark from volname.
2492 */
2493 if (s1[0] == '"') {
2494 int i = 1;
2495 volname = &s1[1];
2496 while (s1[i] != '"' && s1[i] != '\0')
2497 i++;
2498 s1[i] = '\0';
2499 clean_token(nclean, volname);
2500 volname = nclean;
2501 } else {
2502 (void) sscanf(&s1[0], "%1024s", nclean);
2503 volname = nclean;
2504 };
2505 }
2506 /*
2507 * Make sure the user is serious.
2508 */
2509 if (check("Ready to label disk, continue")) {
2510 fmt_print("\n");
2511 return (-1);
2512 }
2513 /*
2514 * Use the volume name chosen above
2515 */
2516 bzero(cur_disk->v_volume, LEN_DKL_VVOL);
2517 bcopy(volname, cur_disk->v_volume, min((int)strlen(volname),
2518 LEN_DKL_VVOL));
2519 if (cur_label == L_TYPE_EFI) {
2520 bzero(cur_parts->etoc->efi_parts[8].p_name, LEN_DKL_VVOL);
2521 bcopy(volname, cur_parts->etoc->efi_parts[8].p_name,
2522 LEN_DKL_VVOL);
2523 }
2524 /*
2525 * Write the labels out (this will also notify unix) and
2526 * return status.
2527 */
2528 fmt_print("\n");
2529 if (status = write_label())
2530 err_print("Label failed.\n");
2531 return (status);
2532 }
2533