1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
23 *
24 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
25 */
26
27 /*
28 * lofi (loopback file) driver - allows you to attach a file to a device,
29 * which can then be accessed through that device. The simple model is that
30 * you tell lofi to open a file, and then use the block device you get as
31 * you would any block device. lofi translates access to the block device
32 * into I/O on the underlying file. This is mostly useful for
33 * mounting images of filesystems.
34 *
35 * lofi is controlled through /dev/lofictl - this is the only device exported
36 * during attach, and is minor number 0. lofiadm communicates with lofi through
37 * ioctls on this device. When a file is attached to lofi, block and character
38 * devices are exported in /dev/lofi and /dev/rlofi. Currently, these devices
39 * are identified by their minor number, and the minor number is also used
40 * as the name in /dev/lofi. If we ever decide to support virtual disks,
41 * we'll have to divide the minor number space to identify fdisk partitions
42 * and slices, and the name will then be the minor number shifted down a
43 * few bits. Minor devices are tracked with state structures handled with
44 * ddi_soft_state(9F) for simplicity.
45 *
46 * A file attached to lofi is opened when attached and not closed until
47 * explicitly detached from lofi. This seems more sensible than deferring
48 * the open until the /dev/lofi device is opened, for a number of reasons.
49 * One is that any failure is likely to be noticed by the person (or script)
50 * running lofiadm. Another is that it would be a security problem if the
51 * file was replaced by another one after being added but before being opened.
52 *
53 * The only hard part about lofi is the ioctls. In order to support things
54 * like 'newfs' on a lofi device, it needs to support certain disk ioctls.
55 * So it has to fake disk geometry and partition information. More may need
56 * to be faked if your favorite utility doesn't work and you think it should
57 * (fdformat doesn't work because it really wants to know the type of floppy
58 * controller to talk to, and that didn't seem easy to fake. Or possibly even
59 * necessary, since we have mkfs_pcfs now).
60 *
61 * Normally, a lofi device cannot be detached if it is open (i.e. busy). To
62 * support simulation of hotplug events, an optional force flag is provided.
63 * If a lofi device is open when a force detach is requested, then the
64 * underlying file is closed and any subsequent operations return EIO. When the
65 * device is closed for the last time, it will be cleaned up at that time. In
66 * addition, the DKIOCSTATE ioctl will return DKIO_DEV_GONE when the device is
67 * detached but not removed.
68 *
69 * Known problems:
70 *
71 * UFS logging. Mounting a UFS filesystem image "logging"
72 * works for basic copy testing but wedges during a build of ON through
73 * that image. Some deadlock in lufs holding the log mutex and then
74 * getting stuck on a buf. So for now, don't do that.
75 *
76 * Direct I/O. Since the filesystem data is being cached in the buffer
77 * cache, _and_ again in the underlying filesystem, it's tempting to
78 * enable direct I/O on the underlying file. Don't, because that deadlocks.
79 * I think to fix the cache-twice problem we might need filesystem support.
80 *
81 * Interesting things to do:
82 *
83 * Allow multiple files for each device. A poor-man's metadisk, basically.
84 *
85 * Pass-through ioctls on block devices. You can (though it's not
86 * documented), give lofi a block device as a file name. Then we shouldn't
87 * need to fake a geometry, however, it may be relevant if you're replacing
88 * metadisk, or using lofi to get crypto.
89 * It makes sense to do lofiadm -c aes -a /dev/dsk/c0t0d0s4 /dev/lofi/1
90 * and then in /etc/vfstab have an entry for /dev/lofi/1 as /export/home.
91 * In fact this even makes sense if you have lofi "above" metadisk.
92 *
93 * Encryption:
94 * Each lofi device can have its own symmetric key and cipher.
95 * They are passed to us by lofiadm(1m) in the correct format for use
96 * with the misc/kcf crypto_* routines.
97 *
98 * Each block has its own IV, that is calculated in lofi_blk_mech(), based
99 * on the "master" key held in the lsp and the block number of the buffer.
100 */
101
102 #include <sys/types.h>
103 #include <netinet/in.h>
104 #include <sys/sysmacros.h>
105 #include <sys/uio.h>
106 #include <sys/kmem.h>
107 #include <sys/cred.h>
108 #include <sys/mman.h>
109 #include <sys/errno.h>
110 #include <sys/aio_req.h>
111 #include <sys/stat.h>
112 #include <sys/file.h>
113 #include <sys/modctl.h>
114 #include <sys/conf.h>
115 #include <sys/debug.h>
116 #include <sys/vnode.h>
117 #include <sys/lofi.h>
118 #include <sys/fcntl.h>
119 #include <sys/pathname.h>
120 #include <sys/filio.h>
121 #include <sys/fdio.h>
122 #include <sys/open.h>
123 #include <sys/disp.h>
124 #include <vm/seg_map.h>
125 #include <sys/ddi.h>
126 #include <sys/sunddi.h>
127 #include <sys/zmod.h>
128 #include <sys/id_space.h>
129 #include <sys/mkdev.h>
130 #include <sys/crypto/common.h>
131 #include <sys/crypto/api.h>
132 #include <sys/rctl.h>
133 #include <LzmaDec.h>
134
135 /*
136 * The basis for CRYOFF is derived from usr/src/uts/common/sys/fs/ufs_fs.h.
137 * Crypto metadata, if it exists, is located at the end of the boot block
138 * (BBOFF + BBSIZE, which is SBOFF). The super block and everything after
139 * is offset by the size of the crypto metadata which is handled by
140 * lsp->ls_crypto_offset.
141 */
142 #define CRYOFF ((off_t)8192)
143
144 #define NBLOCKS_PROP_NAME "Nblocks"
145 #define SIZE_PROP_NAME "Size"
146 #define ZONE_PROP_NAME "zone"
147
148 #define SETUP_C_DATA(cd, buf, len) \
149 (cd).cd_format = CRYPTO_DATA_RAW; \
150 (cd).cd_offset = 0; \
151 (cd).cd_miscdata = NULL; \
152 (cd).cd_length = (len); \
153 (cd).cd_raw.iov_base = (buf); \
154 (cd).cd_raw.iov_len = (len);
155
156 #define UIO_CHECK(uio) \
157 if (((uio)->uio_loffset % DEV_BSIZE) != 0 || \
158 ((uio)->uio_resid % DEV_BSIZE) != 0) { \
159 return (EINVAL); \
160 }
161
162 static dev_info_t *lofi_dip = NULL;
163 static void *lofi_statep = NULL;
164 static kmutex_t lofi_lock; /* state lock */
165 static id_space_t *lofi_minor_id;
166 static list_t lofi_list;
167 static zone_key_t lofi_zone_key;
168
169 /*
170 * Because lofi_taskq_nthreads limits the actual swamping of the device, the
171 * maxalloc parameter (lofi_taskq_maxalloc) should be tuned conservatively
172 * high. If we want to be assured that the underlying device is always busy,
173 * we must be sure that the number of bytes enqueued when the number of
174 * enqueued tasks exceeds maxalloc is sufficient to keep the device busy for
175 * the duration of the sleep time in taskq_ent_alloc(). That is, lofi should
176 * set maxalloc to be the maximum throughput (in bytes per second) of the
177 * underlying device divided by the minimum I/O size. We assume a realistic
178 * maximum throughput of one hundred megabytes per second; we set maxalloc on
179 * the lofi task queue to be 104857600 divided by DEV_BSIZE.
180 */
181 static int lofi_taskq_maxalloc = 104857600 / DEV_BSIZE;
182 static int lofi_taskq_nthreads = 4; /* # of taskq threads per device */
183
184 const char lofi_crypto_magic[6] = LOFI_CRYPTO_MAGIC;
185
186 /*
187 * To avoid decompressing data in a compressed segment multiple times
188 * when accessing small parts of a segment's data, we cache and reuse
189 * the uncompressed segment's data.
190 *
191 * A single cached segment is sufficient to avoid lots of duplicate
192 * segment decompress operations. A small cache size also reduces the
193 * memory footprint.
194 *
195 * lofi_max_comp_cache is the maximum number of decompressed data segments
196 * cached for each compressed lofi image. It can be set to 0 to disable
197 * caching.
198 */
199
200 uint32_t lofi_max_comp_cache = 1;
201
202 static int gzip_decompress(void *src, size_t srclen, void *dst,
203 size_t *destlen, int level);
204
205 static int lzma_decompress(void *src, size_t srclen, void *dst,
206 size_t *dstlen, int level);
207
208 lofi_compress_info_t lofi_compress_table[LOFI_COMPRESS_FUNCTIONS] = {
209 {gzip_decompress, NULL, 6, "gzip"}, /* default */
210 {gzip_decompress, NULL, 6, "gzip-6"},
211 {gzip_decompress, NULL, 9, "gzip-9"},
212 {lzma_decompress, NULL, 0, "lzma"}
213 };
214
215 /*ARGSUSED*/
216 static void
217 *SzAlloc(void *p, size_t size)
218 {
219 return (kmem_alloc(size, KM_SLEEP));
220 }
221
222 /*ARGSUSED*/
223 static void
224 SzFree(void *p, void *address, size_t size)
225 {
226 kmem_free(address, size);
227 }
228
229 static ISzAlloc g_Alloc = { SzAlloc, SzFree };
230
231 /*
232 * Free data referenced by the linked list of cached uncompressed
233 * segments.
234 */
235 static void
236 lofi_free_comp_cache(struct lofi_state *lsp)
237 {
238 struct lofi_comp_cache *lc;
239
240 while ((lc = list_remove_head(&lsp->ls_comp_cache)) != NULL) {
241 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
242 kmem_free(lc, sizeof (struct lofi_comp_cache));
243 lsp->ls_comp_cache_count--;
244 }
245 ASSERT(lsp->ls_comp_cache_count == 0);
246 }
247
248 static int
249 is_opened(struct lofi_state *lsp)
250 {
251 ASSERT(MUTEX_HELD(&lofi_lock));
252 return (lsp->ls_chr_open || lsp->ls_blk_open || lsp->ls_lyr_open_count);
253 }
254
255 static int
256 mark_opened(struct lofi_state *lsp, int otyp)
257 {
258 ASSERT(MUTEX_HELD(&lofi_lock));
259 switch (otyp) {
260 case OTYP_CHR:
261 lsp->ls_chr_open = 1;
262 break;
263 case OTYP_BLK:
264 lsp->ls_blk_open = 1;
265 break;
266 case OTYP_LYR:
267 lsp->ls_lyr_open_count++;
268 break;
269 default:
270 return (-1);
271 }
272 return (0);
273 }
274
275 static void
276 mark_closed(struct lofi_state *lsp, int otyp)
277 {
278 ASSERT(MUTEX_HELD(&lofi_lock));
279 switch (otyp) {
280 case OTYP_CHR:
281 lsp->ls_chr_open = 0;
282 break;
283 case OTYP_BLK:
284 lsp->ls_blk_open = 0;
285 break;
286 case OTYP_LYR:
287 lsp->ls_lyr_open_count--;
288 break;
289 default:
290 break;
291 }
292 }
293
294 static void
295 lofi_free_crypto(struct lofi_state *lsp)
296 {
297 ASSERT(MUTEX_HELD(&lofi_lock));
298
299 if (lsp->ls_crypto_enabled) {
300 /*
301 * Clean up the crypto state so that it doesn't hang around
302 * in memory after we are done with it.
303 */
304 if (lsp->ls_key.ck_data != NULL) {
305 bzero(lsp->ls_key.ck_data,
306 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
307 kmem_free(lsp->ls_key.ck_data,
308 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
309 lsp->ls_key.ck_data = NULL;
310 lsp->ls_key.ck_length = 0;
311 }
312
313 if (lsp->ls_mech.cm_param != NULL) {
314 kmem_free(lsp->ls_mech.cm_param,
315 lsp->ls_mech.cm_param_len);
316 lsp->ls_mech.cm_param = NULL;
317 lsp->ls_mech.cm_param_len = 0;
318 }
319
320 if (lsp->ls_iv_mech.cm_param != NULL) {
321 kmem_free(lsp->ls_iv_mech.cm_param,
322 lsp->ls_iv_mech.cm_param_len);
323 lsp->ls_iv_mech.cm_param = NULL;
324 lsp->ls_iv_mech.cm_param_len = 0;
325 }
326
327 mutex_destroy(&lsp->ls_crypto_lock);
328 }
329 }
330
331 static void
332 lofi_destroy(struct lofi_state *lsp, cred_t *credp)
333 {
334 minor_t minor = getminor(lsp->ls_dev);
335 int i;
336
337 ASSERT(MUTEX_HELD(&lofi_lock));
338
339 list_remove(&lofi_list, lsp);
340
341 lofi_free_crypto(lsp);
342
343 /*
344 * Free pre-allocated compressed buffers
345 */
346 if (lsp->ls_comp_bufs != NULL) {
347 for (i = 0; i < lofi_taskq_nthreads; i++) {
348 if (lsp->ls_comp_bufs[i].bufsize > 0)
349 kmem_free(lsp->ls_comp_bufs[i].buf,
350 lsp->ls_comp_bufs[i].bufsize);
351 }
352 kmem_free(lsp->ls_comp_bufs,
353 sizeof (struct compbuf) * lofi_taskq_nthreads);
354 }
355
356 (void) VOP_CLOSE(lsp->ls_vp, lsp->ls_openflag,
357 1, 0, credp, NULL);
358 VN_RELE(lsp->ls_vp);
359 if (lsp->ls_stacked_vp != lsp->ls_vp)
360 VN_RELE(lsp->ls_stacked_vp);
361
362 taskq_destroy(lsp->ls_taskq);
363
364 if (lsp->ls_kstat != NULL)
365 kstat_delete(lsp->ls_kstat);
366
367 /*
368 * Free cached decompressed segment data
369 */
370 lofi_free_comp_cache(lsp);
371 list_destroy(&lsp->ls_comp_cache);
372
373 if (lsp->ls_uncomp_seg_sz > 0) {
374 kmem_free(lsp->ls_comp_index_data, lsp->ls_comp_index_data_sz);
375 lsp->ls_uncomp_seg_sz = 0;
376 }
377
378 rctl_decr_lofi(lsp->ls_zone.zref_zone, 1);
379 zone_rele_ref(&lsp->ls_zone, ZONE_REF_LOFI);
380
381 mutex_destroy(&lsp->ls_comp_cache_lock);
382 mutex_destroy(&lsp->ls_comp_bufs_lock);
383 mutex_destroy(&lsp->ls_kstat_lock);
384 mutex_destroy(&lsp->ls_vp_lock);
385
386 ASSERT(ddi_get_soft_state(lofi_statep, minor) == lsp);
387 ddi_soft_state_free(lofi_statep, minor);
388 id_free(lofi_minor_id, minor);
389 }
390
391 static void
392 lofi_free_dev(dev_t dev)
393 {
394 minor_t minor = getminor(dev);
395 char namebuf[50];
396
397 ASSERT(MUTEX_HELD(&lofi_lock));
398
399 (void) ddi_prop_remove(dev, lofi_dip, ZONE_PROP_NAME);
400 (void) ddi_prop_remove(dev, lofi_dip, SIZE_PROP_NAME);
401 (void) ddi_prop_remove(dev, lofi_dip, NBLOCKS_PROP_NAME);
402
403 (void) snprintf(namebuf, sizeof (namebuf), "%d", minor);
404 ddi_remove_minor_node(lofi_dip, namebuf);
405 (void) snprintf(namebuf, sizeof (namebuf), "%d,raw", minor);
406 ddi_remove_minor_node(lofi_dip, namebuf);
407 }
408
409 /*ARGSUSED*/
410 static void
411 lofi_zone_shutdown(zoneid_t zoneid, void *arg)
412 {
413 struct lofi_state *lsp;
414 struct lofi_state *next;
415
416 mutex_enter(&lofi_lock);
417
418 for (lsp = list_head(&lofi_list); lsp != NULL; lsp = next) {
419
420 /* lofi_destroy() frees lsp */
421 next = list_next(&lofi_list, lsp);
422
423 if (lsp->ls_zone.zref_zone->zone_id != zoneid)
424 continue;
425
426 /*
427 * No in-zone processes are running, but something has this
428 * open. It's either a global zone process, or a lofi
429 * mount. In either case we set ls_cleanup so the last
430 * user destroys the device.
431 */
432 if (is_opened(lsp)) {
433 lsp->ls_cleanup = 1;
434 } else {
435 lofi_free_dev(lsp->ls_dev);
436 lofi_destroy(lsp, kcred);
437 }
438 }
439
440 mutex_exit(&lofi_lock);
441 }
442
443 /*ARGSUSED*/
444 static int
445 lofi_open(dev_t *devp, int flag, int otyp, struct cred *credp)
446 {
447 minor_t minor;
448 struct lofi_state *lsp;
449
450 /*
451 * lofiadm -a /dev/lofi/1 gets us here.
452 */
453 if (mutex_owner(&lofi_lock) == curthread)
454 return (EINVAL);
455
456 mutex_enter(&lofi_lock);
457
458 minor = getminor(*devp);
459
460 /* master control device */
461 if (minor == 0) {
462 mutex_exit(&lofi_lock);
463 return (0);
464 }
465
466 /* otherwise, the mapping should already exist */
467 lsp = ddi_get_soft_state(lofi_statep, minor);
468 if (lsp == NULL) {
469 mutex_exit(&lofi_lock);
470 return (EINVAL);
471 }
472
473 if (lsp->ls_vp == NULL) {
474 mutex_exit(&lofi_lock);
475 return (ENXIO);
476 }
477
478 if (lsp->ls_readonly && (flag & FWRITE)) {
479 mutex_exit(&lofi_lock);
480 return (EROFS);
481 }
482
483 if (mark_opened(lsp, otyp) == -1) {
484 mutex_exit(&lofi_lock);
485 return (EINVAL);
486 }
487
488 mutex_exit(&lofi_lock);
489 return (0);
490 }
491
492 /*ARGSUSED*/
493 static int
494 lofi_close(dev_t dev, int flag, int otyp, struct cred *credp)
495 {
496 minor_t minor;
497 struct lofi_state *lsp;
498
499 mutex_enter(&lofi_lock);
500 minor = getminor(dev);
501 lsp = ddi_get_soft_state(lofi_statep, minor);
502 if (lsp == NULL) {
503 mutex_exit(&lofi_lock);
504 return (EINVAL);
505 }
506
507 if (minor == 0) {
508 mutex_exit(&lofi_lock);
509 return (0);
510 }
511
512 mark_closed(lsp, otyp);
513
514 /*
515 * If we forcibly closed the underlying device (li_force), or
516 * asked for cleanup (li_cleanup), finish up if we're the last
517 * out of the door.
518 */
519 if (!is_opened(lsp) && (lsp->ls_cleanup || lsp->ls_vp == NULL)) {
520 lofi_free_dev(lsp->ls_dev);
521 lofi_destroy(lsp, credp);
522 }
523
524 mutex_exit(&lofi_lock);
525 return (0);
526 }
527
528 /*
529 * Sets the mechanism's initialization vector (IV) if one is needed.
530 * The IV is computed from the data block number. lsp->ls_mech is
531 * altered so that:
532 * lsp->ls_mech.cm_param_len is set to the IV len.
533 * lsp->ls_mech.cm_param is set to the IV.
534 */
535 static int
536 lofi_blk_mech(struct lofi_state *lsp, longlong_t lblkno)
537 {
538 int ret;
539 crypto_data_t cdata;
540 char *iv;
541 size_t iv_len;
542 size_t min;
543 void *data;
544 size_t datasz;
545
546 ASSERT(MUTEX_HELD(&lsp->ls_crypto_lock));
547
548 if (lsp == NULL)
549 return (CRYPTO_DEVICE_ERROR);
550
551 /* lsp->ls_mech.cm_param{_len} has already been set for static iv */
552 if (lsp->ls_iv_type == IVM_NONE) {
553 return (CRYPTO_SUCCESS);
554 }
555
556 /*
557 * if kmem already alloced from previous call and it's the same size
558 * we need now, just recycle it; allocate new kmem only if we have to
559 */
560 if (lsp->ls_mech.cm_param == NULL ||
561 lsp->ls_mech.cm_param_len != lsp->ls_iv_len) {
562 iv_len = lsp->ls_iv_len;
563 iv = kmem_zalloc(iv_len, KM_SLEEP);
564 } else {
565 iv_len = lsp->ls_mech.cm_param_len;
566 iv = lsp->ls_mech.cm_param;
567 bzero(iv, iv_len);
568 }
569
570 switch (lsp->ls_iv_type) {
571 case IVM_ENC_BLKNO:
572 /* iv is not static, lblkno changes each time */
573 data = &lblkno;
574 datasz = sizeof (lblkno);
575 break;
576 default:
577 data = 0;
578 datasz = 0;
579 break;
580 }
581
582 /*
583 * write blkno into the iv buffer padded on the left in case
584 * blkno ever grows bigger than its current longlong_t size
585 * or a variation other than blkno is used for the iv data
586 */
587 min = MIN(datasz, iv_len);
588 bcopy(data, iv + (iv_len - min), min);
589
590 /* encrypt the data in-place to get the IV */
591 SETUP_C_DATA(cdata, iv, iv_len);
592
593 ret = crypto_encrypt(&lsp->ls_iv_mech, &cdata, &lsp->ls_key,
594 NULL, NULL, NULL);
595 if (ret != CRYPTO_SUCCESS) {
596 cmn_err(CE_WARN, "failed to create iv for block %lld: (0x%x)",
597 lblkno, ret);
598 if (lsp->ls_mech.cm_param != iv)
599 kmem_free(iv, iv_len);
600
601 return (ret);
602 }
603
604 /* clean up the iv from the last computation */
605 if (lsp->ls_mech.cm_param != NULL && lsp->ls_mech.cm_param != iv)
606 kmem_free(lsp->ls_mech.cm_param, lsp->ls_mech.cm_param_len);
607
608 lsp->ls_mech.cm_param_len = iv_len;
609 lsp->ls_mech.cm_param = iv;
610
611 return (CRYPTO_SUCCESS);
612 }
613
614 /*
615 * Performs encryption and decryption of a chunk of data of size "len",
616 * one DEV_BSIZE block at a time. "len" is assumed to be a multiple of
617 * DEV_BSIZE.
618 */
619 static int
620 lofi_crypto(struct lofi_state *lsp, struct buf *bp, caddr_t plaintext,
621 caddr_t ciphertext, size_t len, boolean_t op_encrypt)
622 {
623 crypto_data_t cdata;
624 crypto_data_t wdata;
625 int ret;
626 longlong_t lblkno = bp->b_lblkno;
627
628 mutex_enter(&lsp->ls_crypto_lock);
629
630 /*
631 * though we could encrypt/decrypt entire "len" chunk of data, we need
632 * to break it into DEV_BSIZE pieces to capture blkno incrementing
633 */
634 SETUP_C_DATA(cdata, plaintext, len);
635 cdata.cd_length = DEV_BSIZE;
636 if (ciphertext != NULL) { /* not in-place crypto */
637 SETUP_C_DATA(wdata, ciphertext, len);
638 wdata.cd_length = DEV_BSIZE;
639 }
640
641 do {
642 ret = lofi_blk_mech(lsp, lblkno);
643 if (ret != CRYPTO_SUCCESS)
644 continue;
645
646 if (op_encrypt) {
647 ret = crypto_encrypt(&lsp->ls_mech, &cdata,
648 &lsp->ls_key, NULL,
649 ((ciphertext != NULL) ? &wdata : NULL), NULL);
650 } else {
651 ret = crypto_decrypt(&lsp->ls_mech, &cdata,
652 &lsp->ls_key, NULL,
653 ((ciphertext != NULL) ? &wdata : NULL), NULL);
654 }
655
656 cdata.cd_offset += DEV_BSIZE;
657 if (ciphertext != NULL)
658 wdata.cd_offset += DEV_BSIZE;
659 lblkno++;
660 } while (ret == CRYPTO_SUCCESS && cdata.cd_offset < len);
661
662 mutex_exit(&lsp->ls_crypto_lock);
663
664 if (ret != CRYPTO_SUCCESS) {
665 cmn_err(CE_WARN, "%s failed for block %lld: (0x%x)",
666 op_encrypt ? "crypto_encrypt()" : "crypto_decrypt()",
667 lblkno, ret);
668 }
669
670 return (ret);
671 }
672
673 #define RDWR_RAW 1
674 #define RDWR_BCOPY 2
675
676 static int
677 lofi_rdwr(caddr_t bufaddr, offset_t offset, struct buf *bp,
678 struct lofi_state *lsp, size_t len, int method, caddr_t bcopy_locn)
679 {
680 ssize_t resid;
681 int isread;
682 int error;
683
684 /*
685 * Handles reads/writes for both plain and encrypted lofi
686 * Note: offset is already shifted by lsp->ls_crypto_offset
687 * when it gets here.
688 */
689
690 isread = bp->b_flags & B_READ;
691 if (isread) {
692 if (method == RDWR_BCOPY) {
693 /* DO NOT update bp->b_resid for bcopy */
694 bcopy(bcopy_locn, bufaddr, len);
695 error = 0;
696 } else { /* RDWR_RAW */
697 error = vn_rdwr(UIO_READ, lsp->ls_vp, bufaddr, len,
698 offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred,
699 &resid);
700 bp->b_resid = resid;
701 }
702 if (lsp->ls_crypto_enabled && error == 0) {
703 if (lofi_crypto(lsp, bp, bufaddr, NULL, len,
704 B_FALSE) != CRYPTO_SUCCESS) {
705 /*
706 * XXX: original code didn't set residual
707 * back to len because no error was expected
708 * from bcopy() if encryption is not enabled
709 */
710 if (method != RDWR_BCOPY)
711 bp->b_resid = len;
712 error = EIO;
713 }
714 }
715 return (error);
716 } else {
717 void *iobuf = bufaddr;
718
719 if (lsp->ls_crypto_enabled) {
720 /* don't do in-place crypto to keep bufaddr intact */
721 iobuf = kmem_alloc(len, KM_SLEEP);
722 if (lofi_crypto(lsp, bp, bufaddr, iobuf, len,
723 B_TRUE) != CRYPTO_SUCCESS) {
724 kmem_free(iobuf, len);
725 if (method != RDWR_BCOPY)
726 bp->b_resid = len;
727 return (EIO);
728 }
729 }
730 if (method == RDWR_BCOPY) {
731 /* DO NOT update bp->b_resid for bcopy */
732 bcopy(iobuf, bcopy_locn, len);
733 error = 0;
734 } else { /* RDWR_RAW */
735 error = vn_rdwr(UIO_WRITE, lsp->ls_vp, iobuf, len,
736 offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred,
737 &resid);
738 bp->b_resid = resid;
739 }
740 if (lsp->ls_crypto_enabled) {
741 kmem_free(iobuf, len);
742 }
743 return (error);
744 }
745 }
746
747 static int
748 lofi_mapped_rdwr(caddr_t bufaddr, offset_t offset, struct buf *bp,
749 struct lofi_state *lsp)
750 {
751 int error;
752 offset_t alignedoffset, mapoffset;
753 size_t xfersize;
754 int isread;
755 int smflags;
756 caddr_t mapaddr;
757 size_t len;
758 enum seg_rw srw;
759 int save_error;
760
761 /*
762 * Note: offset is already shifted by lsp->ls_crypto_offset
763 * when it gets here.
764 */
765 if (lsp->ls_crypto_enabled)
766 ASSERT(lsp->ls_vp_comp_size == lsp->ls_vp_size);
767
768 /*
769 * segmap always gives us an 8K (MAXBSIZE) chunk, aligned on
770 * an 8K boundary, but the buf transfer address may not be
771 * aligned on more than a 512-byte boundary (we don't enforce
772 * that even though we could). This matters since the initial
773 * part of the transfer may not start at offset 0 within the
774 * segmap'd chunk. So we have to compensate for that with
775 * 'mapoffset'. Subsequent chunks always start off at the
776 * beginning, and the last is capped by b_resid
777 *
778 * Visually, where "|" represents page map boundaries:
779 * alignedoffset (mapaddr begins at this segmap boundary)
780 * | offset (from beginning of file)
781 * | | len
782 * v v v
783 * ===|====X========|====...======|========X====|====
784 * /-------------...---------------/
785 * ^ bp->b_bcount/bp->b_resid at start
786 * /----/--------/----...------/--------/
787 * ^ ^ ^ ^ ^
788 * | | | | nth xfersize (<= MAXBSIZE)
789 * | | 2nd thru n-1st xfersize (= MAXBSIZE)
790 * | 1st xfersize (<= MAXBSIZE)
791 * mapoffset (offset into 1st segmap, non-0 1st time, 0 thereafter)
792 *
793 * Notes: "alignedoffset" is "offset" rounded down to nearest
794 * MAXBSIZE boundary. "len" is next page boundary of size
795 * PAGESIZE after "alignedoffset".
796 */
797 mapoffset = offset & MAXBOFFSET;
798 alignedoffset = offset - mapoffset;
799 bp->b_resid = bp->b_bcount;
800 isread = bp->b_flags & B_READ;
801 srw = isread ? S_READ : S_WRITE;
802 do {
803 xfersize = MIN(lsp->ls_vp_comp_size - offset,
804 MIN(MAXBSIZE - mapoffset, bp->b_resid));
805 len = roundup(mapoffset + xfersize, PAGESIZE);
806 mapaddr = segmap_getmapflt(segkmap, lsp->ls_vp,
807 alignedoffset, MAXBSIZE, 1, srw);
808 /*
809 * Now fault in the pages. This lets us check
810 * for errors before we reference mapaddr and
811 * try to resolve the fault in bcopy (which would
812 * panic instead). And this can easily happen,
813 * particularly if you've lofi'd a file over NFS
814 * and someone deletes the file on the server.
815 */
816 error = segmap_fault(kas.a_hat, segkmap, mapaddr,
817 len, F_SOFTLOCK, srw);
818 if (error) {
819 (void) segmap_release(segkmap, mapaddr, 0);
820 if (FC_CODE(error) == FC_OBJERR)
821 error = FC_ERRNO(error);
822 else
823 error = EIO;
824 break;
825 }
826 /* error may be non-zero for encrypted lofi */
827 error = lofi_rdwr(bufaddr, 0, bp, lsp, xfersize,
828 RDWR_BCOPY, mapaddr + mapoffset);
829 if (error == 0) {
830 bp->b_resid -= xfersize;
831 bufaddr += xfersize;
832 offset += xfersize;
833 }
834 smflags = 0;
835 if (isread) {
836 smflags |= SM_FREE;
837 /*
838 * If we're reading an entire page starting
839 * at a page boundary, there's a good chance
840 * we won't need it again. Put it on the
841 * head of the freelist.
842 */
843 if (mapoffset == 0 && xfersize == MAXBSIZE)
844 smflags |= SM_DONTNEED;
845 } else {
846 /*
847 * Write back good pages, it is okay to
848 * always release asynchronous here as we'll
849 * follow with VOP_FSYNC for B_SYNC buffers.
850 */
851 if (error == 0)
852 smflags |= SM_WRITE | SM_ASYNC;
853 }
854 (void) segmap_fault(kas.a_hat, segkmap, mapaddr,
855 len, F_SOFTUNLOCK, srw);
856 save_error = segmap_release(segkmap, mapaddr, smflags);
857 if (error == 0)
858 error = save_error;
859 /* only the first map may start partial */
860 mapoffset = 0;
861 alignedoffset += MAXBSIZE;
862 } while ((error == 0) && (bp->b_resid > 0) &&
863 (offset < lsp->ls_vp_comp_size));
864
865 return (error);
866 }
867
868 /*
869 * Check if segment seg_index is present in the decompressed segment
870 * data cache.
871 *
872 * Returns a pointer to the decompressed segment data cache entry if
873 * found, and NULL when decompressed data for this segment is not yet
874 * cached.
875 */
876 static struct lofi_comp_cache *
877 lofi_find_comp_data(struct lofi_state *lsp, uint64_t seg_index)
878 {
879 struct lofi_comp_cache *lc;
880
881 ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
882
883 for (lc = list_head(&lsp->ls_comp_cache); lc != NULL;
884 lc = list_next(&lsp->ls_comp_cache, lc)) {
885 if (lc->lc_index == seg_index) {
886 /*
887 * Decompressed segment data was found in the
888 * cache.
889 *
890 * The cache uses an LRU replacement strategy;
891 * move the entry to head of list.
892 */
893 list_remove(&lsp->ls_comp_cache, lc);
894 list_insert_head(&lsp->ls_comp_cache, lc);
895 return (lc);
896 }
897 }
898 return (NULL);
899 }
900
901 /*
902 * Add the data for a decompressed segment at segment index
903 * seg_index to the cache of the decompressed segments.
904 *
905 * Returns a pointer to the cache element structure in case
906 * the data was added to the cache; returns NULL when the data
907 * wasn't cached.
908 */
909 static struct lofi_comp_cache *
910 lofi_add_comp_data(struct lofi_state *lsp, uint64_t seg_index,
911 uchar_t *data)
912 {
913 struct lofi_comp_cache *lc;
914
915 ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
916
917 while (lsp->ls_comp_cache_count > lofi_max_comp_cache) {
918 lc = list_remove_tail(&lsp->ls_comp_cache);
919 ASSERT(lc != NULL);
920 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
921 kmem_free(lc, sizeof (struct lofi_comp_cache));
922 lsp->ls_comp_cache_count--;
923 }
924
925 /*
926 * Do not cache when disabled by tunable variable
927 */
928 if (lofi_max_comp_cache == 0)
929 return (NULL);
930
931 /*
932 * When the cache has not yet reached the maximum allowed
933 * number of segments, allocate a new cache element.
934 * Otherwise the cache is full; reuse the last list element
935 * (LRU) for caching the decompressed segment data.
936 *
937 * The cache element for the new decompressed segment data is
938 * added to the head of the list.
939 */
940 if (lsp->ls_comp_cache_count < lofi_max_comp_cache) {
941 lc = kmem_alloc(sizeof (struct lofi_comp_cache), KM_SLEEP);
942 lc->lc_data = NULL;
943 list_insert_head(&lsp->ls_comp_cache, lc);
944 lsp->ls_comp_cache_count++;
945 } else {
946 lc = list_remove_tail(&lsp->ls_comp_cache);
947 if (lc == NULL)
948 return (NULL);
949 list_insert_head(&lsp->ls_comp_cache, lc);
950 }
951
952 /*
953 * Free old uncompressed segment data when reusing a cache
954 * entry.
955 */
956 if (lc->lc_data != NULL)
957 kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
958
959 lc->lc_data = data;
960 lc->lc_index = seg_index;
961 return (lc);
962 }
963
964
965 /*ARGSUSED*/
966 static int
967 gzip_decompress(void *src, size_t srclen, void *dst,
968 size_t *dstlen, int level)
969 {
970 ASSERT(*dstlen >= srclen);
971
972 if (z_uncompress(dst, dstlen, src, srclen) != Z_OK)
973 return (-1);
974 return (0);
975 }
976
977 #define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8)
978 /*ARGSUSED*/
979 static int
980 lzma_decompress(void *src, size_t srclen, void *dst,
981 size_t *dstlen, int level)
982 {
983 size_t insizepure;
984 void *actual_src;
985 ELzmaStatus status;
986
987 insizepure = srclen - LZMA_HEADER_SIZE;
988 actual_src = (void *)((Byte *)src + LZMA_HEADER_SIZE);
989
990 if (LzmaDecode((Byte *)dst, (size_t *)dstlen,
991 (const Byte *)actual_src, &insizepure,
992 (const Byte *)src, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status,
993 &g_Alloc) != SZ_OK) {
994 return (-1);
995 }
996 return (0);
997 }
998
999 /*
1000 * This is basically what strategy used to be before we found we
1001 * needed task queues.
1002 */
1003 static void
1004 lofi_strategy_task(void *arg)
1005 {
1006 struct buf *bp = (struct buf *)arg;
1007 int error;
1008 int syncflag = 0;
1009 struct lofi_state *lsp;
1010 offset_t offset;
1011 caddr_t bufaddr;
1012 size_t len;
1013 size_t xfersize;
1014 boolean_t bufinited = B_FALSE;
1015
1016 lsp = ddi_get_soft_state(lofi_statep, getminor(bp->b_edev));
1017 if (lsp == NULL) {
1018 error = ENXIO;
1019 goto errout;
1020 }
1021 if (lsp->ls_kstat) {
1022 mutex_enter(lsp->ls_kstat->ks_lock);
1023 kstat_waitq_to_runq(KSTAT_IO_PTR(lsp->ls_kstat));
1024 mutex_exit(lsp->ls_kstat->ks_lock);
1025 }
1026 bp_mapin(bp);
1027 bufaddr = bp->b_un.b_addr;
1028 offset = bp->b_lblkno * DEV_BSIZE; /* offset within file */
1029 if (lsp->ls_crypto_enabled) {
1030 /* encrypted data really begins after crypto header */
1031 offset += lsp->ls_crypto_offset;
1032 }
1033 len = bp->b_bcount;
1034 bufinited = B_TRUE;
1035
1036 if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
1037 error = EIO;
1038 goto errout;
1039 }
1040
1041 /*
1042 * If we're writing and the buffer was not B_ASYNC
1043 * we'll follow up with a VOP_FSYNC() to force any
1044 * asynchronous I/O to stable storage.
1045 */
1046 if (!(bp->b_flags & B_READ) && !(bp->b_flags & B_ASYNC))
1047 syncflag = FSYNC;
1048
1049 /*
1050 * We used to always use vn_rdwr here, but we cannot do that because
1051 * we might decide to read or write from the the underlying
1052 * file during this call, which would be a deadlock because
1053 * we have the rw_lock. So instead we page, unless it's not
1054 * mapable or it's a character device or it's an encrypted lofi.
1055 */
1056 if ((lsp->ls_vp->v_flag & VNOMAP) || (lsp->ls_vp->v_type == VCHR) ||
1057 lsp->ls_crypto_enabled) {
1058 error = lofi_rdwr(bufaddr, offset, bp, lsp, len, RDWR_RAW,
1059 NULL);
1060 } else if (lsp->ls_uncomp_seg_sz == 0) {
1061 error = lofi_mapped_rdwr(bufaddr, offset, bp, lsp);
1062 } else {
1063 uchar_t *compressed_seg = NULL, *cmpbuf;
1064 uchar_t *uncompressed_seg = NULL;
1065 lofi_compress_info_t *li;
1066 size_t oblkcount;
1067 ulong_t seglen;
1068 uint64_t sblkno, eblkno, cmpbytes;
1069 uint64_t uncompressed_seg_index;
1070 struct lofi_comp_cache *lc;
1071 offset_t sblkoff, eblkoff;
1072 u_offset_t salign, ealign;
1073 u_offset_t sdiff;
1074 uint32_t comp_data_sz;
1075 uint64_t i;
1076 int j;
1077
1078 /*
1079 * From here on we're dealing primarily with compressed files
1080 */
1081 ASSERT(!lsp->ls_crypto_enabled);
1082
1083 /*
1084 * Compressed files can only be read from and
1085 * not written to
1086 */
1087 if (!(bp->b_flags & B_READ)) {
1088 bp->b_resid = bp->b_bcount;
1089 error = EROFS;
1090 goto done;
1091 }
1092
1093 ASSERT(lsp->ls_comp_algorithm_index >= 0);
1094 li = &lofi_compress_table[lsp->ls_comp_algorithm_index];
1095 /*
1096 * Compute starting and ending compressed segment numbers
1097 * We use only bitwise operations avoiding division and
1098 * modulus because we enforce the compression segment size
1099 * to a power of 2
1100 */
1101 sblkno = offset >> lsp->ls_comp_seg_shift;
1102 sblkoff = offset & (lsp->ls_uncomp_seg_sz - 1);
1103 eblkno = (offset + bp->b_bcount) >> lsp->ls_comp_seg_shift;
1104 eblkoff = (offset + bp->b_bcount) & (lsp->ls_uncomp_seg_sz - 1);
1105
1106 /*
1107 * Check the decompressed segment cache.
1108 *
1109 * The cache is used only when the requested data
1110 * is within a segment. Requests that cross
1111 * segment boundaries bypass the cache.
1112 */
1113 if (sblkno == eblkno ||
1114 (sblkno + 1 == eblkno && eblkoff == 0)) {
1115 /*
1116 * Request doesn't cross a segment boundary,
1117 * now check the cache.
1118 */
1119 mutex_enter(&lsp->ls_comp_cache_lock);
1120 lc = lofi_find_comp_data(lsp, sblkno);
1121 if (lc != NULL) {
1122 /*
1123 * We've found the decompressed segment
1124 * data in the cache; reuse it.
1125 */
1126 bcopy(lc->lc_data + sblkoff, bufaddr,
1127 bp->b_bcount);
1128 mutex_exit(&lsp->ls_comp_cache_lock);
1129 bp->b_resid = 0;
1130 error = 0;
1131 goto done;
1132 }
1133 mutex_exit(&lsp->ls_comp_cache_lock);
1134 }
1135
1136 /*
1137 * Align start offset to block boundary for segmap
1138 */
1139 salign = lsp->ls_comp_seg_index[sblkno];
1140 sdiff = salign & (DEV_BSIZE - 1);
1141 salign -= sdiff;
1142 if (eblkno >= (lsp->ls_comp_index_sz - 1)) {
1143 /*
1144 * We're dealing with the last segment of
1145 * the compressed file -- the size of this
1146 * segment *may not* be the same as the
1147 * segment size for the file
1148 */
1149 eblkoff = (offset + bp->b_bcount) &
1150 (lsp->ls_uncomp_last_seg_sz - 1);
1151 ealign = lsp->ls_vp_comp_size;
1152 } else {
1153 ealign = lsp->ls_comp_seg_index[eblkno + 1];
1154 }
1155
1156 /*
1157 * Preserve original request paramaters
1158 */
1159 oblkcount = bp->b_bcount;
1160
1161 /*
1162 * Assign the calculated parameters
1163 */
1164 comp_data_sz = ealign - salign;
1165 bp->b_bcount = comp_data_sz;
1166
1167 /*
1168 * Buffers to hold compressed segments are pre-allocated
1169 * on a per-thread basis. Find a pre-allocated buffer
1170 * that is not currently in use and mark it for use.
1171 */
1172 mutex_enter(&lsp->ls_comp_bufs_lock);
1173 for (j = 0; j < lofi_taskq_nthreads; j++) {
1174 if (lsp->ls_comp_bufs[j].inuse == 0) {
1175 lsp->ls_comp_bufs[j].inuse = 1;
1176 break;
1177 }
1178 }
1179
1180 mutex_exit(&lsp->ls_comp_bufs_lock);
1181 ASSERT(j < lofi_taskq_nthreads);
1182
1183 /*
1184 * If the pre-allocated buffer size does not match
1185 * the size of the I/O request, re-allocate it with
1186 * the appropriate size
1187 */
1188 if (lsp->ls_comp_bufs[j].bufsize < bp->b_bcount) {
1189 if (lsp->ls_comp_bufs[j].bufsize > 0)
1190 kmem_free(lsp->ls_comp_bufs[j].buf,
1191 lsp->ls_comp_bufs[j].bufsize);
1192 lsp->ls_comp_bufs[j].buf = kmem_alloc(bp->b_bcount,
1193 KM_SLEEP);
1194 lsp->ls_comp_bufs[j].bufsize = bp->b_bcount;
1195 }
1196 compressed_seg = lsp->ls_comp_bufs[j].buf;
1197
1198 /*
1199 * Map in the calculated number of blocks
1200 */
1201 error = lofi_mapped_rdwr((caddr_t)compressed_seg, salign,
1202 bp, lsp);
1203
1204 bp->b_bcount = oblkcount;
1205 bp->b_resid = oblkcount;
1206 if (error != 0)
1207 goto done;
1208
1209 /*
1210 * decompress compressed blocks start
1211 */
1212 cmpbuf = compressed_seg + sdiff;
1213 for (i = sblkno; i <= eblkno; i++) {
1214 ASSERT(i < lsp->ls_comp_index_sz - 1);
1215 uchar_t *useg;
1216
1217 /*
1218 * The last segment is special in that it is
1219 * most likely not going to be the same
1220 * (uncompressed) size as the other segments.
1221 */
1222 if (i == (lsp->ls_comp_index_sz - 2)) {
1223 seglen = lsp->ls_uncomp_last_seg_sz;
1224 } else {
1225 seglen = lsp->ls_uncomp_seg_sz;
1226 }
1227
1228 /*
1229 * Each of the segment index entries contains
1230 * the starting block number for that segment.
1231 * The number of compressed bytes in a segment
1232 * is thus the difference between the starting
1233 * block number of this segment and the starting
1234 * block number of the next segment.
1235 */
1236 cmpbytes = lsp->ls_comp_seg_index[i + 1] -
1237 lsp->ls_comp_seg_index[i];
1238
1239 /*
1240 * The first byte in a compressed segment is a flag
1241 * that indicates whether this segment is compressed
1242 * at all.
1243 *
1244 * The variable 'useg' is used (instead of
1245 * uncompressed_seg) in this loop to keep a
1246 * reference to the uncompressed segment.
1247 *
1248 * N.B. If 'useg' is replaced with uncompressed_seg,
1249 * it leads to memory leaks and heap corruption in
1250 * corner cases where compressed segments lie
1251 * adjacent to uncompressed segments.
1252 */
1253 if (*cmpbuf == UNCOMPRESSED) {
1254 useg = cmpbuf + SEGHDR;
1255 } else {
1256 if (uncompressed_seg == NULL)
1257 uncompressed_seg =
1258 kmem_alloc(lsp->ls_uncomp_seg_sz,
1259 KM_SLEEP);
1260 useg = uncompressed_seg;
1261 uncompressed_seg_index = i;
1262
1263 if (li->l_decompress((cmpbuf + SEGHDR),
1264 (cmpbytes - SEGHDR), uncompressed_seg,
1265 &seglen, li->l_level) != 0) {
1266 error = EIO;
1267 goto done;
1268 }
1269 }
1270
1271 /*
1272 * Determine how much uncompressed data we
1273 * have to copy and copy it
1274 */
1275 xfersize = lsp->ls_uncomp_seg_sz - sblkoff;
1276 if (i == eblkno)
1277 xfersize -= (lsp->ls_uncomp_seg_sz - eblkoff);
1278
1279 bcopy((useg + sblkoff), bufaddr, xfersize);
1280
1281 cmpbuf += cmpbytes;
1282 bufaddr += xfersize;
1283 bp->b_resid -= xfersize;
1284 sblkoff = 0;
1285
1286 if (bp->b_resid == 0)
1287 break;
1288 } /* decompress compressed blocks ends */
1289
1290 /*
1291 * Skip to done if there is no uncompressed data to cache
1292 */
1293 if (uncompressed_seg == NULL)
1294 goto done;
1295
1296 /*
1297 * Add the data for the last decompressed segment to
1298 * the cache.
1299 *
1300 * In case the uncompressed segment data was added to (and
1301 * is referenced by) the cache, make sure we don't free it
1302 * here.
1303 */
1304 mutex_enter(&lsp->ls_comp_cache_lock);
1305 if ((lc = lofi_add_comp_data(lsp, uncompressed_seg_index,
1306 uncompressed_seg)) != NULL) {
1307 uncompressed_seg = NULL;
1308 }
1309 mutex_exit(&lsp->ls_comp_cache_lock);
1310
1311 done:
1312 if (compressed_seg != NULL) {
1313 mutex_enter(&lsp->ls_comp_bufs_lock);
1314 lsp->ls_comp_bufs[j].inuse = 0;
1315 mutex_exit(&lsp->ls_comp_bufs_lock);
1316 }
1317 if (uncompressed_seg != NULL)
1318 kmem_free(uncompressed_seg, lsp->ls_uncomp_seg_sz);
1319 } /* end of handling compressed files */
1320
1321 if ((error == 0) && (syncflag != 0))
1322 error = VOP_FSYNC(lsp->ls_vp, syncflag, kcred, NULL);
1323
1324 errout:
1325 if (bufinited && lsp->ls_kstat) {
1326 size_t n_done = bp->b_bcount - bp->b_resid;
1327 kstat_io_t *kioptr;
1328
1329 mutex_enter(lsp->ls_kstat->ks_lock);
1330 kioptr = KSTAT_IO_PTR(lsp->ls_kstat);
1331 if (bp->b_flags & B_READ) {
1332 kioptr->nread += n_done;
1333 kioptr->reads++;
1334 } else {
1335 kioptr->nwritten += n_done;
1336 kioptr->writes++;
1337 }
1338 kstat_runq_exit(kioptr);
1339 mutex_exit(lsp->ls_kstat->ks_lock);
1340 }
1341
1342 mutex_enter(&lsp->ls_vp_lock);
1343 if (--lsp->ls_vp_iocount == 0)
1344 cv_broadcast(&lsp->ls_vp_cv);
1345 mutex_exit(&lsp->ls_vp_lock);
1346
1347 bioerror(bp, error);
1348 biodone(bp);
1349 }
1350
1351 static int
1352 lofi_strategy(struct buf *bp)
1353 {
1354 struct lofi_state *lsp;
1355 offset_t offset;
1356
1357 /*
1358 * We cannot just do I/O here, because the current thread
1359 * _might_ end up back in here because the underlying filesystem
1360 * wants a buffer, which eventually gets into bio_recycle and
1361 * might call into lofi to write out a delayed-write buffer.
1362 * This is bad if the filesystem above lofi is the same as below.
1363 *
1364 * We could come up with a complex strategy using threads to
1365 * do the I/O asynchronously, or we could use task queues. task
1366 * queues were incredibly easy so they win.
1367 */
1368 lsp = ddi_get_soft_state(lofi_statep, getminor(bp->b_edev));
1369 if (lsp == NULL) {
1370 bioerror(bp, ENXIO);
1371 biodone(bp);
1372 return (0);
1373 }
1374
1375 mutex_enter(&lsp->ls_vp_lock);
1376 if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
1377 bioerror(bp, EIO);
1378 biodone(bp);
1379 mutex_exit(&lsp->ls_vp_lock);
1380 return (0);
1381 }
1382
1383 offset = bp->b_lblkno * DEV_BSIZE; /* offset within file */
1384 if (lsp->ls_crypto_enabled) {
1385 /* encrypted data really begins after crypto header */
1386 offset += lsp->ls_crypto_offset;
1387 }
1388 if (offset == lsp->ls_vp_size) {
1389 /* EOF */
1390 if ((bp->b_flags & B_READ) != 0) {
1391 bp->b_resid = bp->b_bcount;
1392 bioerror(bp, 0);
1393 } else {
1394 /* writes should fail */
1395 bioerror(bp, ENXIO);
1396 }
1397 biodone(bp);
1398 mutex_exit(&lsp->ls_vp_lock);
1399 return (0);
1400 }
1401 if (offset > lsp->ls_vp_size) {
1402 bioerror(bp, ENXIO);
1403 biodone(bp);
1404 mutex_exit(&lsp->ls_vp_lock);
1405 return (0);
1406 }
1407 lsp->ls_vp_iocount++;
1408 mutex_exit(&lsp->ls_vp_lock);
1409
1410 if (lsp->ls_kstat) {
1411 mutex_enter(lsp->ls_kstat->ks_lock);
1412 kstat_waitq_enter(KSTAT_IO_PTR(lsp->ls_kstat));
1413 mutex_exit(lsp->ls_kstat->ks_lock);
1414 }
1415 (void) taskq_dispatch(lsp->ls_taskq, lofi_strategy_task, bp, KM_SLEEP);
1416 return (0);
1417 }
1418
1419 /*ARGSUSED2*/
1420 static int
1421 lofi_read(dev_t dev, struct uio *uio, struct cred *credp)
1422 {
1423 if (getminor(dev) == 0)
1424 return (EINVAL);
1425 UIO_CHECK(uio);
1426 return (physio(lofi_strategy, NULL, dev, B_READ, minphys, uio));
1427 }
1428
1429 /*ARGSUSED2*/
1430 static int
1431 lofi_write(dev_t dev, struct uio *uio, struct cred *credp)
1432 {
1433 if (getminor(dev) == 0)
1434 return (EINVAL);
1435 UIO_CHECK(uio);
1436 return (physio(lofi_strategy, NULL, dev, B_WRITE, minphys, uio));
1437 }
1438
1439 /*ARGSUSED2*/
1440 static int
1441 lofi_aread(dev_t dev, struct aio_req *aio, struct cred *credp)
1442 {
1443 if (getminor(dev) == 0)
1444 return (EINVAL);
1445 UIO_CHECK(aio->aio_uio);
1446 return (aphysio(lofi_strategy, anocancel, dev, B_READ, minphys, aio));
1447 }
1448
1449 /*ARGSUSED2*/
1450 static int
1451 lofi_awrite(dev_t dev, struct aio_req *aio, struct cred *credp)
1452 {
1453 if (getminor(dev) == 0)
1454 return (EINVAL);
1455 UIO_CHECK(aio->aio_uio);
1456 return (aphysio(lofi_strategy, anocancel, dev, B_WRITE, minphys, aio));
1457 }
1458
1459 /*ARGSUSED*/
1460 static int
1461 lofi_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1462 {
1463 switch (infocmd) {
1464 case DDI_INFO_DEVT2DEVINFO:
1465 *result = lofi_dip;
1466 return (DDI_SUCCESS);
1467 case DDI_INFO_DEVT2INSTANCE:
1468 *result = 0;
1469 return (DDI_SUCCESS);
1470 }
1471 return (DDI_FAILURE);
1472 }
1473
1474 static int
1475 lofi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1476 {
1477 int error;
1478
1479 if (cmd != DDI_ATTACH)
1480 return (DDI_FAILURE);
1481
1482 lofi_minor_id = id_space_create("lofi_minor_id", 1, L_MAXMIN32 + 1);
1483
1484 if (!lofi_minor_id)
1485 return (DDI_FAILURE);
1486
1487 error = ddi_soft_state_zalloc(lofi_statep, 0);
1488 if (error == DDI_FAILURE) {
1489 id_space_destroy(lofi_minor_id);
1490 return (DDI_FAILURE);
1491 }
1492 error = ddi_create_minor_node(dip, LOFI_CTL_NODE, S_IFCHR, 0,
1493 DDI_PSEUDO, NULL);
1494 if (error == DDI_FAILURE) {
1495 ddi_soft_state_free(lofi_statep, 0);
1496 id_space_destroy(lofi_minor_id);
1497 return (DDI_FAILURE);
1498 }
1499 /* driver handles kernel-issued IOCTLs */
1500 if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
1501 DDI_KERNEL_IOCTL, NULL, 0) != DDI_PROP_SUCCESS) {
1502 ddi_remove_minor_node(dip, NULL);
1503 ddi_soft_state_free(lofi_statep, 0);
1504 id_space_destroy(lofi_minor_id);
1505 return (DDI_FAILURE);
1506 }
1507
1508 zone_key_create(&lofi_zone_key, NULL, lofi_zone_shutdown, NULL);
1509
1510 lofi_dip = dip;
1511 ddi_report_dev(dip);
1512 return (DDI_SUCCESS);
1513 }
1514
1515 static int
1516 lofi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1517 {
1518 if (cmd != DDI_DETACH)
1519 return (DDI_FAILURE);
1520
1521 mutex_enter(&lofi_lock);
1522
1523 if (!list_is_empty(&lofi_list)) {
1524 mutex_exit(&lofi_lock);
1525 return (DDI_FAILURE);
1526 }
1527
1528 lofi_dip = NULL;
1529 ddi_remove_minor_node(dip, NULL);
1530 ddi_prop_remove_all(dip);
1531
1532 mutex_exit(&lofi_lock);
1533
1534 if (zone_key_delete(lofi_zone_key) != 0)
1535 cmn_err(CE_WARN, "failed to delete zone key");
1536
1537 ddi_soft_state_free(lofi_statep, 0);
1538
1539 id_space_destroy(lofi_minor_id);
1540
1541 return (DDI_SUCCESS);
1542 }
1543
1544 /*
1545 * With addition of encryption, be careful that encryption key is wiped before
1546 * kernel memory structures are freed, and also that key is not accidentally
1547 * passed out into userland structures.
1548 */
1549 static void
1550 free_lofi_ioctl(struct lofi_ioctl *klip)
1551 {
1552 /* Make sure this encryption key doesn't stick around */
1553 bzero(klip->li_key, sizeof (klip->li_key));
1554 kmem_free(klip, sizeof (struct lofi_ioctl));
1555 }
1556
1557 /*
1558 * These two just simplify the rest of the ioctls that need to copyin/out
1559 * the lofi_ioctl structure.
1560 */
1561 int
1562 copy_in_lofi_ioctl(const struct lofi_ioctl *ulip, struct lofi_ioctl **klipp,
1563 int flag)
1564 {
1565 struct lofi_ioctl *klip;
1566 int error;
1567
1568 klip = *klipp = kmem_alloc(sizeof (struct lofi_ioctl), KM_SLEEP);
1569 error = ddi_copyin(ulip, klip, sizeof (struct lofi_ioctl), flag);
1570 if (error)
1571 goto err;
1572
1573 /* ensure NULL termination */
1574 klip->li_filename[MAXPATHLEN-1] = '\0';
1575 klip->li_algorithm[MAXALGLEN-1] = '\0';
1576 klip->li_cipher[CRYPTO_MAX_MECH_NAME-1] = '\0';
1577 klip->li_iv_cipher[CRYPTO_MAX_MECH_NAME-1] = '\0';
1578
1579 if (klip->li_minor > L_MAXMIN32) {
1580 error = EINVAL;
1581 goto err;
1582 }
1583
1584 return (0);
1585
1586 err:
1587 free_lofi_ioctl(klip);
1588 return (error);
1589 }
1590
1591 int
1592 copy_out_lofi_ioctl(const struct lofi_ioctl *klip, struct lofi_ioctl *ulip,
1593 int flag)
1594 {
1595 int error;
1596
1597 /*
1598 * NOTE: Do NOT copy the crypto_key_t "back" to userland.
1599 * This ensures that an attacker can't trivially find the
1600 * key for a mapping just by issuing the ioctl.
1601 *
1602 * It can still be found by poking around in kmem with mdb(1),
1603 * but there is no point in making it easy when the info isn't
1604 * of any use in this direction anyway.
1605 *
1606 * Either way we don't actually have the raw key stored in
1607 * a form that we can get it anyway, since we just used it
1608 * to create a ctx template and didn't keep "the original".
1609 */
1610 error = ddi_copyout(klip, ulip, sizeof (struct lofi_ioctl), flag);
1611 if (error)
1612 return (EFAULT);
1613 return (0);
1614 }
1615
1616 static int
1617 lofi_access(struct lofi_state *lsp)
1618 {
1619 ASSERT(MUTEX_HELD(&lofi_lock));
1620 if (INGLOBALZONE(curproc) || lsp->ls_zone.zref_zone == curzone)
1621 return (0);
1622 return (EPERM);
1623 }
1624
1625 /*
1626 * Find the lofi state for the given filename. We compare by vnode to
1627 * allow the global zone visibility into NGZ lofi nodes.
1628 */
1629 static int
1630 file_to_lofi_nocheck(char *filename, boolean_t readonly,
1631 struct lofi_state **lspp)
1632 {
1633 struct lofi_state *lsp;
1634 vnode_t *vp = NULL;
1635 int err = 0;
1636 int rdfiles = 0;
1637
1638 ASSERT(MUTEX_HELD(&lofi_lock));
1639
1640 if ((err = lookupname(filename, UIO_SYSSPACE, FOLLOW,
1641 NULLVPP, &vp)) != 0)
1642 goto out;
1643
1644 if (vp->v_type == VREG) {
1645 vnode_t *realvp;
1646 if (VOP_REALVP(vp, &realvp, NULL) == 0) {
1647 VN_HOLD(realvp);
1648 VN_RELE(vp);
1649 vp = realvp;
1650 }
1651 }
1652
1653 for (lsp = list_head(&lofi_list); lsp != NULL;
1654 lsp = list_next(&lofi_list, lsp)) {
1655 if (lsp->ls_vp == vp) {
1656 if (lspp != NULL)
1657 *lspp = lsp;
1658 if (lsp->ls_readonly) {
1659 rdfiles++;
1660 /* Skip if '-r' is specified */
1661 if (readonly)
1662 continue;
1663 }
1664 goto out;
1665 }
1666 }
1667
1668 err = ENOENT;
1669
1670 /*
1671 * If a filename is given as an argument for lofi_unmap, we shouldn't
1672 * allow unmap if there are multiple read-only lofi devices associated
1673 * with this file.
1674 */
1675 if (lspp != NULL) {
1676 if (rdfiles == 1)
1677 err = 0;
1678 else if (rdfiles > 1)
1679 err = EBUSY;
1680 }
1681
1682 out:
1683 if (vp != NULL)
1684 VN_RELE(vp);
1685 return (err);
1686 }
1687
1688 /*
1689 * Find the minor for the given filename, checking the zone can access
1690 * it.
1691 */
1692 static int
1693 file_to_lofi(char *filename, boolean_t readonly, struct lofi_state **lspp)
1694 {
1695 int err = 0;
1696
1697 ASSERT(MUTEX_HELD(&lofi_lock));
1698
1699 if ((err = file_to_lofi_nocheck(filename, readonly, lspp)) != 0)
1700 return (err);
1701
1702 if ((err = lofi_access(*lspp)) != 0)
1703 return (err);
1704
1705 return (0);
1706 }
1707
1708 /*
1709 * Fakes up a disk geometry, and one big partition, based on the size
1710 * of the file. This is needed because we allow newfs'ing the device,
1711 * and newfs will do several disk ioctls to figure out the geometry and
1712 * partition information. It uses that information to determine the parameters
1713 * to pass to mkfs. Geometry is pretty much irrelevant these days, but we
1714 * have to support it.
1715 */
1716 static void
1717 fake_disk_geometry(struct lofi_state *lsp)
1718 {
1719 u_offset_t dsize = lsp->ls_vp_size - lsp->ls_crypto_offset;
1720
1721 /* dk_geom - see dkio(7I) */
1722 /*
1723 * dkg_ncyl _could_ be set to one here (one big cylinder with gobs
1724 * of sectors), but that breaks programs like fdisk which want to
1725 * partition a disk by cylinder. With one cylinder, you can't create
1726 * an fdisk partition and put pcfs on it for testing (hard to pick
1727 * a number between one and one).
1728 *
1729 * The cheezy floppy test is an attempt to not have too few cylinders
1730 * for a small file, or so many on a big file that you waste space
1731 * for backup superblocks or cylinder group structures.
1732 */
1733 if (dsize < (2 * 1024 * 1024)) /* floppy? */
1734 lsp->ls_dkg.dkg_ncyl = dsize / (100 * 1024);
1735 else
1736 lsp->ls_dkg.dkg_ncyl = dsize / (300 * 1024);
1737 /* in case file file is < 100k */
1738 if (lsp->ls_dkg.dkg_ncyl == 0)
1739 lsp->ls_dkg.dkg_ncyl = 1;
1740 lsp->ls_dkg.dkg_acyl = 0;
1741 lsp->ls_dkg.dkg_bcyl = 0;
1742 lsp->ls_dkg.dkg_nhead = 1;
1743 lsp->ls_dkg.dkg_obs1 = 0;
1744 lsp->ls_dkg.dkg_intrlv = 0;
1745 lsp->ls_dkg.dkg_obs2 = 0;
1746 lsp->ls_dkg.dkg_obs3 = 0;
1747 lsp->ls_dkg.dkg_apc = 0;
1748 lsp->ls_dkg.dkg_rpm = 7200;
1749 lsp->ls_dkg.dkg_pcyl = lsp->ls_dkg.dkg_ncyl + lsp->ls_dkg.dkg_acyl;
1750 lsp->ls_dkg.dkg_nsect = dsize / (DEV_BSIZE * lsp->ls_dkg.dkg_ncyl);
1751 lsp->ls_dkg.dkg_write_reinstruct = 0;
1752 lsp->ls_dkg.dkg_read_reinstruct = 0;
1753
1754 /* vtoc - see dkio(7I) */
1755 bzero(&lsp->ls_vtoc, sizeof (struct vtoc));
1756 lsp->ls_vtoc.v_sanity = VTOC_SANE;
1757 lsp->ls_vtoc.v_version = V_VERSION;
1758 (void) strncpy(lsp->ls_vtoc.v_volume, LOFI_DRIVER_NAME,
1759 sizeof (lsp->ls_vtoc.v_volume));
1760 lsp->ls_vtoc.v_sectorsz = DEV_BSIZE;
1761 lsp->ls_vtoc.v_nparts = 1;
1762 lsp->ls_vtoc.v_part[0].p_tag = V_UNASSIGNED;
1763
1764 /*
1765 * A compressed file is read-only, other files can
1766 * be read-write
1767 */
1768 if (lsp->ls_uncomp_seg_sz > 0) {
1769 lsp->ls_vtoc.v_part[0].p_flag = V_UNMNT | V_RONLY;
1770 } else {
1771 lsp->ls_vtoc.v_part[0].p_flag = V_UNMNT;
1772 }
1773 lsp->ls_vtoc.v_part[0].p_start = (daddr_t)0;
1774 /*
1775 * The partition size cannot just be the number of sectors, because
1776 * that might not end on a cylinder boundary. And if that's the case,
1777 * newfs/mkfs will print a scary warning. So just figure the size
1778 * based on the number of cylinders and sectors/cylinder.
1779 */
1780 lsp->ls_vtoc.v_part[0].p_size = lsp->ls_dkg.dkg_pcyl *
1781 lsp->ls_dkg.dkg_nsect * lsp->ls_dkg.dkg_nhead;
1782
1783 /* dk_cinfo - see dkio(7I) */
1784 bzero(&lsp->ls_ci, sizeof (struct dk_cinfo));
1785 (void) strcpy(lsp->ls_ci.dki_cname, LOFI_DRIVER_NAME);
1786 lsp->ls_ci.dki_ctype = DKC_MD;
1787 lsp->ls_ci.dki_flags = 0;
1788 lsp->ls_ci.dki_cnum = 0;
1789 lsp->ls_ci.dki_addr = 0;
1790 lsp->ls_ci.dki_space = 0;
1791 lsp->ls_ci.dki_prio = 0;
1792 lsp->ls_ci.dki_vec = 0;
1793 (void) strcpy(lsp->ls_ci.dki_dname, LOFI_DRIVER_NAME);
1794 lsp->ls_ci.dki_unit = 0;
1795 lsp->ls_ci.dki_slave = 0;
1796 lsp->ls_ci.dki_partition = 0;
1797 /*
1798 * newfs uses this to set maxcontig. Must not be < 16, or it
1799 * will be 0 when newfs multiplies it by DEV_BSIZE and divides
1800 * it by the block size. Then tunefs doesn't work because
1801 * maxcontig is 0.
1802 */
1803 lsp->ls_ci.dki_maxtransfer = 16;
1804 }
1805
1806 /*
1807 * map in a compressed file
1808 *
1809 * Read in the header and the index that follows.
1810 *
1811 * The header is as follows -
1812 *
1813 * Signature (name of the compression algorithm)
1814 * Compression segment size (a multiple of 512)
1815 * Number of index entries
1816 * Size of the last block
1817 * The array containing the index entries
1818 *
1819 * The header information is always stored in
1820 * network byte order on disk.
1821 */
1822 static int
1823 lofi_map_compressed_file(struct lofi_state *lsp, char *buf)
1824 {
1825 uint32_t index_sz, header_len, i;
1826 ssize_t resid;
1827 enum uio_rw rw;
1828 char *tbuf = buf;
1829 int error;
1830
1831 /* The signature has already been read */
1832 tbuf += sizeof (lsp->ls_comp_algorithm);
1833 bcopy(tbuf, &(lsp->ls_uncomp_seg_sz), sizeof (lsp->ls_uncomp_seg_sz));
1834 lsp->ls_uncomp_seg_sz = ntohl(lsp->ls_uncomp_seg_sz);
1835
1836 /*
1837 * The compressed segment size must be a power of 2
1838 */
1839 if (lsp->ls_uncomp_seg_sz < DEV_BSIZE ||
1840 !ISP2(lsp->ls_uncomp_seg_sz))
1841 return (EINVAL);
1842
1843 for (i = 0; !((lsp->ls_uncomp_seg_sz >> i) & 1); i++)
1844 ;
1845
1846 lsp->ls_comp_seg_shift = i;
1847
1848 tbuf += sizeof (lsp->ls_uncomp_seg_sz);
1849 bcopy(tbuf, &(lsp->ls_comp_index_sz), sizeof (lsp->ls_comp_index_sz));
1850 lsp->ls_comp_index_sz = ntohl(lsp->ls_comp_index_sz);
1851
1852 tbuf += sizeof (lsp->ls_comp_index_sz);
1853 bcopy(tbuf, &(lsp->ls_uncomp_last_seg_sz),
1854 sizeof (lsp->ls_uncomp_last_seg_sz));
1855 lsp->ls_uncomp_last_seg_sz = ntohl(lsp->ls_uncomp_last_seg_sz);
1856
1857 /*
1858 * Compute the total size of the uncompressed data
1859 * for use in fake_disk_geometry and other calculations.
1860 * Disk geometry has to be faked with respect to the
1861 * actual uncompressed data size rather than the
1862 * compressed file size.
1863 */
1864 lsp->ls_vp_size =
1865 (u_offset_t)(lsp->ls_comp_index_sz - 2) * lsp->ls_uncomp_seg_sz
1866 + lsp->ls_uncomp_last_seg_sz;
1867
1868 /*
1869 * Index size is rounded up to DEV_BSIZE for ease
1870 * of segmapping
1871 */
1872 index_sz = sizeof (*lsp->ls_comp_seg_index) * lsp->ls_comp_index_sz;
1873 header_len = sizeof (lsp->ls_comp_algorithm) +
1874 sizeof (lsp->ls_uncomp_seg_sz) +
1875 sizeof (lsp->ls_comp_index_sz) +
1876 sizeof (lsp->ls_uncomp_last_seg_sz);
1877 lsp->ls_comp_offbase = header_len + index_sz;
1878
1879 index_sz += header_len;
1880 index_sz = roundup(index_sz, DEV_BSIZE);
1881
1882 lsp->ls_comp_index_data = kmem_alloc(index_sz, KM_SLEEP);
1883 lsp->ls_comp_index_data_sz = index_sz;
1884
1885 /*
1886 * Read in the index -- this has a side-effect
1887 * of reading in the header as well
1888 */
1889 rw = UIO_READ;
1890 error = vn_rdwr(rw, lsp->ls_vp, lsp->ls_comp_index_data, index_sz,
1891 0, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
1892
1893 if (error != 0)
1894 return (error);
1895
1896 /* Skip the header, this is where the index really begins */
1897 lsp->ls_comp_seg_index =
1898 /*LINTED*/
1899 (uint64_t *)(lsp->ls_comp_index_data + header_len);
1900
1901 /*
1902 * Now recompute offsets in the index to account for
1903 * the header length
1904 */
1905 for (i = 0; i < lsp->ls_comp_index_sz; i++) {
1906 lsp->ls_comp_seg_index[i] = lsp->ls_comp_offbase +
1907 BE_64(lsp->ls_comp_seg_index[i]);
1908 }
1909
1910 return (error);
1911 }
1912
1913 static int
1914 lofi_init_crypto(struct lofi_state *lsp, struct lofi_ioctl *klip)
1915 {
1916 struct crypto_meta chead;
1917 char buf[DEV_BSIZE];
1918 ssize_t resid;
1919 char *marker;
1920 int error;
1921 int ret;
1922 int i;
1923
1924 if (!klip->li_crypto_enabled)
1925 return (0);
1926
1927 /*
1928 * All current algorithms have a max of 448 bits.
1929 */
1930 if (klip->li_iv_len > CRYPTO_BITS2BYTES(512))
1931 return (EINVAL);
1932
1933 if (CRYPTO_BITS2BYTES(klip->li_key_len) > sizeof (klip->li_key))
1934 return (EINVAL);
1935
1936 lsp->ls_crypto_enabled = klip->li_crypto_enabled;
1937
1938 mutex_init(&lsp->ls_crypto_lock, NULL, MUTEX_DRIVER, NULL);
1939
1940 lsp->ls_mech.cm_type = crypto_mech2id(klip->li_cipher);
1941 if (lsp->ls_mech.cm_type == CRYPTO_MECH_INVALID) {
1942 cmn_err(CE_WARN, "invalid cipher %s requested for %s",
1943 klip->li_cipher, klip->li_filename);
1944 return (EINVAL);
1945 }
1946
1947 /* this is just initialization here */
1948 lsp->ls_mech.cm_param = NULL;
1949 lsp->ls_mech.cm_param_len = 0;
1950
1951 lsp->ls_iv_type = klip->li_iv_type;
1952 lsp->ls_iv_mech.cm_type = crypto_mech2id(klip->li_iv_cipher);
1953 if (lsp->ls_iv_mech.cm_type == CRYPTO_MECH_INVALID) {
1954 cmn_err(CE_WARN, "invalid iv cipher %s requested"
1955 " for %s", klip->li_iv_cipher, klip->li_filename);
1956 return (EINVAL);
1957 }
1958
1959 /* iv mech must itself take a null iv */
1960 lsp->ls_iv_mech.cm_param = NULL;
1961 lsp->ls_iv_mech.cm_param_len = 0;
1962 lsp->ls_iv_len = klip->li_iv_len;
1963
1964 /*
1965 * Create ctx using li_cipher & the raw li_key after checking
1966 * that it isn't a weak key.
1967 */
1968 lsp->ls_key.ck_format = CRYPTO_KEY_RAW;
1969 lsp->ls_key.ck_length = klip->li_key_len;
1970 lsp->ls_key.ck_data = kmem_alloc(
1971 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length), KM_SLEEP);
1972 bcopy(klip->li_key, lsp->ls_key.ck_data,
1973 CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
1974
1975 ret = crypto_key_check(&lsp->ls_mech, &lsp->ls_key);
1976 if (ret != CRYPTO_SUCCESS) {
1977 cmn_err(CE_WARN, "weak key check failed for cipher "
1978 "%s on file %s (0x%x)", klip->li_cipher,
1979 klip->li_filename, ret);
1980 return (EINVAL);
1981 }
1982
1983 error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE,
1984 CRYOFF, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
1985 if (error != 0)
1986 return (error);
1987
1988 /*
1989 * This is the case where the header in the lofi image is already
1990 * initialized to indicate it is encrypted.
1991 */
1992 if (strncmp(buf, lofi_crypto_magic, sizeof (lofi_crypto_magic)) == 0) {
1993 /*
1994 * The encryption header information is laid out this way:
1995 * 6 bytes: hex "CFLOFI"
1996 * 2 bytes: version = 0 ... for now
1997 * 96 bytes: reserved1 (not implemented yet)
1998 * 4 bytes: data_sector = 2 ... for now
1999 * more... not implemented yet
2000 */
2001
2002 marker = buf;
2003
2004 /* copy the magic */
2005 bcopy(marker, lsp->ls_crypto.magic,
2006 sizeof (lsp->ls_crypto.magic));
2007 marker += sizeof (lsp->ls_crypto.magic);
2008
2009 /* read the encryption version number */
2010 bcopy(marker, &(lsp->ls_crypto.version),
2011 sizeof (lsp->ls_crypto.version));
2012 lsp->ls_crypto.version = ntohs(lsp->ls_crypto.version);
2013 marker += sizeof (lsp->ls_crypto.version);
2014
2015 /* read a chunk of reserved data */
2016 bcopy(marker, lsp->ls_crypto.reserved1,
2017 sizeof (lsp->ls_crypto.reserved1));
2018 marker += sizeof (lsp->ls_crypto.reserved1);
2019
2020 /* read block number where encrypted data begins */
2021 bcopy(marker, &(lsp->ls_crypto.data_sector),
2022 sizeof (lsp->ls_crypto.data_sector));
2023 lsp->ls_crypto.data_sector = ntohl(lsp->ls_crypto.data_sector);
2024 marker += sizeof (lsp->ls_crypto.data_sector);
2025
2026 /* and ignore the rest until it is implemented */
2027
2028 lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
2029 return (0);
2030 }
2031
2032 /*
2033 * We've requested encryption, but no magic was found, so it must be
2034 * a new image.
2035 */
2036
2037 for (i = 0; i < sizeof (struct crypto_meta); i++) {
2038 if (buf[i] != '\0')
2039 return (EINVAL);
2040 }
2041
2042 marker = buf;
2043 bcopy(lofi_crypto_magic, marker, sizeof (lofi_crypto_magic));
2044 marker += sizeof (lofi_crypto_magic);
2045 chead.version = htons(LOFI_CRYPTO_VERSION);
2046 bcopy(&(chead.version), marker, sizeof (chead.version));
2047 marker += sizeof (chead.version);
2048 marker += sizeof (chead.reserved1);
2049 chead.data_sector = htonl(LOFI_CRYPTO_DATA_SECTOR);
2050 bcopy(&(chead.data_sector), marker, sizeof (chead.data_sector));
2051
2052 /* write the header */
2053 error = vn_rdwr(UIO_WRITE, lsp->ls_vp, buf, DEV_BSIZE,
2054 CRYOFF, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
2055 if (error != 0)
2056 return (error);
2057
2058 /* fix things up so it looks like we read this info */
2059 bcopy(lofi_crypto_magic, lsp->ls_crypto.magic,
2060 sizeof (lofi_crypto_magic));
2061 lsp->ls_crypto.version = LOFI_CRYPTO_VERSION;
2062 lsp->ls_crypto.data_sector = LOFI_CRYPTO_DATA_SECTOR;
2063 lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
2064 return (0);
2065 }
2066
2067 /*
2068 * Check to see if the passed in signature is a valid one. If it is
2069 * valid, return the index into lofi_compress_table.
2070 *
2071 * Return -1 if it is invalid
2072 */
2073 static int
2074 lofi_compress_select(const char *signature)
2075 {
2076 int i;
2077
2078 for (i = 0; i < LOFI_COMPRESS_FUNCTIONS; i++) {
2079 if (strcmp(lofi_compress_table[i].l_name, signature) == 0)
2080 return (i);
2081 }
2082
2083 return (-1);
2084 }
2085
2086 static int
2087 lofi_init_compress(struct lofi_state *lsp)
2088 {
2089 char buf[DEV_BSIZE];
2090 int compress_index;
2091 ssize_t resid;
2092 int error;
2093
2094 error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE, 0, UIO_SYSSPACE,
2095 0, RLIM64_INFINITY, kcred, &resid);
2096
2097 if (error != 0)
2098 return (error);
2099
2100 if ((compress_index = lofi_compress_select(buf)) == -1)
2101 return (0);
2102
2103 /* compression and encryption are mutually exclusive */
2104 if (lsp->ls_crypto_enabled)
2105 return (ENOTSUP);
2106
2107 /* initialize compression info for compressed lofi */
2108 lsp->ls_comp_algorithm_index = compress_index;
2109 (void) strlcpy(lsp->ls_comp_algorithm,
2110 lofi_compress_table[compress_index].l_name,
2111 sizeof (lsp->ls_comp_algorithm));
2112
2113 /* Finally setup per-thread pre-allocated buffers */
2114 lsp->ls_comp_bufs = kmem_zalloc(lofi_taskq_nthreads *
2115 sizeof (struct compbuf), KM_SLEEP);
2116
2117 return (lofi_map_compressed_file(lsp, buf));
2118 }
2119
2120 /*
2121 * map a file to a minor number. Return the minor number.
2122 */
2123 static int
2124 lofi_map_file(dev_t dev, struct lofi_ioctl *ulip, int pickminor,
2125 int *rvalp, struct cred *credp, int ioctl_flag)
2126 {
2127 minor_t minor = (minor_t)-1;
2128 struct lofi_state *lsp = NULL;
2129 struct lofi_ioctl *klip;
2130 int error;
2131 struct vnode *vp = NULL;
2132 vattr_t vattr;
2133 int flag;
2134 dev_t newdev;
2135 char namebuf[50];
2136
2137 error = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
2138 if (error != 0)
2139 return (error);
2140
2141 mutex_enter(&lofi_lock);
2142
2143 mutex_enter(&curproc->p_lock);
2144 if ((error = rctl_incr_lofi(curproc, curproc->p_zone, 1)) != 0) {
2145 mutex_exit(&curproc->p_lock);
2146 mutex_exit(&lofi_lock);
2147 free_lofi_ioctl(klip);
2148 return (error);
2149 }
2150 mutex_exit(&curproc->p_lock);
2151
2152 if (file_to_lofi_nocheck(klip->li_filename, klip->li_readonly,
2153 NULL) == 0) {
2154 error = EBUSY;
2155 goto err;
2156 }
2157
2158 if (pickminor) {
2159 minor = (minor_t)id_allocff_nosleep(lofi_minor_id);
2160 if (minor == (minor_t)-1) {
2161 error = EAGAIN;
2162 goto err;
2163 }
2164 } else {
2165 if (ddi_get_soft_state(lofi_statep, klip->li_minor) != NULL) {
2166 error = EEXIST;
2167 goto err;
2168 }
2169
2170 minor = (minor_t)
2171 id_alloc_specific_nosleep(lofi_minor_id, klip->li_minor);
2172 ASSERT(minor != (minor_t)-1);
2173 }
2174
2175 flag = FREAD | FWRITE | FOFFMAX | FEXCL;
2176 error = vn_open(klip->li_filename, UIO_SYSSPACE, flag, 0, &vp, 0, 0);
2177 if (error) {
2178 /* try read-only */
2179 flag &= ~FWRITE;
2180 error = vn_open(klip->li_filename, UIO_SYSSPACE, flag, 0,
2181 &vp, 0, 0);
2182 if (error)
2183 goto err;
2184 }
2185
2186 if (!V_ISLOFIABLE(vp->v_type)) {
2187 error = EINVAL;
2188 goto err;
2189 }
2190
2191 vattr.va_mask = AT_SIZE;
2192 error = VOP_GETATTR(vp, &vattr, 0, credp, NULL);
2193 if (error)
2194 goto err;
2195
2196 /* the file needs to be a multiple of the block size */
2197 if ((vattr.va_size % DEV_BSIZE) != 0) {
2198 error = EINVAL;
2199 goto err;
2200 }
2201
2202 /* lsp alloc+init */
2203
2204 error = ddi_soft_state_zalloc(lofi_statep, minor);
2205 if (error == DDI_FAILURE) {
2206 error = ENOMEM;
2207 goto err;
2208 }
2209
2210 lsp = ddi_get_soft_state(lofi_statep, minor);
2211 list_insert_tail(&lofi_list, lsp);
2212
2213 newdev = makedevice(getmajor(dev), minor);
2214 lsp->ls_dev = newdev;
2215 zone_init_ref(&lsp->ls_zone);
2216 zone_hold_ref(curzone, &lsp->ls_zone, ZONE_REF_LOFI);
2217 lsp->ls_uncomp_seg_sz = 0;
2218 lsp->ls_comp_algorithm[0] = '\0';
2219 lsp->ls_crypto_offset = 0;
2220
2221 cv_init(&lsp->ls_vp_cv, NULL, CV_DRIVER, NULL);
2222 mutex_init(&lsp->ls_comp_cache_lock, NULL, MUTEX_DRIVER, NULL);
2223 mutex_init(&lsp->ls_comp_bufs_lock, NULL, MUTEX_DRIVER, NULL);
2224 mutex_init(&lsp->ls_kstat_lock, NULL, MUTEX_DRIVER, NULL);
2225 mutex_init(&lsp->ls_vp_lock, NULL, MUTEX_DRIVER, NULL);
2226
2227 (void) snprintf(namebuf, sizeof (namebuf), "%s_taskq_%d",
2228 LOFI_DRIVER_NAME, minor);
2229 lsp->ls_taskq = taskq_create_proc(namebuf, lofi_taskq_nthreads,
2230 minclsyspri, 1, lofi_taskq_maxalloc, curzone->zone_zsched, 0);
2231
2232 list_create(&lsp->ls_comp_cache, sizeof (struct lofi_comp_cache),
2233 offsetof(struct lofi_comp_cache, lc_list));
2234
2235 /*
2236 * save open mode so file can be closed properly and vnode counts
2237 * updated correctly.
2238 */
2239 lsp->ls_openflag = flag;
2240
2241 lsp->ls_vp = vp;
2242 lsp->ls_stacked_vp = vp;
2243 /*
2244 * Try to handle stacked lofs vnodes.
2245 */
2246 if (vp->v_type == VREG) {
2247 vnode_t *realvp;
2248
2249 if (VOP_REALVP(vp, &realvp, NULL) == 0) {
2250 /*
2251 * We need to use the realvp for uniqueness
2252 * checking, but keep the stacked vp for
2253 * LOFI_GET_FILENAME display.
2254 */
2255 VN_HOLD(realvp);
2256 lsp->ls_vp = realvp;
2257 }
2258 }
2259
2260 lsp->ls_vp_size = vattr.va_size;
2261 lsp->ls_vp_comp_size = lsp->ls_vp_size;
2262
2263 lsp->ls_kstat = kstat_create_zone(LOFI_DRIVER_NAME, minor,
2264 NULL, "disk", KSTAT_TYPE_IO, 1, 0, getzoneid());
2265
2266 if (lsp->ls_kstat == NULL) {
2267 error = ENOMEM;
2268 goto err;
2269 }
2270
2271 lsp->ls_kstat->ks_lock = &lsp->ls_kstat_lock;
2272 kstat_zone_add(lsp->ls_kstat, GLOBAL_ZONEID);
2273
2274 lsp->ls_readonly = klip->li_readonly;
2275
2276 if ((error = lofi_init_crypto(lsp, klip)) != 0)
2277 goto err;
2278
2279 if ((error = lofi_init_compress(lsp)) != 0)
2280 goto err;
2281
2282 fake_disk_geometry(lsp);
2283
2284 /* create minor nodes */
2285
2286 (void) snprintf(namebuf, sizeof (namebuf), "%d", minor);
2287 error = ddi_create_minor_node(lofi_dip, namebuf, S_IFBLK, minor,
2288 DDI_PSEUDO, NULL);
2289 if (error != DDI_SUCCESS) {
2290 error = ENXIO;
2291 goto err;
2292 }
2293
2294 (void) snprintf(namebuf, sizeof (namebuf), "%d,raw", minor);
2295 error = ddi_create_minor_node(lofi_dip, namebuf, S_IFCHR, minor,
2296 DDI_PSEUDO, NULL);
2297 if (error != DDI_SUCCESS) {
2298 /* remove block node */
2299 (void) snprintf(namebuf, sizeof (namebuf), "%d", minor);
2300 ddi_remove_minor_node(lofi_dip, namebuf);
2301 error = ENXIO;
2302 goto err;
2303 }
2304
2305 /* create DDI properties */
2306
2307 if ((ddi_prop_update_int64(newdev, lofi_dip, SIZE_PROP_NAME,
2308 lsp->ls_vp_size - lsp->ls_crypto_offset)) != DDI_PROP_SUCCESS) {
2309 error = EINVAL;
2310 goto nodeerr;
2311 }
2312
2313 if ((ddi_prop_update_int64(newdev, lofi_dip, NBLOCKS_PROP_NAME,
2314 (lsp->ls_vp_size - lsp->ls_crypto_offset) / DEV_BSIZE))
2315 != DDI_PROP_SUCCESS) {
2316 error = EINVAL;
2317 goto nodeerr;
2318 }
2319
2320 if (ddi_prop_update_string(newdev, lofi_dip, ZONE_PROP_NAME,
2321 (char *)curproc->p_zone->zone_name) != DDI_PROP_SUCCESS) {
2322 error = EINVAL;
2323 goto nodeerr;
2324 }
2325
2326 kstat_install(lsp->ls_kstat);
2327
2328 mutex_exit(&lofi_lock);
2329
2330 if (rvalp)
2331 *rvalp = (int)minor;
2332 klip->li_minor = minor;
2333 (void) copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
2334 free_lofi_ioctl(klip);
2335 return (0);
2336
2337 nodeerr:
2338 lofi_free_dev(newdev);
2339 err:
2340 if (lsp != NULL) {
2341 lofi_destroy(lsp, credp);
2342 } else {
2343 if (vp != NULL) {
2344 (void) VOP_CLOSE(vp, flag, 1, 0, credp, NULL);
2345 VN_RELE(vp);
2346 }
2347
2348 if (minor != (minor_t)-1)
2349 id_free(lofi_minor_id, minor);
2350
2351 rctl_decr_lofi(curproc->p_zone, 1);
2352 }
2353
2354 mutex_exit(&lofi_lock);
2355 free_lofi_ioctl(klip);
2356 return (error);
2357 }
2358
2359 /*
2360 * unmap a file.
2361 */
2362 static int
2363 lofi_unmap_file(struct lofi_ioctl *ulip, int byfilename,
2364 struct cred *credp, int ioctl_flag)
2365 {
2366 struct lofi_state *lsp;
2367 struct lofi_ioctl *klip;
2368 int err;
2369
2370 err = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
2371 if (err != 0)
2372 return (err);
2373
2374 mutex_enter(&lofi_lock);
2375 if (byfilename) {
2376 if ((err = file_to_lofi(klip->li_filename, klip->li_readonly,
2377 &lsp)) != 0) {
2378 mutex_exit(&lofi_lock);
2379 return (err);
2380 }
2381 } else if (klip->li_minor == 0) {
2382 mutex_exit(&lofi_lock);
2383 free_lofi_ioctl(klip);
2384 return (ENXIO);
2385 } else {
2386 lsp = ddi_get_soft_state(lofi_statep, klip->li_minor);
2387 }
2388
2389 if (lsp == NULL || lsp->ls_vp == NULL || lofi_access(lsp) != 0) {
2390 mutex_exit(&lofi_lock);
2391 free_lofi_ioctl(klip);
2392 return (ENXIO);
2393 }
2394
2395 klip->li_minor = getminor(lsp->ls_dev);
2396
2397 /*
2398 * If it's still held open, we'll do one of three things:
2399 *
2400 * If no flag is set, just return EBUSY.
2401 *
2402 * If the 'cleanup' flag is set, unmap and remove the device when
2403 * the last user finishes.
2404 *
2405 * If the 'force' flag is set, then we forcibly close the underlying
2406 * file. Subsequent operations will fail, and the DKIOCSTATE ioctl
2407 * will return DKIO_DEV_GONE. When the device is last closed, the
2408 * device will be cleaned up appropriately.
2409 *
2410 * This is complicated by the fact that we may have outstanding
2411 * dispatched I/Os. Rather than having a single mutex to serialize all
2412 * I/O, we keep a count of the number of outstanding I/O requests
2413 * (ls_vp_iocount), as well as a flag to indicate that no new I/Os
2414 * should be dispatched (ls_vp_closereq).
2415 *
2416 * We set the flag, wait for the number of outstanding I/Os to reach 0,
2417 * and then close the underlying vnode.
2418 */
2419 if (is_opened(lsp)) {
2420 if (klip->li_force) {
2421 mutex_enter(&lsp->ls_vp_lock);
2422 lsp->ls_vp_closereq = B_TRUE;
2423 /* wake up any threads waiting on dkiocstate */
2424 cv_broadcast(&lsp->ls_vp_cv);
2425 while (lsp->ls_vp_iocount > 0)
2426 cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
2427 mutex_exit(&lsp->ls_vp_lock);
2428
2429 goto out;
2430 } else if (klip->li_cleanup) {
2431 lsp->ls_cleanup = 1;
2432 mutex_exit(&lofi_lock);
2433 free_lofi_ioctl(klip);
2434 return (0);
2435 }
2436
2437 mutex_exit(&lofi_lock);
2438 free_lofi_ioctl(klip);
2439 return (EBUSY);
2440 }
2441
2442 out:
2443 lofi_free_dev(lsp->ls_dev);
2444 lofi_destroy(lsp, credp);
2445
2446 mutex_exit(&lofi_lock);
2447 (void) copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
2448 free_lofi_ioctl(klip);
2449 return (0);
2450 }
2451
2452 /*
2453 * get the filename given the minor number, or the minor number given
2454 * the name.
2455 */
2456 /*ARGSUSED*/
2457 static int
2458 lofi_get_info(dev_t dev, struct lofi_ioctl *ulip, int which,
2459 struct cred *credp, int ioctl_flag)
2460 {
2461 struct lofi_ioctl *klip;
2462 struct lofi_state *lsp;
2463 int error;
2464
2465 error = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
2466 if (error != 0)
2467 return (error);
2468
2469 switch (which) {
2470 case LOFI_GET_FILENAME:
2471 if (klip->li_minor == 0) {
2472 free_lofi_ioctl(klip);
2473 return (EINVAL);
2474 }
2475
2476 mutex_enter(&lofi_lock);
2477 lsp = ddi_get_soft_state(lofi_statep, klip->li_minor);
2478 if (lsp == NULL || lofi_access(lsp) != 0) {
2479 mutex_exit(&lofi_lock);
2480 free_lofi_ioctl(klip);
2481 return (ENXIO);
2482 }
2483
2484 /*
2485 * This may fail if, for example, we're trying to look
2486 * up a zoned NFS path from the global zone.
2487 */
2488 if (vnodetopath(NULL, lsp->ls_stacked_vp, klip->li_filename,
2489 sizeof (klip->li_filename), CRED()) != 0) {
2490 (void) strlcpy(klip->li_filename, "?",
2491 sizeof (klip->li_filename));
2492 }
2493
2494 klip->li_readonly = lsp->ls_readonly;
2495
2496 (void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
2497 sizeof (klip->li_algorithm));
2498 klip->li_crypto_enabled = lsp->ls_crypto_enabled;
2499 mutex_exit(&lofi_lock);
2500 error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
2501 free_lofi_ioctl(klip);
2502 return (error);
2503 case LOFI_GET_MINOR:
2504 mutex_enter(&lofi_lock);
2505 error = file_to_lofi(klip->li_filename,
2506 klip->li_readonly, &lsp);
2507 if (error == 0)
2508 klip->li_minor = getminor(lsp->ls_dev);
2509 mutex_exit(&lofi_lock);
2510
2511 if (error == 0)
2512 error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
2513
2514 free_lofi_ioctl(klip);
2515 return (error);
2516 case LOFI_CHECK_COMPRESSED:
2517 mutex_enter(&lofi_lock);
2518 error = file_to_lofi(klip->li_filename,
2519 klip->li_readonly, &lsp);
2520 if (error != 0) {
2521 mutex_exit(&lofi_lock);
2522 free_lofi_ioctl(klip);
2523 return (error);
2524 }
2525
2526 klip->li_minor = getminor(lsp->ls_dev);
2527 (void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
2528 sizeof (klip->li_algorithm));
2529
2530 mutex_exit(&lofi_lock);
2531 error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
2532 free_lofi_ioctl(klip);
2533 return (error);
2534 default:
2535 free_lofi_ioctl(klip);
2536 return (EINVAL);
2537 }
2538 }
2539
2540 static int
2541 lofi_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *credp,
2542 int *rvalp)
2543 {
2544 int error;
2545 enum dkio_state dkstate;
2546 struct lofi_state *lsp;
2547 minor_t minor;
2548
2549 minor = getminor(dev);
2550 /* lofi ioctls only apply to the master device */
2551 if (minor == 0) {
2552 struct lofi_ioctl *lip = (struct lofi_ioctl *)arg;
2553
2554 /*
2555 * the query command only need read-access - i.e., normal
2556 * users are allowed to do those on the ctl device as
2557 * long as they can open it read-only.
2558 */
2559 switch (cmd) {
2560 case LOFI_MAP_FILE:
2561 if ((flag & FWRITE) == 0)
2562 return (EPERM);
2563 return (lofi_map_file(dev, lip, 1, rvalp, credp, flag));
2564 case LOFI_MAP_FILE_MINOR:
2565 if ((flag & FWRITE) == 0)
2566 return (EPERM);
2567 return (lofi_map_file(dev, lip, 0, rvalp, credp, flag));
2568 case LOFI_UNMAP_FILE:
2569 if ((flag & FWRITE) == 0)
2570 return (EPERM);
2571 return (lofi_unmap_file(lip, 1, credp, flag));
2572 case LOFI_UNMAP_FILE_MINOR:
2573 if ((flag & FWRITE) == 0)
2574 return (EPERM);
2575 return (lofi_unmap_file(lip, 0, credp, flag));
2576 case LOFI_GET_FILENAME:
2577 return (lofi_get_info(dev, lip, LOFI_GET_FILENAME,
2578 credp, flag));
2579 case LOFI_GET_MINOR:
2580 return (lofi_get_info(dev, lip, LOFI_GET_MINOR,
2581 credp, flag));
2582
2583 /*
2584 * This API made limited sense when this value was fixed
2585 * at LOFI_MAX_FILES. However, its use to iterate
2586 * across all possible devices in lofiadm means we don't
2587 * want to return L_MAXMIN32, but the highest
2588 * *allocated* minor.
2589 */
2590 case LOFI_GET_MAXMINOR:
2591 minor = 0;
2592
2593 mutex_enter(&lofi_lock);
2594
2595 for (lsp = list_head(&lofi_list); lsp != NULL;
2596 lsp = list_next(&lofi_list, lsp)) {
2597 if (lofi_access(lsp) != 0)
2598 continue;
2599
2600 if (getminor(lsp->ls_dev) > minor)
2601 minor = getminor(lsp->ls_dev);
2602 }
2603
2604 mutex_exit(&lofi_lock);
2605
2606 error = ddi_copyout(&minor, &lip->li_minor,
2607 sizeof (minor), flag);
2608 if (error)
2609 return (EFAULT);
2610 return (0);
2611
2612 case LOFI_CHECK_COMPRESSED:
2613 return (lofi_get_info(dev, lip, LOFI_CHECK_COMPRESSED,
2614 credp, flag));
2615 default:
2616 return (EINVAL);
2617 }
2618 }
2619
2620 mutex_enter(&lofi_lock);
2621 lsp = ddi_get_soft_state(lofi_statep, minor);
2622 if (lsp == NULL || lsp->ls_vp_closereq) {
2623 mutex_exit(&lofi_lock);
2624 return (ENXIO);
2625 }
2626 mutex_exit(&lofi_lock);
2627
2628 /*
2629 * We explicitly allow DKIOCSTATE, but all other ioctls should fail with
2630 * EIO as if the device was no longer present.
2631 */
2632 if (lsp->ls_vp == NULL && cmd != DKIOCSTATE)
2633 return (EIO);
2634
2635 /* these are for faking out utilities like newfs */
2636 switch (cmd) {
2637 case DKIOCGVTOC:
2638 switch (ddi_model_convert_from(flag & FMODELS)) {
2639 case DDI_MODEL_ILP32: {
2640 struct vtoc32 vtoc32;
2641
2642 vtoctovtoc32(lsp->ls_vtoc, vtoc32);
2643 if (ddi_copyout(&vtoc32, (void *)arg,
2644 sizeof (struct vtoc32), flag))
2645 return (EFAULT);
2646 break;
2647 }
2648
2649 case DDI_MODEL_NONE:
2650 if (ddi_copyout(&lsp->ls_vtoc, (void *)arg,
2651 sizeof (struct vtoc), flag))
2652 return (EFAULT);
2653 break;
2654 }
2655 return (0);
2656 case DKIOCINFO:
2657 error = ddi_copyout(&lsp->ls_ci, (void *)arg,
2658 sizeof (struct dk_cinfo), flag);
2659 if (error)
2660 return (EFAULT);
2661 return (0);
2662 case DKIOCG_VIRTGEOM:
2663 case DKIOCG_PHYGEOM:
2664 case DKIOCGGEOM:
2665 error = ddi_copyout(&lsp->ls_dkg, (void *)arg,
2666 sizeof (struct dk_geom), flag);
2667 if (error)
2668 return (EFAULT);
2669 return (0);
2670 case DKIOCSTATE:
2671 /*
2672 * Normally, lofi devices are always in the INSERTED state. If
2673 * a device is forcefully unmapped, then the device transitions
2674 * to the DKIO_DEV_GONE state.
2675 */
2676 if (ddi_copyin((void *)arg, &dkstate, sizeof (dkstate),
2677 flag) != 0)
2678 return (EFAULT);
2679
2680 mutex_enter(&lsp->ls_vp_lock);
2681 lsp->ls_vp_iocount++;
2682 while (((dkstate == DKIO_INSERTED && lsp->ls_vp != NULL) ||
2683 (dkstate == DKIO_DEV_GONE && lsp->ls_vp == NULL)) &&
2684 !lsp->ls_vp_closereq) {
2685 /*
2686 * By virtue of having the device open, we know that
2687 * 'lsp' will remain valid when we return.
2688 */
2689 if (!cv_wait_sig(&lsp->ls_vp_cv,
2690 &lsp->ls_vp_lock)) {
2691 lsp->ls_vp_iocount--;
2692 cv_broadcast(&lsp->ls_vp_cv);
2693 mutex_exit(&lsp->ls_vp_lock);
2694 return (EINTR);
2695 }
2696 }
2697
2698 dkstate = (!lsp->ls_vp_closereq && lsp->ls_vp != NULL ?
2699 DKIO_INSERTED : DKIO_DEV_GONE);
2700 lsp->ls_vp_iocount--;
2701 cv_broadcast(&lsp->ls_vp_cv);
2702 mutex_exit(&lsp->ls_vp_lock);
2703
2704 if (ddi_copyout(&dkstate, (void *)arg,
2705 sizeof (dkstate), flag) != 0)
2706 return (EFAULT);
2707 return (0);
2708 default:
2709 return (ENOTTY);
2710 }
2711 }
2712
2713 static struct cb_ops lofi_cb_ops = {
2714 lofi_open, /* open */
2715 lofi_close, /* close */
2716 lofi_strategy, /* strategy */
2717 nodev, /* print */
2718 nodev, /* dump */
2719 lofi_read, /* read */
2720 lofi_write, /* write */
2721 lofi_ioctl, /* ioctl */
2722 nodev, /* devmap */
2723 nodev, /* mmap */
2724 nodev, /* segmap */
2725 nochpoll, /* poll */
2726 ddi_prop_op, /* prop_op */
2727 0, /* streamtab */
2728 D_64BIT | D_NEW | D_MP, /* Driver compatibility flag */
2729 CB_REV,
2730 lofi_aread,
2731 lofi_awrite
2732 };
2733
2734 static struct dev_ops lofi_ops = {
2735 DEVO_REV, /* devo_rev, */
2736 0, /* refcnt */
2737 lofi_info, /* info */
2738 nulldev, /* identify */
2739 nulldev, /* probe */
2740 lofi_attach, /* attach */
2741 lofi_detach, /* detach */
2742 nodev, /* reset */
2743 &lofi_cb_ops, /* driver operations */
2744 NULL, /* no bus operations */
2745 NULL, /* power */
2746 ddi_quiesce_not_needed, /* quiesce */
2747 };
2748
2749 static struct modldrv modldrv = {
2750 &mod_driverops,
2751 "loopback file driver",
2752 &lofi_ops,
2753 };
2754
2755 static struct modlinkage modlinkage = {
2756 MODREV_1,
2757 &modldrv,
2758 NULL
2759 };
2760
2761 int
2762 _init(void)
2763 {
2764 int error;
2765
2766 list_create(&lofi_list, sizeof (struct lofi_state),
2767 offsetof(struct lofi_state, ls_list));
2768
2769 error = ddi_soft_state_init(&lofi_statep,
2770 sizeof (struct lofi_state), 0);
2771 if (error)
2772 return (error);
2773
2774 mutex_init(&lofi_lock, NULL, MUTEX_DRIVER, NULL);
2775
2776 error = mod_install(&modlinkage);
2777 if (error) {
2778 mutex_destroy(&lofi_lock);
2779 ddi_soft_state_fini(&lofi_statep);
2780 list_destroy(&lofi_list);
2781 }
2782
2783 return (error);
2784 }
2785
2786 int
2787 _fini(void)
2788 {
2789 int error;
2790
2791 mutex_enter(&lofi_lock);
2792
2793 if (!list_is_empty(&lofi_list)) {
2794 mutex_exit(&lofi_lock);
2795 return (EBUSY);
2796 }
2797
2798 mutex_exit(&lofi_lock);
2799
2800 error = mod_remove(&modlinkage);
2801 if (error)
2802 return (error);
2803
2804 mutex_destroy(&lofi_lock);
2805 ddi_soft_state_fini(&lofi_statep);
2806 list_destroy(&lofi_list);
2807
2808 return (error);
2809 }
2810
2811 int
2812 _info(struct modinfo *modinfop)
2813 {
2814 return (mod_info(&modlinkage, modinfop));
2815 }