Use zfs range locks in ztest

The zfs range lock interface no longer tightly depends on a
znode_t and therefore can be used in ztest.  This allows the
previous ztest specific implementation to be removed, and for
additional test coverage of the shared version.

Signed-off-by: Chunwei Chen <david.chen@osnexus.com>
Signed-off-by: Boris Protopopov <boris.protopopov@actifio.com>
Signed-off-by: Brian Behlendorf <behlendorf1@llnl.gov>
Issue #4023
Issue #4024

diff --git a/cmd/ztest/ztest.c b/cmd/ztest/ztest.c
index a824da977670f12c8809fefeac9859e80d3bc38e..bbf5cbfb78bfb9b8660caa114a48e13bacf7aae4 100644 (file)
--- a/cmd/ztest/ztest.c
+++ b/cmd/ztest/ztest.c
@@ -101,6 +101,7 @@
 #include <sys/zio.h>
 #include <sys/zil.h>
 #include <sys/zil_impl.h>
+#include <sys/zfs_rlock.h>
 #include <sys/vdev_impl.h>
 #include <sys/vdev_file.h>
 #include <sys/spa_impl.h>
@@ -231,15 +232,6 @@ typedef struct bufwad {
        uint64_t        bw_data;
 } bufwad_t;
 
-/*
- * XXX -- fix zfs range locks to be generic so we can use them here.
- */
-typedef enum {
-       RL_READER,
-       RL_WRITER,
-       RL_APPEND
-} rl_type_t;
-
 typedef struct rll {
        void            *rll_writer;
        int             rll_readers;
@@ -247,12 +239,10 @@ typedef struct rll {
        kcondvar_t      rll_cv;
 } rll_t;
 
-typedef struct rl {
-       uint64_t        rl_object;
-       uint64_t        rl_offset;
-       uint64_t        rl_size;
-       rll_t           *rl_lock;
-} rl_t;
+typedef struct zll {
+       list_t z_list;
+       kmutex_t z_lock;
+} zll_t;
 
 #define        ZTEST_RANGE_LOCKS       64
 #define        ZTEST_OBJECT_LOCKS      64
@@ -284,7 +274,7 @@ typedef struct ztest_ds {
        char            zd_name[MAXNAMELEN];
        kmutex_t        zd_dirobj_lock;
        rll_t           zd_object_lock[ZTEST_OBJECT_LOCKS];
-       rll_t           zd_range_lock[ZTEST_RANGE_LOCKS];
+       zll_t           zd_range_lock[ZTEST_RANGE_LOCKS];
 } ztest_ds_t;
 
 /*
@@ -1133,6 +1123,100 @@ ztest_spa_prop_set_uint64(zpool_prop_t prop, uint64_t value)
        return (error);
 }
 
+
+/*
+ * Object and range lock mechanics
+ */
+typedef struct {
+       list_node_t z_lnode;
+       refcount_t z_refcnt;
+       uint64_t z_object;
+       zfs_rlock_t z_range_lock;
+} ztest_znode_t;
+
+typedef struct {
+       rl_t *z_rl;
+       ztest_znode_t *z_ztznode;
+} ztest_zrl_t;
+
+static ztest_znode_t *
+ztest_znode_init(uint64_t object)
+{
+       ztest_znode_t *zp = umem_alloc(sizeof (*zp), UMEM_NOFAIL);
+
+       list_link_init(&zp->z_lnode);
+       refcount_create(&zp->z_refcnt);
+       zp->z_object = object;
+       zfs_rlock_init(&zp->z_range_lock);
+
+       return (zp);
+}
+
+static void
+ztest_znode_fini(ztest_znode_t *zp)
+{
+       ASSERT(refcount_is_zero(&zp->z_refcnt));
+       zfs_rlock_destroy(&zp->z_range_lock);
+       zp->z_object = 0;
+       refcount_destroy(&zp->z_refcnt);
+       list_link_init(&zp->z_lnode);
+       umem_free(zp, sizeof (*zp));
+}
+
+static void
+ztest_zll_init(zll_t *zll)
+{
+       mutex_init(&zll->z_lock, NULL, MUTEX_DEFAULT, NULL);
+       list_create(&zll->z_list, sizeof (ztest_znode_t),
+           offsetof(ztest_znode_t, z_lnode));
+}
+
+static void
+ztest_zll_destroy(zll_t *zll)
+{
+       list_destroy(&zll->z_list);
+       mutex_destroy(&zll->z_lock);
+}
+
+#define        RL_TAG "range_lock"
+static ztest_znode_t *
+ztest_znode_get(ztest_ds_t *zd, uint64_t object)
+{
+       zll_t *zll = &zd->zd_range_lock[object & (ZTEST_OBJECT_LOCKS - 1)];
+       ztest_znode_t *zp = NULL;
+       mutex_enter(&zll->z_lock);
+       for (zp = list_head(&zll->z_list); (zp);
+           zp = list_next(&zll->z_list, zp)) {
+               if (zp->z_object == object) {
+                       refcount_add(&zp->z_refcnt, RL_TAG);
+                       break;
+               }
+       }
+       if (zp == NULL) {
+               zp = ztest_znode_init(object);
+               refcount_add(&zp->z_refcnt, RL_TAG);
+               list_insert_head(&zll->z_list, zp);
+       }
+       mutex_exit(&zll->z_lock);
+       return (zp);
+}
+
+static void
+ztest_znode_put(ztest_ds_t *zd, ztest_znode_t *zp)
+{
+       zll_t *zll = NULL;
+       ASSERT3U(zp->z_object, !=, 0);
+       zll = &zd->zd_range_lock[zp->z_object & (ZTEST_OBJECT_LOCKS - 1)];
+       mutex_enter(&zll->z_lock);
+       refcount_remove(&zp->z_refcnt, RL_TAG);
+       if (refcount_is_zero(&zp->z_refcnt)) {
+               list_remove(&zll->z_list, zp);
+               ztest_znode_fini(zp);
+       }
+       mutex_exit(&zll->z_lock);
+}
+
+
 static void
 ztest_rll_init(rll_t *rll)
 {
@@ -1205,33 +1289,37 @@ ztest_object_unlock(ztest_ds_t *zd, uint64_t object)
        ztest_rll_unlock(rll);
 }
 
-static rl_t *
-ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset,
-    uint64_t size, rl_type_t type)
+static ztest_zrl_t *
+ztest_zrl_init(rl_t *rl, ztest_znode_t *zp)
 {
-       uint64_t hash = object ^ (offset % (ZTEST_RANGE_LOCKS + 1));
-       rll_t *rll = &zd->zd_range_lock[hash & (ZTEST_RANGE_LOCKS - 1)];
-       rl_t *rl;
-
-       rl = umem_alloc(sizeof (*rl), UMEM_NOFAIL);
-       rl->rl_object = object;
-       rl->rl_offset = offset;
-       rl->rl_size = size;
-       rl->rl_lock = rll;
-
-       ztest_rll_lock(rll, type);
-
-       return (rl);
+       ztest_zrl_t *zrl = umem_alloc(sizeof (*zrl), UMEM_NOFAIL);
+       zrl->z_rl = rl;
+       zrl->z_ztznode = zp;
+       return (zrl);
 }
 
 static void
