1336 if (sl->sl_alias) {
1337 (void) strcpy((char *)p, sl->sl_alias);
1338 sli->sli_alias_offset =
1339 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1340 sli->sli_flags |= SLI_ALIAS_VALID;
1341 p += strlen(sl->sl_alias) + 1;
1342 }
1343 if (sl->sl_mgmt_url) {
1344 (void) strcpy((char *)p, sl->sl_mgmt_url);
1345 sli->sli_mgmt_url_offset =
1346 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1347 sli->sli_flags |= SLI_MGMT_URL_VALID;
1348 p += strlen(sl->sl_mgmt_url) + 1;
1349 }
1350 if (sl->sl_flags & SL_WRITE_PROTECTED) {
1351 sli->sli_flags |= SLI_WRITE_PROTECTED;
1352 }
1353 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE) {
1354 sli->sli_flags |= SLI_WRITEBACK_CACHE_DISABLE;
1355 }
1356 if (sl->sl_flags & SL_VID_VALID) {
1357 bcopy(sl->sl_vendor_id, sli->sli_vid, 8);
1358 sli->sli_flags |= SLI_VID_VALID;
1359 }
1360 if (sl->sl_flags & SL_PID_VALID) {
1361 bcopy(sl->sl_product_id, sli->sli_pid, 16);
1362 sli->sli_flags |= SLI_PID_VALID;
1363 }
1364 if (sl->sl_flags & SL_REV_VALID) {
1365 bcopy(sl->sl_revision, sli->sli_rev, 4);
1366 sli->sli_flags |= SLI_REV_VALID;
1367 }
1368 if (sl->sl_serial_no_size) {
1369 bcopy(sl->sl_serial_no, p, sl->sl_serial_no_size);
1370 sli->sli_serial_size = sl->sl_serial_no_size;
1371 sli->sli_serial_offset =
1372 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1373 sli->sli_flags |= SLI_SERIAL_VALID;
1374 p += sli->sli_serial_size;
1375 }
1376 sli->sli_lu_size = sl->sl_lu_size;
1377 sli->sli_data_blocksize_shift = sl->sl_data_blocksize_shift;
1378 sli->sli_data_order = SMS_DATA_ORDER;
1379 bcopy(sl->sl_device_id, sli->sli_device_id, 20);
1380
1381 sli->sli_sms_header.sms_size = sizeof (*sli) + s;
1382 sli->sli_sms_header.sms_id = SMS_ID_LU_INFO_1_1;
1383 sli->sli_sms_header.sms_data_order = SMS_DATA_ORDER;
1384
1385 mutex_exit(&sl->sl_lock);
1386 ret = sbd_write_meta_section(sl, (sm_section_hdr_t *)sli);
1387 kmem_free(sli, sizeof (*sli) + s);
1388 return (ret);
1389 }
1390
1391 /*
1392 * Will scribble SL_UNMAP_ENABLED into sl_flags if we succeed.
1393 */
1394 static void
1395 do_unmap_setup(sbd_lu_t *sl)
1396 {
1397 ASSERT((sl->sl_flags & SL_UNMAP_ENABLED) == 0);
1398
1399 if ((sl->sl_flags & SL_ZFS_META) == 0)
1400 return; /* No UNMAP for you. */
1401
1402 sl->sl_flags |= SL_UNMAP_ENABLED;
1403 }
1404
1405 int
1406 sbd_populate_and_register_lu(sbd_lu_t *sl, uint32_t *err_ret)
1407 {
1408 stmf_lu_t *lu = sl->sl_lu;
1409 stmf_status_t ret;
1410
1411 do_unmap_setup(sl);
1412
1413 lu->lu_id = (scsi_devid_desc_t *)sl->sl_device_id;
1414 if (sl->sl_alias) {
1415 lu->lu_alias = sl->sl_alias;
1416 } else {
1417 lu->lu_alias = sl->sl_name;
1418 }
1419 if (sl->sl_access_state == SBD_LU_STANDBY) {
1420 /* call set access state */
1421 ret = stmf_set_lu_access(lu, STMF_LU_STANDBY);
1422 if (ret != STMF_SUCCESS) {
1423 *err_ret = SBD_RET_ACCESS_STATE_FAILED;
1424 return (EIO);
1425 }
1426 }
1427 /* set proxy_reg_cb_arg to meta filename */
1428 if (sl->sl_meta_filename) {
1429 lu->lu_proxy_reg_arg = sl->sl_meta_filename;
1430 lu->lu_proxy_reg_arg_len = strlen(sl->sl_meta_filename) + 1;
1431 } else {
1818 slu->slu_serial_size);
1819 sl->sl_serial_no_size = slu->slu_serial_size;
1820 p += slu->slu_serial_size;
1821 }
1822 kmem_free(namebuf, sz);
1823 if (slu->slu_vid_valid) {
1824 bcopy(slu->slu_vid, sl->sl_vendor_id, 8);
1825 sl->sl_flags |= SL_VID_VALID;
1826 }
1827 if (slu->slu_pid_valid) {
1828 bcopy(slu->slu_pid, sl->sl_product_id, 16);
1829 sl->sl_flags |= SL_PID_VALID;
1830 }
1831 if (slu->slu_rev_valid) {
1832 bcopy(slu->slu_rev, sl->sl_revision, 4);
1833 sl->sl_flags |= SL_REV_VALID;
1834 }
1835 if (slu->slu_write_protected) {
1836 sl->sl_flags |= SL_WRITE_PROTECTED;
1837 }
1838 if (slu->slu_writeback_cache_disable) {
1839 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE |
1840 SL_SAVED_WRITE_CACHE_DISABLE;
1841 }
1842
1843 if (slu->slu_blksize_valid) {
1844 if ((slu->slu_blksize & (slu->slu_blksize - 1)) ||
1845 (slu->slu_blksize > (32 * 1024)) ||
1846 (slu->slu_blksize == 0)) {
1847 *err_ret = SBD_RET_INVALID_BLKSIZE;
1848 ret = EINVAL;
1849 goto scm_err_out;
1850 }
1851 while ((1 << sl->sl_data_blocksize_shift) != slu->slu_blksize) {
1852 sl->sl_data_blocksize_shift++;
1853 }
1854 } else {
1855 sl->sl_data_blocksize_shift = 9; /* 512 by default */
1856 slu->slu_blksize = 512;
1857 }
2460 }
2461 }
2462 if (sli->sli_flags & SLI_ALIAS_VALID) {
2463 sl->sl_alias_alloc_size = strlen((char *)sli_buf_copy +
2464 sli->sli_alias_offset) + 1;
2465 sl->sl_alias = kmem_alloc(sl->sl_alias_alloc_size, KM_SLEEP);
2466 (void) strcpy(sl->sl_alias, (char *)sli_buf_copy +
2467 sli->sli_alias_offset);
2468 }
2469 if (sli->sli_flags & SLI_MGMT_URL_VALID) {
2470 sl->sl_mgmt_url_alloc_size = strlen((char *)sli_buf_copy +
2471 sli->sli_mgmt_url_offset) + 1;
2472 sl->sl_mgmt_url = kmem_alloc(sl->sl_mgmt_url_alloc_size,
2473 KM_SLEEP);
2474 (void) strcpy(sl->sl_mgmt_url, (char *)sli_buf_copy +
2475 sli->sli_mgmt_url_offset);
2476 }
2477 if (sli->sli_flags & SLI_WRITE_PROTECTED) {
2478 sl->sl_flags |= SL_WRITE_PROTECTED;
2479 }
2480 if (sli->sli_flags & SLI_VID_VALID) {
2481 sl->sl_flags |= SL_VID_VALID;
2482 bcopy(sli->sli_vid, sl->sl_vendor_id, 8);
2483 }
2484 if (sli->sli_flags & SLI_PID_VALID) {
2485 sl->sl_flags |= SL_PID_VALID;
2486 bcopy(sli->sli_pid, sl->sl_product_id, 16);
2487 }
2488 if (sli->sli_flags & SLI_REV_VALID) {
2489 sl->sl_flags |= SL_REV_VALID;
2490 bcopy(sli->sli_rev, sl->sl_revision, 4);
2491 }
2492 if (sli->sli_flags & SLI_WRITEBACK_CACHE_DISABLE) {
2493 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE;
2494 }
2495 sim_sli_loaded:
2496 if ((sl->sl_flags & SL_SHARED_META) == 0) {
2497 data_opened = 0;
2498 } else {
2499 data_opened = 1;
2680 struct_sz += sizeof (sbd_import_lu_t) - 8;
2681 ilu_sz = struct_sz;
2682 ilu = (sbd_import_lu_t *)kmem_zalloc(ilu_sz, KM_SLEEP);
2683 ilu->ilu_struct_size = struct_sz;
2684 (void) strcpy(ilu->ilu_meta_fname,
2685 &(mlu->mlu_buf[mlu->mlu_fname_off]));
2686 ret = sbd_import_lu(ilu, struct_sz, err_ret, 1, &sl);
2687 kmem_free(ilu, ilu_sz);
2688 if (ret != SBD_SUCCESS) {
2689 return (ENOENT);
2690 }
2691 modify_unregistered = 1;
2692 }
2693
2694 if (sl->sl_access_state != SBD_LU_ACTIVE) {
2695 *err_ret = SBD_RET_ACCESS_STATE_FAILED;
2696 ret = EINVAL;
2697 goto smm_err_out;
2698 }
2699
2700 /* check for write cache change */
2701 if (mlu->mlu_writeback_cache_disable_valid) {
2702 /* set wce on device */
2703 sret = sbd_wcd_set(mlu->mlu_writeback_cache_disable, sl);
2704 if (!mlu->mlu_writeback_cache_disable && sret != SBD_SUCCESS) {
2705 *err_ret = SBD_RET_WRITE_CACHE_SET_FAILED;
2706 ret = EFAULT;
2707 goto smm_err_out;
2708 }
2709 mutex_enter(&sl->sl_lock);
2710 if (!mlu->mlu_writeback_cache_disable) {
2711 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) {
2712 ua = 1;
2713 sl->sl_flags &= ~SL_WRITEBACK_CACHE_DISABLE;
2714 sl->sl_flags &= ~SL_SAVED_WRITE_CACHE_DISABLE;
2715 }
2716 } else {
2717 if ((sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) == 0) {
2718 ua = 1;
2719 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE;
3314 if (sl->sl_flags & SL_VID_VALID) {
3315 oslp->slp_lu_vid = 1;
3316 bcopy(sl->sl_vendor_id, oslp->slp_vid, 8);
3317 } else {
3318 bcopy(sbd_vendor_id, oslp->slp_vid, 8);
3319 }
3320 if (sl->sl_flags & SL_PID_VALID) {
3321 oslp->slp_lu_pid = 1;
3322 bcopy(sl->sl_product_id, oslp->slp_pid, 16);
3323 } else {
3324 bcopy(sbd_product_id, oslp->slp_pid, 16);
3325 }
3326 if (sl->sl_flags & SL_REV_VALID) {
3327 oslp->slp_lu_rev = 1;
3328 bcopy(sl->sl_revision, oslp->slp_rev, 4);
3329 } else {
3330 bcopy(sbd_revision, oslp->slp_rev, 4);
3331 }
3332 bcopy(sl->sl_device_id + 4, oslp->slp_guid, 16);
3333
3334 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE)
3335 oslp->slp_writeback_cache_disable_cur = 1;
3336 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE)
3337 oslp->slp_writeback_cache_disable_saved = 1;
3338 if (sl->sl_flags & SL_WRITE_PROTECTED)
3339 oslp->slp_write_protected = 1;
3340
3341 sl->sl_trans_op = SL_OP_NONE;
3342
3343 rw_exit(&sbd_global_prop_lock);
3344 return (0);
3345 }
3346
3347 /*
3348 * Returns an allocated string with the "<pool>/..." form of the zvol name.
3349 */
3350 static char *
3351 sbd_get_zvol_name(sbd_lu_t *sl)
3352 {
3353 char *src;
|
1336 if (sl->sl_alias) {
1337 (void) strcpy((char *)p, sl->sl_alias);
1338 sli->sli_alias_offset =
1339 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1340 sli->sli_flags |= SLI_ALIAS_VALID;
1341 p += strlen(sl->sl_alias) + 1;
1342 }
1343 if (sl->sl_mgmt_url) {
1344 (void) strcpy((char *)p, sl->sl_mgmt_url);
1345 sli->sli_mgmt_url_offset =
1346 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1347 sli->sli_flags |= SLI_MGMT_URL_VALID;
1348 p += strlen(sl->sl_mgmt_url) + 1;
1349 }
1350 if (sl->sl_flags & SL_WRITE_PROTECTED) {
1351 sli->sli_flags |= SLI_WRITE_PROTECTED;
1352 }
1353 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE) {
1354 sli->sli_flags |= SLI_WRITEBACK_CACHE_DISABLE;
1355 }
1356 if (sl->sl_flags & SL_SAVED_UNMAP_ENABLED) {
1357 sli->sli_flags |= SLI_UNMAP_ENABLED;
1358 }
1359 if (sl->sl_flags & SL_VID_VALID) {
1360 bcopy(sl->sl_vendor_id, sli->sli_vid, 8);
1361 sli->sli_flags |= SLI_VID_VALID;
1362 }
1363 if (sl->sl_flags & SL_PID_VALID) {
1364 bcopy(sl->sl_product_id, sli->sli_pid, 16);
1365 sli->sli_flags |= SLI_PID_VALID;
1366 }
1367 if (sl->sl_flags & SL_REV_VALID) {
1368 bcopy(sl->sl_revision, sli->sli_rev, 4);
1369 sli->sli_flags |= SLI_REV_VALID;
1370 }
1371 if (sl->sl_serial_no_size) {
1372 bcopy(sl->sl_serial_no, p, sl->sl_serial_no_size);
1373 sli->sli_serial_size = sl->sl_serial_no_size;
1374 sli->sli_serial_offset =
1375 (uintptr_t)p - (uintptr_t)sli->sli_buf;
1376 sli->sli_flags |= SLI_SERIAL_VALID;
1377 p += sli->sli_serial_size;
1378 }
1379 sli->sli_lu_size = sl->sl_lu_size;
1380 sli->sli_data_blocksize_shift = sl->sl_data_blocksize_shift;
1381 sli->sli_data_order = SMS_DATA_ORDER;
1382 bcopy(sl->sl_device_id, sli->sli_device_id, 20);
1383
1384 sli->sli_sms_header.sms_size = sizeof (*sli) + s;
1385 sli->sli_sms_header.sms_id = SMS_ID_LU_INFO_1_1;
1386 sli->sli_sms_header.sms_data_order = SMS_DATA_ORDER;
1387
1388 mutex_exit(&sl->sl_lock);
1389 ret = sbd_write_meta_section(sl, (sm_section_hdr_t *)sli);
1390 kmem_free(sli, sizeof (*sli) + s);
1391 return (ret);
1392 }
1393
1394 /*
1395 * Will scribble SL_UNMAP_ENABLED on or off in sl_flags if we succeed.
1396 * Returns B_TRUE if the LU is UNMAP-capable.
1397 */
1398 static boolean_t
1399 do_unmap_setup(sbd_lu_t *sl, boolean_t enable)
1400 {
1401 if ((sl->sl_flags & SL_ZFS_META) == 0) {
1402 sl->sl_flags &= ~SL_SAVED_UNMAP_ENABLED;
1403 ASSERT((sl->sl_flags & SL_UNMAP_ENABLED) == 0);
1404 return (B_FALSE); /* No UNMAP for you. */
1405 }
1406
1407 if (enable)
1408 sl->sl_flags |= (SL_UNMAP_ENABLED | SL_SAVED_UNMAP_ENABLED);
1409 else
1410 sl->sl_flags &= ~(SL_UNMAP_ENABLED | SL_SAVED_UNMAP_ENABLED);
1411
1412 return (B_TRUE);
1413 }
1414
1415 int
1416 sbd_populate_and_register_lu(sbd_lu_t *sl, uint32_t *err_ret)
1417 {
1418 stmf_lu_t *lu = sl->sl_lu;
1419 stmf_status_t ret;
1420
1421 #if 0
1422 /* Always try and enable UNMAP upon bringup. */
1423 (void) do_unmap_setup(sl, B_TRUE);
1424 #endif
1425
1426 lu->lu_id = (scsi_devid_desc_t *)sl->sl_device_id;
1427 if (sl->sl_alias) {
1428 lu->lu_alias = sl->sl_alias;
1429 } else {
1430 lu->lu_alias = sl->sl_name;
1431 }
1432 if (sl->sl_access_state == SBD_LU_STANDBY) {
1433 /* call set access state */
1434 ret = stmf_set_lu_access(lu, STMF_LU_STANDBY);
1435 if (ret != STMF_SUCCESS) {
1436 *err_ret = SBD_RET_ACCESS_STATE_FAILED;
1437 return (EIO);
1438 }
1439 }
1440 /* set proxy_reg_cb_arg to meta filename */
1441 if (sl->sl_meta_filename) {
1442 lu->lu_proxy_reg_arg = sl->sl_meta_filename;
1443 lu->lu_proxy_reg_arg_len = strlen(sl->sl_meta_filename) + 1;
1444 } else {
1831 slu->slu_serial_size);
1832 sl->sl_serial_no_size = slu->slu_serial_size;
1833 p += slu->slu_serial_size;
1834 }
1835 kmem_free(namebuf, sz);
1836 if (slu->slu_vid_valid) {
1837 bcopy(slu->slu_vid, sl->sl_vendor_id, 8);
1838 sl->sl_flags |= SL_VID_VALID;
1839 }
1840 if (slu->slu_pid_valid) {
1841 bcopy(slu->slu_pid, sl->sl_product_id, 16);
1842 sl->sl_flags |= SL_PID_VALID;
1843 }
1844 if (slu->slu_rev_valid) {
1845 bcopy(slu->slu_rev, sl->sl_revision, 4);
1846 sl->sl_flags |= SL_REV_VALID;
1847 }
1848 if (slu->slu_write_protected) {
1849 sl->sl_flags |= SL_WRITE_PROTECTED;
1850 }
1851
1852 if (slu->slu_unmap) {
1853 (void) do_unmap_setup(sl, B_TRUE);
1854 }
1855
1856 if (slu->slu_writeback_cache_disable) {
1857 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE |
1858 SL_SAVED_WRITE_CACHE_DISABLE;
1859 }
1860
1861 if (slu->slu_blksize_valid) {
1862 if ((slu->slu_blksize & (slu->slu_blksize - 1)) ||
1863 (slu->slu_blksize > (32 * 1024)) ||
1864 (slu->slu_blksize == 0)) {
1865 *err_ret = SBD_RET_INVALID_BLKSIZE;
1866 ret = EINVAL;
1867 goto scm_err_out;
1868 }
1869 while ((1 << sl->sl_data_blocksize_shift) != slu->slu_blksize) {
1870 sl->sl_data_blocksize_shift++;
1871 }
1872 } else {
1873 sl->sl_data_blocksize_shift = 9; /* 512 by default */
1874 slu->slu_blksize = 512;
1875 }
2478 }
2479 }
2480 if (sli->sli_flags & SLI_ALIAS_VALID) {
2481 sl->sl_alias_alloc_size = strlen((char *)sli_buf_copy +
2482 sli->sli_alias_offset) + 1;
2483 sl->sl_alias = kmem_alloc(sl->sl_alias_alloc_size, KM_SLEEP);
2484 (void) strcpy(sl->sl_alias, (char *)sli_buf_copy +
2485 sli->sli_alias_offset);
2486 }
2487 if (sli->sli_flags & SLI_MGMT_URL_VALID) {
2488 sl->sl_mgmt_url_alloc_size = strlen((char *)sli_buf_copy +
2489 sli->sli_mgmt_url_offset) + 1;
2490 sl->sl_mgmt_url = kmem_alloc(sl->sl_mgmt_url_alloc_size,
2491 KM_SLEEP);
2492 (void) strcpy(sl->sl_mgmt_url, (char *)sli_buf_copy +
2493 sli->sli_mgmt_url_offset);
2494 }
2495 if (sli->sli_flags & SLI_WRITE_PROTECTED) {
2496 sl->sl_flags |= SL_WRITE_PROTECTED;
2497 }
2498 if (sli->sli_flags & SLI_UNMAP_ENABLED) {
2499 sl->sl_flags |= SL_UNMAP_ENABLED;
2500 }
2501 if (sli->sli_flags & SLI_VID_VALID) {
2502 sl->sl_flags |= SL_VID_VALID;
2503 bcopy(sli->sli_vid, sl->sl_vendor_id, 8);
2504 }
2505 if (sli->sli_flags & SLI_PID_VALID) {
2506 sl->sl_flags |= SL_PID_VALID;
2507 bcopy(sli->sli_pid, sl->sl_product_id, 16);
2508 }
2509 if (sli->sli_flags & SLI_REV_VALID) {
2510 sl->sl_flags |= SL_REV_VALID;
2511 bcopy(sli->sli_rev, sl->sl_revision, 4);
2512 }
2513 if (sli->sli_flags & SLI_WRITEBACK_CACHE_DISABLE) {
2514 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE;
2515 }
2516 sim_sli_loaded:
2517 if ((sl->sl_flags & SL_SHARED_META) == 0) {
2518 data_opened = 0;
2519 } else {
2520 data_opened = 1;
2701 struct_sz += sizeof (sbd_import_lu_t) - 8;
2702 ilu_sz = struct_sz;
2703 ilu = (sbd_import_lu_t *)kmem_zalloc(ilu_sz, KM_SLEEP);
2704 ilu->ilu_struct_size = struct_sz;
2705 (void) strcpy(ilu->ilu_meta_fname,
2706 &(mlu->mlu_buf[mlu->mlu_fname_off]));
2707 ret = sbd_import_lu(ilu, struct_sz, err_ret, 1, &sl);
2708 kmem_free(ilu, ilu_sz);
2709 if (ret != SBD_SUCCESS) {
2710 return (ENOENT);
2711 }
2712 modify_unregistered = 1;
2713 }
2714
2715 if (sl->sl_access_state != SBD_LU_ACTIVE) {
2716 *err_ret = SBD_RET_ACCESS_STATE_FAILED;
2717 ret = EINVAL;
2718 goto smm_err_out;
2719 }
2720
2721 /* Change UNMAP status... */
2722 if (mlu->mlu_unmap_valid) {
2723 mutex_enter(&sl->sl_lock);
2724 ASSERT(ret == 0);
2725 if (!do_unmap_setup(sl, mlu->mlu_unmap))
2726 ret = EINVAL;
2727 mutex_exit(&sl->sl_lock);
2728 if (ret != 0)
2729 goto smm_err_out;
2730 }
2731
2732 /* check for write cache change */
2733 if (mlu->mlu_writeback_cache_disable_valid) {
2734 /* set wce on device */
2735 sret = sbd_wcd_set(mlu->mlu_writeback_cache_disable, sl);
2736 if (!mlu->mlu_writeback_cache_disable && sret != SBD_SUCCESS) {
2737 *err_ret = SBD_RET_WRITE_CACHE_SET_FAILED;
2738 ret = EFAULT;
2739 goto smm_err_out;
2740 }
2741 mutex_enter(&sl->sl_lock);
2742 if (!mlu->mlu_writeback_cache_disable) {
2743 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) {
2744 ua = 1;
2745 sl->sl_flags &= ~SL_WRITEBACK_CACHE_DISABLE;
2746 sl->sl_flags &= ~SL_SAVED_WRITE_CACHE_DISABLE;
2747 }
2748 } else {
2749 if ((sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE) == 0) {
2750 ua = 1;
2751 sl->sl_flags |= SL_WRITEBACK_CACHE_DISABLE;
3346 if (sl->sl_flags & SL_VID_VALID) {
3347 oslp->slp_lu_vid = 1;
3348 bcopy(sl->sl_vendor_id, oslp->slp_vid, 8);
3349 } else {
3350 bcopy(sbd_vendor_id, oslp->slp_vid, 8);
3351 }
3352 if (sl->sl_flags & SL_PID_VALID) {
3353 oslp->slp_lu_pid = 1;
3354 bcopy(sl->sl_product_id, oslp->slp_pid, 16);
3355 } else {
3356 bcopy(sbd_product_id, oslp->slp_pid, 16);
3357 }
3358 if (sl->sl_flags & SL_REV_VALID) {
3359 oslp->slp_lu_rev = 1;
3360 bcopy(sl->sl_revision, oslp->slp_rev, 4);
3361 } else {
3362 bcopy(sbd_revision, oslp->slp_rev, 4);
3363 }
3364 bcopy(sl->sl_device_id + 4, oslp->slp_guid, 16);
3365
3366 if (sl->sl_flags & SL_UNMAP_ENABLED)
3367 oslp->slp_unmap_cur = 1;
3368 if (sl->sl_flags & SL_SAVED_UNMAP_ENABLED)
3369 oslp->slp_unmap_saved = 1;
3370 if (sl->sl_flags & SL_WRITEBACK_CACHE_DISABLE)
3371 oslp->slp_writeback_cache_disable_cur = 1;
3372 if (sl->sl_flags & SL_SAVED_WRITE_CACHE_DISABLE)
3373 oslp->slp_writeback_cache_disable_saved = 1;
3374 if (sl->sl_flags & SL_WRITE_PROTECTED)
3375 oslp->slp_write_protected = 1;
3376
3377 sl->sl_trans_op = SL_OP_NONE;
3378
3379 rw_exit(&sbd_global_prop_lock);
3380 return (0);
3381 }
3382
3383 /*
3384 * Returns an allocated string with the "<pool>/..." form of the zvol name.
3385 */
3386 static char *
3387 sbd_get_zvol_name(sbd_lu_t *sl)
3388 {
3389 char *src;
|