Lines Matching defs:lsp
111 * on the "master" key held in the lsp and the block number of the buffer.
156 * lsp->ls_crypto_offset.
269 lofi_free_comp_cache(struct lofi_state *lsp)
273 while ((lc = list_remove_head(&lsp->ls_comp_cache)) != NULL) {
274 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
276 lsp->ls_comp_cache_count--;
278 ASSERT(lsp->ls_comp_cache_count == 0);
282 is_opened(struct lofi_state *lsp)
289 if (lsp->ls_open_lyr[i]) {
296 if (lsp->ls_open_reg[i]) {
305 lofi_free_crypto(struct lofi_state *lsp)
309 if (lsp->ls_crypto_enabled) {
314 if (lsp->ls_key.ck_data != NULL) {
315 bzero(lsp->ls_key.ck_data,
316 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
317 kmem_free(lsp->ls_key.ck_data,
318 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
319 lsp->ls_key.ck_data = NULL;
320 lsp->ls_key.ck_length = 0;
323 if (lsp->ls_mech.cm_param != NULL) {
324 kmem_free(lsp->ls_mech.cm_param,
325 lsp->ls_mech.cm_param_len);
326 lsp->ls_mech.cm_param = NULL;
327 lsp->ls_mech.cm_param_len = 0;
330 if (lsp->ls_iv_mech.cm_param != NULL) {
331 kmem_free(lsp->ls_iv_mech.cm_param,
332 lsp->ls_iv_mech.cm_param_len);
333 lsp->ls_iv_mech.cm_param = NULL;
334 lsp->ls_iv_mech.cm_param_len = 0;
337 mutex_destroy(&lsp->ls_crypto_lock);
346 struct lofi_state *lsp;
355 lsp = ddi_get_soft_state(lofi_statep, instance);
357 if (lsp == NULL)
364 * Make sure the mapping is set up by checking lsp->ls_vp_ready.
366 mutex_enter(&lsp->ls_vp_lock);
367 while (lsp->ls_vp_ready == B_FALSE)
368 cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
369 mutex_exit(&lsp->ls_vp_lock);
371 if (P2PHASE(length, (1U << lsp->ls_lbshift)) != 0) {
381 if (lsp->ls_readonly == B_TRUE) {
392 bp->b_edev = lsp->ls_dev;
394 if (lsp->ls_kstat) {
395 mutex_enter(lsp->ls_kstat->ks_lock);
396 kstat_waitq_enter(KSTAT_IO_PTR(lsp->ls_kstat));
397 mutex_exit(lsp->ls_kstat->ks_lock);
399 (void) taskq_dispatch(lsp->ls_taskq, lofi_strategy_task, bp, KM_SLEEP);
425 struct lofi_state *lsp;
434 lsp = ddi_get_soft_state(lofi_statep, instance);
436 if (lsp == NULL)
440 * Make sure the mapping is set up by checking lsp->ls_vp_ready.
453 mutex_enter(&lsp->ls_vp_lock);
454 if (tg_cookie != NULL && lsp->ls_vp_ready == B_FALSE) {
455 mutex_exit(&lsp->ls_vp_lock);
458 while (lsp->ls_vp_ready == B_FALSE)
459 cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
460 mutex_exit(&lsp->ls_vp_lock);
462 ashift = lsp->ls_lbshift;
469 (lsp->ls_vp_size - lsp->ls_crypto_offset) >> ashift;
470 geomp->g_nsect = lsp->ls_dkg.dkg_nsect;
471 geomp->g_nhead = lsp->ls_dkg.dkg_nhead;
472 geomp->g_acyl = lsp->ls_dkg.dkg_acyl;
473 geomp->g_ncyl = lsp->ls_dkg.dkg_ncyl;
475 geomp->g_intrlv = lsp->ls_dkg.dkg_intrlv;
476 geomp->g_rpm = lsp->ls_dkg.dkg_rpm;
482 (lsp->ls_vp_size - lsp->ls_crypto_offset) >> ashift;
492 tgattr->media_is_writable = !lsp->ls_readonly;
503 lofi_destroy(struct lofi_state *lsp, cred_t *credp)
505 int id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
510 list_remove(&lofi_list, lsp);
512 lofi_free_crypto(lsp);
517 if (lsp->ls_comp_bufs != NULL) {
519 if (lsp->ls_comp_bufs[i].bufsize > 0)
520 kmem_free(lsp->ls_comp_bufs[i].buf,
521 lsp->ls_comp_bufs[i].bufsize);
523 kmem_free(lsp->ls_comp_bufs,
527 if (lsp->ls_vp != NULL) {
528 (void) VOP_PUTPAGE(lsp->ls_vp, 0, 0, B_INVAL, credp, NULL);
529 (void) VOP_CLOSE(lsp->ls_vp, lsp->ls_openflag,
531 VN_RELE(lsp->ls_vp);
533 if (lsp->ls_stacked_vp != lsp->ls_vp)
534 VN_RELE(lsp->ls_stacked_vp);
536 if (lsp->ls_taskq != NULL)
537 taskq_destroy(lsp->ls_taskq);
539 if (lsp->ls_kstat != NULL)
540 kstat_delete(lsp->ls_kstat);
545 lofi_free_comp_cache(lsp);
546 list_destroy(&lsp->ls_comp_cache);
548 if (lsp->ls_uncomp_seg_sz > 0) {
549 kmem_free(lsp->ls_comp_index_data, lsp->ls_comp_index_data_sz);
550 lsp->ls_uncomp_seg_sz = 0;
553 rctl_decr_lofi(lsp->ls_zone.zref_zone, 1);
554 zone_rele_ref(&lsp->ls_zone, ZONE_REF_LOFI);
556 mutex_destroy(&lsp->ls_comp_cache_lock);
557 mutex_destroy(&lsp->ls_comp_bufs_lock);
558 mutex_destroy(&lsp->ls_kstat_lock);
559 mutex_destroy(&lsp->ls_vp_lock);
560 cv_destroy(&lsp->ls_vp_cv);
561 lsp->ls_vp_ready = B_FALSE;
563 ASSERT(ddi_get_soft_state(lofi_statep, id) == lsp);
564 (void) ndi_devi_offline(lsp->ls_dip, NDI_DEVI_REMOVE);
569 lofi_free_dev(struct lofi_state *lsp)
573 if (lsp->ls_cmlbhandle != NULL) {
574 cmlb_invalidate(lsp->ls_cmlbhandle, 0);
575 cmlb_detach(lsp->ls_cmlbhandle, 0);
576 cmlb_free_handle(&lsp->ls_cmlbhandle);
577 lsp->ls_cmlbhandle = NULL;
579 (void) ddi_prop_remove_all(lsp->ls_dip);
580 ddi_remove_minor_node(lsp->ls_dip, NULL);
587 struct lofi_state *lsp;
592 for (lsp = list_head(&lofi_list); lsp != NULL; lsp = next) {
594 /* lofi_destroy() frees lsp */
595 next = list_next(&lofi_list, lsp);
597 if (lsp->ls_zone.zref_zone->zone_id != zoneid)
606 if (is_opened(lsp)) {
607 lsp->ls_cleanup = 1;
609 lofi_free_dev(lsp);
610 lofi_destroy(lsp, kcred);
628 struct lofi_state *lsp;
654 lsp = ddi_get_soft_state(lofi_statep, id);
655 if (lsp == NULL) {
660 if (lsp->ls_vp == NULL) {
665 if (lsp->ls_readonly && (flag & FWRITE)) {
670 if ((lsp->ls_open_excl) & (mask)) {
676 if (lsp->ls_open_lyr[part]) {
681 if (lsp->ls_open_reg[i] & mask) {
688 if (lsp->ls_cmlbhandle != NULL) {
689 if (cmlb_validate(lsp->ls_cmlbhandle, 0, 0) != 0) {
698 } else if (cmlb_partinfo(lsp->ls_cmlbhandle, part, &nblks, &lba,
711 lsp->ls_open_lyr[part]++;
713 lsp->ls_open_reg[otyp] |= mask;
716 lsp->ls_open_excl |= mask;
730 struct lofi_state *lsp;
737 lsp = ddi_get_soft_state(lofi_statep, id);
738 if (lsp == NULL) {
748 if (lsp->ls_open_excl & mask)
749 lsp->ls_open_excl &= ~mask;
752 lsp->ls_open_lyr[part]--;
754 lsp->ls_open_reg[otyp] &= ~mask;
762 if (!is_opened(lsp) && (lsp->ls_cleanup || lsp->ls_vp == NULL)) {
763 lofi_free_dev(lsp);
764 lofi_destroy(lsp, credp);
773 * The IV is computed from the data block number. lsp->ls_mech is
775 * lsp->ls_mech.cm_param_len is set to the IV len.
776 * lsp->ls_mech.cm_param is set to the IV.
779 lofi_blk_mech(struct lofi_state *lsp, longlong_t lblkno)
789 ASSERT(MUTEX_HELD(&lsp->ls_crypto_lock));
791 if (lsp == NULL)
794 /* lsp->ls_mech.cm_param{_len} has already been set for static iv */
795 if (lsp->ls_iv_type == IVM_NONE) {
803 if (lsp->ls_mech.cm_param == NULL ||
804 lsp->ls_mech.cm_param_len != lsp->ls_iv_len) {
805 iv_len = lsp->ls_iv_len;
808 iv_len = lsp->ls_mech.cm_param_len;
809 iv = lsp->ls_mech.cm_param;
813 switch (lsp->ls_iv_type) {
836 ret = crypto_encrypt(&lsp->ls_iv_mech, &cdata, &lsp->ls_key,
841 if (lsp->ls_mech.cm_param != iv)
848 if (lsp->ls_mech.cm_param != NULL && lsp->ls_mech.cm_param != iv)
849 kmem_free(lsp->ls_mech.cm_param, lsp->ls_mech.cm_param_len);
851 lsp->ls_mech.cm_param_len = iv_len;
852 lsp->ls_mech.cm_param = iv;
863 lofi_crypto(struct lofi_state *lsp, struct buf *bp, caddr_t plaintext,
871 mutex_enter(&lsp->ls_crypto_lock);
885 ret = lofi_blk_mech(lsp, lblkno);
890 ret = crypto_encrypt(&lsp->ls_mech, &cdata,
891 &lsp->ls_key, NULL,
894 ret = crypto_decrypt(&lsp->ls_mech, &cdata,
895 &lsp->ls_key, NULL,
905 mutex_exit(&lsp->ls_crypto_lock);
921 struct lofi_state *lsp, size_t len, int method, caddr_t bcopy_locn)
929 * Note: offset is already shifted by lsp->ls_crypto_offset
940 error = vn_rdwr(UIO_READ, lsp->ls_vp, bufaddr, len,
945 if (lsp->ls_crypto_enabled && error == 0) {
946 if (lofi_crypto(lsp, bp, bufaddr, NULL, len,
962 if (lsp->ls_crypto_enabled) {
965 if (lofi_crypto(lsp, bp, bufaddr, iobuf, len,
978 error = vn_rdwr(UIO_WRITE, lsp->ls_vp, iobuf, len,
983 if (lsp->ls_crypto_enabled) {
992 struct lofi_state *lsp)
1005 * Note: offset is already shifted by lsp->ls_crypto_offset
1008 if (lsp->ls_crypto_enabled)
1009 ASSERT(lsp->ls_vp_comp_size == lsp->ls_vp_size);
1046 xfersize = MIN(lsp->ls_vp_comp_size - offset,
1049 mapaddr = segmap_getmapflt(segkmap, lsp->ls_vp,
1070 error = lofi_rdwr(bufaddr, 0, bp, lsp, xfersize,
1106 (offset < lsp->ls_vp_comp_size));
1120 lofi_find_comp_data(struct lofi_state *lsp, uint64_t seg_index)
1124 ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
1126 for (lc = list_head(&lsp->ls_comp_cache); lc != NULL;
1127 lc = list_next(&lsp->ls_comp_cache, lc)) {
1136 list_remove(&lsp->ls_comp_cache, lc);
1137 list_insert_head(&lsp->ls_comp_cache, lc);
1153 lofi_add_comp_data(struct lofi_state *lsp, uint64_t seg_index,
1158 ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
1160 while (lsp->ls_comp_cache_count > lofi_max_comp_cache) {
1161 lc = list_remove_tail(&lsp->ls_comp_cache);
1163 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
1165 lsp->ls_comp_cache_count--;
1183 if (lsp->ls_comp_cache_count < lofi_max_comp_cache) {
1186 list_insert_head(&lsp->ls_comp_cache, lc);
1187 lsp->ls_comp_cache_count++;
1189 lc = list_remove_tail(&lsp->ls_comp_cache);
1192 list_insert_head(&lsp->ls_comp_cache, lc);
1200 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
1252 struct lofi_state *lsp;
1259 lsp = ddi_get_soft_state(lofi_statep,
1262 if (lsp == NULL) {
1266 if (lsp->ls_kstat) {
1267 mutex_enter(lsp->ls_kstat->ks_lock);
1268 kstat_waitq_to_runq(KSTAT_IO_PTR(lsp->ls_kstat));
1269 mutex_exit(lsp->ls_kstat->ks_lock);
1272 mutex_enter(&lsp->ls_vp_lock);
1273 lsp->ls_vp_iocount++;
1274 mutex_exit(&lsp->ls_vp_lock);
1279 << lsp->ls_lbshift; /* offset within file */
1280 if (lsp->ls_crypto_enabled) {
1282 offset += lsp->ls_crypto_offset;
1287 if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
1307 if ((lsp->ls_vp->v_flag & VNOMAP) || (lsp->ls_vp->v_type == VCHR) ||
1308 lsp->ls_crypto_enabled) {
1309 error = lofi_rdwr(bufaddr, offset, bp, lsp, len, RDWR_RAW,
1311 } else if (lsp->ls_uncomp_seg_sz == 0) {
1312 error = lofi_mapped_rdwr(bufaddr, offset, bp, lsp);
1332 ASSERT(!lsp->ls_crypto_enabled);
1344 ASSERT(lsp->ls_comp_algorithm_index >= 0);
1345 li = &lofi_compress_table[lsp->ls_comp_algorithm_index];
1352 sblkno = offset >> lsp->ls_comp_seg_shift;
1353 sblkoff = offset & (lsp->ls_uncomp_seg_sz - 1);
1354 eblkno = (offset + bp->b_bcount) >> lsp->ls_comp_seg_shift;
1355 eblkoff = (offset + bp->b_bcount) & (lsp->ls_uncomp_seg_sz - 1);
1370 mutex_enter(&lsp->ls_comp_cache_lock);
1371 lc = lofi_find_comp_data(lsp, sblkno);
1379 mutex_exit(&lsp->ls_comp_cache_lock);
1384 mutex_exit(&lsp->ls_comp_cache_lock);
1390 salign = lsp->ls_comp_seg_index[sblkno];
1393 if (eblkno >= (lsp->ls_comp_index_sz - 1)) {
1401 (lsp->ls_uncomp_last_seg_sz - 1);
1402 ealign = lsp->ls_vp_comp_size;
1404 ealign = lsp->ls_comp_seg_index[eblkno + 1];
1423 mutex_enter(&lsp->ls_comp_bufs_lock);
1425 if (lsp->ls_comp_bufs[j].inuse == 0) {
1426 lsp->ls_comp_bufs[j].inuse = 1;
1431 mutex_exit(&lsp->ls_comp_bufs_lock);
1439 if (lsp->ls_comp_bufs[j].bufsize < bp->b_bcount) {
1440 if (lsp->ls_comp_bufs[j].bufsize > 0)
1441 kmem_free(lsp->ls_comp_bufs[j].buf,
1442 lsp->ls_comp_bufs[j].bufsize);
1443 lsp->ls_comp_bufs[j].buf = kmem_alloc(bp->b_bcount,
1445 lsp->ls_comp_bufs[j].bufsize = bp->b_bcount;
1447 compressed_seg = lsp->ls_comp_bufs[j].buf;
1453 bp, lsp);
1465 ASSERT(i < lsp->ls_comp_index_sz - 1);
1473 if (i == (lsp->ls_comp_index_sz - 2)) {
1474 seglen = lsp->ls_uncomp_last_seg_sz;
1476 seglen = lsp->ls_uncomp_seg_sz;
1487 cmpbytes = lsp->ls_comp_seg_index[i + 1] -
1488 lsp->ls_comp_seg_index[i];
1509 kmem_alloc(lsp->ls_uncomp_seg_sz,
1526 xfersize = lsp->ls_uncomp_seg_sz - sblkoff;
1528 xfersize -= (lsp->ls_uncomp_seg_sz - eblkoff);
1555 mutex_enter(&lsp->ls_comp_cache_lock);
1556 if ((lc = lofi_add_comp_data(lsp, uncompressed_seg_index,
1560 mutex_exit(&lsp->ls_comp_cache_lock);
1564 mutex_enter(&lsp->ls_comp_bufs_lock);
1565 lsp->ls_comp_bufs[j].inuse = 0;
1566 mutex_exit(&lsp->ls_comp_bufs_lock);
1569 kmem_free(uncompressed_seg, lsp->ls_uncomp_seg_sz);
1573 error = VOP_FSYNC(lsp->ls_vp, syncflag, kcred, NULL);
1576 if (bufinited && lsp->ls_kstat) {
1580 mutex_enter(lsp->ls_kstat->ks_lock);
1581 kioptr = KSTAT_IO_PTR(lsp->ls_kstat);
1590 mutex_exit(lsp->ls_kstat->ks_lock);
1593 mutex_enter(&lsp->ls_vp_lock);
1594 if (--lsp->ls_vp_iocount == 0)
1595 cv_broadcast(&lsp->ls_vp_cv);
1596 mutex_exit(&lsp->ls_vp_lock);
1605 struct lofi_state *lsp;
1624 lsp = ddi_get_soft_state(lofi_statep,
1628 if (lsp == NULL) {
1633 shift = lsp->ls_lbshift;
1636 p_nblks = lsp->ls_vp_size >> shift;
1638 if (lsp->ls_cmlbhandle != NULL) {
1639 if (cmlb_partinfo(lsp->ls_cmlbhandle, part, &p_nblks, &p_lba,
1656 mutex_enter(&lsp->ls_vp_lock);
1657 if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
1660 mutex_exit(&lsp->ls_vp_lock);
1664 if (lsp->ls_crypto_enabled) {
1666 offset += lsp->ls_crypto_offset;
1670 if (offset == lsp->ls_vp_size ||
1671 offset == (((p_lba + p_nblks) << shift) + lsp->ls_crypto_offset)) {
1681 mutex_exit(&lsp->ls_vp_lock);
1684 if ((offset > lsp->ls_vp_size) ||
1685 (offset > (((p_lba + p_nblks) << shift) + lsp->ls_crypto_offset)) ||
1689 mutex_exit(&lsp->ls_vp_lock);
1693 mutex_exit(&lsp->ls_vp_lock);
1695 if (lsp->ls_kstat) {
1696 mutex_enter(lsp->ls_kstat->ks_lock);
1697 kstat_waitq_enter(KSTAT_IO_PTR(lsp->ls_kstat));
1698 mutex_exit(lsp->ls_kstat->ks_lock);
1701 (void) taskq_dispatch(lsp->ls_taskq, lofi_strategy_task, bp, KM_SLEEP);
1749 struct lofi_state *lsp;
1756 lsp = ddi_get_soft_state(lofi_statep, instance);
1757 if (lsp == NULL)
1759 *result = lsp->ls_dip;
1769 lofi_create_minor_nodes(struct lofi_state *lsp, boolean_t labeled)
1772 int instance = ddi_get_instance(lsp->ls_dip);
1775 cmlb_alloc_handle(&lsp->ls_cmlbhandle);
1776 error = cmlb_attach(lsp->ls_dip, &lofi_tg_ops, DTYPE_DIRECT,
1778 CMLB_CREATE_P0_MINOR_NODE, lsp->ls_cmlbhandle, (void *)1);
1781 cmlb_free_handle(&lsp->ls_cmlbhandle);
1782 lsp->ls_cmlbhandle = NULL;
1787 error = ddi_create_minor_node(lsp->ls_dip, LOFI_BLOCK_NODE,
1790 error = ddi_create_minor_node(lsp->ls_dip,
1794 ddi_remove_minor_node(lsp->ls_dip,
1805 lofi_zone_bind(struct lofi_state *lsp)
1816 if (ddi_prop_update_string(lsp->ls_dev, lsp->ls_dip, ZONE_PROP_NAME,
1821 zone_init_ref(&lsp->ls_zone);
1822 zone_hold_ref(curzone, &lsp->ls_zone, ZONE_REF_LOFI);
1828 lofi_zone_unbind(struct lofi_state *lsp)
1830 (void) ddi_prop_remove(DDI_DEV_T_NONE, lsp->ls_dip, ZONE_PROP_NAME);
1832 zone_rele_ref(&lsp->ls_zone, ZONE_REF_LOFI);
1841 struct lofi_state *lsp;
1847 /* lsp alloc+init, soft state is freed in lofi_detach */
1853 lsp = ddi_get_soft_state(lofi_statep, instance);
1854 lsp->ls_dip = dip;
1856 if ((error = lofi_zone_bind(lsp)) != 0)
1859 cv_init(&lsp->ls_vp_cv, NULL, CV_DRIVER, NULL);
1860 mutex_init(&lsp->ls_comp_cache_lock, NULL, MUTEX_DRIVER, NULL);
1861 mutex_init(&lsp->ls_comp_bufs_lock, NULL, MUTEX_DRIVER, NULL);
1862 mutex_init(&lsp->ls_kstat_lock, NULL, MUTEX_DRIVER, NULL);
1863 mutex_init(&lsp->ls_vp_lock, NULL, MUTEX_DRIVER, NULL);
1865 if ((error = lofi_create_minor_nodes(lsp, labeled)) != 0) {
1866 lofi_zone_unbind(lsp);
1877 lsp->ls_kstat = kstat_create_zone(LOFI_DRIVER_NAME, instance,
1879 if (lsp->ls_kstat == NULL) {
1880 (void) ddi_prop_remove(DDI_DEV_T_NONE, lsp->ls_dip,
1886 lsp->ls_kstat->ks_lock = &lsp->ls_kstat_lock;
1887 kstat_zone_add(lsp->ls_kstat, GLOBAL_ZONEID);
1888 kstat_install(lsp->ls_kstat);
1891 if (lsp->ls_cmlbhandle != NULL) {
1892 cmlb_detach(lsp->ls_cmlbhandle, 0);
1893 cmlb_free_handle(&lsp->ls_cmlbhandle);
1896 lofi_zone_unbind(lsp);
1898 mutex_destroy(&lsp->ls_comp_cache_lock);
1899 mutex_destroy(&lsp->ls_comp_bufs_lock);
1900 mutex_destroy(&lsp->ls_kstat_lock);
1901 mutex_destroy(&lsp->ls_vp_lock);
1902 cv_destroy(&lsp->ls_vp_cv);
1958 struct lofi_state *lsp;
1972 lsp = ddi_get_soft_state(lofi_statep, instance);
2006 lsp->ls_dip = dip;
2019 struct lofi_state *lsp;
2031 lsp = ddi_get_soft_state(lofi_statep, instance);
2032 if (lsp != NULL && lsp->ls_vp_ready == B_FALSE) {
2133 lofi_access(struct lofi_state *lsp)
2136 if (INGLOBALZONE(curproc) || lsp->ls_zone.zref_zone == curzone)
2149 struct lofi_state *lsp;
2169 for (lsp = list_head(&lofi_list); lsp != NULL;
2170 lsp = list_next(&lofi_list, lsp)) {
2171 if (lsp->ls_vp == vp) {
2173 *lspp = lsp;
2174 if (lsp->ls_readonly) {
2230 fake_disk_geometry(struct lofi_state *lsp)
2232 u_offset_t dsize = lsp->ls_vp_size - lsp->ls_crypto_offset;
2246 bzero(&lsp->ls_dkg, sizeof (lsp->ls_dkg));
2248 lsp->ls_dkg.dkg_ncyl = dsize / (100 * 1024);
2250 lsp->ls_dkg.dkg_ncyl = dsize / (300 * 1024);
2252 if (lsp->ls_dkg.dkg_ncyl == 0)
2253 lsp->ls_dkg.dkg_ncyl = 1;
2255 lsp->ls_dkg.dkg_pcyl = lsp->ls_dkg.dkg_ncyl;
2256 lsp->ls_dkg.dkg_nhead = 1;
2257 lsp->ls_dkg.dkg_rpm = 7200;
2259 lsp->ls_dkg.dkg_nsect = dsize /
2260 (lsp->ls_dkg.dkg_ncyl << lsp->ls_pbshift);
2272 fake_disk_vtoc(struct lofi_state *lsp, struct vtoc *vt)
2279 vt->v_sectorsz = 1 << lsp->ls_pbshift;
2287 if (lsp->ls_uncomp_seg_sz > 0) {
2299 vt->v_part[0].p_size = lsp->ls_dkg.dkg_pcyl *
2300 lsp->ls_dkg.dkg_nsect * lsp->ls_dkg.dkg_nhead;
2341 lofi_map_compressed_file(struct lofi_state *lsp, char *buf)
2350 tbuf += sizeof (lsp->ls_comp_algorithm);
2351 bcopy(tbuf, &(lsp->ls_uncomp_seg_sz), sizeof (lsp->ls_uncomp_seg_sz));
2352 lsp->ls_uncomp_seg_sz = ntohl(lsp->ls_uncomp_seg_sz);
2357 if (lsp->ls_uncomp_seg_sz < DEV_BSIZE ||
2358 !ISP2(lsp->ls_uncomp_seg_sz))
2361 for (i = 0; !((lsp->ls_uncomp_seg_sz >> i) & 1); i++)
2364 lsp->ls_comp_seg_shift = i;
2366 tbuf += sizeof (lsp->ls_uncomp_seg_sz);
2367 bcopy(tbuf, &(lsp->ls_comp_index_sz), sizeof (lsp->ls_comp_index_sz));
2368 lsp->ls_comp_index_sz = ntohl(lsp->ls_comp_index_sz);
2370 tbuf += sizeof (lsp->ls_comp_index_sz);
2371 bcopy(tbuf, &(lsp->ls_uncomp_last_seg_sz),
2372 sizeof (lsp->ls_uncomp_last_seg_sz));
2373 lsp->ls_uncomp_last_seg_sz = ntohl(lsp->ls_uncomp_last_seg_sz);
2382 lsp->ls_vp_size =
2383 (u_offset_t)(lsp->ls_comp_index_sz - 2) * lsp->ls_uncomp_seg_sz
2384 + lsp->ls_uncomp_last_seg_sz;
2390 index_sz = sizeof (*lsp->ls_comp_seg_index) * lsp->ls_comp_index_sz;
2391 header_len = sizeof (lsp->ls_comp_algorithm) +
2392 sizeof (lsp->ls_uncomp_seg_sz) +
2393 sizeof (lsp->ls_comp_index_sz) +
2394 sizeof (lsp->ls_uncomp_last_seg_sz);
2395 lsp->ls_comp_offbase = header_len + index_sz;
2400 lsp->ls_comp_index_data = kmem_alloc(index_sz, KM_SLEEP);
2401 lsp->ls_comp_index_data_sz = index_sz;
2408 error = vn_rdwr(rw, lsp->ls_vp, lsp->ls_comp_index_data, index_sz,
2415 lsp->ls_comp_seg_index =
2417 (uint64_t *)(lsp->ls_comp_index_data + header_len);
2423 for (i = 0; i < lsp->ls_comp_index_sz; i++) {
2424 lsp->ls_comp_seg_index[i] = lsp->ls_comp_offbase +
2425 BE_64(lsp->ls_comp_seg_index[i]);
2432 lofi_init_crypto(struct lofi_state *lsp, struct lofi_ioctl *klip)
2454 lsp->ls_crypto_enabled = klip->li_crypto_enabled;
2456 mutex_init(&lsp->ls_crypto_lock, NULL, MUTEX_DRIVER, NULL);
2458 lsp->ls_mech.cm_type = crypto_mech2id(klip->li_cipher);
2459 if (lsp->ls_mech.cm_type == CRYPTO_MECH_INVALID) {
2466 lsp->ls_mech.cm_param = NULL;
2467 lsp->ls_mech.cm_param_len = 0;
2469 lsp->ls_iv_type = klip->li_iv_type;
2470 lsp->ls_iv_mech.cm_type = crypto_mech2id(klip->li_iv_cipher);
2471 if (lsp->ls_iv_mech.cm_type == CRYPTO_MECH_INVALID) {
2478 lsp->ls_iv_mech.cm_param = NULL;
2479 lsp->ls_iv_mech.cm_param_len = 0;
2480 lsp->ls_iv_len = klip->li_iv_len;
2486 lsp->ls_key.ck_format = CRYPTO_KEY_RAW;
2487 lsp->ls_key.ck_length = klip->li_key_len;
2488 lsp->ls_key.ck_data = kmem_alloc(
2489 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length), KM_SLEEP);
2490 bcopy(klip->li_key, lsp->ls_key.ck_data,
2491 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
2493 ret = crypto_key_check(&lsp->ls_mech, &lsp->ls_key);
2501 error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE,
2523 bcopy(marker, lsp->ls_crypto.magic,
2524 sizeof (lsp->ls_crypto.magic));
2525 marker += sizeof (lsp->ls_crypto.magic);
2528 bcopy(marker, &(lsp->ls_crypto.version),
2529 sizeof (lsp->ls_crypto.version));
2530 lsp->ls_crypto.version = ntohs(lsp->ls_crypto.version);
2531 marker += sizeof (lsp->ls_crypto.version);
2534 bcopy(marker, lsp->ls_crypto.reserved1,
2535 sizeof (lsp->ls_crypto.reserved1));
2536 marker += sizeof (lsp->ls_crypto.reserved1);
2539 bcopy(marker, &(lsp->ls_crypto.data_sector),
2540 sizeof (lsp->ls_crypto.data_sector));
2541 lsp->ls_crypto.data_sector = ntohl(lsp->ls_crypto.data_sector);
2542 marker += sizeof (lsp->ls_crypto.data_sector);
2546 lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
2571 error = vn_rdwr(UIO_WRITE, lsp->ls_vp, buf, DEV_BSIZE,
2577 bcopy(lofi_crypto_magic, lsp->ls_crypto.magic,
2579 lsp->ls_crypto.version = LOFI_CRYPTO_VERSION;
2580 lsp->ls_crypto.data_sector = LOFI_CRYPTO_DATA_SECTOR;
2581 lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
2605 lofi_init_compress(struct lofi_state *lsp)
2612 error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE, 0, UIO_SYSSPACE,
2622 if (lsp->ls_crypto_enabled)
2626 lsp->ls_comp_algorithm_index = compress_index;
2627 (void) strlcpy(lsp->ls_comp_algorithm,
2629 sizeof (lsp->ls_comp_algorithm));
2632 lsp->ls_comp_bufs = kmem_zalloc(lofi_taskq_nthreads *
2635 return (lofi_map_compressed_file(lsp, buf));
2686 struct lofi_state *lsp = NULL;
2691 lsp = ddi_get_soft_state(lofi_statep, 0);
2692 parent = ddi_get_parent(lsp->ls_dip);
2739 lofi_create_inquiry(struct lofi_state *lsp, struct scsi_inquiry *inq)
2745 mutex_enter(&lsp->ls_vp_lock);
2746 if (lsp->ls_vp != NULL)
2747 p = strrchr(lsp->ls_vp->v_path, '/');
2750 mutex_exit(&lsp->ls_vp_lock);
2803 struct lofi_state *lsp = NULL;
2857 lsp = ddi_get_soft_state(lofi_statep, id);
2858 if (lsp == NULL)
2865 lsp->ls_dev = makedevice(getmajor(dev), LOFI_ID2MINOR(id));
2867 list_create(&lsp->ls_comp_cache, sizeof (struct lofi_comp_cache),
2874 lsp->ls_openflag = flag;
2876 lsp->ls_vp = vp;
2877 lsp->ls_stacked_vp = vp;
2879 lsp->ls_vp_size = vattr.va_size;
2880 lsp->ls_vp_comp_size = lsp->ls_vp_size;
2895 lsp->ls_vp = realvp;
2899 lsp->ls_lbshift = highbit(DEV_BSIZE) - 1;
2900 lsp->ls_pbshift = lsp->ls_lbshift;
2902 lsp->ls_readonly = klip->li_readonly;
2903 lsp->ls_uncomp_seg_sz = 0;
2904 lsp->ls_comp_algorithm[0] = '\0';
2905 lsp->ls_crypto_offset = 0;
2909 lsp->ls_taskq = taskq_create_proc(namebuf, lofi_taskq_nthreads,
2912 if ((error = lofi_init_crypto(lsp, klip)) != 0)
2915 if ((error = lofi_init_compress(lsp)) != 0)
2918 fake_disk_geometry(lsp);
2920 if ((ddi_prop_update_int64(lsp->ls_dev, lsp->ls_dip, SIZE_PROP_NAME,
2921 lsp->ls_vp_size - lsp->ls_crypto_offset)) != DDI_PROP_SUCCESS) {
2926 if ((ddi_prop_update_int64(lsp->ls_dev, lsp->ls_dip, NBLOCKS_PROP_NAME,
2927 (lsp->ls_vp_size - lsp->ls_crypto_offset) / DEV_BSIZE))
2933 list_insert_tail(&lofi_list, lsp);
2937 mutex_enter(&lsp->ls_vp_lock);
2938 lsp->ls_vp_ready = B_TRUE;
2939 cv_broadcast(&lsp->ls_vp_cv);
2940 mutex_exit(&lsp->ls_vp_lock);
2952 if (lsp != NULL) {
2953 lofi_destroy(lsp, credp);
2974 struct lofi_state *lsp;
2988 &lsp)) != 0) {
2997 lsp = ddi_get_soft_state(lofi_statep, klip->li_id);
3000 if (lsp == NULL || lsp->ls_vp == NULL || lofi_access(lsp) != 0) {
3006 klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
3030 if (is_opened(lsp)) {
3032 mutex_enter(&lsp->ls_vp_lock);
3033 lsp->ls_vp_closereq = B_TRUE;
3035 cv_broadcast(&lsp->ls_vp_cv);
3036 while (lsp->ls_vp_iocount > 0)
3037 cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
3038 mutex_exit(&lsp->ls_vp_lock);
3042 lsp->ls_cleanup = 1;
3054 lofi_free_dev(lsp);
3055 lofi_destroy(lsp, credp);
3091 struct lofi_state *lsp;
3106 lsp = ddi_get_soft_state(lofi_statep, klip->li_id);
3107 if (lsp == NULL || lofi_access(lsp) != 0) {
3117 if (vnodetopath(NULL, lsp->ls_stacked_vp, klip->li_filename,
3123 klip->li_readonly = lsp->ls_readonly;
3124 klip->li_labeled = lsp->ls_cmlbhandle != NULL;
3126 (void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
3128 klip->li_crypto_enabled = lsp->ls_crypto_enabled;
3138 klip->li_readonly, &lsp);
3144 klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
3146 klip->li_readonly = lsp->ls_readonly;
3147 klip->li_labeled = lsp->ls_cmlbhandle != NULL;
3158 klip->li_readonly, &lsp);
3165 klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
3166 (void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
3230 struct lofi_state *lsp;
3280 for (lsp = list_head(&lofi_list); lsp != NULL;
3281 lsp = list_next(&lofi_list, lsp)) {
3283 if (lofi_access(lsp) != 0)
3286 i = ddi_get_instance(lsp->ls_dip);
3308 lsp = ddi_get_soft_state(lofi_statep, id);
3309 if (lsp == NULL || lsp->ls_vp_closereq) {
3315 if (ddi_prop_exists(DDI_DEV_T_ANY, lsp->ls_dip, DDI_PROP_DONTPASS,
3317 error = cmlb_ioctl(lsp->ls_cmlbhandle, dev, cmd, arg, flag,
3327 if (lsp->ls_vp == NULL && cmd != DKIOCSTATE)
3335 int shift = lsp->ls_lbshift;
3339 media_info.dki_pbsize = 1U << lsp->ls_pbshift;
3348 (lsp->ls_vp_size - lsp->ls_crypto_offset) >> shift;
3363 fake_disk_vtoc(lsp, &vt);
3394 error = ddi_copyout(&lsp->ls_dkg, (void *)arg,
3409 mutex_enter(&lsp->ls_vp_lock);
3410 lsp->ls_vp_iocount++;
3411 while (((dkstate == DKIO_INSERTED && lsp->ls_vp != NULL) ||
3412 (dkstate == DKIO_DEV_GONE && lsp->ls_vp == NULL)) &&
3413 !lsp->ls_vp_closereq) {
3416 * 'lsp' will remain valid when we return.
3418 if (!cv_wait_sig(&lsp->ls_vp_cv,
3419 &lsp->ls_vp_lock)) {
3420 lsp->ls_vp_iocount--;
3421 cv_broadcast(&lsp->ls_vp_cv);
3422 mutex_exit(&lsp->ls_vp_lock);
3427 dkstate = (!lsp->ls_vp_closereq && lsp->ls_vp != NULL ?
3429 lsp->ls_vp_iocount--;
3430 cv_broadcast(&lsp->ls_vp_cv);
3431 mutex_exit(&lsp->ls_vp_lock);
3444 lofi_create_inquiry(lsp, &inq);
3453 BE_32((lsp->ls_vp_size - lsp->ls_crypto_offset) >>
3454 lsp->ls_lbshift);
3455 capacity.lbasize = BE_32(1 << lsp->ls_lbshift);
3499 struct lofi_state *lsp;
3501 lsp = ddi_get_soft_state(lofi_statep, ddi_get_instance(dip));
3502 if (lsp == NULL) {
3507 return (cmlb_prop_op(lsp->ls_cmlbhandle, dev, dip, prop_op, mod_flags,