 @@ -1,14 +1,14 @@
-/*	$NetBSD: fss.c,v 1.104 2018/01/23 22:42:29 pgoyette Exp $	*/
+/*	$NetBSD: fss.c,v 1.105 2018/08/29 09:04:03 hannken Exp $	*/
 /*-
  * Copyright (c) 2003 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Juergen Hannken-Illjes.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -26,27 +26,27 @@
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * File system snapshot disk driver.
+ *
  * Block/character interface to the snapshot of a mounted file system.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: fss.c,v 1.104 2018/01/23 22:42:29 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: fss.c,v 1.105 2018/08/29 09:04:03 hannken Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 #include <sys/malloc.h>
 #include <sys/buf.h>
 #include <sys/ioctl.h>
 #include <sys/disklabel.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/stat.h>
 @@ -163,28 +163,32 @@ fss_attach(device_t parent, device_t sel
 	disk_init(sc->sc_dkdev, device_xname(self), NULL);
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	if (fss_num_attached++ == 0)
 		vfs_hooks_attach(&fss_vfs_hooks);
+}
 static int
 fss_detach(device_t self, int flags)
+{
 	struct fss_softc *sc = device_private(self);
-	if (sc->sc_flags & FSS_ACTIVE)
+	mutex_enter(&sc->sc_slock);
 	if (sc->sc_state != FSS_IDLE) {
 		mutex_exit(&sc->sc_slock);
 		return EBUSY;
+	}
 	mutex_exit(&sc->sc_slock);
 	if (--fss_num_attached == 0)
 		vfs_hooks_detach(&fss_vfs_hooks);
 	pmf_device_deregister(self);
 	mutex_destroy(&sc->sc_slock);
 	mutex_destroy(&sc->sc_lock);
 	cv_destroy(&sc->sc_work_cv);
 	cv_destroy(&sc->sc_cache_cv);
 	bufq_drain(sc->sc_bufq);
 	bufq_free(sc->sc_bufq);
 	disk_destroy(sc->sc_dkdev);
 	free(sc->sc_dkdev, M_DEVBUF);
 @@ -205,26 +209,27 @@ fss_open(dev_t dev, int flags, int mode,
 	sc = device_lookup_private(&fss_cd, minor(dev));
 	if (sc == NULL) {
 		cf = malloc(sizeof(*cf), M_DEVBUF, M_WAITOK);
 		cf->cf_name = fss_cd.cd_name;
 		cf->cf_atname = fss_cd.cd_name;
 		cf->cf_unit = minor(dev);
 		cf->cf_fstate = FSTATE_STAR;
 		sc = device_private(config_attach_pseudo(cf));
 		if (sc == NULL) {
 			mutex_exit(&fss_device_lock);
 			return ENOMEM;
+		}
 		sc->sc_state = FSS_IDLE;
+	}
 	mutex_enter(&sc->sc_slock);
 	sc->sc_flags |= mflag;
 	mutex_exit(&sc->sc_slock);
 	mutex_exit(&fss_device_lock);
 	return 0;
+}
 int
 @@ -236,60 +241,60 @@ fss_close(dev_t dev, int flags, int mode
 	mflag = (mode == S_IFCHR ? FSS_CDEV_OPEN : FSS_BDEV_OPEN);
 	error = 0;
 	mutex_enter(&fss_device_lock);
 restart:
 	mutex_enter(&sc->sc_slock);
 	if ((sc->sc_flags & (FSS_CDEV_OPEN|FSS_BDEV_OPEN)) != mflag) {
 		sc->sc_flags &= ~mflag;
 		mutex_exit(&sc->sc_slock);
 		mutex_exit(&fss_device_lock);
 		return 0;
+	}
-	if ((sc->sc_flags & FSS_ACTIVE) != 0 &&
+	if (sc->sc_state != FSS_IDLE &&
 	    (sc->sc_uflags & FSS_UNCONFIG_ON_CLOSE) != 0) {
 		sc->sc_uflags &= ~FSS_UNCONFIG_ON_CLOSE;
 		mutex_exit(&sc->sc_slock);
 		error = fss_ioctl(dev, FSSIOCCLR, NULL, FWRITE, l);
 		goto restart;
+	}
-	if ((sc->sc_flags & FSS_ACTIVE) != 0) {
+	if (sc->sc_state != FSS_IDLE) {
 		mutex_exit(&sc->sc_slock);
 		mutex_exit(&fss_device_lock);
 		return error;
+	}
-	KASSERT((sc->sc_flags & FSS_ACTIVE) == 0);
+	KASSERT(sc->sc_state == FSS_IDLE);
 	KASSERT((sc->sc_flags & (FSS_CDEV_OPEN|FSS_BDEV_OPEN)) == mflag);
 	mutex_exit(&sc->sc_slock);
 	cf = device_cfdata(sc->sc_dev);
 	error = config_detach(sc->sc_dev, DETACH_QUIET);
 	if (! error)
 		free(cf, M_DEVBUF);
 	mutex_exit(&fss_device_lock);
 	return error;
+}
 void
 fss_strategy(struct buf *bp)
+{
 	const bool write = ((bp->b_flags & B_READ) != B_READ);
 	struct fss_softc *sc = device_lookup_private(&fss_cd, minor(bp->b_dev));
 	mutex_enter(&sc->sc_slock);
-	if (write || !FSS_ISVALID(sc)) {
+	if (write || sc->sc_state != FSS_ACTIVE) {
 		bp->b_error = (write ? EROFS : ENXIO);
 		goto done;
+	}
 	/* Check bounds for non-persistent snapshots. */
 	if ((sc->sc_flags & FSS_PERSISTENT) == 0 &&
 	    bounds_check_with_mediasize(bp, DEV_BSIZE,
 	    btodb(FSS_CLTOB(sc, sc->sc_clcount - 1) + sc->sc_clresid)) <= 0)
 		goto done;
 	bp->b_rawblkno = bp->b_blkno;
 	bufq_put(sc->sc_bufq, bp);
 	cv_signal(&sc->sc_work_cv);
 @@ -307,119 +312,119 @@ fss_read(dev_t dev, struct uio *uio, int
+{
 	return physio(fss_strategy, NULL, dev, B_READ, minphys, uio);
+}
 int
 fss_write(dev_t dev, struct uio *uio, int flags)
+{
 	return physio(fss_strategy, NULL, dev, B_WRITE, minphys, uio);
+}
 int
 fss_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
+{
-	int error;
+	int error = 0;
 	struct fss_softc *sc = device_lookup_private(&fss_cd, minor(dev));
 	struct fss_set _fss;
 	struct fss_set *fss = (struct fss_set *)data;
 	struct fss_set50 *fss50 = (struct fss_set50 *)data;
 	struct fss_get *fsg = (struct fss_get *)data;
 #ifndef _LP64
 	struct fss_get50 *fsg50 = (struct fss_get50 *)data;
 #endif
 	switch (cmd) {
 	case FSSIOCSET50:
 		fss = &_fss;
 		fss->fss_mount = fss50->fss_mount;
 		fss->fss_bstore = fss50->fss_bstore;
 		fss->fss_csize = fss50->fss_csize;
 		fss->fss_flags = 0;
 		/* Fall through */
 	case FSSIOCSET:
 		mutex_enter(&sc->sc_lock);
 		if ((flag & FWRITE) == 0)
 			error = EPERM;
-		else if ((sc->sc_flags & FSS_ACTIVE) != 0)
+		mutex_enter(&sc->sc_slock);
 		if (error == 0 && sc->sc_state != FSS_IDLE)
 			error = EBUSY;
-		else
+		mutex_exit(&sc->sc_slock);
 		if (error == 0)
 			error = fss_create_snapshot(sc, fss, l);
 		if (error == 0)
 			sc->sc_uflags = fss->fss_flags;
 		mutex_exit(&sc->sc_lock);
 		break;
 	case FSSIOCCLR:
 		mutex_enter(&sc->sc_lock);
 		if ((flag & FWRITE) == 0)
 			error = EPERM;
-		else if ((sc->sc_flags & FSS_ACTIVE) == 0)
+		mutex_enter(&sc->sc_slock);
 		if (error == 0 && sc->sc_state == FSS_IDLE)
 			error = ENXIO;
-		else
+		mutex_exit(&sc->sc_slock);
 		if (error == 0)
 			error = fss_delete_snapshot(sc, l);
 		mutex_exit(&sc->sc_lock);
 		break;
 #ifndef _LP64
 	case FSSIOCGET50:
 		mutex_enter(&sc->sc_lock);
-		switch (sc->sc_flags & (FSS_PERSISTENT | FSS_ACTIVE)) {
+		mutex_enter(&sc->sc_slock);
-		case FSS_ACTIVE:
+		if (sc->sc_state == FSS_IDLE) {
 			error = ENXIO;
 		} else if ((sc->sc_flags & FSS_PERSISTENT) == 0) {
 			memcpy(fsg50->fsg_mount, sc->sc_mntname, MNAMELEN);
 			fsg50->fsg_csize = FSS_CLSIZE(sc);
 			timeval_to_timeval50(&sc->sc_time, &fsg50->fsg_time);
 			fsg50->fsg_mount_size = sc->sc_clcount;
 			fsg50->fsg_bs_size = sc->sc_clnext;
 			error = 0;
-			break;
+		} else {
 		case FSS_PERSISTENT | FSS_ACTIVE:
 			memcpy(fsg50->fsg_mount, sc->sc_mntname, MNAMELEN);
 			fsg50->fsg_csize = 0;
 			timeval_to_timeval50(&sc->sc_time, &fsg50->fsg_time);
 			fsg50->fsg_mount_size = 0;
 			fsg50->fsg_bs_size = 0;
 			error = 0;
 			break;
 		default:
 			error = ENXIO;
 			break;
+		}
 		mutex_exit(&sc->sc_slock);
 		mutex_exit(&sc->sc_lock);
 		break;
 #endif /* _LP64 */
 	case FSSIOCGET:
 		mutex_enter(&sc->sc_lock);
-		switch (sc->sc_flags & (FSS_PERSISTENT | FSS_ACTIVE)) {
+		mutex_enter(&sc->sc_slock);
-		case FSS_ACTIVE:
+		if (sc->sc_state == FSS_IDLE) {
 			error = ENXIO;
 		} else if ((sc->sc_flags & FSS_PERSISTENT) == 0) {
 			memcpy(fsg->fsg_mount, sc->sc_mntname, MNAMELEN);
 			fsg->fsg_csize = FSS_CLSIZE(sc);
 			fsg->fsg_time = sc->sc_time;
 			fsg->fsg_mount_size = sc->sc_clcount;
 			fsg->fsg_bs_size = sc->sc_clnext;
 			error = 0;
-			break;
+		} else {
 		case FSS_PERSISTENT | FSS_ACTIVE:
 			memcpy(fsg->fsg_mount, sc->sc_mntname, MNAMELEN);
 			fsg->fsg_csize = 0;
 			fsg->fsg_time = sc->sc_time;
 			fsg->fsg_mount_size = 0;
 			fsg->fsg_bs_size = 0;
 			error = 0;
 			break;
 		default:
 			error = ENXIO;
 			break;
+		}
 		mutex_exit(&sc->sc_slock);
 		mutex_exit(&sc->sc_lock);
 		break;
 	case FSSIOFSET:
 		mutex_enter(&sc->sc_slock);
 		sc->sc_uflags = *(int *)data;
 		mutex_exit(&sc->sc_slock);
 		error = 0;
 		break;
 	case FSSIOFGET:
 		mutex_enter(&sc->sc_slock);
 		*(int *)data = sc->sc_uflags;
 @@ -447,33 +452,38 @@ fss_dump(dev_t dev, daddr_t blkno, void
+{
 	return EROFS;
+}
 /*
  * An error occurred reading or writing the snapshot or backing store.
  * If it is the first error log to console and disestablish cow handler.
  * The caller holds the mutex.
  */
 static inline void
 fss_error(struct fss_softc *sc, const char *msg)
+{
-	if ((sc->sc_flags & (FSS_ACTIVE | FSS_ERROR)) != FSS_ACTIVE)
+	KASSERT(mutex_owned(&sc->sc_slock));
 	if (sc->sc_state == FSS_ERROR)
 		return;
 	aprint_error_dev(sc->sc_dev, "snapshot invalid: %s\n", msg);
-	if ((sc->sc_flags & FSS_PERSISTENT) == 0)
+	if ((sc->sc_flags & FSS_PERSISTENT) == 0) {
 		mutex_exit(&sc->sc_slock);
 		fscow_disestablish(sc->sc_mount, fss_copy_on_write, sc);
-	sc->sc_flags |= FSS_ERROR;
+		mutex_enter(&sc->sc_slock);
+	}
 	sc->sc_state = FSS_ERROR;
+}
 /*
  * Allocate the variable sized parts of the softc and
  * fork the kernel thread.
+ *
  * The fields sc_clcount, sc_clshift, sc_cache_size and sc_indir_size
  * must be initialized.
  */
 static int
 fss_softc_alloc(struct fss_softc *sc)
+{
 	int i, error;
 @@ -560,46 +570,46 @@ fss_softc_free(struct fss_softc *sc)
  * Set all active snapshots on this file system into ERROR state.
  */
 static void
 fss_unmount_hook(struct mount *mp)
+{
 	int i;
 	struct fss_softc *sc;
 	mutex_enter(&fss_device_lock);
 	for (i = 0; i < fss_cd.cd_ndevs; i++) {
 		if ((sc = device_lookup_private(&fss_cd, i)) == NULL)
 			continue;
 		mutex_enter(&sc->sc_slock);
-		if ((sc->sc_flags & FSS_ACTIVE) != 0 && sc->sc_mount == mp)
+		if (sc->sc_state != FSS_IDLE && sc->sc_mount == mp)
 			fss_error(sc, "forced by unmount");
 		mutex_exit(&sc->sc_slock);
+	}
 	mutex_exit(&fss_device_lock);
+}
 /*
  * A buffer is written to the snapshotted block device. Copy to
  * backing store if needed.
  */
 static int
 fss_copy_on_write(void *v, struct buf *bp, bool data_valid)
+{
 	int error;
 	u_int32_t cl, ch, c;
 	struct fss_softc *sc = v;
 	mutex_enter(&sc->sc_slock);
-	if (!FSS_ISVALID(sc)) {
+	if (sc->sc_state != FSS_ACTIVE) {
 		mutex_exit(&sc->sc_slock);
 		return 0;
+	}
 	cl = FSS_BTOCL(sc, dbtob(bp->b_blkno));
 	ch = FSS_BTOCL(sc, dbtob(bp->b_blkno)+bp->b_bcount-1);
 	error = 0;
 	if (curlwp == uvm.pagedaemon_lwp) {
 		for (c = cl; c <= ch; c++)
 			if (isclr(sc->sc_copied, c)) {
 				error = ENOMEM;
 				break;
+			}
 @@ -772,27 +782,29 @@ fss_create_snapshot(struct fss_softc *sc
 	u_int32_t csize;
 	off_t bsize;
 	bsize = 0;	/* XXX gcc */
 	/*
 	 * Open needed files.
 	 */
 	if ((error = fss_create_files(sc, fss, &bsize, l)) != 0)
 		goto bad;
 	if (sc->sc_flags & FSS_PERSISTENT) {
 		fss_softc_alloc(sc);
-		sc->sc_flags |= FSS_ACTIVE;
+		mutex_enter(&sc->sc_slock);
 		sc->sc_state = FSS_ACTIVE;
 		mutex_exit(&sc->sc_slock);
 		return 0;
+	}
 	/*
 	 * Set cluster size. Must be a power of two and
 	 * a multiple of backing store block size.
 	 */
 	if (fss->fss_csize <= 0)
 		csize = MAXPHYS;
 	else
 		csize = fss->fss_csize;
 	if (bsize/csize > FSS_CLUSTER_MAX)
 		csize = bsize/FSS_CLUSTER_MAX+1;
 @@ -837,28 +849,31 @@ fss_create_snapshot(struct fss_softc *sc
 	/*
 	 * Activate the snapshot.
 	 */
 	if ((error = vfs_suspend(sc->sc_mount, 0)) != 0)
 		goto bad;
 	microtime(&sc->sc_time);
 	vrele_flush(sc->sc_mount);
 	error = VFS_SYNC(sc->sc_mount, MNT_WAIT, curlwp->l_cred);
 	if (error == 0)
 		error = fscow_establish(sc->sc_mount, fss_copy_on_write, sc);
-	if (error == 0)
+	if (error == 0) {
-		sc->sc_flags |= FSS_ACTIVE;
+		mutex_enter(&sc->sc_slock);
 		sc->sc_state = FSS_ACTIVE;
 		mutex_exit(&sc->sc_slock);
+	}
 	vfs_resume(sc->sc_mount);
 	if (error != 0)
 		goto bad;
 	aprint_debug_dev(sc->sc_dev, "%s snapshot active\n", sc->sc_mntname);
 	aprint_debug_dev(sc->sc_dev,
 	    "%u clusters of %u, %u cache slots, %u indir clusters\n",
 	    sc->sc_clcount, FSS_CLSIZE(sc),
 	    sc->sc_cache_size, sc->sc_indir_size);
 	return 0;
 @@ -873,31 +888,33 @@ bad:
+	}
 	sc->sc_bs_vp = NULL;
 	return error;
+}
 /*
  * Delete a snapshot.
  */
 static int
 fss_delete_snapshot(struct fss_softc *sc, struct lwp *l)
+{
 	if ((sc->sc_flags & (FSS_PERSISTENT | FSS_ERROR)) == 0)
 		fscow_disestablish(sc->sc_mount, fss_copy_on_write, sc);
 	mutex_enter(&sc->sc_slock);
-	sc->sc_flags &= ~(FSS_ACTIVE|FSS_ERROR);
+	if ((sc->sc_flags & FSS_PERSISTENT) == 0 && sc->sc_state != FSS_ERROR) {
 		mutex_exit(&sc->sc_slock);
 		fscow_disestablish(sc->sc_mount, fss_copy_on_write, sc);
 		mutex_enter(&sc->sc_slock);
+	}
 	sc->sc_state = FSS_IDLE;
 	sc->sc_mount = NULL;
 	sc->sc_bdev = NODEV;
 	mutex_exit(&sc->sc_slock);
 	fss_softc_free(sc);
 	if (sc->sc_flags & FSS_PERSISTENT)
 		vrele(sc->sc_bs_vp);
 	else
 		vn_close(sc->sc_bs_vp, FREAD|FWRITE, l->l_cred);
 	sc->sc_bs_vp = NULL;
 	sc->sc_flags &= ~FSS_PERSISTENT;
 	return 0;
 @@ -912,27 +929,27 @@ fss_read_cluster(struct fss_softc *sc, u
 	int error, todo, offset, len;
 	daddr_t dblk;
 	struct buf *bp, *mbp;
 	struct fss_cache *scp, *scl;
 	/*
 	 * Get a free cache slot.
 	 */
 	scl = sc->sc_cache+sc->sc_cache_size;
 	mutex_enter(&sc->sc_slock);
 restart:
-	if (isset(sc->sc_copied, cl) || !FSS_ISVALID(sc)) {
+	if (isset(sc->sc_copied, cl) || sc->sc_state != FSS_ACTIVE) {
 		mutex_exit(&sc->sc_slock);
 		return 0;
+	}
 	for (scp = sc->sc_cache; scp < scl; scp++)
 		if (scp->fc_cluster == cl) {
 			if (scp->fc_type == FSS_CACHE_VALID) {
 				mutex_exit(&sc->sc_slock);
 				return 0;
 			} else if (scp->fc_type == FSS_CACHE_BUSY) {
 				cv_wait(&scp->fc_state_cv, &sc->sc_slock);
 				goto restart;
+			}
 @@ -1098,27 +1115,27 @@ fss_bs_thread(void *arg)
 		thread_idle = true;
 		if ((sc->sc_flags & FSS_BS_THREAD) == 0) {
 			mutex_exit(&sc->sc_slock);
 			kthread_exit(0);
+		}
 		/*
 		 * Process I/O requests (persistent)
 		 */
 		if (sc->sc_flags & FSS_PERSISTENT) {
 			if ((bp = bufq_get(sc->sc_bufq)) == NULL)
 				continue;
-			is_valid = FSS_ISVALID(sc);
+			is_valid = (sc->sc_state == FSS_ACTIVE);
 			is_read = (bp->b_flags & B_READ);
 			thread_idle = false;
 			mutex_exit(&sc->sc_slock);
 			if (is_valid) {
 				disk_busy(sc->sc_dkdev);
 				error = fss_bs_io(sc, FSS_READ, 0,
 				    dbtob(bp->b_blkno), bp->b_bcount,
 				    bp->b_data, &resid);
 				if (error)
 					resid = bp->b_bcount;
 				disk_unbusy(sc->sc_dkdev,
 				    (error ? 0 : bp->b_bcount), is_read);
 @@ -1160,27 +1177,27 @@ fss_bs_thread(void *arg)
 			} else
 				fss_error(sc, "write error on backing store");
 			scp->fc_type = FSS_CACHE_FREE;
 			cv_broadcast(&sc->sc_cache_cv);
 			break;
+		}
 		/*
 		 * Process I/O requests
 		 */
 		if ((bp = bufq_get(sc->sc_bufq)) == NULL)
 			continue;
-		is_valid = FSS_ISVALID(sc);
+		is_valid = (sc->sc_state == FSS_ACTIVE);
 		is_read = (bp->b_flags & B_READ);
 		thread_idle = false;
 		if (!is_valid) {
 			mutex_exit(&sc->sc_slock);
 			bp->b_error = ENXIO;
 			bp->b_resid = bp->b_bcount;
 			biodone(bp);
 			mutex_enter(&sc->sc_slock);
 			continue;
+		}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: fssvar.h,v 1.29 2015/09/06 06:00:59 dholland Exp $	*/
+/*	$NetBSD: fssvar.h,v 1.30 2018/08/29 09:04:03 hannken Exp $	*/
 /*-
  * Copyright (c) 2003, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Juergen Hannken-Illjes.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -73,30 +73,26 @@ struct fss_get50 {
 	blkcnt_t	fsg_mount_size;	/* # clusters on file system */
 	blkcnt_t	fsg_bs_size;	/* # clusters on backing store */
 };
 #define FSSIOCSET50	_IOW('F', 0, struct fss_set50)	/* Old configure */
 #define FSSIOCGET50	_IOR('F', 1, struct fss_get50)	/* Old Status */
 #include <sys/bufq.h>
 #define FSS_CLUSTER_MAX	(1<<24)		/* Upper bound of clusters. The
 					   sc_copied map uses up to
 					   FSS_CLUSTER_MAX/NBBY bytes */
 /* Check if still valid */
 #define FSS_ISVALID(sc) \
 	(((sc)->sc_flags & (FSS_ACTIVE|FSS_ERROR)) == FSS_ACTIVE)
 /* Offset to cluster */
 #define FSS_BTOCL(sc, off) \
 	((off) >> (sc)->sc_clshift)
 /* Cluster to offset */
 #define FSS_CLTOB(sc, cl) \
 	((off_t)(cl) << (sc)->sc_clshift)
 /* Offset from start of cluster */
 #define FSS_CLOFF(sc, off) \
 	((off) & (sc)->sc_clmask)
 /* Size of cluster */
 @@ -127,35 +123,40 @@ typedef enum {
 typedef enum {
 	FSS_CACHE_FREE	= 0,		/* Cache entry is free */
 	FSS_CACHE_BUSY	= 1,		/* Cache entry is read from device */
 	FSS_CACHE_VALID	= 2		/* Cache entry contains valid data */
 } fss_cache_type;
 struct fss_cache {
 	fss_cache_type	fc_type;	/* Current state */
 	u_int32_t	fc_cluster;	/* Cluster number of this entry */
 	kcondvar_t	fc_state_cv;	/* Signals state change from busy */
 	void *		fc_data;	/* Data */
 };
 typedef enum {
 	FSS_IDLE,			/* Device is unconfigured */
 	FSS_ACTIVE,			/* Device is configured */
 	FSS_ERROR			/* Device had errors */
 } fss_state_t;
 struct fss_softc {
 	device_t	sc_dev;		/* Self */
 	kmutex_t	sc_slock;	/* Protect this softc */
 	kmutex_t	sc_lock;	/* Sleep lock for fss_ioctl */
 	kcondvar_t	sc_work_cv;	/* Signals work for the kernel thread */
 	kcondvar_t	sc_cache_cv;	/* Signals free cache slot */
 	fss_state_t	sc_state;	/* Current state */
 	volatile int	sc_flags;	/* Flags */
 #define FSS_ACTIVE	0x01		/* Snapshot is active */
 #define FSS_ERROR	0x02		/* I/O error occurred */
 #define FSS_BS_THREAD	0x04		/* Kernel thread is running */
 #define FSS_PERSISTENT	0x20		/* File system internal snapshot */
 #define FSS_CDEV_OPEN	0x40		/* character device open */
 #define FSS_BDEV_OPEN	0x80		/* block device open */
 	int		sc_uflags;	/* User visible flags */
 	struct disk	*sc_dkdev;	/* Generic disk device info */
 	struct mount	*sc_mount;	/* Mount point */
 	char		sc_mntname[MNAMELEN]; /* Mount point */
 	struct timeval	sc_time;	/* Time this snapshot was taken */
 	dev_t		sc_bdev;	/* Underlying block device */
 	struct vnode	*sc_bs_vp;	/* Our backing store */
 	int		sc_bs_bshift;	/* Shift of backing store block */
 	u_int32_t	sc_bs_bmask;	/* Mask of backing store block */