zpool: Allow lockless zpool status

Add a new `ZPOOL_LOCK_BEHAVIOR` envvar to control `zpool status` lock
behavior.  `ZPOOL_LOCK_BEHAVIOR` can have one of these values:

"lockless": Try for a short amount of time to get the spa_namespace
lock.  If that doesn't work, then do the zpool status locklessly.  This
is dangerous and can crash your system if the pools configs are being
modified while zpool status is running. This setting requires `zpool
status` to be run as root.

"trylock": Try for a short amount of time to get the spa_namespace
lock.  If that doesn't work then simply abort 'zpool status'.

"wait": Wait forever for the lock.  This is the default.

These options allow users to view the zpool status when the pool
gets stuck while holding the spa_namespace lock.

Signed-off-by: Tony Hutter <[email protected]>

Author: tonyhutter

cmd/zdb/zdb.c

@@ -7815,7 +7815,8 @@ import_checkpointed_state(char *target, nvlist_t *cfg, boolean_t target_is_spa,
 
 	if (cfg == NULL) {
 		zdb_set_skip_mmp(poolname);
-		error = spa_get_stats(poolname, &cfg, NULL, 0);
+		error = spa_get_stats(poolname, &cfg, NULL, 0,
+		    ZPOOL_LOCK_BEHAVIOR_DEFAULT);
 		if (error != 0) {
 			fatal("Tried to read config of pool \"%s\" but "
 			    "spa_get_stats() failed with error %d\n",

cmd/zpool/zpool_iter.c

@@ -118,6 +118,7 @@ pool_list_get(int argc, char **argv, zprop_list_t **proplist, zfs_type_t type,
     boolean_t literal, int *err)
 {
 	zpool_list_t *zlp;
+	int rc;
 
 	zlp = safe_malloc(sizeof (zpool_list_t));
 
@@ -137,7 +138,11 @@ pool_list_get(int argc, char **argv, zprop_list_t **proplist, zfs_type_t type,
 	zlp->zl_literal = literal;
 
 	if (argc == 0) {
-		(void) zpool_iter(g_zfs, add_pool, zlp);
+		rc = zpool_iter(g_zfs, add_pool, zlp);
+		if (rc != 0) {
+			free(zlp);
+			return (NULL);
+		}
 		zlp->zl_findall = B_TRUE;
 	} else {
 		int i;

cmd/zpool/zpool_main.c

@@ -11048,6 +11048,32 @@ status_callback(zpool_handle_t *zhp, void *data)
 	return (0);
 }
 
+/*
+ * Set the zpool status lock behavior based off of the ZPOOL_LOCK_BEHAVIOR
+ * envvar.  If the var is not set, or an unknown value, then set the lock
+ * behavior to ZPOOL_LOCK_BEHAVIOR_DEFAULT.
+ */
+static void
+zpool_set_lock_behavior(void)
+{
+	char *str;
+	zpool_lock_behavior_t zpool_lock_behavior;
+
+	str = getenv("ZPOOL_LOCK_BEHAVIOR");
+	if (str == NULL)
+		zpool_lock_behavior = ZPOOL_LOCK_BEHAVIOR_DEFAULT;
+	else if (strcmp(str, "wait") == 0)
+		zpool_lock_behavior = ZPOOL_LOCK_BEHAVIOR_WAIT;
+	else if (strcmp(str, "trylock") == 0)
+		zpool_lock_behavior = ZPOOL_LOCK_BEHAVIOR_TRYLOCK;
+	else if (strcmp(str, "lockless") == 0)
+		zpool_lock_behavior = ZPOOL_LOCK_BEHAVIOR_LOCKLESS;
+	else
+		zpool_lock_behavior = ZPOOL_LOCK_BEHAVIOR_DEFAULT;
+
+	libzfs_set_lock_behavior(g_zfs, zpool_lock_behavior);
+}
+
 /*
  * zpool status [-dDegiLpPstvx] [-c [script1,script2,...]] ...
  * 				[-j|--json [--json-flat-vdevs] [--json-int] ...
@@ -11223,6 +11249,8 @@ zpool_do_status(int argc, char **argv)
 		usage(B_FALSE);
 	}
 
+	zpool_set_lock_behavior();
+
 	for (;;) {
 		if (cb.cb_json) {
 			cb.cb_jsobj = zpool_json_schema(0, 1);

include/libzfs.h

@@ -265,6 +265,8 @@ _LIBZFS_H int zpool_create(libzfs_handle_t *, const char *, nvlist_t *,
     nvlist_t *, nvlist_t *);
 _LIBZFS_H int zpool_destroy(zpool_handle_t *, const char *);
 _LIBZFS_H int zpool_add(zpool_handle_t *, nvlist_t *, boolean_t check_ashift);
+_LIBZFS_H void libzfs_set_lock_behavior(libzfs_handle_t *,
+    zpool_lock_behavior_t);
 
 typedef struct splitflags {
 	/* do not split, but return the config that would be split off */

include/os/freebsd/spl/sys/mutex.h

@@ -72,4 +72,19 @@ typedef enum {
 #define	mutex_owned(lock)	sx_xlocked(lock)
 #define	mutex_owner(lock)	sx_xholder(lock)
 
+/*
+ * Poor-man's version of Linux kernel's down_timeout(). Try to acquire a mutex
+ * for 'ns' number of nanoseconds.  Returns 0 if mutex was acquired or ETIME
+ * if timeout occurred.
+ */
+static inline int mutex_enter_timeout(kmutex_t *mutex, uint64_t ns)
+{
+	hrtime_t end = gethrtime() + ns;
+	while (gethrtime() < end) {
+		if (mutex_tryenter(mutex))
+			return (0);	/* success */
+	}
+	return (ETIME);
+}
+
 #endif	/* _OPENSOLARIS_SYS_MUTEX_H_ */

include/os/linux/spl/sys/mutex.h

@@ -26,6 +26,7 @@
 #define	_SPL_MUTEX_H
 
 #include <sys/types.h>
+#include <sys/time.h>
 #include <linux/sched.h>
 #include <linux/mutex.h>
 #include <linux/lockdep.h>
@@ -187,4 +188,19 @@ spl_mutex_lockdep_on_maybe(kmutex_t *mp)			\
 	/* NOTE: do not dereference mp after this point */	\
 }
 
+/*
+ * Poor-man's version of Linux kernel's down_timeout(). Try to acquire a mutex
+ * for 'ns' number of nanoseconds.  Returns 0 if mutex was acquired or ETIME
+ * if timeout occurred.
+ */
+static inline int mutex_enter_timeout(kmutex_t *mutex, uint64_t ns)
+{
+	hrtime_t end = gethrtime() + ns;
+	while (gethrtime() < end) {
+		if (mutex_tryenter(mutex))
+			return (0);	/* success */
+	}
+	return (ETIME);
+}
+
 #endif /* _SPL_MUTEX_H */

include/sys/fs/zfs.h

@@ -874,6 +874,9 @@ typedef struct zpool_load_policy {
 #define	ZPOOL_CONFIG_REBUILD_STATS	"org.openzfs:rebuild_stats"
 #define	ZPOOL_CONFIG_COMPATIBILITY	"compatibility"
 
+/* ZFS_IOC_POOL_STATS argument to for spa_namespace locking behavior */
+#define	ZPOOL_CONFIG_LOCK_BEHAVIOR	"lock_behavior"	/* not stored on disk */
+
 /*
  * The persistent vdev state is stored as separate values rather than a single
  * 'vdev_state' entry.  This is because a device can be in multiple states, such
@@ -1999,6 +2002,30 @@ enum zio_encrypt {
 	    ZFS_XA_NS_PREFIX_MATCH(LINUX_TRUSTED, name) || \
 	    ZFS_XA_NS_PREFIX_MATCH(LINUX_USER, name))
 
+/*
+ * Set locking behavior for zpool commands.
+ */
+typedef enum {
+	/* Wait to acquire the lock on the zpool config */
+	ZPOOL_LOCK_BEHAVIOR_WAIT = 0,
+	ZPOOL_LOCK_BEHAVIOR_DEFAULT = ZPOOL_LOCK_BEHAVIOR_WAIT,
+	/*
+	 * Return an error if it's taking an unnecessarily long time to
+	 * acquire the lock on the pool config (default 100ms)
+	 */
+	ZPOOL_LOCK_BEHAVIOR_TRYLOCK = 1,
+
+	/*
+	 * DANGER: THIS CAN CRASH YOUR SYSTEM
+	 *
+	 * If you can't acquire the pool config lock after 100ms then do a
+	 * a lockless lookup.  This should only be done in emergencies, as it
+	 * can crash the kernel module!
+	 */
+	ZPOOL_LOCK_BEHAVIOR_LOCKLESS = 2,
+	ZPOOL_LOCK_BEHAVIOR_END = 3	/* last entry marker */
+} zpool_lock_behavior_t;
+
 #ifdef	__cplusplus
 }
 #endif

include/sys/spa.h

@@ -772,10 +772,13 @@ typedef enum trim_type {
 
 /* state manipulation functions */
 extern int spa_open(const char *pool, spa_t **, const void *tag);
+extern int spa_open_common_lock_behavior(const char *pool, spa_t **spapp,
+    const void *tag, nvlist_t *nvpolicy, nvlist_t **config,
+    zpool_lock_behavior_t zpool_lock_behavior);
 extern int spa_open_rewind(const char *pool, spa_t **, const void *tag,
     nvlist_t *policy, nvlist_t **config);
 extern int spa_get_stats(const char *pool, nvlist_t **config, char *altroot,
-    size_t buflen);
+    size_t buflen, zpool_lock_behavior_t zpool_lock_behavior);
 extern int spa_create(const char *pool, nvlist_t *nvroot, nvlist_t *props,
     nvlist_t *zplprops, struct dsl_crypto_params *dcp);
 extern int spa_import(char *pool, nvlist_t *config, nvlist_t *props,
@@ -880,10 +883,13 @@ extern kcondvar_t spa_namespace_cv;
 #define	SPA_CONFIG_UPDATE_VDEVS	1
 
 extern void spa_write_cachefile(spa_t *, boolean_t, boolean_t, boolean_t);
-extern int spa_all_configs(uint64_t *generation, nvlist_t **pools);
+extern int spa_all_configs(uint64_t *generation, nvlist_t **pools,
+    zpool_lock_behavior_t zpool_lock_behavior);
 extern void spa_config_set(spa_t *spa, nvlist_t *config);
 extern nvlist_t *spa_config_generate(spa_t *spa, vdev_t *vd, uint64_t txg,
     int getstats);
+extern nvlist_t *spa_config_generate_lock_behavior(spa_t *spa, vdev_t *vd,
+    uint64_t txg, int getstats, zpool_lock_behavior_t zpool_lock_behavior);
 extern void spa_config_update(spa_t *spa, int what);
 extern int spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv,
     vdev_t *parent, uint_t id, int atype);
@@ -895,9 +901,11 @@ extern int spa_config_parse(spa_t *spa, vdev_t **vdp, nvlist_t *nv,
 
 /* Namespace manipulation */
 extern spa_t *spa_lookup(const char *name);
+extern spa_t *spa_lookup_lockless(const char *name);
 extern spa_t *spa_add(const char *name, nvlist_t *config, const char *altroot);
 extern void spa_remove(spa_t *spa);
 extern spa_t *spa_next(spa_t *prev);
+extern spa_t *spa_next_lockless(spa_t *prev);
 
 /* Refcount functions */
 extern void spa_open_ref(spa_t *spa, const void *tag);

include/sys/spa_impl.h

@@ -500,6 +500,7 @@ extern void spa_set_deadman_synctime(hrtime_t ns);
 extern void spa_set_deadman_ziotime(hrtime_t ns);
 extern const char *spa_history_zone(void);
 extern const char *zfs_active_allocator;
+extern unsigned int spa_namespace_trylock_ms;
 extern int param_set_active_allocator_common(const char *val);
 
 #ifdef	__cplusplus

include/sys/zfs_context.h

@@ -270,6 +270,7 @@ extern void mutex_enter(kmutex_t *mp);
 extern int mutex_enter_check_return(kmutex_t *mp);
 extern void mutex_exit(kmutex_t *mp);
 extern int mutex_tryenter(kmutex_t *mp);
+extern int mutex_enter_timeout(kmutex_t *mp, uint64_t ns);
 
 #define	NESTED_SINGLE 1
 #define	mutex_enter_nested(mp, class) mutex_enter(mp)