lofi.c revision 406fc5100dac8d225a315a6def6be8d628f34e24
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * CDDL HEADER START
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * The contents of this file are subject to the terms of the
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Common Development and Distribution License (the "License").
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * You may not use this file except in compliance with the License.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * or http://www.opensolaris.org/os/licensing.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * See the License for the specific language governing permissions
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * and limitations under the License.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * When distributing Covered Code, include this CDDL HEADER in each
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * If applicable, add the following below this CDDL HEADER, with the
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * fields enclosed by brackets "[]" replaced with your own identifying
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * information: Portions Copyright [yyyy] [name of copyright owner]
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * CDDL HEADER END
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster/*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Copyright (c) 2016 Andrey Sokolov
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Copyright 2016 Toomas Soome <tsoome@me.com>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster/*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * lofi (loopback file) driver - allows you to attach a file to a device,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * which can then be accessed through that device. The simple model is that
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * you tell lofi to open a file, and then use the block device you get as
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * you would any block device. lofi translates access to the block device
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * into I/O on the underlying file. This is mostly useful for
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * mounting images of filesystems.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * lofi is controlled through /dev/lofictl - this is the only device exported
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * during attach, and is instance number 0. lofiadm communicates with lofi
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * through ioctls on this device. When a file is attached to lofi, block and
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * character devices are exported in /dev/lofi and /dev/rlofi. These devices
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * are identified by lofi instance number, and the instance number is also used
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * as the name in /dev/lofi.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Virtual disks, or, labeled lofi, implements virtual disk support to
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * support partition table and related tools. Such mappings will cause
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * block and character devices to be exported in /dev/dsk and /dev/rdsk
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * directories.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * To support virtual disks, the instance number space is divided to two
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * parts, upper part for instance number and lower part for minor number
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * space to identify partitions and slices. The virtual disk support is
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * implemented by stacking cmlb module. For virtual disks, the partition
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * related ioctl calls are routed to cmlb module. Compression and encryption
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * is not supported for virtual disks.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Mapped devices are tracked with state structures handled with
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * ddi_soft_state(9F) for simplicity.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * A file attached to lofi is opened when attached and not closed until
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * explicitly detached from lofi. This seems more sensible than deferring
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * the open until the /dev/lofi device is opened, for a number of reasons.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * One is that any failure is likely to be noticed by the person (or script)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * running lofiadm. Another is that it would be a security problem if the
ce4d3fddc8fe2eddd68a20af9570b3cc63ece5abNeil Madden * file was replaced by another one after being added but before being opened.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * The only hard part about lofi is the ioctls. In order to support things
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * like 'newfs' on a lofi device, it needs to support certain disk ioctls.
57a1b25dcdf865eacb2fe2e17c5ca83e942da047David Luna * So it has to fake disk geometry and partition information. More may need
57a1b25dcdf865eacb2fe2e17c5ca83e942da047David Luna * to be faked if your favorite utility doesn't work and you think it should
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * (fdformat doesn't work because it really wants to know the type of floppy
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * controller to talk to, and that didn't seem easy to fake. Or possibly even
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * necessary, since we have mkfs_pcfs now).
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Normally, a lofi device cannot be detached if it is open (i.e. busy). To
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * support simulation of hotplug events, an optional force flag is provided.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * If a lofi device is open when a force detach is requested, then the
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * underlying file is closed and any subsequent operations return EIO. When the
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * device is closed for the last time, it will be cleaned up at that time. In
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * addition, the DKIOCSTATE ioctl will return DKIO_DEV_GONE when the device is
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * detached but not removed.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Known problems:
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * UFS logging. Mounting a UFS filesystem image "logging"
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * works for basic copy testing but wedges during a build of ON through
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * that image. Some deadlock in lufs holding the log mutex and then
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * getting stuck on a buf. So for now, don't do that.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Direct I/O. Since the filesystem data is being cached in the buffer
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * cache, _and_ again in the underlying filesystem, it's tempting to
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * enable direct I/O on the underlying file. Don't, because that deadlocks.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * I think to fix the cache-twice problem we might need filesystem support.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Interesting things to do:
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Allow multiple files for each device. A poor-man's metadisk, basically.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Pass-through ioctls on block devices. You can (though it's not
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * documented), give lofi a block device as a file name. Then we shouldn't
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * need to fake a geometry, however, it may be relevant if you're replacing
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * metadisk, or using lofi to get crypto.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * It makes sense to do lofiadm -c aes -a /dev/dsk/c0t0d0s4 /dev/lofi/1
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * and then in /etc/vfstab have an entry for /dev/lofi/1 as /export/home.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * In fact this even makes sense if you have lofi "above" metadisk.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Encryption:
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Each lofi device can have its own symmetric key and cipher.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * They are passed to us by lofiadm(1m) in the correct format for use
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * with the misc/kcf crypto_* routines.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Each block has its own IV, that is calculated in lofi_blk_mech(), based
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * on the "master" key held in the lsp and the block number of the buffer.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/types.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <netinet/in.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/sysmacros.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/uio.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/kmem.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/cred.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/mman.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/errno.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/aio_req.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/stat.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/file.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/modctl.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/conf.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/debug.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/vnode.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/lofi.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/fcntl.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/pathname.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/filio.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/fdio.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/open.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/disp.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <vm/seg_map.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/ddi.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/sunddi.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/zmod.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/id_space.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/mkdev.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/crypto/common.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/crypto/api.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/rctl.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/vtoc.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#include <sys/scsi/scsi.h> /* for DTYPE_DIRECT */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/scsi/impl/uscsi.h>
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#include <sys/sysevent/dev.h>
ce4d3fddc8fe2eddd68a20af9570b3cc63ece5abNeil Madden#include <LzmaDec.h>
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#define NBLOCKS_PROP_NAME "Nblocks"
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#define SIZE_PROP_NAME "Size"
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#define ZONE_PROP_NAME "zone"
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#define SETUP_C_DATA(cd, buf, len) \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_format = CRYPTO_DATA_RAW; \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_offset = 0; \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_miscdata = NULL; \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_length = (len); \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_raw.iov_base = (buf); \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (cd).cd_raw.iov_len = (len);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington#define UIO_CHECK(uio) \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (((uio)->uio_loffset % DEV_BSIZE) != 0 || \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington ((uio)->uio_resid % DEV_BSIZE) != 0) { \
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (EINVAL); \
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#define DEVFS_CHANNEL "devfsadm_event_channel"
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster#define LOFI_TIMEOUT 30
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterstatic evchan_t *lofi_chan;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic kmutex_t lofi_chan_lock;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic kcondvar_t lofi_chan_cv;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterstatic nvlist_t *lofi_devlink_cache;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic void *lofi_statep;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterstatic kmutex_t lofi_lock; /* state lock */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic id_space_t *lofi_id; /* lofi ID values */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic list_t lofi_list;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic zone_key_t lofi_zone_key;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster/*
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Because lofi_taskq_nthreads limits the actual swamping of the device, the
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * maxalloc parameter (lofi_taskq_maxalloc) should be tuned conservatively
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * high. If we want to be assured that the underlying device is always busy,
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * we must be sure that the number of bytes enqueued when the number of
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * enqueued tasks exceeds maxalloc is sufficient to keep the device busy for
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * the duration of the sleep time in taskq_ent_alloc(). That is, lofi should
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * set maxalloc to be the maximum throughput (in bytes per second) of the
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * underlying device divided by the minimum I/O size. We assume a realistic
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * maximum throughput of one hundred megabytes per second; we set maxalloc on
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * the lofi task queue to be 104857600 divided by DEV_BSIZE.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int lofi_taskq_maxalloc = 104857600 / DEV_BSIZE;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int lofi_taskq_nthreads = 4; /* # of taskq threads per device */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterconst char lofi_crypto_magic[6] = LOFI_CRYPTO_MAGIC;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * To avoid decompressing data in a compressed segment multiple times
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * when accessing small parts of a segment's data, we cache and reuse
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * the uncompressed segment's data.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * A single cached segment is sufficient to avoid lots of duplicate
7f1ad89d15984c64fde1e507c3b38238cb2e3f8dJames Phillpotts * segment decompress operations. A small cache size also reduces the
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * memory footprint.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * lofi_max_comp_cache is the maximum number of decompressed data segments
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * cached for each compressed lofi image. It can be set to 0 to disable
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * caching.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosteruint32_t lofi_max_comp_cache = 1;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int gzip_decompress(void *src, size_t srclen, void *dst,
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington size_t *destlen, int level);
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int lzma_decompress(void *src, size_t srclen, void *dst,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster size_t *dstlen, int level);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonlofi_compress_info_t lofi_compress_table[LOFI_COMPRESS_FUNCTIONS] = {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington {gzip_decompress, NULL, 6, "gzip"}, /* default */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington {gzip_decompress, NULL, 6, "gzip-6"},
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster {gzip_decompress, NULL, 9, "gzip-9"},
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington {lzma_decompress, NULL, 0, "lzma"}
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington};
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic void lofi_strategy_task(void *);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int lofi_tg_rdwr(dev_info_t *, uchar_t, void *, diskaddr_t,
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington size_t, void *);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int lofi_tg_getinfo(dev_info_t *, int, void *, void *);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterstruct cmlb_tg_ops lofi_tg_ops = {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster TG_DK_OPS_VERSION_1,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lofi_tg_rdwr,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lofi_tg_getinfo
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna};
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna/*ARGSUSED*/
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Lunastatic void
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna*SzAlloc(void *p, size_t size)
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna{
7e1f38ed3474c45b25b65d5784e78f72fc25556bDavid Luna return (kmem_alloc(size, KM_SLEEP));
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster}
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/*ARGSUSED*/
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic void
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill CunningtonSzFree(void *p, void *address, size_t size)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington{
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster kmem_free(address, size);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington}
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic ISzAlloc g_Alloc = { SzAlloc, SzFree };
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Free data referenced by the linked list of cached uncompressed
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * segments.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic void
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterlofi_free_comp_cache(struct lofi_state *lsp)
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster{
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington struct lofi_comp_cache *lc;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster while ((lc = list_remove_head(&lsp->ls_comp_cache)) != NULL) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington kmem_free(lc, sizeof (struct lofi_comp_cache));
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp->ls_comp_cache_count--;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington ASSERT(lsp->ls_comp_cache_count == 0);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington}
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosterstatic int
8af80418ba1ec431c8027fa9668e5678658d3611Allan Fosteris_opened(struct lofi_state *lsp)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington{
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington int i;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington boolean_t last = B_TRUE;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington ASSERT(MUTEX_HELD(&lofi_lock));
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster for (i = 0; i < LOFI_PART_MAX; i++) {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster if (lsp->ls_open_lyr[i]) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington last = B_FALSE;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington break;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington for (i = 0; last && (i < OTYP_LYR); i++) {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster if (lsp->ls_open_reg[i]) {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster last = B_FALSE;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (!last);
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster}
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic void
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonlofi_free_crypto(struct lofi_state *lsp)
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster{
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster ASSERT(MUTEX_HELD(&lofi_lock));
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (lsp->ls_crypto_enabled) {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster /*
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Clean up the crypto state so that it doesn't hang around
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * in memory after we are done with it.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster if (lsp->ls_key.ck_data != NULL) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bzero(lsp->ls_key.ck_data,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster kmem_free(lsp->ls_key.ck_data,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp->ls_key.ck_data = NULL;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lsp->ls_key.ck_length = 0;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster if (lsp->ls_mech.cm_param != NULL) {
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster kmem_free(lsp->ls_mech.cm_param,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lsp->ls_mech.cm_param_len);
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lsp->ls_mech.cm_param = NULL;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster lsp->ls_mech.cm_param_len = 0;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster }
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (lsp->ls_iv_mech.cm_param != NULL) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington kmem_free(lsp->ls_iv_mech.cm_param,
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp->ls_iv_mech.cm_param_len);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp->ls_iv_mech.cm_param = NULL;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp->ls_iv_mech.cm_param_len = 0;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington mutex_destroy(&lsp->ls_crypto_lock);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster}
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/* ARGSUSED */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonstatic int
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunningtonlofi_tg_rdwr(dev_info_t *dip, uchar_t cmd, void *bufaddr, diskaddr_t start,
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington size_t length, void *tg_cookie)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington{
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington struct lofi_state *lsp;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington buf_t *bp;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington int instance;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington int rv = 0;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington instance = ddi_get_instance(dip);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (instance == 0) /* control node does not have disk */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (ENXIO);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington lsp = ddi_get_soft_state(lofi_statep, instance);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (lsp == NULL)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (ENXIO);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (cmd != TG_READ && cmd != TG_WRITE)
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster return (EINVAL);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington /*
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Make sure the mapping is set up by checking lsp->ls_vp_ready.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington */
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster mutex_enter(&lsp->ls_vp_lock);
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster while (lsp->ls_vp_ready == B_FALSE)
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington mutex_exit(&lsp->ls_vp_lock);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (P2PHASE(length, (1U << lsp->ls_lbshift)) != 0) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington /* We can only transfer whole blocks at a time! */
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (EINVAL);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp = getrbuf(KM_SLEEP);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster if (cmd == TG_READ) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp->b_flags = B_READ;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington } else {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (lsp->ls_readonly == B_TRUE) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington freerbuf(bp);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (EROFS);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster bp->b_flags = B_WRITE;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp->b_un.b_addr = bufaddr;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp->b_bcount = length;
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster bp->b_lblkno = start;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp->b_private = NULL;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington bp->b_edev = lsp->ls_dev;
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington if (lsp->ls_kstat) {
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington mutex_enter(lsp->ls_kstat->ks_lock);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington kstat_waitq_enter(KSTAT_IO_PTR(lsp->ls_kstat));
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington mutex_exit(lsp->ls_kstat->ks_lock);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington }
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (void) taskq_dispatch(lsp->ls_taskq, lofi_strategy_task, bp, KM_SLEEP);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington (void) biowait(bp);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington rv = geterror(bp);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington freerbuf(bp);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington return (rv);
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington}
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington/*
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * Get device geometry info for cmlb.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * We have mapped disk image as virtual block device and have to report
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * physical/virtual geometry to cmlb.
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington *
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * So we have two principal cases:
bee2440354b4bc8796e1de0b6cbd60e1f68deba0Phill Cunnington * 1. Uninitialised image without any existing labels,
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * for this case we fabricate the data based on mapped image.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * 2. Image with existing label information.
8af80418ba1ec431c8027fa9668e5678658d3611Allan Foster * Since we have no information how the image was created (it may be
* dump from some physical device), we need to rely on label information
* from image, or we get "corrupted label" errors.
* NOTE: label can be MBR, MBR+SMI, GPT
*/
static int
lofi_tg_getinfo(dev_info_t *dip, int cmd, void *arg, void *tg_cookie)
{
struct lofi_state *lsp;
int instance;
int ashift;
_NOTE(ARGUNUSED(tg_cookie));
instance = ddi_get_instance(dip);
if (instance == 0) /* control device has no storage */
return (ENXIO);
lsp = ddi_get_soft_state(lofi_statep, instance);
if (lsp == NULL)
return (ENXIO);
/*
* Make sure the mapping is set up by checking lsp->ls_vp_ready.
*
* When mapping is created, new lofi instance is created and
* lofi_attach() will call cmlb_attach() as part of the procedure
* to set the mapping up. This chain of events will happen in
* the same thread.
* Since cmlb_attach() will call lofi_tg_getinfo to get
* capacity, we return error on that call if cookie is set,
* otherwise lofi_attach will be stuck as the mapping is not yet
* finalized and lofi is not yet ready.
* Note, such error is not fatal for cmlb, as the label setup
* will be finalized when cmlb_validate() is called.
*/
mutex_enter(&lsp->ls_vp_lock);
if (tg_cookie != NULL && lsp->ls_vp_ready == B_FALSE) {
mutex_exit(&lsp->ls_vp_lock);
return (ENXIO);
}
while (lsp->ls_vp_ready == B_FALSE)
cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
mutex_exit(&lsp->ls_vp_lock);
ashift = lsp->ls_lbshift;
switch (cmd) {
case TG_GETPHYGEOM: {
cmlb_geom_t *geomp = arg;
geomp->g_capacity =
(lsp->ls_vp_size - lsp->ls_crypto_offset) >> ashift;
geomp->g_nsect = lsp->ls_dkg.dkg_nsect;
geomp->g_nhead = lsp->ls_dkg.dkg_nhead;
geomp->g_acyl = lsp->ls_dkg.dkg_acyl;
geomp->g_ncyl = lsp->ls_dkg.dkg_ncyl;
geomp->g_secsize = (1U << ashift);
geomp->g_intrlv = lsp->ls_dkg.dkg_intrlv;
geomp->g_rpm = lsp->ls_dkg.dkg_rpm;
return (0);
}
case TG_GETCAPACITY:
*(diskaddr_t *)arg =
(lsp->ls_vp_size - lsp->ls_crypto_offset) >> ashift;
return (0);
case TG_GETBLOCKSIZE:
*(uint32_t *)arg = (1U << ashift);
return (0);
case TG_GETATTR: {
tg_attribute_t *tgattr = arg;
tgattr->media_is_writable = !lsp->ls_readonly;
tgattr->media_is_solid_state = B_FALSE;
return (0);
}
default:
return (EINVAL);
}
}
static void
lofi_destroy(struct lofi_state *lsp, cred_t *credp)
{
int id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
int i;
ASSERT(MUTEX_HELD(&lofi_lock));
list_remove(&lofi_list, lsp);
lofi_free_crypto(lsp);
/*
* Free pre-allocated compressed buffers
*/
if (lsp->ls_comp_bufs != NULL) {
for (i = 0; i < lofi_taskq_nthreads; i++) {
if (lsp->ls_comp_bufs[i].bufsize > 0)
kmem_free(lsp->ls_comp_bufs[i].buf,
lsp->ls_comp_bufs[i].bufsize);
}
kmem_free(lsp->ls_comp_bufs,
sizeof (struct compbuf) * lofi_taskq_nthreads);
}
if (lsp->ls_vp != NULL) {
(void) VOP_PUTPAGE(lsp->ls_vp, 0, 0, B_INVAL, credp, NULL);
(void) VOP_CLOSE(lsp->ls_vp, lsp->ls_openflag,
1, 0, credp, NULL);
VN_RELE(lsp->ls_vp);
}
if (lsp->ls_stacked_vp != lsp->ls_vp)
VN_RELE(lsp->ls_stacked_vp);
if (lsp->ls_taskq != NULL)
taskq_destroy(lsp->ls_taskq);
if (lsp->ls_kstat != NULL)
kstat_delete(lsp->ls_kstat);
/*
* Free cached decompressed segment data
*/
lofi_free_comp_cache(lsp);
list_destroy(&lsp->ls_comp_cache);
if (lsp->ls_uncomp_seg_sz > 0) {
kmem_free(lsp->ls_comp_index_data, lsp->ls_comp_index_data_sz);
lsp->ls_uncomp_seg_sz = 0;
}
rctl_decr_lofi(lsp->ls_zone.zref_zone, 1);
zone_rele_ref(&lsp->ls_zone, ZONE_REF_LOFI);
mutex_destroy(&lsp->ls_comp_cache_lock);
mutex_destroy(&lsp->ls_comp_bufs_lock);
mutex_destroy(&lsp->ls_kstat_lock);
mutex_destroy(&lsp->ls_vp_lock);
cv_destroy(&lsp->ls_vp_cv);
lsp->ls_vp_ready = B_FALSE;
ASSERT(ddi_get_soft_state(lofi_statep, id) == lsp);
(void) ndi_devi_offline(lsp->ls_dip, NDI_DEVI_REMOVE);
id_free(lofi_id, id);
}
static void
lofi_free_dev(struct lofi_state *lsp)
{
ASSERT(MUTEX_HELD(&lofi_lock));
if (lsp->ls_cmlbhandle != NULL) {
cmlb_invalidate(lsp->ls_cmlbhandle, 0);
cmlb_detach(lsp->ls_cmlbhandle, 0);
cmlb_free_handle(&lsp->ls_cmlbhandle);
lsp->ls_cmlbhandle = NULL;
}
(void) ddi_prop_remove_all(lsp->ls_dip);
ddi_remove_minor_node(lsp->ls_dip, NULL);
}
/*ARGSUSED*/
static void
lofi_zone_shutdown(zoneid_t zoneid, void *arg)
{
struct lofi_state *lsp;
struct lofi_state *next;
mutex_enter(&lofi_lock);
for (lsp = list_head(&lofi_list); lsp != NULL; lsp = next) {
/* lofi_destroy() frees lsp */
next = list_next(&lofi_list, lsp);
if (lsp->ls_zone.zref_zone->zone_id != zoneid)
continue;
/*
* No in-zone processes are running, but something has this
* open. It's either a global zone process, or a lofi
* mount. In either case we set ls_cleanup so the last
* user destroys the device.
*/
if (is_opened(lsp)) {
lsp->ls_cleanup = 1;
} else {
lofi_free_dev(lsp);
lofi_destroy(lsp, kcred);
}
}
mutex_exit(&lofi_lock);
}
/*ARGSUSED*/
static int
lofi_open(dev_t *devp, int flag, int otyp, struct cred *credp)
{
int id;
minor_t part;
uint64_t mask;
diskaddr_t nblks;
diskaddr_t lba;
boolean_t ndelay;
struct lofi_state *lsp;
if (otyp >= OTYPCNT)
return (EINVAL);
ndelay = (flag & (FNDELAY | FNONBLOCK)) ? B_TRUE : B_FALSE;
/*
* lofiadm -a /dev/lofi/1 gets us here.
*/
if (mutex_owner(&lofi_lock) == curthread)
return (EINVAL);
mutex_enter(&lofi_lock);
id = LOFI_MINOR2ID(getminor(*devp));
part = LOFI_PART(getminor(*devp));
mask = (1U << part);
/* master control device */
if (id == 0) {
mutex_exit(&lofi_lock);
return (0);
}
/* otherwise, the mapping should already exist */
lsp = ddi_get_soft_state(lofi_statep, id);
if (lsp == NULL) {
mutex_exit(&lofi_lock);
return (EINVAL);
}
if (lsp->ls_vp == NULL) {
mutex_exit(&lofi_lock);
return (ENXIO);
}
if (lsp->ls_readonly && (flag & FWRITE)) {
mutex_exit(&lofi_lock);
return (EROFS);
}
if ((lsp->ls_open_excl) & (mask)) {
mutex_exit(&lofi_lock);
return (EBUSY);
}
if (flag & FEXCL) {
if (lsp->ls_open_lyr[part]) {
mutex_exit(&lofi_lock);
return (EBUSY);
}
for (int i = 0; i < OTYP_LYR; i++) {
if (lsp->ls_open_reg[i] & mask) {
mutex_exit(&lofi_lock);
return (EBUSY);
}
}
}
if (lsp->ls_cmlbhandle != NULL) {
if (cmlb_validate(lsp->ls_cmlbhandle, 0, 0) != 0) {
/*
* non-blocking opens are allowed to succeed to
* support format and fdisk to create partitioning.
*/
if (!ndelay) {
mutex_exit(&lofi_lock);
return (ENXIO);
}
} else if (cmlb_partinfo(lsp->ls_cmlbhandle, part, &nblks, &lba,
NULL, NULL, 0) == 0) {
if ((!nblks) && ((!ndelay) || (otyp != OTYP_CHR))) {
mutex_exit(&lofi_lock);
return (ENXIO);
}
} else if (!ndelay) {
mutex_exit(&lofi_lock);
return (ENXIO);
}
}
if (otyp == OTYP_LYR) {
lsp->ls_open_lyr[part]++;
} else {
lsp->ls_open_reg[otyp] |= mask;
}
if (flag & FEXCL) {
lsp->ls_open_excl |= mask;
}
mutex_exit(&lofi_lock);
return (0);
}
/*ARGSUSED*/
static int
lofi_close(dev_t dev, int flag, int otyp, struct cred *credp)
{
minor_t part;
int id;
uint64_t mask;
struct lofi_state *lsp;
id = LOFI_MINOR2ID(getminor(dev));
part = LOFI_PART(getminor(dev));
mask = (1U << part);
mutex_enter(&lofi_lock);
lsp = ddi_get_soft_state(lofi_statep, id);
if (lsp == NULL) {
mutex_exit(&lofi_lock);
return (EINVAL);
}
if (id == 0) {
mutex_exit(&lofi_lock);
return (0);
}
if (lsp->ls_open_excl & mask)
lsp->ls_open_excl &= ~mask;
if (otyp == OTYP_LYR) {
lsp->ls_open_lyr[part]--;
} else {
lsp->ls_open_reg[otyp] &= ~mask;
}
/*
* If we forcibly closed the underlying device (li_force), or
* asked for cleanup (li_cleanup), finish up if we're the last
* out of the door.
*/
if (!is_opened(lsp) && (lsp->ls_cleanup || lsp->ls_vp == NULL)) {
lofi_free_dev(lsp);
lofi_destroy(lsp, credp);
}
mutex_exit(&lofi_lock);
return (0);
}
/*
* Sets the mechanism's initialization vector (IV) if one is needed.
* The IV is computed from the data block number. lsp->ls_mech is
* altered so that:
* lsp->ls_mech.cm_param_len is set to the IV len.
* lsp->ls_mech.cm_param is set to the IV.
*/
static int
lofi_blk_mech(struct lofi_state *lsp, longlong_t lblkno)
{
int ret;
crypto_data_t cdata;
char *iv;
size_t iv_len;
size_t min;
void *data;
size_t datasz;
ASSERT(MUTEX_HELD(&lsp->ls_crypto_lock));
if (lsp == NULL)
return (CRYPTO_DEVICE_ERROR);
/* lsp->ls_mech.cm_param{_len} has already been set for static iv */
if (lsp->ls_iv_type == IVM_NONE) {
return (CRYPTO_SUCCESS);
}
/*
* if kmem already alloced from previous call and it's the same size
* we need now, just recycle it; allocate new kmem only if we have to
*/
if (lsp->ls_mech.cm_param == NULL ||
lsp->ls_mech.cm_param_len != lsp->ls_iv_len) {
iv_len = lsp->ls_iv_len;
iv = kmem_zalloc(iv_len, KM_SLEEP);
} else {
iv_len = lsp->ls_mech.cm_param_len;
iv = lsp->ls_mech.cm_param;
bzero(iv, iv_len);
}
switch (lsp->ls_iv_type) {
case IVM_ENC_BLKNO:
/* iv is not static, lblkno changes each time */
data = &lblkno;
datasz = sizeof (lblkno);
break;
default:
data = 0;
datasz = 0;
break;
}
/*
* write blkno into the iv buffer padded on the left in case
* blkno ever grows bigger than its current longlong_t size
* or a variation other than blkno is used for the iv data
*/
min = MIN(datasz, iv_len);
bcopy(data, iv + (iv_len - min), min);
/* encrypt the data in-place to get the IV */
SETUP_C_DATA(cdata, iv, iv_len);
ret = crypto_encrypt(&lsp->ls_iv_mech, &cdata, &lsp->ls_key,
NULL, NULL, NULL);
if (ret != CRYPTO_SUCCESS) {
cmn_err(CE_WARN, "failed to create iv for block %lld: (0x%x)",
lblkno, ret);
if (lsp->ls_mech.cm_param != iv)
kmem_free(iv, iv_len);
return (ret);
}
/* clean up the iv from the last computation */
if (lsp->ls_mech.cm_param != NULL && lsp->ls_mech.cm_param != iv)
kmem_free(lsp->ls_mech.cm_param, lsp->ls_mech.cm_param_len);
lsp->ls_mech.cm_param_len = iv_len;
lsp->ls_mech.cm_param = iv;
return (CRYPTO_SUCCESS);
}
/*
* Performs encryption and decryption of a chunk of data of size "len",
* one DEV_BSIZE block at a time. "len" is assumed to be a multiple of
* DEV_BSIZE.
*/
static int
lofi_crypto(struct lofi_state *lsp, struct buf *bp, caddr_t plaintext,
caddr_t ciphertext, size_t len, boolean_t op_encrypt)
{
crypto_data_t cdata;
crypto_data_t wdata;
int ret;
longlong_t lblkno = bp->b_lblkno;
mutex_enter(&lsp->ls_crypto_lock);
/*
* though we could encrypt/decrypt entire "len" chunk of data, we need
* to break it into DEV_BSIZE pieces to capture blkno incrementing
*/
SETUP_C_DATA(cdata, plaintext, len);
cdata.cd_length = DEV_BSIZE;
if (ciphertext != NULL) { /* not in-place crypto */
SETUP_C_DATA(wdata, ciphertext, len);
wdata.cd_length = DEV_BSIZE;
}
do {
ret = lofi_blk_mech(lsp, lblkno);
if (ret != CRYPTO_SUCCESS)
continue;
if (op_encrypt) {
ret = crypto_encrypt(&lsp->ls_mech, &cdata,
&lsp->ls_key, NULL,
((ciphertext != NULL) ? &wdata : NULL), NULL);
} else {
ret = crypto_decrypt(&lsp->ls_mech, &cdata,
&lsp->ls_key, NULL,
((ciphertext != NULL) ? &wdata : NULL), NULL);
}
cdata.cd_offset += DEV_BSIZE;
if (ciphertext != NULL)
wdata.cd_offset += DEV_BSIZE;
lblkno++;
} while (ret == CRYPTO_SUCCESS && cdata.cd_offset < len);
mutex_exit(&lsp->ls_crypto_lock);
if (ret != CRYPTO_SUCCESS) {
cmn_err(CE_WARN, "%s failed for block %lld: (0x%x)",
op_encrypt ? "crypto_encrypt()" : "crypto_decrypt()",
lblkno, ret);
}
return (ret);
}
#define RDWR_RAW 1
#define RDWR_BCOPY 2
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)
{
ssize_t resid;
int isread;
int error;
/*
* Handles reads/writes for both plain and encrypted lofi
* Note: offset is already shifted by lsp->ls_crypto_offset
* when it gets here.
*/
isread = bp->b_flags & B_READ;
if (isread) {
if (method == RDWR_BCOPY) {
/* DO NOT update bp->b_resid for bcopy */
bcopy(bcopy_locn, bufaddr, len);
error = 0;
} else { /* RDWR_RAW */
error = vn_rdwr(UIO_READ, lsp->ls_vp, bufaddr, len,
offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred,
&resid);
bp->b_resid = resid;
}
if (lsp->ls_crypto_enabled && error == 0) {
if (lofi_crypto(lsp, bp, bufaddr, NULL, len,
B_FALSE) != CRYPTO_SUCCESS) {
/*
* XXX: original code didn't set residual
* back to len because no error was expected
* from bcopy() if encryption is not enabled
*/
if (method != RDWR_BCOPY)
bp->b_resid = len;
error = EIO;
}
}
return (error);
} else {
void *iobuf = bufaddr;
if (lsp->ls_crypto_enabled) {
/* don't do in-place crypto to keep bufaddr intact */
iobuf = kmem_alloc(len, KM_SLEEP);
if (lofi_crypto(lsp, bp, bufaddr, iobuf, len,
B_TRUE) != CRYPTO_SUCCESS) {
kmem_free(iobuf, len);
if (method != RDWR_BCOPY)
bp->b_resid = len;
return (EIO);
}
}
if (method == RDWR_BCOPY) {
/* DO NOT update bp->b_resid for bcopy */
bcopy(iobuf, bcopy_locn, len);
error = 0;
} else { /* RDWR_RAW */
error = vn_rdwr(UIO_WRITE, lsp->ls_vp, iobuf, len,
offset, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred,
&resid);
bp->b_resid = resid;
}
if (lsp->ls_crypto_enabled) {
kmem_free(iobuf, len);
}
return (error);
}
}
static int
lofi_mapped_rdwr(caddr_t bufaddr, offset_t offset, struct buf *bp,
struct lofi_state *lsp)
{
int error;
offset_t alignedoffset, mapoffset;
size_t xfersize;
int isread;
int smflags;
caddr_t mapaddr;
size_t len;
enum seg_rw srw;
int save_error;
/*
* Note: offset is already shifted by lsp->ls_crypto_offset
* when it gets here.
*/
if (lsp->ls_crypto_enabled)
ASSERT(lsp->ls_vp_comp_size == lsp->ls_vp_size);
/*
* segmap always gives us an 8K (MAXBSIZE) chunk, aligned on
* an 8K boundary, but the buf transfer address may not be
* aligned on more than a 512-byte boundary (we don't enforce
* that even though we could). This matters since the initial
* part of the transfer may not start at offset 0 within the
* segmap'd chunk. So we have to compensate for that with
* 'mapoffset'. Subsequent chunks always start off at the
* beginning, and the last is capped by b_resid
*
* Visually, where "|" represents page map boundaries:
* alignedoffset (mapaddr begins at this segmap boundary)
* | offset (from beginning of file)
* | | len
* v v v
* ===|====X========|====...======|========X====|====
* /-------------...---------------/
* ^ bp->b_bcount/bp->b_resid at start
* /----/--------/----...------/--------/
* ^ ^ ^ ^ ^
* | | | | nth xfersize (<= MAXBSIZE)
* | | 2nd thru n-1st xfersize (= MAXBSIZE)
* | 1st xfersize (<= MAXBSIZE)
* mapoffset (offset into 1st segmap, non-0 1st time, 0 thereafter)
*
* Notes: "alignedoffset" is "offset" rounded down to nearest
* MAXBSIZE boundary. "len" is next page boundary of size
* PAGESIZE after "alignedoffset".
*/
mapoffset = offset & MAXBOFFSET;
alignedoffset = offset - mapoffset;
bp->b_resid = bp->b_bcount;
isread = bp->b_flags & B_READ;
srw = isread ? S_READ : S_WRITE;
do {
xfersize = MIN(lsp->ls_vp_comp_size - offset,
MIN(MAXBSIZE - mapoffset, bp->b_resid));
len = roundup(mapoffset + xfersize, PAGESIZE);
mapaddr = segmap_getmapflt(segkmap, lsp->ls_vp,
alignedoffset, MAXBSIZE, 1, srw);
/*
* Now fault in the pages. This lets us check
* for errors before we reference mapaddr and
* try to resolve the fault in bcopy (which would
* panic instead). And this can easily happen,
* particularly if you've lofi'd a file over NFS
* and someone deletes the file on the server.
*/
error = segmap_fault(kas.a_hat, segkmap, mapaddr,
len, F_SOFTLOCK, srw);
if (error) {
(void) segmap_release(segkmap, mapaddr, 0);
if (FC_CODE(error) == FC_OBJERR)
error = FC_ERRNO(error);
else
error = EIO;
break;
}
/* error may be non-zero for encrypted lofi */
error = lofi_rdwr(bufaddr, 0, bp, lsp, xfersize,
RDWR_BCOPY, mapaddr + mapoffset);
if (error == 0) {
bp->b_resid -= xfersize;
bufaddr += xfersize;
offset += xfersize;
}
smflags = 0;
if (isread) {
smflags |= SM_FREE;
/*
* If we're reading an entire page starting
* at a page boundary, there's a good chance
* we won't need it again. Put it on the
* head of the freelist.
*/
if (mapoffset == 0 && xfersize == MAXBSIZE)
smflags |= SM_DONTNEED;
} else {
/*
* Write back good pages, it is okay to
* always release asynchronous here as we'll
* follow with VOP_FSYNC for B_SYNC buffers.
*/
if (error == 0)
smflags |= SM_WRITE | SM_ASYNC;
}
(void) segmap_fault(kas.a_hat, segkmap, mapaddr,
len, F_SOFTUNLOCK, srw);
save_error = segmap_release(segkmap, mapaddr, smflags);
if (error == 0)
error = save_error;
/* only the first map may start partial */
mapoffset = 0;
alignedoffset += MAXBSIZE;
} while ((error == 0) && (bp->b_resid > 0) &&
(offset < lsp->ls_vp_comp_size));
return (error);
}
/*
* Check if segment seg_index is present in the decompressed segment
* data cache.
*
* Returns a pointer to the decompressed segment data cache entry if
* found, and NULL when decompressed data for this segment is not yet
* cached.
*/
static struct lofi_comp_cache *
lofi_find_comp_data(struct lofi_state *lsp, uint64_t seg_index)
{
struct lofi_comp_cache *lc;
ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
for (lc = list_head(&lsp->ls_comp_cache); lc != NULL;
lc = list_next(&lsp->ls_comp_cache, lc)) {
if (lc->lc_index == seg_index) {
/*
* Decompressed segment data was found in the
* cache.
*
* The cache uses an LRU replacement strategy;
* move the entry to head of list.
*/
list_remove(&lsp->ls_comp_cache, lc);
list_insert_head(&lsp->ls_comp_cache, lc);
return (lc);
}
}
return (NULL);
}
/*
* Add the data for a decompressed segment at segment index
* seg_index to the cache of the decompressed segments.
*
* Returns a pointer to the cache element structure in case
* the data was added to the cache; returns NULL when the data
* wasn't cached.
*/
static struct lofi_comp_cache *
lofi_add_comp_data(struct lofi_state *lsp, uint64_t seg_index,
uchar_t *data)
{
struct lofi_comp_cache *lc;
ASSERT(MUTEX_HELD(&lsp->ls_comp_cache_lock));
while (lsp->ls_comp_cache_count > lofi_max_comp_cache) {
lc = list_remove_tail(&lsp->ls_comp_cache);
ASSERT(lc != NULL);
kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
kmem_free(lc, sizeof (struct lofi_comp_cache));
lsp->ls_comp_cache_count--;
}
/*
* Do not cache when disabled by tunable variable
*/
if (lofi_max_comp_cache == 0)
return (NULL);
/*
* When the cache has not yet reached the maximum allowed
* number of segments, allocate a new cache element.
* Otherwise the cache is full; reuse the last list element
* (LRU) for caching the decompressed segment data.
*
* The cache element for the new decompressed segment data is
* added to the head of the list.
*/
if (lsp->ls_comp_cache_count < lofi_max_comp_cache) {
lc = kmem_alloc(sizeof (struct lofi_comp_cache), KM_SLEEP);
lc->lc_data = NULL;
list_insert_head(&lsp->ls_comp_cache, lc);
lsp->ls_comp_cache_count++;
} else {
lc = list_remove_tail(&lsp->ls_comp_cache);
if (lc == NULL)
return (NULL);
list_insert_head(&lsp->ls_comp_cache, lc);
}
/*
* Free old uncompressed segment data when reusing a cache
* entry.
*/
if (lc->lc_data != NULL)
kmem_free(lc->lc_data, lsp->ls_uncomp_seg_sz);
lc->lc_data = data;
lc->lc_index = seg_index;
return (lc);
}
/*ARGSUSED*/
static int
gzip_decompress(void *src, size_t srclen, void *dst,
size_t *dstlen, int level)
{
ASSERT(*dstlen >= srclen);
if (z_uncompress(dst, dstlen, src, srclen) != Z_OK)
return (-1);
return (0);
}
#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8)
/*ARGSUSED*/
static int
lzma_decompress(void *src, size_t srclen, void *dst,
size_t *dstlen, int level)
{
size_t insizepure;
void *actual_src;
ELzmaStatus status;
insizepure = srclen - LZMA_HEADER_SIZE;
actual_src = (void *)((Byte *)src + LZMA_HEADER_SIZE);
if (LzmaDecode((Byte *)dst, (size_t *)dstlen,
(const Byte *)actual_src, &insizepure,
(const Byte *)src, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status,
&g_Alloc) != SZ_OK) {
return (-1);
}
return (0);
}
/*
* This is basically what strategy used to be before we found we
* needed task queues.
*/
static void
lofi_strategy_task(void *arg)
{
struct buf *bp = (struct buf *)arg;
int error;
int syncflag = 0;
struct lofi_state *lsp;
offset_t offset;
caddr_t bufaddr;
size_t len;
size_t xfersize;
boolean_t bufinited = B_FALSE;
lsp = ddi_get_soft_state(lofi_statep,
LOFI_MINOR2ID(getminor(bp->b_edev)));
if (lsp == NULL) {
error = ENXIO;
goto errout;
}
if (lsp->ls_kstat) {
mutex_enter(lsp->ls_kstat->ks_lock);
kstat_waitq_to_runq(KSTAT_IO_PTR(lsp->ls_kstat));
mutex_exit(lsp->ls_kstat->ks_lock);
}
mutex_enter(&lsp->ls_vp_lock);
lsp->ls_vp_iocount++;
mutex_exit(&lsp->ls_vp_lock);
bp_mapin(bp);
bufaddr = bp->b_un.b_addr;
offset = (bp->b_lblkno + (diskaddr_t)(uintptr_t)bp->b_private)
<< lsp->ls_lbshift; /* offset within file */
if (lsp->ls_crypto_enabled) {
/* encrypted data really begins after crypto header */
offset += lsp->ls_crypto_offset;
}
len = bp->b_bcount;
bufinited = B_TRUE;
if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
error = EIO;
goto errout;
}
/*
* If we're writing and the buffer was not B_ASYNC
* we'll follow up with a VOP_FSYNC() to force any
* asynchronous I/O to stable storage.
*/
if (!(bp->b_flags & B_READ) && !(bp->b_flags & B_ASYNC))
syncflag = FSYNC;
/*
* We used to always use vn_rdwr here, but we cannot do that because
* we might decide to read or write from the the underlying
* file during this call, which would be a deadlock because
* we have the rw_lock. So instead we page, unless it's not
* mapable or it's a character device or it's an encrypted lofi.
*/
if ((lsp->ls_vp->v_flag & VNOMAP) || (lsp->ls_vp->v_type == VCHR) ||
lsp->ls_crypto_enabled) {
error = lofi_rdwr(bufaddr, offset, bp, lsp, len, RDWR_RAW,
NULL);
} else if (lsp->ls_uncomp_seg_sz == 0) {
error = lofi_mapped_rdwr(bufaddr, offset, bp, lsp);
} else {
uchar_t *compressed_seg = NULL, *cmpbuf;
uchar_t *uncompressed_seg = NULL;
lofi_compress_info_t *li;
size_t oblkcount;
ulong_t seglen;
uint64_t sblkno, eblkno, cmpbytes;
uint64_t uncompressed_seg_index;
struct lofi_comp_cache *lc;
offset_t sblkoff, eblkoff;
u_offset_t salign, ealign;
u_offset_t sdiff;
uint32_t comp_data_sz;
uint64_t i;
int j;
/*
* From here on we're dealing primarily with compressed files
*/
ASSERT(!lsp->ls_crypto_enabled);
/*
* Compressed files can only be read from and
* not written to
*/
if (!(bp->b_flags & B_READ)) {
bp->b_resid = bp->b_bcount;
error = EROFS;
goto done;
}
ASSERT(lsp->ls_comp_algorithm_index >= 0);
li = &lofi_compress_table[lsp->ls_comp_algorithm_index];
/*
* Compute starting and ending compressed segment numbers
* We use only bitwise operations avoiding division and
* modulus because we enforce the compression segment size
* to a power of 2
*/
sblkno = offset >> lsp->ls_comp_seg_shift;
sblkoff = offset & (lsp->ls_uncomp_seg_sz - 1);
eblkno = (offset + bp->b_bcount) >> lsp->ls_comp_seg_shift;
eblkoff = (offset + bp->b_bcount) & (lsp->ls_uncomp_seg_sz - 1);
/*
* Check the decompressed segment cache.
*
* The cache is used only when the requested data
* is within a segment. Requests that cross
* segment boundaries bypass the cache.
*/
if (sblkno == eblkno ||
(sblkno + 1 == eblkno && eblkoff == 0)) {
/*
* Request doesn't cross a segment boundary,
* now check the cache.
*/
mutex_enter(&lsp->ls_comp_cache_lock);
lc = lofi_find_comp_data(lsp, sblkno);
if (lc != NULL) {
/*
* We've found the decompressed segment
* data in the cache; reuse it.
*/
bcopy(lc->lc_data + sblkoff, bufaddr,
bp->b_bcount);
mutex_exit(&lsp->ls_comp_cache_lock);
bp->b_resid = 0;
error = 0;
goto done;
}
mutex_exit(&lsp->ls_comp_cache_lock);
}
/*
* Align start offset to block boundary for segmap
*/
salign = lsp->ls_comp_seg_index[sblkno];
sdiff = salign & (DEV_BSIZE - 1);
salign -= sdiff;
if (eblkno >= (lsp->ls_comp_index_sz - 1)) {
/*
* We're dealing with the last segment of
* the compressed file -- the size of this
* segment *may not* be the same as the
* segment size for the file
*/
eblkoff = (offset + bp->b_bcount) &
(lsp->ls_uncomp_last_seg_sz - 1);
ealign = lsp->ls_vp_comp_size;
} else {
ealign = lsp->ls_comp_seg_index[eblkno + 1];
}
/*
* Preserve original request paramaters
*/
oblkcount = bp->b_bcount;
/*
* Assign the calculated parameters
*/
comp_data_sz = ealign - salign;
bp->b_bcount = comp_data_sz;
/*
* Buffers to hold compressed segments are pre-allocated
* on a per-thread basis. Find a pre-allocated buffer
* that is not currently in use and mark it for use.
*/
mutex_enter(&lsp->ls_comp_bufs_lock);
for (j = 0; j < lofi_taskq_nthreads; j++) {
if (lsp->ls_comp_bufs[j].inuse == 0) {
lsp->ls_comp_bufs[j].inuse = 1;
break;
}
}
mutex_exit(&lsp->ls_comp_bufs_lock);
ASSERT(j < lofi_taskq_nthreads);
/*
* If the pre-allocated buffer size does not match
* the size of the I/O request, re-allocate it with
* the appropriate size
*/
if (lsp->ls_comp_bufs[j].bufsize < bp->b_bcount) {
if (lsp->ls_comp_bufs[j].bufsize > 0)
kmem_free(lsp->ls_comp_bufs[j].buf,
lsp->ls_comp_bufs[j].bufsize);
lsp->ls_comp_bufs[j].buf = kmem_alloc(bp->b_bcount,
KM_SLEEP);
lsp->ls_comp_bufs[j].bufsize = bp->b_bcount;
}
compressed_seg = lsp->ls_comp_bufs[j].buf;
/*
* Map in the calculated number of blocks
*/
error = lofi_mapped_rdwr((caddr_t)compressed_seg, salign,
bp, lsp);
bp->b_bcount = oblkcount;
bp->b_resid = oblkcount;
if (error != 0)
goto done;
/*
* decompress compressed blocks start
*/
cmpbuf = compressed_seg + sdiff;
for (i = sblkno; i <= eblkno; i++) {
ASSERT(i < lsp->ls_comp_index_sz - 1);
uchar_t *useg;
/*
* The last segment is special in that it is
* most likely not going to be the same
* (uncompressed) size as the other segments.
*/
if (i == (lsp->ls_comp_index_sz - 2)) {
seglen = lsp->ls_uncomp_last_seg_sz;
} else {
seglen = lsp->ls_uncomp_seg_sz;
}
/*
* Each of the segment index entries contains
* the starting block number for that segment.
* The number of compressed bytes in a segment
* is thus the difference between the starting
* block number of this segment and the starting
* block number of the next segment.
*/
cmpbytes = lsp->ls_comp_seg_index[i + 1] -
lsp->ls_comp_seg_index[i];
/*
* The first byte in a compressed segment is a flag
* that indicates whether this segment is compressed
* at all.
*
* The variable 'useg' is used (instead of
* uncompressed_seg) in this loop to keep a
* reference to the uncompressed segment.
*
* N.B. If 'useg' is replaced with uncompressed_seg,
* it leads to memory leaks and heap corruption in
* corner cases where compressed segments lie
* adjacent to uncompressed segments.
*/
if (*cmpbuf == UNCOMPRESSED) {
useg = cmpbuf + SEGHDR;
} else {
if (uncompressed_seg == NULL)
uncompressed_seg =
kmem_alloc(lsp->ls_uncomp_seg_sz,
KM_SLEEP);
useg = uncompressed_seg;
uncompressed_seg_index = i;
if (li->l_decompress((cmpbuf + SEGHDR),
(cmpbytes - SEGHDR), uncompressed_seg,
&seglen, li->l_level) != 0) {
error = EIO;
goto done;
}
}
/*
* Determine how much uncompressed data we
* have to copy and copy it
*/
xfersize = lsp->ls_uncomp_seg_sz - sblkoff;
if (i == eblkno)
xfersize -= (lsp->ls_uncomp_seg_sz - eblkoff);
bcopy((useg + sblkoff), bufaddr, xfersize);
cmpbuf += cmpbytes;
bufaddr += xfersize;
bp->b_resid -= xfersize;
sblkoff = 0;
if (bp->b_resid == 0)
break;
} /* decompress compressed blocks ends */
/*
* Skip to done if there is no uncompressed data to cache
*/
if (uncompressed_seg == NULL)
goto done;
/*
* Add the data for the last decompressed segment to
* the cache.
*
* In case the uncompressed segment data was added to (and
* is referenced by) the cache, make sure we don't free it
* here.
*/
mutex_enter(&lsp->ls_comp_cache_lock);
if ((lc = lofi_add_comp_data(lsp, uncompressed_seg_index,
uncompressed_seg)) != NULL) {
uncompressed_seg = NULL;
}
mutex_exit(&lsp->ls_comp_cache_lock);
done:
if (compressed_seg != NULL) {
mutex_enter(&lsp->ls_comp_bufs_lock);
lsp->ls_comp_bufs[j].inuse = 0;
mutex_exit(&lsp->ls_comp_bufs_lock);
}
if (uncompressed_seg != NULL)
kmem_free(uncompressed_seg, lsp->ls_uncomp_seg_sz);
} /* end of handling compressed files */
if ((error == 0) && (syncflag != 0))
error = VOP_FSYNC(lsp->ls_vp, syncflag, kcred, NULL);
errout:
if (bufinited && lsp->ls_kstat) {
size_t n_done = bp->b_bcount - bp->b_resid;
kstat_io_t *kioptr;
mutex_enter(lsp->ls_kstat->ks_lock);
kioptr = KSTAT_IO_PTR(lsp->ls_kstat);
if (bp->b_flags & B_READ) {
kioptr->nread += n_done;
kioptr->reads++;
} else {
kioptr->nwritten += n_done;
kioptr->writes++;
}
kstat_runq_exit(kioptr);
mutex_exit(lsp->ls_kstat->ks_lock);
}
mutex_enter(&lsp->ls_vp_lock);
if (--lsp->ls_vp_iocount == 0)
cv_broadcast(&lsp->ls_vp_cv);
mutex_exit(&lsp->ls_vp_lock);
bioerror(bp, error);
biodone(bp);
}
static int
lofi_strategy(struct buf *bp)
{
struct lofi_state *lsp;
offset_t offset;
minor_t part;
diskaddr_t p_lba;
diskaddr_t p_nblks;
int shift;
/*
* We cannot just do I/O here, because the current thread
* _might_ end up back in here because the underlying filesystem
* wants a buffer, which eventually gets into bio_recycle and
* might call into lofi to write out a delayed-write buffer.
* This is bad if the filesystem above lofi is the same as below.
*
* We could come up with a complex strategy using threads to
* do the I/O asynchronously, or we could use task queues. task
* queues were incredibly easy so they win.
*/
lsp = ddi_get_soft_state(lofi_statep,
LOFI_MINOR2ID(getminor(bp->b_edev)));
part = LOFI_PART(getminor(bp->b_edev));
if (lsp == NULL) {
bioerror(bp, ENXIO);
biodone(bp);
return (0);
}
shift = lsp->ls_lbshift;
p_lba = 0;
p_nblks = lsp->ls_vp_size >> shift;
if (lsp->ls_cmlbhandle != NULL) {
if (cmlb_partinfo(lsp->ls_cmlbhandle, part, &p_nblks, &p_lba,
NULL, NULL, 0)) {
bioerror(bp, ENXIO);
biodone(bp);
return (0);
}
}
/* start block past partition end? */
if (bp->b_lblkno > p_nblks) {
bioerror(bp, ENXIO);
biodone(bp);
return (0);
}
offset = (bp->b_lblkno+p_lba) << shift; /* offset within file */
mutex_enter(&lsp->ls_vp_lock);
if (lsp->ls_vp == NULL || lsp->ls_vp_closereq) {
bioerror(bp, EIO);
biodone(bp);
mutex_exit(&lsp->ls_vp_lock);
return (0);
}
if (lsp->ls_crypto_enabled) {
/* encrypted data really begins after crypto header */
offset += lsp->ls_crypto_offset;
}
/* make sure we will not pass the file or partition size */
if (offset == lsp->ls_vp_size ||
offset == (((p_lba + p_nblks) << shift) + lsp->ls_crypto_offset)) {
/* EOF */
if ((bp->b_flags & B_READ) != 0) {
bp->b_resid = bp->b_bcount;
bioerror(bp, 0);
} else {
/* writes should fail */
bioerror(bp, ENXIO);
}
biodone(bp);
mutex_exit(&lsp->ls_vp_lock);
return (0);
}
if ((offset > lsp->ls_vp_size) ||
(offset > (((p_lba + p_nblks) << shift) + lsp->ls_crypto_offset)) ||
((offset + bp->b_bcount) > ((p_lba + p_nblks) << shift))) {
bioerror(bp, ENXIO);
biodone(bp);
mutex_exit(&lsp->ls_vp_lock);
return (0);
}
mutex_exit(&lsp->ls_vp_lock);
if (lsp->ls_kstat) {
mutex_enter(lsp->ls_kstat->ks_lock);
kstat_waitq_enter(KSTAT_IO_PTR(lsp->ls_kstat));
mutex_exit(lsp->ls_kstat->ks_lock);
}
bp->b_private = (void *)(uintptr_t)p_lba; /* partition start */
(void) taskq_dispatch(lsp->ls_taskq, lofi_strategy_task, bp, KM_SLEEP);
return (0);
}
/*ARGSUSED2*/
static int
lofi_read(dev_t dev, struct uio *uio, struct cred *credp)
{
if (getminor(dev) == 0)
return (EINVAL);
UIO_CHECK(uio);
return (physio(lofi_strategy, NULL, dev, B_READ, minphys, uio));
}
/*ARGSUSED2*/
static int
lofi_write(dev_t dev, struct uio *uio, struct cred *credp)
{
if (getminor(dev) == 0)
return (EINVAL);
UIO_CHECK(uio);
return (physio(lofi_strategy, NULL, dev, B_WRITE, minphys, uio));
}
/*ARGSUSED2*/
static int
lofi_aread(dev_t dev, struct aio_req *aio, struct cred *credp)
{
if (getminor(dev) == 0)
return (EINVAL);
UIO_CHECK(aio->aio_uio);
return (aphysio(lofi_strategy, anocancel, dev, B_READ, minphys, aio));
}
/*ARGSUSED2*/
static int
lofi_awrite(dev_t dev, struct aio_req *aio, struct cred *credp)
{
if (getminor(dev) == 0)
return (EINVAL);
UIO_CHECK(aio->aio_uio);
return (aphysio(lofi_strategy, anocancel, dev, B_WRITE, minphys, aio));
}
/*ARGSUSED*/
static int
lofi_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
struct lofi_state *lsp;
dev_t dev = (dev_t)arg;
int instance;
instance = LOFI_MINOR2ID(getminor(dev));
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
lsp = ddi_get_soft_state(lofi_statep, instance);
if (lsp == NULL)
return (DDI_FAILURE);
*result = lsp->ls_dip;
return (DDI_SUCCESS);
case DDI_INFO_DEVT2INSTANCE:
*result = (void *) (intptr_t)instance;
return (DDI_SUCCESS);
}
return (DDI_FAILURE);
}
static int
lofi_create_minor_nodes(struct lofi_state *lsp, boolean_t labeled)
{
int error = 0;
int instance = ddi_get_instance(lsp->ls_dip);
if (labeled == B_TRUE) {
cmlb_alloc_handle(&lsp->ls_cmlbhandle);
error = cmlb_attach(lsp->ls_dip, &lofi_tg_ops, DTYPE_DIRECT,
B_FALSE, B_FALSE, DDI_NT_BLOCK_CHAN,
CMLB_CREATE_P0_MINOR_NODE, lsp->ls_cmlbhandle, (void *)1);
if (error != DDI_SUCCESS) {
cmlb_free_handle(&lsp->ls_cmlbhandle);
lsp->ls_cmlbhandle = NULL;
error = ENXIO;
}
} else {
/* create minor nodes */
error = ddi_create_minor_node(lsp->ls_dip, LOFI_BLOCK_NODE,
S_IFBLK, LOFI_ID2MINOR(instance), DDI_PSEUDO, 0);
if (error == DDI_SUCCESS) {
error = ddi_create_minor_node(lsp->ls_dip,
LOFI_CHAR_NODE, S_IFCHR, LOFI_ID2MINOR(instance),
DDI_PSEUDO, 0);
if (error != DDI_SUCCESS) {
ddi_remove_minor_node(lsp->ls_dip,
LOFI_BLOCK_NODE);
error = ENXIO;
}
} else
error = ENXIO;
}
return (error);
}
static int
lofi_zone_bind(struct lofi_state *lsp)
{
int error = 0;
mutex_enter(&curproc->p_lock);
if ((error = rctl_incr_lofi(curproc, curproc->p_zone, 1)) != 0) {
mutex_exit(&curproc->p_lock);
return (error);
}
mutex_exit(&curproc->p_lock);
if (ddi_prop_update_string(lsp->ls_dev, lsp->ls_dip, ZONE_PROP_NAME,
(char *)curproc->p_zone->zone_name) != DDI_PROP_SUCCESS) {
rctl_decr_lofi(curproc->p_zone, 1);
error = EINVAL;
} else {
zone_init_ref(&lsp->ls_zone);
zone_hold_ref(curzone, &lsp->ls_zone, ZONE_REF_LOFI);
}
return (error);
}
static void
lofi_zone_unbind(struct lofi_state *lsp)
{
(void) ddi_prop_remove(DDI_DEV_T_NONE, lsp->ls_dip, ZONE_PROP_NAME);
rctl_decr_lofi(curproc->p_zone, 1);
zone_rele_ref(&lsp->ls_zone, ZONE_REF_LOFI);
}
static int
lofi_online_dev(dev_info_t *dip)
{
boolean_t labeled;
int error;
int instance = ddi_get_instance(dip);
struct lofi_state *lsp;
labeled = B_FALSE;
if (ddi_prop_exists(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, "labeled"))
labeled = B_TRUE;
/* lsp alloc+init, soft state is freed in lofi_detach */
error = ddi_soft_state_zalloc(lofi_statep, instance);
if (error == DDI_FAILURE) {
return (ENOMEM);
}
lsp = ddi_get_soft_state(lofi_statep, instance);
lsp->ls_dip = dip;
if ((error = lofi_zone_bind(lsp)) != 0)
goto err;
cv_init(&lsp->ls_vp_cv, NULL, CV_DRIVER, NULL);
mutex_init(&lsp->ls_comp_cache_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&lsp->ls_comp_bufs_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&lsp->ls_kstat_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&lsp->ls_vp_lock, NULL, MUTEX_DRIVER, NULL);
if ((error = lofi_create_minor_nodes(lsp, labeled)) != 0) {
lofi_zone_unbind(lsp);
goto lerr;
}
/* driver handles kernel-issued IOCTLs */
if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
DDI_KERNEL_IOCTL, NULL, 0) != DDI_PROP_SUCCESS) {
error = DDI_FAILURE;
goto merr;
}
lsp->ls_kstat = kstat_create_zone(LOFI_DRIVER_NAME, instance,
NULL, "disk", KSTAT_TYPE_IO, 1, 0, getzoneid());
if (lsp->ls_kstat == NULL) {
(void) ddi_prop_remove(DDI_DEV_T_NONE, lsp->ls_dip,
DDI_KERNEL_IOCTL);
error = ENOMEM;
goto merr;
}
lsp->ls_kstat->ks_lock = &lsp->ls_kstat_lock;
kstat_zone_add(lsp->ls_kstat, GLOBAL_ZONEID);
kstat_install(lsp->ls_kstat);
return (DDI_SUCCESS);
merr:
if (lsp->ls_cmlbhandle != NULL) {
cmlb_detach(lsp->ls_cmlbhandle, 0);
cmlb_free_handle(&lsp->ls_cmlbhandle);
}
ddi_remove_minor_node(dip, NULL);
lofi_zone_unbind(lsp);
lerr:
mutex_destroy(&lsp->ls_comp_cache_lock);
mutex_destroy(&lsp->ls_comp_bufs_lock);
mutex_destroy(&lsp->ls_kstat_lock);
mutex_destroy(&lsp->ls_vp_lock);
cv_destroy(&lsp->ls_vp_cv);
err:
ddi_soft_state_free(lofi_statep, instance);
return (error);
}
/*ARGSUSED*/
static int
lofi_dev_callback(sysevent_t *ev, void *cookie)
{
nvlist_t *nvlist;
char *class, *driver;
char name[10];
int32_t instance;
class = sysevent_get_class_name(ev);
if (strcmp(class, EC_DEV_ADD) && strcmp(class, EC_DEV_REMOVE))
return (0);
(void) sysevent_get_attr_list(ev, &nvlist);
driver = fnvlist_lookup_string(nvlist, DEV_DRIVER_NAME);
instance = fnvlist_lookup_int32(nvlist, DEV_INSTANCE);
if (strcmp(driver, LOFI_DRIVER_NAME) != 0) {
fnvlist_free(nvlist);
return (0);
}
/*
* insert or remove device info, then announce the change
* via cv_broadcast.
* This allows the MAP/UNMAP to monitor device change.
*/
(void) snprintf(name, sizeof (name), "%d", instance);
if (strcmp(class, EC_DEV_ADD) == 0) {
mutex_enter(&lofi_chan_lock);
fnvlist_add_nvlist(lofi_devlink_cache, name, nvlist);
cv_broadcast(&lofi_chan_cv);
mutex_exit(&lofi_chan_lock);
} else if (strcmp(class, EC_DEV_REMOVE) == 0) {
mutex_enter(&lofi_chan_lock);
/* Can not use fnvlist_remove() as we can get ENOENT. */
(void) nvlist_remove_all(lofi_devlink_cache, name);
cv_broadcast(&lofi_chan_cv);
mutex_exit(&lofi_chan_lock);
}
fnvlist_free(nvlist);
return (0);
}
static int
lofi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int rv;
int instance = ddi_get_instance(dip);
struct lofi_state *lsp;
if (cmd != DDI_ATTACH)
return (DDI_FAILURE);
/*
* Instance 0 is control instance, attaching control instance
* will set the lofi up and ready.
*/
if (instance == 0) {
rv = ddi_soft_state_zalloc(lofi_statep, 0);
if (rv == DDI_FAILURE) {
return (DDI_FAILURE);
}
lsp = ddi_get_soft_state(lofi_statep, instance);
rv = ddi_create_minor_node(dip, LOFI_CTL_NODE, S_IFCHR, 0,
DDI_PSEUDO, 0);
if (rv == DDI_FAILURE) {
ddi_soft_state_free(lofi_statep, 0);
return (DDI_FAILURE);
}
/* driver handles kernel-issued IOCTLs */
if (ddi_prop_create(DDI_DEV_T_NONE, dip, DDI_PROP_CANSLEEP,
DDI_KERNEL_IOCTL, NULL, 0) != DDI_PROP_SUCCESS) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(lofi_statep, 0);
return (DDI_FAILURE);
}
rv = sysevent_evc_bind(DEVFS_CHANNEL, &lofi_chan,
EVCH_CREAT | EVCH_HOLD_PEND);
if (rv == 0) {
rv = sysevent_evc_subscribe(lofi_chan, "lofi",
EC_ALL, lofi_dev_callback, NULL, 0);
rv |= sysevent_evc_subscribe(lofi_chan, "disk",
EC_ALL, lofi_dev_callback, NULL, 0);
} else
lofi_chan = NULL;
if (rv != 0) {
if (lofi_chan != NULL)
(void) sysevent_evc_unbind(lofi_chan);
ddi_prop_remove_all(dip);
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(lofi_statep, 0);
return (DDI_FAILURE);
}
zone_key_create(&lofi_zone_key, NULL, lofi_zone_shutdown, NULL);
lsp->ls_dip = dip;
} else {
if (lofi_online_dev(dip) == DDI_FAILURE)
return (DDI_FAILURE);
}
ddi_report_dev(dip);
return (DDI_SUCCESS);
}
static int
lofi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
struct lofi_state *lsp;
int instance = ddi_get_instance(dip);
if (cmd != DDI_DETACH)
return (DDI_FAILURE);
/*
* If the instance is not 0, release state.
* The instance 0 is control device, we can not detach it
* before other instances are detached.
*/
if (instance != 0) {
lsp = ddi_get_soft_state(lofi_statep, instance);
if (lsp != NULL && lsp->ls_vp_ready == B_FALSE) {
ddi_soft_state_free(lofi_statep, instance);
return (DDI_SUCCESS);
} else
return (DDI_FAILURE);
}
mutex_enter(&lofi_lock);
if (!list_is_empty(&lofi_list)) {
mutex_exit(&lofi_lock);
return (DDI_FAILURE);
}
ddi_remove_minor_node(dip, NULL);
ddi_prop_remove_all(dip);
mutex_exit(&lofi_lock);
(void) sysevent_evc_unbind(lofi_chan);
if (zone_key_delete(lofi_zone_key) != 0)
cmn_err(CE_WARN, "failed to delete zone key");
ddi_soft_state_free(lofi_statep, 0);
return (DDI_SUCCESS);
}
/*
* With the addition of encryption, we must be careful that encryption key is
* wiped before kernel's data structures are freed so it cannot accidentally
* slip out to userland through uninitialized data elsewhere.
*/
static void
free_lofi_ioctl(struct lofi_ioctl *klip)
{
/* Make sure this encryption key doesn't stick around */
bzero(klip->li_key, sizeof (klip->li_key));
kmem_free(klip, sizeof (struct lofi_ioctl));
}
/*
* These two functions simplify the rest of the ioctls that need to copyin/out
* the lofi_ioctl structure.
*/
int
copy_in_lofi_ioctl(const struct lofi_ioctl *ulip, struct lofi_ioctl **klipp,
int flag)
{
struct lofi_ioctl *klip;
int error;
klip = *klipp = kmem_alloc(sizeof (struct lofi_ioctl), KM_SLEEP);
error = ddi_copyin(ulip, klip, sizeof (struct lofi_ioctl), flag);
if (error)
goto err;
/* ensure NULL termination */
klip->li_filename[MAXPATHLEN-1] = '\0';
klip->li_devpath[MAXPATHLEN-1] = '\0';
klip->li_algorithm[MAXALGLEN-1] = '\0';
klip->li_cipher[CRYPTO_MAX_MECH_NAME-1] = '\0';
klip->li_iv_cipher[CRYPTO_MAX_MECH_NAME-1] = '\0';
if (klip->li_id > L_MAXMIN32) {
error = EINVAL;
goto err;
}
return (0);
err:
free_lofi_ioctl(klip);
return (error);
}
int
copy_out_lofi_ioctl(const struct lofi_ioctl *klip, struct lofi_ioctl *ulip,
int flag)
{
int error;
/*
* NOTE: Do NOT copy the crypto_key_t "back" to userland.
* This ensures that an attacker can't trivially find the
* key for a mapping just by issuing the ioctl.
*
* It can still be found by poking around in kmem with mdb(1),
* but there is no point in making it easy when the info isn't
* of any use in this direction anyway.
*
* Either way we don't actually have the raw key stored in
* a form that we can get it anyway, since we just used it
* to create a ctx template and didn't keep "the original".
*/
error = ddi_copyout(klip, ulip, sizeof (struct lofi_ioctl), flag);
if (error)
return (EFAULT);
return (0);
}
static int
lofi_access(struct lofi_state *lsp)
{
ASSERT(MUTEX_HELD(&lofi_lock));
if (INGLOBALZONE(curproc) || lsp->ls_zone.zref_zone == curzone)
return (0);
return (EPERM);
}
/*
* Find the lofi state for the given filename. We compare by vnode to
* allow the global zone visibility into NGZ lofi nodes.
*/
static int
file_to_lofi_nocheck(char *filename, boolean_t readonly,
struct lofi_state **lspp)
{
struct lofi_state *lsp;
vnode_t *vp = NULL;
int err = 0;
int rdfiles = 0;
ASSERT(MUTEX_HELD(&lofi_lock));
if ((err = lookupname(filename, UIO_SYSSPACE, FOLLOW,
NULLVPP, &vp)) != 0)
goto out;
if (vp->v_type == VREG) {
vnode_t *realvp;
if (VOP_REALVP(vp, &realvp, NULL) == 0) {
VN_HOLD(realvp);
VN_RELE(vp);
vp = realvp;
}
}
for (lsp = list_head(&lofi_list); lsp != NULL;
lsp = list_next(&lofi_list, lsp)) {
if (lsp->ls_vp == vp) {
if (lspp != NULL)
*lspp = lsp;
if (lsp->ls_readonly) {
rdfiles++;
/* Skip if '-r' is specified */
if (readonly)
continue;
}
goto out;
}
}
err = ENOENT;
/*
* If a filename is given as an argument for lofi_unmap, we shouldn't
* allow unmap if there are multiple read-only lofi devices associated
* with this file.
*/
if (lspp != NULL) {
if (rdfiles == 1)
err = 0;
else if (rdfiles > 1)
err = EBUSY;
}
out:
if (vp != NULL)
VN_RELE(vp);
return (err);
}
/*
* Find the minor for the given filename, checking the zone can access
* it.
*/
static int
file_to_lofi(char *filename, boolean_t readonly, struct lofi_state **lspp)
{
int err = 0;
ASSERT(MUTEX_HELD(&lofi_lock));
if ((err = file_to_lofi_nocheck(filename, readonly, lspp)) != 0)
return (err);
if ((err = lofi_access(*lspp)) != 0)
return (err);
return (0);
}
/*
* Fakes up a disk geometry based on the size of the file. This is needed
* to support newfs on traditional lofi device, but also will provide
* geometry hint for cmlb.
*/
static void
fake_disk_geometry(struct lofi_state *lsp)
{
u_offset_t dsize = lsp->ls_vp_size - lsp->ls_crypto_offset;
/* dk_geom - see dkio(7I) */
/*
* dkg_ncyl _could_ be set to one here (one big cylinder with gobs
* of sectors), but that breaks programs like fdisk which want to
* partition a disk by cylinder. With one cylinder, you can't create
* an fdisk partition and put pcfs on it for testing (hard to pick
* a number between one and one).
*
* The cheezy floppy test is an attempt to not have too few cylinders
* for a small file, or so many on a big file that you waste space
* for backup superblocks or cylinder group structures.
*/
bzero(&lsp->ls_dkg, sizeof (lsp->ls_dkg));
if (dsize < (2 * 1024 * 1024)) /* floppy? */
lsp->ls_dkg.dkg_ncyl = dsize / (100 * 1024);
else
lsp->ls_dkg.dkg_ncyl = dsize / (300 * 1024);
/* in case file file is < 100k */
if (lsp->ls_dkg.dkg_ncyl == 0)
lsp->ls_dkg.dkg_ncyl = 1;
lsp->ls_dkg.dkg_pcyl = lsp->ls_dkg.dkg_ncyl;
lsp->ls_dkg.dkg_nhead = 1;
lsp->ls_dkg.dkg_rpm = 7200;
lsp->ls_dkg.dkg_nsect = dsize /
(lsp->ls_dkg.dkg_ncyl << lsp->ls_pbshift);
}
/*
* build vtoc - see dkio(7I)
*
* Fakes one big partition based on the size of the file. This is needed
* because we allow newfs'ing the traditional lofi device and newfs will
* do several disk ioctls to figure out the geometry and partition information.
* It uses that information to determine the parameters to pass to mkfs.
*/
static void
fake_disk_vtoc(struct lofi_state *lsp, struct vtoc *vt)
{
bzero(vt, sizeof (struct vtoc));
vt->v_sanity = VTOC_SANE;
vt->v_version = V_VERSION;
(void) strncpy(vt->v_volume, LOFI_DRIVER_NAME,
sizeof (vt->v_volume));
vt->v_sectorsz = 1 << lsp->ls_pbshift;
vt->v_nparts = 1;
vt->v_part[0].p_tag = V_UNASSIGNED;
/*
* A compressed file is read-only, other files can
* be read-write
*/
if (lsp->ls_uncomp_seg_sz > 0) {
vt->v_part[0].p_flag = V_UNMNT | V_RONLY;
} else {
vt->v_part[0].p_flag = V_UNMNT;
}
vt->v_part[0].p_start = (daddr_t)0;
/*
* The partition size cannot just be the number of sectors, because
* that might not end on a cylinder boundary. And if that's the case,
* newfs/mkfs will print a scary warning. So just figure the size
* based on the number of cylinders and sectors/cylinder.
*/
vt->v_part[0].p_size = lsp->ls_dkg.dkg_pcyl *
lsp->ls_dkg.dkg_nsect * lsp->ls_dkg.dkg_nhead;
}
/*
* build dk_cinfo - see dkio(7I)
*/
static void
fake_disk_info(dev_t dev, struct dk_cinfo *ci)
{
bzero(ci, sizeof (struct dk_cinfo));
(void) strlcpy(ci->dki_cname, LOFI_DRIVER_NAME, sizeof (ci->dki_cname));
ci->dki_ctype = DKC_SCSI_CCS;
(void) strlcpy(ci->dki_dname, LOFI_DRIVER_NAME, sizeof (ci->dki_dname));
ci->dki_unit = LOFI_MINOR2ID(getminor(dev));
ci->dki_partition = LOFI_PART(getminor(dev));
/*
* newfs uses this to set maxcontig. Must not be < 16, or it
* will be 0 when newfs multiplies it by DEV_BSIZE and divides
* it by the block size. Then tunefs doesn't work because
* maxcontig is 0.
*/
ci->dki_maxtransfer = 16;
}
/*
* map in a compressed file
*
* Read in the header and the index that follows.
*
* The header is as follows -
*
* Signature (name of the compression algorithm)
* Compression segment size (a multiple of 512)
* Number of index entries
* Size of the last block
* The array containing the index entries
*
* The header information is always stored in
* network byte order on disk.
*/
static int
lofi_map_compressed_file(struct lofi_state *lsp, char *buf)
{
uint32_t index_sz, header_len, i;
ssize_t resid;
enum uio_rw rw;
char *tbuf = buf;
int error;
/* The signature has already been read */
tbuf += sizeof (lsp->ls_comp_algorithm);
bcopy(tbuf, &(lsp->ls_uncomp_seg_sz), sizeof (lsp->ls_uncomp_seg_sz));
lsp->ls_uncomp_seg_sz = ntohl(lsp->ls_uncomp_seg_sz);
/*
* The compressed segment size must be a power of 2
*/
if (lsp->ls_uncomp_seg_sz < DEV_BSIZE ||
!ISP2(lsp->ls_uncomp_seg_sz))
return (EINVAL);
for (i = 0; !((lsp->ls_uncomp_seg_sz >> i) & 1); i++)
;
lsp->ls_comp_seg_shift = i;
tbuf += sizeof (lsp->ls_uncomp_seg_sz);
bcopy(tbuf, &(lsp->ls_comp_index_sz), sizeof (lsp->ls_comp_index_sz));
lsp->ls_comp_index_sz = ntohl(lsp->ls_comp_index_sz);
tbuf += sizeof (lsp->ls_comp_index_sz);
bcopy(tbuf, &(lsp->ls_uncomp_last_seg_sz),
sizeof (lsp->ls_uncomp_last_seg_sz));
lsp->ls_uncomp_last_seg_sz = ntohl(lsp->ls_uncomp_last_seg_sz);
/*
* Compute the total size of the uncompressed data
* for use in fake_disk_geometry and other calculations.
* Disk geometry has to be faked with respect to the
* actual uncompressed data size rather than the
* compressed file size.
*/
lsp->ls_vp_size =
(u_offset_t)(lsp->ls_comp_index_sz - 2) * lsp->ls_uncomp_seg_sz
+ lsp->ls_uncomp_last_seg_sz;
/*
* Index size is rounded up to DEV_BSIZE for ease
* of segmapping
*/
index_sz = sizeof (*lsp->ls_comp_seg_index) * lsp->ls_comp_index_sz;
header_len = sizeof (lsp->ls_comp_algorithm) +
sizeof (lsp->ls_uncomp_seg_sz) +
sizeof (lsp->ls_comp_index_sz) +
sizeof (lsp->ls_uncomp_last_seg_sz);
lsp->ls_comp_offbase = header_len + index_sz;
index_sz += header_len;
index_sz = roundup(index_sz, DEV_BSIZE);
lsp->ls_comp_index_data = kmem_alloc(index_sz, KM_SLEEP);
lsp->ls_comp_index_data_sz = index_sz;
/*
* Read in the index -- this has a side-effect
* of reading in the header as well
*/
rw = UIO_READ;
error = vn_rdwr(rw, lsp->ls_vp, lsp->ls_comp_index_data, index_sz,
0, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
if (error != 0)
return (error);
/* Skip the header, this is where the index really begins */
lsp->ls_comp_seg_index =
/*LINTED*/
(uint64_t *)(lsp->ls_comp_index_data + header_len);
/*
* Now recompute offsets in the index to account for
* the header length
*/
for (i = 0; i < lsp->ls_comp_index_sz; i++) {
lsp->ls_comp_seg_index[i] = lsp->ls_comp_offbase +
BE_64(lsp->ls_comp_seg_index[i]);
}
return (error);
}
static int
lofi_init_crypto(struct lofi_state *lsp, struct lofi_ioctl *klip)
{
struct crypto_meta chead;
char buf[DEV_BSIZE];
ssize_t resid;
char *marker;
int error;
int ret;
int i;
if (!klip->li_crypto_enabled)
return (0);
/*
* All current algorithms have a max of 448 bits.
*/
if (klip->li_iv_len > CRYPTO_BITS2BYTES(512))
return (EINVAL);
if (CRYPTO_BITS2BYTES(klip->li_key_len) > sizeof (klip->li_key))
return (EINVAL);
lsp->ls_crypto_enabled = klip->li_crypto_enabled;
mutex_init(&lsp->ls_crypto_lock, NULL, MUTEX_DRIVER, NULL);
lsp->ls_mech.cm_type = crypto_mech2id(klip->li_cipher);
if (lsp->ls_mech.cm_type == CRYPTO_MECH_INVALID) {
cmn_err(CE_WARN, "invalid cipher %s requested for %s",
klip->li_cipher, klip->li_filename);
return (EINVAL);
}
/* this is just initialization here */
lsp->ls_mech.cm_param = NULL;
lsp->ls_mech.cm_param_len = 0;
lsp->ls_iv_type = klip->li_iv_type;
lsp->ls_iv_mech.cm_type = crypto_mech2id(klip->li_iv_cipher);
if (lsp->ls_iv_mech.cm_type == CRYPTO_MECH_INVALID) {
cmn_err(CE_WARN, "invalid iv cipher %s requested"
" for %s", klip->li_iv_cipher, klip->li_filename);
return (EINVAL);
}
/* iv mech must itself take a null iv */
lsp->ls_iv_mech.cm_param = NULL;
lsp->ls_iv_mech.cm_param_len = 0;
lsp->ls_iv_len = klip->li_iv_len;
/*
* Create ctx using li_cipher & the raw li_key after checking
* that it isn't a weak key.
*/
lsp->ls_key.ck_format = CRYPTO_KEY_RAW;
lsp->ls_key.ck_length = klip->li_key_len;
lsp->ls_key.ck_data = kmem_alloc(
CRYPTO_BITS2BYTES(lsp->ls_key.ck_length), KM_SLEEP);
bcopy(klip->li_key, lsp->ls_key.ck_data,
CRYPTO_BITS2BYTES(lsp->ls_key.ck_length));
ret = crypto_key_check(&lsp->ls_mech, &lsp->ls_key);
if (ret != CRYPTO_SUCCESS) {
cmn_err(CE_WARN, "weak key check failed for cipher "
"%s on file %s (0x%x)", klip->li_cipher,
klip->li_filename, ret);
return (EINVAL);
}
error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE,
CRYOFF, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
if (error != 0)
return (error);
/*
* This is the case where the header in the lofi image is already
* initialized to indicate it is encrypted.
*/
if (strncmp(buf, lofi_crypto_magic, sizeof (lofi_crypto_magic)) == 0) {
/*
* The encryption header information is laid out this way:
* 6 bytes: hex "CFLOFI"
* 2 bytes: version = 0 ... for now
* 96 bytes: reserved1 (not implemented yet)
* 4 bytes: data_sector = 2 ... for now
* more... not implemented yet
*/
marker = buf;
/* copy the magic */
bcopy(marker, lsp->ls_crypto.magic,
sizeof (lsp->ls_crypto.magic));
marker += sizeof (lsp->ls_crypto.magic);
/* read the encryption version number */
bcopy(marker, &(lsp->ls_crypto.version),
sizeof (lsp->ls_crypto.version));
lsp->ls_crypto.version = ntohs(lsp->ls_crypto.version);
marker += sizeof (lsp->ls_crypto.version);
/* read a chunk of reserved data */
bcopy(marker, lsp->ls_crypto.reserved1,
sizeof (lsp->ls_crypto.reserved1));
marker += sizeof (lsp->ls_crypto.reserved1);
/* read block number where encrypted data begins */
bcopy(marker, &(lsp->ls_crypto.data_sector),
sizeof (lsp->ls_crypto.data_sector));
lsp->ls_crypto.data_sector = ntohl(lsp->ls_crypto.data_sector);
marker += sizeof (lsp->ls_crypto.data_sector);
/* and ignore the rest until it is implemented */
lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
return (0);
}
/*
* We've requested encryption, but no magic was found, so it must be
* a new image.
*/
for (i = 0; i < sizeof (struct crypto_meta); i++) {
if (buf[i] != '\0')
return (EINVAL);
}
marker = buf;
bcopy(lofi_crypto_magic, marker, sizeof (lofi_crypto_magic));
marker += sizeof (lofi_crypto_magic);
chead.version = htons(LOFI_CRYPTO_VERSION);
bcopy(&(chead.version), marker, sizeof (chead.version));
marker += sizeof (chead.version);
marker += sizeof (chead.reserved1);
chead.data_sector = htonl(LOFI_CRYPTO_DATA_SECTOR);
bcopy(&(chead.data_sector), marker, sizeof (chead.data_sector));
/* write the header */
error = vn_rdwr(UIO_WRITE, lsp->ls_vp, buf, DEV_BSIZE,
CRYOFF, UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);
if (error != 0)
return (error);
/* fix things up so it looks like we read this info */
bcopy(lofi_crypto_magic, lsp->ls_crypto.magic,
sizeof (lofi_crypto_magic));
lsp->ls_crypto.version = LOFI_CRYPTO_VERSION;
lsp->ls_crypto.data_sector = LOFI_CRYPTO_DATA_SECTOR;
lsp->ls_crypto_offset = lsp->ls_crypto.data_sector * DEV_BSIZE;
return (0);
}
/*
* Check to see if the passed in signature is a valid one. If it is
* valid, return the index into lofi_compress_table.
*
* Return -1 if it is invalid
*/
static int
lofi_compress_select(const char *signature)
{
int i;
for (i = 0; i < LOFI_COMPRESS_FUNCTIONS; i++) {
if (strcmp(lofi_compress_table[i].l_name, signature) == 0)
return (i);
}
return (-1);
}
static int
lofi_init_compress(struct lofi_state *lsp)
{
char buf[DEV_BSIZE];
int compress_index;
ssize_t resid;
int error;
error = vn_rdwr(UIO_READ, lsp->ls_vp, buf, DEV_BSIZE, 0, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, &resid);
if (error != 0)
return (error);
if ((compress_index = lofi_compress_select(buf)) == -1)
return (0);
/* compression and encryption are mutually exclusive */
if (lsp->ls_crypto_enabled)
return (ENOTSUP);
/* initialize compression info for compressed lofi */
lsp->ls_comp_algorithm_index = compress_index;
(void) strlcpy(lsp->ls_comp_algorithm,
lofi_compress_table[compress_index].l_name,
sizeof (lsp->ls_comp_algorithm));
/* Finally setup per-thread pre-allocated buffers */
lsp->ls_comp_bufs = kmem_zalloc(lofi_taskq_nthreads *
sizeof (struct compbuf), KM_SLEEP);
return (lofi_map_compressed_file(lsp, buf));
}
/*
* Allocate new or proposed id from lofi_id.
*
* Special cases for proposed id:
* 0: not allowed, 0 is id for control device.
* -1: allocate first usable id from lofi_id.
* any other value is proposed value from userland
*
* returns DDI_SUCCESS or errno.
*/
static int
lofi_alloc_id(int *idp)
{
int id, error = DDI_SUCCESS;
if (*idp == -1) {
id = id_allocff_nosleep(lofi_id);
if (id == -1) {
error = EAGAIN;
goto err;
}
} else if (*idp == 0) {
error = EINVAL;
goto err;
} else if (*idp > ((1 << (L_BITSMINOR - LOFI_CMLB_SHIFT)) - 1)) {
error = ERANGE;
goto err;
} else {
if (ddi_get_soft_state(lofi_statep, *idp) != NULL) {
error = EEXIST;
goto err;
}
id = id_alloc_specific_nosleep(lofi_id, *idp);
if (id == -1) {
error = EAGAIN;
goto err;
}
}
*idp = id;
err:
return (error);
}
static int
lofi_create_dev(struct lofi_ioctl *klip)
{
dev_info_t *parent, *child;
struct lofi_state *lsp = NULL;
char namebuf[MAXNAMELEN];
int error, circ;
/* get control device */
lsp = ddi_get_soft_state(lofi_statep, 0);
parent = ddi_get_parent(lsp->ls_dip);
if ((error = lofi_alloc_id((int *)&klip->li_id)))
return (error);
(void) snprintf(namebuf, sizeof (namebuf), LOFI_DRIVER_NAME "@%d",
klip->li_id);
ndi_devi_enter(parent, &circ);
child = ndi_devi_findchild(parent, namebuf);
ndi_devi_exit(parent, circ);
if (child == NULL) {
child = ddi_add_child(parent, LOFI_DRIVER_NAME,
(pnode_t)DEVI_SID_NODEID, klip->li_id);
if ((error = ddi_prop_update_int(DDI_DEV_T_NONE, child,
"instance", klip->li_id)) != DDI_PROP_SUCCESS)
goto err;
if (klip->li_labeled == B_TRUE) {
if ((error = ddi_prop_create(DDI_DEV_T_NONE, child,
DDI_PROP_CANSLEEP, "labeled", 0, 0))
!= DDI_PROP_SUCCESS)
goto err;
}
if ((error = ndi_devi_online(child, NDI_ONLINE_ATTACH))
!= NDI_SUCCESS)
goto err;
} else {
id_free(lofi_id, klip->li_id);
error = EEXIST;
return (error);
}
goto done;
err:
ddi_prop_remove_all(child);
(void) ndi_devi_offline(child, NDI_DEVI_REMOVE);
id_free(lofi_id, klip->li_id);
done:
return (error);
}
static void
lofi_create_inquiry(struct lofi_state *lsp, struct scsi_inquiry *inq)
{
char *p = NULL;
(void) strlcpy(inq->inq_vid, LOFI_DRIVER_NAME, sizeof (inq->inq_vid));
mutex_enter(&lsp->ls_vp_lock);
if (lsp->ls_vp != NULL)
p = strrchr(lsp->ls_vp->v_path, '/');
if (p != NULL)
(void) strncpy(inq->inq_pid, p + 1, sizeof (inq->inq_pid));
mutex_exit(&lsp->ls_vp_lock);
(void) strlcpy(inq->inq_revision, "1.0", sizeof (inq->inq_revision));
}
/*
* copy devlink name from event cache
*/
static void
lofi_copy_devpath(struct lofi_ioctl *klip)
{
int error;
char namebuf[MAXNAMELEN], *str;
clock_t ticks;
nvlist_t *nvl;
if (klip->li_labeled == B_TRUE)
klip->li_devpath[0] = '\0';
else {
/* no need to wait for messages */
(void) snprintf(klip->li_devpath, sizeof (klip->li_devpath),
"/dev/" LOFI_CHAR_NAME "/%d", klip->li_id);
return;
}
(void) snprintf(namebuf, sizeof (namebuf), "%d", klip->li_id);
ticks = ddi_get_lbolt() + LOFI_TIMEOUT * drv_usectohz(1000000);
nvl = NULL;
mutex_enter(&lofi_chan_lock);
while (nvlist_lookup_nvlist(lofi_devlink_cache, namebuf, &nvl) != 0) {
error = cv_timedwait(&lofi_chan_cv, &lofi_chan_lock, ticks);
if (error == -1)
break;
}
if (nvl != NULL) {
if (nvlist_lookup_string(nvl, DEV_NAME, &str) == 0) {
(void) strlcpy(klip->li_devpath, str,
sizeof (klip->li_devpath));
}
}
mutex_exit(&lofi_chan_lock);
}
/*
* map a file to a minor number. Return the minor number.
*/
static int
lofi_map_file(dev_t dev, struct lofi_ioctl *ulip, int pickminor,
int *rvalp, struct cred *credp, int ioctl_flag)
{
int id = -1;
struct lofi_state *lsp = NULL;
struct lofi_ioctl *klip;
int error;
struct vnode *vp = NULL;
vattr_t vattr;
int flag;
char namebuf[MAXNAMELEN];
error = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
if (error != 0)
return (error);
mutex_enter(&lofi_lock);
if (file_to_lofi_nocheck(klip->li_filename, klip->li_readonly,
NULL) == 0) {
error = EBUSY;
goto err;
}
flag = FREAD | FWRITE | FOFFMAX | FEXCL;
error = vn_open(klip->li_filename, UIO_SYSSPACE, flag, 0, &vp, 0, 0);
if (error) {
/* try read-only */
flag &= ~FWRITE;
error = vn_open(klip->li_filename, UIO_SYSSPACE, flag, 0,
&vp, 0, 0);
if (error)
goto err;
}
if (!V_ISLOFIABLE(vp->v_type)) {
error = EINVAL;
goto err;
}
vattr.va_mask = AT_SIZE;
error = VOP_GETATTR(vp, &vattr, 0, credp, NULL);
if (error)
goto err;
/* the file needs to be a multiple of the block size */
if ((vattr.va_size % DEV_BSIZE) != 0) {
error = EINVAL;
goto err;
}
if (pickminor) {
klip->li_id = (uint32_t)-1;
}
if ((error = lofi_create_dev(klip)) != 0)
goto err;
id = klip->li_id;
lsp = ddi_get_soft_state(lofi_statep, id);
if (lsp == NULL)
goto err;
/*
* from this point lofi_destroy() is used to clean up on error
* make sure the basic data is set
*/
lsp->ls_dev = makedevice(getmajor(dev), LOFI_ID2MINOR(id));
list_create(&lsp->ls_comp_cache, sizeof (struct lofi_comp_cache),
offsetof(struct lofi_comp_cache, lc_list));
/*
* save open mode so file can be closed properly and vnode counts
* updated correctly.
*/
lsp->ls_openflag = flag;
lsp->ls_vp = vp;
lsp->ls_stacked_vp = vp;
lsp->ls_vp_size = vattr.va_size;
lsp->ls_vp_comp_size = lsp->ls_vp_size;
/*
* Try to handle stacked lofs vnodes.
*/
if (vp->v_type == VREG) {
vnode_t *realvp;
if (VOP_REALVP(vp, &realvp, NULL) == 0) {
/*
* We need to use the realvp for uniqueness
* checking, but keep the stacked vp for
* LOFI_GET_FILENAME display.
*/
VN_HOLD(realvp);
lsp->ls_vp = realvp;
}
}
lsp->ls_lbshift = highbit(DEV_BSIZE) - 1;
lsp->ls_pbshift = lsp->ls_lbshift;
lsp->ls_readonly = klip->li_readonly;
lsp->ls_uncomp_seg_sz = 0;
lsp->ls_comp_algorithm[0] = '\0';
lsp->ls_crypto_offset = 0;
(void) snprintf(namebuf, sizeof (namebuf), "%s_taskq_%d",
LOFI_DRIVER_NAME, id);
lsp->ls_taskq = taskq_create_proc(namebuf, lofi_taskq_nthreads,
minclsyspri, 1, lofi_taskq_maxalloc, curzone->zone_zsched, 0);
if ((error = lofi_init_crypto(lsp, klip)) != 0)
goto err;
if ((error = lofi_init_compress(lsp)) != 0)
goto err;
fake_disk_geometry(lsp);
if ((ddi_prop_update_int64(lsp->ls_dev, lsp->ls_dip, SIZE_PROP_NAME,
lsp->ls_vp_size - lsp->ls_crypto_offset)) != DDI_PROP_SUCCESS) {
error = EINVAL;
goto err;
}
if ((ddi_prop_update_int64(lsp->ls_dev, lsp->ls_dip, NBLOCKS_PROP_NAME,
(lsp->ls_vp_size - lsp->ls_crypto_offset) / DEV_BSIZE))
!= DDI_PROP_SUCCESS) {
error = EINVAL;
goto err;
}
list_insert_tail(&lofi_list, lsp);
/*
* Notify we are ready to rock.
*/
mutex_enter(&lsp->ls_vp_lock);
lsp->ls_vp_ready = B_TRUE;
cv_broadcast(&lsp->ls_vp_cv);
mutex_exit(&lsp->ls_vp_lock);
mutex_exit(&lofi_lock);
lofi_copy_devpath(klip);
if (rvalp)
*rvalp = id;
(void) copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
free_lofi_ioctl(klip);
return (0);
err:
if (lsp != NULL) {
lofi_destroy(lsp, credp);
} else {
if (vp != NULL) {
(void) VOP_PUTPAGE(vp, 0, 0, B_INVAL, credp, NULL);
(void) VOP_CLOSE(vp, flag, 1, 0, credp, NULL);
VN_RELE(vp);
}
}
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (error);
}
/*
* unmap a file.
*/
static int
lofi_unmap_file(struct lofi_ioctl *ulip, int byfilename,
struct cred *credp, int ioctl_flag)
{
struct lofi_state *lsp;
struct lofi_ioctl *klip;
nvlist_t *nvl = NULL;
clock_t ticks;
char name[MAXNAMELEN];
int err;
err = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
if (err != 0)
return (err);
mutex_enter(&lofi_lock);
if (byfilename) {
if ((err = file_to_lofi(klip->li_filename, klip->li_readonly,
&lsp)) != 0) {
mutex_exit(&lofi_lock);
return (err);
}
} else if (klip->li_id == 0) {
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (ENXIO);
} else {
lsp = ddi_get_soft_state(lofi_statep, klip->li_id);
}
if (lsp == NULL || lsp->ls_vp == NULL || lofi_access(lsp) != 0) {
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (ENXIO);
}
klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
/*
* If it's still held open, we'll do one of three things:
*
* If no flag is set, just return EBUSY.
*
* If the 'cleanup' flag is set, unmap and remove the device when
* the last user finishes.
*
* If the 'force' flag is set, then we forcibly close the underlying
* file. Subsequent operations will fail, and the DKIOCSTATE ioctl
* will return DKIO_DEV_GONE. When the device is last closed, the
* device will be cleaned up appropriately.
*
* This is complicated by the fact that we may have outstanding
* dispatched I/Os. Rather than having a single mutex to serialize all
* I/O, we keep a count of the number of outstanding I/O requests
* (ls_vp_iocount), as well as a flag to indicate that no new I/Os
* should be dispatched (ls_vp_closereq).
*
* We set the flag, wait for the number of outstanding I/Os to reach 0,
* and then close the underlying vnode.
*/
if (is_opened(lsp)) {
if (klip->li_force) {
mutex_enter(&lsp->ls_vp_lock);
lsp->ls_vp_closereq = B_TRUE;
/* wake up any threads waiting on dkiocstate */
cv_broadcast(&lsp->ls_vp_cv);
while (lsp->ls_vp_iocount > 0)
cv_wait(&lsp->ls_vp_cv, &lsp->ls_vp_lock);
mutex_exit(&lsp->ls_vp_lock);
goto out;
} else if (klip->li_cleanup) {
lsp->ls_cleanup = 1;
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (0);
}
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (EBUSY);
}
out:
lofi_free_dev(lsp);
lofi_destroy(lsp, credp);
/*
* check the lofi_devlink_cache if device is really gone.
* note: we just wait for timeout here and dont give error if
* timer will expire. This check is to try to ensure the unmap is
* really done when lofiadm -d completes.
* Since lofi_lock is held, also hopefully the lofiadm -a calls
* wont interfere the the unmap.
*/
(void) snprintf(name, sizeof (name), "%d", klip->li_id);
ticks = ddi_get_lbolt() + LOFI_TIMEOUT * drv_usectohz(1000000);
mutex_enter(&lofi_chan_lock);
while (nvlist_lookup_nvlist(lofi_devlink_cache, name, &nvl) == 0) {
err = cv_timedwait(&lofi_chan_cv, &lofi_chan_lock, ticks);
if (err == -1)
break;
}
mutex_exit(&lofi_chan_lock);
mutex_exit(&lofi_lock);
(void) copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
free_lofi_ioctl(klip);
return (0);
}
/*
* get the filename given the minor number, or the minor number given
* the name.
*/
/*ARGSUSED*/
static int
lofi_get_info(dev_t dev, struct lofi_ioctl *ulip, int which,
struct cred *credp, int ioctl_flag)
{
struct lofi_ioctl *klip;
struct lofi_state *lsp;
int error;
error = copy_in_lofi_ioctl(ulip, &klip, ioctl_flag);
if (error != 0)
return (error);
switch (which) {
case LOFI_GET_FILENAME:
if (klip->li_id == 0) {
free_lofi_ioctl(klip);
return (EINVAL);
}
mutex_enter(&lofi_lock);
lsp = ddi_get_soft_state(lofi_statep, klip->li_id);
if (lsp == NULL || lofi_access(lsp) != 0) {
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (ENXIO);
}
/*
* This may fail if, for example, we're trying to look
* up a zoned NFS path from the global zone.
*/
if (vnodetopath(NULL, lsp->ls_stacked_vp, klip->li_filename,
sizeof (klip->li_filename), CRED()) != 0) {
(void) strlcpy(klip->li_filename, "?",
sizeof (klip->li_filename));
}
klip->li_readonly = lsp->ls_readonly;
klip->li_labeled = lsp->ls_cmlbhandle != NULL;
(void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
sizeof (klip->li_algorithm));
klip->li_crypto_enabled = lsp->ls_crypto_enabled;
mutex_exit(&lofi_lock);
lofi_copy_devpath(klip);
error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
free_lofi_ioctl(klip);
return (error);
case LOFI_GET_MINOR:
mutex_enter(&lofi_lock);
error = file_to_lofi(klip->li_filename,
klip->li_readonly, &lsp);
if (error != 0) {
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (error);
}
klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
klip->li_readonly = lsp->ls_readonly;
klip->li_labeled = lsp->ls_cmlbhandle != NULL;
mutex_exit(&lofi_lock);
lofi_copy_devpath(klip);
error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
free_lofi_ioctl(klip);
return (error);
case LOFI_CHECK_COMPRESSED:
mutex_enter(&lofi_lock);
error = file_to_lofi(klip->li_filename,
klip->li_readonly, &lsp);
if (error != 0) {
mutex_exit(&lofi_lock);
free_lofi_ioctl(klip);
return (error);
}
klip->li_id = LOFI_MINOR2ID(getminor(lsp->ls_dev));
(void) strlcpy(klip->li_algorithm, lsp->ls_comp_algorithm,
sizeof (klip->li_algorithm));
mutex_exit(&lofi_lock);
error = copy_out_lofi_ioctl(klip, ulip, ioctl_flag);
free_lofi_ioctl(klip);
return (error);
default:
free_lofi_ioctl(klip);
return (EINVAL);
}
}
static int
uscsi_is_inquiry(intptr_t arg, int flag, union scsi_cdb *cdb,
struct uscsi_cmd *uscmd)
{
int rval;
#ifdef _MULTI_DATAMODEL
switch (ddi_model_convert_from(flag & FMODELS)) {
case DDI_MODEL_ILP32: {
struct uscsi_cmd32 ucmd32;
if (ddi_copyin((void *)arg, &ucmd32, sizeof (ucmd32), flag)) {
rval = EFAULT;
goto err;
}
uscsi_cmd32touscsi_cmd((&ucmd32), uscmd);
break;
}
case DDI_MODEL_NONE:
if (ddi_copyin((void *)arg, uscmd, sizeof (*uscmd), flag)) {
rval = EFAULT;
goto err;
}
break;
default:
rval = EFAULT;
goto err;
}
#else
if (ddi_copyin((void *)arg, uscmd, sizeof (*uscmd), flag)) {
rval = EFAULT;
goto err;
}
#endif /* _MULTI_DATAMODEL */
if (ddi_copyin(uscmd->uscsi_cdb, cdb, uscmd->uscsi_cdblen, flag)) {
rval = EFAULT;
goto err;
}
if (cdb->scc_cmd == SCMD_INQUIRY) {
return (0);
}
err:
return (rval);
}
static int
lofi_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *credp,
int *rvalp)
{
int error;
enum dkio_state dkstate;
struct lofi_state *lsp;
int id;
id = LOFI_MINOR2ID(getminor(dev));
/* lofi ioctls only apply to the master device */
if (id == 0) {
struct lofi_ioctl *lip = (struct lofi_ioctl *)arg;
/*
* the query command only need read-access - i.e., normal
* users are allowed to do those on the ctl device as
* long as they can open it read-only.
*/
switch (cmd) {
case LOFI_MAP_FILE:
if ((flag & FWRITE) == 0)
return (EPERM);
return (lofi_map_file(dev, lip, 1, rvalp, credp, flag));
case LOFI_MAP_FILE_MINOR:
if ((flag & FWRITE) == 0)
return (EPERM);
return (lofi_map_file(dev, lip, 0, rvalp, credp, flag));
case LOFI_UNMAP_FILE:
if ((flag & FWRITE) == 0)
return (EPERM);
return (lofi_unmap_file(lip, 1, credp, flag));
case LOFI_UNMAP_FILE_MINOR:
if ((flag & FWRITE) == 0)
return (EPERM);
return (lofi_unmap_file(lip, 0, credp, flag));
case LOFI_GET_FILENAME:
return (lofi_get_info(dev, lip, LOFI_GET_FILENAME,
credp, flag));
case LOFI_GET_MINOR:
return (lofi_get_info(dev, lip, LOFI_GET_MINOR,
credp, flag));
/*
* This API made limited sense when this value was fixed
* at LOFI_MAX_FILES. However, its use to iterate
* across all possible devices in lofiadm means we don't
* want to return L_MAXMIN, but the highest
* *allocated* id.
*/
case LOFI_GET_MAXMINOR:
id = 0;
mutex_enter(&lofi_lock);
for (lsp = list_head(&lofi_list); lsp != NULL;
lsp = list_next(&lofi_list, lsp)) {
int i;
if (lofi_access(lsp) != 0)
continue;
i = ddi_get_instance(lsp->ls_dip);
if (i > id)
id = i;
}
mutex_exit(&lofi_lock);
error = ddi_copyout(&id, &lip->li_id,
sizeof (id), flag);
if (error)
return (EFAULT);
return (0);
case LOFI_CHECK_COMPRESSED:
return (lofi_get_info(dev, lip, LOFI_CHECK_COMPRESSED,
credp, flag));
default:
return (EINVAL);
}
}
mutex_enter(&lofi_lock);
lsp = ddi_get_soft_state(lofi_statep, id);
if (lsp == NULL || lsp->ls_vp_closereq) {
mutex_exit(&lofi_lock);
return (ENXIO);
}
mutex_exit(&lofi_lock);
if (ddi_prop_exists(DDI_DEV_T_ANY, lsp->ls_dip, DDI_PROP_DONTPASS,
"labeled") == 1) {
error = cmlb_ioctl(lsp->ls_cmlbhandle, dev, cmd, arg, flag,
credp, rvalp, 0);
if (error != ENOTTY)
return (error);
}
/*
* We explicitly allow DKIOCSTATE, but all other ioctls should fail with
* EIO as if the device was no longer present.
*/
if (lsp->ls_vp == NULL && cmd != DKIOCSTATE)
return (EIO);
/* these are for faking out utilities like newfs */
switch (cmd) {
case DKIOCGMEDIAINFO:
case DKIOCGMEDIAINFOEXT: {
struct dk_minfo_ext media_info;
int shift = lsp->ls_lbshift;
int size;
if (cmd == DKIOCGMEDIAINFOEXT) {
media_info.dki_pbsize = 1U << lsp->ls_pbshift;
size = sizeof (struct dk_minfo_ext);
} else {
size = sizeof (struct dk_minfo);
}
media_info.dki_media_type = DK_FIXED_DISK;
media_info.dki_lbsize = 1U << shift;
media_info.dki_capacity =
(lsp->ls_vp_size - lsp->ls_crypto_offset) >> shift;
if (ddi_copyout(&media_info, (void *)arg, size, flag))
return (EFAULT);
return (0);
}
case DKIOCREMOVABLE: {
int i = 0;
if (ddi_copyout(&i, (caddr_t)arg, sizeof (int), flag))
return (EFAULT);
return (0);
}
case DKIOCGVTOC: {
struct vtoc vt;
fake_disk_vtoc(lsp, &vt);
switch (ddi_model_convert_from(flag & FMODELS)) {
case DDI_MODEL_ILP32: {
struct vtoc32 vtoc32;
vtoctovtoc32(vt, vtoc32);
if (ddi_copyout(&vtoc32, (void *)arg,
sizeof (struct vtoc32), flag))
return (EFAULT);
break;
}
case DDI_MODEL_NONE:
if (ddi_copyout(&vt, (void *)arg,
sizeof (struct vtoc), flag))
return (EFAULT);
break;
}
return (0);
}
case DKIOCINFO: {
struct dk_cinfo ci;
fake_disk_info(dev, &ci);
if (ddi_copyout(&ci, (void *)arg, sizeof (ci), flag))
return (EFAULT);
return (0);
}
case DKIOCG_VIRTGEOM:
case DKIOCG_PHYGEOM:
case DKIOCGGEOM:
error = ddi_copyout(&lsp->ls_dkg, (void *)arg,
sizeof (struct dk_geom), flag);
if (error)
return (EFAULT);
return (0);
case DKIOCSTATE:
/*
* Normally, lofi devices are always in the INSERTED state. If
* a device is forcefully unmapped, then the device transitions
* to the DKIO_DEV_GONE state.
*/
if (ddi_copyin((void *)arg, &dkstate, sizeof (dkstate),
flag) != 0)
return (EFAULT);
mutex_enter(&lsp->ls_vp_lock);
lsp->ls_vp_iocount++;
while (((dkstate == DKIO_INSERTED && lsp->ls_vp != NULL) ||
(dkstate == DKIO_DEV_GONE && lsp->ls_vp == NULL)) &&
!lsp->ls_vp_closereq) {
/*
* By virtue of having the device open, we know that
* 'lsp' will remain valid when we return.
*/
if (!cv_wait_sig(&lsp->ls_vp_cv,
&lsp->ls_vp_lock)) {
lsp->ls_vp_iocount--;
cv_broadcast(&lsp->ls_vp_cv);
mutex_exit(&lsp->ls_vp_lock);
return (EINTR);
}
}
dkstate = (!lsp->ls_vp_closereq && lsp->ls_vp != NULL ?
DKIO_INSERTED : DKIO_DEV_GONE);
lsp->ls_vp_iocount--;
cv_broadcast(&lsp->ls_vp_cv);
mutex_exit(&lsp->ls_vp_lock);
if (ddi_copyout(&dkstate, (void *)arg,
sizeof (dkstate), flag) != 0)
return (EFAULT);
return (0);
case USCSICMD: {
struct uscsi_cmd uscmd;
union scsi_cdb cdb;
if (uscsi_is_inquiry(arg, flag, &cdb, &uscmd) == 0) {
struct scsi_inquiry inq = {0};
lofi_create_inquiry(lsp, &inq);
if (ddi_copyout(&inq, uscmd.uscsi_bufaddr,
uscmd.uscsi_buflen, flag) != 0)
return (EFAULT);
return (0);
} else if (cdb.scc_cmd == SCMD_READ_CAPACITY) {
struct scsi_capacity capacity;
capacity.capacity =
BE_32((lsp->ls_vp_size - lsp->ls_crypto_offset) >>
lsp->ls_lbshift);
capacity.lbasize = BE_32(1 << lsp->ls_lbshift);
if (ddi_copyout(&capacity, uscmd.uscsi_bufaddr,
uscmd.uscsi_buflen, flag) != 0)
return (EFAULT);
return (0);
}
uscmd.uscsi_rqstatus = 0xff;
#ifdef _MULTI_DATAMODEL
switch (ddi_model_convert_from(flag & FMODELS)) {
case DDI_MODEL_ILP32: {
struct uscsi_cmd32 ucmd32;
uscsi_cmdtouscsi_cmd32((&uscmd), (&ucmd32));
if (ddi_copyout(&ucmd32, (void *)arg, sizeof (ucmd32),
flag) != 0)
return (EFAULT);
break;
}
case DDI_MODEL_NONE:
if (ddi_copyout(&uscmd, (void *)arg, sizeof (uscmd),
flag) != 0)
return (EFAULT);
break;
default:
return (EFAULT);
}
#else
if (ddi_copyout(&uscmd, (void *)arg, sizeof (uscmd), flag) != 0)
return (EFAULT);
#endif /* _MULTI_DATAMODEL */
return (0);
}
default:
#ifdef DEBUG
cmn_err(CE_WARN, "lofi_ioctl: %d is not implemented\n", cmd);
#endif /* DEBUG */
return (ENOTTY);
}
}
static int
lofi_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op, int mod_flags,
char *name, caddr_t valuep, int *lengthp)
{
struct lofi_state *lsp;
lsp = ddi_get_soft_state(lofi_statep, ddi_get_instance(dip));
if (lsp == NULL) {
return (ddi_prop_op(dev, dip, prop_op, mod_flags,
name, valuep, lengthp));
}
return (cmlb_prop_op(lsp->ls_cmlbhandle, dev, dip, prop_op, mod_flags,
name, valuep, lengthp, LOFI_PART(getminor(dev)), NULL));
}
static struct cb_ops lofi_cb_ops = {
lofi_open, /* open */
lofi_close, /* close */
lofi_strategy, /* strategy */
nodev, /* print */
nodev, /* dump */
lofi_read, /* read */
lofi_write, /* write */
lofi_ioctl, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
nochpoll, /* poll */
lofi_prop_op, /* prop_op */
0, /* streamtab */
D_64BIT | D_NEW | D_MP, /* Driver compatibility flag */
CB_REV,
lofi_aread,
lofi_awrite
};
static struct dev_ops lofi_ops = {
DEVO_REV, /* devo_rev, */
0, /* refcnt */
lofi_info, /* info */
nulldev, /* identify */
nulldev, /* probe */
lofi_attach, /* attach */
lofi_detach, /* detach */
nodev, /* reset */
&lofi_cb_ops, /* driver operations */
NULL, /* no bus operations */
NULL, /* power */
ddi_quiesce_not_needed, /* quiesce */
};
static struct modldrv modldrv = {
&mod_driverops,
"loopback file driver",
&lofi_ops,
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
int
_init(void)
{
int error;
list_create(&lofi_list, sizeof (struct lofi_state),
offsetof(struct lofi_state, ls_list));
error = ddi_soft_state_init((void **)&lofi_statep,
sizeof (struct lofi_state), 0);
if (error) {
list_destroy(&lofi_list);
return (error);
}
/*
* The minor number is stored as id << LOFI_CMLB_SHIFT as
* we need to reserve space for cmlb minor numbers.
* This will leave out 4096 id values on 32bit kernel, which should
* still suffice.
*/
lofi_id = id_space_create("lofi_id", 1,
(1 << (L_BITSMINOR - LOFI_CMLB_SHIFT)));
if (lofi_id == NULL) {
ddi_soft_state_fini((void **)&lofi_statep);
list_destroy(&lofi_list);
return (DDI_FAILURE);
}
mutex_init(&lofi_lock, NULL, MUTEX_DRIVER, NULL);
mutex_init(&lofi_chan_lock, NULL, MUTEX_DRIVER, NULL);
cv_init(&lofi_chan_cv, NULL, CV_DRIVER, NULL);
error = nvlist_alloc(&lofi_devlink_cache, NV_UNIQUE_NAME, KM_SLEEP);
if (error == 0)
error = mod_install(&modlinkage);
if (error) {
id_space_destroy(lofi_id);
if (lofi_devlink_cache != NULL)
nvlist_free(lofi_devlink_cache);
mutex_destroy(&lofi_chan_lock);
cv_destroy(&lofi_chan_cv);
mutex_destroy(&lofi_lock);
ddi_soft_state_fini((void **)&lofi_statep);
list_destroy(&lofi_list);
}
return (error);
}
int
_fini(void)
{
int error;
mutex_enter(&lofi_lock);
if (!list_is_empty(&lofi_list)) {
mutex_exit(&lofi_lock);
return (EBUSY);
}
mutex_exit(&lofi_lock);
error = mod_remove(&modlinkage);
if (error)
return (error);
mutex_enter(&lofi_chan_lock);
nvlist_free(lofi_devlink_cache);
lofi_devlink_cache = NULL;
mutex_exit(&lofi_chan_lock);
mutex_destroy(&lofi_chan_lock);
cv_destroy(&lofi_chan_cv);
mutex_destroy(&lofi_lock);
id_space_destroy(lofi_id);
ddi_soft_state_fini((void **)&lofi_statep);
list_destroy(&lofi_list);
return (error);
}
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}