Lines Matching refs:cl
290 static dev_t cmlb_make_device(struct cmlb_lun *cl);
291 static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid,
293 static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
295 static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
300 static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
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);
305 static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
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,
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);
319 static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
327 static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
331 static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
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,
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,
339 static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
341 static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
343 static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
345 static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
347 static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
349 static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
351 static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
353 static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
357 static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
359 static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart,
361 static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start,
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,
366 static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
368 static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
372 static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
409 cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...) in cmlb_dbg() argument
415 ASSERT(cl != NULL); in cmlb_dbg()
416 dev = CMLB_DEVINFO(cl); in cmlb_dbg()
433 ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) { in cmlb_dbg()
435 cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap); in cmlb_dbg()
537 struct cmlb_lun *cl; in cmlb_alloc_handle() local
539 cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP); in cmlb_alloc_handle()
542 cl->cl_state = CMLB_INITED; in cmlb_alloc_handle()
543 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; in cmlb_alloc_handle()
544 mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL); in cmlb_alloc_handle()
546 *cmlbhandlep = (cmlb_handle_t)(cl); in cmlb_alloc_handle()
560 struct cmlb_lun *cl; in cmlb_free_handle() local
562 cl = (struct cmlb_lun *)*cmlbhandlep; in cmlb_free_handle()
563 if (cl != NULL) { in cmlb_free_handle()
564 mutex_destroy(CMLB_MUTEX(cl)); in cmlb_free_handle()
565 kmem_free(cl, sizeof (struct cmlb_lun)); in cmlb_free_handle()
690 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_attach() local
700 mutex_enter(CMLB_MUTEX(cl)); in cmlb_attach()
702 CMLB_DEVINFO(cl) = devi; in cmlb_attach()
703 cl->cmlb_tg_ops = tgopsp; in cmlb_attach()
704 cl->cl_device_type = device_type; in cmlb_attach()
705 cl->cl_is_removable = is_removable; in cmlb_attach()
706 cl->cl_is_hotpluggable = is_hotpluggable; in cmlb_attach()
707 cl->cl_node_type = node_type; in cmlb_attach()
708 cl->cl_sys_blocksize = DEV_BSIZE; in cmlb_attach()
709 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_attach()
710 cl->cl_def_labeltype = CMLB_LABEL_VTOC; in cmlb_attach()
711 cl->cl_alter_behavior = alter_behavior; in cmlb_attach()
712 cl->cl_reserved = -1; in cmlb_attach()
713 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN; in cmlb_attach()
715 cl->cl_logical_drive_count = 0; in cmlb_attach()
719 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
720 status = DK_TG_GETCAP(cl, &cap, tg_cookie); in cmlb_attach()
721 mutex_enter(CMLB_MUTEX(cl)); in cmlb_attach()
724 cl->cl_def_labeltype = CMLB_LABEL_EFI; in cmlb_attach()
729 cl->cl_last_labeltype = CMLB_LABEL_UNDEF; in cmlb_attach()
730 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; in cmlb_attach()
732 if (cmlb_create_minor_nodes(cl) != 0) { in cmlb_attach()
733 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
738 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn); in cmlb_attach()
740 cl->cl_state = CMLB_ATTACHED; in cmlb_attach()
742 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
763 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_detach() local
765 mutex_enter(CMLB_MUTEX(cl)); in cmlb_detach()
766 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; in cmlb_detach()
767 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_detach()
768 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); in cmlb_detach()
769 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL); in cmlb_detach()
770 cl->cl_state = CMLB_INITED; in cmlb_detach()
771 mutex_exit(CMLB_MUTEX(cl)); in cmlb_detach()
806 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_validate() local
815 if (cl == NULL) in cmlb_validate()
818 mutex_enter(CMLB_MUTEX(cl)); in cmlb_validate()
819 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_validate()
820 mutex_exit(CMLB_MUTEX(cl)); in cmlb_validate()
828 if (cl->cl_f_geometry_is_valid) { in cmlb_validate()
829 cl->cl_cur_labeltype = CMLB_LABEL_EFI; in cmlb_validate()
837 cl->cl_cur_labeltype = CMLB_LABEL_VTOC; in cmlb_validate()
841 (void) cmlb_create_minor_nodes(cl); in cmlb_validate()
843 mutex_exit(CMLB_MUTEX(cl)); in cmlb_validate()
860 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_invalidate() local
862 if (cl == NULL) in cmlb_invalidate()
865 mutex_enter(CMLB_MUTEX(cl)); in cmlb_invalidate()
866 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_invalidate()
867 mutex_exit(CMLB_MUTEX(cl)); in cmlb_invalidate()
887 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_is_valid() local
892 return (cl->cl_f_geometry_is_valid); in cmlb_is_valid()
917 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_close() local
919 mutex_enter(CMLB_MUTEX(cl)); in cmlb_close()
920 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_close()
923 if (ISREMOVABLE(cl)) { in cmlb_close()
924 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; in cmlb_close()
925 (void) cmlb_create_minor_nodes(cl); in cmlb_close()
928 mutex_exit(CMLB_MUTEX(cl)); in cmlb_close()
957 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_get_devid_block() local
959 mutex_enter(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
960 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_get_devid_block()
961 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
965 if ((!cl->cl_f_geometry_is_valid) || in cmlb_get_devid_block()
966 (cl->cl_solaris_size < DK_LABEL_LOC)) { in cmlb_get_devid_block()
967 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
971 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) { in cmlb_get_devid_block()
972 if (cl->cl_reserved != -1) { in cmlb_get_devid_block()
973 blk = cl->cl_map[cl->cl_reserved].dkl_cylno; in cmlb_get_devid_block()
975 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
980 if (cl->cl_label_from_media != CMLB_LABEL_VTOC) { in cmlb_get_devid_block()
981 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
986 if (cl->cl_g.dkg_acyl < 2) { in cmlb_get_devid_block()
987 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
995 cyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl - 2; in cmlb_get_devid_block()
996 spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; in cmlb_get_devid_block()
997 head = cl->cl_g.dkg_nhead - 1; in cmlb_get_devid_block()
998 blk = cl->cl_solaris_offset + in cmlb_get_devid_block()
999 (cyl * (spc - cl->cl_g.dkg_apc)) + in cmlb_get_devid_block()
1000 (head * cl->cl_g.dkg_nsect) + 1; in cmlb_get_devid_block()
1004 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
1046 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_partinfo() local
1052 ASSERT(cl != NULL); in cmlb_partinfo()
1053 mutex_enter(CMLB_MUTEX(cl)); in cmlb_partinfo()
1054 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_partinfo()
1055 mutex_exit(CMLB_MUTEX(cl)); in cmlb_partinfo()
1062 if (!cl->cl_f_geometry_is_valid) in cmlb_partinfo()
1063 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, in cmlb_partinfo()
1066 if (((!cl->cl_f_geometry_is_valid) || in cmlb_partinfo()
1067 (part < NDKMAP && cl->cl_solaris_size == 0)) && in cmlb_partinfo()
1072 *startblockp = (diskaddr_t)cl->cl_offset[part]; in cmlb_partinfo()
1076 cl->cl_map[part].dkl_nblk; in cmlb_partinfo()
1080 ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) || in cmlb_partinfo()
1082 cl->cl_vtoc.v_part[part].p_tag; in cmlb_partinfo()
1101 mutex_exit(CMLB_MUTEX(cl)); in cmlb_partinfo()
1131 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_efi_label_capacity() local
1134 ASSERT(cl != NULL); in cmlb_efi_label_capacity()
1135 mutex_enter(CMLB_MUTEX(cl)); in cmlb_efi_label_capacity()
1136 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_efi_label_capacity()
1137 mutex_exit(CMLB_MUTEX(cl)); in cmlb_efi_label_capacity()
1141 if (!cl->cl_f_geometry_is_valid) in cmlb_efi_label_capacity()
1142 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE, in cmlb_efi_label_capacity()
1145 if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) || in cmlb_efi_label_capacity()
1146 (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) { in cmlb_efi_label_capacity()
1149 *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk; in cmlb_efi_label_capacity()
1153 mutex_exit(CMLB_MUTEX(cl)); in cmlb_efi_label_capacity()
1165 struct cmlb_lun *cl; in cmlb_ioctl() local
1167 cl = (struct cmlb_lun *)cmlbhandle; in cmlb_ioctl()
1169 ASSERT(cl != NULL); in cmlb_ioctl()
1171 mutex_enter(CMLB_MUTEX(cl)); in cmlb_ioctl()
1172 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_ioctl()
1173 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1190 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { in cmlb_ioctl()
1191 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1196 (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT, in cmlb_ioctl()
1204 if (cl->cl_label_from_media == CMLB_LABEL_EFI) { in cmlb_ioctl()
1206 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1209 (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) { in cmlb_ioctl()
1210 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1216 if (cl->cl_label_from_media == CMLB_LABEL_EFI) { in cmlb_ioctl()
1218 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1227 mutex_exit(CMLB_MUTEX(cl)); in cmlb_ioctl()
1231 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n"); in cmlb_ioctl()
1232 err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1236 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n"); in cmlb_ioctl()
1237 err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag); in cmlb_ioctl()
1241 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n"); in cmlb_ioctl()
1242 err = cmlb_dkio_get_partition(cl, (caddr_t)arg, in cmlb_ioctl()
1247 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n"); in cmlb_ioctl()
1248 err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag); in cmlb_ioctl()
1252 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n"); in cmlb_ioctl()
1253 err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1257 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n"); in cmlb_ioctl()
1258 err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1262 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n"); in cmlb_ioctl()
1263 err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1267 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n"); in cmlb_ioctl()
1268 err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1272 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n"); in cmlb_ioctl()
1273 err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag, in cmlb_ioctl()
1278 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n"); in cmlb_ioctl()
1279 err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag, in cmlb_ioctl()
1284 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n"); in cmlb_ioctl()
1285 err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1289 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n"); in cmlb_ioctl()
1290 err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1294 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n"); in cmlb_ioctl()
1295 err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1298 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n"); in cmlb_ioctl()
1300 err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1306 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n"); in cmlb_ioctl()
1308 err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag); in cmlb_ioctl()
1314 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO"); in cmlb_ioctl()
1316 err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag); in cmlb_ioctl()
1322 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO"); in cmlb_ioctl()
1324 err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag); in cmlb_ioctl()
1331 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART"); in cmlb_ioctl()
1332 err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie); in cmlb_ioctl()
1355 i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl), in cmlb_ioctl()
1356 i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl))); in cmlb_ioctl()
1363 cmlb_make_device(struct cmlb_lun *cl) in cmlb_make_device() argument
1365 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) { in cmlb_make_device()
1366 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)), in cmlb_make_device()
1368 CMLB_DEVINFO(cl)) << CMLBUNIT_FORCE_P0_SHIFT)); in cmlb_make_device()
1370 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)), in cmlb_make_device()
1371 ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT)); in cmlb_make_device()
1385 cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie) in cmlb_check_update_blockcount() argument
1391 ASSERT(mutex_owned(CMLB_MUTEX(cl))); in cmlb_check_update_blockcount()
1393 if (cl->cl_f_geometry_is_valid) in cmlb_check_update_blockcount()
1396 mutex_exit(CMLB_MUTEX(cl)); in cmlb_check_update_blockcount()
1397 status = DK_TG_GETCAP(cl, &capacity, tg_cookie); in cmlb_check_update_blockcount()
1399 mutex_enter(CMLB_MUTEX(cl)); in cmlb_check_update_blockcount()
1403 status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie); in cmlb_check_update_blockcount()
1404 mutex_enter(CMLB_MUTEX(cl)); in cmlb_check_update_blockcount()
1409 cl->cl_blockcount = capacity; in cmlb_check_update_blockcount()
1410 cl->cl_tgt_blocksize = lbasize; in cmlb_check_update_blockcount()
1411 if (!cl->cl_is_removable) { in cmlb_check_update_blockcount()
1412 cl->cl_sys_blocksize = lbasize; in cmlb_check_update_blockcount()
1451 cmlb_create_minor_nodes(struct cmlb_lun *cl) in cmlb_create_minor_nodes() argument
1459 ASSERT(cl != NULL); in cmlb_create_minor_nodes()
1460 ASSERT(mutex_owned(CMLB_MUTEX(cl))); in cmlb_create_minor_nodes()
1463 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0); in cmlb_create_minor_nodes()
1465 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) in cmlb_create_minor_nodes()
1471 if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF && in cmlb_create_minor_nodes()
1472 cl->cl_last_labeltype == cl->cl_cur_labeltype) { in cmlb_create_minor_nodes()
1477 if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) { in cmlb_create_minor_nodes()
1482 if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) { in cmlb_create_minor_nodes()
1484 newlabeltype = cl->cl_def_labeltype; in cmlb_create_minor_nodes()
1486 instance = ddi_get_instance(CMLB_DEVINFO(cl)); in cmlb_create_minor_nodes()
1495 if (cmlb_create_minor(CMLB_DEVINFO(cl), name, in cmlb_create_minor_nodes()
1498 cl->cl_node_type, 0, internal) == DDI_FAILURE) { in cmlb_create_minor_nodes()
1504 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); in cmlb_create_minor_nodes()
1509 cl->cl_last_labeltype = newlabeltype; in cmlb_create_minor_nodes()
1514 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE) { in cmlb_create_minor_nodes()
1515 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q", S_IFBLK, in cmlb_create_minor_nodes()
1517 cl->cl_node_type, 0, internal) == DDI_FAILURE) { in cmlb_create_minor_nodes()
1518 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); in cmlb_create_minor_nodes()
1522 if (cmlb_create_minor(CMLB_DEVINFO(cl), "q,raw", in cmlb_create_minor_nodes()
1525 cl->cl_node_type, 0, internal) == DDI_FAILURE) { in cmlb_create_minor_nodes()
1526 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); in cmlb_create_minor_nodes()
1535 if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) { in cmlb_create_minor_nodes()
1536 if (cl->cl_last_labeltype != cl->cl_def_labeltype) { in cmlb_create_minor_nodes()
1538 newlabeltype = cl->cl_def_labeltype; in cmlb_create_minor_nodes()
1547 if (cl->cl_cur_labeltype != cl->cl_last_labeltype) { in cmlb_create_minor_nodes()
1549 newlabeltype = cl->cl_cur_labeltype; in cmlb_create_minor_nodes()
1559 instance = ddi_get_instance(CMLB_DEVINFO(cl)); in cmlb_create_minor_nodes()
1567 cl->cl_last_labeltype != CMLB_LABEL_EFI) { in cmlb_create_minor_nodes()
1569 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h"); in cmlb_create_minor_nodes()
1570 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw"); in cmlb_create_minor_nodes()
1571 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd", in cmlb_create_minor_nodes()
1573 cl->cl_node_type, 0, internal); in cmlb_create_minor_nodes()
1574 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw", in cmlb_create_minor_nodes()
1576 cl->cl_node_type, 0, internal); in cmlb_create_minor_nodes()
1579 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd"); in cmlb_create_minor_nodes()
1580 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw"); in cmlb_create_minor_nodes()
1581 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h", in cmlb_create_minor_nodes()
1583 cl->cl_node_type, 0, internal); in cmlb_create_minor_nodes()
1584 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw", in cmlb_create_minor_nodes()
1586 cl->cl_node_type, 0, internal); in cmlb_create_minor_nodes()
1589 cl->cl_last_labeltype = newlabeltype; in cmlb_create_minor_nodes()
1620 cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags, argument
1627 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1630 if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) {
1631 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
1636 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
1639 capacity = cl->cl_blockcount;
1646 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
1647 cl->cl_offset[P0_RAW_DISK] = 0;
1652 cl->cl_map[P0_RAW_DISK].dkl_nblk = capacity;
1659 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
1661 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
1662 label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
1666 cmlb_dbg(CMLB_TRACE, cl,
1687 (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {
1689 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1694 CMLB_LABEL(cl),
1695 ddi_get_instance(CMLB_DEVINFO(cl)));
1697 cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
1715 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
1725 rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1726 if ((rval != 0) && !ISCD(cl)) {
1727 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1731 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
1738 cl->cl_f_geometry_is_valid = B_TRUE;
1742 label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1744 buffer_size = cl->cl_sys_blocksize;
1746 cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
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));
1763 if (cmlb_uselabel(cl,
1768 cl->cl_label_from_media = CMLB_LABEL_VTOC;
1791 if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1796 if (!cl->cl_f_geometry_is_valid) {
1797 cmlb_build_default_label(cl, tg_cookie);
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;
1815 cl->cl_offset[FDISK_P1 + count] =
1816 cl->cl_fmap[count].fmap_start;
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;
1826 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
1828 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
1848 cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity, argument
1852 ASSERT(cl != NULL);
1853 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1919 mutex_exit(CMLB_MUTEX(cl));
1921 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
1923 mutex_enter(CMLB_MUTEX(cl));
1964 cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity, argument
1975 ASSERT(cl != NULL);
1976 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1983 mutex_exit(CMLB_MUTEX(cl));
1985 ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1986 mutex_enter(CMLB_MUTEX(cl));
1988 bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
1994 if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1995 cl->cl_lgeom.g_nhead == 0) {
2005 nhead = cl->cl_lgeom.g_nhead;
2006 nsect = cl->cl_lgeom.g_nsect;
2009 if (ISCD(cl)) {
2035 mutex_exit(CMLB_MUTEX(cl));
2036 (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
2037 mutex_enter(CMLB_MUTEX(cl));
2043 bcopy(pgeomp, &cl->cl_pgeom, sizeof (cl->cl_pgeom));
2045 cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
2047 cmlb_dbg(CMLB_INFO, cl,
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);
2076 cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts) argument
2086 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2087 ASSERT(cl->cl_update_ext_minor_nodes == 1);
2090 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
2091 instance = ddi_get_instance(CMLB_DEVINFO(cl));
2095 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
2100 if (cl->cl_logical_drive_count) {
2101 for (i = 0; i < cl->cl_logical_drive_count; i++) {
2103 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2105 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2111 (void) ddi_deviname(cl->cl_devi, devnm);
2112 pdip = ddi_get_parent(cl->cl_devi);
2122 if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
2125 cl->cl_node_type, 0, internal) == DDI_FAILURE) {
2131 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2132 cl->cl_logical_drive_count = 0;
2136 if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
2139 cl->cl_node_type, 0) == DDI_FAILURE) {
2145 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2146 cl->cl_logical_drive_count = 0;
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;
2162 cl->cl_logical_drive_count = i;
2163 cl->cl_update_ext_minor_nodes = 0;
2204 cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start, argument
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;
2238 ts = cl->cl_fmap[FD_NUMPART].fmap_start;
2239 te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1;
2251 ts = cl->cl_fmap[i].fmap_start;
2252 te = ts + cl->cl_fmap[i].fmap_nblk - 1;
2286 cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie) argument
2293 int sec_sz = cl->cl_sys_blocksize;
2297 ASSERT(cl != NULL);
2298 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2309 mutex_exit(CMLB_MUTEX(cl));
2310 rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC,
2312 mutex_enter(CMLB_MUTEX(cl));
2314 cmlb_dbg(CMLB_ERROR, cl,
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));
2340 cmlb_dbg(CMLB_ERROR, cl,
2380 cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie) argument
2384 cl->cl_solaris_offset = 0;
2385 cl->cl_solaris_size = capacity;
2386 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2411 ASSERT(cl != NULL);
2412 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2420 blocksize = cl->cl_tgt_blocksize;
2424 mutex_exit(CMLB_MUTEX(cl));
2425 rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
2426 mutex_enter(CMLB_MUTEX(cl));
2429 cmlb_dbg(CMLB_ERROR, cl,
2431 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2470 dev_t dev = cmlb_make_device(cl);
2472 if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
2475 if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
2478 cmlb_dbg(CMLB_ERROR, cl,
2481 ddi_get_instance(CMLB_DEVINFO(cl)));
2493 cmlb_dbg(CMLB_ERROR, cl,
2495 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2502 cmlb_dbg(CMLB_INFO, cl, "cmlb_read_fdisk:\n");
2503 cmlb_dbg(CMLB_INFO, cl, " relsect "
2506 cmlb_dbg(CMLB_INFO, cl,
2534 cl->cl_fmap[i].fmap_start = 0;
2535 cl->cl_fmap[i].fmap_nblk = 0;
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);
2561 mutex_exit(CMLB_MUTEX(cl));
2562 rval = DK_TG_READ(cl, bufp,
2565 mutex_enter(CMLB_MUTEX(cl));
2568 cmlb_dbg(CMLB_ERROR, cl,
2593 if (cmlb_validate_ext_part(cl, i, j, abs_secnum,
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)) {
2606 cl->cl_update_ext_minor_nodes = 1;
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;
2614 (cmlb_is_linux_swap(cl, abs_secnum,
2648 (cmlb_is_linux_swap(cl, relsect,
2660 if (ld_count < cl->cl_logical_drive_count) {
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;
2671 cl->cl_update_ext_minor_nodes = 1;
2673 if (cl->cl_update_ext_minor_nodes) {
2674 rval = cmlb_update_ext_minor_nodes(cl, ld_count);
2680 cmlb_dbg(CMLB_INFO, cl, "fdisk 0x%x 0x%lx",
2681 cl->cl_solaris_offset, cl->cl_solaris_size);
2689 if ((cl->cl_solaris_offset != solaris_offset) ||
2690 (cl->cl_solaris_size != solaris_size) ||
2692 cmlb_dbg(CMLB_INFO, cl, "fdisk moved 0x%x 0x%lx",
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;
2699 cl->cl_solaris_offset = solaris_offset;
2700 cl->cl_solaris_size = solaris_size;
2802 cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags, argument
2820 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2822 lbasize = cl->cl_sys_blocksize;
2824 cl->cl_reserved = -1;
2825 mutex_exit(CMLB_MUTEX(cl));
2829 rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie);
2856 rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
2869 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
2880 if ((rval = DK_TG_READ(cl, buf,
2881 cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2891 if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2893 if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2901 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2909 rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
2921 mutex_enter(CMLB_MUTEX(cl));
2927 cl->cl_map[i].dkl_cylno =
2929 cl->cl_map[i].dkl_nblk =
2932 cl->cl_offset[i] =
2936 if (cl->cl_reserved == -1) {
2939 cl->cl_reserved = i;
2949 cl->cl_map[i].dkl_cylno = 0;
2956 cl->cl_map[i].dkl_nblk = capacity;
2958 cl->cl_map[i].dkl_nblk = alternate_lba + 1;
2960 cl->cl_offset[i] = 0;
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;
2970 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2977 mutex_enter(CMLB_MUTEX(cl));
2988 cl->cl_f_geometry_is_valid = B_FALSE;
3014 cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags) argument
3027 ASSERT(cl != NULL);
3028 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3033 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3035 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3053 if (!ISCD(cl)) {
3055 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3058 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
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;
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;
3083 cl->cl_dkg_skew = labp->dkl_skew;
3087 cl->cl_g.dkg_apc = labp->dkl_apc;
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);
3105 cl->cl_g.dkg_read_reinstruct = labp->dkl_read_reinstruct;
3106 cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
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;
3122 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3129 cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
3130 cl->cl_map[i].dkl_nblk = vpartp->p_size;
3135 bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
3141 bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
3145 track_capacity = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
3146 label_capacity = (cl->cl_g.dkg_ncyl * track_capacity);
3148 if (cl->cl_g.dkg_acyl) {
3151 label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
3164 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3172 cl->cl_f_geometry_is_valid = B_TRUE;
3182 if (label_capacity <= cl->cl_blockcount) {
3191 cmlb_dbg(CMLB_ERROR, cl,
3193 label_capacity, cl->cl_blockcount);
3194 cl->cl_solaris_size = label_capacity;
3200 if (ISCD(cl)) {
3209 (part_end > cl->cl_blockcount)) {
3210 cl->cl_f_geometry_is_valid = B_FALSE;
3220 (part_end > cl->cl_blockcount)) {
3221 cl->cl_f_geometry_is_valid = B_FALSE;
3229 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3231 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
3233 label_capacity, cl->cl_blockcount);
3235 cl->cl_f_geometry_is_valid = B_FALSE;
3241 cmlb_dbg(CMLB_INFO, cl, "cmlb_uselabel: (label geometry)\n");
3242 cmlb_dbg(CMLB_INFO, cl,
3244 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3245 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
3247 cmlb_dbg(CMLB_INFO, cl,
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);
3253 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3269 cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie) argument
3278 ASSERT(cl != NULL);
3279 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3288 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
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)));
3314 cl->cl_solaris_size = cl->cl_blockcount;
3315 if (ISCD(cl)) {
3335 mutex_exit(CMLB_MUTEX(cl));
3337 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
3339 mutex_enter(CMLB_MUTEX(cl));
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;
3348 cl->cl_g.dkg_ncyl = 1;
3349 cl->cl_g.dkg_nhead = 1;
3350 cl->cl_g.dkg_nsect = cl->cl_blockcount;
3353 if (cl->cl_blockcount < 160) {
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) {
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);
3368 cl->cl_g.dkg_nhead = 255;
3370 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
3374 if (cl->cl_g.dkg_nsect == 0)
3375 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
3377 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
3378 (255 * cl->cl_g.dkg_nsect);
3381 cl->cl_solaris_size =
3382 (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
3383 cl->cl_g.dkg_nsect;
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;
3393 cl->cl_map[0].dkl_cylno = 0;
3394 cl->cl_map[0].dkl_nblk = cl->cl_solaris_size;
3396 cl->cl_map[2].dkl_cylno = 0;
3397 cl->cl_map[2].dkl_nblk = cl->cl_solaris_size;
3401 if (cl->cl_solaris_size == 0) {
3406 cl->cl_f_geometry_is_valid = B_TRUE;
3416 if (ISCD(cl)) {
3417 phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
3429 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
3430 capacity = cl->cl_blockcount - 1;
3432 capacity = cl->cl_blockcount;
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;
3442 cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
3443 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3445 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
3446 disksize = cl->cl_solaris_size;
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;
3453 if (ISCD(cl)) {
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;
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;
3469 cl->cl_map[0].dkl_cylno = 0;
3470 cl->cl_map[0].dkl_nblk = disksize;
3471 cl->cl_offset[0] = 0;
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;
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;
3487 cl->cl_map[8].dkl_cylno = 0;
3488 cl->cl_map[8].dkl_nblk = phys_spc;
3489 cl->cl_offset[8] = 0;
3491 if ((cl->cl_alter_behavior &
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;
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;
3505 cl->cl_g.dkg_apc = 0;
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;
3513 cl->cl_map[2].dkl_cylno = 0;
3514 cl->cl_map[2].dkl_nblk = disksize;
3515 cl->cl_offset[2] = 0;
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;
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);
3538 cl->cl_g.dkg_read_reinstruct = 0;
3539 cl->cl_g.dkg_write_reinstruct = 0;
3541 cl->cl_g.dkg_intrlv = 1;
3543 cl->cl_vtoc.v_sanity = VTOC_SANE;
3544 cl->cl_vtoc.v_nparts = V_NUMPAR;
3545 cl->cl_vtoc.v_version = V_VERSION;
3547 cl->cl_f_geometry_is_valid = B_TRUE;
3548 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
3550 cmlb_dbg(CMLB_INFO, cl,
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);
3612 cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag, argument
3623 mutex_enter(CMLB_MUTEX(cl));
3624 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3627 cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
3633 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3634 cmlb_setup_default_geometry(cl, tg_cookie);
3640 mutex_exit(CMLB_MUTEX(cl));
3645 if (cl->cl_solaris_size == 0) {
3646 mutex_exit(CMLB_MUTEX(cl));
3657 bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
3664 mutex_exit(CMLB_MUTEX(cl));
3701 cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag) argument
3710 if (cl->cl_solaris_size == 0) {
3727 mutex_enter(CMLB_MUTEX(cl));
3728 bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
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;
3734 cl->cl_offset[i] += cl->cl_solaris_offset;
3737 cl->cl_f_geometry_is_valid = B_FALSE;
3738 mutex_exit(CMLB_MUTEX(cl));
3766 cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag, argument
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));
3781 mutex_exit(CMLB_MUTEX(cl));
3784 if (cl->cl_solaris_size == 0) {
3796 dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3797 dk_map32[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
3808 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3816 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3844 cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag) argument
3861 mutex_enter(CMLB_MUTEX(cl));
3863 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3864 mutex_exit(CMLB_MUTEX(cl));
3867 mutex_exit(CMLB_MUTEX(cl));
3868 if (cl->cl_solaris_size == 0) {
3904 mutex_enter(CMLB_MUTEX(cl));
3906 bcopy(dk_map, cl->cl_map, size);
3908 vp = (struct dkl_partition *)&(cl->cl_vtoc);
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;
3915 vp->p_start = cl->cl_offset[i];
3920 cl->cl_offset[i] += cl->cl_solaris_offset;
3923 mutex_exit(CMLB_MUTEX(cl));
3951 cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
3958 mutex_enter(CMLB_MUTEX(cl));
3959 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3960 mutex_exit(CMLB_MUTEX(cl));
3964 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3968 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
3974 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3975 cmlb_setup_default_geometry(cl, tg_cookie);
3981 mutex_exit(CMLB_MUTEX(cl));
3986 cmlb_build_user_vtoc(cl, &user_vtoc);
3987 mutex_exit(CMLB_MUTEX(cl));
4016 mutex_exit(CMLB_MUTEX(cl));
4028 ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
4031 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
4032 sizeof (cl->cl_vtoc), flag)) {
4040 vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
4049 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
4066 cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag, argument
4076 mutex_enter(CMLB_MUTEX(cl));
4077 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
4081 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
4087 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
4088 cmlb_setup_default_geometry(cl, tg_cookie);
4094 mutex_exit(CMLB_MUTEX(cl));
4099 cmlb_build_user_vtoc(cl, &user_vtoc);
4100 mutex_exit(CMLB_MUTEX(cl));
4128 vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
4129 mutex_exit(CMLB_MUTEX(cl));
4146 cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
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));
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));
4177 rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
4197 cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) argument
4205 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
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];
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;
4222 user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
4230 lmap = cl->cl_map;
4231 lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
4234 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4246 user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
4249 bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
4254 cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag, argument
4270 buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4271 rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie);
4290 n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t);
4292 rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie);
4313 kmem_free(buffer, cl->cl_sys_blocksize);
4343 cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4351 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4353 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4385 mutex_enter(CMLB_MUTEX(cl));
4387 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
4388 mutex_exit(CMLB_MUTEX(cl));
4393 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4394 mutex_exit(CMLB_MUTEX(cl));
4399 if (cl->cl_g.dkg_ncyl == 0) {
4400 mutex_exit(CMLB_MUTEX(cl));
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");
4415 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4416 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4418 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4420 cl->cl_node_type, 0, internal);
4421 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4423 cl->cl_node_type, 0, internal);
4424 mutex_enter(CMLB_MUTEX(cl));
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,
4430 cmlb_dbg(CMLB_ERROR, cl,
4434 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
4437 mutex_exit(CMLB_MUTEX(cl));
4445 cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4452 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
4479 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4480 mutex_enter(CMLB_MUTEX(cl));
4482 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4483 mutex_exit(CMLB_MUTEX(cl));
4488 if (cl->cl_g.dkg_ncyl == 0) {
4489 mutex_exit(CMLB_MUTEX(cl));
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");
4503 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4504 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4506 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4508 cl->cl_node_type, 0, internal);
4509 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4511 cl->cl_node_type, 0, internal);
4513 mutex_enter(CMLB_MUTEX(cl));
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,
4519 cmlb_dbg(CMLB_ERROR, cl,
4525 mutex_exit(CMLB_MUTEX(cl));
4543 cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) argument
4554 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4558 user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
4560 cmlb_dbg(CMLB_INFO, cl,
4565 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4567 cmlb_dbg(CMLB_INFO, cl,
4576 cmlb_dbg(CMLB_INFO, cl,
4587 if (ncyl > (int)cl->cl_g.dkg_ncyl) {
4588 cmlb_dbg(CMLB_INFO, cl,
4592 ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
4608 vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
4614 lmap = cl->cl_map;
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];
4628 cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
4629 cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
4631 bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
4633 cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
4636 cl->cl_vtoc.v_reserved[i] = user_vtoc->v_reserved[i];
4643 lmap = cl->cl_map;
4644 lpart = cl->cl_vtoc.v_part;
4660 cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
4662 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4665 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4669 bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
4689 cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie) argument
4695 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
4697 mutex_enter(CMLB_MUTEX(cl));
4698 cl->cl_reserved = -1;
4699 mutex_exit(CMLB_MUTEX(cl));
4701 gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4703 if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) {
4712 if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize,
4714 cmlb_dbg(CMLB_INFO, cl,
4719 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
4724 if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4732 cmlb_dbg(CMLB_TRACE, cl,
4735 if ((rval = DK_TG_WRITE(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4737 cmlb_dbg(CMLB_INFO, cl,
4745 if ((rval = DK_TG_READ(cl, gpt, cap - 2,
4746 cl->cl_sys_blocksize, tg_cookie)) != 0) {
4753 cmlb_dbg(CMLB_TRACE, cl,
4757 if ((rval = DK_TG_WRITE(cl, gpt, cap - 2,
4758 cl->cl_sys_blocksize, tg_cookie))) {
4759 cmlb_dbg(CMLB_INFO, cl,
4767 kmem_free(gpt, cl->cl_sys_blocksize);
4786 cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie) argument
4796 label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
4802 rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
4831 blk += cl->cl_solaris_offset;
4833 rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
4835 cmlb_dbg(CMLB_INFO, cl,
4859 cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie) argument
4863 mutex_exit(CMLB_MUTEX(cl));
4864 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4865 mutex_enter(CMLB_MUTEX(cl));
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);
4879 mutex_enter(CMLB_MUTEX(cl));
4902 cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie) argument
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));
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;
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;
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;
4933 bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
4935 dkl->dkl_skew = cl->cl_dkg_skew;
4941 dkl->dkl_write_reinstruct = cl->cl_g.dkg_write_reinstruct;
4942 dkl->dkl_read_reinstruct = cl->cl_g.dkg_read_reinstruct;
4953 mutex_exit(CMLB_MUTEX(cl));
4955 rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
4957 kmem_free(dkl, cl->cl_sys_blocksize);
4958 mutex_enter(CMLB_MUTEX(cl));
4969 cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4982 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4984 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
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));
5004 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
5006 cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
5007 mutex_exit(CMLB_MUTEX(cl));
5017 mutex_enter(CMLB_MUTEX(cl));
5018 if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
5019 cmlb_dbg(CMLB_TRACE, cl,
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",
5030 cl->cl_node_type, 0, internal);
5031 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
5034 cl->cl_node_type, 0, internal);
5036 mutex_exit(CMLB_MUTEX(cl));
5038 rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
5042 mutex_enter(CMLB_MUTEX(cl));
5043 cl->cl_f_geometry_is_valid = B_FALSE;
5044 mutex_exit(CMLB_MUTEX(cl));
5073 cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
5081 if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
5091 buffer_size = cl->cl_sys_blocksize;
5093 cmlb_dbg(CMLB_TRACE, cl,
5097 if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
5131 cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
5138 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5141 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
5150 mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
5153 cl->cl_sys_blocksize, flag) != 0) {
5154 kmem_free(mboot, cl->cl_sys_blocksize);
5161 kmem_free(mboot, cl->cl_sys_blocksize);
5165 rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
5167 mutex_enter(CMLB_MUTEX(cl));
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);
5183 cmlb_setup_default_geometry(cl, tg_cookie);
5192 if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
5193 cmlb_setup_default_geometry(cl, tg_cookie);
5196 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
5197 mutex_exit(CMLB_MUTEX(cl));
5198 kmem_free(mboot, cl->cl_sys_blocksize);
5206 cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag, argument
5212 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5214 mutex_enter(CMLB_MUTEX(cl));
5215 capacity = cl->cl_blockcount;
5216 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5218 mutex_exit(CMLB_MUTEX(cl));
5222 mutex_exit(CMLB_MUTEX(cl));
5243 cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie) argument
5251 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
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)));
5270 if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
5276 mutex_exit(CMLB_MUTEX(cl));
5277 ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
5278 mutex_enter(CMLB_MUTEX(cl));
5283 cmlb_dbg(CMLB_ERROR, cl,
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) {
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) {
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);
5312 cl->cl_g.dkg_nhead = 255;
5314 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
5318 if (cl->cl_g.dkg_nsect == 0)
5319 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
5321 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
5322 (255 * cl->cl_g.dkg_nsect);
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;
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;
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;
5347 cl->cl_map['a'-'a'].dkl_cylno = 0;
5348 cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
5350 cl->cl_map['c'-'a'].dkl_cylno = 0;
5351 cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
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);
5361 cl->cl_f_geometry_is_valid = B_FALSE;
5385 cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie) argument
5392 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5394 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
5402 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
5403 cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
5411 capacity = cl->cl_blockcount;
5418 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
5424 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
5425 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5427 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5431 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
5438 cl->cl_f_geometry_is_valid = B_TRUE;
5442 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5453 if (!cl->cl_f_geometry_is_valid) {
5456 cmlb_build_default_label(cl, tg_cookie);
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;
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;
5483 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
5484 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
5490 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5497 cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag) argument
5505 mutex_enter(CMLB_MUTEX(cl));
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));
5518 dkgp->dkg_ncyl = cl->cl_lgeom.g_ncyl;
5519 dkgp->dkg_acyl = cl->cl_lgeom.g_acyl;
5521 dkgp->dkg_nhead = cl->cl_lgeom.g_nhead;
5522 dkgp->dkg_nsect = cl->cl_lgeom.g_nsect;
5524 mutex_exit(CMLB_MUTEX(cl));
5538 cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag, argument
5549 mutex_enter(CMLB_MUTEX(cl));
5551 if (cl->cl_g.dkg_nhead != 0 &&
5552 cl->cl_g.dkg_nsect != 0) {
5560 bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
5562 dkgp->dkg_ncyl = cl->cl_blockcount /
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;
5587 if (cl->cl_blockcount == 0) {
5588 mutex_exit(CMLB_MUTEX(cl));
5596 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
5597 capacity = cl->cl_blockcount - 1;
5599 capacity = cl->cl_blockcount;
5601 cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie);
5609 mutex_exit(CMLB_MUTEX(cl));
5619 cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) argument
5629 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5634 mutex_enter(CMLB_MUTEX(cl));
5636 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5638 mutex_exit(CMLB_MUTEX(cl));
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));
5675 cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) argument
5685 if (cl->cl_alter_behavior & CMLB_CREATE_P0_MINOR_NODE)
5690 mutex_enter(CMLB_MUTEX(cl));
5692 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5694 mutex_exit(CMLB_MUTEX(cl));
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));
5713 struct cmlb_lun *cl; local
5724 cl = (struct cmlb_lun *)cmlbhandle;
5725 if (cl == NULL) {
5731 capacity = cl->cl_blockcount;
5734 lbasize = cl->cl_tgt_blocksize;
5792 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5798 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5824 dblk = lbasize / cl->cl_sys_blocksize;