-ztest_range_unlock(rl_t *rl)
+ztest_zrl_fini(ztest_zrl_t *zrl)
 {
-       rll_t *rll = rl->rl_lock;
+       umem_free(zrl, sizeof (*zrl));
+}
 
-       ztest_rll_unlock(rll);
+static ztest_zrl_t *
+ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset,
+    uint64_t size, rl_type_t type)
+{
+       ztest_znode_t *zp = ztest_znode_get(zd, object);
+       rl_t *rl = zfs_range_lock(&zp->z_range_lock, offset,
+           size, type);
+       return (ztest_zrl_init(rl, zp));
+}
 
-       umem_free(rl, sizeof (*rl));
+static void
+ztest_range_unlock(ztest_ds_t *zd, ztest_zrl_t *zrl)
+{
+       zfs_range_unlock(zrl->z_rl);
+       ztest_znode_put(zd, zrl->z_ztznode);
+       ztest_zrl_fini(zrl);
 }
 
 static void
@@ -1253,7 +1341,7 @@ ztest_zd_init(ztest_ds_t *zd, ztest_shared_ds_t *szd, objset_t *os)
                ztest_rll_init(&zd->zd_object_lock[l]);
 
        for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
-               ztest_rll_init(&zd->zd_range_lock[l]);
+               ztest_zll_init(&zd->zd_range_lock[l]);
 }
 
 static void
