upstream/illumos/illumos-gate: comparison usr/src/uts/common/fs/zfs/zfs

equal deleted inserted replaced

-:6f48102ad665
+:693dd2cad55f
 #include <sys/mount.h>
 #include <sys/sdt.h>
 #include <sys/fs/zfs.h>
 #include <sys/zfs_ctldir.h>
 #include <sys/zfs_dir.h>
+#include <sys/zfs_onexit.h>
 #include <sys/zvol.h>
 #include <sys/dsl_scan.h>
 #include <sharefs/share.h>
 #include <sys/dmu_objset.h>
 * zc_value		name of snapshot to create
 * zc_string		name of clone origin (if DRR_FLAG_CLONE)
 * zc_cookie		file descriptor to recv from
 * zc_begin_record	the BEGIN record of the stream (not byteswapped)
 * zc_guid		force flag
+* zc_cleanup_fd	cleanup-on-exit file descriptor
+* zc_action_handle	handle for this guid/ds mapping (or zero on first call)
 *
 * outputs:
 * zc_cookie		number of bytes read
 * zc_nvlist_dst{_size} error for each unapplied received property
 * zc_obj		zprop_errflags_t
+* zc_action_handle	handle for this guid/ds mapping
 */
 static int
 zfs_ioc_recv(zfs_cmd_t *zc)
 {
 	file_t *fp;
 		 */
 		props_error = EINVAL;
 	}
 	off = fp->f_offset;
-	error = dmu_recv_stream(&drc, fp->f_vnode, &off);
+	error = dmu_recv_stream(&drc, fp->f_vnode, &off, zc->zc_cleanup_fd,
+	    &zc->zc_action_handle);
 	if (error == 0) {
 		zfsvfs_t *zfsvfs = NULL;
 		if (getzfsvfs(tofs, &zfsvfs) == 0) {
 	return (error);
 }
 /*
 * inputs:
-* zc_name	name of filesystem
+* zc_name		name of filesystem
-* zc_value	short name of snap
+* zc_value		short name of snap
-* zc_string	user-supplied tag for this reference
+* zc_string		user-supplied tag for this hold
-* zc_cookie	recursive flag
+* zc_cookie		recursive flag
-* zc_temphold	set if hold is temporary
+* zc_temphold		set if hold is temporary
+* zc_cleanup_fd	cleanup-on-exit file descriptor for calling process
 *
 * outputs:		none
 */
 static int
 zfs_ioc_hold(zfs_cmd_t *zc)
 	if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
 		return (EINVAL);
 	return (dsl_dataset_user_hold(zc->zc_name, zc->zc_value,
-	    zc->zc_string, recursive, zc->zc_temphold));
+	    zc->zc_string, recursive, zc->zc_temphold, zc->zc_cleanup_fd));
 }
 /*
 * inputs:
-* zc_name	name of dataset from which we're releasing a user reference
+* zc_name	name of dataset from which we're releasing a user hold
 * zc_value	short name of snap
-* zc_string	user-supplied tag for this reference
+* zc_string	user-supplied tag for this hold
 * zc_cookie	recursive flag
 *
-* outputs:		none
+* outputs:	none
 */
 static int
 zfs_ioc_release(zfs_cmd_t *zc)
 {
 	boolean_t recursive = zc->zc_cookie;
 		spa_close(spa, FTAG);
 	}
 	return (error);
 }
+/*
+* Find a free minor number.
+*/
+minor_t
+zfsdev_minor_alloc(void)
+{
+	static minor_t last_minor;
+	minor_t m;
+	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
+	for (m = last_minor + 1; m != last_minor; m++) {
+		if (m > ZFSDEV_MAX_MINOR)
+			m = 1;
+		if (ddi_get_soft_state(zfsdev_state, m) == NULL) {
+			last_minor = m;
+			return (m);
+		}
+	}
+	return (0);
+}
+static int
+zfs_ctldev_init(dev_t *devp)
+{
+	minor_t minor;
+	zfs_soft_state_t *zs;
+	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
+	ASSERT(getminor(*devp) == 0);
+	minor = zfsdev_minor_alloc();
+	if (minor == 0)
+		return (ENXIO);
+	if (ddi_soft_state_zalloc(zfsdev_state, minor) != DDI_SUCCESS)
+		return (EAGAIN);
+	*devp = makedevice(getemajor(*devp), minor);
+	zs = ddi_get_soft_state(zfsdev_state, minor);
+	zs->zss_type = ZSST_CTLDEV;
+	zfs_onexit_init((zfs_onexit_t **)&zs->zss_data);
+	return (0);
+}
+static void
+zfs_ctldev_destroy(zfs_onexit_t *zo, minor_t minor)
+{
+	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
+	zfs_onexit_destroy(zo);
+	ddi_soft_state_free(zfsdev_state, minor);
+}
+void *
+zfsdev_get_soft_state(minor_t minor, enum zfs_soft_state_type which)
+{
+	zfs_soft_state_t *zp;
+	zp = ddi_get_soft_state(zfsdev_state, minor);
+	if (zp == NULL || zp->zss_type != which)
+		return (NULL);
+	return (zp->zss_data);
+}
+static int
+zfsdev_open(dev_t *devp, int flag, int otyp, cred_t *cr)
+{
+	int error = 0;
+	if (getminor(*devp) != 0)
+		return (zvol_open(devp, flag, otyp, cr));
+	/* This is the control device. Allocate a new minor if requested. */
+	if (flag & FEXCL) {
+		mutex_enter(&zfsdev_state_lock);
+		error = zfs_ctldev_init(devp);
+		mutex_exit(&zfsdev_state_lock);
+	}
+	return (error);
+}
+static int
+zfsdev_close(dev_t dev, int flag, int otyp, cred_t *cr)
+{
+	zfs_onexit_t *zo;
+	minor_t minor = getminor(dev);
+	if (minor == 0)
+		return (0);
+	mutex_enter(&zfsdev_state_lock);
+	zo = zfsdev_get_soft_state(minor, ZSST_CTLDEV);
+	if (zo == NULL) {
+		mutex_exit(&zfsdev_state_lock);
+		return (zvol_close(dev, flag, otyp, cr));
+	}
+	zfs_ctldev_destroy(zo, minor);
+	mutex_exit(&zfsdev_state_lock);
+	return (0);
+}
 static int
 zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
 {
 	zfs_cmd_t *zc;
 	uint_t vec;
 	int error, rc;
+	minor_t minor = getminor(dev);
-	if (getminor(dev) != 0)
+	if (minor != 0 &&
+	    zfsdev_get_soft_state(minor, ZSST_CTLDEV) == NULL)
 		return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
 	vec = cmd - ZFS_IOC;
 	ASSERT3U(getmajor(dev), ==, ddi_driver_major(zfs_dip));
 *
 * /dev/zfs has basically nothing to do except serve up ioctls,
 * so most of the standard driver entry points are in zvol.c.
 */
 static struct cb_ops zfs_cb_ops = {
-	zvol_open,	/* open */
+	zfsdev_open,	/* open */
-	zvol_close,	/* close */
+	zfsdev_close,	/* close */
 	zvol_strategy,	/* strategy */
 	nodev,		/* print */
 	zvol_dump,	/* dump */
 	zvol_read,	/* read */
 	zvol_write,	/* write */

changeset 12527	693dd2cad55f
parent 12296	7cf402a7f374
child 12620	12fcd99a642d