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 /*
23 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved.
24 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 * Copyright 2016 Toomas Soome <tsoome@me.com>
27 * Copyright (c) 2019, Joyent, Inc.
28 */
29
30 /*
31 * This module provides support for labeling operations for target
32 * drivers.
33 */
34
35 #include <sys/scsi/scsi.h>
36 #include <sys/sunddi.h>
37 #include <sys/dklabel.h>
38 #include <sys/dkio.h>
39 #include <sys/vtoc.h>
40 #include <sys/dktp/fdisk.h>
41 #include <sys/vtrace.h>
42 #include <sys/efi_partition.h>
43 #include <sys/cmlb.h>
44 #include <sys/cmlb_impl.h>
45 #if defined(__i386) || defined(__amd64)
46 #include <sys/fs/dv_node.h>
47 #endif
48 #include <sys/ddi_impldefs.h>
49
50 /*
51 * Driver minor node structure and data table
52 */
53 struct driver_minor_data {
54 char *name;
55 minor_t minor;
56 int type;
57 };
58
59 static struct driver_minor_data dk_minor_data[] = {
60 {"a", 0, S_IFBLK},
61 {"b", 1, S_IFBLK},
62 {"c", 2, S_IFBLK},
63 {"d", 3, S_IFBLK},
64 {"e", 4, S_IFBLK},
65 {"f", 5, S_IFBLK},
66 {"g", 6, S_IFBLK},
67 {"h", 7, S_IFBLK},
68 #if defined(_SUNOS_VTOC_16)
69 {"i", 8, S_IFBLK},
70 {"j", 9, S_IFBLK},
71 {"k", 10, S_IFBLK},
72 {"l", 11, S_IFBLK},
73 {"m", 12, S_IFBLK},
74 {"n", 13, S_IFBLK},
75 {"o", 14, S_IFBLK},
76 {"p", 15, S_IFBLK},
77 #endif /* defined(_SUNOS_VTOC_16) */
78 #if defined(_FIRMWARE_NEEDS_FDISK)
79 {"q", 16, S_IFBLK},
80 {"r", 17, S_IFBLK},
81 {"s", 18, S_IFBLK},
82 {"t", 19, S_IFBLK},
83 {"u", 20, S_IFBLK},
84 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
85 {"a,raw", 0, S_IFCHR},
86 {"b,raw", 1, S_IFCHR},
87 {"c,raw", 2, S_IFCHR},
88 {"d,raw", 3, S_IFCHR},
89 {"e,raw", 4, S_IFCHR},
90 {"f,raw", 5, S_IFCHR},
91 {"g,raw", 6, S_IFCHR},
92 {"h,raw", 7, S_IFCHR},
93 #if defined(_SUNOS_VTOC_16)
94 {"i,raw", 8, S_IFCHR},
95 {"j,raw", 9, S_IFCHR},
96 {"k,raw", 10, S_IFCHR},
97 {"l,raw", 11, S_IFCHR},
98 {"m,raw", 12, S_IFCHR},
99 {"n,raw", 13, S_IFCHR},
100 {"o,raw", 14, S_IFCHR},
101 {"p,raw", 15, S_IFCHR},
102 #endif /* defined(_SUNOS_VTOC_16) */
103 #if defined(_FIRMWARE_NEEDS_FDISK)
104 {"q,raw", 16, S_IFCHR},
105 {"r,raw", 17, S_IFCHR},
106 {"s,raw", 18, S_IFCHR},
107 {"t,raw", 19, S_IFCHR},
108 {"u,raw", 20, S_IFCHR},
109 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
110 {0}
111 };
112
113 #if defined(__i386) || defined(__amd64)
114 #if defined(_FIRMWARE_NEEDS_FDISK)
115 static struct driver_minor_data dk_ext_minor_data[] = {
116 {"p5", 21, S_IFBLK},
117 {"p6", 22, S_IFBLK},
118 {"p7", 23, S_IFBLK},
119 {"p8", 24, S_IFBLK},
120 {"p9", 25, S_IFBLK},
121 {"p10", 26, S_IFBLK},
122 {"p11", 27, S_IFBLK},
123 {"p12", 28, S_IFBLK},
124 {"p13", 29, S_IFBLK},
125 {"p14", 30, S_IFBLK},
126 {"p15", 31, S_IFBLK},
127 {"p16", 32, S_IFBLK},
128 {"p17", 33, S_IFBLK},
129 {"p18", 34, S_IFBLK},
130 {"p19", 35, S_IFBLK},
131 {"p20", 36, S_IFBLK},
132 {"p21", 37, S_IFBLK},
133 {"p22", 38, S_IFBLK},
134 {"p23", 39, S_IFBLK},
135 {"p24", 40, S_IFBLK},
136 {"p25", 41, S_IFBLK},
137 {"p26", 42, S_IFBLK},
138 {"p27", 43, S_IFBLK},
139 {"p28", 44, S_IFBLK},
140 {"p29", 45, S_IFBLK},
141 {"p30", 46, S_IFBLK},
142 {"p31", 47, S_IFBLK},
143 {"p32", 48, S_IFBLK},
144 {"p33", 49, S_IFBLK},
145 {"p34", 50, S_IFBLK},
146 {"p35", 51, S_IFBLK},
147 {"p36", 52, S_IFBLK},
148 {"p5,raw", 21, S_IFCHR},
149 {"p6,raw", 22, S_IFCHR},
150 {"p7,raw", 23, S_IFCHR},
151 {"p8,raw", 24, S_IFCHR},
152 {"p9,raw", 25, S_IFCHR},
153 {"p10,raw", 26, S_IFCHR},
154 {"p11,raw", 27, S_IFCHR},
155 {"p12,raw", 28, S_IFCHR},
156 {"p13,raw", 29, S_IFCHR},
157 {"p14,raw", 30, S_IFCHR},
158 {"p15,raw", 31, S_IFCHR},
159 {"p16,raw", 32, S_IFCHR},
160 {"p17,raw", 33, S_IFCHR},
161 {"p18,raw", 34, S_IFCHR},
162 {"p19,raw", 35, S_IFCHR},
163 {"p20,raw", 36, S_IFCHR},
164 {"p21,raw", 37, S_IFCHR},
165 {"p22,raw", 38, S_IFCHR},
166 {"p23,raw", 39, S_IFCHR},
167 {"p24,raw", 40, S_IFCHR},
168 {"p25,raw", 41, S_IFCHR},
169 {"p26,raw", 42, S_IFCHR},
170 {"p27,raw", 43, S_IFCHR},
171 {"p28,raw", 44, S_IFCHR},
172 {"p29,raw", 45, S_IFCHR},
173 {"p30,raw", 46, S_IFCHR},
174 {"p31,raw", 47, S_IFCHR},
175 {"p32,raw", 48, S_IFCHR},
176 {"p33,raw", 49, S_IFCHR},
177 {"p34,raw", 50, S_IFCHR},
178 {"p35,raw", 51, S_IFCHR},
179 {"p36,raw", 52, S_IFCHR},
180 {0}
181 };
182 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
183 #endif /* if defined(__i386) || defined(__amd64) */
184
185 static struct driver_minor_data dk_minor_data_efi[] = {
186 {"a", 0, S_IFBLK},
187 {"b", 1, S_IFBLK},
188 {"c", 2, S_IFBLK},
189 {"d", 3, S_IFBLK},
190 {"e", 4, S_IFBLK},
191 {"f", 5, S_IFBLK},
192 {"g", 6, S_IFBLK},
193 {"wd", 7, S_IFBLK},
194 #if defined(_SUNOS_VTOC_16)
195 {"i", 8, S_IFBLK},
196 {"j", 9, S_IFBLK},
197 {"k", 10, S_IFBLK},
198 {"l", 11, S_IFBLK},
199 {"m", 12, S_IFBLK},
200 {"n", 13, S_IFBLK},
201 {"o", 14, S_IFBLK},
202 {"p", 15, S_IFBLK},
203 #endif /* defined(_SUNOS_VTOC_16) */
204 #if defined(_FIRMWARE_NEEDS_FDISK)
205 {"q", 16, S_IFBLK},
206 {"r", 17, S_IFBLK},
207 {"s", 18, S_IFBLK},
208 {"t", 19, S_IFBLK},
209 {"u", 20, S_IFBLK},
210 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
211 {"a,raw", 0, S_IFCHR},
212 {"b,raw", 1, S_IFCHR},
213 {"c,raw", 2, S_IFCHR},
214 {"d,raw", 3, S_IFCHR},
215 {"e,raw", 4, S_IFCHR},
216 {"f,raw", 5, S_IFCHR},
217 {"g,raw", 6, S_IFCHR},
218 {"wd,raw", 7, S_IFCHR},
219 #if defined(_SUNOS_VTOC_16)
220 {"i,raw", 8, S_IFCHR},
221 {"j,raw", 9, S_IFCHR},
222 {"k,raw", 10, S_IFCHR},
223 {"l,raw", 11, S_IFCHR},
224 {"m,raw", 12, S_IFCHR},
225 {"n,raw", 13, S_IFCHR},
226 {"o,raw", 14, S_IFCHR},
227 {"p,raw", 15, S_IFCHR},
228 #endif /* defined(_SUNOS_VTOC_16) */
229 #if defined(_FIRMWARE_NEEDS_FDISK)
230 {"q,raw", 16, S_IFCHR},
231 {"r,raw", 17, S_IFCHR},
232 {"s,raw", 18, S_IFCHR},
233 {"t,raw", 19, S_IFCHR},
234 {"u,raw", 20, S_IFCHR},
235 #endif /* defined(_FIRMWARE_NEEDS_FDISK) */
236 {0}
237 };
238
239 /*
240 * Declare the dynamic properties implemented in prop_op(9E) implementation
241 * that we want to have show up in a di_init(3DEVINFO) device tree snapshot
242 * of drivers that call cmlb_attach().
243 */
244 static i_ddi_prop_dyn_t cmlb_prop_dyn[] = {
245 {"Nblocks", DDI_PROP_TYPE_INT64, S_IFBLK},
246 {"Size", DDI_PROP_TYPE_INT64, S_IFCHR},
247 {"device-nblocks", DDI_PROP_TYPE_INT64},
248 {"device-blksize", DDI_PROP_TYPE_INT},
249 {"device-solid-state", DDI_PROP_TYPE_INT},
250 {"device-rotational", DDI_PROP_TYPE_INT},
251 {NULL}
252 };
253
254 /*
255 * This implies an upper limit of 8192 GPT partitions
256 * in one transfer for GUID Partition Entry Array.
257 */
258 len_t cmlb_tg_max_efi_xfer = 1024 * 1024;
259
260 /*
261 * External kernel interfaces
262 */
263 extern struct mod_ops mod_miscops;
264
265 extern int ddi_create_internal_pathname(dev_info_t *dip, char *name,
266 int spec_type, minor_t minor_num);
267
268 /*
269 * Global buffer and mutex for debug logging
270 */
271 static char cmlb_log_buffer[1024];
272 static kmutex_t cmlb_log_mutex;
273
274
275 struct cmlb_lun *cmlb_debug_cl = NULL;
276 uint_t cmlb_level_mask = 0x0;
277
278 int cmlb_rot_delay = 4; /* default rotational delay */
279
280 static struct modlmisc modlmisc = {
281 &mod_miscops, /* Type of module */
282 "Common Labeling module"
283 };
284
285 static struct modlinkage modlinkage = {
286 MODREV_1, (void *)&modlmisc, NULL
287 };
288
289 /* Local function prototypes */
290 static dev_t cmlb_make_device(struct cmlb_lun *cl);
291 static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid,
292 int flags, void *tg_cookie);
293 static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
294 void *tg_cookie);
295 static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
296 void *tg_cookie);
297 static void cmlb_swap_efi_gpt(efi_gpt_t *e);
298 static void cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p);
299 static int cmlb_validate_efi(efi_gpt_t *labp);
300 static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
301 void *tg_cookie);
302 static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
303 static int cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *l, int flags);
304 #if defined(_SUNOS_VTOC_8)
305 static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
306 #endif
307 static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
308 static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
309 static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
310 void *tg_cookie);
311 static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
312 static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
313 static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
314 static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
315 static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
316 static boolean_t cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr);
317
318 #if defined(__i386) || defined(__amd64)
319 static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
320 #endif
321
322 #if defined(_FIRMWARE_NEEDS_FDISK)
323 static boolean_t cmlb_has_max_chs_vals(struct ipart *fdp);
324 #endif
325
326 #if defined(_SUNOS_VTOC_16)
327 static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
328 struct dk_geom *cl_g, void *tg_cookie);
329 #endif
330
331 static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
332 void *tg_cookie);
333 static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
334 static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
335 void *tg_cookie);
336 static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
337 static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
338 void *tg_cookie);
339 static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
340 int flag, void *tg_cookie);
341 static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
342 void *tg_cookie);
343 static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
344 void *tg_cookie);
345 static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
346 int flag, void *tg_cookie);
347 static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
348 int flag, void *tg_cookie);
349 static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
350 void *tg_cookie);
351 static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
352 void *tg_cookie);
353 static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
354 void *tg_cookie);
355
356 #if defined(__i386) || defined(__amd64)
357 static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
358 void *tg_cookie);
359 static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart,
360 uint32_t start, uint32_t size);
361 static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start,
362 void *tg_cookie);
363 static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
364 static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag,
365 void *tg_cookie);
366 static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
367 int flag);
368 static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
369 int flag);
370 #endif
371
372 static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
373 static void cmlb_v_log(dev_info_t *dev, const char *label, uint_t level,
374 const char *fmt, va_list ap);
375 static void cmlb_log(dev_info_t *dev, const char *label, uint_t level,
376 const char *fmt, ...);
377
378 int
379 _init(void)
380 {
381 mutex_init(&cmlb_log_mutex, NULL, MUTEX_DRIVER, NULL);
382 return (mod_install(&modlinkage));
383 }
384
385 int
386 _info(struct modinfo *modinfop)
387 {
388 return (mod_info(&modlinkage, modinfop));
389 }
390
391 int
392 _fini(void)
393 {
394 int err;
395
396 if ((err = mod_remove(&modlinkage)) != 0) {
397 return (err);
398 }
399
400 mutex_destroy(&cmlb_log_mutex);
401 return (err);
402 }
403
404 /*
405 * cmlb_dbg is used for debugging to log additional info
406 * Level of output is controlled via cmlb_level_mask setting.
407 */
408 static void
409 cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...)
410 {
411 va_list ap;
412 dev_info_t *dev;
413 uint_t level_mask = 0;
414
415 ASSERT(cl != NULL);
416 dev = CMLB_DEVINFO(cl);
417 ASSERT(dev != NULL);
418 /*
419 * Filter messages based on the global component and level masks,
420 * also print if cl matches the value of cmlb_debug_cl, or if
421 * cmlb_debug_cl is set to NULL.
422 */
423 if (comp & CMLB_TRACE)
424 level_mask |= CMLB_LOGMASK_TRACE;
425
426 if (comp & CMLB_INFO)
427 level_mask |= CMLB_LOGMASK_INFO;
428
429 if (comp & CMLB_ERROR)
430 level_mask |= CMLB_LOGMASK_ERROR;
431
432 if ((cmlb_level_mask & level_mask) &&
433 ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) {
434 va_start(ap, fmt);
435 cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap);
436 va_end(ap);
437 }
438 }
439
440 /*
441 * cmlb_log is basically a duplicate of scsi_log. It is redefined here
442 * so that this module does not depend on scsi module.
443 */
444 static void
445 cmlb_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt, ...)
446 {
447 va_list ap;
448
449 va_start(ap, fmt);
450 cmlb_v_log(dev, label, level, fmt, ap);
451 va_end(ap);
452 }
453
454 static void
455 cmlb_v_log(dev_info_t *dev, const char *label, uint_t level, const char *fmt,
456 va_list ap)
457 {
458 static char name[256];
459 int log_only = 0;
460 int boot_only = 0;
461 int console_only = 0;
462
463 mutex_enter(&cmlb_log_mutex);
464
465 if (dev) {
466 if (level == CE_PANIC || level == CE_WARN ||
467 level == CE_NOTE) {
468 (void) sprintf(name, "%s (%s%d):\n",
469 ddi_pathname(dev, cmlb_log_buffer),
470 label, ddi_get_instance(dev));
471 } else {
472 name[0] = '\0';
473 }
474 } else {
475 (void) sprintf(name, "%s:", label);
476 }
477
478 (void) vsprintf(cmlb_log_buffer, fmt, ap);
479
480 switch (cmlb_log_buffer[0]) {
481 case '!':
482 log_only = 1;
483 break;
484 case '?':
485 boot_only = 1;
486 break;
487 case '^':
488 console_only = 1;
489 break;
490 }
491
492 switch (level) {
493 case CE_NOTE:
494 level = CE_CONT;
495 /* FALLTHROUGH */
496 case CE_CONT:
497 case CE_WARN:
498 case CE_PANIC:
499 if (boot_only) {
500 cmn_err(level, "?%s\t%s", name, &cmlb_log_buffer[1]);
501 } else if (console_only) {
502 cmn_err(level, "^%s\t%s", name, &cmlb_log_buffer[1]);
503 } else if (log_only) {
504 cmn_err(level, "!%s\t%s", name, &cmlb_log_buffer[1]);
505 } else {
506 cmn_err(level, "%s\t%s", name, cmlb_log_buffer);
507 }
508 break;
509 case CE_IGNORE:
510 break;
511 default:
512 cmn_err(CE_CONT, "^DEBUG: %s\t%s", name, cmlb_log_buffer);
513 break;
514 }
515 mutex_exit(&cmlb_log_mutex);
516 }
517
518
519 /*
520 * cmlb_alloc_handle:
521 *
522 * Allocates a handle.
523 *
524 * Arguments:
525 * cmlbhandlep pointer to handle
526 *
527 * Notes:
528 * Allocates a handle and stores the allocated handle in the area
529 * pointed to by cmlbhandlep
530 *
531 * Context:
532 * Kernel thread only (can sleep).
533 */
534 void
535 cmlb_alloc_handle(cmlb_handle_t *cmlbhandlep)
536 {
537 struct cmlb_lun *cl;
538
539 cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP);
540 ASSERT(cmlbhandlep != NULL);
541
542 cl->cl_state = CMLB_INITED;
543 cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
544 mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL);
545
546 *cmlbhandlep = (cmlb_handle_t)(cl);
547 }
548
549 /*
550 * cmlb_free_handle
551 *
552 * Frees handle.
553 *
554 * Arguments:
555 * cmlbhandlep pointer to handle
556 */
557 void
558 cmlb_free_handle(cmlb_handle_t *cmlbhandlep)
559 {
560 struct cmlb_lun *cl;
561
562 cl = (struct cmlb_lun *)*cmlbhandlep;
563 if (cl != NULL) {
564 mutex_destroy(CMLB_MUTEX(cl));
565 kmem_free(cl, sizeof (struct cmlb_lun));
566 }
567
568 }
569
570 /*
571 * cmlb_attach:
572 *
573 * Attach handle to device, create minor nodes for device.
574 *
575 * Arguments:
576 * devi pointer to device's dev_info structure.
577 * tgopsp pointer to array of functions cmlb can use to callback
578 * to target driver.
579 *
580 * device_type Peripheral device type as defined in
581 * scsi/generic/inquiry.h
582 *
583 * is_removable whether or not device is removable.
584 *
585 * is_hotpluggable whether or not device is hotpluggable.
586 *
587 * node_type minor node type (as used by ddi_create_minor_node)
588 *
589 * alter_behavior
590 * bit flags:
591 *
592 * CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT: create
593 * an alternate slice for the default label, if
594 * device type is DTYPE_DIRECT an architectures default
595 * label type is VTOC16.
596 * Otherwise alternate slice will no be created.
597 *
598 *
599 * CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8: report a default
600 * geometry and label for DKIOCGGEOM and DKIOCGVTOC
601 * on architecture with VTOC8 label types.
602 *
603 * CMLB_OFF_BY_ONE: do the workaround for legacy off-by-
604 * one bug in obtaining capacity (in sd):
605 * SCSI READ_CAPACITY command returns the LBA number of the
606 * last logical block, but sd once treated this number as
607 * disks' capacity on x86 platform. And LBAs are addressed
608 * based 0. So the last block was lost on x86 platform.
609 *
610 * Now, we remove this workaround. In order for present sd
611 * driver to work with disks which are labeled/partitioned
612 * via previous sd, we add workaround as follows:
613 *
614 * 1) Locate backup EFI label: cmlb searches the next to
615 * last
616 * block for backup EFI label. If fails, it will
617 * turn to the last block for backup EFI label;
618 *
619 * 2) Clear backup EFI label: cmlb first search the last
620 * block for backup EFI label, and will search the
621 * next to last block only if failed for the last
622 * block.
623 *
624 * 3) Calculate geometry:refer to cmlb_convert_geometry()
625 * If capacity increasing by 1 causes disks' capacity
626 * to cross over the limits in geometry calculation,
627 * geometry info will change. This will raise an issue:
628 * In case that primary VTOC label is destroyed, format
629 * commandline can restore it via backup VTOC labels.
630 * And format locates backup VTOC labels by use of
631 * geometry. So changing geometry will
632 * prevent format from finding backup VTOC labels. To
633 * eliminate this side effect for compatibility,
634 * sd uses (capacity -1) to calculate geometry;
635 *
636 * 4) 1TB disks: some important data structures use
637 * 32-bit signed long/int (for example, daddr_t),
638 * so that sd doesn't support a disk with capacity
639 * larger than 1TB on 32-bit platform. However,
640 * for exactly 1TB disk, it was treated as (1T - 512)B
641 * in the past, and could have valid Solaris
642 * partitions. To workaround this, if an exactly 1TB
643 * disk has Solaris fdisk partition, it will be allowed
644 * to work with sd.
645 *
646 *
647 *
648 * CMLB_FAKE_LABEL_ONE_PARTITION: create s0 and s2 covering
649 * the entire disk, if there is no valid partition info.
650 * If there is a valid Solaris partition, s0 and s2 will
651 * only cover the entire Solaris partition.
652 *
653 * CMLB_CREATE_P0_MINOR_NODE: create p0 node covering
654 * the entire disk. Used by lofi to ensure presence of
655 * whole disk device node in case of LOFI_MAP_FILE ioctl.
656 *
657 * cmlbhandle cmlb handle associated with device
658 *
659 * tg_cookie cookie from target driver to be passed back to target
660 * driver when we call back to it through tg_ops.
661 *
662 * Notes:
663 * Assumes a default label based on capacity for non-removable devices.
664 * If capacity > 1TB, EFI is assumed otherwise VTOC (default VTOC
665 * for the architecture).
666 *
667 * For removable devices, default label type is assumed to be VTOC
668 * type. Create minor nodes based on a default label type.
669 * Label on the media is not validated.
670 * minor number consists of:
671 * if _SUNOS_VTOC_8 is defined
672 * lowest 3 bits is taken as partition number
673 * the rest is instance number
674 * if _SUNOS_VTOC_16 is defined
675 * lowest 6 bits is taken as partition number
676 * the rest is instance number
677 *
678 *
679 * Return values:
680 * 0 Success
681 * ENXIO creating minor nodes failed.
682 * EINVAL invalid arg, unsupported tg_ops version
683 */
684 int
685 cmlb_attach(dev_info_t *devi, cmlb_tg_ops_t *tgopsp, int device_type,
686 boolean_t is_removable, boolean_t is_hotpluggable, char *node_type,
687 int alter_behavior, cmlb_handle_t cmlbhandle, void *tg_cookie)
688 {
689
690 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
691 diskaddr_t cap;
692 int status;
693
694 ASSERT(VALID_BOOLEAN(is_removable));
695 ASSERT(VALID_BOOLEAN(is_hotpluggable));
696
697 if (tgopsp->tg_version < TG_DK_OPS_VERSION_1)
698 return (EINVAL);
699
700 mutex_enter(CMLB_MUTEX(cl));
701
702 CMLB_DEVINFO(cl) = devi;
703 cl->cmlb_tg_ops = tgopsp;
704 cl->cl_device_type = device_type;
705 cl->cl_is_removable = is_removable;
706 cl->cl_is_hotpluggable = is_hotpluggable;
707 cl->cl_node_type = node_type;
708 cl->cl_sys_blocksize = DEV_BSIZE;
709 cl->cl_f_geometry_is_valid = B_FALSE;
710 cl->cl_def_labeltype = CMLB_LABEL_VTOC;
711 cl->cl_alter_behavior = alter_behavior;
712 cl->cl_reserved = -1;
713 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
714 #if defined(__i386) || defined(__amd64)
715 cl->cl_logical_drive_count = 0;
716 #endif
717
718 if (!is_removable) {
719 mutex_exit(CMLB_MUTEX(cl));
720 status = DK_TG_GETCAP(cl, &cap, tg_cookie);
721 mutex_enter(CMLB_MUTEX(cl));
722 if (status == 0 && cap > CMLB_EXTVTOC_LIMIT) {
723 /* set default EFI if > 2TB */
724 cl->cl_def_labeltype = CMLB_LABEL_EFI;
725 }
726 }
727
728 /* create minor nodes based on default label type */
729 cl->cl_last_labeltype = CMLB_LABEL_UNDEF;
730 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
731
732 if (cmlb_create_minor_nodes(cl) != 0) {
733 mutex_exit(CMLB_MUTEX(cl));
734 return (ENXIO);
735 }
736
737 /* Define the dynamic properties for devinfo spapshots. */
738 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn);
739
740 cl->cl_state = CMLB_ATTACHED;
741
742 mutex_exit(CMLB_MUTEX(cl));
743 return (0);
744 }
745
746 /*
747 * cmlb_detach:
748 *
749 * Invalidate in-core labeling data and remove all minor nodes for
750 * the device associate with handle.
751 *
752 * Arguments:
753 * cmlbhandle cmlb handle associated with device.
754 *
755 * tg_cookie cookie from target driver to be passed back to target
756 * driver when we call back to it through tg_ops.
757 *
758 */
759 /*ARGSUSED1*/
760 void
761 cmlb_detach(cmlb_handle_t cmlbhandle, void *tg_cookie)
762 {
763 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
764
765 mutex_enter(CMLB_MUTEX(cl));
766 cl->cl_def_labeltype = CMLB_LABEL_UNDEF;
767 cl->cl_f_geometry_is_valid = B_FALSE;
768 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
769 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL);
770 cl->cl_state = CMLB_INITED;
771 mutex_exit(CMLB_MUTEX(cl));
772 }
773
774 /*
775 * cmlb_validate:
776 *
777 * Validates label.
778 *
779 * Arguments
780 * cmlbhandle cmlb handle associated with device.
781 *
782 * flags operation flags. used for verbosity control
783 *
784 * tg_cookie cookie from target driver to be passed back to target
785 * driver when we call back to it through tg_ops.
786 *
787 *
788 * Notes:
789 * If new label type is different from the current, adjust minor nodes
790 * accordingly.
791 *
792 * Return values:
793 * 0 success
794 * Note: having fdisk but no solaris partition is assumed
795 * success.
796 *
797 * ENOMEM memory allocation failed
798 * EIO i/o errors during read or get capacity
799 * EACCESS reservation conflicts
800 * EINVAL label was corrupt, or no default label was assumed
801 * ENXIO invalid handle
802 */
803 int
804 cmlb_validate(cmlb_handle_t cmlbhandle, int flags, void *tg_cookie)
805 {
806 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
807 int rval;
808 int ret = 0;
809
810 /*
811 * Temp work-around checking cl for NULL since there is a bug
812 * in sd_detach calling this routine from taskq_dispatch
813 * inited function.
814 */
815 if (cl == NULL)
816 return (ENXIO);
817
818 mutex_enter(CMLB_MUTEX(cl));
819 if (cl->cl_state < CMLB_ATTACHED) {
820 mutex_exit(CMLB_MUTEX(cl));
821 return (ENXIO);
822 }
823
824 rval = cmlb_validate_geometry((struct cmlb_lun *)cmlbhandle, B_TRUE,
825 flags, tg_cookie);
826
827 if (rval == ENOTSUP) {
828 if (cl->cl_f_geometry_is_valid) {
829 cl->cl_cur_labeltype = CMLB_LABEL_EFI;
830 ret = 0;
831 } else {
832 ret = EINVAL;
833 }
834 } else {
835 ret = rval;
836 if (ret == 0)
837 cl->cl_cur_labeltype = CMLB_LABEL_VTOC;
838 }
839
840 if (ret == 0)
841 (void) cmlb_create_minor_nodes(cl);
842
843 mutex_exit(CMLB_MUTEX(cl));
844 return (ret);
845 }
846
847 /*
848 * cmlb_invalidate:
849 * Invalidate in core label data
850 *
851 * Arguments:
852 * cmlbhandle cmlb handle associated with device.
853 * tg_cookie cookie from target driver to be passed back to target
854 * driver when we call back to it through tg_ops.
855 */
856 /*ARGSUSED1*/
857 void
858 cmlb_invalidate(cmlb_handle_t cmlbhandle, void *tg_cookie)
859 {
860 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
861
862 if (cl == NULL)
863 return;
864
865 mutex_enter(CMLB_MUTEX(cl));
866 cl->cl_f_geometry_is_valid = B_FALSE;
867 mutex_exit(CMLB_MUTEX(cl));
868 }
869
870 /*
871 * cmlb_is_valid
872 * Get status on whether the incore label/geom data is valid
873 *
874 * Arguments:
875 * cmlbhandle cmlb handle associated with device.
876 *
877 * Return values:
878 * B_TRUE if incore label/geom data is valid.
879 * B_FALSE otherwise.
880 *
881 */
882
883
884 boolean_t
885 cmlb_is_valid(cmlb_handle_t cmlbhandle)
886 {
887 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
888
889 if (cmlbhandle == NULL)
890 return (B_FALSE);
891
892 return (cl->cl_f_geometry_is_valid);
893
894 }
895
896
897
898 /*
899 * cmlb_close:
900 *
901 * Close the device, revert to a default label minor node for the device,
902 * if it is removable.
903 *
904 * Arguments:
905 * cmlbhandle cmlb handle associated with device.
906 *
907 * tg_cookie cookie from target driver to be passed back to target
908 * driver when we call back to it through tg_ops.
909 * Return values:
910 * 0 Success
911 * ENXIO Re-creating minor node failed.
912 */
913 /*ARGSUSED1*/
914 int
915 cmlb_close(cmlb_handle_t cmlbhandle, void *tg_cookie)
916 {
917 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
918
919 mutex_enter(CMLB_MUTEX(cl));
920 cl->cl_f_geometry_is_valid = B_FALSE;
921
922 /* revert to default minor node for this device */
923 if (ISREMOVABLE(cl)) {
924 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF;
925 (void) cmlb_create_minor_nodes(cl);
926 }
927
928 mutex_exit(CMLB_MUTEX(cl));
929 return (0);
930 }
931
932 /*
933 * cmlb_get_devid_block:
934 * get the block number where device id is stored.
935 *
936 * Arguments:
937 * cmlbhandle cmlb handle associated with device.
938 * devidblockp pointer to block number.
939 * tg_cookie cookie from target driver to be passed back to target
940 * driver when we call back to it through tg_ops.
941 *
942 * Notes:
943 * It stores the block number of device id in the area pointed to
944 * by devidblockp.
945 * with the block number of device id.
946 *
947 * Return values:
948 * 0 success
949 * EINVAL device id does not apply to current label type.
950 */
951 /*ARGSUSED2*/
952 int
953 cmlb_get_devid_block(cmlb_handle_t cmlbhandle, diskaddr_t *devidblockp,
954 void *tg_cookie)
955 {
956 daddr_t spc, blk, head, cyl;
957 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
958
959 mutex_enter(CMLB_MUTEX(cl));
960 if (cl->cl_state < CMLB_ATTACHED) {
961 mutex_exit(CMLB_MUTEX(cl));
962 return (EINVAL);
963 }
964
965 if ((!cl->cl_f_geometry_is_valid) ||
966 (cl->cl_solaris_size < DK_LABEL_LOC)) {
967 mutex_exit(CMLB_MUTEX(cl));
968 return (EINVAL);
969 }
970
971 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) {
972 if (cl->cl_reserved != -1) {
973 blk = cl->cl_map[cl->cl_reserved].dkl_cylno;
974 } else {
975 mutex_exit(CMLB_MUTEX(cl));
976 return (EINVAL);
977 }
978 } else {
979 /* if the disk is unlabeled, don't write a devid to it */
980 if (cl->cl_label_from_media != CMLB_LABEL_VTOC) {
981 mutex_exit(CMLB_MUTEX(cl));
982 return (EINVAL);
983 }
984
985 /* this geometry doesn't allow us to write a devid */
986 if (cl->cl_g.dkg_acyl < 2) {
987 mutex_exit(CMLB_MUTEX(cl));
988 return (EINVAL);
989 }
990
991 /*
992 * Subtract 2 guarantees that the next to last cylinder
993 * is used
994 */
995 cyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl - 2;
996 spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
997 head = cl->cl_g.dkg_nhead - 1;
998 blk = cl->cl_solaris_offset +
999 (cyl * (spc - cl->cl_g.dkg_apc)) +
1000 (head * cl->cl_g.dkg_nsect) + 1;
1001 }
1002
1003 *devidblockp = blk;
1004 mutex_exit(CMLB_MUTEX(cl));
1005 return (0);
1006 }
1007
1008 /*
1009 * cmlb_partinfo:
1010 * Get partition info for specified partition number.
1011 *
1012 * Arguments:
1013 * cmlbhandle cmlb handle associated with device.
1014 * part partition number
1015 * nblocksp pointer to number of blocks
1016 * startblockp pointer to starting block
1017 * partnamep pointer to name of partition
1018 * tagp pointer to tag info
1019 * tg_cookie cookie from target driver to be passed back to target
1020 * driver when we call back to it through tg_ops.
1021 *
1022 *
1023 * Notes:
1024 * If in-core label is not valid, this functions tries to revalidate
1025 * the label. If label is valid, it stores the total number of blocks
1026 * in this partition in the area pointed to by nblocksp, starting
1027 * block number in area pointed to by startblockp, pointer to partition
1028 * name in area pointed to by partnamep, and tag value in area
1029 * pointed by tagp.
1030 * For EFI labels, tag value will be set to 0.
1031 *
1032 * For all nblocksp, startblockp and partnamep, tagp, a value of NULL
1033 * indicates the corresponding info is not requested.
1034 *
1035 *
1036 * Return values:
1037 * 0 success
1038 * EINVAL no valid label or requested partition number is invalid.
1039 *
1040 */
1041 int
1042 cmlb_partinfo(cmlb_handle_t cmlbhandle, int part, diskaddr_t *nblocksp,
1043 diskaddr_t *startblockp, char **partnamep, uint16_t *tagp, void *tg_cookie)
1044 {
1045
1046 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
1047 int rval;
1048 #if defined(__i386) || defined(__amd64)
1049 int ext_part;
1050 #endif
1051
1052 ASSERT(cl != NULL);
1053 mutex_enter(CMLB_MUTEX(cl));
1054 if (cl->cl_state < CMLB_ATTACHED) {
1055 mutex_exit(CMLB_MUTEX(cl));
1056 return (EINVAL);
1057 }
1058
1059 if (part < 0 || part >= MAXPART) {
1060 rval = EINVAL;
1061 } else {
1062 if (!cl->cl_f_geometry_is_valid)
1063 (void) cmlb_validate_geometry((struct cmlb_lun *)cl,
1064 B_FALSE, 0, tg_cookie);
1065
1066 if (((!cl->cl_f_geometry_is_valid) ||
1067 (part < NDKMAP && cl->cl_solaris_size == 0)) &&
1068 (part != P0_RAW_DISK)) {
1069 rval = EINVAL;
1070 } else {
1071 if (startblockp != NULL)
1072 *startblockp = (diskaddr_t)cl->cl_offset[part];
1073
1074 if (nblocksp != NULL)
1075 *nblocksp = (diskaddr_t)
1076 cl->cl_map[part].dkl_nblk;
1077
1078 if (tagp != NULL)
1079 *tagp =
1080 ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) ||
1081 (part >= NDKMAP)) ? V_UNASSIGNED :
1082 cl->cl_vtoc.v_part[part].p_tag;
1083 rval = 0;
1084 }
1085
1086 /* consistent with behavior of sd for getting minor name */
1087 if (partnamep != NULL) {
1088 #if defined(__i386) || defined(__amd64)
1089 #if defined(_FIRMWARE_NEEDS_FDISK)
1090 if (part > FDISK_P4) {
1091 ext_part = part-FDISK_P4-1;
1092 *partnamep = dk_ext_minor_data[ext_part].name;
1093 } else
1094 #endif
1095 #endif
1096 *partnamep = dk_minor_data[part].name;
1097 }
1098
1099 }
1100
1101 mutex_exit(CMLB_MUTEX(cl));
1102 return (rval);
1103 }
1104
1105 /*
1106 * cmlb_efi_label_capacity:
1107 * Get capacity stored in EFI disk label.
1108 *
1109 * Arguments:
1110 * cmlbhandle cmlb handle associated with device.
1111 * capacity pointer to capacity stored in EFI disk label.
1112 * tg_cookie cookie from target driver to be passed back to target
1113 * driver when we call back to it through tg_ops.
1114 *
1115 *
1116 * Notes:
1117 * If in-core label is not valid, this functions tries to revalidate
1118 * the label. If label is valid and is an EFI label, it stores the capacity
1119 * in disk label in the area pointed to by capacity.
1120 *
1121 *
1122 * Return values:
1123 * 0 success
1124 * EINVAL no valid EFI label or capacity is NULL.
1125 *
1126 */
1127 int
1128 cmlb_efi_label_capacity(cmlb_handle_t cmlbhandle, diskaddr_t *capacity,
1129 void *tg_cookie)
1130 {
1131 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle;
1132 int rval;
1133
1134 ASSERT(cl != NULL);
1135 mutex_enter(CMLB_MUTEX(cl));
1136 if (cl->cl_state < CMLB_ATTACHED) {
1137 mutex_exit(CMLB_MUTEX(cl));
1138 return (EINVAL);
1139 }
1140
1141 if (!cl->cl_f_geometry_is_valid)
1142 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE,
1143 0, tg_cookie);
1144
1145 if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) ||
1146 (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) {
1147 rval = EINVAL;
1148 } else {
1149 *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk;
1150 rval = 0;
1151 }
1152
1153 mutex_exit(CMLB_MUTEX(cl));
1154 return (rval);
1155 }
1156
1157 /* Caller should make sure Test Unit Ready succeeds before calling this. */
1158 /*ARGSUSED*/
1159 int
1160 cmlb_ioctl(cmlb_handle_t cmlbhandle, dev_t dev, int cmd, intptr_t arg,
1161 int flag, cred_t *cred_p, int *rval_p, void *tg_cookie)
1162 {
1163
1164 int err;
1165 struct cmlb_lun *cl;
1166
1167 cl = (struct cmlb_lun *)cmlbhandle;
1168
1169 ASSERT(cl != NULL);
1170
1171 mutex_enter(CMLB_MUTEX(cl));
1172 if (cl->cl_state < CMLB_ATTACHED) {
1173 mutex_exit(CMLB_MUTEX(cl));
1174 return (EIO);
1175 }
1176
1177 switch (cmd) {
1178 case DKIOCSEXTVTOC:
1179 case DKIOCSGEOM:
1180 case DKIOCSETEFI:
1181 case DKIOCSMBOOT:
1182 #if defined(__i386) || defined(__amd64)
1183 case DKIOCSETEXTPART:
1184 #endif
1185 break;
1186 case DKIOCSVTOC:
1187 #if defined(__i386) || defined(__amd64)
1188 case DKIOCPARTINFO:
1189 #endif
1190 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1191 mutex_exit(CMLB_MUTEX(cl));
1192 return (EOVERFLOW);
1193 }
1194 break;
1195 default:
1196 (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT,
1197 tg_cookie);
1198
1199 switch (cmd) {
1200 case DKIOCGVTOC:
1201 case DKIOCGAPART:
1202 case DKIOCSAPART:
1203
1204 if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1205 /* GPT label on disk */
1206 mutex_exit(CMLB_MUTEX(cl));
1207 return (ENOTSUP);
1208 } else if
1209 (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1210 mutex_exit(CMLB_MUTEX(cl));
1211 return (EOVERFLOW);
1212 }
1213 break;
1214
1215 case DKIOCGGEOM:
1216 if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1217 /* GPT label on disk */
1218 mutex_exit(CMLB_MUTEX(cl));
1219 return (ENOTSUP);
1220 }
1221 break;
1222 default:
1223 break;
1224 }
1225 }
1226
1227 mutex_exit(CMLB_MUTEX(cl));
1228
1229 switch (cmd) {
1230 case DKIOCGGEOM:
1231 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
1232 err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
1233 break;
1234
1235 case DKIOCSGEOM:
1236 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
1237 err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
1238 break;
1239
1240 case DKIOCGAPART:
1241 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
1242 err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
1243 flag, tg_cookie);
1244 break;
1245
1246 case DKIOCSAPART:
1247 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
1248 err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
1249 break;
1250
1251 case DKIOCGVTOC:
1252 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1253 err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
1254 break;
1255
1256 case DKIOCGEXTVTOC:
1257 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1258 err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie);
1259 break;
1260
1261 case DKIOCGETEFI:
1262 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
1263 err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
1264 break;
1265
1266 case DKIOCPARTITION:
1267 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
1268 err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
1269 break;
1270
1271 case DKIOCSVTOC:
1272 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1273 err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
1274 tg_cookie);
1275 break;
1276
1277 case DKIOCSEXTVTOC:
1278 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1279 err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag,
1280 tg_cookie);
1281 break;
1282
1283 case DKIOCSETEFI:
1284 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
1285 err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
1286 break;
1287
1288 case DKIOCGMBOOT:
1289 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
1290 err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
1291 break;
1292
1293 case DKIOCSMBOOT:
1294 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
1295 err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
1296 break;
1297 case DKIOCG_PHYGEOM:
1298 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
1299 #if defined(__i386) || defined(__amd64)
1300 err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie);
1301 #else
1302 err = ENOTTY;
1303 #endif
1304 break;
1305 case DKIOCG_VIRTGEOM:
1306 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
1307 #if defined(__i386) || defined(__amd64)
1308 err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
1309 #else
1310 err = ENOTTY;
1311 #endif
1312 break;
1313 case DKIOCPARTINFO:
1314 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
1315 #if defined(__i386) || defined(__amd64)
1316 err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
1317 #else
1318 err = ENOTTY;
1319 #endif
1320 break;
1321 case DKIOCEXTPARTINFO:
1322 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
1323 #if defined(__i386) || defined(__amd64)
1324 err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag);
1325 #else
1326 err = ENOTTY;
1327 #endif
1328 break;
1329 #if defined(__i386) || defined(__amd64)
1330 case DKIOCSETEXTPART:
1331 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART");
1332 err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie);
1333 break;
1334 #endif
1335 default:
1336 err = ENOTTY;
1337
1338 }
1339
1340 /*
1341 * An ioctl that succeeds and changed ('set') size(9P) information
1342 * needs to invalidate the cached devinfo snapshot to avoid having
1343 * old information being returned in a snapshots.
1344 *
1345 * NB: When available, call ddi_change_minor_node() to clear
1346 * SSIZEVALID in specfs vnodes via spec_size_invalidate().
1347 */
1348 if (err == 0) {
1349 switch (cmd) {
1350 case DKIOCSGEOM:
1351 case DKIOCSAPART:
1352 case DKIOCSVTOC:
1353 case DKIOCSEXTVTOC:
1354 case DKIOCSETEFI:
1355 i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl),
1356 i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl)));
1357 }
1358 }
1359 return (err);
1360 }
1361
1362 dev_t
1363 cmlb_make_device(struct cmlb_lun *cl)
1364 {
1365 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
1366 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1367 ddi_get_instance(
1368 CMLB_DEVINFO(cl)) << CMLBUNIT_FORCE_P0_SHIFT));
1369 } else {
1370 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1371 ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
1372 }
1373 }
1374
1375 /*
1376 * Function: cmlb_check_update_blockcount
1377 *
1378 * Description: If current capacity value is invalid, obtains the
1379 * current capacity from target driver.
1380 *
1381 * Return Code: 0 success
1382 * EIO failure
1383 */
1384 static int
1385 cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie)
1386 {
1387 int status;
1388 diskaddr_t capacity;
1389 uint32_t lbasize;
1390
1391 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1392
1393 if (cl->cl_f_geometry_is_valid)
1394 return (0);
1395
1396 mutex_exit(CMLB_MUTEX(cl));
1397 status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
1398 if (status != 0) {
1399 mutex_enter(CMLB_MUTEX(cl));
1400 return (EIO);
1401 }
1402
1403 status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
1404 mutex_enter(CMLB_MUTEX(cl));
1405 if (status != 0)
1406 return (EIO);
1407
1408 if ((capacity != 0) && (lbasize != 0)) {
1409 cl->cl_blockcount = capacity;
1410 cl->cl_tgt_blocksize = lbasize;
1411 if (!cl->cl_is_removable) {
1412 cl->cl_sys_blocksize = lbasize;
1413 }
1414 return (0);
1415 } else {
1416 return (EIO);
1417 }
1418 }
1419
1420 static int
1421 cmlb_create_minor(dev_info_t *dip, char *name, int spec_type,
1422 minor_t minor_num, char *node_type, int flag, boolean_t internal)
1423 {
1424 ASSERT(VALID_BOOLEAN(internal));
1425
1426 if (internal)
1427 return (ddi_create_internal_pathname(dip,
1428 name, spec_type, minor_num));
1429 else
1430 return (ddi_create_minor_node(dip,
1431 name, spec_type, minor_num, node_type, flag));
1432 }
1433
1434 /*
1435 * Function: cmlb_create_minor_nodes
1436 *
1437 * Description: Create or adjust the minor device nodes for the instance.
1438 * Minor nodes are created based on default label type,
1439 * current label type and last label type we created
1440 * minor nodes based on.
1441 *
1442 *
1443 * Arguments: cl - driver soft state (unit) structure
1444 *
1445 * Return Code: 0 success
1446 * ENXIO failure.
1447 *
1448 * Context: Kernel thread context
1449 */
1450 static int
1451 cmlb_create_minor_nodes(struct cmlb_lun *cl)
1452 {
1453 struct driver_minor_data *dmdp;
1454 int instance, shift;
1455 char name[48];
1456 cmlb_label_t newlabeltype;
1457 boolean_t internal;
1458
1459 ASSERT(cl != NULL);
1460 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1461
1462 internal = VOID2BOOLEAN(
1463 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
1464
1465 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
1466 shift = CMLBUNIT_FORCE_P0_SHIFT;
1467 else
1468 shift = CMLBUNIT_SHIFT;
1469
1470 /* check the most common case */
1471 if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
1472 cl->cl_last_labeltype == cl->cl_cur_labeltype) {
1473 /* do nothing */
1474 return (0);
1475 }
1476
1477 if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
1478 /* we should never get here */
1479 return (ENXIO);
1480 }
1481
1482 if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
1483 /* first time during attach */
1484 newlabeltype = cl->cl_def_labeltype;
1485
1486 instance = ddi_get_instance(CMLB_DEVINFO(cl));
1487
1488 /* Create all the minor nodes for this target. */
1489 dmdp = (newlabeltype == CMLB_LABEL_EFI) ? dk_minor_data_efi :
1490 dk_minor_data;
1491 while (dmdp->name != NULL) {
1492
1493 (void) sprintf(name, "%s", dmdp->name);
1494
1495 if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
1496 dmdp->type,
1497 (instance << shift) | dmdp->minor,
1498 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
1499 /*
1500 * Clean up any nodes that may have been
1501 * created, in case this fails in the middle
1502 * of the loop.
1503 */
1504 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1505 return (ENXIO);
1506 }
1507 dmdp++;
1508 }
1509 cl->cl_last_labeltype = newlabeltype;
1510 #if defined(_SUNOS_VTOC_8)
1511 /*
1512 * "emulate" p0 device for sparc, used by lofi
1513 */
1514 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) {
1515 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q", S_IFBLK,
1516 (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
1517 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
1518 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1519 return (ENXIO);
1520 }
1521
1522 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q,raw",
1523 S_IFCHR,
1524 (instance << CMLBUNIT_FORCE_P0_SHIFT) | P0_RAW_DISK,
1525 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
1526 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1527 return (ENXIO);
1528 }
1529 }
1530 #endif /* defined(_SUNOS_VTOC_8) */
1531 return (0);
1532 }
1533
1534 /* Not first time */
1535 if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
1536 if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
1537 /* close time, revert to default. */
1538 newlabeltype = cl->cl_def_labeltype;
1539 } else {
1540 /*
1541 * do nothing since the type for which we last created
1542 * nodes matches the default
1543 */
1544 return (0);
1545 }
1546 } else {
1547 if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
1548 /* We are not closing, use current label type */
1549 newlabeltype = cl->cl_cur_labeltype;
1550 } else {
1551 /*
1552 * do nothing since the type for which we last created
1553 * nodes matches the current label type
1554 */
1555 return (0);
1556 }
1557 }
1558
1559 instance = ddi_get_instance(CMLB_DEVINFO(cl));
1560
1561 /*
1562 * Currently we only fix up the s7 node when we are switching
1563 * label types from or to EFI. This is consistent with
1564 * current behavior of sd.
1565 */
1566 if (newlabeltype == CMLB_LABEL_EFI &&
1567 cl->cl_last_labeltype != CMLB_LABEL_EFI) {
1568 /* from vtoc to EFI */
1569 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
1570 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
1571 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
1572 S_IFBLK, (instance << shift) | WD_NODE,
1573 cl->cl_node_type, NULL, internal);
1574 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
1575 S_IFCHR, (instance << shift) | WD_NODE,
1576 cl->cl_node_type, NULL, internal);
1577 } else {
1578 /* from efi to vtoc */
1579 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
1580 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
1581 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
1582 S_IFBLK, (instance << shift) | WD_NODE,
1583 cl->cl_node_type, NULL, internal);
1584 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
1585 S_IFCHR, (instance << shift) | WD_NODE,
1586 cl->cl_node_type, NULL, internal);
1587 }
1588
1589 cl->cl_last_labeltype = newlabeltype;
1590 return (0);
1591 }
1592
1593 /*
1594 * Function: cmlb_validate_geometry
1595 *
1596 * Description: Read the label from the disk (if present). Update the unit's
1597 * geometry and vtoc information from the data in the label.
1598 * Verify that the label is valid.
1599 *
1600 * Arguments:
1601 * cl driver soft state (unit) structure
1602 *
1603 * forcerevalid force revalidation even if we are already valid.
1604 * flags operation flags from target driver. Used for verbosity
1605 * control at this time.
1606 * tg_cookie cookie from target driver to be passed back to target
1607 * driver when we call back to it through tg_ops.
1608 *
1609 * Return Code: 0 - Successful completion
1610 * EINVAL - Invalid value in cl->cl_tgt_blocksize or
1611 * cl->cl_blockcount; or label on disk is corrupted
1612 * or unreadable.
1613 * EACCES - Reservation conflict at the device.
1614 * ENOMEM - Resource allocation error
1615 * ENOTSUP - geometry not applicable
1616 *
1617 * Context: Kernel thread only (can sleep).
1618 */
1619 static int
1620 cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags,
1621 void *tg_cookie)
1622 {
1623 int label_error = 0;
1624 diskaddr_t capacity;
1625 int count;
1626
1627 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1628 ASSERT(VALID_BOOLEAN(forcerevalid));
1629
1630 if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) {
1631 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
1632 return (ENOTSUP);
1633 return (0);
1634 }
1635
1636 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
1637 return (EIO);
1638
1639 capacity = cl->cl_blockcount;
1640
1641 /*
1642 * Set up the "whole disk" fdisk partition; this should always
1643 * exist, regardless of whether the disk contains an fdisk table
1644 * or vtoc.
1645 */
1646 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
1647 cl->cl_offset[P0_RAW_DISK] = 0;
1648 /*
1649 * note if capacity > int32_max(1TB) we are in 64bit environment
1650 * so no truncation happens
1651 */
1652 cl->cl_map[P0_RAW_DISK].dkl_nblk = capacity;
1653
1654 /*
1655 * Refresh the logical and physical geometry caches.
1656 * (data from MODE SENSE format/rigid disk geometry pages,
1657 * and scsi_ifgetcap("geometry").
1658 */
1659 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
1660
1661 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
1662 label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
1663 if (label_error == 0) {
1664
1665 /* found a valid EFI label */
1666 cmlb_dbg(CMLB_TRACE, cl,
1667 "cmlb_validate_geometry: found EFI label\n");
1668 /*
1669 * solaris_size and geometry_is_valid are set in
1670 * cmlb_use_efi
1671 */
1672 return (ENOTSUP);
1673 }
1674
1675 /* NO EFI label found */
1676
1677 if (capacity > CMLB_EXTVTOC_LIMIT) {
1678 if (label_error == ESRCH) {
1679 /*
1680 * they've configured a LUN over 2TB, but used
1681 * format.dat to restrict format's view of the
1682 * capacity to be under 2TB in some earlier Solaris
1683 * release.
1684 */
1685 /* i.e > 2TB with a VTOC < 2TB */
1686 if (!(flags & CMLB_SILENT) &&
1687 (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {
1688
1689 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1690 CE_NOTE, "!Disk (%s%d) is limited to 2 TB "
1691 "due to VTOC label. To use the full "
1692 "capacity of the disk, use format(1M) to "
1693 "relabel the disk with EFI/GPT label.\n",
1694 CMLB_LABEL(cl),
1695 ddi_get_instance(CMLB_DEVINFO(cl)));
1696
1697 cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
1698 }
1699 } else {
1700 return (ENOTSUP);
1701 }
1702 }
1703
1704 label_error = 0;
1705
1706 /*
1707 * at this point it is either labeled with a VTOC or it is
1708 * under 1TB (<= 1TB actually for off-by-1)
1709 */
1710
1711 /*
1712 * Only DIRECT ACCESS devices will have Scl labels.
1713 * CD's supposedly have a Scl label, too
1714 */
1715 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
1716 struct dk_label *dkl;
1717 offset_t label_addr;
1718 int rval;
1719 size_t buffer_size;
1720
1721 /*
1722 * Note: This will set up cl->cl_solaris_size and
1723 * cl->cl_solaris_offset.
1724 */
1725 rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1726 if ((rval != 0) && !ISCD(cl)) {
1727 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1728 return (rval);
1729 }
1730
1731 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
1732 /*
1733 * Found fdisk table but no Solaris partition entry,
1734 * so don't call cmlb_uselabel() and don't create
1735 * a default label.
1736 */
1737 label_error = 0;
1738 cl->cl_f_geometry_is_valid = B_TRUE;
1739 goto no_solaris_partition;
1740 }
1741
1742 label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1743
1744 buffer_size = cl->cl_sys_blocksize;
1745
1746 cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
1747 "label_addr: 0x%x allocation size: 0x%x\n",
1748 label_addr, buffer_size);
1749
1750 if ((dkl = kmem_zalloc(buffer_size, KM_NOSLEEP)) == NULL)
1751 return (ENOMEM);
1752
1753 mutex_exit(CMLB_MUTEX(cl));
1754 rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
1755 mutex_enter(CMLB_MUTEX(cl));
1756
1757 switch (rval) {
1758 case 0:
1759 /*
1760 * cmlb_uselabel will establish that the geometry
1761 * is valid.
1762 */
1763 if (cmlb_uselabel(cl,
1764 (struct dk_label *)(uintptr_t)dkl, flags) !=
1765 CMLB_LABEL_IS_VALID) {
1766 label_error = EINVAL;
1767 } else
1768 cl->cl_label_from_media = CMLB_LABEL_VTOC;
1769 break;
1770 case EACCES:
1771 label_error = EACCES;
1772 break;
1773 default:
1774 label_error = EINVAL;
1775 break;
1776 }
1777
1778 kmem_free(dkl, buffer_size);
1779 }
1780
1781 /*
1782 * If a valid label was not found, AND if no reservation conflict
1783 * was detected, then go ahead and create a default label (4069506).
1784 *
1785 * Note: currently, for VTOC_8 devices, the default label is created
1786 * for removables and hotpluggables only. For VTOC_16 devices, the
1787 * default label will be created for all devices.
1788 * (see cmlb_build_default_label)
1789 */
1790 #if defined(_SUNOS_VTOC_8)
1791 if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1792 (label_error != EACCES)) {
1793 #elif defined(_SUNOS_VTOC_16)
1794 if (label_error != EACCES) {
1795 #endif
1796 if (!cl->cl_f_geometry_is_valid) {
1797 cmlb_build_default_label(cl, tg_cookie);
1798 }
1799 label_error = 0;
1800 }
1801
1802 no_solaris_partition:
1803
1804 #if defined(_SUNOS_VTOC_16)
1805 /*
1806 * If we have valid geometry, set up the remaining fdisk partitions.
1807 * Note that dkl_cylno is not used for the fdisk map entries, so
1808 * we set it to an entirely bogus value.
1809 */
1810 for (count = 0; count < FDISK_PARTS; count++) {
1811 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX;
1812 cl->cl_map[FDISK_P1 + count].dkl_nblk =
1813 cl->cl_fmap[count].fmap_nblk;
1814
1815 cl->cl_offset[FDISK_P1 + count] =
1816 cl->cl_fmap[count].fmap_start;
1817 }
1818 #endif
1819
1820 for (count = 0; count < NDKMAP; count++) {
1821 #if defined(_SUNOS_VTOC_8)
1822 struct dk_map *lp = &cl->cl_map[count];
1823 cl->cl_offset[count] =
1824 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
1825 #elif defined(_SUNOS_VTOC_16)
1826 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
1827
1828 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
1829 #else
1830 #error "No VTOC format defined."
1831 #endif
1832 }
1833
1834 return (label_error);
1835 }
1836
1837 #if defined(_SUNOS_VTOC_16)
1838 /*
1839 * Function: cmlb_convert_geometry
1840 *
1841 * Description: Convert physical geometry into a dk_geom structure. In
1842 * other words, make sure we don't wrap 16-bit values.
1843 * e.g. converting from geom_cache to dk_geom
1844 *
1845 * Context: Kernel thread only
1846 */
1847 static void
1848 cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
1849 struct dk_geom *cl_g, void *tg_cookie)
1850 {
1851
1852 ASSERT(cl != NULL);
1853 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1854
1855 /* Unlabeled SCSI floppy device */
1856 if (capacity < 160) {
1857 /* Less than 80K */
1858 cl_g->dkg_nhead = 1;
1859 cl_g->dkg_ncyl = capacity;
1860 cl_g->dkg_nsect = 1;
1861 return;
1862 } else if (capacity <= 0x1000) {
1863 cl_g->dkg_nhead = 2;
1864 cl_g->dkg_ncyl = 80;
1865 cl_g->dkg_nsect = capacity / (cl_g->dkg_nhead * cl_g->dkg_ncyl);
1866 return;
1867 }
1868
1869 /*
1870 * For all devices we calculate cylinders using the heads and sectors
1871 * we assign based on capacity of the device. The algorithm is
1872 * designed to be compatible with the way other operating systems
1873 * lay out fdisk tables for X86 and to insure that the cylinders never
1874 * exceed 65535 to prevent problems with X86 ioctls that report
1875 * geometry.
1876 * For some smaller disk sizes we report geometry that matches those
1877 * used by X86 BIOS usage. For larger disks, we use SPT that are
1878 * multiples of 63, since other OSes that are not limited to 16-bits
1879 * for cylinders stop at 63 SPT we make do by using multiples of 63 SPT.
1880 *
1881 * The following table (in order) illustrates some end result
1882 * calculations:
1883 *
1884 * Maximum number of blocks nhead nsect
1885 *
1886 * 2097152 (1GB) 64 32
1887 * 16777216 (8GB) 128 32
1888 * 1052819775 (502.02GB) 255 63
1889 * 2105639550 (0.98TB) 255 126
1890 * 3158459325 (1.47TB) 255 189
1891 * 4211279100 (1.96TB) 255 252
1892 * 5264098875 (2.45TB) 255 315
1893 * ...
1894 *
1895 * For Solid State Drive(SSD), it uses 4K page size inside and may be
1896 * double with every new generation. If the I/O is not aligned with
1897 * page size on SSDs, SSDs perform a lot slower.
1898 * By default, Solaris partition starts from cylinder 1. It will be
1899 * misaligned even with 4K if using heads(255) and SPT(63). To
1900 * workaround the problem, if the device is SSD, we use heads(224) and
1901 * SPT multiple of 56. Thus the default Solaris partition starts from
1902 * a position that aligns with 128K on a 512 bytes sector size SSD.
1903 */
1904
1905 if (capacity <= 0x200000) {
1906 cl_g->dkg_nhead = 64;
1907 cl_g->dkg_nsect = 32;
1908 } else if (capacity <= 0x01000000) {
1909 cl_g->dkg_nhead = 128;
1910 cl_g->dkg_nsect = 32;
1911 } else {
1912 tg_attribute_t tgattribute;
1913 int is_solid_state;
1914 unsigned short nhead;
1915 unsigned short nsect;
1916
1917 bzero(&tgattribute, sizeof (tg_attribute_t));
1918
1919 mutex_exit(CMLB_MUTEX(cl));
1920 is_solid_state =
1921 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
1922 tgattribute.media_is_solid_state : FALSE;
1923 mutex_enter(CMLB_MUTEX(cl));
1924
1925 if (is_solid_state) {
1926 nhead = 224;
1927 nsect = 56;
1928 } else {
1929 nhead = 255;
1930 nsect = 63;
1931 }
1932
1933 cl_g->dkg_nhead = nhead;
1934
1935 /* make dkg_nsect be smallest multiple of nsect */
1936 cl_g->dkg_nsect = ((capacity +
1937 (UINT16_MAX * nhead * nsect) - 1) /
1938 (UINT16_MAX * nhead * nsect)) * nsect;
1939
1940 if (cl_g->dkg_nsect == 0)
1941 cl_g->dkg_nsect = (UINT16_MAX / nsect) * nsect;
1942 }
1943
1944 }
1945 #endif
1946
1947 /*
1948 * Function: cmlb_resync_geom_caches
1949 *
1950 * Description: (Re)initialize both geometry caches: the virtual geometry
1951 * information is extracted from the HBA (the "geometry"
1952 * capability), and the physical geometry cache data is
1953 * generated by issuing MODE SENSE commands.
1954 *
1955 * Arguments:
1956 * cl driver soft state (unit) structure
1957 * capacity disk capacity in #blocks
1958 * tg_cookie cookie from target driver to be passed back to target
1959 * driver when we call back to it through tg_ops.
1960 *
1961 * Context: Kernel thread only (can sleep).
1962 */
1963 static void
1964 cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
1965 void *tg_cookie)
1966 {
1967 struct cmlb_geom pgeom;
1968 struct cmlb_geom lgeom;
1969 struct cmlb_geom *pgeomp = &pgeom;
1970 unsigned short nhead;
1971 unsigned short nsect;
1972 int spc;
1973 int ret;
1974
1975 ASSERT(cl != NULL);
1976 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1977
1978 /*
1979 * Ask the controller for its logical geometry.
1980 * Note: if the HBA does not support scsi_ifgetcap("geometry"),
1981 * then the lgeom cache will be invalid.
1982 */
1983 mutex_exit(CMLB_MUTEX(cl));
1984 bzero(&lgeom, sizeof (struct cmlb_geom));
1985 ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1986 mutex_enter(CMLB_MUTEX(cl));
1987
1988 bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
1989
1990 /*
1991 * Initialize the pgeom cache from lgeom, so that if MODE SENSE
1992 * doesn't work, DKIOCG_PHYSGEOM can return reasonable values.
1993 */
1994 if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1995 cl->cl_lgeom.g_nhead == 0) {
1996 /*
1997 * Note: Perhaps this needs to be more adaptive? The rationale
1998 * is that, if there's no HBA geometry from the HBA driver, any
1999 * guess is good, since this is the physical geometry. If MODE
2000 * SENSE fails this gives a max cylinder size for non-LBA access
2001 */
2002 nhead = 255;
2003 nsect = 63;
2004 } else {
2005 nhead = cl->cl_lgeom.g_nhead;
2006 nsect = cl->cl_lgeom.g_nsect;
2007 }
2008
2009 if (ISCD(cl)) {
2010 pgeomp->g_nhead = 1;
2011 pgeomp->g_nsect = nsect * nhead;
2012 } else {
2013 pgeomp->g_nhead = nhead;
2014 pgeomp->g_nsect = nsect;
2015 }
2016
2017 spc = pgeomp->g_nhead * pgeomp->g_nsect;
2018 pgeomp->g_capacity = capacity;
2019 if (spc == 0)
2020 pgeomp->g_ncyl = 0;
2021 else
2022 pgeomp->g_ncyl = pgeomp->g_capacity / spc;
2023 pgeomp->g_acyl = 0;
2024
2025 /*
2026 * Retrieve fresh geometry data from the hardware, stash it
2027 * here temporarily before we rebuild the incore label.
2028 *
2029 * We want to use the MODE SENSE commands to derive the
2030 * physical geometry of the device, but if either command
2031 * fails, the logical geometry is used as the fallback for
2032 * disk label geometry.
2033 */
2034
2035 mutex_exit(CMLB_MUTEX(cl));
2036 (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
2037 mutex_enter(CMLB_MUTEX(cl));
2038
2039 /*
2040 * Now update the real copy while holding the mutex. This
2041 * way the global copy is never in an inconsistent state.
2042 */
2043 bcopy(pgeomp, &cl->cl_pgeom, sizeof (cl->cl_pgeom));
2044
2045 cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
2046 "(cached from lgeom)\n");
2047 cmlb_dbg(CMLB_INFO, cl,
2048 " ncyl: %ld; acyl: %d; nhead: %d; nsect: %d\n",
2049 cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
2050 cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
2051 cmlb_dbg(CMLB_INFO, cl, " lbasize: %d; capacity: %ld; "
2052 "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
2053 cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
2054 cl->cl_pgeom.g_rpm);
2055 }
2056
2057
2058 #if defined(__i386) || defined(__amd64)
2059 /*
2060 * Function: cmlb_update_ext_minor_nodes
2061 *
2062 * Description: Routine to add/remove extended partition device nodes
2063 *
2064 * Arguments:
2065 * cl driver soft state (unit) structure
2066 * num_parts Number of logical drives found on the LUN
2067 *
2068 * Should be called with the mutex held
2069 *
2070 * Return Code: 0 for success
2071 *
2072 * Context: User and Kernel thread
2073 *
2074 */
2075 static int
2076 cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts)
2077 {
2078 int i, count, shift;
2079 char name[48];
2080 int instance;
2081 struct driver_minor_data *demdp, *demdpr;
2082 char *devnm;
2083 dev_info_t *pdip;
2084 boolean_t internal;
2085
2086 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2087 ASSERT(cl->cl_update_ext_minor_nodes == 1);
2088
2089 internal = VOID2BOOLEAN(
2090 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
2091 instance = ddi_get_instance(CMLB_DEVINFO(cl));
2092 demdp = dk_ext_minor_data;
2093 demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];
2094
2095 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
2096 shift = CMLBUNIT_FORCE_P0_SHIFT;
2097 else
2098 shift = CMLBUNIT_SHIFT;
2099
2100 if (cl->cl_logical_drive_count) {
2101 for (i = 0; i < cl->cl_logical_drive_count; i++) {
2102 (void) sprintf(name, "%s", demdp->name);
2103 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2104 (void) sprintf(name, "%s", demdpr->name);
2105 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2106 demdp++;
2107 demdpr++;
2108 }
2109 /* There are existing device nodes. Remove them */
2110 devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
2111 (void) ddi_deviname(cl->cl_devi, devnm);
2112 pdip = ddi_get_parent(cl->cl_devi);
2113 (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE);
2114 kmem_free(devnm, MAXNAMELEN + 1);
2115 }
2116
2117 demdp = dk_ext_minor_data;
2118 demdpr = &dk_ext_minor_data[MAX_EXT_PARTS];
2119
2120 for (i = 0; i < num_parts; i++) {
2121 (void) sprintf(name, "%s", demdp->name);
2122 if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
2123 demdp->type,
2124 (instance << shift) | demdp->minor,
2125 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
2126 /*
2127 * Clean up any nodes that may have been
2128 * created, in case this fails in the middle
2129 * of the loop.
2130 */
2131 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2132 cl->cl_logical_drive_count = 0;
2133 return (ENXIO);
2134 }
2135 (void) sprintf(name, "%s", demdpr->name);
2136 if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
2137 demdpr->type,
2138 (instance << shift) | demdpr->minor,
2139 cl->cl_node_type, NULL) == DDI_FAILURE) {
2140 /*
2141 * Clean up any nodes that may have been
2142 * created, in case this fails in the middle
2143 * of the loop.
2144 */
2145 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2146 cl->cl_logical_drive_count = 0;
2147 return (ENXIO);
2148 }
2149 demdp++;
2150 demdpr++;
2151 }
2152
2153 /* Update the cl_map array for logical drives */
2154 for (count = 0; count < MAX_EXT_PARTS; count++) {
2155 cl->cl_map[FDISK_P4 + 1 + count].dkl_cylno = UINT32_MAX;
2156 cl->cl_map[FDISK_P4 + 1 + count].dkl_nblk =
2157 cl->cl_fmap[FD_NUMPART + count].fmap_nblk;
2158 cl->cl_offset[FDISK_P4 + 1 + count] =
2159 cl->cl_fmap[FD_NUMPART + count].fmap_start;
2160 }
2161
2162 cl->cl_logical_drive_count = i;
2163 cl->cl_update_ext_minor_nodes = 0;
2164 return (0);
2165 }
2166 /*
2167 * Function: cmlb_validate_ext_part
2168 *
2169 * Description: utility routine to validate an extended partition's
2170 * metadata as found on disk
2171 *
2172 * Arguments:
2173 * cl driver soft state (unit) structure
2174 * part partition number of the extended partition
2175 * epart partition number of the logical drive
2176 * start absolute sector number of the start of the logical
2177 * drive being validated
2178 * size size of logical drive being validated
2179 *
2180 * Return Code: 0 for success
2181 *
2182 * Context: User and Kernel thread
2183 *
2184 * Algorithm :
2185 * Error cases are :
2186 * 1. If start block is lesser than or equal to the end block
2187 * 2. If either start block or end block is beyond the bounadry
2188 * of the extended partition.
2189 * 3. start or end block overlap with existing partitions.
2190 * To check this, first make sure that the start block doesnt
2191 * overlap with existing partitions. Then, calculate the
2192 * possible end block for the given start block that doesnt
2193 * overlap with existing partitions. This can be calculated by
2194 * first setting the possible end block to the end of the
2195 * extended partition (optimistic) and then, checking if there
2196 * is any other partition that lies after the start of the
2197 * partition being validated. If so, set the possible end to
2198 * one block less than the beginning of the next nearest partition
2199 * If the actual end block is greater than the calculated end
2200 * block, we have an overlap.
2201 *
2202 */
2203 static int
2204 cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start,
2205 uint32_t size)
2206 {
2207 int i;
2208 uint32_t end = start + size - 1;
2209 uint32_t ext_start = cl->cl_fmap[part].fmap_start;
2210 uint32_t ext_end = ext_start + cl->cl_fmap[part].fmap_nblk - 1;
2211 uint32_t ts, te;
2212 uint32_t poss_end = ext_end;
2213
2214 if (end <= start) {
2215 return (1);
2216 }
2217
2218 /*
2219 * Check if the logical drive boundaries are within that of the
2220 * extended partition.
2221 */
2222 if (start <= ext_start || start > ext_end || end <= ext_start ||
2223 end > ext_end) {
2224 return (1);
2225 }
2226
2227 /*
2228 * epart will be equal to FD_NUMPART if it is the first logical drive.
2229 * There is no need to check for overlaps with other logical drives,
2230 * since it is the only logical drive that we have come across so far.
2231 */
2232 if (epart == FD_NUMPART) {
2233 return (0);
2234 }
2235
2236 /* Check for overlaps with existing logical drives */
2237 i = FD_NUMPART;
2238 ts = cl->cl_fmap[FD_NUMPART].fmap_start;
2239 te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1;
2240
2241 while ((i < epart) && ts && te) {
2242 if (start >= ts && start <= te) {
2243 return (1);
2244 }
2245
2246 if ((ts < poss_end) && (ts > start)) {
2247 poss_end = ts - 1;
2248 }
2249
2250 i++;
2251 ts = cl->cl_fmap[i].fmap_start;
2252 te = ts + cl->cl_fmap[i].fmap_nblk - 1;
2253 }
2254
2255 if (end > poss_end) {
2256 return (1);
2257 }
2258
2259 return (0);
2260 }
2261
2262
2263 /*
2264 * Function: cmlb_is_linux_swap
2265 *
2266 * Description: utility routine to verify if a partition is a linux swap
2267 * partition or not.
2268 *
2269 * Arguments:
2270 * cl driver soft state (unit) structure
2271 * part_start absolute sector number of the start of the partition
2272 * being verified
2273 * tg_cookie cookie from target driver to be passed back to target
2274 * driver when we call back to it through tg_ops.
2275 *
2276 * Return Code: 0 for success
2277 *
2278 * Context: User and Kernel thread
2279 *
2280 * Notes:
2281 * The linux swap magic "SWAP-SPACE" or "SWAPSPACE2" is found as the
2282 * last 10 bytes of a disk block whose size is that of the linux page
2283 * size. This disk block is found at the beginning of the swap partition.
2284 */
2285 static int
2286 cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie)
2287 {
2288 int i;
2289 int rval = -1;
2290 uint32_t seek_offset;
2291 uint32_t linux_pg_size;
2292 char *buf, *linux_swap_magic;
2293 int sec_sz = cl->cl_sys_blocksize;
2294 /* Known linux kernel page sizes */
2295 uint32_t linux_pg_size_arr[] = {4096, };
2296
2297 ASSERT(cl != NULL);
2298 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2299
2300 if ((buf = kmem_zalloc(sec_sz, KM_NOSLEEP)) == NULL) {
2301 return (ENOMEM);
2302 }
2303
2304 /*
2305 * Check if there is a sane Solaris VTOC
2306 * If there is a valid vtoc, no need to lookup
2307 * for the linux swap signature.
2308 */
2309 mutex_exit(CMLB_MUTEX(cl));
2310 rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC,
2311 sec_sz, tg_cookie);
2312 mutex_enter(CMLB_MUTEX(cl));
2313 if (rval != 0) {
2314 cmlb_dbg(CMLB_ERROR, cl,
2315 "cmlb_is_linux_swap: disk vtoc read err\n");
2316 rval = EIO;
2317 goto done;
2318 }
2319
2320 if ((((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) &&
2321 (((struct dk_label *)buf)->dkl_vtoc.v_sanity == VTOC_SANE)) {
2322 rval = -1;
2323 goto done;
2324 }
2325
2326
2327 /* No valid vtoc, so check for linux swap signature */
2328 linux_swap_magic = buf + sec_sz - 10;
2329
2330 for (i = 0; i < sizeof (linux_pg_size_arr)/sizeof (uint32_t); i++) {
2331 linux_pg_size = linux_pg_size_arr[i];
2332 seek_offset = linux_pg_size/sec_sz - 1;
2333 seek_offset += part_start;
2334
2335 mutex_exit(CMLB_MUTEX(cl));
2336 rval = DK_TG_READ(cl, buf, seek_offset, sec_sz, tg_cookie);
2337 mutex_enter(CMLB_MUTEX(cl));
2338
2339 if (rval != 0) {
2340 cmlb_dbg(CMLB_ERROR, cl,
2341 "cmlb_is_linux_swap: disk read err\n");
2342 rval = EIO;
2343 break;
2344 }
2345
2346 rval = -1;
2347
2348 if ((strncmp(linux_swap_magic, "SWAP-SPACE", 10) == 0) ||
2349 (strncmp(linux_swap_magic, "SWAPSPACE2", 10) == 0)) {
2350 /* Found a linux swap */
2351 rval = 0;
2352 break;
2353 }
2354 }
2355
2356 done:
2357 kmem_free(buf, sec_sz);
2358 return (rval);
2359 }
2360 #endif
2361
2362 /*
2363 * Function: cmlb_read_fdisk
2364 *
2365 * Description: utility routine to read the fdisk table.
2366 *
2367 * Arguments:
2368 * cl driver soft state (unit) structure
2369 * capacity disk capacity in #blocks
2370 * tg_cookie cookie from target driver to be passed back to target
2371 * driver when we call back to it through tg_ops.
2372 *
2373 * Return Code: 0 for success (includes not reading for no_fdisk_present case
2374 * errnos from tg_rw if failed to read the first block.
2375 *
2376 * Context: Kernel thread only (can sleep).
2377 */
2378 /*ARGSUSED*/
2379 static int
2380 cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie)
2381 {
2382 #if defined(_NO_FDISK_PRESENT)
2383
2384 cl->cl_solaris_offset = 0;
2385 cl->cl_solaris_size = capacity;
2386 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2387 return (0);
2388
2389 #elif defined(_FIRMWARE_NEEDS_FDISK)
2390
2391 struct ipart *fdp;
2392 struct mboot *mbp;
2393 struct ipart fdisk[FD_NUMPART];
2394 int i, k;
2395 char sigbuf[2];
2396 caddr_t bufp;
2397 int uidx;
2398 int rval;
2399 int lba = 0;
2400 uint_t solaris_offset; /* offset to solaris part. */
2401 daddr_t solaris_size; /* size of solaris partition */
2402 uint32_t blocksize;
2403 #if defined(__i386) || defined(__amd64)
2404 struct ipart eparts[2];
2405 struct ipart *efdp1 = &eparts[0];
2406 struct ipart *efdp2 = &eparts[1];
2407 int ext_part_exists = 0;
2408 int ld_count = 0;
2409 #endif
2410
2411 ASSERT(cl != NULL);
2412 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2413
2414 /*
2415 * Start off assuming no fdisk table
2416 */
2417 solaris_offset = 0;
2418 solaris_size = capacity;
2419
2420 blocksize = cl->cl_tgt_blocksize;
2421
2422 bufp = kmem_zalloc(blocksize, KM_SLEEP);
2423
2424 mutex_exit(CMLB_MUTEX(cl));
2425 rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
2426 mutex_enter(CMLB_MUTEX(cl));
2427
2428 if (rval != 0) {
2429 cmlb_dbg(CMLB_ERROR, cl,
2430 "cmlb_read_fdisk: fdisk read err\n");
2431 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2432 goto done;
2433 }
2434
2435 mbp = (struct mboot *)bufp;
2436
2437 /*
2438 * The fdisk table does not begin on a 4-byte boundary within the
2439 * master boot record, so we copy it to an aligned structure to avoid
2440 * alignment exceptions on some processors.
2441 */
2442 bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
2443
2444 /*
2445 * Check for lba support before verifying sig; sig might not be
2446 * there, say on a blank disk, but the max_chs mark may still
2447 * be present.
2448 *
2449 * Note: LBA support and BEFs are an x86-only concept but this
2450 * code should work OK on SPARC as well.
2451 */
2452
2453 /*
2454 * First, check for lba-access-ok on root node (or prom root node)
2455 * if present there, don't need to search fdisk table.
2456 */
2457 if (ddi_getprop(DDI_DEV_T_ANY, ddi_root_node(), 0,
2458 "lba-access-ok", 0) != 0) {
2459 /* All drives do LBA; don't search fdisk table */
2460 lba = 1;
2461 } else {
2462 /* Okay, look for mark in fdisk table */
2463 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2464 /* accumulate "lba" value from all partitions */
2465 lba = (lba || cmlb_has_max_chs_vals(fdp));
2466 }
2467 }
2468
2469 if (lba != 0) {
2470 dev_t dev = cmlb_make_device(cl);
2471
2472 if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
2473 "lba-access-ok", 0) == 0) {
2474 /* not found; create it */
2475 if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
2476 "lba-access-ok", (caddr_t)NULL, 0) !=
2477 DDI_PROP_SUCCESS) {
2478 cmlb_dbg(CMLB_ERROR, cl,
2479 "cmlb_read_fdisk: Can't create lba "
2480 "property for instance %d\n",
2481 ddi_get_instance(CMLB_DEVINFO(cl)));
2482 }
2483 }
2484 }
2485
2486 bcopy(&mbp->signature, sigbuf, sizeof (sigbuf));
2487
2488 /*
2489 * Endian-independent signature check
2490 */
2491 if (((sigbuf[1] & 0xFF) != ((MBB_MAGIC >> 8) & 0xFF)) ||
2492 (sigbuf[0] != (MBB_MAGIC & 0xFF))) {
2493 cmlb_dbg(CMLB_ERROR, cl,
2494 "cmlb_read_fdisk: no fdisk\n");
2495 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2496 goto done;
2497 }
2498
2499 #ifdef CMLBDEBUG
2500 if (cmlb_level_mask & CMLB_LOGMASK_INFO) {
2501 fdp = fdisk;
2502 cmlb_dbg(CMLB_INFO, cl, "cmlb_read_fdisk:\n");
2503 cmlb_dbg(CMLB_INFO, cl, " relsect "
2504 "numsect sysid bootid\n");
2505 for (i = 0; i < FD_NUMPART; i++, fdp++) {
2506 cmlb_dbg(CMLB_INFO, cl,
2507 " %d: %8d %8d 0x%08x 0x%08x\n",
2508 i, fdp->relsect, fdp->numsect,
2509 fdp->systid, fdp->bootid);
2510 }
2511 }
2512 #endif
2513
2514 /*
2515 * Try to find the unix partition
2516 */
2517 uidx = -1;
2518 solaris_offset = 0;
2519 solaris_size = 0;
2520
2521 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2522 uint32_t relsect;
2523 uint32_t numsect;
2524 uchar_t systid;
2525 #if defined(__i386) || defined(__amd64)
2526 /*
2527 * Stores relative block offset from the beginning of the
2528 * Extended Partition.
2529 */
2530 int ext_relsect = 0;
2531 #endif
2532
2533 if (fdp->numsect == 0) {
2534 cl->cl_fmap[i].fmap_start = 0;
2535 cl->cl_fmap[i].fmap_nblk = 0;
2536 continue;
2537 }
2538
2539 /*
2540 * Data in the fdisk table is little-endian.
2541 */
2542 relsect = LE_32(fdp->relsect);
2543 numsect = LE_32(fdp->numsect);
2544
2545 cl->cl_fmap[i].fmap_start = relsect;
2546 cl->cl_fmap[i].fmap_nblk = numsect;
2547 cl->cl_fmap[i].fmap_systid = LE_8(fdp->systid);
2548
2549 #if defined(__i386) || defined(__amd64)
2550 /* Support only one extended partition per LUN */
2551 if ((fdp->systid == EXTDOS || fdp->systid == FDISK_EXTLBA) &&
2552 (ext_part_exists == 0)) {
2553 int j;
2554 uint32_t logdrive_offset;
2555 uint32_t ext_numsect;
2556 uint32_t abs_secnum;
2557
2558 ext_part_exists = 1;
2559
2560 for (j = FD_NUMPART; j < FDISK_PARTS; j++) {
2561 mutex_exit(CMLB_MUTEX(cl));
2562 rval = DK_TG_READ(cl, bufp,
2563 (relsect + ext_relsect), blocksize,
2564 tg_cookie);
2565 mutex_enter(CMLB_MUTEX(cl));
2566
2567 if (rval != 0) {
2568 cmlb_dbg(CMLB_ERROR, cl,
2569 "cmlb_read_fdisk: Extended "
2570 "partition read err\n");
2571 goto done;
2572 }
2573 /*
2574 * The first ipart entry provides the offset
2575 * at which the logical drive starts off from
2576 * the beginning of the container partition
2577 * and the size of the logical drive.
2578 * The second ipart entry provides the offset
2579 * of the next container partition from the
2580 * beginning of the extended partition.
2581 */
2582 bcopy(&bufp[FDISK_PART_TABLE_START], eparts,
2583 sizeof (eparts));
2584 logdrive_offset = LE_32(efdp1->relsect);
2585 ext_numsect = LE_32(efdp1->numsect);
2586 systid = LE_8(efdp1->systid);
2587 if (logdrive_offset <= 0 || ext_numsect <= 0)
2588 break;
2589 abs_secnum = relsect + ext_relsect +
2590 logdrive_offset;
2591
2592 /* Boundary condition and overlap checking */
2593 if (cmlb_validate_ext_part(cl, i, j, abs_secnum,
2594 ext_numsect)) {
2595 break;
2596 }
2597
2598 if ((cl->cl_fmap[j].fmap_start != abs_secnum) ||
2599 (cl->cl_fmap[j].fmap_nblk != ext_numsect) ||
2600 (cl->cl_fmap[j].fmap_systid != systid)) {
2601 /*
2602 * Indicates change from previous
2603 * partinfo. Need to recreate
2604 * logical device nodes.
2605 */
2606 cl->cl_update_ext_minor_nodes = 1;
2607 }
2608 cl->cl_fmap[j].fmap_start = abs_secnum;
2609 cl->cl_fmap[j].fmap_nblk = ext_numsect;
2610 cl->cl_fmap[j].fmap_systid = systid;
2611 ld_count++;
2612
2613 if ((efdp1->systid == SUNIXOS &&
2614 (cmlb_is_linux_swap(cl, abs_secnum,
2615 tg_cookie) != 0)) ||
2616 efdp1->systid == SUNIXOS2) {
2617 if (uidx == -1) {
2618 uidx = 0;
2619 solaris_offset = abs_secnum;
2620 solaris_size = ext_numsect;
2621 }
2622 }
2623
2624 if ((ext_relsect = LE_32(efdp2->relsect)) == 0)
2625 break;
2626 }
2627 }
2628
2629 #endif
2630
2631 if (fdp->systid != SUNIXOS &&
2632 fdp->systid != SUNIXOS2 &&
2633 fdp->systid != EFI_PMBR) {
2634 continue;
2635 }
2636
2637 /*
2638 * use the last active solaris partition id found
2639 * (there should only be 1 active partition id)
2640 *
2641 * if there are no active solaris partition id
2642 * then use the first inactive solaris partition id
2643 */
2644 if ((uidx == -1) || (fdp->bootid == ACTIVE)) {
2645 #if defined(__i386) || defined(__amd64)
2646 if (fdp->systid != SUNIXOS ||
2647 (fdp->systid == SUNIXOS &&
2648 (cmlb_is_linux_swap(cl, relsect,
2649 tg_cookie) != 0))) {
2650 #endif
2651 uidx = i;
2652 solaris_offset = relsect;
2653 solaris_size = numsect;
2654 #if defined(__i386) || defined(__amd64)
2655 }
2656 #endif
2657 }
2658 }
2659 #if defined(__i386) || defined(__amd64)
2660 if (ld_count < cl->cl_logical_drive_count) {
2661 /*
2662 * Some/all logical drives were deleted. Clear out
2663 * the fmap entries correspoding to those deleted drives.
2664 */
2665 for (k = ld_count + FD_NUMPART;
2666 k < cl->cl_logical_drive_count + FD_NUMPART; k++) {
2667 cl->cl_fmap[k].fmap_start = 0;
2668 cl->cl_fmap[k].fmap_nblk = 0;
2669 cl->cl_fmap[k].fmap_systid = 0;
2670 }
2671 cl->cl_update_ext_minor_nodes = 1;
2672 }
2673 if (cl->cl_update_ext_minor_nodes) {
2674 rval = cmlb_update_ext_minor_nodes(cl, ld_count);
2675 if (rval != 0) {
2676 goto done;
2677 }
2678 }
2679 #endif
2680 cmlb_dbg(CMLB_INFO, cl, "fdisk 0x%x 0x%lx",
2681 cl->cl_solaris_offset, cl->cl_solaris_size);
2682 done:
2683
2684 /*
2685 * Clear the VTOC info, only if the Solaris partition entry
2686 * has moved, changed size, been deleted, or if the size of
2687 * the partition is too small to even fit the label sector.
2688 */
2689 if ((cl->cl_solaris_offset != solaris_offset) ||
2690 (cl->cl_solaris_size != solaris_size) ||
2691 solaris_size <= DK_LABEL_LOC) {
2692 cmlb_dbg(CMLB_INFO, cl, "fdisk moved 0x%x 0x%lx",
2693 solaris_offset, solaris_size);
2694 bzero(&cl->cl_g, sizeof (struct dk_geom));
2695 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2696 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
2697 cl->cl_f_geometry_is_valid = B_FALSE;
2698 }
2699 cl->cl_solaris_offset = solaris_offset;
2700 cl->cl_solaris_size = solaris_size;
2701 kmem_free(bufp, blocksize);
2702 return (rval);
2703
2704 #else /* #elif defined(_FIRMWARE_NEEDS_FDISK) */
2705 #error "fdisk table presence undetermined for this platform."
2706 #endif /* #if defined(_NO_FDISK_PRESENT) */
2707 }
2708
2709 static void
2710 cmlb_swap_efi_gpt(efi_gpt_t *e)
2711 {
2712 _NOTE(ASSUMING_PROTECTED(*e))
2713 e->efi_gpt_Signature = LE_64(e->efi_gpt_Signature);
2714 e->efi_gpt_Revision = LE_32(e->efi_gpt_Revision);
2715 e->efi_gpt_HeaderSize = LE_32(e->efi_gpt_HeaderSize);
2716 e->efi_gpt_HeaderCRC32 = LE_32(e->efi_gpt_HeaderCRC32);
2717 e->efi_gpt_MyLBA = LE_64(e->efi_gpt_MyLBA);
2718 e->efi_gpt_AlternateLBA = LE_64(e->efi_gpt_AlternateLBA);
2719 e->efi_gpt_FirstUsableLBA = LE_64(e->efi_gpt_FirstUsableLBA);
2720 e->efi_gpt_LastUsableLBA = LE_64(e->efi_gpt_LastUsableLBA);
2721 UUID_LE_CONVERT(e->efi_gpt_DiskGUID, e->efi_gpt_DiskGUID);
2722 e->efi_gpt_PartitionEntryLBA = LE_64(e->efi_gpt_PartitionEntryLBA);
2723 e->efi_gpt_NumberOfPartitionEntries =
2724 LE_32(e->efi_gpt_NumberOfPartitionEntries);
2725 e->efi_gpt_SizeOfPartitionEntry =
2726 LE_32(e->efi_gpt_SizeOfPartitionEntry);
2727 e->efi_gpt_PartitionEntryArrayCRC32 =
2728 LE_32(e->efi_gpt_PartitionEntryArrayCRC32);
2729 }
2730
2731 static void
2732 cmlb_swap_efi_gpe(int nparts, efi_gpe_t *p)
2733 {
2734 int i;
2735
2736 _NOTE(ASSUMING_PROTECTED(*p))
2737 for (i = 0; i < nparts; i++) {
2738 UUID_LE_CONVERT(p[i].efi_gpe_PartitionTypeGUID,
2739 p[i].efi_gpe_PartitionTypeGUID);
2740 p[i].efi_gpe_StartingLBA = LE_64(p[i].efi_gpe_StartingLBA);
2741 p[i].efi_gpe_EndingLBA = LE_64(p[i].efi_gpe_EndingLBA);
2742 /* PartitionAttrs */
2743 }
2744 }
2745
2746 static int
2747 cmlb_validate_efi(efi_gpt_t *labp)
2748 {
2749 if (labp->efi_gpt_Signature != EFI_SIGNATURE)
2750 return (EINVAL);
2751 /* at least 92 bytes in this version of the spec. */
2752 if (sizeof (efi_gpt_t) - sizeof (labp->efi_gpt_Reserved2) >
2753 labp->efi_gpt_HeaderSize)
2754 return (EINVAL);
2755 /* this should be 128 bytes */
2756 if (labp->efi_gpt_SizeOfPartitionEntry != sizeof (efi_gpe_t))
2757 return (EINVAL);
2758 return (0);
2759 }
2760
2761 /*
2762 * This function returns B_FALSE if there is a valid MBR signature and no
2763 * partition table entries of type EFI_PMBR (0xEE). Otherwise it returns B_TRUE.
2764 *
2765 * The EFI spec (1.10 and later) requires having a Protective MBR (PMBR) to
2766 * recognize the disk as GPT partitioned. However, some other OS creates an MBR
2767 * where a PMBR entry is not the only one. Also, if the first block has been
2768 * corrupted, currently best attempt to allow data access would be to try to
2769 * check for GPT headers. Hence in case of more than one partition entry, but
2770 * at least one EFI_PMBR partition type or no valid magic number, the function
2771 * returns B_TRUE to continue with looking for GPT header.
2772 */
2773
2774 static boolean_t
2775 cmlb_check_efi_mbr(uchar_t *buf, boolean_t *is_mbr)
2776 {
2777 struct ipart *fdp;
2778 struct mboot *mbp = (struct mboot *)buf;
2779 struct ipart fdisk[FD_NUMPART];
2780 int i;
2781
2782 if (is_mbr != NULL)
2783 *is_mbr = B_TRUE;
2784
2785 if (LE_16(mbp->signature) != MBB_MAGIC) {
2786 if (is_mbr != NULL)
2787 *is_mbr = B_FALSE;
2788 return (B_TRUE);
2789 }
2790
2791 bcopy(&mbp->parts[0], fdisk, sizeof (fdisk));
2792
2793 for (fdp = fdisk, i = 0; i < FD_NUMPART; i++, fdp++) {
2794 if (fdp->systid == EFI_PMBR)
2795 return (B_TRUE);
2796 }
2797
2798 return (B_FALSE);
2799 }
2800
2801 static int
2802 cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
2803 void *tg_cookie)
2804 {
2805 int i;
2806 int rval = 0;
2807 efi_gpe_t *partitions;
2808 uchar_t *buf;
2809 uint_t lbasize; /* is really how much to read */
2810 diskaddr_t cap = 0;
2811 uint_t nparts;
2812 diskaddr_t gpe_lba;
2813 diskaddr_t alternate_lba;
2814 int iofailed = 0;
2815 struct uuid uuid_type_reserved = EFI_RESERVED;
2816 #if defined(_FIRMWARE_NEEDS_FDISK)
2817 boolean_t is_mbr;
2818 #endif
2819
2820 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2821
2822 lbasize = cl->cl_sys_blocksize;
2823
2824 cl->cl_reserved = -1;
2825 mutex_exit(CMLB_MUTEX(cl));
2826
2827 buf = kmem_zalloc(EFI_MIN_ARRAY_SIZE, KM_SLEEP);
2828
2829 rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie);
2830 if (rval) {
2831 iofailed = 1;
2832 goto done_err;
2833 }
2834 if (((struct dk_label *)buf)->dkl_magic == DKL_MAGIC) {
2835 /* not ours */
2836 rval = ESRCH;
2837 goto done_err;
2838 }
2839
2840 #if defined(_FIRMWARE_NEEDS_FDISK)
2841 if (!cmlb_check_efi_mbr(buf, &is_mbr)) {
2842 if (is_mbr)
2843 rval = ESRCH;
2844 else
2845 rval = EINVAL;
2846 goto done_err;
2847 }
2848 #else
2849 if (!cmlb_check_efi_mbr(buf, NULL)) {
2850 rval = EINVAL;
2851 goto done_err;
2852 }
2853
2854 #endif
2855
2856 rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
2857 if (rval) {
2858 iofailed = 1;
2859 goto done_err;
2860 }
2861 cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2862
2863 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
2864 /*
2865 * Couldn't read the primary, try the backup. Our
2866 * capacity at this point could be based on CHS, so
2867 * check what the device reports.
2868 */
2869 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
2870 if (rval) {
2871 iofailed = 1;
2872 goto done_err;
2873 }
2874
2875 /*
2876 * CMLB_OFF_BY_ONE case, we check the next to last block first
2877 * for backup GPT header, otherwise check the last block.
2878 */
2879
2880 if ((rval = DK_TG_READ(cl, buf,
2881 cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2882 lbasize, tg_cookie))
2883 != 0) {
2884 iofailed = 1;
2885 goto done_err;
2886 }
2887 cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2888
2889 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0) {
2890
2891 if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2892 goto done_err;
2893 if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2894 tg_cookie)) != 0)
2895 goto done_err;
2896 cmlb_swap_efi_gpt((efi_gpt_t *)buf);
2897 if ((rval = cmlb_validate_efi((efi_gpt_t *)buf)) != 0)
2898 goto done_err;
2899 }
2900 if (!(flags & CMLB_SILENT))
2901 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2902 "primary label corrupt; using backup\n");
2903 }
2904
2905 nparts = ((efi_gpt_t *)buf)->efi_gpt_NumberOfPartitionEntries;
2906 gpe_lba = ((efi_gpt_t *)buf)->efi_gpt_PartitionEntryLBA;
2907 alternate_lba = ((efi_gpt_t *)buf)->efi_gpt_AlternateLBA;
2908
2909 rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
2910 if (rval) {
2911 iofailed = 1;
2912 goto done_err;
2913 }
2914 partitions = (efi_gpe_t *)buf;
2915
2916 if (nparts > MAXPART) {
2917 nparts = MAXPART;
2918 }
2919 cmlb_swap_efi_gpe(nparts, partitions);
2920
2921 mutex_enter(CMLB_MUTEX(cl));
2922
2923 /* Fill in partition table. */
2924 for (i = 0; i < nparts; i++) {
2925 if (partitions->efi_gpe_StartingLBA != 0 ||
2926 partitions->efi_gpe_EndingLBA != 0) {
2927 cl->cl_map[i].dkl_cylno =
2928 partitions->efi_gpe_StartingLBA;
2929 cl->cl_map[i].dkl_nblk =
2930 partitions->efi_gpe_EndingLBA -
2931 partitions->efi_gpe_StartingLBA + 1;
2932 cl->cl_offset[i] =
2933 partitions->efi_gpe_StartingLBA;
2934 }
2935
2936 if (cl->cl_reserved == -1) {
2937 if (bcmp(&partitions->efi_gpe_PartitionTypeGUID,
2938 &uuid_type_reserved, sizeof (struct uuid)) == 0) {
2939 cl->cl_reserved = i;
2940 }
2941 }
2942 if (i == WD_NODE) {
2943 /*
2944 * minor number 7 corresponds to the whole disk
2945 * if the disk capacity is expanded after disk is
2946 * labeled, minor number 7 represents the capacity
2947 * indicated by the disk label.
2948 */
2949 cl->cl_map[i].dkl_cylno = 0;
2950 if (alternate_lba == 1) {
2951 /*
2952 * We are using backup label. Since we can
2953 * find a valid label at the end of disk,
2954 * the disk capacity is not expanded.
2955 */
2956 cl->cl_map[i].dkl_nblk = capacity;
2957 } else {
2958 cl->cl_map[i].dkl_nblk = alternate_lba + 1;
2959 }
2960 cl->cl_offset[i] = 0;
2961 }
2962 partitions++;
2963 }
2964 cl->cl_solaris_offset = 0;
2965 cl->cl_solaris_size = capacity;
2966 cl->cl_label_from_media = CMLB_LABEL_EFI;
2967 cl->cl_f_geometry_is_valid = B_TRUE;
2968
2969 /* clear the vtoc label */
2970 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2971
2972 kmem_free(buf, EFI_MIN_ARRAY_SIZE);
2973 return (0);
2974
2975 done_err:
2976 kmem_free(buf, EFI_MIN_ARRAY_SIZE);
2977 mutex_enter(CMLB_MUTEX(cl));
2978 done_err1:
2979 /*
2980 * if we didn't find something that could look like a VTOC
2981 * and the disk is over 1TB, we know there isn't a valid label.
2982 * Otherwise let cmlb_uselabel decide what to do. We only
2983 * want to invalidate this if we're certain the label isn't
2984 * valid because cmlb_prop_op will now fail, which in turn
2985 * causes things like opens and stats on the partition to fail.
2986 */
2987 if ((capacity > CMLB_EXTVTOC_LIMIT) && (rval != ESRCH) && !iofailed) {
2988 cl->cl_f_geometry_is_valid = B_FALSE;
2989 }
2990 return (rval);
2991 }
2992
2993
2994 /*
2995 * Function: cmlb_uselabel
2996 *
2997 * Description: Validate the disk label and update the relevant data (geometry,
2998 * partition, vtoc, and capacity data) in the cmlb_lun struct.
2999 * Marks the geometry of the unit as being valid.
3000 *
3001 * Arguments: cl: unit struct.
3002 * dk_label: disk label
3003 *
3004 * Return Code: CMLB_LABEL_IS_VALID: Label read from disk is OK; geometry,
3005 * partition, vtoc, and capacity data are good.
3006 *
3007 * CMLB_LABEL_IS_INVALID: Magic number or checksum error in the
3008 * label; or computed capacity does not jibe with capacity
3009 * reported from the READ CAPACITY command.
3010 *
3011 * Context: Kernel thread only (can sleep).
3012 */
3013 static int
3014 cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags)
3015 {
3016 short *sp;
3017 short sum;
3018 short count;
3019 int label_error = CMLB_LABEL_IS_VALID;
3020 int i;
3021 diskaddr_t label_capacity;
3022 uint32_t part_end;
3023 diskaddr_t track_capacity;
3024 #if defined(_SUNOS_VTOC_16)
3025 struct dkl_partition *vpartp;
3026 #endif
3027 ASSERT(cl != NULL);
3028 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3029
3030 /* Validate the magic number of the label. */
3031 if (labp->dkl_magic != DKL_MAGIC) {
3032 #if defined(__sparc)
3033 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3034 if (!(flags & CMLB_SILENT))
3035 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3036 CE_WARN,
3037 "Corrupt label; wrong magic number\n");
3038 }
3039 #endif
3040 return (CMLB_LABEL_IS_INVALID);
3041 }
3042
3043 /* Validate the checksum of the label. */
3044 sp = (short *)labp;
3045 sum = 0;
3046 count = sizeof (struct dk_label) / sizeof (short);
3047 while (count--) {
3048 sum ^= *sp++;
3049 }
3050
3051 if (sum != 0) {
3052 #if defined(_SUNOS_VTOC_16)
3053 if (!ISCD(cl)) {
3054 #elif defined(_SUNOS_VTOC_8)
3055 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3056 #endif
3057 if (!(flags & CMLB_SILENT))
3058 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3059 CE_WARN,
3060 "Corrupt label - label checksum failed\n");
3061 }
3062 return (CMLB_LABEL_IS_INVALID);
3063 }
3064
3065
3066 /*
3067 * Fill in geometry structure with data from label.
3068 */
3069 bzero(&cl->cl_g, sizeof (struct dk_geom));
3070 cl->cl_g.dkg_ncyl = labp->dkl_ncyl;
3071 cl->cl_g.dkg_acyl = labp->dkl_acyl;
3072 cl->cl_g.dkg_bcyl = 0;
3073 cl->cl_g.dkg_nhead = labp->dkl_nhead;
3074 cl->cl_g.dkg_nsect = labp->dkl_nsect;
3075 cl->cl_g.dkg_intrlv = labp->dkl_intrlv;
3076
3077 #if defined(_SUNOS_VTOC_8)
3078 cl->cl_g.dkg_gap1 = labp->dkl_gap1;
3079 cl->cl_g.dkg_gap2 = labp->dkl_gap2;
3080 cl->cl_g.dkg_bhead = labp->dkl_bhead;
3081 #endif
3082 #if defined(_SUNOS_VTOC_16)
3083 cl->cl_dkg_skew = labp->dkl_skew;
3084 #endif
3085
3086 #if defined(__i386) || defined(__amd64)
3087 cl->cl_g.dkg_apc = labp->dkl_apc;
3088 #endif
3089
3090 /*
3091 * Currently we rely on the values in the label being accurate. If
3092 * dkl_rpm or dkl_pcly are zero in the label, use a default value.
3093 *
3094 * Note: In the future a MODE SENSE may be used to retrieve this data,
3095 * although this command is optional in SCSI-2.
3096 */
3097 cl->cl_g.dkg_rpm = (labp->dkl_rpm != 0) ? labp->dkl_rpm : 3600;
3098 cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
3099 (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);
3100
3101 /*
3102 * The Read and Write reinstruct values may not be valid
3103 * for older disks.
3104 */
3105 cl->cl_g.dkg_read_reinstruct = labp->dkl_read_reinstruct;
3106 cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
3107
3108 /* Fill in partition table. */
3109 #if defined(_SUNOS_VTOC_8)
3110 for (i = 0; i < NDKMAP; i++) {
3111 cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
3112 cl->cl_map[i].dkl_nblk = labp->dkl_map[i].dkl_nblk;
3113 }
3114 #endif
3115 #if defined(_SUNOS_VTOC_16)
3116 vpartp = labp->dkl_vtoc.v_part;
3117 track_capacity = labp->dkl_nhead * labp->dkl_nsect;
3118
3119 /* Prevent divide by zero */
3120 if (track_capacity == 0) {
3121 if (!(flags & CMLB_SILENT))
3122 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3123 "Corrupt label - zero nhead or nsect value\n");
3124
3125 return (CMLB_LABEL_IS_INVALID);
3126 }
3127
3128 for (i = 0; i < NDKMAP; i++, vpartp++) {
3129 cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
3130 cl->cl_map[i].dkl_nblk = vpartp->p_size;
3131 }
3132 #endif
3133
3134 /* Fill in VTOC Structure. */
3135 bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
3136 #if defined(_SUNOS_VTOC_8)
3137 /*
3138 * The 8-slice vtoc does not include the ascii label; save it into
3139 * the device's soft state structure here.
3140 */
3141 bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
3142 #endif
3143
3144 /* Now look for a valid capacity. */
3145 track_capacity = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
3146 label_capacity = (cl->cl_g.dkg_ncyl * track_capacity);
3147
3148 if (cl->cl_g.dkg_acyl) {
3149 #if defined(__i386) || defined(__amd64)
3150 /* we may have > 1 alts cylinder */
3151 label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
3152 #else
3153 label_capacity += track_capacity;
3154 #endif
3155 }
3156
3157 /*
3158 * Force check here to ensure the computed capacity is valid.
3159 * If capacity is zero, it indicates an invalid label and
3160 * we should abort updating the relevant data then.
3161 */
3162 if (label_capacity == 0) {
3163 if (!(flags & CMLB_SILENT))
3164 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3165 "Corrupt label - no valid capacity could be "
3166 "retrieved\n");
3167
3168 return (CMLB_LABEL_IS_INVALID);
3169 }
3170
3171 /* Mark the geometry as valid. */
3172 cl->cl_f_geometry_is_valid = B_TRUE;
3173
3174 /*
3175 * if we got invalidated when mutex exit and entered again,
3176 * if blockcount different than when we came in, need to
3177 * retry from beginning of cmlb_validate_geometry.
3178 * revisit this on next phase of utilizing this for
3179 * sd.
3180 */
3181
3182 if (label_capacity <= cl->cl_blockcount) {
3183 #if defined(_SUNOS_VTOC_8)
3184 /*
3185 * We can't let this happen on drives that are subdivided
3186 * into logical disks (i.e., that have an fdisk table).
3187 * The cl_blockcount field should always hold the full media
3188 * size in sectors, period. This code would overwrite
3189 * cl_blockcount with the size of the Solaris fdisk partition.
3190 */
3191 cmlb_dbg(CMLB_ERROR, cl,
3192 "cmlb_uselabel: Label %d blocks; Drive %d blocks\n",
3193 label_capacity, cl->cl_blockcount);
3194 cl->cl_solaris_size = label_capacity;
3195
3196 #endif /* defined(_SUNOS_VTOC_8) */
3197 goto done;
3198 }
3199
3200 if (ISCD(cl)) {
3201 /* For CDROMs, we trust that the data in the label is OK. */
3202 #if defined(_SUNOS_VTOC_8)
3203 for (i = 0; i < NDKMAP; i++) {
3204 part_end = labp->dkl_nhead * labp->dkl_nsect *
3205 labp->dkl_map[i].dkl_cylno +
3206 labp->dkl_map[i].dkl_nblk - 1;
3207
3208 if ((labp->dkl_map[i].dkl_nblk) &&
3209 (part_end > cl->cl_blockcount)) {
3210 cl->cl_f_geometry_is_valid = B_FALSE;
3211 break;
3212 }
3213 }
3214 #endif
3215 #if defined(_SUNOS_VTOC_16)
3216 vpartp = &(labp->dkl_vtoc.v_part[0]);
3217 for (i = 0; i < NDKMAP; i++, vpartp++) {
3218 part_end = vpartp->p_start + vpartp->p_size;
3219 if ((vpartp->p_size > 0) &&
3220 (part_end > cl->cl_blockcount)) {
3221 cl->cl_f_geometry_is_valid = B_FALSE;
3222 break;
3223 }
3224 }
3225 #endif
3226 } else {
3227 /* label_capacity > cl->cl_blockcount */
3228 if (!(flags & CMLB_SILENT)) {
3229 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3230 "Corrupt label - bad geometry\n");
3231 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
3232 "Label says %llu blocks; Drive says %llu blocks\n",
3233 label_capacity, cl->cl_blockcount);
3234 }
3235 cl->cl_f_geometry_is_valid = B_FALSE;
3236 label_error = CMLB_LABEL_IS_INVALID;
3237 }
3238
3239 done:
3240
3241 cmlb_dbg(CMLB_INFO, cl, "cmlb_uselabel: (label geometry)\n");
3242 cmlb_dbg(CMLB_INFO, cl,
3243 " ncyl: %d; acyl: %d; nhead: %d; nsect: %d\n",
3244 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3245 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
3246
3247 cmlb_dbg(CMLB_INFO, cl,
3248 " label_capacity: %d; intrlv: %d; rpm: %d\n",
3249 cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
3250 cmlb_dbg(CMLB_INFO, cl, " wrt_reinstr: %d; rd_reinstr: %d\n",
3251 cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);
3252
3253 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3254
3255 return (label_error);
3256 }
3257
3258
3259 /*
3260 * Function: cmlb_build_default_label
3261 *
3262 * Description: Generate a default label for those devices that do not have
3263 * one, e.g., new media, removable cartridges, etc..
3264 *
3265 * Context: Kernel thread only
3266 */
3267 /*ARGSUSED*/
3268 static void
3269 cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie)
3270 {
3271 #if defined(_SUNOS_VTOC_16)
3272 uint_t phys_spc;
3273 uint_t disksize;
3274 struct dk_geom cl_g;
3275 diskaddr_t capacity;
3276 #endif
3277
3278 ASSERT(cl != NULL);
3279 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3280
3281 #if defined(_SUNOS_VTOC_8)
3282 /*
3283 * Note: This is a legacy check for non-removable devices on VTOC_8
3284 * only. This may be a valid check for VTOC_16 as well.
3285 * Once we understand why there is this difference between SPARC and
3286 * x86 platform, we could remove this legacy check.
3287 */
3288 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3289 return;
3290 }
3291 #endif
3292
3293 bzero(&cl->cl_g, sizeof (struct dk_geom));
3294 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
3295 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
3296
3297 #if defined(_SUNOS_VTOC_8)
3298
3299 /*
3300 * It's a REMOVABLE media, therefore no label (on sparc, anyway).
3301 * But it is still necessary to set up various geometry information,
3302 * and we are doing this here.
3303 */
3304
3305 /*
3306 * For the rpm, we use the minimum for the disk. For the head, cyl,
3307 * and number of sector per track, if the capacity <= 1GB, head = 64,
3308 * sect = 32. else head = 255, sect 63 Note: the capacity should be
3309 * equal to C*H*S values. This will cause some truncation of size due
3310 * to round off errors. For CD-ROMs, this truncation can have adverse
3311 * side effects, so returning ncyl and nhead as 1. The nsect will
3312 * overflow for most of CD-ROMs as nsect is of type ushort. (4190569)
3313 */
3314 cl->cl_solaris_size = cl->cl_blockcount;
3315 if (ISCD(cl)) {
3316 tg_attribute_t tgattribute;
3317 int is_writable;
3318 /*
3319 * Preserve the old behavior for non-writable
3320 * medias. Since dkg_nsect is a ushort, it
3321 * will lose bits as cdroms have more than
3322 * 65536 sectors. So if we recalculate
3323 * capacity, it will become much shorter.
3324 * But the dkg_* information is not
3325 * used for CDROMs so it is OK. But for
3326 * Writable CDs we need this information
3327 * to be valid (for newfs say). So we
3328 * make nsect and nhead > 1 that way
3329 * nsect can still stay within ushort limit
3330 * without losing any bits.
3331 */
3332
3333 bzero(&tgattribute, sizeof (tg_attribute_t));
3334
3335 mutex_exit(CMLB_MUTEX(cl));
3336 is_writable =
3337 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
3338 tgattribute.media_is_writable : 1;
3339 mutex_enter(CMLB_MUTEX(cl));
3340
3341 if (is_writable) {
3342 cl->cl_g.dkg_nhead = 64;
3343 cl->cl_g.dkg_nsect = 32;
3344 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
3345 cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl *
3346 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
3347 } else {
3348 cl->cl_g.dkg_ncyl = 1;
3349 cl->cl_g.dkg_nhead = 1;
3350 cl->cl_g.dkg_nsect = cl->cl_blockcount;
3351 }
3352 } else {
3353 if (cl->cl_blockcount < 160) {
3354 /* Less than 80K */
3355 cl->cl_g.dkg_nhead = 1;
3356 cl->cl_g.dkg_ncyl = cl->cl_blockcount;
3357 cl->cl_g.dkg_nsect = 1;
3358 } else if (cl->cl_blockcount <= 0x1000) {
3359 /* unlabeled SCSI floppy device */
3360 cl->cl_g.dkg_nhead = 2;
3361 cl->cl_g.dkg_ncyl = 80;
3362 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
3363 } else if (cl->cl_blockcount <= 0x200000) {
3364 cl->cl_g.dkg_nhead = 64;
3365 cl->cl_g.dkg_nsect = 32;
3366 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
3367 } else {
3368 cl->cl_g.dkg_nhead = 255;
3369
3370 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
3371 (UINT16_MAX * 255 * 63) - 1) /
3372 (UINT16_MAX * 255 * 63)) * 63;
3373
3374 if (cl->cl_g.dkg_nsect == 0)
3375 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
3376
3377 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
3378 (255 * cl->cl_g.dkg_nsect);
3379 }
3380
3381 cl->cl_solaris_size =
3382 (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
3383 cl->cl_g.dkg_nsect;
3384
3385 }
3386
3387 cl->cl_g.dkg_acyl = 0;
3388 cl->cl_g.dkg_bcyl = 0;
3389 cl->cl_g.dkg_rpm = 200;
3390 cl->cl_asciilabel[0] = '\0';
3391 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl;
3392
3393 cl->cl_map[0].dkl_cylno = 0;
3394 cl->cl_map[0].dkl_nblk = cl->cl_solaris_size;
3395
3396 cl->cl_map[2].dkl_cylno = 0;
3397 cl->cl_map[2].dkl_nblk = cl->cl_solaris_size;
3398
3399 #elif defined(_SUNOS_VTOC_16)
3400
3401 if (cl->cl_solaris_size == 0) {
3402 /*
3403 * Got fdisk table but no solaris entry therefore
3404 * don't create a default label
3405 */
3406 cl->cl_f_geometry_is_valid = B_TRUE;
3407 return;
3408 }
3409
3410 /*
3411 * For CDs we continue to use the physical geometry to calculate
3412 * number of cylinders. All other devices must convert the
3413 * physical geometry (cmlb_geom) to values that will fit
3414 * in a dk_geom structure.
3415 */
3416 if (ISCD(cl)) {
3417 phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
3418 } else {
3419 /* Convert physical geometry to disk geometry */
3420 bzero(&cl_g, sizeof (struct dk_geom));
3421
3422 /*
3423 * Refer to comments related to off-by-1 at the
3424 * header of this file.
3425 * Before calculating geometry, capacity should be
3426 * decreased by 1.
3427 */
3428
3429 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
3430 capacity = cl->cl_blockcount - 1;
3431 else
3432 capacity = cl->cl_blockcount;
3433
3434
3435 cmlb_convert_geometry(cl, capacity, &cl_g, tg_cookie);
3436 bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
3437 phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
3438 }
3439
3440 if (phys_spc == 0)
3441 return;
3442 cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
3443 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3444 /* disable devid */
3445 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
3446 disksize = cl->cl_solaris_size;
3447 } else {
3448 cl->cl_g.dkg_acyl = DK_ACYL;
3449 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
3450 disksize = cl->cl_g.dkg_ncyl * phys_spc;
3451 }
3452
3453 if (ISCD(cl)) {
3454 /*
3455 * CD's don't use the "heads * sectors * cyls"-type of
3456 * geometry, but instead use the entire capacity of the media.
3457 */
3458 disksize = cl->cl_solaris_size;
3459 cl->cl_g.dkg_nhead = 1;
3460 cl->cl_g.dkg_nsect = 1;
3461 cl->cl_g.dkg_rpm =
3462 (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;
3463
3464 cl->cl_vtoc.v_part[0].p_start = 0;
3465 cl->cl_vtoc.v_part[0].p_size = disksize;
3466 cl->cl_vtoc.v_part[0].p_tag = V_BACKUP;
3467 cl->cl_vtoc.v_part[0].p_flag = V_UNMNT;
3468
3469 cl->cl_map[0].dkl_cylno = 0;
3470 cl->cl_map[0].dkl_nblk = disksize;
3471 cl->cl_offset[0] = 0;
3472
3473 } else {
3474 /*
3475 * Hard disks and removable media cartridges
3476 */
3477 cl->cl_g.dkg_rpm =
3478 (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
3479 cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;
3480
3481 /* Add boot slice */
3482 cl->cl_vtoc.v_part[8].p_start = 0;
3483 cl->cl_vtoc.v_part[8].p_size = phys_spc;
3484 cl->cl_vtoc.v_part[8].p_tag = V_BOOT;
3485 cl->cl_vtoc.v_part[8].p_flag = V_UNMNT;
3486
3487 cl->cl_map[8].dkl_cylno = 0;
3488 cl->cl_map[8].dkl_nblk = phys_spc;
3489 cl->cl_offset[8] = 0;
3490
3491 if ((cl->cl_alter_behavior &
3492 CMLB_CREATE_ALTSLICE_VTOC_16_DTYPE_DIRECT) &&
3493 cl->cl_device_type == DTYPE_DIRECT) {
3494 cl->cl_vtoc.v_part[9].p_start = phys_spc;
3495 cl->cl_vtoc.v_part[9].p_size = 2 * phys_spc;
3496 cl->cl_vtoc.v_part[9].p_tag = V_ALTSCTR;
3497 cl->cl_vtoc.v_part[9].p_flag = 0;
3498
3499 cl->cl_map[9].dkl_cylno = 1;
3500 cl->cl_map[9].dkl_nblk = 2 * phys_spc;
3501 cl->cl_offset[9] = phys_spc;
3502 }
3503 }
3504
3505 cl->cl_g.dkg_apc = 0;
3506
3507 /* Add backup slice */
3508 cl->cl_vtoc.v_part[2].p_start = 0;
3509 cl->cl_vtoc.v_part[2].p_size = disksize;
3510 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
3511 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
3512
3513 cl->cl_map[2].dkl_cylno = 0;
3514 cl->cl_map[2].dkl_nblk = disksize;
3515 cl->cl_offset[2] = 0;
3516
3517 /*
3518 * single slice (s0) covering the entire disk
3519 */
3520 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3521 cl->cl_vtoc.v_part[0].p_start = 0;
3522 cl->cl_vtoc.v_part[0].p_tag = V_UNASSIGNED;
3523 cl->cl_vtoc.v_part[0].p_flag = 0;
3524 cl->cl_vtoc.v_part[0].p_size = disksize;
3525 cl->cl_map[0].dkl_cylno = 0;
3526 cl->cl_map[0].dkl_nblk = disksize;
3527 cl->cl_offset[0] = 0;
3528 }
3529
3530 (void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
3531 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3532 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
3533
3534 #else
3535 #error "No VTOC format defined."
3536 #endif
3537
3538 cl->cl_g.dkg_read_reinstruct = 0;
3539 cl->cl_g.dkg_write_reinstruct = 0;
3540
3541 cl->cl_g.dkg_intrlv = 1;
3542
3543 cl->cl_vtoc.v_sanity = VTOC_SANE;
3544 cl->cl_vtoc.v_nparts = V_NUMPAR;
3545 cl->cl_vtoc.v_version = V_VERSION;
3546
3547 cl->cl_f_geometry_is_valid = B_TRUE;
3548 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
3549
3550 cmlb_dbg(CMLB_INFO, cl,
3551 "cmlb_build_default_label: Default label created: "
3552 "cyl: %d\tacyl: %d\tnhead: %d\tnsect: %d\tcap: %d\n",
3553 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
3554 cl->cl_g.dkg_nsect, cl->cl_blockcount);
3555 }
3556
3557
3558 #if defined(_FIRMWARE_NEEDS_FDISK)
3559 /*
3560 * Max CHS values, as they are encoded into bytes, for 1022/254/63
3561 */
3562 #define LBA_MAX_SECT (63 | ((1022 & 0x300) >> 2))
3563 #define LBA_MAX_CYL (1022 & 0xFF)
3564 #define LBA_MAX_HEAD (254)
3565
3566
3567 /*
3568 * Function: cmlb_has_max_chs_vals
3569 *
3570 * Description: Return B_TRUE if Cylinder-Head-Sector values are all at maximum.
3571 *
3572 * Arguments: fdp - ptr to CHS info
3573 *
3574 * Return Code: True or false
3575 *
3576 * Context: Any.
3577 */
3578 static boolean_t
3579 cmlb_has_max_chs_vals(struct ipart *fdp)
3580 {
3581 return ((fdp->begcyl == LBA_MAX_CYL) &&
3582 (fdp->beghead == LBA_MAX_HEAD) &&
3583 (fdp->begsect == LBA_MAX_SECT) &&
3584 (fdp->endcyl == LBA_MAX_CYL) &&
3585 (fdp->endhead == LBA_MAX_HEAD) &&
3586 (fdp->endsect == LBA_MAX_SECT));
3587 }
3588 #endif
3589
3590 /*
3591 * Function: cmlb_dkio_get_geometry
3592 *
3593 * Description: This routine is the driver entry point for handling user
3594 * requests to get the device geometry (DKIOCGGEOM).
3595 *
3596 * Arguments:
3597 * arg pointer to user provided dk_geom structure specifying
3598 * the controller's notion of the current geometry.
3599 *
3600 * flag this argument is a pass through to ddi_copyxxx()
3601 * directly from the mode argument of ioctl().
3602 *
3603 * tg_cookie cookie from target driver to be passed back to target
3604 * driver when we call back to it through tg_ops.
3605 *
3606 * Return Code: 0
3607 * EFAULT
3608 * ENXIO
3609 * EIO
3610 */
3611 static int
3612 cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
3613 void *tg_cookie)
3614 {
3615 struct dk_geom *tmp_geom = NULL;
3616 int rval = 0;
3617
3618 /*
3619 * cmlb_validate_geometry does not spin a disk up
3620 * if it was spcl down. We need to make sure it
3621 * is ready.
3622 */
3623 mutex_enter(CMLB_MUTEX(cl));
3624 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3625 #if defined(_SUNOS_VTOC_8)
3626 if (rval == EINVAL &&
3627 cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
3628 /*
3629 * This is to return a default label geometry even when we
3630 * do not really assume a default label for the device.
3631 * dad driver utilizes this.
3632 */
3633 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3634 cmlb_setup_default_geometry(cl, tg_cookie);
3635 rval = 0;
3636 }
3637 }
3638 #endif
3639 if (rval) {
3640 mutex_exit(CMLB_MUTEX(cl));
3641 return (rval);
3642 }
3643
3644 #if defined(__i386) || defined(__amd64)
3645 if (cl->cl_solaris_size == 0) {
3646 mutex_exit(CMLB_MUTEX(cl));
3647 return (EIO);
3648 }
3649 #endif
3650
3651 /*
3652 * Make a local copy of the soft state geometry to avoid some potential
3653 * race conditions associated with holding the mutex and updating the
3654 * write_reinstruct value
3655 */
3656 tmp_geom = kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
3657 bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
3658
3659 if (tmp_geom->dkg_write_reinstruct == 0) {
3660 tmp_geom->dkg_write_reinstruct =
3661 (int)((int)(tmp_geom->dkg_nsect * tmp_geom->dkg_rpm *
3662 cmlb_rot_delay) / (int)60000);
3663 }
3664 mutex_exit(CMLB_MUTEX(cl));
3665
3666 rval = ddi_copyout(tmp_geom, (void *)arg, sizeof (struct dk_geom),
3667 flag);
3668 if (rval != 0) {
3669 rval = EFAULT;
3670 }
3671
3672 kmem_free(tmp_geom, sizeof (struct dk_geom));
3673 return (rval);
3674
3675 }
3676
3677
3678 /*
3679 * Function: cmlb_dkio_set_geometry
3680 *
3681 * Description: This routine is the driver entry point for handling user
3682 * requests to set the device geometry (DKIOCSGEOM). The actual
3683 * device geometry is not updated, just the driver "notion" of it.
3684 *
3685 * Arguments:
3686 * arg pointer to user provided dk_geom structure used to set
3687 * the controller's notion of the current geometry.
3688 *
3689 * flag this argument is a pass through to ddi_copyxxx()
3690 * directly from the mode argument of ioctl().
3691 *
3692 * tg_cookie cookie from target driver to be passed back to target
3693 * driver when we call back to it through tg_ops.
3694 *
3695 * Return Code: 0
3696 * EFAULT
3697 * ENXIO
3698 * EIO
3699 */
3700 static int
3701 cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag)
3702 {
3703 struct dk_geom *tmp_geom;
3704 struct dk_map *lp;
3705 int rval = 0;
3706 int i;
3707
3708
3709 #if defined(__i386) || defined(__amd64)
3710 if (cl->cl_solaris_size == 0) {
3711 return (EIO);
3712 }
3713 #endif
3714 /*
3715 * We need to copy the user specified geometry into local
3716 * storage and then update the softstate. We don't want to hold
3717 * the mutex and copyin directly from the user to the soft state
3718 */
3719 tmp_geom = (struct dk_geom *)
3720 kmem_zalloc(sizeof (struct dk_geom), KM_SLEEP);
3721 rval = ddi_copyin(arg, tmp_geom, sizeof (struct dk_geom), flag);
3722 if (rval != 0) {
3723 kmem_free(tmp_geom, sizeof (struct dk_geom));
3724 return (EFAULT);
3725 }
3726
3727 mutex_enter(CMLB_MUTEX(cl));
3728 bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
3729 for (i = 0; i < NDKMAP; i++) {
3730 lp = &cl->cl_map[i];
3731 cl->cl_offset[i] =
3732 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
3733 #if defined(__i386) || defined(__amd64)
3734 cl->cl_offset[i] += cl->cl_solaris_offset;
3735 #endif
3736 }
3737 cl->cl_f_geometry_is_valid = B_FALSE;
3738 mutex_exit(CMLB_MUTEX(cl));
3739 kmem_free(tmp_geom, sizeof (struct dk_geom));
3740
3741 return (rval);
3742 }
3743
3744 /*
3745 * Function: cmlb_dkio_get_partition
3746 *
3747 * Description: This routine is the driver entry point for handling user
3748 * requests to get the partition table (DKIOCGAPART).
3749 *
3750 * Arguments:
3751 * arg pointer to user provided dk_allmap structure specifying
3752 * the controller's notion of the current partition table.
3753 *
3754 * flag this argument is a pass through to ddi_copyxxx()
3755 * directly from the mode argument of ioctl().
3756 *
3757 * tg_cookie cookie from target driver to be passed back to target
3758 * driver when we call back to it through tg_ops.
3759 *
3760 * Return Code: 0
3761 * EFAULT
3762 * ENXIO
3763 * EIO
3764 */
3765 static int
3766 cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
3767 void *tg_cookie)
3768 {
3769 int rval = 0;
3770 int size;
3771
3772 /*
3773 * Make sure the geometry is valid before getting the partition
3774 * information.
3775 */
3776 mutex_enter(CMLB_MUTEX(cl));
3777 if ((rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie)) != 0) {
3778 mutex_exit(CMLB_MUTEX(cl));
3779 return (rval);
3780 }
3781 mutex_exit(CMLB_MUTEX(cl));
3782
3783 #if defined(__i386) || defined(__amd64)
3784 if (cl->cl_solaris_size == 0) {
3785 return (EIO);
3786 }
3787 #endif
3788
3789 #ifdef _MULTI_DATAMODEL
3790 switch (ddi_model_convert_from(flag & FMODELS)) {
3791 case DDI_MODEL_ILP32: {
3792 struct dk_map32 dk_map32[NDKMAP];
3793 int i;
3794
3795 for (i = 0; i < NDKMAP; i++) {
3796 dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3797 dk_map32[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
3798 }
3799 size = NDKMAP * sizeof (struct dk_map32);
3800 rval = ddi_copyout(dk_map32, (void *)arg, size, flag);
3801 if (rval != 0) {
3802 rval = EFAULT;
3803 }
3804 break;
3805 }
3806 case DDI_MODEL_NONE:
3807 size = NDKMAP * sizeof (struct dk_map);
3808 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3809 if (rval != 0) {
3810 rval = EFAULT;
3811 }
3812 break;
3813 }
3814 #else /* ! _MULTI_DATAMODEL */
3815 size = NDKMAP * sizeof (struct dk_map);
3816 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3817 if (rval != 0) {
3818 rval = EFAULT;
3819 }
3820 #endif /* _MULTI_DATAMODEL */
3821 return (rval);
3822 }
3823
3824 /*
3825 * Function: cmlb_dkio_set_partition
3826 *
3827 * Description: This routine is the driver entry point for handling user
3828 * requests to set the partition table (DKIOCSAPART). The actual
3829 * device partition is not updated.
3830 *
3831 * Arguments:
3832 * arg - pointer to user provided dk_allmap structure used to set
3833 * the controller's notion of the partition table.
3834 * flag - this argument is a pass through to ddi_copyxxx()
3835 * directly from the mode argument of ioctl().
3836 *
3837 * Return Code: 0
3838 * EINVAL
3839 * EFAULT
3840 * ENXIO
3841 * EIO
3842 */
3843 static int
3844 cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag)
3845 {
3846 struct dk_map dk_map[NDKMAP];
3847 struct dk_map *lp;
3848 int rval = 0;
3849 int size;
3850 int i;
3851 #if defined(_SUNOS_VTOC_16)
3852 struct dkl_partition *vp;
3853 #endif
3854
3855 /*
3856 * Set the map for all logical partitions. We lock
3857 * the priority just to make sure an interrupt doesn't
3858 * come in while the map is half updated.
3859 */
3860 _NOTE(DATA_READABLE_WITHOUT_LOCK(cmlb_lun::cl_solaris_size))
3861 mutex_enter(CMLB_MUTEX(cl));
3862
3863 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3864 mutex_exit(CMLB_MUTEX(cl));
3865 return (ENOTSUP);
3866 }
3867 mutex_exit(CMLB_MUTEX(cl));
3868 if (cl->cl_solaris_size == 0) {
3869 return (EIO);
3870 }
3871
3872 #ifdef _MULTI_DATAMODEL
3873 switch (ddi_model_convert_from(flag & FMODELS)) {
3874 case DDI_MODEL_ILP32: {
3875 struct dk_map32 dk_map32[NDKMAP];
3876
3877 size = NDKMAP * sizeof (struct dk_map32);
3878 rval = ddi_copyin((void *)arg, dk_map32, size, flag);
3879 if (rval != 0) {
3880 return (EFAULT);
3881 }
3882 for (i = 0; i < NDKMAP; i++) {
3883 dk_map[i].dkl_cylno = dk_map32[i].dkl_cylno;
3884 dk_map[i].dkl_nblk = dk_map32[i].dkl_nblk;
3885 }
3886 break;
3887 }
3888 case DDI_MODEL_NONE:
3889 size = NDKMAP * sizeof (struct dk_map);
3890 rval = ddi_copyin((void *)arg, dk_map, size, flag);
3891 if (rval != 0) {
3892 return (EFAULT);
3893 }
3894 break;
3895 }
3896 #else /* ! _MULTI_DATAMODEL */
3897 size = NDKMAP * sizeof (struct dk_map);
3898 rval = ddi_copyin((void *)arg, dk_map, size, flag);
3899 if (rval != 0) {
3900 return (EFAULT);
3901 }
3902 #endif /* _MULTI_DATAMODEL */
3903
3904 mutex_enter(CMLB_MUTEX(cl));
3905 /* Note: The size used in this bcopy is set based upon the data model */
3906 bcopy(dk_map, cl->cl_map, size);
3907 #if defined(_SUNOS_VTOC_16)
3908 vp = (struct dkl_partition *)&(cl->cl_vtoc);
3909 #endif /* defined(_SUNOS_VTOC_16) */
3910 for (i = 0; i < NDKMAP; i++) {
3911 lp = &cl->cl_map[i];
3912 cl->cl_offset[i] =
3913 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
3914 #if defined(_SUNOS_VTOC_16)
3915 vp->p_start = cl->cl_offset[i];
3916 vp->p_size = lp->dkl_nblk;
3917 vp++;
3918 #endif /* defined(_SUNOS_VTOC_16) */
3919 #if defined(__i386) || defined(__amd64)
3920 cl->cl_offset[i] += cl->cl_solaris_offset;
3921 #endif
3922 }
3923 mutex_exit(CMLB_MUTEX(cl));
3924 return (rval);
3925 }
3926
3927
3928 /*
3929 * Function: cmlb_dkio_get_vtoc
3930 *
3931 * Description: This routine is the driver entry point for handling user
3932 * requests to get the current volume table of contents
3933 * (DKIOCGVTOC).
3934 *
3935 * Arguments:
3936 * arg pointer to user provided vtoc structure specifying
3937 * the current vtoc.
3938 *
3939 * flag this argument is a pass through to ddi_copyxxx()
3940 * directly from the mode argument of ioctl().
3941 *
3942 * tg_cookie cookie from target driver to be passed back to target
3943 * driver when we call back to it through tg_ops.
3944 *
3945 * Return Code: 0
3946 * EFAULT
3947 * ENXIO
3948 * EIO
3949 */
3950 static int
3951 cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
3952 {
3953 #if defined(_SUNOS_VTOC_8)
3954 struct vtoc user_vtoc;
3955 #endif /* defined(_SUNOS_VTOC_8) */
3956 int rval = 0;
3957
3958 mutex_enter(CMLB_MUTEX(cl));
3959 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3960 mutex_exit(CMLB_MUTEX(cl));
3961 return (EOVERFLOW);
3962 }
3963
3964 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3965
3966 #if defined(_SUNOS_VTOC_8)
3967 if (rval == EINVAL &&
3968 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
3969 /*
3970 * This is to return a default label even when we do not
3971 * really assume a default label for the device.
3972 * dad driver utilizes this.
3973 */
3974 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3975 cmlb_setup_default_geometry(cl, tg_cookie);
3976 rval = 0;
3977 }
3978 }
3979 #endif
3980 if (rval) {
3981 mutex_exit(CMLB_MUTEX(cl));
3982 return (rval);
3983 }
3984
3985 #if defined(_SUNOS_VTOC_8)
3986 cmlb_build_user_vtoc(cl, &user_vtoc);
3987 mutex_exit(CMLB_MUTEX(cl));
3988
3989 #ifdef _MULTI_DATAMODEL
3990 switch (ddi_model_convert_from(flag & FMODELS)) {
3991 case DDI_MODEL_ILP32: {
3992 struct vtoc32 user_vtoc32;
3993
3994 vtoctovtoc32(user_vtoc, user_vtoc32);
3995 if (ddi_copyout(&user_vtoc32, (void *)arg,
3996 sizeof (struct vtoc32), flag)) {
3997 return (EFAULT);
3998 }
3999 break;
4000 }
4001
4002 case DDI_MODEL_NONE:
4003 if (ddi_copyout(&user_vtoc, (void *)arg,
4004 sizeof (struct vtoc), flag)) {
4005 return (EFAULT);
4006 }
4007 break;
4008 }
4009 #else /* ! _MULTI_DATAMODEL */
4010 if (ddi_copyout(&user_vtoc, (void *)arg, sizeof (struct vtoc), flag)) {
4011 return (EFAULT);
4012 }
4013 #endif /* _MULTI_DATAMODEL */
4014
4015 #elif defined(_SUNOS_VTOC_16)
4016 mutex_exit(CMLB_MUTEX(cl));
4017
4018 #ifdef _MULTI_DATAMODEL
4019 /*
4020 * The cl_vtoc structure is a "struct dk_vtoc" which is always
4021 * 32-bit to maintain compatibility with existing on-disk
4022 * structures. Thus, we need to convert the structure when copying
4023 * it out to a datamodel-dependent "struct vtoc" in a 64-bit
4024 * program. If the target is a 32-bit program, then no conversion
4025 * is necessary.
4026 */
4027 /* LINTED: logical expression always true: op "||" */
4028 ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
4029 switch (ddi_model_convert_from(flag & FMODELS)) {
4030 case DDI_MODEL_ILP32:
4031 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
4032 sizeof (cl->cl_vtoc), flag)) {
4033 return (EFAULT);
4034 }
4035 break;
4036
4037 case DDI_MODEL_NONE: {
4038 struct vtoc user_vtoc;
4039
4040 vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
4041 if (ddi_copyout(&user_vtoc, (void *)arg,
4042 sizeof (struct vtoc), flag)) {
4043 return (EFAULT);
4044 }
4045 break;
4046 }
4047 }
4048 #else /* ! _MULTI_DATAMODEL */
4049 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
4050 flag)) {
4051 return (EFAULT);
4052 }
4053 #endif /* _MULTI_DATAMODEL */
4054 #else
4055 #error "No VTOC format defined."
4056 #endif
4057
4058 return (rval);
4059 }
4060
4061
4062 /*
4063 * Function: cmlb_dkio_get_extvtoc
4064 */
4065 static int
4066 cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
4067 void *tg_cookie)
4068 {
4069 struct extvtoc ext_vtoc;
4070 #if defined(_SUNOS_VTOC_8)
4071 struct vtoc user_vtoc;
4072 #endif /* defined(_SUNOS_VTOC_8) */
4073 int rval = 0;
4074
4075 bzero(&ext_vtoc, sizeof (struct extvtoc));
4076 mutex_enter(CMLB_MUTEX(cl));
4077 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
4078
4079 #if defined(_SUNOS_VTOC_8)
4080 if (rval == EINVAL &&
4081 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
4082 /*
4083 * This is to return a default label even when we do not
4084 * really assume a default label for the device.
4085 * dad driver utilizes this.
4086 */
4087 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
4088 cmlb_setup_default_geometry(cl, tg_cookie);
4089 rval = 0;
4090 }
4091 }
4092 #endif
4093 if (rval) {
4094 mutex_exit(CMLB_MUTEX(cl));
4095 return (rval);
4096 }
4097
4098 #if defined(_SUNOS_VTOC_8)
4099 cmlb_build_user_vtoc(cl, &user_vtoc);
4100 mutex_exit(CMLB_MUTEX(cl));
4101
4102 /*
4103 * Checking callers data model does not make much sense here
4104 * since extvtoc will always be equivalent to 64bit vtoc.
4105 * What is important is whether the kernel is in 32 or 64 bit
4106 */
4107
4108 #ifdef _LP64
4109 if (ddi_copyout(&user_vtoc, (void *)arg,
4110 sizeof (struct extvtoc), flag)) {
4111 return (EFAULT);
4112 }
4113 #else
4114 vtoc32tovtoc(user_vtoc, ext_vtoc);
4115 if (ddi_copyout(&ext_vtoc, (void *)arg,
4116 sizeof (struct extvtoc), flag)) {
4117 return (EFAULT);
4118 }
4119 #endif
4120
4121 #elif defined(_SUNOS_VTOC_16)
4122 /*
4123 * The cl_vtoc structure is a "struct dk_vtoc" which is always
4124 * 32-bit to maintain compatibility with existing on-disk
4125 * structures. Thus, we need to convert the structure when copying
4126 * it out to extvtoc
4127 */
4128 vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
4129 mutex_exit(CMLB_MUTEX(cl));
4130
4131 if (ddi_copyout(&ext_vtoc, (void *)arg, sizeof (struct extvtoc), flag))
4132 return (EFAULT);
4133 #else
4134 #error "No VTOC format defined."
4135 #endif
4136
4137 return (rval);
4138 }
4139
4140 /*
4141 * This routine implements the DKIOCGETEFI ioctl. This ioctl is currently
4142 * used to read the GPT Partition Table Header (primary/backup), the GUID
4143 * partition Entry Array (primary/backup), and the MBR.
4144 */
4145 static int
4146 cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
4147 {
4148 dk_efi_t user_efi;
4149 int rval = 0;
4150 void *buffer;
4151 diskaddr_t tgt_lba;
4152
4153 if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
4154 return (EFAULT);
4155
4156 user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
4157
4158 if (user_efi.dki_length == 0 ||
4159 user_efi.dki_length > cmlb_tg_max_efi_xfer)
4160 return (EINVAL);
4161
4162 tgt_lba = user_efi.dki_lba;
4163
4164 mutex_enter(CMLB_MUTEX(cl));
4165 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4166 (cl->cl_tgt_blocksize == 0) ||
4167 (user_efi.dki_length % cl->cl_sys_blocksize)) {
4168 mutex_exit(CMLB_MUTEX(cl));
4169 return (EINVAL);
4170 }
4171 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
4172 tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
4173 cl->cl_sys_blocksize;
4174 mutex_exit(CMLB_MUTEX(cl));
4175
4176 buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
4177 rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
4178 if (rval == 0 && ddi_copyout(buffer, user_efi.dki_data,
4179 user_efi.dki_length, flag) != 0)
4180 rval = EFAULT;
4181
4182 kmem_free(buffer, user_efi.dki_length);
4183 return (rval);
4184 }
4185
4186 #if defined(_SUNOS_VTOC_8)
4187 /*
4188 * Function: cmlb_build_user_vtoc
4189 *
4190 * Description: This routine populates a pass by reference variable with the
4191 * current volume table of contents.
4192 *
4193 * Arguments: cl - driver soft state (unit) structure
4194 * user_vtoc - pointer to vtoc structure to be populated
4195 */
4196 static void
4197 cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
4198 {
4199 struct dk_map2 *lpart;
4200 struct dk_map *lmap;
4201 struct partition *vpart;
4202 uint32_t nblks;
4203 int i;
4204
4205 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4206
4207 /*
4208 * Return vtoc structure fields in the provided VTOC area, addressed
4209 * by *vtoc.
4210 */
4211 bzero(user_vtoc, sizeof (struct vtoc));
4212 user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
4213 user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
4214 user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
4215 user_vtoc->v_sanity = VTOC_SANE;
4216 user_vtoc->v_version = cl->cl_vtoc.v_version;
4217 bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
4218 user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
4219 user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;
4220
4221 for (i = 0; i < 10; i++)
4222 user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
4223
4224 /*
4225 * Convert partitioning information.
4226 *
4227 * Note the conversion from starting cylinder number
4228 * to starting sector number.
4229 */
4230 lmap = cl->cl_map;
4231 lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
4232 vpart = user_vtoc->v_part;
4233
4234 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4235
4236 for (i = 0; i < V_NUMPAR; i++) {
4237 vpart->p_tag = lpart->p_tag;
4238 vpart->p_flag = lpart->p_flag;
4239 vpart->p_start = lmap->dkl_cylno * nblks;
4240 vpart->p_size = lmap->dkl_nblk;
4241 lmap++;
4242 lpart++;
4243 vpart++;
4244
4245 /* (4364927) */
4246 user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
4247 }
4248
4249 bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
4250 }
4251 #endif
4252
4253 static int
4254 cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
4255 void *tg_cookie)
4256 {
4257 struct partition64 p64;
4258 int rval = 0;
4259 uint_t nparts;
4260 efi_gpe_t *partitions;
4261 efi_gpt_t *buffer;
4262 diskaddr_t gpe_lba;
4263 int n_gpe_per_blk = 0;
4264
4265 if (ddi_copyin((const void *)arg, &p64,
4266 sizeof (struct partition64), flag)) {
4267 return (EFAULT);
4268 }
4269
4270 buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4271 rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie);
4272 if (rval != 0)
4273 goto done_error;
4274
4275 cmlb_swap_efi_gpt(buffer);
4276
4277 if ((rval = cmlb_validate_efi(buffer)) != 0)
4278 goto done_error;
4279
4280 nparts = buffer->efi_gpt_NumberOfPartitionEntries;
4281 gpe_lba = buffer->efi_gpt_PartitionEntryLBA;
4282 if (p64.p_partno >= nparts) {
4283 /* couldn't find it */
4284 rval = ESRCH;
4285 goto done_error;
4286 }
4287 /*
4288 * Read the block that contains the requested GPE.
4289 */
4290 n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t);
4291 gpe_lba += p64.p_partno / n_gpe_per_blk;
4292 rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie);
4293
4294 if (rval) {
4295 goto done_error;
4296 }
4297 partitions = (efi_gpe_t *)buffer;
4298 partitions += p64.p_partno % n_gpe_per_blk;
4299
4300 /* Byte swap only the requested GPE */
4301 cmlb_swap_efi_gpe(1, partitions);
4302
4303 bcopy(&partitions->efi_gpe_PartitionTypeGUID, &p64.p_type,
4304 sizeof (struct uuid));
4305 p64.p_start = partitions->efi_gpe_StartingLBA;
4306 p64.p_size = partitions->efi_gpe_EndingLBA -
4307 p64.p_start + 1;
4308
4309 if (ddi_copyout(&p64, (void *)arg, sizeof (struct partition64), flag))
4310 rval = EFAULT;
4311
4312 done_error:
4313 kmem_free(buffer, cl->cl_sys_blocksize);
4314 return (rval);
4315 }
4316
4317
4318 /*
4319 * Function: cmlb_dkio_set_vtoc
4320 *
4321 * Description: This routine is the driver entry point for handling user
4322 * requests to set the current volume table of contents
4323 * (DKIOCSVTOC).
4324 *
4325 * Arguments:
4326 * dev the device number
4327 * arg pointer to user provided vtoc structure used to set the
4328 * current vtoc.
4329 *
4330 * flag this argument is a pass through to ddi_copyxxx()
4331 * directly from the mode argument of ioctl().
4332 *
4333 * tg_cookie cookie from target driver to be passed back to target
4334 * driver when we call back to it through tg_ops.
4335 *
4336 * Return Code: 0
4337 * EFAULT
4338 * ENXIO
4339 * EINVAL
4340 * ENOTSUP
4341 */
4342 static int
4343 cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4344 void *tg_cookie)
4345 {
4346 struct vtoc user_vtoc;
4347 int shift, rval = 0;
4348 boolean_t internal;
4349
4350 internal = VOID2BOOLEAN(
4351 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4352
4353 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4354 shift = CMLBUNIT_FORCE_P0_SHIFT;
4355 else
4356 shift = CMLBUNIT_SHIFT;
4357
4358 #ifdef _MULTI_DATAMODEL
4359 switch (ddi_model_convert_from(flag & FMODELS)) {
4360 case DDI_MODEL_ILP32: {
4361 struct vtoc32 user_vtoc32;
4362
4363 if (ddi_copyin((const void *)arg, &user_vtoc32,
4364 sizeof (struct vtoc32), flag)) {
4365 return (EFAULT);
4366 }
4367 vtoc32tovtoc(user_vtoc32, user_vtoc);
4368 break;
4369 }
4370
4371 case DDI_MODEL_NONE:
4372 if (ddi_copyin((const void *)arg, &user_vtoc,
4373 sizeof (struct vtoc), flag)) {
4374 return (EFAULT);
4375 }
4376 break;
4377 }
4378 #else /* ! _MULTI_DATAMODEL */
4379 if (ddi_copyin((const void *)arg, &user_vtoc,
4380 sizeof (struct vtoc), flag)) {
4381 return (EFAULT);
4382 }
4383 #endif /* _MULTI_DATAMODEL */
4384
4385 mutex_enter(CMLB_MUTEX(cl));
4386
4387 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
4388 mutex_exit(CMLB_MUTEX(cl));
4389 return (EOVERFLOW);
4390 }
4391
4392 #if defined(__i386) || defined(__amd64)
4393 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4394 mutex_exit(CMLB_MUTEX(cl));
4395 return (EINVAL);
4396 }
4397 #endif
4398
4399 if (cl->cl_g.dkg_ncyl == 0) {
4400 mutex_exit(CMLB_MUTEX(cl));
4401 return (EINVAL);
4402 }
4403
4404 mutex_exit(CMLB_MUTEX(cl));
4405 cmlb_clear_efi(cl, tg_cookie);
4406 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4407 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
4408
4409 /*
4410 * cmlb_dkio_set_vtoc creates duplicate minor nodes when
4411 * relabeling an SMI disk. To avoid that we remove them
4412 * before creating.
4413 * It should be OK to remove a non-existed minor node.
4414 */
4415 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4416 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4417
4418 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4419 S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4420 cl->cl_node_type, NULL, internal);
4421 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4422 S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4423 cl->cl_node_type, NULL, internal);
4424 mutex_enter(CMLB_MUTEX(cl));
4425
4426 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4427 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
4428 if (cmlb_validate_geometry(cl,
4429 B_TRUE, 0, tg_cookie) != 0) {
4430 cmlb_dbg(CMLB_ERROR, cl,
4431 "cmlb_dkio_set_vtoc: "
4432 "Failed validate geometry\n");
4433 }
4434 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
4435 }
4436 }
4437 mutex_exit(CMLB_MUTEX(cl));
4438 return (rval);
4439 }
4440
4441 /*
4442 * Function: cmlb_dkio_set_extvtoc
4443 */
4444 static int
4445 cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4446 void *tg_cookie)
4447 {
4448 int shift, rval = 0;
4449 struct vtoc user_vtoc;
4450 boolean_t internal;
4451
4452 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4453 shift = CMLBUNIT_FORCE_P0_SHIFT;
4454 else
4455 shift = CMLBUNIT_SHIFT;
4456
4457 /*
4458 * Checking callers data model does not make much sense here
4459 * since extvtoc will always be equivalent to 64bit vtoc.
4460 * What is important is whether the kernel is in 32 or 64 bit
4461 */
4462
4463 #ifdef _LP64
4464 if (ddi_copyin((const void *)arg, &user_vtoc,
4465 sizeof (struct extvtoc), flag)) {
4466 return (EFAULT);
4467 }
4468 #else
4469 struct extvtoc user_extvtoc;
4470 if (ddi_copyin((const void *)arg, &user_extvtoc,
4471 sizeof (struct extvtoc), flag)) {
4472 return (EFAULT);
4473 }
4474
4475 vtoctovtoc32(user_extvtoc, user_vtoc);
4476 #endif
4477
4478 internal = VOID2BOOLEAN(
4479 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4480 mutex_enter(CMLB_MUTEX(cl));
4481 #if defined(__i386) || defined(__amd64)
4482 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4483 mutex_exit(CMLB_MUTEX(cl));
4484 return (EINVAL);
4485 }
4486 #endif
4487
4488 if (cl->cl_g.dkg_ncyl == 0) {
4489 mutex_exit(CMLB_MUTEX(cl));
4490 return (EINVAL);
4491 }
4492
4493 mutex_exit(CMLB_MUTEX(cl));
4494 cmlb_clear_efi(cl, tg_cookie);
4495 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4496 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
4497 /*
4498 * cmlb_dkio_set_extvtoc creates duplicate minor nodes when
4499 * relabeling an SMI disk. To avoid that we remove them
4500 * before creating.
4501 * It should be OK to remove a non-existed minor node.
4502 */
4503 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4504 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4505
4506 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4507 S_IFBLK, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4508 cl->cl_node_type, NULL, internal);
4509 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4510 S_IFCHR, (CMLBUNIT(dev, shift) << shift) | WD_NODE,
4511 cl->cl_node_type, NULL, internal);
4512
4513 mutex_enter(CMLB_MUTEX(cl));
4514
4515 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4516 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
4517 if (cmlb_validate_geometry(cl,
4518 B_TRUE, 0, tg_cookie) != 0) {
4519 cmlb_dbg(CMLB_ERROR, cl,
4520 "cmlb_dkio_set_vtoc: "
4521 "Failed validate geometry\n");
4522 }
4523 }
4524 }
4525 mutex_exit(CMLB_MUTEX(cl));
4526 return (rval);
4527 }
4528
4529 /*
4530 * Function: cmlb_build_label_vtoc
4531 *
4532 * Description: This routine updates the driver soft state current volume table
4533 * of contents based on a user specified vtoc.
4534 *
4535 * Arguments: cl - driver soft state (unit) structure
4536 * user_vtoc - pointer to vtoc structure specifying vtoc to be used
4537 * to update the driver soft state.
4538 *
4539 * Return Code: 0
4540 * EINVAL
4541 */
4542 static int
4543 cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc)
4544 {
4545 struct dk_map *lmap;
4546 struct partition *vpart;
4547 uint_t nblks;
4548 #if defined(_SUNOS_VTOC_8)
4549 int ncyl;
4550 struct dk_map2 *lpart;
4551 #endif /* defined(_SUNOS_VTOC_8) */
4552 int i;
4553
4554 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4555
4556 /* Sanity-check the vtoc */
4557 if (user_vtoc->v_sanity != VTOC_SANE ||
4558 user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
4559 user_vtoc->v_nparts != V_NUMPAR) {
4560 cmlb_dbg(CMLB_INFO, cl,
4561 "cmlb_build_label_vtoc: vtoc not valid\n");
4562 return (EINVAL);
4563 }
4564
4565 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4566 if (nblks == 0) {
4567 cmlb_dbg(CMLB_INFO, cl,
4568 "cmlb_build_label_vtoc: geom nblks is 0\n");
4569 return (EINVAL);
4570 }
4571
4572 #if defined(_SUNOS_VTOC_8)
4573 vpart = user_vtoc->v_part;
4574 for (i = 0; i < V_NUMPAR; i++) {
4575 if (((unsigned)vpart->p_start % nblks) != 0) {
4576 cmlb_dbg(CMLB_INFO, cl,
4577 "cmlb_build_label_vtoc: p_start not multiply of"
4578 "nblks part %d p_start %d nblks %d\n", i,
4579 vpart->p_start, nblks);
4580 return (EINVAL);
4581 }
4582 ncyl = (unsigned)vpart->p_start / nblks;
4583 ncyl += (unsigned)vpart->p_size / nblks;
4584 if (((unsigned)vpart->p_size % nblks) != 0) {
4585 ncyl++;
4586 }
4587 if (ncyl > (int)cl->cl_g.dkg_ncyl) {
4588 cmlb_dbg(CMLB_INFO, cl,
4589 "cmlb_build_label_vtoc: ncyl %d > dkg_ncyl %d"
4590 "p_size %ld p_start %ld nblks %d part number %d"
4591 "tag %d\n",
4592 ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
4593 vpart->p_start, nblks,
4594 i, vpart->p_tag);
4595
4596 return (EINVAL);
4597 }
4598 vpart++;
4599 }
4600 #endif /* defined(_SUNOS_VTOC_8) */
4601
4602 /* Put appropriate vtoc structure fields into the disk label */
4603 #if defined(_SUNOS_VTOC_16)
4604 /*
4605 * The vtoc is always a 32bit data structure to maintain the
4606 * on-disk format. Convert "in place" instead of doing bcopy.
4607 */
4608 vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
4609
4610 /*
4611 * in the 16-slice vtoc, starting sectors are expressed in
4612 * numbers *relative* to the start of the Solaris fdisk partition.
4613 */
4614 lmap = cl->cl_map;
4615 vpart = user_vtoc->v_part;
4616
4617 for (i = 0; i < (int)user_vtoc->v_nparts; i++, lmap++, vpart++) {
4618 lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
4619 lmap->dkl_nblk = (unsigned)vpart->p_size;
4620 }
4621
4622 #elif defined(_SUNOS_VTOC_8)
4623
4624 cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
4625 cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
4626 cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];
4627
4628 cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
4629 cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
4630
4631 bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
4632
4633 cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
4634
4635 for (i = 0; i < 10; i++)
4636 cl->cl_vtoc.v_reserved[i] = user_vtoc->v_reserved[i];
4637
4638 /*
4639 * Note the conversion from starting sector number
4640 * to starting cylinder number.
4641 * Return error if division results in a remainder.
4642 */
4643 lmap = cl->cl_map;
4644 lpart = cl->cl_vtoc.v_part;
4645 vpart = user_vtoc->v_part;
4646
4647 for (i = 0; i < (int)user_vtoc->v_nparts; i++) {
4648 lpart->p_tag = vpart->p_tag;
4649 lpart->p_flag = vpart->p_flag;
4650 lmap->dkl_cylno = (unsigned)vpart->p_start / nblks;
4651 lmap->dkl_nblk = (unsigned)vpart->p_size;
4652
4653 lmap++;
4654 lpart++;
4655 vpart++;
4656
4657 /* (4387723) */
4658 #ifdef _LP64
4659 if (user_vtoc->timestamp[i] > TIME32_MAX) {
4660 cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
4661 } else {
4662 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4663 }
4664 #else
4665 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4666 #endif
4667 }
4668
4669 bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
4670 #else
4671 #error "No VTOC format defined."
4672 #endif
4673 return (0);
4674 }
4675
4676 /*
4677 * Function: cmlb_clear_efi
4678 *
4679 * Description: This routine clears all EFI labels.
4680 *
4681 * Arguments:
4682 * cl driver soft state (unit) structure
4683 *
4684 * tg_cookie cookie from target driver to be passed back to target
4685 * driver when we call back to it through tg_ops.
4686 * Return Code: void
4687 */
4688 static void
4689 cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie)
4690 {
4691 efi_gpt_t *gpt;
4692 diskaddr_t cap;
4693 int rval;
4694
4695 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
4696
4697 mutex_enter(CMLB_MUTEX(cl));
4698 cl->cl_reserved = -1;
4699 mutex_exit(CMLB_MUTEX(cl));
4700
4701 gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4702
4703 if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) {
4704 goto done;
4705 }
4706
4707 cmlb_swap_efi_gpt(gpt);
4708 rval = cmlb_validate_efi(gpt);
4709 if (rval == 0) {
4710 /* clear primary */
4711 bzero(gpt, sizeof (efi_gpt_t));
4712 if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize,
4713 tg_cookie)) {
4714 cmlb_dbg(CMLB_INFO, cl,
4715 "cmlb_clear_efi: clear primary label failed\n");
4716 }
4717 }
4718 /* the backup */
4719 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
4720 if (rval) {
4721 goto done;
4722 }
4723
4724 if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4725 tg_cookie)) != 0) {
4726 goto done;
4727 }
4728 cmlb_swap_efi_gpt(gpt);
4729 rval = cmlb_validate_efi(gpt);
4730 if (rval == 0) {
4731 /* clear backup */
4732 cmlb_dbg(CMLB_TRACE, cl,
4733 "cmlb_clear_efi clear backup@%lu\n", cap - 1);
4734 bzero(gpt, sizeof (efi_gpt_t));
4735 if ((rval = DK_TG_WRITE(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4736 tg_cookie))) {
4737 cmlb_dbg(CMLB_INFO, cl,
4738 "cmlb_clear_efi: clear backup label failed\n");
4739 }
4740 } else {
4741 /*
4742 * Refer to comments related to off-by-1 at the
4743 * header of this file
4744 */
4745 if ((rval = DK_TG_READ(cl, gpt, cap - 2,
4746 cl->cl_sys_blocksize, tg_cookie)) != 0) {
4747 goto done;
4748 }
4749 cmlb_swap_efi_gpt(gpt);
4750 rval = cmlb_validate_efi(gpt);
4751 if (rval == 0) {
4752 /* clear legacy backup EFI label */
4753 cmlb_dbg(CMLB_TRACE, cl,
4754 "cmlb_clear_efi clear legacy backup@%lu\n",
4755 cap - 2);
4756 bzero(gpt, sizeof (efi_gpt_t));
4757 if ((rval = DK_TG_WRITE(cl, gpt, cap - 2,
4758 cl->cl_sys_blocksize, tg_cookie))) {
4759 cmlb_dbg(CMLB_INFO, cl,
4760 "cmlb_clear_efi: clear legacy backup label "
4761 "failed\n");
4762 }
4763 }
4764 }
4765
4766 done:
4767 kmem_free(gpt, cl->cl_sys_blocksize);
4768 }
4769
4770 /*
4771 * Function: cmlb_set_vtoc
4772 *
4773 * Description: This routine writes data to the appropriate positions
4774 *
4775 * Arguments:
4776 * cl driver soft state (unit) structure
4777 *
4778 * dkl the data to be written
4779 *
4780 * tg_cookie cookie from target driver to be passed back to target
4781 * driver when we call back to it through tg_ops.
4782 *
4783 * Return: void
4784 */
4785 static int
4786 cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie)
4787 {
4788 uint_t label_addr;
4789 int sec;
4790 diskaddr_t blk;
4791 int head;
4792 int cyl;
4793 int rval;
4794
4795 #if defined(__i386) || defined(__amd64)
4796 label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
4797 #else
4798 /* Write the primary label at block 0 of the solaris partition. */
4799 label_addr = 0;
4800 #endif
4801
4802 rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
4803 tg_cookie);
4804
4805 if (rval != 0) {
4806 return (rval);
4807 }
4808
4809 /*
4810 * Calculate where the backup labels go. They are always on
4811 * the last alternate cylinder, but some older drives put them
4812 * on head 2 instead of the last head. They are always on the
4813 * first 5 odd sectors of the appropriate track.
4814 *
4815 * We have no choice at this point, but to believe that the
4816 * disk label is valid. Use the geometry of the disk
4817 * as described in the label.
4818 */
4819 cyl = dkl->dkl_ncyl + dkl->dkl_acyl - 1;
4820 head = dkl->dkl_nhead - 1;
4821
4822 /*
4823 * Write and verify the backup labels. Make sure we don't try to
4824 * write past the last cylinder.
4825 */
4826 for (sec = 1; ((sec < 5 * 2 + 1) && (sec < dkl->dkl_nsect)); sec += 2) {
4827 blk = (diskaddr_t)(
4828 (cyl * ((dkl->dkl_nhead * dkl->dkl_nsect) - dkl->dkl_apc)) +
4829 (head * dkl->dkl_nsect) + sec);
4830 #if defined(__i386) || defined(__amd64)
4831 blk += cl->cl_solaris_offset;
4832 #endif
4833 rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
4834 tg_cookie);
4835 cmlb_dbg(CMLB_INFO, cl,
4836 "cmlb_set_vtoc: wrote backup label %llx\n", blk);
4837 if (rval != 0) {
4838 goto exit;
4839 }
4840 }
4841 exit:
4842 return (rval);
4843 }
4844
4845 /*
4846 * Function: cmlb_clear_vtoc
4847 *
4848 * Description: This routine clears out the VTOC labels.
4849 *
4850 * Arguments:
4851 * cl driver soft state (unit) structure
4852 *
4853 * tg_cookie cookie from target driver to be passed back to target
4854 * driver when we call back to it through tg_ops.
4855 *
4856 * Return: void
4857 */
4858 static void
4859 cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie)
4860 {
4861 struct dk_label *dkl;
4862
4863 mutex_exit(CMLB_MUTEX(cl));
4864 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4865 mutex_enter(CMLB_MUTEX(cl));
4866 /*
4867 * cmlb_set_vtoc uses these fields in order to figure out
4868 * where to overwrite the backup labels
4869 */
4870 dkl->dkl_apc = cl->cl_g.dkg_apc;
4871 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4872 dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4873 dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4874 dkl->dkl_nsect = cl->cl_g.dkg_nsect;
4875 mutex_exit(CMLB_MUTEX(cl));
4876 (void) cmlb_set_vtoc(cl, dkl, tg_cookie);
4877 kmem_free(dkl, cl->cl_sys_blocksize);
4878
4879 mutex_enter(CMLB_MUTEX(cl));
4880 }
4881
4882 /*
4883 * Function: cmlb_write_label
4884 *
4885 * Description: This routine will validate and write the driver soft state vtoc
4886 * contents to the device.
4887 *
4888 * Arguments:
4889 * cl cmlb handle
4890 *
4891 * tg_cookie cookie from target driver to be passed back to target
4892 * driver when we call back to it through tg_ops.
4893 *
4894 *
4895 * Return Code: the code returned by cmlb_send_scsi_cmd()
4896 * 0
4897 * EINVAL
4898 * ENXIO
4899 * ENOMEM
4900 */
4901 static int
4902 cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie)
4903 {
4904 struct dk_label *dkl;
4905 short sum;
4906 short *sp;
4907 int i;
4908 int rval;
4909
4910 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4911 mutex_exit(CMLB_MUTEX(cl));
4912 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4913 mutex_enter(CMLB_MUTEX(cl));
4914
4915 bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
4916 dkl->dkl_rpm = cl->cl_g.dkg_rpm;
4917 dkl->dkl_pcyl = cl->cl_g.dkg_pcyl;
4918 dkl->dkl_apc = cl->cl_g.dkg_apc;
4919 dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
4920 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4921 dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4922 dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4923 dkl->dkl_nsect = cl->cl_g.dkg_nsect;
4924
4925 #if defined(_SUNOS_VTOC_8)
4926 dkl->dkl_obs1 = cl->cl_g.dkg_obs1;
4927 dkl->dkl_obs2 = cl->cl_g.dkg_obs2;
4928 dkl->dkl_obs3 = cl->cl_g.dkg_obs3;
4929 for (i = 0; i < NDKMAP; i++) {
4930 dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
4931 dkl->dkl_map[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
4932 }
4933 bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
4934 #elif defined(_SUNOS_VTOC_16)
4935 dkl->dkl_skew = cl->cl_dkg_skew;
4936 #else
4937 #error "No VTOC format defined."
4938 #endif
4939
4940 dkl->dkl_magic = DKL_MAGIC;
4941 dkl->dkl_write_reinstruct = cl->cl_g.dkg_write_reinstruct;
4942 dkl->dkl_read_reinstruct = cl->cl_g.dkg_read_reinstruct;
4943
4944 /* Construct checksum for the new disk label */
4945 sum = 0;
4946 sp = (short *)dkl;
4947 i = sizeof (struct dk_label) / sizeof (short);
4948 while (i--) {
4949 sum ^= *sp++;
4950 }
4951 dkl->dkl_cksum = sum;
4952
4953 mutex_exit(CMLB_MUTEX(cl));
4954
4955 rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
4956 exit:
4957 kmem_free(dkl, cl->cl_sys_blocksize);
4958 mutex_enter(CMLB_MUTEX(cl));
4959 return (rval);
4960 }
4961
4962 /*
4963 * This routine implements the DKIOCSETEFI ioctl. This ioctl is currently
4964 * used to write (or clear) the GPT Partition Table header (primary/backup)
4965 * and GUID partition Entry Array (primary/backup). It is also used to write
4966 * the Protective MBR.
4967 */
4968 static int
4969 cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag,
4970 void *tg_cookie)
4971 {
4972 dk_efi_t user_efi;
4973 int shift, rval = 0;
4974 void *buffer;
4975 diskaddr_t tgt_lba;
4976 boolean_t internal;
4977
4978 if (ddi_copyin(arg, &user_efi, sizeof (dk_efi_t), flag))
4979 return (EFAULT);
4980
4981 internal = VOID2BOOLEAN(
4982 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4983
4984 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4985 shift = CMLBUNIT_FORCE_P0_SHIFT;
4986 else
4987 shift = CMLBUNIT_SHIFT;
4988
4989 user_efi.dki_data = (void *)(uintptr_t)user_efi.dki_data_64;
4990
4991 if (user_efi.dki_length == 0 ||
4992 user_efi.dki_length > cmlb_tg_max_efi_xfer)
4993 return (EINVAL);
4994
4995 tgt_lba = user_efi.dki_lba;
4996
4997 mutex_enter(CMLB_MUTEX(cl));
4998 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4999 (cl->cl_tgt_blocksize == 0) ||
5000 (user_efi.dki_length % cl->cl_sys_blocksize)) {
5001 mutex_exit(CMLB_MUTEX(cl));
5002 return (EINVAL);
5003 }
5004 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
5005 tgt_lba = tgt_lba *
5006 cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
5007 mutex_exit(CMLB_MUTEX(cl));
5008
5009 buffer = kmem_alloc(user_efi.dki_length, KM_SLEEP);
5010 if (ddi_copyin(user_efi.dki_data, buffer, user_efi.dki_length, flag)) {
5011 rval = EFAULT;
5012 } else {
5013 /*
5014 * let's clear the vtoc labels and clear the softstate
5015 * vtoc.
5016 */
5017 mutex_enter(CMLB_MUTEX(cl));
5018 if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
5019 cmlb_dbg(CMLB_TRACE, cl,
5020 "cmlb_dkio_set_efi: CLEAR VTOC\n");
5021 if (cl->cl_label_from_media == CMLB_LABEL_VTOC)
5022 cmlb_clear_vtoc(cl, tg_cookie);
5023 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
5024 mutex_exit(CMLB_MUTEX(cl));
5025 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
5026 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
5027 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
5028 S_IFBLK,
5029 (CMLBUNIT(dev, shift) << shift) | WD_NODE,
5030 cl->cl_node_type, NULL, internal);
5031 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
5032 S_IFCHR,
5033 (CMLBUNIT(dev, shift) << shift) | WD_NODE,
5034 cl->cl_node_type, NULL, internal);
5035 } else
5036 mutex_exit(CMLB_MUTEX(cl));
5037
5038 rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
5039 tg_cookie);
5040
5041 if (rval == 0) {
5042 mutex_enter(CMLB_MUTEX(cl));
5043 cl->cl_f_geometry_is_valid = B_FALSE;
5044 mutex_exit(CMLB_MUTEX(cl));
5045 }
5046 }
5047 kmem_free(buffer, user_efi.dki_length);
5048 return (rval);
5049 }
5050
5051 /*
5052 * Function: cmlb_dkio_get_mboot
5053 *
5054 * Description: This routine is the driver entry point for handling user
5055 * requests to get the current device mboot (DKIOCGMBOOT)
5056 *
5057 * Arguments:
5058 * arg pointer to user provided mboot structure specifying
5059 * the current mboot.
5060 *
5061 * flag this argument is a pass through to ddi_copyxxx()
5062 * directly from the mode argument of ioctl().
5063 *
5064 * tg_cookie cookie from target driver to be passed back to target
5065 * driver when we call back to it through tg_ops.
5066 *
5067 * Return Code: 0
5068 * EINVAL
5069 * EFAULT
5070 * ENXIO
5071 */
5072 static int
5073 cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
5074 {
5075 struct mboot *mboot;
5076 int rval;
5077 size_t buffer_size;
5078
5079
5080 #if defined(_SUNOS_VTOC_8)
5081 if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
5082 #elif defined(_SUNOS_VTOC_16)
5083 if (arg == NULL) {
5084 #endif
5085 return (EINVAL);
5086 }
5087
5088 /*
5089 * Read the mboot block, located at absolute block 0 on the target.
5090 */
5091 buffer_size = cl->cl_sys_blocksize;
5092
5093 cmlb_dbg(CMLB_TRACE, cl,
5094 "cmlb_dkio_get_mboot: allocation size: 0x%x\n", buffer_size);
5095
5096 mboot = kmem_zalloc(buffer_size, KM_SLEEP);
5097 if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
5098 if (ddi_copyout(mboot, (void *)arg,
5099 sizeof (struct mboot), flag) != 0) {
5100 rval = EFAULT;
5101 }
5102 }
5103 kmem_free(mboot, buffer_size);
5104 return (rval);
5105 }
5106
5107
5108 /*
5109 * Function: cmlb_dkio_set_mboot
5110 *
5111 * Description: This routine is the driver entry point for handling user
5112 * requests to validate and set the device master boot
5113 * (DKIOCSMBOOT).
5114 *
5115 * Arguments:
5116 * arg pointer to user provided mboot structure used to set the
5117 * master boot.
5118 *
5119 * flag this argument is a pass through to ddi_copyxxx()
5120 * directly from the mode argument of ioctl().
5121 *
5122 * tg_cookie cookie from target driver to be passed back to target
5123 * driver when we call back to it through tg_ops.
5124 *
5125 * Return Code: 0
5126 * EINVAL
5127 * EFAULT
5128 * ENXIO
5129 */
5130 static int
5131 cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie)
5132 {
5133 struct mboot *mboot = NULL;
5134 int rval;
5135 ushort_t magic;
5136
5137
5138 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5139
5140 #if defined(_SUNOS_VTOC_8)
5141 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
5142 return (EINVAL);
5143 }
5144 #endif
5145
5146 if (arg == NULL) {
5147 return (EINVAL);
5148 }
5149
5150 mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
5151
5152 if (ddi_copyin((const void *)arg, mboot,
5153 cl->cl_sys_blocksize, flag) != 0) {
5154 kmem_free(mboot, cl->cl_sys_blocksize);
5155 return (EFAULT);
5156 }
5157
5158 /* Is this really a master boot record? */
5159 magic = LE_16(mboot->signature);
5160 if (magic != MBB_MAGIC) {
5161 kmem_free(mboot, cl->cl_sys_blocksize);
5162 return (EINVAL);
5163 }
5164
5165 rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
5166
5167 mutex_enter(CMLB_MUTEX(cl));
5168 #if defined(__i386) || defined(__amd64)
5169 if (rval == 0) {
5170 /*
5171 * mboot has been written successfully.
5172 * update the fdisk and vtoc tables in memory
5173 */
5174 rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
5175 if ((!cl->cl_f_geometry_is_valid) || (rval != 0)) {
5176 mutex_exit(CMLB_MUTEX(cl));
5177 kmem_free(mboot, cl->cl_sys_blocksize);
5178 return (rval);
5179 }
5180 }
5181
5182 #ifdef __lock_lint
5183 cmlb_setup_default_geometry(cl, tg_cookie);
5184 #endif
5185
5186 #else
5187 if (rval == 0) {
5188 /*
5189 * mboot has been written successfully.
5190 * set up the default geometry and VTOC
5191 */
5192 if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
5193 cmlb_setup_default_geometry(cl, tg_cookie);
5194 }
5195 #endif
5196 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
5197 mutex_exit(CMLB_MUTEX(cl));
5198 kmem_free(mboot, cl->cl_sys_blocksize);
5199 return (rval);
5200 }
5201
5202
5203 #if defined(__i386) || defined(__amd64)
5204 /*ARGSUSED*/
5205 static int
5206 cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
5207 void *tg_cookie)
5208 {
5209 int fdisk_rval;
5210 diskaddr_t capacity;
5211
5212 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5213
5214 mutex_enter(CMLB_MUTEX(cl));
5215 capacity = cl->cl_blockcount;
5216 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5217 if (fdisk_rval != 0) {
5218 mutex_exit(CMLB_MUTEX(cl));
5219 return (fdisk_rval);
5220 }
5221
5222 mutex_exit(CMLB_MUTEX(cl));
5223 return (fdisk_rval);
5224 }
5225 #endif
5226
5227 /*
5228 * Function: cmlb_setup_default_geometry
5229 *
5230 * Description: This local utility routine sets the default geometry as part of
5231 * setting the device mboot.
5232 *
5233 * Arguments:
5234 * cl driver soft state (unit) structure
5235 *
5236 * tg_cookie cookie from target driver to be passed back to target
5237 * driver when we call back to it through tg_ops.
5238 *
5239 *
5240 * Note: This may be redundant with cmlb_build_default_label.
5241 */
5242 static void
5243 cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie)
5244 {
5245 struct cmlb_geom pgeom;
5246 struct cmlb_geom *pgeomp = &pgeom;
5247 int ret;
5248 int geom_base_cap = 1;
5249
5250
5251 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5252
5253 /* zero out the soft state geometry and partition table. */
5254 bzero(&cl->cl_g, sizeof (struct dk_geom));
5255 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
5256 bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
5257
5258 /*
5259 * For the rpm, we use the minimum for the disk.
5260 * For the head, cyl and number of sector per track,
5261 * if the capacity <= 1GB, head = 64, sect = 32.
5262 * else head = 255, sect 63
5263 * Note: the capacity should be equal to C*H*S values.
5264 * This will cause some truncation of size due to
5265 * round off errors. For CD-ROMs, this truncation can
5266 * have adverse side effects, so returning ncyl and
5267 * nhead as 1. The nsect will overflow for most of
5268 * CD-ROMs as nsect is of type ushort.
5269 */
5270 if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
5271 /*
5272 * newfs currently can not handle 255 ntracks for SPARC
5273 * so get the geometry from target driver instead of coming up
5274 * with one based on capacity.
5275 */
5276 mutex_exit(CMLB_MUTEX(cl));
5277 ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
5278 mutex_enter(CMLB_MUTEX(cl));
5279
5280 if (ret == 0) {
5281 geom_base_cap = 0;
5282 } else {
5283 cmlb_dbg(CMLB_ERROR, cl,
5284 "cmlb_setup_default_geometry: "
5285 "tg_getphygeom failed %d\n", ret);
5286
5287 /* do default setting, geometry based on capacity */
5288 }
5289 }
5290
5291 if (geom_base_cap) {
5292 if (ISCD(cl)) {
5293 cl->cl_g.dkg_ncyl = 1;
5294 cl->cl_g.dkg_nhead = 1;
5295 cl->cl_g.dkg_nsect = cl->cl_blockcount;
5296 } else if (cl->cl_blockcount < 160) {
5297 /* Less than 80K */
5298 cl->cl_g.dkg_nhead = 1;
5299 cl->cl_g.dkg_ncyl = cl->cl_blockcount;
5300 cl->cl_g.dkg_nsect = 1;
5301 } else if (cl->cl_blockcount <= 0x1000) {
5302 /* Needed for unlabeled SCSI floppies. */
5303 cl->cl_g.dkg_nhead = 2;
5304 cl->cl_g.dkg_ncyl = 80;
5305 cl->cl_g.dkg_pcyl = 80;
5306 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
5307 } else if (cl->cl_blockcount <= 0x200000) {
5308 cl->cl_g.dkg_nhead = 64;
5309 cl->cl_g.dkg_nsect = 32;
5310 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
5311 } else {
5312 cl->cl_g.dkg_nhead = 255;
5313
5314 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
5315 (UINT16_MAX * 255 * 63) - 1) /
5316 (UINT16_MAX * 255 * 63)) * 63;
5317
5318 if (cl->cl_g.dkg_nsect == 0)
5319 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
5320
5321 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
5322 (255 * cl->cl_g.dkg_nsect);
5323 }
5324
5325 cl->cl_g.dkg_acyl = 0;
5326 cl->cl_g.dkg_bcyl = 0;
5327 cl->cl_g.dkg_intrlv = 1;
5328 cl->cl_g.dkg_rpm = 200;
5329 if (cl->cl_g.dkg_pcyl == 0)
5330 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
5331 cl->cl_g.dkg_acyl;
5332 } else {
5333 cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
5334 cl->cl_g.dkg_acyl = pgeomp->g_acyl;
5335 cl->cl_g.dkg_nhead = pgeomp->g_nhead;
5336 cl->cl_g.dkg_nsect = pgeomp->g_nsect;
5337 cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
5338 cl->cl_g.dkg_rpm = pgeomp->g_rpm;
5339 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
5340 }
5341
5342 cl->cl_g.dkg_read_reinstruct = 0;
5343 cl->cl_g.dkg_write_reinstruct = 0;
5344 cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
5345 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
5346
5347 cl->cl_map['a'-'a'].dkl_cylno = 0;
5348 cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
5349
5350 cl->cl_map['c'-'a'].dkl_cylno = 0;
5351 cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
5352
5353 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
5354 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
5355 cl->cl_vtoc.v_nparts = V_NUMPAR;
5356 cl->cl_vtoc.v_version = V_VERSION;
5357 (void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
5358 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
5359 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
5360
5361 cl->cl_f_geometry_is_valid = B_FALSE;
5362 }
5363
5364
5365 #if defined(__i386) || defined(__amd64)
5366 /*
5367 * Function: cmlb_update_fdisk_and_vtoc
5368 *
5369 * Description: This local utility routine updates the device fdisk and vtoc
5370 * as part of setting the device mboot.
5371 *
5372 * Arguments:
5373 * cl driver soft state (unit) structure
5374 *
5375 * tg_cookie cookie from target driver to be passed back to target
5376 * driver when we call back to it through tg_ops.
5377 *
5378 *
5379 * Return Code: 0 for success or errno-type return code.
5380 *
5381 * Note:x86: This looks like a duplicate of cmlb_validate_geometry(), but
5382 * these did exist separately in x86 sd.c.
5383 */
5384 static int
5385 cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie)
5386 {
5387 int count;
5388 int label_rc = 0;
5389 int fdisk_rval;
5390 diskaddr_t capacity;
5391
5392 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5393
5394 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
5395 return (EINVAL);
5396
5397 /*
5398 * Set up the "whole disk" fdisk partition; this should always
5399 * exist, regardless of whether the disk contains an fdisk table
5400 * or vtoc.
5401 */
5402 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
5403 cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
5404
5405 /*
5406 * copy the lbasize and capacity so that if they're
5407 * reset while we're not holding the CMLB_MUTEX(cl), we will
5408 * continue to use valid values after the CMLB_MUTEX(cl) is
5409 * reacquired.
5410 */
5411 capacity = cl->cl_blockcount;
5412
5413 /*
5414 * refresh the logical and physical geometry caches.
5415 * (data from mode sense format/rigid disk geometry pages,
5416 * and scsi_ifgetcap("geometry").
5417 */
5418 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
5419
5420 /*
5421 * Only DIRECT ACCESS devices will have Scl labels.
5422 * CD's supposedly have a Scl label, too
5423 */
5424 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
5425 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5426 if (fdisk_rval != 0) {
5427 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5428 return (fdisk_rval);
5429 }
5430
5431 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
5432 /*
5433 * Found fdisk table but no Solaris partition entry,
5434 * so don't call cmlb_uselabel() and don't create
5435 * a default label.
5436 */
5437 label_rc = 0;
5438 cl->cl_f_geometry_is_valid = B_TRUE;
5439 goto no_solaris_partition;
5440 }
5441 } else if (capacity < 0) {
5442 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5443 return (EINVAL);
5444 }
5445
5446 /*
5447 * For Removable media We reach here if we have found a
5448 * SOLARIS PARTITION.
5449 * If cl_f_geometry_is_valid is B_FALSE it indicates that the SOLARIS
5450 * PARTITION has changed from the previous one, hence we will setup a
5451 * default VTOC in this case.
5452 */
5453 if (!cl->cl_f_geometry_is_valid) {
5454 /* if we get here it is writable */
5455 /* we are called from SMBOOT, and after a write of fdisk */
5456 cmlb_build_default_label(cl, tg_cookie);
5457 label_rc = 0;
5458 }
5459
5460 no_solaris_partition:
5461
5462 #if defined(_SUNOS_VTOC_16)
5463 /*
5464 * If we have valid geometry, set up the remaining fdisk partitions.
5465 * Note that dkl_cylno is not used for the fdisk map entries, so
5466 * we set it to an entirely bogus value.
5467 */
5468 for (count = 0; count < FDISK_PARTS; count++) {
5469 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX;
5470 cl->cl_map[FDISK_P1 + count].dkl_nblk =
5471 cl->cl_fmap[count].fmap_nblk;
5472 cl->cl_offset[FDISK_P1 + count] =
5473 cl->cl_fmap[count].fmap_start;
5474 }
5475 #endif
5476
5477 for (count = 0; count < NDKMAP; count++) {
5478 #if defined(_SUNOS_VTOC_8)
5479 struct dk_map *lp = &cl->cl_map[count];
5480 cl->cl_offset[count] =
5481 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
5482 #elif defined(_SUNOS_VTOC_16)
5483 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
5484 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
5485 #else
5486 #error "No VTOC format defined."
5487 #endif
5488 }
5489
5490 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5491 return (label_rc);
5492 }
5493 #endif
5494
5495 #if defined(__i386) || defined(__amd64)
5496 static int
5497 cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag)
5498 {
5499 int err = 0;
5500
5501 /* Return the driver's notion of the media's logical geometry */
5502 struct dk_geom disk_geom;
5503 struct dk_geom *dkgp = &disk_geom;
5504
5505 mutex_enter(CMLB_MUTEX(cl));
5506 /*
5507 * If there is no HBA geometry available, or
5508 * if the HBA returned us something that doesn't
5509 * really fit into an Int 13/function 8 geometry
5510 * result, just fail the ioctl. See PSARC 1998/313.
5511 */
5512 if (cl->cl_lgeom.g_nhead == 0 ||
5513 cl->cl_lgeom.g_nsect == 0 ||
5514 cl->cl_lgeom.g_ncyl > 1024) {
5515 mutex_exit(CMLB_MUTEX(cl));
5516 err = EINVAL;
5517 } else {
5518 dkgp->dkg_ncyl = cl->cl_lgeom.g_ncyl;
5519 dkgp->dkg_acyl = cl->cl_lgeom.g_acyl;
5520 dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
5521 dkgp->dkg_nhead = cl->cl_lgeom.g_nhead;
5522 dkgp->dkg_nsect = cl->cl_lgeom.g_nsect;
5523
5524 mutex_exit(CMLB_MUTEX(cl));
5525 if (ddi_copyout(dkgp, (void *)arg,
5526 sizeof (struct dk_geom), flag)) {
5527 err = EFAULT;
5528 } else {
5529 err = 0;
5530 }
5531 }
5532 return (err);
5533 }
5534 #endif
5535
5536 #if defined(__i386) || defined(__amd64)
5537 static int
5538 cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag,
5539 void *tg_cookie)
5540 {
5541 int err = 0;
5542 diskaddr_t capacity;
5543
5544
5545 /* Return the driver's notion of the media physical geometry */
5546 struct dk_geom disk_geom;
5547 struct dk_geom *dkgp = &disk_geom;
5548
5549 mutex_enter(CMLB_MUTEX(cl));
5550
5551 if (cl->cl_g.dkg_nhead != 0 &&
5552 cl->cl_g.dkg_nsect != 0) {
5553 /*
5554 * We succeeded in getting a geometry, but
5555 * right now it is being reported as just the
5556 * Solaris fdisk partition, just like for
5557 * DKIOCGGEOM. We need to change that to be
5558 * correct for the entire disk now.
5559 */
5560 bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
5561 dkgp->dkg_acyl = 0;
5562 dkgp->dkg_ncyl = cl->cl_blockcount /
5563 (dkgp->dkg_nhead * dkgp->dkg_nsect);
5564 } else {
5565 bzero(dkgp, sizeof (struct dk_geom));
5566 /*
5567 * This disk does not have a Solaris VTOC
5568 * so we must present a physical geometry
5569 * that will remain consistent regardless
5570 * of how the disk is used. This will ensure
5571 * that the geometry does not change regardless
5572 * of the fdisk partition type (ie. EFI, FAT32,
5573 * Solaris, etc).
5574 */
5575 if (ISCD(cl)) {
5576 dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
5577 dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
5578 dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
5579 dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
5580 } else {
5581 /*
5582 * Invalid cl_blockcount can generate invalid
5583 * dk_geom and may result in division by zero
5584 * system failure. Should make sure blockcount
5585 * is valid before using it here.
5586 */
5587 if (cl->cl_blockcount == 0) {
5588 mutex_exit(CMLB_MUTEX(cl));
5589 err = EIO;
5590 return (err);
5591 }
5592 /*
5593 * Refer to comments related to off-by-1 at the
5594 * header of this file
5595 */
5596 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
5597 capacity = cl->cl_blockcount - 1;
5598 else
5599 capacity = cl->cl_blockcount;
5600
5601 cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie);
5602 dkgp->dkg_acyl = 0;
5603 dkgp->dkg_ncyl = capacity /
5604 (dkgp->dkg_nhead * dkgp->dkg_nsect);
5605 }
5606 }
5607 dkgp->dkg_pcyl = dkgp->dkg_ncyl + dkgp->dkg_acyl;
5608
5609 mutex_exit(CMLB_MUTEX(cl));
5610 if (ddi_copyout(dkgp, (void *)arg, sizeof (struct dk_geom), flag))
5611 err = EFAULT;
5612
5613 return (err);
5614 }
5615 #endif
5616
5617 #if defined(__i386) || defined(__amd64)
5618 static int
5619 cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag)
5620 {
5621 int err = 0;
5622
5623 /*
5624 * Return parameters describing the selected disk slice.
5625 * Note: this ioctl is for the intel platform only
5626 */
5627 int part;
5628
5629 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5630 part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
5631 else
5632 part = CMLBPART(dev);
5633
5634 mutex_enter(CMLB_MUTEX(cl));
5635 /* don't check cl_solaris_size for pN */
5636 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5637 err = EIO;
5638 mutex_exit(CMLB_MUTEX(cl));
5639 } else {
5640 struct part_info p;
5641
5642 p.p_start = (daddr_t)cl->cl_offset[part];
5643 p.p_length = (int)cl->cl_map[part].dkl_nblk;
5644 mutex_exit(CMLB_MUTEX(cl));
5645 #ifdef _MULTI_DATAMODEL
5646 switch (ddi_model_convert_from(flag & FMODELS)) {
5647 case DDI_MODEL_ILP32:
5648 {
5649 struct part_info32 p32;
5650
5651 p32.p_start = (daddr32_t)p.p_start;
5652 p32.p_length = p.p_length;
5653 if (ddi_copyout(&p32, (void *)arg,
5654 sizeof (p32), flag))
5655 err = EFAULT;
5656 break;
5657 }
5658
5659 case DDI_MODEL_NONE:
5660 {
5661 if (ddi_copyout(&p, (void *)arg, sizeof (p),
5662 flag))
5663 err = EFAULT;
5664 break;
5665 }
5666 }
5667 #else /* ! _MULTI_DATAMODEL */
5668 if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
5669 err = EFAULT;
5670 #endif /* _MULTI_DATAMODEL */
5671 }
5672 return (err);
5673 }
5674 static int
5675 cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag)
5676 {
5677 int err = 0;
5678
5679 /*
5680 * Return parameters describing the selected disk slice.
5681 * Note: this ioctl is for the intel platform only
5682 */
5683 int part;
5684
5685 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5686 part = getminor(dev) & ((1 << CMLBUNIT_FORCE_P0_SHIFT) - 1);
5687 else
5688 part = CMLBPART(dev);
5689
5690 mutex_enter(CMLB_MUTEX(cl));
5691 /* don't check cl_solaris_size for pN */
5692 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5693 err = EIO;
5694 mutex_exit(CMLB_MUTEX(cl));
5695 } else {
5696 struct extpart_info p;
5697
5698 p.p_start = (diskaddr_t)cl->cl_offset[part];
5699 p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk;
5700 mutex_exit(CMLB_MUTEX(cl));
5701 if (ddi_copyout(&p, (void *)arg, sizeof (p), flag))
5702 err = EFAULT;
5703 }
5704 return (err);
5705 }
5706 #endif
5707
5708 int
5709 cmlb_prop_op(cmlb_handle_t cmlbhandle,
5710 dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
5711 char *name, caddr_t valuep, int *lengthp, int part, void *tg_cookie)
5712 {
5713 struct cmlb_lun *cl;
5714 diskaddr_t capacity;
5715 uint32_t lbasize;
5716 enum dp { DP_NBLOCKS, DP_BLKSIZE, DP_SSD, DP_ROT } dp;
5717 int callers_length;
5718 caddr_t buffer;
5719 uint64_t nblocks64;
5720 uint_t dblk;
5721 tg_attribute_t tgattr;
5722
5723 /* Always fallback to ddi_prop_op... */
5724 cl = (struct cmlb_lun *)cmlbhandle;
5725 if (cl == NULL) {
5726 fallback: return (ddi_prop_op(dev, dip, prop_op, mod_flags,
5727 name, valuep, lengthp));
5728 }
5729
5730 /* Pick up capacity and blocksize information. */
5731 capacity = cl->cl_blockcount;
5732 if (capacity == 0)
5733 goto fallback;
5734 lbasize = cl->cl_tgt_blocksize;
5735 if (lbasize == 0)
5736 lbasize = DEV_BSIZE; /* 0 -> DEV_BSIZE units */
5737
5738 /* Check for dynamic property of whole device. */
5739 if (dev == DDI_DEV_T_ANY) {
5740 /* Fallback to ddi_prop_op if we don't understand. */
5741 if (strcmp(name, "device-nblocks") == 0)
5742 dp = DP_NBLOCKS;
5743 else if (strcmp(name, "device-blksize") == 0)
5744 dp = DP_BLKSIZE;
5745 else if (strcmp(name, "device-solid-state") == 0)
5746 dp = DP_SSD;
5747 else if (strcmp(name, "device-rotational") == 0)
5748 dp = DP_ROT;
5749 else
5750 goto fallback;
5751
5752 /* get callers length, establish length of our dynamic prop */
5753 callers_length = *lengthp;
5754 if (dp == DP_NBLOCKS)
5755 *lengthp = sizeof (uint64_t);
5756 else if ((dp == DP_BLKSIZE) || (dp == DP_SSD))
5757 *lengthp = sizeof (uint32_t);
5758
5759 /* service request for the length of the property */
5760 if (prop_op == PROP_LEN)
5761 return (DDI_PROP_SUCCESS);
5762
5763 switch (prop_op) {
5764 case PROP_LEN_AND_VAL_ALLOC:
5765 if ((buffer = kmem_alloc(*lengthp,
5766 (mod_flags & DDI_PROP_CANSLEEP) ?
5767 KM_SLEEP : KM_NOSLEEP)) == NULL)
5768 return (DDI_PROP_NO_MEMORY);
5769 *(caddr_t *)valuep = buffer; /* set callers buf */
5770 break;
5771
5772 case PROP_LEN_AND_VAL_BUF:
5773 /* the length of the prop and the request must match */
5774 if (callers_length != *lengthp)
5775 return (DDI_PROP_INVAL_ARG);
5776 buffer = valuep; /* get callers buf */
5777 break;
5778
5779 default:
5780 return (DDI_PROP_INVAL_ARG);
5781 }
5782
5783 /* transfer the value into the buffer */
5784 switch (dp) {
5785 case DP_NBLOCKS:
5786 *((uint64_t *)buffer) = capacity;
5787 break;
5788 case DP_BLKSIZE:
5789 *((uint32_t *)buffer) = lbasize;
5790 break;
5791 case DP_SSD:
5792 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5793 tgattr.media_is_solid_state = B_FALSE;
5794 *((uint32_t *)buffer) =
5795 tgattr.media_is_solid_state ? 1 : 0;
5796 break;
5797 case DP_ROT:
5798 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5799 tgattr.media_is_rotational = B_TRUE;
5800 *((uint32_t *)buffer) =
5801 tgattr.media_is_rotational ? 1 : 0;
5802 break;
5803 }
5804 return (DDI_PROP_SUCCESS);
5805 }
5806
5807 /*
5808 * Support dynamic size oriented properties of partition. Requests
5809 * issued under conditions where size is valid are passed to
5810 * ddi_prop_op_nblocks with the size information, otherwise the
5811 * request is passed to ddi_prop_op. Size depends on valid geometry.
5812 */
5813 if (!cmlb_is_valid(cmlbhandle))
5814 goto fallback;
5815
5816 /* Get partition nblocks value. */
5817 (void) cmlb_partinfo(cmlbhandle, part,
5818 (diskaddr_t *)&nblocks64, NULL, NULL, NULL, tg_cookie);
5819
5820 /*
5821 * Assume partition information is in sys_blocksize units, compute
5822 * divisor for size(9P) property representation.
5823 */
5824 dblk = lbasize / cl->cl_sys_blocksize;
5825
5826 /* Now let ddi_prop_op_nblocks_blksize() handle the request. */
5827 return (ddi_prop_op_nblocks_blksize(dev, dip, prop_op, mod_flags,
5828 name, valuep, lengthp, nblocks64 / dblk, lbasize));
5829 }