@@ -1268,7 +1356,7 @@ ztest_zd_fini(ztest_ds_t *zd)
                ztest_rll_destroy(&zd->zd_object_lock[l]);
 
        for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
-               ztest_rll_destroy(&zd->zd_range_lock[l]);
+               ztest_zll_destroy(&zd->zd_range_lock[l]);
 }
 
 #define        TXG_MIGHTWAIT   (ztest_random(10) == 0 ? TXG_NOWAIT : TXG_WAIT)
@@ -1625,7 +1713,7 @@ ztest_replay_write(ztest_ds_t *zd, lr_write_t *lr, boolean_t byteswap)
        dmu_tx_t *tx;
        dmu_buf_t *db;
        arc_buf_t *abuf = NULL;
-       rl_t *rl;
+       ztest_zrl_t *rl;
 
        if (byteswap)
                byteswap_uint64_array(lr, sizeof (*lr));
@@ -1674,7 +1762,7 @@ ztest_replay_write(ztest_ds_t *zd, lr_write_t *lr, boolean_t byteswap)
                if (abuf != NULL)
                        dmu_return_arcbuf(abuf);
                dmu_buf_rele(db, FTAG);
-               ztest_range_unlock(rl);
+               ztest_range_unlock(zd, rl);
                ztest_object_unlock(zd, lr->lr_foid);
                return (ENOSPC);
        }
@@ -1731,7 +1819,7 @@ ztest_replay_write(ztest_ds_t *zd, lr_write_t *lr, boolean_t byteswap)
 
        dmu_tx_commit(tx);
 
-       ztest_range_unlock(rl);
+       ztest_range_unlock(zd, rl);
        ztest_object_unlock(zd, lr->lr_foid);
 
        return (0);
@@ -1743,7 +1831,7 @@ ztest_replay_truncate(ztest_ds_t *zd, lr_truncate_t *lr, boolean_t byteswap)
        objset_t *os = zd->zd_os;
        dmu_tx_t *tx;
        uint64_t txg;
-       rl_t *rl;
+       ztest_zrl_t *rl;
 
        if (byteswap)
                byteswap_uint64_array(lr, sizeof (*lr));
@@ -1758,7 +1846,7 @@ ztest_replay_truncate(ztest_ds_t *zd, lr_truncate_t *lr, boolean_t byteswap)
 
        txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
        if (txg == 0) {
-               ztest_range_unlock(rl);
+               ztest_range_unlock(zd, rl);
                ztest_object_unlock(zd, lr->lr_foid);
                return (ENOSPC);
        }
@@ -1770,7 +1858,7 @@ ztest_replay_truncate(ztest_ds_t *zd, lr_truncate_t *lr, boolean_t byteswap)
 
        dmu_tx_commit(tx);
 
-       ztest_range_unlock(rl);
+       ztest_range_unlock(zd, rl);
        ztest_object_unlock(zd, lr->lr_foid);
 
        return (0);
