xref: /titanic_41/usr/src/uts/common/io/lofi.c (revision 1a95defd9ad2425f3c74030860dd9eb24a3e7930)
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
SzAlloc(void * p,size_t size)217 *SzAlloc(void *p, size_t size)
218 {
219 	return (kmem_alloc(size, KM_SLEEP));
220 }
221 
222 /*ARGSUSED*/
223 static void
SzFree(void * p,void * address,size_t size)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
lofi_free_comp_cache(struct lofi_state * lsp)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
is_opened(struct lofi_state * lsp)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
mark_opened(struct lofi_state * lsp,int otyp)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
mark_closed(struct lofi_state * lsp,int otyp)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
lofi_free_crypto(struct lofi_state * lsp)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
lofi_destroy(struct lofi_state * lsp,cred_t * credp)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
lofi_free_dev(dev_t dev)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
lofi_zone_shutdown(zoneid_t zoneid,void * arg)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
lofi_open(dev_t * devp,int flag,int otyp,struct cred * credp)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
lofi_close(dev_t dev,int flag,int otyp,struct cred * credp)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
lofi_blk_mech(struct lofi_state * lsp,longlong_t lblkno)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
lofi_crypto(struct lofi_state * lsp,struct buf * bp,caddr_t plaintext,caddr_t ciphertext,size_t len,boolean_t op_encrypt)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
lofi_rdwr(caddr_t bufaddr,offset_t offset,struct buf * bp,struct lofi_state * lsp,size_t len,int method,caddr_t bcopy_locn)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
lofi_mapped_rdwr(caddr_t bufaddr,offset_t offset,struct buf * bp,struct lofi_state * lsp)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 *
lofi_find_comp_data(struct lofi_state * lsp,uint64_t seg_index)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 *
lofi_add_comp_data(struct lofi_state * lsp,uint64_t seg_index,uchar_t * data)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
gzip_decompress(void * src,size_t srclen,void * dst,size_t * dstlen,int level)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
lzma_decompress(void * src,size_t srclen,void * dst,size_t * dstlen,int level)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
lofi_strategy_task(void * arg)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
lofi_strategy(struct buf * bp)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
lofi_read(dev_t dev,struct uio * uio,struct cred * credp)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
lofi_write(dev_t dev,struct uio * uio,struct cred * credp)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
lofi_aread(dev_t dev,struct aio_req * aio,struct cred * credp)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
lofi_awrite(dev_t dev,struct aio_req * aio,struct cred * credp)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
lofi_info(dev_info_t * dip,ddi_info_cmd_t infocmd,void * arg,void ** result)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
lofi_attach(dev_info_t * dip,ddi_attach_cmd_t cmd)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
lofi_detach(dev_info_t * dip,ddi_detach_cmd_t cmd)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
free_lofi_ioctl(struct lofi_ioctl * klip)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
copy_in_lofi_ioctl(const struct lofi_ioctl * ulip,struct lofi_ioctl ** klipp,int flag)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
copy_out_lofi_ioctl(const struct lofi_ioctl * klip,struct lofi_ioctl * ulip,int flag)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
lofi_access(struct lofi_state * lsp)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
file_to_lofi_nocheck(char * filename,boolean_t readonly,struct lofi_state ** lspp)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
file_to_lofi(char * filename,boolean_t readonly,struct lofi_state ** lspp)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
fake_disk_geometry(struct lofi_state * lsp)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
lofi_map_compressed_file(struct lofi_state * lsp,char * buf)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
lofi_init_crypto(struct lofi_state * lsp,struct lofi_ioctl * klip)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
lofi_compress_select(const char * signature)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
lofi_init_compress(struct lofi_state * lsp)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
lofi_map_file(dev_t dev,struct lofi_ioctl * ulip,int pickminor,int * rvalp,struct cred * credp,int ioctl_flag)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
lofi_unmap_file(struct lofi_ioctl * ulip,int byfilename,struct cred * credp,int ioctl_flag)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
lofi_get_info(dev_t dev,struct lofi_ioctl * ulip,int which,struct cred * credp,int ioctl_flag)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
lofi_ioctl(dev_t dev,int cmd,intptr_t arg,int flag,cred_t * credp,int * rvalp)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
_init(void)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
_fini(void)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
_info(struct modinfo * modinfop)2812 _info(struct modinfo *modinfop)
2813 {
2814 	return (mod_info(&modlinkage, modinfop));
2815 }
2816