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 */
25
26 /*
27 * This file contains functions to prompt the user for various
28 * disk characteristics. By isolating these into functions,
29 * we can guarantee that prompts, defaults, etc are identical.
30 */
31 #include "global.h"
32 #include "prompts.h"
33 #include "io.h"
34 #include "param.h"
35 #include "startup.h"
36
37 #ifdef sparc
38 #include <sys/hdio.h>
39 #endif
40
41
42 /*
43 * Prompt for max number of LBA
44 */
45 uint64_t
get_mlba()46 get_mlba()
47 {
48 u_ioparam_t ioparam;
49
50 ioparam.io_bounds.lower = (1024 * 16) + 68;
51 ioparam.io_bounds.upper = UINT_MAX64;
52
53 return (input(FIO_INT64, "Enter maximum number of LBAs",
54 ':', &ioparam, (int *)NULL, DATA_INPUT));
55 }
56
57 /*
58 * Prompt for number of cylinders
59 */
60 int
get_ncyl()61 get_ncyl()
62 {
63 u_ioparam_t ioparam;
64
65 ioparam.io_bounds.lower = 1;
66 ioparam.io_bounds.upper = MAX_CYLS;
67 return (input(FIO_INT, "Enter number of data cylinders",
68 ':', &ioparam, (int *)NULL, DATA_INPUT));
69 }
70
71 /*
72 * Prompt for number of alternate cylinders
73 */
74 int
get_acyl(n_cyls)75 get_acyl(n_cyls)
76 int n_cyls;
77 {
78 u_ioparam_t ioparam;
79 int deflt;
80
81 ioparam.io_bounds.lower = 2;
82 ioparam.io_bounds.upper = MAX_CYLS - n_cyls;
83 deflt = 2;
84 return (input(FIO_INT, "Enter number of alternate cylinders", ':',
85 &ioparam, &deflt, DATA_INPUT));
86 }
87
88 /*
89 * Prompt for number of physical cylinders
90 */
91 int
get_pcyl(n_cyls,a_cyls)92 get_pcyl(n_cyls, a_cyls)
93 int n_cyls;
94 int a_cyls;
95 {
96 u_ioparam_t ioparam;
97 int deflt;
98
99 ioparam.io_bounds.lower = n_cyls + a_cyls;
100 ioparam.io_bounds.upper = MAX_CYLS;
101 deflt = n_cyls + a_cyls;
102 return (input(FIO_INT, "Enter number of physical cylinders", ':',
103 &ioparam, &deflt, DATA_INPUT));
104 }
105
106 /*
107 * Prompt for number of heads
108 */
109 int
get_nhead()110 get_nhead()
111 {
112 u_ioparam_t ioparam;
113
114 ioparam.io_bounds.lower = 1;
115 ioparam.io_bounds.upper = MAX_HEADS;
116 return (input(FIO_INT, "Enter number of heads", ':',
117 &ioparam, (int *)NULL, DATA_INPUT));
118 }
119
120 /*
121 * Prompt for number of physical heads
122 */
123 int
get_phead(n_heads,options)124 get_phead(n_heads, options)
125 int n_heads;
126 ulong_t *options;
127 {
128 u_ioparam_t ioparam;
129 int deflt;
130
131 if (SCSI) {
132 ioparam.io_bounds.lower = n_heads;
133 ioparam.io_bounds.upper = INFINITY;
134 if (input(FIO_OPINT, "Enter physical number of heads",
135 ':', &ioparam, &deflt, DATA_INPUT)) {
136 *options |= SUP_PHEAD;
137 return (deflt);
138 }
139 }
140 return (0);
141 }
142
143
144 /*
145 * Prompt for number of sectors per track
146 */
147 int
get_nsect()148 get_nsect()
149 {
150 u_ioparam_t ioparam;
151
152 ioparam.io_bounds.lower = 1;
153 ioparam.io_bounds.upper = MAX_SECTS;
154 return (input(FIO_INT,
155 "Enter number of data sectors/track", ':',
156 &ioparam, (int *)NULL, DATA_INPUT));
157 }
158
159 /*
160 * Prompt for number of physical sectors per track
161 */
162 int
get_psect(options)163 get_psect(options)
164 ulong_t *options;
165 {
166 u_ioparam_t ioparam;
167 int deflt;
168
169 if (SCSI) {
170 ioparam.io_bounds.lower = 0;
171 ioparam.io_bounds.upper = INFINITY;
172 if (input(FIO_OPINT, "Enter number of physical sectors/track",
173 ':', &ioparam, &deflt, DATA_INPUT)) {
174 *options |= SUP_PSECT;
175 return (deflt);
176 }
177 }
178 return (0);
179 }
180
181 /*
182 * Prompt for bytes per track
183 */
184 int
get_bpt(n_sects,options)185 get_bpt(n_sects, options)
186 int n_sects;
187 ulong_t *options;
188 {
189 u_ioparam_t ioparam;
190 int deflt;
191
192 if (SMD) {
193 *options |= SUP_BPT;
194 ioparam.io_bounds.lower = 1;
195 ioparam.io_bounds.upper = INFINITY;
196 deflt = n_sects * cur_blksz;
197 return (input(FIO_INT, "Enter number of bytes/track",
198 ':', &ioparam, &deflt, DATA_INPUT));
199 }
200
201 return (0);
202 }
203
204 /*
205 * Prompt for rpm
206 */
207 int
get_rpm()208 get_rpm()
209 {
210 u_ioparam_t ioparam;
211 int deflt;
212
213 ioparam.io_bounds.lower = MIN_RPM;
214 ioparam.io_bounds.upper = MAX_RPM;
215 deflt = AVG_RPM;
216 return (input(FIO_INT, "Enter rpm of drive", ':',
217 &ioparam, &deflt, DATA_INPUT));
218 }
219
220 /*
221 * Prompt for formatting time
222 */
223 int
get_fmt_time(options)224 get_fmt_time(options)
225 ulong_t *options;
226 {
227 u_ioparam_t ioparam;
228 int deflt;
229
230 ioparam.io_bounds.lower = 0;
231 ioparam.io_bounds.upper = INFINITY;
232 if (input(FIO_OPINT, "Enter format time", ':',
233 &ioparam, &deflt, DATA_INPUT)) {
234 *options |= SUP_FMTTIME;
235 return (deflt);
236 }
237 return (0);
238 }
239
240 /*
241 * Prompt for cylinder skew
242 */
243 int
get_cyl_skew(options)244 get_cyl_skew(options)
245 ulong_t *options;
246 {
247 u_ioparam_t ioparam;
248 int deflt;
249
250 ioparam.io_bounds.lower = 0;
251 ioparam.io_bounds.upper = INFINITY;
252 if (input(FIO_OPINT, "Enter cylinder skew", ':',
253 &ioparam, &deflt, DATA_INPUT)) {
254 *options |= SUP_CYLSKEW;
255 return (deflt);
256 }
257 return (0);
258 }
259
260 /*
261 * Prompt for track skew
262 */
263 int
get_trk_skew(options)264 get_trk_skew(options)
265 ulong_t *options;
266 {
267 u_ioparam_t ioparam;
268 int deflt;
269
270 ioparam.io_bounds.lower = 0;
271 ioparam.io_bounds.upper = INFINITY;
272 if (input(FIO_OPINT, "Enter track skew", ':',
273 &ioparam, &deflt, DATA_INPUT)) {
274 *options |= SUP_TRKSKEW;
275 return (deflt);
276 }
277 return (0);
278 }
279
280 /*
281 * Prompt for tracks per zone
282 */
283 int
get_trks_zone(options)284 get_trks_zone(options)
285 ulong_t *options;
286 {
287 u_ioparam_t ioparam;
288 int deflt;
289
290 ioparam.io_bounds.lower = 0;
291 ioparam.io_bounds.upper = INFINITY;
292 if (input(FIO_OPINT, "Enter tracks per zone", ':',
293 &ioparam, &deflt, DATA_INPUT)) {
294 *options |= SUP_TRKS_ZONE;
295 return (deflt);
296 }
297 return (0);
298 }
299
300 /*
301 * Prompt for alternate tracks
302 */
303 int
get_atrks(options)304 get_atrks(options)
305 ulong_t *options;
306 {
307 u_ioparam_t ioparam;
308 int deflt;
309
310 ioparam.io_bounds.lower = 0;
311 ioparam.io_bounds.upper = INFINITY;
312 if (input(FIO_OPINT, "Enter alternate tracks", ':',
313 &ioparam, &deflt, DATA_INPUT)) {
314 *options |= SUP_ATRKS;
315 return (deflt);
316 }
317 return (0);
318 }
319
320 /*
321 * Prompt for alternate sectors
322 */
323 int
get_asect(options)324 get_asect(options)
325 ulong_t *options;
326 {
327 u_ioparam_t ioparam;
328 int deflt;
329
330 ioparam.io_bounds.lower = 0;
331 ioparam.io_bounds.upper = INFINITY;
332 if (input(FIO_OPINT, "Enter alternate sectors", ':',
333 &ioparam, &deflt, DATA_INPUT)) {
334 *options |= SUP_ASECT;
335 return (deflt);
336 }
337 return (0);
338 }
339
340 /*
341 * Prompt for cache setting
342 */
343 int
get_cache(options)344 get_cache(options)
345 ulong_t *options;
346 {
347 u_ioparam_t ioparam;
348 int deflt;
349
350 ioparam.io_bounds.lower = 0;
351 ioparam.io_bounds.upper = 0xff;
352 if (input(FIO_OPINT, "Enter cache control", ':',
353 &ioparam, &deflt, DATA_INPUT)) {
354 *options |= SUP_CACHE;
355 return (deflt);
356 }
357 return (0);
358 }
359
360 /*
361 * Prompt for prefetch threshold
362 */
363 int
get_threshold(options)364 get_threshold(options)
365 ulong_t *options;
366 {
367 u_ioparam_t ioparam;
368 int deflt;
369
370 ioparam.io_bounds.lower = 0;
371 ioparam.io_bounds.upper = INFINITY;
372 if (input(FIO_OPINT, "Enter prefetch threshold",
373 ':', &ioparam, &deflt, DATA_INPUT)) {
374 *options |= SUP_PREFETCH;
375 return (deflt);
376 }
377 return (0);
378 }
379
380 /*
381 * Prompt for minimum prefetch
382 */
383 int
get_min_prefetch(options)384 get_min_prefetch(options)
385 ulong_t *options;
386 {
387 u_ioparam_t ioparam;
388 int deflt;
389
390 ioparam.io_bounds.lower = 0;
391 ioparam.io_bounds.upper = INFINITY;
392 if (input(FIO_OPINT, "Enter minimum prefetch",
393 ':', &ioparam, &deflt, DATA_INPUT)) {
394 *options |= SUP_CACHE_MIN;
395 return (deflt);
396 }
397 return (0);
398 }
399
400 /*
401 * Prompt for maximum prefetch
402 */
403 int
get_max_prefetch(min_prefetch,options)404 get_max_prefetch(min_prefetch, options)
405 int min_prefetch;
406 ulong_t *options;
407 {
408 u_ioparam_t ioparam;
409 int deflt;
410
411 ioparam.io_bounds.lower = min_prefetch;
412 ioparam.io_bounds.upper = INFINITY;
413 if (input(FIO_OPINT, "Enter maximum prefetch",
414 ':', &ioparam, &deflt, DATA_INPUT)) {
415 *options |= SUP_CACHE_MAX;
416 return (deflt);
417 }
418 return (0);
419 }
420
421 /*
422 * Prompt for bytes per sector
423 */
424 int
get_bps()425 get_bps()
426 {
427 u_ioparam_t ioparam;
428 int deflt;
429
430 if (cur_ctype->ctype_flags & CF_SMD_DEFS) {
431 ioparam.io_bounds.lower = MIN_BPS;
432 ioparam.io_bounds.upper = MAX_BPS;
433 deflt = AVG_BPS;
434 return (input(FIO_INT, "Enter bytes per sector",
435 ':', &ioparam, &deflt, DATA_INPUT));
436 }
437
438 return (0);
439 }
440
441 /*
442 * Prompt for ascii label
443 */
444 char *
get_asciilabel()445 get_asciilabel()
446 {
447 return ((char *)(uintptr_t)input(FIO_OSTR,
448 "Enter disk type name (remember quotes)", ':',
449 (u_ioparam_t *)NULL, (int *)NULL, DATA_INPUT));
450 }
451