@@ -1873,23 +1961,30 @@ zil_replay_func_t ztest_replay_vector[TX_MAX_TYPE] = {
 /*
  * ZIL get_data callbacks
  */
+typedef struct ztest_zgd_private {
+       ztest_ds_t *z_zd;
+       ztest_zrl_t *z_rl;
+       uint64_t z_object;
+} ztest_zgd_private_t;
 
 static void
 ztest_get_done(zgd_t *zgd, int error)
 {
-       ztest_ds_t *zd = zgd->zgd_private;
-       uint64_t object = zgd->zgd_rl->rl_object;
+       ztest_zgd_private_t *zzp = zgd->zgd_private;
+       ztest_ds_t *zd = zzp->z_zd;
+       uint64_t object = zzp->z_object;
 
        if (zgd->zgd_db)
                dmu_buf_rele(zgd->zgd_db, zgd);
 
-       ztest_range_unlock(zgd->zgd_rl);
+       ztest_range_unlock(zd, zzp->z_rl);
        ztest_object_unlock(zd, object);
 
        if (error == 0 && zgd->zgd_bp)
                zil_add_block(zgd->zgd_zilog, zgd->zgd_bp);
 
        umem_free(zgd, sizeof (*zgd));
+       umem_free(zzp, sizeof (*zzp));
 }
 
 static int
@@ -1907,6 +2002,7 @@ ztest_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
        dmu_buf_t *db;
        zgd_t *zgd;
        int error;
+       ztest_zgd_private_t *zgd_private;
 
        ztest_object_lock(zd, object, RL_READER);
        error = dmu_bonus_hold(os, object, FTAG, &db);
@@ -1929,10 +2025,13 @@ ztest_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
 
        zgd = umem_zalloc(sizeof (*zgd), UMEM_NOFAIL);
        zgd->zgd_zilog = zd->zd_zilog;
-       zgd->zgd_private = zd;
+       zgd_private = umem_zalloc(sizeof (ztest_zgd_private_t), UMEM_NOFAIL);
+       zgd_private->z_zd = zd;
+       zgd_private->z_object = object;
+       zgd->zgd_private = zgd_private;
 
        if (buf != NULL) {      /* immediate write */
-               zgd->zgd_rl = ztest_range_lock(zd, object, offset, size,
+               zgd_private->z_rl = ztest_range_lock(zd, object, offset, size,
                    RL_READER);
 
                error = dmu_read(os, object, offset, size, buf,
@@ -1947,7 +2046,7 @@ ztest_get_data(void *arg, lr_write_t *lr, char *buf, zio_t *zio)
                        offset = 0;
                }
 
-               zgd->zgd_rl = ztest_range_lock(zd, object, offset, size,
+               zgd_private->z_rl = ztest_range_lock(zd, object, offset, size,
                    RL_READER);
 
                error = dmu_buf_hold(os, object, offset, zgd, &db,
@@ -2198,7 +2297,7 @@ ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
        objset_t *os = zd->zd_os;
        dmu_tx_t *tx;
        uint64_t txg;
-       rl_t *rl;
+       ztest_zrl_t *rl;
 
        txg_wait_synced(dmu_objset_pool(os), 0);
 
@@ -2219,7 +2318,7 @@ ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
                (void) dmu_free_long_range(os, object, offset, size);
        }
 
-       ztest_range_unlock(rl);
+       ztest_range_unlock(zd, rl);
        ztest_object_unlock(zd, object);
 }
 

diff --git a/include/sys/zfs_rlock.h b/include/sys/zfs_rlock.h
index 5322f3bc73af3350a46a824d0561c5fcd26ceb47..5373f0d57320c0617f6066c218291db5bd71b8e9 100644 (file)
--- a/include/sys/zfs_rlock.h
+++ b/include/sys/zfs_rlock.h
@@ -30,11 +30,14 @@
 extern "C" {
 #endif
 
-#ifdef _KERNEL
-
 #include <sys/list.h>
 #include <sys/avl.h>
+
+#ifdef _KERNEL
 #include <sys/condvar.h>
+#else
+#include <sys/zfs_context.h>
+#endif
 
 typedef enum {
        RL_READER,
@@ -106,7 +109,6 @@ zfs_rlock_destroy(zfs_rlock_t *zrl)
        avl_destroy(&zrl->zr_avl);
        mutex_destroy(&zrl->zr_mutex);
 }
-#endif /* _KERNEL */
 
 #ifdef __cplusplus
 }

diff --git a/lib/libzpool/Makefile.am b/lib/libzpool/Makefile.am
index 3e59efa5c4b1b00ef6a3b0c50b4d7f98851ba295..9bb1a8eea3faec82689c9ea29ec866e8606457eb 100644 (file)
--- a/lib/libzpool/Makefile.am
+++ b/lib/libzpool/Makefile.am
@@ -103,6 +103,7 @@ KERNEL_C = \
        zfs_fuid.c \
        zfs_sa.c \
        zfs_znode.c \
+       zfs_rlock.c \
        zil.c \
        zio.c \
        zio_checksum.c \