Lines Matching refs:cl
288 static dev_t cmlb_make_device(struct cmlb_lun *cl);
289 static int cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid,
291 static void cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity,
293 static int cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity,
298 static int cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags,
300 static void cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie);
301 static int cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *l, int flags);
303 static void cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
305 static int cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc);
306 static int cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie);
307 static int cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl,
309 static void cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie);
310 static void cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie);
311 static void cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie);
312 static int cmlb_create_minor_nodes(struct cmlb_lun *cl);
313 static int cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie);
317 static int cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie);
325 static void cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity,
329 static int cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag,
331 static int cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag);
332 static int cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
334 static int cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag);
335 static int cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag,
337 static int cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
339 static int cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
341 static int cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag,
343 static int cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
345 static int cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
347 static int cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
349 static int cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag,
351 static int cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag,
355 static int cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag,
357 static int cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart,
359 static int cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start,
361 static int cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag);
362 static int cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag,
364 static int cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
366 static int cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg,
370 static void cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...);
407 cmlb_dbg(uint_t comp, struct cmlb_lun *cl, const char *fmt, ...) in cmlb_dbg() argument
413 ASSERT(cl != NULL); in cmlb_dbg()
414 dev = CMLB_DEVINFO(cl); in cmlb_dbg()
431 ((cmlb_debug_cl == NULL) || (cmlb_debug_cl == cl))) { in cmlb_dbg()
433 cmlb_v_log(dev, CMLB_LABEL(cl), CE_CONT, fmt, ap); in cmlb_dbg()
535 struct cmlb_lun *cl; in cmlb_alloc_handle() local
537 cl = kmem_zalloc(sizeof (struct cmlb_lun), KM_SLEEP); in cmlb_alloc_handle()
540 cl->cl_state = CMLB_INITED; in cmlb_alloc_handle()
541 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; in cmlb_alloc_handle()
542 mutex_init(CMLB_MUTEX(cl), NULL, MUTEX_DRIVER, NULL); in cmlb_alloc_handle()
544 *cmlbhandlep = (cmlb_handle_t)(cl); in cmlb_alloc_handle()
558 struct cmlb_lun *cl; in cmlb_free_handle() local
560 cl = (struct cmlb_lun *)*cmlbhandlep; in cmlb_free_handle()
561 if (cl != NULL) { in cmlb_free_handle()
562 mutex_destroy(CMLB_MUTEX(cl)); in cmlb_free_handle()
563 kmem_free(cl, sizeof (struct cmlb_lun)); in cmlb_free_handle()
685 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_attach() local
695 mutex_enter(CMLB_MUTEX(cl)); in cmlb_attach()
697 CMLB_DEVINFO(cl) = devi; in cmlb_attach()
698 cl->cmlb_tg_ops = tgopsp; in cmlb_attach()
699 cl->cl_device_type = device_type; in cmlb_attach()
700 cl->cl_is_removable = is_removable; in cmlb_attach()
701 cl->cl_is_hotpluggable = is_hotpluggable; in cmlb_attach()
702 cl->cl_node_type = node_type; in cmlb_attach()
703 cl->cl_sys_blocksize = DEV_BSIZE; in cmlb_attach()
704 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_attach()
705 cl->cl_def_labeltype = CMLB_LABEL_VTOC; in cmlb_attach()
706 cl->cl_alter_behavior = alter_behavior; in cmlb_attach()
707 cl->cl_reserved = -1; in cmlb_attach()
708 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN; in cmlb_attach()
710 cl->cl_logical_drive_count = 0; in cmlb_attach()
714 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
715 status = DK_TG_GETCAP(cl, &cap, tg_cookie); in cmlb_attach()
716 mutex_enter(CMLB_MUTEX(cl)); in cmlb_attach()
719 cl->cl_def_labeltype = CMLB_LABEL_EFI; in cmlb_attach()
724 cl->cl_last_labeltype = CMLB_LABEL_UNDEF; in cmlb_attach()
725 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; in cmlb_attach()
727 if (cmlb_create_minor_nodes(cl) != 0) { in cmlb_attach()
728 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
733 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), cmlb_prop_dyn); in cmlb_attach()
735 cl->cl_state = CMLB_ATTACHED; in cmlb_attach()
737 mutex_exit(CMLB_MUTEX(cl)); in cmlb_attach()
758 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_detach() local
760 mutex_enter(CMLB_MUTEX(cl)); in cmlb_detach()
761 cl->cl_def_labeltype = CMLB_LABEL_UNDEF; in cmlb_detach()
762 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_detach()
763 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL); in cmlb_detach()
764 i_ddi_prop_dyn_driver_set(CMLB_DEVINFO(cl), NULL); in cmlb_detach()
765 cl->cl_state = CMLB_INITED; in cmlb_detach()
766 mutex_exit(CMLB_MUTEX(cl)); in cmlb_detach()
801 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_validate() local
810 if (cl == NULL) in cmlb_validate()
813 mutex_enter(CMLB_MUTEX(cl)); in cmlb_validate()
814 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_validate()
815 mutex_exit(CMLB_MUTEX(cl)); in cmlb_validate()
823 if (cl->cl_f_geometry_is_valid) { in cmlb_validate()
824 cl->cl_cur_labeltype = CMLB_LABEL_EFI; in cmlb_validate()
832 cl->cl_cur_labeltype = CMLB_LABEL_VTOC; in cmlb_validate()
836 (void) cmlb_create_minor_nodes(cl); in cmlb_validate()
838 mutex_exit(CMLB_MUTEX(cl)); in cmlb_validate()
855 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_invalidate() local
857 if (cl == NULL) in cmlb_invalidate()
860 mutex_enter(CMLB_MUTEX(cl)); in cmlb_invalidate()
861 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_invalidate()
862 mutex_exit(CMLB_MUTEX(cl)); in cmlb_invalidate()
882 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_is_valid() local
887 return (cl->cl_f_geometry_is_valid); in cmlb_is_valid()
912 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_close() local
914 mutex_enter(CMLB_MUTEX(cl)); in cmlb_close()
915 cl->cl_f_geometry_is_valid = B_FALSE; in cmlb_close()
918 if (ISREMOVABLE(cl)) { in cmlb_close()
919 cl->cl_cur_labeltype = CMLB_LABEL_UNDEF; in cmlb_close()
920 (void) cmlb_create_minor_nodes(cl); in cmlb_close()
923 mutex_exit(CMLB_MUTEX(cl)); in cmlb_close()
952 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; in cmlb_get_devid_block() local
954 mutex_enter(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
955 if (cl->cl_state < CMLB_ATTACHED) { in cmlb_get_devid_block()
956 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
960 if ((!cl->cl_f_geometry_is_valid) || in cmlb_get_devid_block()
961 (cl->cl_solaris_size < DK_LABEL_LOC)) { in cmlb_get_devid_block()
962 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
966 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI) { in cmlb_get_devid_block()
967 if (cl->cl_reserved != -1) { in cmlb_get_devid_block()
968 blk = cl->cl_map[cl->cl_reserved].dkl_cylno; in cmlb_get_devid_block()
970 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
975 if (cl->cl_label_from_media != CMLB_LABEL_VTOC) { in cmlb_get_devid_block()
976 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
981 if (cl->cl_g.dkg_acyl < 2) { in cmlb_get_devid_block()
982 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
990 cyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl - 2; in cmlb_get_devid_block()
991 spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect; in cmlb_get_devid_block()
992 head = cl->cl_g.dkg_nhead - 1; in cmlb_get_devid_block()
993 blk = cl->cl_solaris_offset + in cmlb_get_devid_block()
994 (cyl * (spc - cl->cl_g.dkg_apc)) + in cmlb_get_devid_block()
995 (head * cl->cl_g.dkg_nsect) + 1; in cmlb_get_devid_block()
999 mutex_exit(CMLB_MUTEX(cl)); in cmlb_get_devid_block()
1041 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; local
1047 ASSERT(cl != NULL);
1048 mutex_enter(CMLB_MUTEX(cl));
1049 if (cl->cl_state < CMLB_ATTACHED) {
1050 mutex_exit(CMLB_MUTEX(cl));
1057 if (!cl->cl_f_geometry_is_valid)
1058 (void) cmlb_validate_geometry((struct cmlb_lun *)cl,
1062 if (((!cl->cl_f_geometry_is_valid) ||
1063 (part < NDKMAP && cl->cl_solaris_size == 0)) &&
1066 if ((!cl->cl_f_geometry_is_valid) ||
1067 (part < NDKMAP && cl->cl_solaris_size == 0)) {
1072 *startblockp = (diskaddr_t)cl->cl_offset[part];
1076 cl->cl_map[part].dkl_nblk;
1080 ((cl->cl_cur_labeltype == CMLB_LABEL_EFI) ||
1082 cl->cl_vtoc.v_part[part].p_tag;
1101 mutex_exit(CMLB_MUTEX(cl));
1131 struct cmlb_lun *cl = (struct cmlb_lun *)cmlbhandle; local
1134 ASSERT(cl != NULL);
1135 mutex_enter(CMLB_MUTEX(cl));
1136 if (cl->cl_state < CMLB_ATTACHED) {
1137 mutex_exit(CMLB_MUTEX(cl));
1141 if (!cl->cl_f_geometry_is_valid)
1142 (void) cmlb_validate_geometry((struct cmlb_lun *)cl, B_FALSE,
1145 if ((!cl->cl_f_geometry_is_valid) || (capacity == NULL) ||
1146 (cl->cl_cur_labeltype != CMLB_LABEL_EFI)) {
1149 *capacity = (diskaddr_t)cl->cl_map[WD_NODE].dkl_nblk;
1153 mutex_exit(CMLB_MUTEX(cl));
1165 struct cmlb_lun *cl; local
1167 cl = (struct cmlb_lun *)cmlbhandle;
1169 ASSERT(cl != NULL);
1171 mutex_enter(CMLB_MUTEX(cl));
1172 if (cl->cl_state < CMLB_ATTACHED) {
1173 mutex_exit(CMLB_MUTEX(cl));
1190 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1191 mutex_exit(CMLB_MUTEX(cl));
1196 (void) cmlb_validate_geometry(cl, 1, CMLB_SILENT,
1204 if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1206 mutex_exit(CMLB_MUTEX(cl));
1209 (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
1210 mutex_exit(CMLB_MUTEX(cl));
1216 if (cl->cl_label_from_media == CMLB_LABEL_EFI) {
1218 mutex_exit(CMLB_MUTEX(cl));
1227 mutex_exit(CMLB_MUTEX(cl));
1231 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGGEOM\n");
1232 err = cmlb_dkio_get_geometry(cl, (caddr_t)arg, flag, tg_cookie);
1236 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSGEOM\n");
1237 err = cmlb_dkio_set_geometry(cl, (caddr_t)arg, flag);
1241 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGAPART\n");
1242 err = cmlb_dkio_get_partition(cl, (caddr_t)arg,
1247 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSAPART\n");
1248 err = cmlb_dkio_set_partition(cl, (caddr_t)arg, flag);
1252 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1253 err = cmlb_dkio_get_vtoc(cl, (caddr_t)arg, flag, tg_cookie);
1257 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGVTOC\n");
1258 err = cmlb_dkio_get_extvtoc(cl, (caddr_t)arg, flag, tg_cookie);
1262 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGETEFI\n");
1263 err = cmlb_dkio_get_efi(cl, (caddr_t)arg, flag, tg_cookie);
1267 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTITION\n");
1268 err = cmlb_dkio_partition(cl, (caddr_t)arg, flag, tg_cookie);
1272 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1273 err = cmlb_dkio_set_vtoc(cl, dev, (caddr_t)arg, flag,
1278 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSVTOC\n");
1279 err = cmlb_dkio_set_extvtoc(cl, dev, (caddr_t)arg, flag,
1284 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEFI\n");
1285 err = cmlb_dkio_set_efi(cl, dev, (caddr_t)arg, flag, tg_cookie);
1289 cmlb_dbg(CMLB_TRACE, cl, "DKIOCGMBOOT\n");
1290 err = cmlb_dkio_get_mboot(cl, (caddr_t)arg, flag, tg_cookie);
1294 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSMBOOT\n");
1295 err = cmlb_dkio_set_mboot(cl, (caddr_t)arg, flag, tg_cookie);
1298 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_PHYGEOM\n");
1300 err = cmlb_dkio_get_phygeom(cl, (caddr_t)arg, flag, tg_cookie);
1306 cmlb_dbg(CMLB_TRACE, cl, "DKIOCG_VIRTGEOM\n");
1308 err = cmlb_dkio_get_virtgeom(cl, (caddr_t)arg, flag);
1314 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
1316 err = cmlb_dkio_partinfo(cl, dev, (caddr_t)arg, flag);
1322 cmlb_dbg(CMLB_TRACE, cl, "DKIOCPARTINFO");
1324 err = cmlb_dkio_extpartinfo(cl, dev, (caddr_t)arg, flag);
1331 cmlb_dbg(CMLB_TRACE, cl, "DKIOCSETEXTPART");
1332 err = cmlb_dkio_set_ext_part(cl, (caddr_t)arg, flag, tg_cookie);
1355 i_ddi_prop_dyn_cache_invalidate(CMLB_DEVINFO(cl),
1356 i_ddi_prop_dyn_driver_get(CMLB_DEVINFO(cl)));
1363 cmlb_make_device(struct cmlb_lun *cl) argument
1365 return (makedevice(ddi_driver_major(CMLB_DEVINFO(cl)),
1366 ddi_get_instance(CMLB_DEVINFO(cl)) << CMLBUNIT_SHIFT));
1379 cmlb_check_update_blockcount(struct cmlb_lun *cl, void *tg_cookie) argument
1385 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1387 if (cl->cl_f_geometry_is_valid)
1390 mutex_exit(CMLB_MUTEX(cl));
1391 status = DK_TG_GETCAP(cl, &capacity, tg_cookie);
1393 mutex_enter(CMLB_MUTEX(cl));
1397 status = DK_TG_GETBLOCKSIZE(cl, &lbasize, tg_cookie);
1398 mutex_enter(CMLB_MUTEX(cl));
1403 cl->cl_blockcount = capacity;
1404 cl->cl_tgt_blocksize = lbasize;
1405 if (!cl->cl_is_removable) {
1406 cl->cl_sys_blocksize = lbasize;
1445 cmlb_create_minor_nodes(struct cmlb_lun *cl) argument
1453 ASSERT(cl != NULL);
1454 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1457 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
1460 if (cl->cl_cur_labeltype != CMLB_LABEL_UNDEF &&
1461 cl->cl_last_labeltype == cl->cl_cur_labeltype) {
1466 if (cl->cl_def_labeltype == CMLB_LABEL_UNDEF) {
1471 if (cl->cl_last_labeltype == CMLB_LABEL_UNDEF) {
1473 newlabeltype = cl->cl_def_labeltype;
1475 instance = ddi_get_instance(CMLB_DEVINFO(cl));
1484 if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
1487 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
1493 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
1498 cl->cl_last_labeltype = newlabeltype;
1503 if (cl->cl_cur_labeltype == CMLB_LABEL_UNDEF) {
1504 if (cl->cl_last_labeltype != cl->cl_def_labeltype) {
1506 newlabeltype = cl->cl_def_labeltype;
1515 if (cl->cl_cur_labeltype != cl->cl_last_labeltype) {
1517 newlabeltype = cl->cl_cur_labeltype;
1527 instance = ddi_get_instance(CMLB_DEVINFO(cl));
1535 cl->cl_last_labeltype != CMLB_LABEL_EFI) {
1537 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
1538 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
1539 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
1541 cl->cl_node_type, NULL, internal);
1542 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
1544 cl->cl_node_type, NULL, internal);
1547 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
1548 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
1549 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
1551 cl->cl_node_type, NULL, internal);
1552 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
1554 cl->cl_node_type, NULL, internal);
1557 cl->cl_last_labeltype = newlabeltype;
1588 cmlb_validate_geometry(struct cmlb_lun *cl, boolean_t forcerevalid, int flags, argument
1595 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1598 if ((cl->cl_f_geometry_is_valid) && (!forcerevalid)) {
1599 if (cl->cl_cur_labeltype == CMLB_LABEL_EFI)
1604 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
1607 capacity = cl->cl_blockcount;
1615 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
1616 cl->cl_offset[P0_RAW_DISK] = 0;
1621 cl->cl_map[P0_RAW_DISK].dkl_nblk = capacity;
1628 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
1630 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
1631 label_error = cmlb_use_efi(cl, capacity, flags, tg_cookie);
1635 cmlb_dbg(CMLB_TRACE, cl,
1656 (cl->cl_msglog_flag & CMLB_ALLOW_2TB_WARN)) {
1658 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
1663 CMLB_LABEL(cl),
1664 ddi_get_instance(CMLB_DEVINFO(cl)));
1666 cl->cl_msglog_flag &= ~CMLB_ALLOW_2TB_WARN;
1684 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
1694 rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
1695 if ((rval != 0) && !ISCD(cl)) {
1696 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1700 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
1707 cl->cl_f_geometry_is_valid = B_TRUE;
1711 label_addr = (daddr_t)(cl->cl_solaris_offset + DK_LABEL_LOC);
1713 buffer_size = cl->cl_sys_blocksize;
1715 cmlb_dbg(CMLB_TRACE, cl, "cmlb_validate_geometry: "
1722 mutex_exit(CMLB_MUTEX(cl));
1723 rval = DK_TG_READ(cl, dkl, label_addr, buffer_size, tg_cookie);
1724 mutex_enter(CMLB_MUTEX(cl));
1732 if (cmlb_uselabel(cl,
1737 cl->cl_label_from_media = CMLB_LABEL_VTOC;
1760 if ((ISREMOVABLE(cl) || ISHOTPLUGGABLE(cl)) &&
1765 if (!cl->cl_f_geometry_is_valid) {
1766 cmlb_build_default_label(cl, tg_cookie);
1780 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT16_MAX;
1781 cl->cl_map[FDISK_P1 + count].dkl_nblk =
1782 cl->cl_fmap[count].fmap_nblk;
1784 cl->cl_offset[FDISK_P1 + count] =
1785 cl->cl_fmap[count].fmap_start;
1791 struct dk_map *lp = &cl->cl_map[count];
1792 cl->cl_offset[count] =
1793 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
1795 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
1797 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
1817 cmlb_convert_geometry(struct cmlb_lun *cl, diskaddr_t capacity, argument
1821 ASSERT(cl != NULL);
1822 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1888 mutex_exit(CMLB_MUTEX(cl));
1890 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
1892 mutex_enter(CMLB_MUTEX(cl));
1933 cmlb_resync_geom_caches(struct cmlb_lun *cl, diskaddr_t capacity, argument
1944 ASSERT(cl != NULL);
1945 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
1952 mutex_exit(CMLB_MUTEX(cl));
1954 ret = DK_TG_GETVIRTGEOM(cl, &lgeom, tg_cookie);
1955 mutex_enter(CMLB_MUTEX(cl));
1957 bcopy(&lgeom, &cl->cl_lgeom, sizeof (cl->cl_lgeom));
1963 if (ret != 0 || cl->cl_lgeom.g_nsect == 0 ||
1964 cl->cl_lgeom.g_nhead == 0) {
1974 nhead = cl->cl_lgeom.g_nhead;
1975 nsect = cl->cl_lgeom.g_nsect;
1978 if (ISCD(cl)) {
2004 mutex_exit(CMLB_MUTEX(cl));
2005 (void) DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
2006 mutex_enter(CMLB_MUTEX(cl));
2012 bcopy(pgeomp, &cl->cl_pgeom, sizeof (cl->cl_pgeom));
2014 cmlb_dbg(CMLB_INFO, cl, "cmlb_resync_geom_caches: "
2016 cmlb_dbg(CMLB_INFO, cl,
2018 cl->cl_pgeom.g_ncyl, cl->cl_pgeom.g_acyl,
2019 cl->cl_pgeom.g_nhead, cl->cl_pgeom.g_nsect);
2020 cmlb_dbg(CMLB_INFO, cl, " lbasize: %d; capacity: %ld; "
2021 "intrlv: %d; rpm: %d\n", cl->cl_pgeom.g_secsize,
2022 cl->cl_pgeom.g_capacity, cl->cl_pgeom.g_intrlv,
2023 cl->cl_pgeom.g_rpm);
2045 cmlb_update_ext_minor_nodes(struct cmlb_lun *cl, int num_parts) argument
2055 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2056 ASSERT(cl->cl_update_ext_minor_nodes == 1);
2059 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
2060 instance = ddi_get_instance(CMLB_DEVINFO(cl));
2065 if (cl->cl_logical_drive_count) {
2066 for (i = 0; i < cl->cl_logical_drive_count; i++) {
2068 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2070 ddi_remove_minor_node(CMLB_DEVINFO(cl), name);
2076 (void) ddi_deviname(cl->cl_devi, devnm);
2077 pdip = ddi_get_parent(cl->cl_devi);
2087 if (cmlb_create_minor(CMLB_DEVINFO(cl), name,
2090 cl->cl_node_type, NULL, internal) == DDI_FAILURE) {
2096 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2097 cl->cl_logical_drive_count = 0;
2101 if (ddi_create_minor_node(CMLB_DEVINFO(cl), name,
2104 cl->cl_node_type, NULL) == DDI_FAILURE) {
2110 ddi_remove_minor_node(CMLB_DEVINFO(cl), NULL);
2111 cl->cl_logical_drive_count = 0;
2120 cl->cl_map[FDISK_P4 + 1 + count].dkl_cylno = UINT32_MAX;
2121 cl->cl_map[FDISK_P4 + 1 + count].dkl_nblk =
2122 cl->cl_fmap[FD_NUMPART + count].fmap_nblk;
2123 cl->cl_offset[FDISK_P4 + 1 + count] =
2124 cl->cl_fmap[FD_NUMPART + count].fmap_start;
2127 cl->cl_logical_drive_count = i;
2128 cl->cl_update_ext_minor_nodes = 0;
2169 cmlb_validate_ext_part(struct cmlb_lun *cl, int part, int epart, uint32_t start, argument
2174 uint32_t ext_start = cl->cl_fmap[part].fmap_start;
2175 uint32_t ext_end = ext_start + cl->cl_fmap[part].fmap_nblk - 1;
2203 ts = cl->cl_fmap[FD_NUMPART].fmap_start;
2204 te = ts + cl->cl_fmap[FD_NUMPART].fmap_nblk - 1;
2216 ts = cl->cl_fmap[i].fmap_start;
2217 te = ts + cl->cl_fmap[i].fmap_nblk - 1;
2251 cmlb_is_linux_swap(struct cmlb_lun *cl, uint32_t part_start, void *tg_cookie) argument
2258 int sec_sz = cl->cl_sys_blocksize;
2262 ASSERT(cl != NULL);
2263 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2274 mutex_exit(CMLB_MUTEX(cl));
2275 rval = DK_TG_READ(cl, buf, part_start + DK_LABEL_LOC,
2277 mutex_enter(CMLB_MUTEX(cl));
2279 cmlb_dbg(CMLB_ERROR, cl,
2300 mutex_exit(CMLB_MUTEX(cl));
2301 rval = DK_TG_READ(cl, buf, seek_offset, sec_sz, tg_cookie);
2302 mutex_enter(CMLB_MUTEX(cl));
2305 cmlb_dbg(CMLB_ERROR, cl,
2345 cmlb_read_fdisk(struct cmlb_lun *cl, diskaddr_t capacity, void *tg_cookie) argument
2349 cl->cl_solaris_offset = 0;
2350 cl->cl_solaris_size = capacity;
2351 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2376 ASSERT(cl != NULL);
2377 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2385 blocksize = cl->cl_tgt_blocksize;
2389 mutex_exit(CMLB_MUTEX(cl));
2390 rval = DK_TG_READ(cl, bufp, 0, blocksize, tg_cookie);
2391 mutex_enter(CMLB_MUTEX(cl));
2394 cmlb_dbg(CMLB_ERROR, cl,
2396 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2435 dev_t dev = cmlb_make_device(cl);
2437 if (ddi_getprop(dev, CMLB_DEVINFO(cl), DDI_PROP_DONTPASS,
2440 if (ddi_prop_create(dev, CMLB_DEVINFO(cl), 0,
2443 cmlb_dbg(CMLB_ERROR, cl,
2446 ddi_get_instance(CMLB_DEVINFO(cl)));
2458 cmlb_dbg(CMLB_ERROR, cl,
2460 bzero(cl->cl_fmap, sizeof (struct fmap) * FD_NUMPART);
2467 cmlb_dbg(CMLB_INFO, cl, "cmlb_read_fdisk:\n");
2468 cmlb_dbg(CMLB_INFO, cl, " relsect "
2471 cmlb_dbg(CMLB_INFO, cl,
2499 cl->cl_fmap[i].fmap_start = 0;
2500 cl->cl_fmap[i].fmap_nblk = 0;
2510 cl->cl_fmap[i].fmap_start = relsect;
2511 cl->cl_fmap[i].fmap_nblk = numsect;
2512 cl->cl_fmap[i].fmap_systid = LE_8(fdp->systid);
2526 mutex_exit(CMLB_MUTEX(cl));
2527 rval = DK_TG_READ(cl, bufp,
2530 mutex_enter(CMLB_MUTEX(cl));
2533 cmlb_dbg(CMLB_ERROR, cl,
2558 if (cmlb_validate_ext_part(cl, i, j, abs_secnum,
2563 if ((cl->cl_fmap[j].fmap_start != abs_secnum) ||
2564 (cl->cl_fmap[j].fmap_nblk != ext_numsect) ||
2565 (cl->cl_fmap[j].fmap_systid != systid)) {
2571 cl->cl_update_ext_minor_nodes = 1;
2573 cl->cl_fmap[j].fmap_start = abs_secnum;
2574 cl->cl_fmap[j].fmap_nblk = ext_numsect;
2575 cl->cl_fmap[j].fmap_systid = systid;
2579 (cmlb_is_linux_swap(cl, abs_secnum,
2613 (cmlb_is_linux_swap(cl, relsect,
2625 if (ld_count < cl->cl_logical_drive_count) {
2631 k < cl->cl_logical_drive_count + FD_NUMPART; k++) {
2632 cl->cl_fmap[k].fmap_start = 0;
2633 cl->cl_fmap[k].fmap_nblk = 0;
2634 cl->cl_fmap[k].fmap_systid = 0;
2636 cl->cl_update_ext_minor_nodes = 1;
2638 if (cl->cl_update_ext_minor_nodes) {
2639 rval = cmlb_update_ext_minor_nodes(cl, ld_count);
2645 cmlb_dbg(CMLB_INFO, cl, "fdisk 0x%x 0x%lx",
2646 cl->cl_solaris_offset, cl->cl_solaris_size);
2654 if ((cl->cl_solaris_offset != solaris_offset) ||
2655 (cl->cl_solaris_size != solaris_size) ||
2657 cmlb_dbg(CMLB_INFO, cl, "fdisk moved 0x%x 0x%lx",
2659 bzero(&cl->cl_g, sizeof (struct dk_geom));
2660 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2661 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
2662 cl->cl_f_geometry_is_valid = B_FALSE;
2664 cl->cl_solaris_offset = solaris_offset;
2665 cl->cl_solaris_size = solaris_size;
2767 cmlb_use_efi(struct cmlb_lun *cl, diskaddr_t capacity, int flags, argument
2785 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2787 lbasize = cl->cl_sys_blocksize;
2789 cl->cl_reserved = -1;
2790 mutex_exit(CMLB_MUTEX(cl));
2794 rval = DK_TG_READ(cl, buf, 0, lbasize, tg_cookie);
2821 rval = DK_TG_READ(cl, buf, 1, lbasize, tg_cookie);
2834 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
2845 if ((rval = DK_TG_READ(cl, buf,
2846 cap - ((cl->cl_alter_behavior & CMLB_OFF_BY_ONE) ? 2 : 1),
2856 if (!(cl->cl_alter_behavior & CMLB_OFF_BY_ONE))
2858 if ((rval = DK_TG_READ(cl, buf, cap - 1, lbasize,
2866 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
2874 rval = DK_TG_READ(cl, buf, gpe_lba, EFI_MIN_ARRAY_SIZE, tg_cookie);
2886 mutex_enter(CMLB_MUTEX(cl));
2892 cl->cl_map[i].dkl_cylno =
2894 cl->cl_map[i].dkl_nblk =
2897 cl->cl_offset[i] =
2901 if (cl->cl_reserved == -1) {
2904 cl->cl_reserved = i;
2914 cl->cl_map[i].dkl_cylno = 0;
2921 cl->cl_map[i].dkl_nblk = capacity;
2923 cl->cl_map[i].dkl_nblk = alternate_lba + 1;
2925 cl->cl_offset[i] = 0;
2929 cl->cl_solaris_offset = 0;
2930 cl->cl_solaris_size = capacity;
2931 cl->cl_label_from_media = CMLB_LABEL_EFI;
2932 cl->cl_f_geometry_is_valid = B_TRUE;
2935 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
2942 mutex_enter(CMLB_MUTEX(cl));
2953 cl->cl_f_geometry_is_valid = B_FALSE;
2979 cmlb_uselabel(struct cmlb_lun *cl, struct dk_label *labp, int flags) argument
2992 ASSERT(cl != NULL);
2993 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
2998 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3000 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3018 if (!ISCD(cl)) {
3020 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3023 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl),
3034 bzero(&cl->cl_g, sizeof (struct dk_geom));
3035 cl->cl_g.dkg_ncyl = labp->dkl_ncyl;
3036 cl->cl_g.dkg_acyl = labp->dkl_acyl;
3037 cl->cl_g.dkg_bcyl = 0;
3038 cl->cl_g.dkg_nhead = labp->dkl_nhead;
3039 cl->cl_g.dkg_nsect = labp->dkl_nsect;
3040 cl->cl_g.dkg_intrlv = labp->dkl_intrlv;
3043 cl->cl_g.dkg_gap1 = labp->dkl_gap1;
3044 cl->cl_g.dkg_gap2 = labp->dkl_gap2;
3045 cl->cl_g.dkg_bhead = labp->dkl_bhead;
3048 cl->cl_dkg_skew = labp->dkl_skew;
3052 cl->cl_g.dkg_apc = labp->dkl_apc;
3062 cl->cl_g.dkg_rpm = (labp->dkl_rpm != 0) ? labp->dkl_rpm : 3600;
3063 cl->cl_g.dkg_pcyl = (labp->dkl_pcyl != 0) ? labp->dkl_pcyl :
3064 (cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl);
3070 cl->cl_g.dkg_read_reinstruct = labp->dkl_read_reinstruct;
3071 cl->cl_g.dkg_write_reinstruct = labp->dkl_write_reinstruct;
3076 cl->cl_map[i].dkl_cylno = labp->dkl_map[i].dkl_cylno;
3077 cl->cl_map[i].dkl_nblk = labp->dkl_map[i].dkl_nblk;
3087 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3094 cl->cl_map[i].dkl_cylno = vpartp->p_start / track_capacity;
3095 cl->cl_map[i].dkl_nblk = vpartp->p_size;
3100 bcopy(&labp->dkl_vtoc, &cl->cl_vtoc, sizeof (struct dk_vtoc));
3106 bcopy(labp->dkl_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
3110 track_capacity = (cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect);
3111 label_capacity = (cl->cl_g.dkg_ncyl * track_capacity);
3113 if (cl->cl_g.dkg_acyl) {
3116 label_capacity += (track_capacity * cl->cl_g.dkg_acyl);
3129 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3137 cl->cl_f_geometry_is_valid = B_TRUE;
3147 if (label_capacity <= cl->cl_blockcount) {
3156 cmlb_dbg(CMLB_ERROR, cl,
3158 label_capacity, cl->cl_blockcount);
3159 cl->cl_solaris_size = label_capacity;
3165 if (ISCD(cl)) {
3174 (part_end > cl->cl_blockcount)) {
3175 cl->cl_f_geometry_is_valid = B_FALSE;
3185 (part_end > cl->cl_blockcount)) {
3186 cl->cl_f_geometry_is_valid = B_FALSE;
3194 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_WARN,
3196 cmlb_log(CMLB_DEVINFO(cl), CMLB_LABEL(cl), CE_CONT,
3198 label_capacity, cl->cl_blockcount);
3200 cl->cl_f_geometry_is_valid = B_FALSE;
3206 cmlb_dbg(CMLB_INFO, cl, "cmlb_uselabel: (label geometry)\n");
3207 cmlb_dbg(CMLB_INFO, cl,
3209 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3210 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
3212 cmlb_dbg(CMLB_INFO, cl,
3214 cl->cl_blockcount, cl->cl_g.dkg_intrlv, cl->cl_g.dkg_rpm);
3215 cmlb_dbg(CMLB_INFO, cl, " wrt_reinstr: %d; rd_reinstr: %d\n",
3216 cl->cl_g.dkg_write_reinstruct, cl->cl_g.dkg_read_reinstruct);
3218 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3234 cmlb_build_default_label(struct cmlb_lun *cl, void *tg_cookie) argument
3243 ASSERT(cl != NULL);
3244 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
3253 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
3258 bzero(&cl->cl_g, sizeof (struct dk_geom));
3259 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
3260 bzero(&cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
3279 cl->cl_solaris_size = cl->cl_blockcount;
3280 if (ISCD(cl)) {
3300 mutex_exit(CMLB_MUTEX(cl));
3302 (DK_TG_GETATTRIBUTE(cl, &tgattribute, tg_cookie) == 0) ?
3304 mutex_enter(CMLB_MUTEX(cl));
3307 cl->cl_g.dkg_nhead = 64;
3308 cl->cl_g.dkg_nsect = 32;
3309 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
3310 cl->cl_solaris_size = (diskaddr_t)cl->cl_g.dkg_ncyl *
3311 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
3313 cl->cl_g.dkg_ncyl = 1;
3314 cl->cl_g.dkg_nhead = 1;
3315 cl->cl_g.dkg_nsect = cl->cl_blockcount;
3318 if (cl->cl_blockcount < 160) {
3320 cl->cl_g.dkg_nhead = 1;
3321 cl->cl_g.dkg_ncyl = cl->cl_blockcount;
3322 cl->cl_g.dkg_nsect = 1;
3323 } else if (cl->cl_blockcount <= 0x1000) {
3325 cl->cl_g.dkg_nhead = 2;
3326 cl->cl_g.dkg_ncyl = 80;
3327 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
3328 } else if (cl->cl_blockcount <= 0x200000) {
3329 cl->cl_g.dkg_nhead = 64;
3330 cl->cl_g.dkg_nsect = 32;
3331 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
3333 cl->cl_g.dkg_nhead = 255;
3335 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
3339 if (cl->cl_g.dkg_nsect == 0)
3340 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
3342 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
3343 (255 * cl->cl_g.dkg_nsect);
3346 cl->cl_solaris_size =
3347 (diskaddr_t)cl->cl_g.dkg_ncyl * cl->cl_g.dkg_nhead *
3348 cl->cl_g.dkg_nsect;
3352 cl->cl_g.dkg_acyl = 0;
3353 cl->cl_g.dkg_bcyl = 0;
3354 cl->cl_g.dkg_rpm = 200;
3355 cl->cl_asciilabel[0] = '\0';
3356 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl;
3358 cl->cl_map[0].dkl_cylno = 0;
3359 cl->cl_map[0].dkl_nblk = cl->cl_solaris_size;
3361 cl->cl_map[2].dkl_cylno = 0;
3362 cl->cl_map[2].dkl_nblk = cl->cl_solaris_size;
3366 if (cl->cl_solaris_size == 0) {
3371 cl->cl_f_geometry_is_valid = B_TRUE;
3381 if (ISCD(cl)) {
3382 phys_spc = cl->cl_pgeom.g_nhead * cl->cl_pgeom.g_nsect;
3394 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
3395 capacity = cl->cl_blockcount - 1;
3397 capacity = cl->cl_blockcount;
3400 cmlb_convert_geometry(cl, capacity, &cl_g, tg_cookie);
3401 bcopy(&cl_g, &cl->cl_g, sizeof (cl->cl_g));
3402 phys_spc = cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
3407 cl->cl_g.dkg_pcyl = cl->cl_solaris_size / phys_spc;
3408 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3410 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl;
3411 disksize = cl->cl_solaris_size;
3413 cl->cl_g.dkg_acyl = DK_ACYL;
3414 cl->cl_g.dkg_ncyl = cl->cl_g.dkg_pcyl - DK_ACYL;
3415 disksize = cl->cl_g.dkg_ncyl * phys_spc;
3418 if (ISCD(cl)) {
3423 disksize = cl->cl_solaris_size;
3424 cl->cl_g.dkg_nhead = 1;
3425 cl->cl_g.dkg_nsect = 1;
3426 cl->cl_g.dkg_rpm =
3427 (cl->cl_pgeom.g_rpm == 0) ? 200 : cl->cl_pgeom.g_rpm;
3429 cl->cl_vtoc.v_part[0].p_start = 0;
3430 cl->cl_vtoc.v_part[0].p_size = disksize;
3431 cl->cl_vtoc.v_part[0].p_tag = V_BACKUP;
3432 cl->cl_vtoc.v_part[0].p_flag = V_UNMNT;
3434 cl->cl_map[0].dkl_cylno = 0;
3435 cl->cl_map[0].dkl_nblk = disksize;
3436 cl->cl_offset[0] = 0;
3442 cl->cl_g.dkg_rpm =
3443 (cl->cl_pgeom.g_rpm == 0) ? 3600: cl->cl_pgeom.g_rpm;
3444 cl->cl_vtoc.v_sectorsz = cl->cl_sys_blocksize;
3447 cl->cl_vtoc.v_part[8].p_start = 0;
3448 cl->cl_vtoc.v_part[8].p_size = phys_spc;
3449 cl->cl_vtoc.v_part[8].p_tag = V_BOOT;
3450 cl->cl_vtoc.v_part[8].p_flag = V_UNMNT;
3452 cl->cl_map[8].dkl_cylno = 0;
3453 cl->cl_map[8].dkl_nblk = phys_spc;
3454 cl->cl_offset[8] = 0;
3456 if ((cl->cl_alter_behavior &
3458 cl->cl_device_type == DTYPE_DIRECT) {
3459 cl->cl_vtoc.v_part[9].p_start = phys_spc;
3460 cl->cl_vtoc.v_part[9].p_size = 2 * phys_spc;
3461 cl->cl_vtoc.v_part[9].p_tag = V_ALTSCTR;
3462 cl->cl_vtoc.v_part[9].p_flag = 0;
3464 cl->cl_map[9].dkl_cylno = 1;
3465 cl->cl_map[9].dkl_nblk = 2 * phys_spc;
3466 cl->cl_offset[9] = phys_spc;
3470 cl->cl_g.dkg_apc = 0;
3473 cl->cl_vtoc.v_part[2].p_start = 0;
3474 cl->cl_vtoc.v_part[2].p_size = disksize;
3475 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
3476 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
3478 cl->cl_map[2].dkl_cylno = 0;
3479 cl->cl_map[2].dkl_nblk = disksize;
3480 cl->cl_offset[2] = 0;
3485 if (cl->cl_alter_behavior & CMLB_FAKE_LABEL_ONE_PARTITION) {
3486 cl->cl_vtoc.v_part[0].p_start = 0;
3487 cl->cl_vtoc.v_part[0].p_tag = V_UNASSIGNED;
3488 cl->cl_vtoc.v_part[0].p_flag = 0;
3489 cl->cl_vtoc.v_part[0].p_size = disksize;
3490 cl->cl_map[0].dkl_cylno = 0;
3491 cl->cl_map[0].dkl_nblk = disksize;
3492 cl->cl_offset[0] = 0;
3495 (void) sprintf(cl->cl_vtoc.v_asciilabel, "DEFAULT cyl %d alt %d"
3496 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
3497 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
3503 cl->cl_g.dkg_read_reinstruct = 0;
3504 cl->cl_g.dkg_write_reinstruct = 0;
3506 cl->cl_g.dkg_intrlv = 1;
3508 cl->cl_vtoc.v_sanity = VTOC_SANE;
3509 cl->cl_vtoc.v_nparts = V_NUMPAR;
3510 cl->cl_vtoc.v_version = V_VERSION;
3512 cl->cl_f_geometry_is_valid = B_TRUE;
3513 cl->cl_label_from_media = CMLB_LABEL_UNDEF;
3515 cmlb_dbg(CMLB_INFO, cl,
3518 cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl, cl->cl_g.dkg_nhead,
3519 cl->cl_g.dkg_nsect, cl->cl_blockcount);
3577 cmlb_dkio_get_geometry(struct cmlb_lun *cl, caddr_t arg, int flag, argument
3588 mutex_enter(CMLB_MUTEX(cl));
3589 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3592 cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
3598 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3599 cmlb_setup_default_geometry(cl, tg_cookie);
3605 mutex_exit(CMLB_MUTEX(cl));
3610 if (cl->cl_solaris_size == 0) {
3611 mutex_exit(CMLB_MUTEX(cl));
3622 bcopy(&cl->cl_g, tmp_geom, sizeof (struct dk_geom));
3629 mutex_exit(CMLB_MUTEX(cl));
3666 cmlb_dkio_set_geometry(struct cmlb_lun *cl, caddr_t arg, int flag) argument
3675 if (cl->cl_solaris_size == 0) {
3692 mutex_enter(CMLB_MUTEX(cl));
3693 bcopy(tmp_geom, &cl->cl_g, sizeof (struct dk_geom));
3695 lp = &cl->cl_map[i];
3696 cl->cl_offset[i] =
3697 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
3699 cl->cl_offset[i] += cl->cl_solaris_offset;
3702 cl->cl_f_geometry_is_valid = B_FALSE;
3703 mutex_exit(CMLB_MUTEX(cl));
3731 cmlb_dkio_get_partition(struct cmlb_lun *cl, caddr_t arg, int flag, argument
3741 mutex_enter(CMLB_MUTEX(cl));
3742 if ((rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie)) != 0) {
3743 mutex_exit(CMLB_MUTEX(cl));
3746 mutex_exit(CMLB_MUTEX(cl));
3749 if (cl->cl_solaris_size == 0) {
3761 dk_map32[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
3762 dk_map32[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
3773 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3781 rval = ddi_copyout(cl->cl_map, (void *)arg, size, flag);
3809 cmlb_dkio_set_partition(struct cmlb_lun *cl, caddr_t arg, int flag) argument
3826 mutex_enter(CMLB_MUTEX(cl));
3828 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3829 mutex_exit(CMLB_MUTEX(cl));
3832 mutex_exit(CMLB_MUTEX(cl));
3833 if (cl->cl_solaris_size == 0) {
3869 mutex_enter(CMLB_MUTEX(cl));
3871 bcopy(dk_map, cl->cl_map, size);
3873 vp = (struct dkl_partition *)&(cl->cl_vtoc);
3876 lp = &cl->cl_map[i];
3877 cl->cl_offset[i] =
3878 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
3880 vp->p_start = cl->cl_offset[i];
3885 cl->cl_offset[i] += cl->cl_solaris_offset;
3888 mutex_exit(CMLB_MUTEX(cl));
3916 cmlb_dkio_get_vtoc(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
3923 mutex_enter(CMLB_MUTEX(cl));
3924 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
3925 mutex_exit(CMLB_MUTEX(cl));
3929 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
3933 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
3939 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
3940 cmlb_setup_default_geometry(cl, tg_cookie);
3946 mutex_exit(CMLB_MUTEX(cl));
3951 cmlb_build_user_vtoc(cl, &user_vtoc);
3952 mutex_exit(CMLB_MUTEX(cl));
3981 mutex_exit(CMLB_MUTEX(cl));
3993 ASSERT(sizeof (cl->cl_vtoc) == sizeof (struct vtoc32));
3996 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg,
3997 sizeof (cl->cl_vtoc), flag)) {
4005 vtoc32tovtoc(cl->cl_vtoc, user_vtoc);
4014 if (ddi_copyout(&(cl->cl_vtoc), (void *)arg, sizeof (cl->cl_vtoc),
4031 cmlb_dkio_get_extvtoc(struct cmlb_lun *cl, caddr_t arg, int flag, argument
4041 mutex_enter(CMLB_MUTEX(cl));
4042 rval = cmlb_validate_geometry(cl, B_TRUE, 0, tg_cookie);
4046 (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8)) {
4052 if (cl->cl_blockcount <= CMLB_OLDVTOC_LIMIT) {
4053 cmlb_setup_default_geometry(cl, tg_cookie);
4059 mutex_exit(CMLB_MUTEX(cl));
4064 cmlb_build_user_vtoc(cl, &user_vtoc);
4065 mutex_exit(CMLB_MUTEX(cl));
4093 vtoc32tovtoc(cl->cl_vtoc, ext_vtoc);
4094 mutex_exit(CMLB_MUTEX(cl));
4111 cmlb_dkio_get_efi(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
4129 mutex_enter(CMLB_MUTEX(cl));
4130 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4131 (cl->cl_tgt_blocksize == 0) ||
4132 (user_efi.dki_length % cl->cl_sys_blocksize)) {
4133 mutex_exit(CMLB_MUTEX(cl));
4136 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
4137 tgt_lba = tgt_lba * cl->cl_tgt_blocksize /
4138 cl->cl_sys_blocksize;
4139 mutex_exit(CMLB_MUTEX(cl));
4142 rval = DK_TG_READ(cl, buffer, tgt_lba, user_efi.dki_length, tg_cookie);
4162 cmlb_build_user_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) argument
4170 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4177 user_vtoc->v_bootinfo[0] = cl->cl_vtoc.v_bootinfo[0];
4178 user_vtoc->v_bootinfo[1] = cl->cl_vtoc.v_bootinfo[1];
4179 user_vtoc->v_bootinfo[2] = cl->cl_vtoc.v_bootinfo[2];
4181 user_vtoc->v_version = cl->cl_vtoc.v_version;
4182 bcopy(cl->cl_vtoc.v_volume, user_vtoc->v_volume, LEN_DKL_VVOL);
4183 user_vtoc->v_sectorsz = cl->cl_sys_blocksize;
4184 user_vtoc->v_nparts = cl->cl_vtoc.v_nparts;
4187 user_vtoc->v_reserved[i] = cl->cl_vtoc.v_reserved[i];
4195 lmap = cl->cl_map;
4196 lpart = (struct dk_map2 *)cl->cl_vtoc.v_part;
4199 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4211 user_vtoc->timestamp[i] = (time_t)cl->cl_vtoc.v_timestamp[i];
4214 bcopy(cl->cl_asciilabel, user_vtoc->v_asciilabel, LEN_DKL_ASCII);
4219 cmlb_dkio_partition(struct cmlb_lun *cl, caddr_t arg, int flag, argument
4235 buffer = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4236 rval = DK_TG_READ(cl, buffer, 1, cl->cl_sys_blocksize, tg_cookie);
4255 n_gpe_per_blk = cl->cl_sys_blocksize / sizeof (efi_gpe_t);
4257 rval = DK_TG_READ(cl, buffer, gpe_lba, cl->cl_sys_blocksize, tg_cookie);
4278 kmem_free(buffer, cl->cl_sys_blocksize);
4308 cmlb_dkio_set_vtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4316 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4345 mutex_enter(CMLB_MUTEX(cl));
4347 if (cl->cl_blockcount > CMLB_OLDVTOC_LIMIT) {
4348 mutex_exit(CMLB_MUTEX(cl));
4353 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4354 mutex_exit(CMLB_MUTEX(cl));
4359 if (cl->cl_g.dkg_ncyl == 0) {
4360 mutex_exit(CMLB_MUTEX(cl));
4364 mutex_exit(CMLB_MUTEX(cl));
4365 cmlb_clear_efi(cl, tg_cookie);
4366 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4367 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
4375 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4376 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4378 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4380 cl->cl_node_type, NULL, internal);
4381 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4383 cl->cl_node_type, NULL, internal);
4384 mutex_enter(CMLB_MUTEX(cl));
4386 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4387 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
4388 if (cmlb_validate_geometry(cl,
4390 cmlb_dbg(CMLB_ERROR, cl,
4394 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
4397 mutex_exit(CMLB_MUTEX(cl));
4405 cmlb_dkio_set_extvtoc(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4435 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4436 mutex_enter(CMLB_MUTEX(cl));
4438 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize) {
4439 mutex_exit(CMLB_MUTEX(cl));
4444 if (cl->cl_g.dkg_ncyl == 0) {
4445 mutex_exit(CMLB_MUTEX(cl));
4449 mutex_exit(CMLB_MUTEX(cl));
4450 cmlb_clear_efi(cl, tg_cookie);
4451 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd");
4452 ddi_remove_minor_node(CMLB_DEVINFO(cl), "wd,raw");
4459 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4460 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4462 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h",
4464 cl->cl_node_type, NULL, internal);
4465 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "h,raw",
4467 cl->cl_node_type, NULL, internal);
4469 mutex_enter(CMLB_MUTEX(cl));
4471 if ((rval = cmlb_build_label_vtoc(cl, &user_vtoc)) == 0) {
4472 if ((rval = cmlb_write_label(cl, tg_cookie)) == 0) {
4473 if (cmlb_validate_geometry(cl,
4475 cmlb_dbg(CMLB_ERROR, cl,
4481 mutex_exit(CMLB_MUTEX(cl));
4499 cmlb_build_label_vtoc(struct cmlb_lun *cl, struct vtoc *user_vtoc) argument
4510 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4514 user_vtoc->v_sectorsz != cl->cl_sys_blocksize ||
4516 cmlb_dbg(CMLB_INFO, cl,
4521 nblks = cl->cl_g.dkg_nsect * cl->cl_g.dkg_nhead;
4523 cmlb_dbg(CMLB_INFO, cl,
4532 cmlb_dbg(CMLB_INFO, cl,
4543 if (ncyl > (int)cl->cl_g.dkg_ncyl) {
4544 cmlb_dbg(CMLB_INFO, cl,
4548 ncyl, cl->cl_g.dkg_ncyl, vpart->p_size,
4564 vtoctovtoc32((*user_vtoc), (*((struct vtoc32 *)&(cl->cl_vtoc))));
4570 lmap = cl->cl_map;
4580 cl->cl_vtoc.v_bootinfo[0] = (uint32_t)user_vtoc->v_bootinfo[0];
4581 cl->cl_vtoc.v_bootinfo[1] = (uint32_t)user_vtoc->v_bootinfo[1];
4582 cl->cl_vtoc.v_bootinfo[2] = (uint32_t)user_vtoc->v_bootinfo[2];
4584 cl->cl_vtoc.v_sanity = (uint32_t)user_vtoc->v_sanity;
4585 cl->cl_vtoc.v_version = (uint32_t)user_vtoc->v_version;
4587 bcopy(user_vtoc->v_volume, cl->cl_vtoc.v_volume, LEN_DKL_VVOL);
4589 cl->cl_vtoc.v_nparts = user_vtoc->v_nparts;
4592 cl->cl_vtoc.v_reserved[i] = user_vtoc->v_reserved[i];
4599 lmap = cl->cl_map;
4600 lpart = cl->cl_vtoc.v_part;
4616 cl->cl_vtoc.v_timestamp[i] = TIME32_MAX;
4618 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4621 cl->cl_vtoc.v_timestamp[i] = user_vtoc->timestamp[i];
4625 bcopy(user_vtoc->v_asciilabel, cl->cl_asciilabel, LEN_DKL_ASCII);
4645 cmlb_clear_efi(struct cmlb_lun *cl, void *tg_cookie) argument
4651 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
4653 mutex_enter(CMLB_MUTEX(cl));
4654 cl->cl_reserved = -1;
4655 mutex_exit(CMLB_MUTEX(cl));
4657 gpt = kmem_alloc(cl->cl_sys_blocksize, KM_SLEEP);
4659 if (DK_TG_READ(cl, gpt, 1, cl->cl_sys_blocksize, tg_cookie) != 0) {
4668 if (rval = DK_TG_WRITE(cl, gpt, 1, cl->cl_sys_blocksize,
4670 cmlb_dbg(CMLB_INFO, cl,
4675 rval = DK_TG_GETCAP(cl, &cap, tg_cookie);
4680 if ((rval = DK_TG_READ(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4688 cmlb_dbg(CMLB_TRACE, cl,
4691 if ((rval = DK_TG_WRITE(cl, gpt, cap - 1, cl->cl_sys_blocksize,
4693 cmlb_dbg(CMLB_INFO, cl,
4701 if ((rval = DK_TG_READ(cl, gpt, cap - 2,
4702 cl->cl_sys_blocksize, tg_cookie)) != 0) {
4709 cmlb_dbg(CMLB_TRACE, cl,
4713 if ((rval = DK_TG_WRITE(cl, gpt, cap - 2,
4714 cl->cl_sys_blocksize, tg_cookie))) {
4715 cmlb_dbg(CMLB_INFO, cl,
4723 kmem_free(gpt, cl->cl_sys_blocksize);
4742 cmlb_set_vtoc(struct cmlb_lun *cl, struct dk_label *dkl, void *tg_cookie) argument
4752 label_addr = cl->cl_solaris_offset + DK_LABEL_LOC;
4758 rval = DK_TG_WRITE(cl, dkl, label_addr, cl->cl_sys_blocksize,
4787 blk += cl->cl_solaris_offset;
4789 rval = DK_TG_WRITE(cl, dkl, blk, cl->cl_sys_blocksize,
4791 cmlb_dbg(CMLB_INFO, cl,
4815 cmlb_clear_vtoc(struct cmlb_lun *cl, void *tg_cookie) argument
4819 mutex_exit(CMLB_MUTEX(cl));
4820 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4821 mutex_enter(CMLB_MUTEX(cl));
4826 dkl->dkl_apc = cl->cl_g.dkg_apc;
4827 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4828 dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4829 dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4830 dkl->dkl_nsect = cl->cl_g.dkg_nsect;
4831 mutex_exit(CMLB_MUTEX(cl));
4832 (void) cmlb_set_vtoc(cl, dkl, tg_cookie);
4833 kmem_free(dkl, cl->cl_sys_blocksize);
4835 mutex_enter(CMLB_MUTEX(cl));
4858 cmlb_write_label(struct cmlb_lun *cl, void *tg_cookie) argument
4866 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
4867 mutex_exit(CMLB_MUTEX(cl));
4868 dkl = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
4869 mutex_enter(CMLB_MUTEX(cl));
4871 bcopy(&cl->cl_vtoc, &dkl->dkl_vtoc, sizeof (struct dk_vtoc));
4872 dkl->dkl_rpm = cl->cl_g.dkg_rpm;
4873 dkl->dkl_pcyl = cl->cl_g.dkg_pcyl;
4874 dkl->dkl_apc = cl->cl_g.dkg_apc;
4875 dkl->dkl_intrlv = cl->cl_g.dkg_intrlv;
4876 dkl->dkl_ncyl = cl->cl_g.dkg_ncyl;
4877 dkl->dkl_acyl = cl->cl_g.dkg_acyl;
4878 dkl->dkl_nhead = cl->cl_g.dkg_nhead;
4879 dkl->dkl_nsect = cl->cl_g.dkg_nsect;
4882 dkl->dkl_obs1 = cl->cl_g.dkg_obs1;
4883 dkl->dkl_obs2 = cl->cl_g.dkg_obs2;
4884 dkl->dkl_obs3 = cl->cl_g.dkg_obs3;
4886 dkl->dkl_map[i].dkl_cylno = cl->cl_map[i].dkl_cylno;
4887 dkl->dkl_map[i].dkl_nblk = cl->cl_map[i].dkl_nblk;
4889 bcopy(cl->cl_asciilabel, dkl->dkl_asciilabel, LEN_DKL_ASCII);
4891 dkl->dkl_skew = cl->cl_dkg_skew;
4897 dkl->dkl_write_reinstruct = cl->cl_g.dkg_write_reinstruct;
4898 dkl->dkl_read_reinstruct = cl->cl_g.dkg_read_reinstruct;
4909 mutex_exit(CMLB_MUTEX(cl));
4911 rval = cmlb_set_vtoc(cl, dkl, tg_cookie);
4913 kmem_free(dkl, cl->cl_sys_blocksize);
4914 mutex_enter(CMLB_MUTEX(cl));
4925 cmlb_dkio_set_efi(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag, argument
4938 (cl->cl_alter_behavior & (CMLB_INTERNAL_MINOR_NODES)) != 0);
4948 mutex_enter(CMLB_MUTEX(cl));
4949 if ((cmlb_check_update_blockcount(cl, tg_cookie) != 0) ||
4950 (cl->cl_tgt_blocksize == 0) ||
4951 (user_efi.dki_length % cl->cl_sys_blocksize)) {
4952 mutex_exit(CMLB_MUTEX(cl));
4955 if (cl->cl_tgt_blocksize != cl->cl_sys_blocksize)
4957 cl->cl_tgt_blocksize / cl->cl_sys_blocksize;
4958 mutex_exit(CMLB_MUTEX(cl));
4968 mutex_enter(CMLB_MUTEX(cl));
4969 if (cl->cl_vtoc.v_sanity == VTOC_SANE) {
4970 cmlb_dbg(CMLB_TRACE, cl,
4972 if (cl->cl_label_from_media == CMLB_LABEL_VTOC)
4973 cmlb_clear_vtoc(cl, tg_cookie);
4974 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
4975 mutex_exit(CMLB_MUTEX(cl));
4976 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h");
4977 ddi_remove_minor_node(CMLB_DEVINFO(cl), "h,raw");
4978 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd",
4981 cl->cl_node_type, NULL, internal);
4982 (void) cmlb_create_minor(CMLB_DEVINFO(cl), "wd,raw",
4985 cl->cl_node_type, NULL, internal);
4987 mutex_exit(CMLB_MUTEX(cl));
4989 rval = DK_TG_WRITE(cl, buffer, tgt_lba, user_efi.dki_length,
4993 mutex_enter(CMLB_MUTEX(cl));
4994 cl->cl_f_geometry_is_valid = B_FALSE;
4995 mutex_exit(CMLB_MUTEX(cl));
5024 cmlb_dkio_get_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
5032 if ((!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) || (arg == NULL)) {
5042 buffer_size = cl->cl_sys_blocksize;
5044 cmlb_dbg(CMLB_TRACE, cl,
5048 if ((rval = DK_TG_READ(cl, mboot, 0, buffer_size, tg_cookie)) == 0) {
5082 cmlb_dkio_set_mboot(struct cmlb_lun *cl, caddr_t arg, int flag, void *tg_cookie) argument
5089 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5092 if (!ISREMOVABLE(cl) && !ISHOTPLUGGABLE(cl)) {
5101 mboot = kmem_zalloc(cl->cl_sys_blocksize, KM_SLEEP);
5104 cl->cl_sys_blocksize, flag) != 0) {
5105 kmem_free(mboot, cl->cl_sys_blocksize);
5112 kmem_free(mboot, cl->cl_sys_blocksize);
5116 rval = DK_TG_WRITE(cl, mboot, 0, cl->cl_sys_blocksize, tg_cookie);
5118 mutex_enter(CMLB_MUTEX(cl));
5125 rval = cmlb_update_fdisk_and_vtoc(cl, tg_cookie);
5126 if ((!cl->cl_f_geometry_is_valid) || (rval != 0)) {
5127 mutex_exit(CMLB_MUTEX(cl));
5128 kmem_free(mboot, cl->cl_sys_blocksize);
5134 cmlb_setup_default_geometry(cl, tg_cookie);
5143 if (cl->cl_blockcount <= CMLB_EXTVTOC_LIMIT)
5144 cmlb_setup_default_geometry(cl, tg_cookie);
5147 cl->cl_msglog_flag |= CMLB_ALLOW_2TB_WARN;
5148 mutex_exit(CMLB_MUTEX(cl));
5149 kmem_free(mboot, cl->cl_sys_blocksize);
5157 cmlb_dkio_set_ext_part(struct cmlb_lun *cl, caddr_t arg, int flag, argument
5163 ASSERT(!mutex_owned(CMLB_MUTEX(cl)));
5165 mutex_enter(CMLB_MUTEX(cl));
5166 capacity = cl->cl_blockcount;
5167 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5169 mutex_exit(CMLB_MUTEX(cl));
5173 mutex_exit(CMLB_MUTEX(cl));
5194 cmlb_setup_default_geometry(struct cmlb_lun *cl, void *tg_cookie) argument
5202 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5205 bzero(&cl->cl_g, sizeof (struct dk_geom));
5206 bzero(&cl->cl_vtoc, sizeof (struct dk_vtoc));
5207 bzero(cl->cl_map, NDKMAP * (sizeof (struct dk_map)));
5221 if (cl->cl_alter_behavior & CMLB_FAKE_GEOM_LABEL_IOCTLS_VTOC8) {
5227 mutex_exit(CMLB_MUTEX(cl));
5228 ret = DK_TG_GETPHYGEOM(cl, pgeomp, tg_cookie);
5229 mutex_enter(CMLB_MUTEX(cl));
5234 cmlb_dbg(CMLB_ERROR, cl,
5243 if (ISCD(cl)) {
5244 cl->cl_g.dkg_ncyl = 1;
5245 cl->cl_g.dkg_nhead = 1;
5246 cl->cl_g.dkg_nsect = cl->cl_blockcount;
5247 } else if (cl->cl_blockcount < 160) {
5249 cl->cl_g.dkg_nhead = 1;
5250 cl->cl_g.dkg_ncyl = cl->cl_blockcount;
5251 cl->cl_g.dkg_nsect = 1;
5252 } else if (cl->cl_blockcount <= 0x1000) {
5254 cl->cl_g.dkg_nhead = 2;
5255 cl->cl_g.dkg_ncyl = 80;
5256 cl->cl_g.dkg_pcyl = 80;
5257 cl->cl_g.dkg_nsect = cl->cl_blockcount / (2 * 80);
5258 } else if (cl->cl_blockcount <= 0x200000) {
5259 cl->cl_g.dkg_nhead = 64;
5260 cl->cl_g.dkg_nsect = 32;
5261 cl->cl_g.dkg_ncyl = cl->cl_blockcount / (64 * 32);
5263 cl->cl_g.dkg_nhead = 255;
5265 cl->cl_g.dkg_nsect = ((cl->cl_blockcount +
5269 if (cl->cl_g.dkg_nsect == 0)
5270 cl->cl_g.dkg_nsect = (UINT16_MAX / 63) * 63;
5272 cl->cl_g.dkg_ncyl = cl->cl_blockcount /
5273 (255 * cl->cl_g.dkg_nsect);
5276 cl->cl_g.dkg_acyl = 0;
5277 cl->cl_g.dkg_bcyl = 0;
5278 cl->cl_g.dkg_intrlv = 1;
5279 cl->cl_g.dkg_rpm = 200;
5280 if (cl->cl_g.dkg_pcyl == 0)
5281 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl +
5282 cl->cl_g.dkg_acyl;
5284 cl->cl_g.dkg_ncyl = (short)pgeomp->g_ncyl;
5285 cl->cl_g.dkg_acyl = pgeomp->g_acyl;
5286 cl->cl_g.dkg_nhead = pgeomp->g_nhead;
5287 cl->cl_g.dkg_nsect = pgeomp->g_nsect;
5288 cl->cl_g.dkg_intrlv = pgeomp->g_intrlv;
5289 cl->cl_g.dkg_rpm = pgeomp->g_rpm;
5290 cl->cl_g.dkg_pcyl = cl->cl_g.dkg_ncyl + cl->cl_g.dkg_acyl;
5293 cl->cl_g.dkg_read_reinstruct = 0;
5294 cl->cl_g.dkg_write_reinstruct = 0;
5295 cl->cl_solaris_size = cl->cl_g.dkg_ncyl *
5296 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect;
5298 cl->cl_map['a'-'a'].dkl_cylno = 0;
5299 cl->cl_map['a'-'a'].dkl_nblk = cl->cl_solaris_size;
5301 cl->cl_map['c'-'a'].dkl_cylno = 0;
5302 cl->cl_map['c'-'a'].dkl_nblk = cl->cl_solaris_size;
5304 cl->cl_vtoc.v_part[2].p_tag = V_BACKUP;
5305 cl->cl_vtoc.v_part[2].p_flag = V_UNMNT;
5306 cl->cl_vtoc.v_nparts = V_NUMPAR;
5307 cl->cl_vtoc.v_version = V_VERSION;
5308 (void) sprintf((char *)cl->cl_asciilabel, "DEFAULT cyl %d alt %d"
5309 " hd %d sec %d", cl->cl_g.dkg_ncyl, cl->cl_g.dkg_acyl,
5310 cl->cl_g.dkg_nhead, cl->cl_g.dkg_nsect);
5312 cl->cl_f_geometry_is_valid = B_FALSE;
5336 cmlb_update_fdisk_and_vtoc(struct cmlb_lun *cl, void *tg_cookie) argument
5343 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5345 if (cmlb_check_update_blockcount(cl, tg_cookie) != 0)
5354 cl->cl_map[P0_RAW_DISK].dkl_cylno = 0;
5355 cl->cl_map[P0_RAW_DISK].dkl_nblk = cl->cl_blockcount;
5364 capacity = cl->cl_blockcount;
5371 cmlb_resync_geom_caches(cl, capacity, tg_cookie);
5377 if (cl->cl_device_type == DTYPE_DIRECT || ISREMOVABLE(cl)) {
5378 fdisk_rval = cmlb_read_fdisk(cl, capacity, tg_cookie);
5380 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5384 if (cl->cl_solaris_size <= DK_LABEL_LOC) {
5391 cl->cl_f_geometry_is_valid = B_TRUE;
5395 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5406 if (!cl->cl_f_geometry_is_valid) {
5409 cmlb_build_default_label(cl, tg_cookie);
5422 cl->cl_map[FDISK_P1 + count].dkl_cylno = UINT32_MAX;
5423 cl->cl_map[FDISK_P1 + count].dkl_nblk =
5424 cl->cl_fmap[count].fmap_nblk;
5425 cl->cl_offset[FDISK_P1 + count] =
5426 cl->cl_fmap[count].fmap_start;
5432 struct dk_map *lp = &cl->cl_map[count];
5433 cl->cl_offset[count] =
5434 cl->cl_g.dkg_nhead * cl->cl_g.dkg_nsect * lp->dkl_cylno;
5436 struct dkl_partition *vp = &cl->cl_vtoc.v_part[count];
5437 cl->cl_offset[count] = vp->p_start + cl->cl_solaris_offset;
5443 ASSERT(mutex_owned(CMLB_MUTEX(cl)));
5450 cmlb_dkio_get_virtgeom(struct cmlb_lun *cl, caddr_t arg, int flag) argument
5458 mutex_enter(CMLB_MUTEX(cl));
5465 if (cl->cl_lgeom.g_nhead == 0 ||
5466 cl->cl_lgeom.g_nsect == 0 ||
5467 cl->cl_lgeom.g_ncyl > 1024) {
5468 mutex_exit(CMLB_MUTEX(cl));
5471 dkgp->dkg_ncyl = cl->cl_lgeom.g_ncyl;
5472 dkgp->dkg_acyl = cl->cl_lgeom.g_acyl;
5474 dkgp->dkg_nhead = cl->cl_lgeom.g_nhead;
5475 dkgp->dkg_nsect = cl->cl_lgeom.g_nsect;
5477 mutex_exit(CMLB_MUTEX(cl));
5491 cmlb_dkio_get_phygeom(struct cmlb_lun *cl, caddr_t arg, int flag, argument
5502 mutex_enter(CMLB_MUTEX(cl));
5504 if (cl->cl_g.dkg_nhead != 0 &&
5505 cl->cl_g.dkg_nsect != 0) {
5513 bcopy(&cl->cl_g, dkgp, sizeof (*dkgp));
5515 dkgp->dkg_ncyl = cl->cl_blockcount /
5528 if (ISCD(cl)) {
5529 dkgp->dkg_nhead = cl->cl_pgeom.g_nhead;
5530 dkgp->dkg_nsect = cl->cl_pgeom.g_nsect;
5531 dkgp->dkg_ncyl = cl->cl_pgeom.g_ncyl;
5532 dkgp->dkg_acyl = cl->cl_pgeom.g_acyl;
5540 if (cl->cl_blockcount == 0) {
5541 mutex_exit(CMLB_MUTEX(cl));
5549 if (cl->cl_alter_behavior & CMLB_OFF_BY_ONE)
5550 capacity = cl->cl_blockcount - 1;
5552 capacity = cl->cl_blockcount;
5554 cmlb_convert_geometry(cl, capacity, dkgp, tg_cookie);
5562 mutex_exit(CMLB_MUTEX(cl));
5572 cmlb_dkio_partinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) argument
5584 mutex_enter(CMLB_MUTEX(cl));
5586 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5588 mutex_exit(CMLB_MUTEX(cl));
5592 p.p_start = (daddr_t)cl->cl_offset[part];
5593 p.p_length = (int)cl->cl_map[part].dkl_nblk;
5594 mutex_exit(CMLB_MUTEX(cl));
5625 cmlb_dkio_extpartinfo(struct cmlb_lun *cl, dev_t dev, caddr_t arg, int flag) argument
5637 mutex_enter(CMLB_MUTEX(cl));
5639 if (part < P0_RAW_DISK && cl->cl_solaris_size == 0) {
5641 mutex_exit(CMLB_MUTEX(cl));
5645 p.p_start = (diskaddr_t)cl->cl_offset[part];
5646 p.p_length = (diskaddr_t)cl->cl_map[part].dkl_nblk;
5647 mutex_exit(CMLB_MUTEX(cl));
5660 struct cmlb_lun *cl; local
5671 cl = (struct cmlb_lun *)cmlbhandle;
5672 if (cl == NULL) {
5678 capacity = cl->cl_blockcount;
5681 lbasize = cl->cl_tgt_blocksize;
5739 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5745 if (DK_TG_GETATTRIBUTE(cl, &tgattr, tg_cookie) != 0)
5771 dblk = lbasize / cl->cl_sys_blocksize;