|
0
|
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 2006 Sun Microsystems, Inc. All rights reserved.
|
|
|
23 * Use is subject to license terms.
|
|
|
24 */
|
|
|
25
|
|
|
26 #pragma ident "@(#)main.c 1.34 06/03/08 SMI"
|
|
|
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 #ifdef sparc
|
|
|
334 int i;
|
|
|
335 caddr_t bad_ptr = (caddr_t)&badmap;
|
|
|
336 #endif
|
|
|
337
|
|
|
338 /*
|
|
|
339 * If there was an old current disk, close the file for it.
|
|
|
340 */
|
|
|
341 if (cur_disk != NULL)
|
|
|
342 (void) close(cur_file);
|
|
|
343 /*
|
|
|
344 * Kill off any defect lists still lying around.
|
|
|
345 */
|
|
|
346 kill_deflist(&cur_list);
|
|
|
347 kill_deflist(&work_list);
|
|
|
348 /*
|
|
|
349 * If there were any buffers, free them up.
|
|
|
350 */
|
|
|
351 if ((char *)cur_buf != NULL) {
|
|
|
352 destroy_data((char *)cur_buf);
|
|
|
353 cur_buf = NULL;
|
|
|
354 }
|
|
|
355 if ((char *)pattern_buf != NULL) {
|
|
|
356 destroy_data((char *)pattern_buf);
|
|
|
357 pattern_buf = NULL;
|
|
|
358 }
|
|
|
359 /*
|
|
|
360 * Fill in the hardware struct pointers for the new disk.
|
|
|
361 */
|
|
|
362 cur_disk = disk;
|
|
|
363 cur_dtype = cur_disk->disk_type;
|
|
|
364 cur_label = cur_disk->label_type;
|
|
|
365 cur_ctlr = cur_disk->disk_ctlr;
|
|
|
366 cur_parts = cur_disk->disk_parts;
|
|
|
367 cur_ctype = cur_ctlr->ctlr_ctype;
|
|
|
368 cur_ops = cur_ctype->ctype_ops;
|
|
|
369 cur_flags = 0;
|
|
|
370 /*
|
|
|
371 * Open a file for the new disk.
|
|
|
372 */
|
|
|
373 if ((cur_file = open_disk(cur_disk->disk_path,
|
|
|
374 O_RDWR | O_NDELAY)) < 0) {
|
|
|
375 err_print(
|
|
|
376 "Error: can't open selected disk '%s'.\n", cur_disk->disk_name);
|
|
|
377 fullabort();
|
|
|
378 }
|
|
|
379 #ifdef sparc
|
|
|
380 /*
|
|
|
381 * If the new disk uses bad-144, initialize the bad block table.
|
|
|
382 */
|
|
|
383 if (cur_ctlr->ctlr_flags & DKI_BAD144) {
|
|
|
384 badmap.bt_mbz = badmap.bt_csn = badmap.bt_flag = 0;
|
|
|
385 for (i = 0; i < NDKBAD; i++) {
|
|
|
386 badmap.bt_bad[i].bt_cyl = -1;
|
|
|
387 badmap.bt_bad[i].bt_trksec = -1;
|
|
|
388 }
|
|
|
389 }
|
|
|
390 #endif
|
|
|
391 /*
|
|
|
392 * If the type of the new disk is known...
|
|
|
393 */
|
|
|
394 if (cur_dtype != NULL) {
|
|
|
395 /*
|
|
|
396 * Initialize the physical characteristics.
|
|
|
397 * If need disk specs, prompt for undefined disk
|
|
|
398 * characteristics. If running from a file,
|
|
|
399 * use defaults.
|
|
|
400 */
|
|
|
401 if (cur_dtype->dtype_flags & DT_NEED_SPEFS) {
|
|
|
402 get_disk_characteristics();
|
|
|
403 cur_dtype->dtype_flags &= ~DT_NEED_SPEFS;
|
|
|
404 }
|
|
|
405
|
|
|
406 ncyl = cur_dtype->dtype_ncyl;
|
|
|
407 acyl = cur_dtype->dtype_acyl;
|
|
|
408 pcyl = cur_dtype->dtype_pcyl;
|
|
|
409 nhead = cur_dtype->dtype_nhead;
|
|
|
410 nsect = cur_dtype->dtype_nsect;
|
|
|
411 phead = cur_dtype->dtype_phead;
|
|
|
412 psect = cur_dtype->dtype_psect;
|
|
|
413 /*
|
|
|
414 * Alternates per cylinder are forced to 0 or 1,
|
|
|
415 * independent of what the label says. This works
|
|
|
416 * because we know which ctlr we are dealing with.
|
|
|
417 */
|
|
|
418 if (cur_ctype->ctype_flags & CF_APC)
|
|
|
419 apc = 1;
|
|
|
420 else
|
|
|
421 apc = 0;
|
|
|
422 /*
|
|
|
423 * Initialize the surface analysis info. We always start
|
|
|
424 * out with scan set for the whole disk. Note,
|
|
|
425 * for SCSI disks, we can only scan the data area.
|
|
|
426 */
|
|
|
427 scan_lower = 0;
|
|
|
428 scan_size = BUF_SECTS;
|
|
|
429 if ((cur_ctype->ctype_flags & CF_SCSI) &&
|
|
|
430 (cur_disk->label_type == L_TYPE_SOLARIS)) {
|
|
|
431 scan_upper = datasects() - 1;
|
|
|
432 } else if (cur_disk->label_type == L_TYPE_SOLARIS) {
|
|
|
433 scan_upper = physsects() - 1;
|
|
|
434 } else if (cur_disk->label_type == L_TYPE_EFI) {
|
|
|
435 scan_upper = cur_parts->etoc->efi_last_lba;
|
|
|
436 }
|
|
|
437
|
|
|
438 /*
|
|
|
439 * Allocate the buffers.
|
|
|
440 */
|
|
|
441 cur_buf = (void *) zalloc(BUF_SECTS * SECSIZE);
|
|
|
442 pattern_buf = (void *) zalloc(BUF_SECTS * SECSIZE);
|
|
|
443
|
|
|
444 /*
|
|
|
445 * Tell the user which disk (s)he selected.
|
|
|
446 */
|
|
|
447 if (chk_volname(cur_disk)) {
|
|
|
448 fmt_print("selecting %s: ", cur_disk->disk_name);
|
|
|
449 print_volname(cur_disk);
|
|
|
450 fmt_print("\n");
|
|
|
451 } else {
|
|
|
452 fmt_print("selecting %s\n", cur_disk->disk_name);
|
|
|
453 }
|
|
|
454
|
|
|
455 /*
|
|
|
456 * If the drive is formatted...
|
|
|
457 */
|
|
|
458 if ((*cur_ops->op_ck_format)()) {
|
|
|
459 /*
|
|
|
460 * Mark it formatted.
|
|
|
461 */
|
|
|
462 cur_flags |= DISK_FORMATTED;
|
|
|
463 /*
|
|
|
464 * Read the defect list, if we have one.
|
|
|
465 */
|
|
|
466 if (!EMBEDDED_SCSI) {
|
|
|
467 read_list(&cur_list);
|
|
|
468 }
|
|
|
469 #ifdef sparc
|
|
|
470 /*
|
|
|
471 * If the disk does BAD-144, we do an ioctl to
|
|
|
472 * tell SunOS about the bad block table.
|
|
|
473 */
|
|
|
474 if (cur_ctlr->ctlr_flags & DKI_BAD144) {
|
|
|
475 if (ioctl(cur_file, HDKIOCSBAD, &bad_ptr)) {
|
|
|
476 err_print(
|
|
|
477 "Warning: error telling SunOS bad block map table.\n");
|
|
|
478 }
|
|
|
479 }
|
|
|
480 #endif
|
|
|
481 fmt_print("[disk formatted");
|
|
|
482 if (!EMBEDDED_SCSI) {
|
|
|
483 if (cur_list.list != NULL) {
|
|
|
484 fmt_print(", defect list found");
|
|
|
485 } else {
|
|
|
486 fmt_print(", no defect list found");
|
|
|
487 }
|
|
|
488 }
|
|
|
489 fmt_print("]");
|
|
|
490 /*
|
|
|
491 * Drive wasn't formatted. Tell the user in case he
|
|
|
492 * disagrees.
|
|
|
493 */
|
|
|
494 } else if (EMBEDDED_SCSI) {
|
|
|
495 fmt_print("[disk unformatted]");
|
|
|
496 } else {
|
|
|
497 /*
|
|
|
498 * Make sure the user is serious. Note, for
|
|
|
499 * SCSI disks since this is instantaneous, we
|
|
|
500 * will just do it and not ask for confirmation.
|
|
|
501 */
|
|
|
502 status = 0;
|
|
|
503 if (!(cur_ctype->ctype_flags & CF_CONFIRM)) {
|
|
|
504 if (check("\n\
|
|
|
505 Ready to get manufacturer's defect list from unformatted drive.\n\
|
|
|
506 This cannot be interrupted and takes a long while.\n\
|
|
|
507 Continue"))
|
|
|
508 status = 1;
|
|
|
509 else
|
|
|
510 fmt_print(
|
|
|
511 "Extracting manufacturer's defect list...");
|
|
|
512 }
|
|
|
513 /*
|
|
|
514 * Extract manufacturer's defect list.
|
|
|
515 */
|
|
|
516 if ((status == 0) && (cur_ops->op_ex_man != NULL)) {
|
|
|
517 status = (*cur_ops->op_ex_man)(&cur_list);
|
|
|
518 } else {
|
|
|
519 status = 1;
|
|
|
520 }
|
|
|
521 fmt_print("[disk unformatted");
|
|
|
522 if (status != 0) {
|
|
|
523 fmt_print(", no defect list found]");
|
|
|
524 } else {
|
|
|
525 fmt_print(", defect list found]");
|
|
|
526 }
|
|
|
527 }
|
|
|
528 } else {
|
|
|
529 /*
|
|
|
530 * Disk type is not known.
|
|
|
531 * Initialize physical characteristics to 0 and tell the
|
|
|
532 * user we don't know what type the disk is.
|
|
|
533 */
|
|
|
534 ncyl = acyl = nhead = nsect = psect = 0;
|
|
|
535 }
|
|
|
536
|
|
|
537 fmt_print("\n");
|
|
|
538
|
|
|
539 /*
|
|
|
540 * Check to see if there are any mounted file systems on the
|
|
|
541 * disk. If there are, print a warning.
|
|
|
542 */
|
|
|
543 if (checkmount((daddr_t)-1, (daddr_t)-1))
|
|
|
544 err_print("Warning: Current Disk has mounted partitions.\n");
|
|
|
545
|
|
|
546 /*
|
|
|
547 * If any part of this device is also part of an SVM, VxVM or
|
|
|
548 * Live Upgrade device, print a warning.
|
|
|
549 */
|
|
|
550 (void) checkdevinuse(cur_disk->disk_name, (diskaddr_t)-1,
|
|
|
551 (diskaddr_t)-1, 1, 0);
|
|
|
552
|
|
|
553 /*
|
|
|
554 * Get the Solaris Fdisk Partition information
|
|
|
555 */
|
|
|
556 (void) copy_solaris_part(&cur_disk->fdisk_part);
|
|
|
557 }
|
|
|
558
|
|
|
559
|
|
|
560 /*
|
|
|
561 * Prompt for some undefined disk characteristics.
|
|
|
562 * Used when there is no disk definition, but the
|
|
|
563 * disk has a valid label, so basically we're
|
|
|
564 * prompting for everything that isn't in the label.
|
|
|
565 */
|
|
|
566 static void
|
|
|
567 get_disk_characteristics()
|
|
|
568 {
|
|
|
569 /*
|
|
|
570 * The need_spefs flag is used to tell us that this disk
|
|
|
571 * is not a known type and the ctlr specific info must
|
|
|
572 * be prompted for. We only prompt for the info that applies
|
|
|
573 * to this ctlr.
|
|
|
574 */
|
|
|
575 assert(cur_dtype->dtype_flags & DT_NEED_SPEFS);
|
|
|
576
|
|
|
577 /*
|
|
|
578 * If we're running with input from a file, use
|
|
|
579 * reasonable defaults, since prompting for the
|
|
|
580 * information will probably mess things up.
|
|
|
581 */
|
|
|
582 if (option_f) {
|
|
|
583 cur_dtype->dtype_pcyl = ncyl + acyl;
|
|
|
584 cur_dtype->dtype_rpm = AVG_RPM;
|
|
|
585 cur_dtype->dtype_bpt = INFINITY;
|
|
|
586 cur_dtype->dtype_phead = 0;
|
|
|
587 cur_dtype->dtype_psect = 0;
|
|
|
588 cur_dtype->dtype_cyl_skew = 0;
|
|
|
589 cur_dtype->dtype_trk_skew = 0;
|
|
|
590 cur_dtype->dtype_trks_zone = 0;
|
|
|
591 cur_dtype->dtype_atrks = 0;
|
|
|
592 cur_dtype->dtype_asect = 0;
|
|
|
593 cur_dtype->dtype_cache = 0;
|
|
|
594 cur_dtype->dtype_threshold = 0;
|
|
|
595 cur_dtype->dtype_prefetch_min = 0;
|
|
|
596 cur_dtype->dtype_prefetch_max = 0;
|
|
|
597
|
|
|
598 if (cur_ctype->ctype_flags & CF_SMD_DEFS) {
|
|
|
599 cur_dtype->dtype_bps = AVG_BPS;
|
|
|
600 }
|
|
|
601 } else {
|
|
|
602
|
|
|
603 cur_dtype->dtype_pcyl = get_pcyl(ncyl, cur_dtype->dtype_acyl);
|
|
|
604 cur_dtype->dtype_bpt = get_bpt(cur_dtype->dtype_nsect,
|
|
|
605 &cur_dtype->dtype_options);
|
|
|
606 cur_dtype->dtype_rpm = get_rpm();
|
|
|
607 cur_dtype->dtype_fmt_time =
|
|
|
608 get_fmt_time(&cur_dtype->dtype_options);
|
|
|
609 cur_dtype->dtype_cyl_skew =
|
|
|
610 get_cyl_skew(&cur_dtype->dtype_options);
|
|
|
611 cur_dtype->dtype_trk_skew =
|
|
|
612 get_trk_skew(&cur_dtype->dtype_options);
|
|
|
613 cur_dtype->dtype_trks_zone =
|
|
|
614 get_trks_zone(&cur_dtype->dtype_options);
|
|
|
615 cur_dtype->dtype_atrks = get_atrks(&cur_dtype->dtype_options);
|
|
|
616 cur_dtype->dtype_asect = get_asect(&cur_dtype->dtype_options);
|
|
|
617 cur_dtype->dtype_cache = get_cache(&cur_dtype->dtype_options);
|
|
|
618 cur_dtype->dtype_threshold =
|
|
|
619 get_threshold(&cur_dtype->dtype_options);
|
|
|
620 cur_dtype->dtype_prefetch_min =
|
|
|
621 get_min_prefetch(&cur_dtype->dtype_options);
|
|
|
622 cur_dtype->dtype_prefetch_max =
|
|
|
623 get_max_prefetch(cur_dtype->dtype_prefetch_min,
|
|
|
624 &cur_dtype->dtype_options);
|
|
|
625 cur_dtype->dtype_phead =
|
|
|
626 get_phead(nhead, &cur_dtype->dtype_options);
|
|
|
627 cur_dtype->dtype_psect = get_psect(&cur_dtype->dtype_options);
|
|
|
628 cur_dtype->dtype_bps = get_bps();
|
|
|
629 #ifdef sparc
|
|
|
630 cur_dtype->dtype_dr_type = 0;
|
|
|
631 #endif
|
|
|
632 }
|
|
|
633 }
|
