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 }