X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Fgenops.c;h=436e5c76d11fd93b4a18c61931af8e10c660e622;hp=b0af24a54e891c45e7616814ca51afe432c70d29;hb=6722a95fd0416fa6f24140130ea8a1e0df5f1542;hpb=c77e504fdac12d3be7d19a652d6c7da497018c76

diff --git a/lustre/obdclass/genops.c b/lustre/obdclass/genops.c
index b0af24a..436e5c7 100644
--- a/lustre/obdclass/genops.c
+++ b/lustre/obdclass/genops.c
@@ -15,11 +15,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
@@ -27,7 +23,7 @@
  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -41,32 +37,30 @@
 
 #define DEBUG_SUBSYSTEM S_CLASS
 
-#include <linux/kthread.h>
+#include <linux/pid_namespace.h>
+#include <linux/workqueue.h>
+#include <lustre_compat.h>
 #include <obd_class.h>
+#include <lustre_log.h>
 #include <lprocfs_status.h>
 #include <lustre_disk.h>
 #include <lustre_kernelcomm.h>
 
-spinlock_t obd_types_lock;
+DEFINE_RWLOCK(obd_dev_lock);
+static struct obd_device *obd_devs[MAX_OBD_DEVICES];
 
 static struct kmem_cache *obd_device_cachep;
-struct kmem_cache *obdo_cachep;
-EXPORT_SYMBOL(obdo_cachep);
-static struct kmem_cache *import_cachep;
-
-static struct list_head obd_zombie_imports;
-static struct list_head obd_zombie_exports;
-static spinlock_t  obd_zombie_impexp_lock;
+static struct kobj_type class_ktype;
+static struct workqueue_struct *zombie_wq;
 
-static void obd_zombie_impexp_notify(void);
 static void obd_zombie_export_add(struct obd_export *exp);
 static void obd_zombie_import_add(struct obd_import *imp);
 static void print_export_data(struct obd_export *exp,
-                              const char *status, int locks);
+                              const char *status, int locks, int debug_level);
 
-struct list_head obd_stale_exports;
-spinlock_t       obd_stale_export_lock;
-atomic_t         obd_stale_export_num;
+static LIST_HEAD(obd_stale_exports);
+static DEFINE_SPINLOCK(obd_stale_export_lock);
+static atomic_t obd_stale_export_num = ATOMIC_INIT(0);
 
 int (*ptlrpc_put_connection_superhack)(struct ptlrpc_connection *c);
 EXPORT_SYMBOL(ptlrpc_put_connection_superhack);
@@ -102,30 +96,26 @@ static void obd_device_free(struct obd_device *obd)
 
 struct obd_type *class_search_type(const char *name)
 {
-	struct list_head *tmp;
-	struct obd_type *type;
+	struct kobject *kobj = kset_find_obj(lustre_kset, name);
 
-	spin_lock(&obd_types_lock);
-	list_for_each(tmp, &obd_types) {
-		type = list_entry(tmp, struct obd_type, typ_chain);
-		if (strcmp(type->typ_name, name) == 0) {
-			spin_unlock(&obd_types_lock);
-			return type;
-		}
-	}
-	spin_unlock(&obd_types_lock);
+	if (kobj && kobj->ktype == &class_ktype)
+		return container_of(kobj, struct obd_type, typ_kobj);
+
+	kobject_put(kobj);
 	return NULL;
 }
 EXPORT_SYMBOL(class_search_type);
 
 struct obd_type *class_get_type(const char *name)
 {
-        struct obd_type *type = class_search_type(name);
+	struct obd_type *type;
 
+	type = class_search_type(name);
 #ifdef HAVE_MODULE_LOADING_SUPPORT
         if (!type) {
                 const char *modname = name;
 
+#ifdef HAVE_SERVER_SUPPORT
 		if (strcmp(modname, "obdfilter") == 0)
 			modname = "ofd";
 
@@ -134,6 +124,7 @@ struct obd_type *class_get_type(const char *name)
 
 		if (!strncmp(modname, LUSTRE_MDS_NAME, strlen(LUSTRE_MDS_NAME)))
 			modname = LUSTRE_MDT_NAME;
+#endif /* HAVE_SERVER_SUPPORT */
 
 		if (!request_module("%s", modname)) {
 			CDEBUG(D_INFO, "Loaded module '%s'\n", modname);
@@ -145,10 +136,17 @@ struct obd_type *class_get_type(const char *name)
         }
 #endif
         if (type) {
-		spin_lock(&type->obd_type_lock);
-		type->typ_refcnt++;
-		try_module_get(type->typ_dt_ops->o_owner);
-		spin_unlock(&type->obd_type_lock);
+		if (try_module_get(type->typ_dt_ops->o_owner)) {
+			atomic_inc(&type->typ_refcnt);
+			/* class_search_type() returned a counted reference,
+			 * but we don't need that count any more as
+			 * we have one through typ_refcnt.
+			 */
+			kobject_put(&type->typ_kobj);
+		} else {
+			kobject_put(&type->typ_kobj);
+			type = NULL;
+		}
 	}
 	return type;
 }
@@ -156,11 +154,83 @@ struct obd_type *class_get_type(const char *name)
 void class_put_type(struct obd_type *type)
 {
 	LASSERT(type);
-	spin_lock(&type->obd_type_lock);
-	type->typ_refcnt--;
 	module_put(type->typ_dt_ops->o_owner);
-	spin_unlock(&type->obd_type_lock);
+	atomic_dec(&type->typ_refcnt);
+}
+
+static void class_sysfs_release(struct kobject *kobj)
+{
+	struct obd_type *type = container_of(kobj, struct obd_type, typ_kobj);
+
+	debugfs_remove_recursive(type->typ_debugfs_entry);
+	type->typ_debugfs_entry = NULL;
+
+	if (type->typ_lu)
+		lu_device_type_fini(type->typ_lu);
+
+#ifdef CONFIG_PROC_FS
+	if (type->typ_name && type->typ_procroot)
+		remove_proc_subtree(type->typ_name, proc_lustre_root);
+#endif
+	if (type->typ_md_ops)
+		OBD_FREE_PTR(type->typ_md_ops);
+	if (type->typ_dt_ops)
+		OBD_FREE_PTR(type->typ_dt_ops);
+
+	OBD_FREE(type, sizeof(*type));
+}
+
+static struct kobj_type class_ktype = {
+	.sysfs_ops      = &lustre_sysfs_ops,
+	.release        = class_sysfs_release,
+};
+
+#ifdef HAVE_SERVER_SUPPORT
+struct obd_type *class_add_symlinks(const char *name, bool enable_proc)
+{
+	struct dentry *symlink;
+	struct obd_type *type;
+	int rc;
+
+	type = class_search_type(name);
+	if (type) {
+		kobject_put(&type->typ_kobj);
+		return ERR_PTR(-EEXIST);
+	}
+
+	OBD_ALLOC(type, sizeof(*type));
+	if (!type)
+		return ERR_PTR(-ENOMEM);
+
+	type->typ_kobj.kset = lustre_kset;
+	rc = kobject_init_and_add(&type->typ_kobj, &class_ktype,
+				  &lustre_kset->kobj, "%s", name);
+	if (rc)
+		return ERR_PTR(rc);
+
+	symlink = debugfs_create_dir(name, debugfs_lustre_root);
+	if (IS_ERR_OR_NULL(symlink)) {
+		rc = symlink ? PTR_ERR(symlink) : -ENOMEM;
+		kobject_put(&type->typ_kobj);
+		return ERR_PTR(rc);
+	}
+	type->typ_debugfs_entry = symlink;
+	type->typ_sym_filter = true;
+
+	if (enable_proc) {
+		type->typ_procroot = lprocfs_register(name, proc_lustre_root,
+						      NULL, NULL);
+		if (IS_ERR(type->typ_procroot)) {
+			CERROR("%s: can't create compat proc entry: %d\n",
+			       name, (int)PTR_ERR(type->typ_procroot));
+			type->typ_procroot = NULL;
+		}
+	}
+
+	return type;
 }
+EXPORT_SYMBOL(class_add_symlinks);
+#endif /* HAVE_SERVER_SUPPORT */
 
 #define CLASS_MAX_NAME 1024
 
@@ -168,44 +238,57 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops,
 			bool enable_proc, struct lprocfs_vars *vars,
 			const char *name, struct lu_device_type *ldt)
 {
-        struct obd_type *type;
-        int rc = 0;
-        ENTRY;
-
-        /* sanity check */
-        LASSERT(strnlen(name, CLASS_MAX_NAME) < CLASS_MAX_NAME);
+	struct obd_type *type;
+	int rc;
 
-        if (class_search_type(name)) {
+	ENTRY;
+	/* sanity check */
+	LASSERT(strnlen(name, CLASS_MAX_NAME) < CLASS_MAX_NAME);
+
+	type = class_search_type(name);
+	if (type) {
+#ifdef HAVE_SERVER_SUPPORT
+		if (type->typ_sym_filter)
+			goto dir_exist;
+#endif /* HAVE_SERVER_SUPPORT */
+		kobject_put(&type->typ_kobj);
                 CDEBUG(D_IOCTL, "Type %s already registered\n", name);
                 RETURN(-EEXIST);
         }
 
-        rc = -ENOMEM;
         OBD_ALLOC(type, sizeof(*type));
         if (type == NULL)
-                RETURN(rc);
+		RETURN(-ENOMEM);
 
+	type->typ_kobj.kset = lustre_kset;
+	kobject_init(&type->typ_kobj, &class_ktype);
+#ifdef HAVE_SERVER_SUPPORT
+dir_exist:
+#endif /* HAVE_SERVER_SUPPORT */
         OBD_ALLOC_PTR(type->typ_dt_ops);
         OBD_ALLOC_PTR(type->typ_md_ops);
-        OBD_ALLOC(type->typ_name, strlen(name) + 1);
 
         if (type->typ_dt_ops == NULL ||
-            type->typ_md_ops == NULL ||
-            type->typ_name == NULL)
-                GOTO (failed, rc);
+	    type->typ_md_ops == NULL)
+		GOTO (failed, rc = -ENOMEM);
 
         *(type->typ_dt_ops) = *dt_ops;
         /* md_ops is optional */
         if (md_ops)
                 *(type->typ_md_ops) = *md_ops;
-        strcpy(type->typ_name, name);
-	spin_lock_init(&type->obd_type_lock);
 
+#ifdef HAVE_SERVER_SUPPORT
+	if (type->typ_sym_filter) {
+		type->typ_sym_filter = false;
+		kobject_put(&type->typ_kobj);
+		goto setup_ldt;
+	}
+#endif
 #ifdef CONFIG_PROC_FS
-	if (enable_proc) {
-		type->typ_procroot = lprocfs_register(type->typ_name,
+	if (enable_proc && !type->typ_procroot) {
+		type->typ_procroot = lprocfs_register(name,
 						      proc_lustre_root,
-						      vars, type);
+						      NULL, type);
 		if (IS_ERR(type->typ_procroot)) {
 			rc = PTR_ERR(type->typ_procroot);
 			type->typ_procroot = NULL;
@@ -213,39 +296,41 @@ int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops,
 		}
 	}
 #endif
-        if (ldt != NULL) {
-                type->typ_lu = ldt;
-                rc = lu_device_type_init(ldt);
-                if (rc != 0)
-                        GOTO (failed, rc);
-        }
+	type->typ_debugfs_entry = ldebugfs_register(name, debugfs_lustre_root,
+						    vars, type);
+	if (IS_ERR_OR_NULL(type->typ_debugfs_entry)) {
+		rc = type->typ_debugfs_entry ? PTR_ERR(type->typ_debugfs_entry)
+					     : -ENOMEM;
+		type->typ_debugfs_entry = NULL;
+		GOTO(failed, rc);
+	}
 
-	spin_lock(&obd_types_lock);
-	list_add(&type->typ_chain, &obd_types);
-	spin_unlock(&obd_types_lock);
+	rc = kobject_add(&type->typ_kobj, &lustre_kset->kobj, "%s", name);
+	if (rc)
+		GOTO(failed, rc);
+#ifdef HAVE_SERVER_SUPPORT
+setup_ldt:
+#endif
+	if (ldt) {
+		type->typ_lu = ldt;
+		rc = lu_device_type_init(ldt);
+		if (rc)
+			GOTO(failed, rc);
+	}
 
-        RETURN (0);
+	RETURN(0);
 
 failed:
-	if (type->typ_name != NULL) {
-#ifdef CONFIG_PROC_FS
-		if (type->typ_procroot != NULL)
-			remove_proc_subtree(type->typ_name, proc_lustre_root);
-#endif
-                OBD_FREE(type->typ_name, strlen(name) + 1);
-	}
-        if (type->typ_md_ops != NULL)
-                OBD_FREE_PTR(type->typ_md_ops);
-        if (type->typ_dt_ops != NULL)
-                OBD_FREE_PTR(type->typ_dt_ops);
-        OBD_FREE(type, sizeof(*type));
-        RETURN(rc);
+	kobject_put(&type->typ_kobj);
+
+	RETURN(rc);
 }
 EXPORT_SYMBOL(class_register_type);
 
 int class_unregister_type(const char *name)
 {
         struct obd_type *type = class_search_type(name);
+	int rc = 0;
         ENTRY;
 
         if (!type) {
@@ -253,59 +338,43 @@ int class_unregister_type(const char *name)
                 RETURN(-EINVAL);
         }
 
-        if (type->typ_refcnt) {
-                CERROR("type %s has refcount (%d)\n", name, type->typ_refcnt);
+	if (atomic_read(&type->typ_refcnt)) {
+		CERROR("type %s has refcount (%d)\n", name,
+		       atomic_read(&type->typ_refcnt));
                 /* This is a bad situation, let's make the best of it */
                 /* Remove ops, but leave the name for debugging */
                 OBD_FREE_PTR(type->typ_dt_ops);
                 OBD_FREE_PTR(type->typ_md_ops);
-                RETURN(-EBUSY);
+		GOTO(out_put, rc = -EBUSY);
         }
 
-	/* we do not use type->typ_procroot as for compatibility purposes
-	 * other modules can share names (i.e. lod can use lov entry). so
-	 * we can't reference pointer as it can get invalided when another
-	 * module removes the entry */
-#ifdef CONFIG_PROC_FS
-	if (type->typ_procroot != NULL)
-		remove_proc_subtree(type->typ_name, proc_lustre_root);
-	if (type->typ_procsym != NULL)
-		lprocfs_remove(&type->typ_procsym);
-#endif
-        if (type->typ_lu)
-                lu_device_type_fini(type->typ_lu);
-
-	spin_lock(&obd_types_lock);
-	list_del(&type->typ_chain);
-	spin_unlock(&obd_types_lock);
-        OBD_FREE(type->typ_name, strlen(name) + 1);
-        if (type->typ_dt_ops != NULL)
-                OBD_FREE_PTR(type->typ_dt_ops);
-        if (type->typ_md_ops != NULL)
-                OBD_FREE_PTR(type->typ_md_ops);
-        OBD_FREE(type, sizeof(*type));
-        RETURN(0);
+	/* Put the final ref */
+	kobject_put(&type->typ_kobj);
+out_put:
+	/* Put the ref returned by class_search_type() */
+	kobject_put(&type->typ_kobj);
+
+	RETURN(rc);
 } /* class_unregister_type */
 EXPORT_SYMBOL(class_unregister_type);
 
 /**
  * Create a new obd device.
  *
- * Find an empty slot in ::obd_devs[], create a new obd device in it.
+ * Allocate the new obd_device and initialize it.
  *
  * \param[in] type_name obd device type string.
  * \param[in] name      obd device name.
+ * \param[in] uuid      obd device UUID
  *
- * \retval NULL if create fails, otherwise return the obd device
- *         pointer created.
+ * \retval newdev         pointer to created obd_device
+ * \retval ERR_PTR(errno) on error
  */
-struct obd_device *class_newdev(const char *type_name, const char *name)
+struct obd_device *class_newdev(const char *type_name, const char *name,
+				const char *uuid)
 {
-        struct obd_device *result = NULL;
         struct obd_device *newdev;
         struct obd_type *type = NULL;
-        int i;
-        int new_obd_minor = 0;
         ENTRY;
 
         if (strlen(name) >= MAX_OBD_NAME) {
@@ -320,93 +389,197 @@ struct obd_device *class_newdev(const char *type_name, const char *name)
         }
 
         newdev = obd_device_alloc();
-	if (newdev == NULL)
-		GOTO(out_type, result = ERR_PTR(-ENOMEM));
-
+	if (newdev == NULL) {
+		class_put_type(type);
+		RETURN(ERR_PTR(-ENOMEM));
+	}
         LASSERT(newdev->obd_magic == OBD_DEVICE_MAGIC);
+	strncpy(newdev->obd_name, name, sizeof(newdev->obd_name) - 1);
+	newdev->obd_type = type;
+	newdev->obd_minor = -1;
+
+	rwlock_init(&newdev->obd_pool_lock);
+	newdev->obd_pool_limit = 0;
+	newdev->obd_pool_slv = 0;
+
+	INIT_LIST_HEAD(&newdev->obd_exports);
+	INIT_LIST_HEAD(&newdev->obd_unlinked_exports);
+	INIT_LIST_HEAD(&newdev->obd_delayed_exports);
+	INIT_LIST_HEAD(&newdev->obd_exports_timed);
+	INIT_LIST_HEAD(&newdev->obd_nid_stats);
+	spin_lock_init(&newdev->obd_nid_lock);
+	spin_lock_init(&newdev->obd_dev_lock);
+	mutex_init(&newdev->obd_dev_mutex);
+	spin_lock_init(&newdev->obd_osfs_lock);
+	/* newdev->obd_osfs_age must be set to a value in the distant
+	 * past to guarantee a fresh statfs is fetched on mount. */
+	newdev->obd_osfs_age = ktime_get_seconds() - 1000;
+
+	/* XXX belongs in setup not attach  */
+	init_rwsem(&newdev->obd_observer_link_sem);
+	/* recovery data */
+	spin_lock_init(&newdev->obd_recovery_task_lock);
+	init_waitqueue_head(&newdev->obd_next_transno_waitq);
+	init_waitqueue_head(&newdev->obd_evict_inprogress_waitq);
+	INIT_LIST_HEAD(&newdev->obd_req_replay_queue);
+	INIT_LIST_HEAD(&newdev->obd_lock_replay_queue);
+	INIT_LIST_HEAD(&newdev->obd_final_req_queue);
+	INIT_LIST_HEAD(&newdev->obd_evict_list);
+	INIT_LIST_HEAD(&newdev->obd_lwp_list);
+
+	llog_group_init(&newdev->obd_olg);
+	/* Detach drops this */
+	atomic_set(&newdev->obd_refcount, 1);
+	lu_ref_init(&newdev->obd_reference);
+	lu_ref_add(&newdev->obd_reference, "newdev", newdev);
+
+	newdev->obd_conn_inprogress = 0;
+
+	strncpy(newdev->obd_uuid.uuid, uuid, UUID_MAX);
+
+	CDEBUG(D_IOCTL, "Allocate new device %s (%p)\n",
+	       newdev->obd_name, newdev);
+
+	return newdev;
+}
 
-	write_lock(&obd_dev_lock);
-        for (i = 0; i < class_devno_max(); i++) {
-                struct obd_device *obd = class_num2obd(i);
+/**
+ * Free obd device.
+ *
+ * \param[in] obd obd_device to be freed
+ *
+ * \retval none
+ */
+void class_free_dev(struct obd_device *obd)
+{
+	struct obd_type *obd_type = obd->obd_type;
 
-		if (obd && (strcmp(name, obd->obd_name) == 0)) {
-                        CERROR("Device %s already exists at %d, won't add\n",
-                               name, i);
-                        if (result) {
-                                LASSERTF(result->obd_magic == OBD_DEVICE_MAGIC,
-                                         "%p obd_magic %08x != %08x\n", result,
-                                         result->obd_magic, OBD_DEVICE_MAGIC);
-                                LASSERTF(result->obd_minor == new_obd_minor,
-                                         "%p obd_minor %d != %d\n", result,
-                                         result->obd_minor, new_obd_minor);
-
-                                obd_devs[result->obd_minor] = NULL;
-                                result->obd_name[0]='\0';
-                         }
-                        result = ERR_PTR(-EEXIST);
-                        break;
-                }
-                if (!result && !obd) {
-                        result = newdev;
-                        result->obd_minor = i;
-                        new_obd_minor = i;
-                        result->obd_type = type;
-                        strncpy(result->obd_name, name,
-                                sizeof(result->obd_name) - 1);
-                        obd_devs[i] = result;
-                }
-        }
-	write_unlock(&obd_dev_lock);
+	LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC, "%p obd_magic %08x "
+		 "!= %08x\n", obd, obd->obd_magic, OBD_DEVICE_MAGIC);
+	LASSERTF(obd->obd_minor == -1 || obd_devs[obd->obd_minor] == obd,
+		 "obd %p != obd_devs[%d] %p\n",
+		 obd, obd->obd_minor, obd_devs[obd->obd_minor]);
+	LASSERTF(atomic_read(&obd->obd_refcount) == 0,
+		 "obd_refcount should be 0, not %d\n",
+		 atomic_read(&obd->obd_refcount));
+	LASSERT(obd_type != NULL);
 
-        if (result == NULL && i >= class_devno_max()) {
-                CERROR("all %u OBD devices used, increase MAX_OBD_DEVICES\n",
-                       class_devno_max());
-		GOTO(out, result = ERR_PTR(-EOVERFLOW));
-        }
+	CDEBUG(D_INFO, "Release obd device %s obd_type name = %s\n",
+	       obd->obd_name, obd->obd_type->typ_name);
 
-	if (IS_ERR(result))
-		GOTO(out, result);
+	CDEBUG(D_CONFIG, "finishing cleanup of obd %s (%s)\n",
+			 obd->obd_name, obd->obd_uuid.uuid);
+	if (obd->obd_stopping) {
+		int err;
 
-	CDEBUG(D_IOCTL, "Adding new device %s (%p)\n",
-	       result->obd_name, result);
+		/* If we're not stopping, we were never set up */
+		err = obd_cleanup(obd);
+		if (err)
+			CERROR("Cleanup %s returned %d\n",
+				obd->obd_name, err);
+	}
 
-	RETURN(result);
-out:
-	obd_device_free(newdev);
-out_type:
-	class_put_type(type);
-	return result;
+	obd_device_free(obd);
+
+	class_put_type(obd_type);
 }
 
-void class_release_dev(struct obd_device *obd)
+/**
+ * Unregister obd device.
+ *
+ * Free slot in obd_dev[] used by \a obd.
+ *
+ * \param[in] new_obd obd_device to be unregistered
+ *
+ * \retval none
+ */
+void class_unregister_device(struct obd_device *obd)
 {
-        struct obd_type *obd_type = obd->obd_type;
-
-        LASSERTF(obd->obd_magic == OBD_DEVICE_MAGIC, "%p obd_magic %08x != %08x\n",
-                 obd, obd->obd_magic, OBD_DEVICE_MAGIC);
-        LASSERTF(obd == obd_devs[obd->obd_minor], "obd %p != obd_devs[%d] %p\n",
-                 obd, obd->obd_minor, obd_devs[obd->obd_minor]);
-        LASSERT(obd_type != NULL);
+	write_lock(&obd_dev_lock);
+	if (obd->obd_minor >= 0) {
+		LASSERT(obd_devs[obd->obd_minor] == obd);
+		obd_devs[obd->obd_minor] = NULL;
+		obd->obd_minor = -1;
+	}
+	write_unlock(&obd_dev_lock);
+}
 
-        CDEBUG(D_INFO, "Release obd device %s at %d obd_type name =%s\n",
-               obd->obd_name, obd->obd_minor, obd->obd_type->typ_name);
+/**
+ * Register obd device.
+ *
+ * Find free slot in obd_devs[], fills it with \a new_obd.
+ *
+ * \param[in] new_obd obd_device to be registered
+ *
+ * \retval 0          success
+ * \retval -EEXIST    device with this name is registered
+ * \retval -EOVERFLOW obd_devs[] is full
+ */
+int class_register_device(struct obd_device *new_obd)
+{
+	int ret = 0;
+	int i;
+	int new_obd_minor = 0;
+	bool minor_assign = false;
+	bool retried = false;
 
+again:
 	write_lock(&obd_dev_lock);
-        obd_devs[obd->obd_minor] = NULL;
+	for (i = 0; i < class_devno_max(); i++) {
+		struct obd_device *obd = class_num2obd(i);
+
+		if (obd != NULL &&
+		    (strcmp(new_obd->obd_name, obd->obd_name) == 0)) {
+
+			if (!retried) {
+				write_unlock(&obd_dev_lock);
+
+				/* the obd_device could be waited to be
+ 				 * destroyed by the "obd_zombie_impexp_thread".
+ 				 */
+				obd_zombie_barrier();
+				retried = true;
+				goto again;
+			}
+
+			CERROR("%s: already exists, won't add\n",
+			       obd->obd_name);
+			/* in case we found a free slot before duplicate */
+			minor_assign = false;
+			ret = -EEXIST;
+			break;
+		}
+		if (!minor_assign && obd == NULL) {
+			new_obd_minor = i;
+			minor_assign = true;
+		}
+	}
+
+	if (minor_assign) {
+		new_obd->obd_minor = new_obd_minor;
+		LASSERTF(obd_devs[new_obd_minor] == NULL, "obd_devs[%d] "
+			 "%p\n", new_obd_minor, obd_devs[new_obd_minor]);
+		obd_devs[new_obd_minor] = new_obd;
+	} else {
+		if (ret == 0) {
+			ret = -EOVERFLOW;
+			CERROR("%s: all %u/%u devices used, increase "
+			       "MAX_OBD_DEVICES: rc = %d\n", new_obd->obd_name,
+			       i, class_devno_max(), ret);
+		}
+	}
 	write_unlock(&obd_dev_lock);
-        obd_device_free(obd);
 
-        class_put_type(obd_type);
+	RETURN(ret);
 }
 
-int class_name2dev(const char *name)
+static int class_name2dev_nolock(const char *name)
 {
         int i;
 
         if (!name)
                 return -1;
 
-	read_lock(&obd_dev_lock);
         for (i = 0; i < class_devno_max(); i++) {
                 struct obd_device *obd = class_num2obd(i);
 
@@ -415,17 +588,30 @@ int class_name2dev(const char *name)
                            out any references */
                         LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
                         if (obd->obd_attached) {
-				read_unlock(&obd_dev_lock);
                                 return i;
                         }
                         break;
                 }
         }
-	read_unlock(&obd_dev_lock);
 
         return -1;
 }
 
+int class_name2dev(const char *name)
+{
+	int i;
+
+	if (!name)
+		return -1;
+
+	read_lock(&obd_dev_lock);
+	i = class_name2dev_nolock(name);
+	read_unlock(&obd_dev_lock);
+
+	return i;
+}
+EXPORT_SYMBOL(class_name2dev);
+
 struct obd_device *class_name2obd(const char *name)
 {
         int dev = class_name2dev(name);
@@ -436,25 +622,34 @@ struct obd_device *class_name2obd(const char *name)
 }
 EXPORT_SYMBOL(class_name2obd);
 
-int class_uuid2dev(struct obd_uuid *uuid)
+int class_uuid2dev_nolock(struct obd_uuid *uuid)
 {
         int i;
 
-	read_lock(&obd_dev_lock);
         for (i = 0; i < class_devno_max(); i++) {
                 struct obd_device *obd = class_num2obd(i);
 
                 if (obd && obd_uuid_equals(uuid, &obd->obd_uuid)) {
                         LASSERT(obd->obd_magic == OBD_DEVICE_MAGIC);
-			read_unlock(&obd_dev_lock);
                         return i;
                 }
         }
-	read_unlock(&obd_dev_lock);
 
         return -1;
 }
 
+int class_uuid2dev(struct obd_uuid *uuid)
+{
+	int i;
+
+	read_lock(&obd_dev_lock);
+	i = class_uuid2dev_nolock(uuid);
+	read_unlock(&obd_dev_lock);
+
+	return i;
+}
+EXPORT_SYMBOL(class_uuid2dev);
+
 struct obd_device *class_uuid2obd(struct obd_uuid *uuid)
 {
         int dev = class_uuid2dev(uuid);
@@ -493,6 +688,40 @@ struct obd_device *class_num2obd(int num)
 }
 
 /**
+ * Find obd in obd_dev[] by name or uuid.
+ *
+ * Increment obd's refcount if found.
+ *
+ * \param[in] str obd name or uuid
+ *
+ * \retval NULL    if not found
+ * \retval target  pointer to found obd_device
+ */
+struct obd_device *class_dev_by_str(const char *str)
+{
+	struct obd_device *target = NULL;
+	struct obd_uuid tgtuuid;
+	int rc;
+
+	obd_str2uuid(&tgtuuid, str);
+
+	read_lock(&obd_dev_lock);
+	rc = class_uuid2dev_nolock(&tgtuuid);
+	if (rc < 0)
+		rc = class_name2dev_nolock(str);
+
+	if (rc >= 0)
+		target = class_num2obd(rc);
+
+	if (target != NULL)
+		class_incref(target, "find", current);
+	read_unlock(&obd_dev_lock);
+
+	RETURN(target);
+}
+EXPORT_SYMBOL(class_dev_by_str);
+
+/**
  * Get obd devices count. Device in any
  *    state are counted
  * \retval obd device count
@@ -538,14 +767,13 @@ void class_obd_list(void)
 			 atomic_read(&obd->obd_refcount));
         }
 	read_unlock(&obd_dev_lock);
-        return;
 }
 
 /* Search for a client OBD connected to tgt_uuid.  If grp_uuid is
    specified, then only the client with that uuid is returned,
    otherwise any client connected to the tgt is returned. */
 struct obd_device * class_find_client_obd(struct obd_uuid *tgt_uuid,
-                                          const char * typ_name,
+					  const char *type_name,
                                           struct obd_uuid *grp_uuid)
 {
         int i;
@@ -556,8 +784,8 @@ struct obd_device * class_find_client_obd(struct obd_uuid *tgt_uuid,
 
                 if (obd == NULL)
                         continue;
-                if ((strncmp(obd->obd_type->typ_name, typ_name,
-                             strlen(typ_name)) == 0)) {
+		if ((strncmp(obd->obd_type->typ_name, type_name,
+			     strlen(type_name)) == 0)) {
                         if (obd_uuid_equals(tgt_uuid,
                                             &obd->u.cli.cl_target_uuid) &&
                             ((grp_uuid)? obd_uuid_equals(grp_uuid,
@@ -661,14 +889,6 @@ void obd_cleanup_caches(void)
 		kmem_cache_destroy(obd_device_cachep);
                 obd_device_cachep = NULL;
         }
-        if (obdo_cachep) {
-		kmem_cache_destroy(obdo_cachep);
-                obdo_cachep = NULL;
-        }
-        if (import_cachep) {
-		kmem_cache_destroy(import_cachep);
-                import_cachep = NULL;
-        }
 
         EXIT;
 }
@@ -679,31 +899,20 @@ int obd_init_caches(void)
 	ENTRY;
 
 	LASSERT(obd_device_cachep == NULL);
-	obd_device_cachep = kmem_cache_create("ll_obd_dev_cache",
-					      sizeof(struct obd_device),
-					      0, 0, NULL);
+	obd_device_cachep = kmem_cache_create_usercopy("ll_obd_dev_cache",
+				sizeof(struct obd_device),
+				0, 0, 0, sizeof(struct obd_device), NULL);
 	if (!obd_device_cachep)
 		GOTO(out, rc = -ENOMEM);
 
-	LASSERT(obdo_cachep == NULL);
-	obdo_cachep = kmem_cache_create("ll_obdo_cache", sizeof(struct obdo),
-					0, 0, NULL);
-	if (!obdo_cachep)
-		GOTO(out, rc = -ENOMEM);
-
-	LASSERT(import_cachep == NULL);
-	import_cachep = kmem_cache_create("ll_import_cache",
-					  sizeof(struct obd_import),
-					  0, 0, NULL);
-	if (!import_cachep)
-		GOTO(out, rc = -ENOMEM);
-
 	RETURN(0);
 out:
 	obd_cleanup_caches();
 	RETURN(rc);
 }
 
+static struct portals_handle_ops export_handle_ops;
+
 /* map connection to client */
 struct obd_export *class_conn2export(struct lustre_handle *conn)
 {
@@ -720,8 +929,8 @@ struct obd_export *class_conn2export(struct lustre_handle *conn)
                 RETURN(NULL);
         }
 
-        CDEBUG(D_INFO, "looking for export cookie "LPX64"\n", conn->cookie);
-	export = class_handle2object(conn->cookie, NULL);
+	CDEBUG(D_INFO, "looking for export cookie %#llx\n", conn->cookie);
+	export = class_handle2object(conn->cookie, &export_handle_ops);
 	RETURN(export);
 }
 EXPORT_SYMBOL(class_conn2export);
@@ -734,18 +943,6 @@ struct obd_device *class_exp2obd(struct obd_export *exp)
 }
 EXPORT_SYMBOL(class_exp2obd);
 
-struct obd_device *class_conn2obd(struct lustre_handle *conn)
-{
-        struct obd_export *export;
-        export = class_conn2export(conn);
-        if (export) {
-                struct obd_device *obd = export->exp_obd;
-                class_export_put(export);
-                return obd;
-        }
-        return NULL;
-}
-
 struct obd_import *class_exp2cliimp(struct obd_export *exp)
 {
         struct obd_device *obd = exp->exp_obd;
@@ -755,21 +952,13 @@ struct obd_import *class_exp2cliimp(struct obd_export *exp)
 }
 EXPORT_SYMBOL(class_exp2cliimp);
 
-struct obd_import *class_conn2cliimp(struct lustre_handle *conn)
-{
-        struct obd_device *obd = class_conn2obd(conn);
-        if (obd == NULL)
-                return NULL;
-        return obd->u.cli.cl_import;
-}
-
 /* Export management functions */
 static void class_export_destroy(struct obd_export *exp)
 {
         struct obd_device *obd = exp->exp_obd;
         ENTRY;
 
-        LASSERT_ATOMIC_ZERO(&exp->exp_refcount);
+	LASSERT(refcount_read(&exp->exp_handle.h_ref) == 0);
 	LASSERT(obd != NULL);
 
         CDEBUG(D_IOCTL, "destroying export %p/%s for %s\n", exp,
@@ -784,27 +973,25 @@ static void class_export_destroy(struct obd_export *exp)
 	LASSERT(list_empty(&exp->exp_req_replay_queue));
 	LASSERT(list_empty(&exp->exp_hp_rpcs));
         obd_destroy_export(exp);
-        class_decref(obd, "export", exp);
+	/* self export doesn't hold a reference to an obd, although it
+	 * exists until freeing of the obd */
+	if (exp != obd->obd_self_export)
+		class_decref(obd, "export", exp);
 
         OBD_FREE_RCU(exp, sizeof(*exp), &exp->exp_handle);
         EXIT;
 }
 
-static void export_handle_addref(void *export)
-{
-        class_export_get(export);
-}
-
 static struct portals_handle_ops export_handle_ops = {
-	.hop_addref = export_handle_addref,
 	.hop_free   = NULL,
+	.hop_type	= "export",
 };
 
 struct obd_export *class_export_get(struct obd_export *exp)
 {
-	atomic_inc(&exp->exp_refcount);
-        CDEBUG(D_INFO, "GETting export %p : new refcount %d\n", exp,
-	       atomic_read(&exp->exp_refcount));
+	refcount_inc(&exp->exp_handle.h_ref);
+	CDEBUG(D_INFO, "GET export %p refcount=%d\n", exp,
+	       refcount_read(&exp->exp_handle.h_ref));
         return exp;
 }
 EXPORT_SYMBOL(class_export_get);
@@ -812,29 +999,52 @@ EXPORT_SYMBOL(class_export_get);
 void class_export_put(struct obd_export *exp)
 {
         LASSERT(exp != NULL);
-        LASSERT_ATOMIC_GT_LT(&exp->exp_refcount, 0, LI_POISON);
+	LASSERT(refcount_read(&exp->exp_handle.h_ref) >  0);
+	LASSERT(refcount_read(&exp->exp_handle.h_ref) < LI_POISON);
         CDEBUG(D_INFO, "PUTting export %p : new refcount %d\n", exp,
-	       atomic_read(&exp->exp_refcount) - 1);
+	       refcount_read(&exp->exp_handle.h_ref) - 1);
+
+	if (refcount_dec_and_test(&exp->exp_handle.h_ref)) {
+		struct obd_device *obd = exp->exp_obd;
 
-	if (atomic_dec_and_test(&exp->exp_refcount)) {
-		LASSERT(!list_empty(&exp->exp_obd_chain));
-		LASSERT(list_empty(&exp->exp_stale_list));
 		CDEBUG(D_IOCTL, "final put %p/%s\n",
 		       exp, exp->exp_client_uuid.uuid);
 
 		/* release nid stat refererence */
 		lprocfs_exp_cleanup(exp);
 
-		obd_zombie_export_add(exp);
+		if (exp == obd->obd_self_export) {
+			/* self export should be destroyed without
+			 * zombie thread as it doesn't hold a
+			 * reference to obd and doesn't hold any
+			 * resources */
+			class_export_destroy(exp);
+			/* self export is destroyed, no class
+			 * references exist and it is safe to free
+			 * obd */
+			class_free_dev(obd);
+		} else {
+			LASSERT(!list_empty(&exp->exp_obd_chain));
+			obd_zombie_export_add(exp);
+		}
+
 	}
 }
 EXPORT_SYMBOL(class_export_put);
 
+static void obd_zombie_exp_cull(struct work_struct *ws)
+{
+	struct obd_export *export;
+
+	export = container_of(ws, struct obd_export, exp_zombie_work);
+	class_export_destroy(export);
+}
+
 /* Creates a new export, adds it to the hash table, and returns a
  * pointer to it. The refcount is 2: one for the hash reference, and
  * one for the pointer returned by this function. */
-struct obd_export *class_new_export(struct obd_device *obd,
-                                    struct obd_uuid *cluuid)
+struct obd_export *__class_new_export(struct obd_device *obd,
+				      struct obd_uuid *cluuid, bool is_self)
 {
         struct obd_export *export;
 	struct cfs_hash *hash = NULL;
@@ -848,7 +1058,8 @@ struct obd_export *class_new_export(struct obd_device *obd,
         export->exp_conn_cnt = 0;
         export->exp_lock_hash = NULL;
 	export->exp_flock_hash = NULL;
-	atomic_set(&export->exp_refcount, 2);
+	/* 2 = class_handle_hash + last */
+	refcount_set(&export->exp_handle.h_ref, 2);
 	atomic_set(&export->exp_rpc_count, 0);
 	atomic_set(&export->exp_cb_count, 0);
 	atomic_set(&export->exp_locks_count, 0);
@@ -862,11 +1073,11 @@ struct obd_export *class_new_export(struct obd_device *obd,
 	spin_lock_init(&export->exp_uncommitted_replies_lock);
 	INIT_LIST_HEAD(&export->exp_uncommitted_replies);
 	INIT_LIST_HEAD(&export->exp_req_replay_queue);
-	INIT_LIST_HEAD(&export->exp_handle.h_link);
+	INIT_LIST_HEAD_RCU(&export->exp_handle.h_link);
 	INIT_LIST_HEAD(&export->exp_hp_rpcs);
 	INIT_LIST_HEAD(&export->exp_reg_rpcs);
 	class_handle_hash(&export->exp_handle, &export_handle_ops);
-	export->exp_last_request_time = cfs_time_current_sec();
+	export->exp_last_request_time = ktime_get_real_seconds();
 	spin_lock_init(&export->exp_lock);
 	spin_lock_init(&export->exp_rpc_lock);
 	INIT_HLIST_NODE(&export->exp_uuid_hash);
@@ -875,23 +1086,24 @@ struct obd_export *class_new_export(struct obd_device *obd,
 	spin_lock_init(&export->exp_bl_list_lock);
 	INIT_LIST_HEAD(&export->exp_bl_list);
 	INIT_LIST_HEAD(&export->exp_stale_list);
+	INIT_WORK(&export->exp_zombie_work, obd_zombie_exp_cull);
 
 	export->exp_sp_peer = LUSTRE_SP_ANY;
 	export->exp_flvr.sf_rpc = SPTLRPC_FLVR_INVALID;
 	export->exp_client_uuid = *cluuid;
 	obd_init_export(export);
 
-	spin_lock(&obd->obd_dev_lock);
-	/* shouldn't happen, but might race */
-	if (obd->obd_stopping)
-		GOTO(exit_unlock, rc = -ENODEV);
+	if (!obd_uuid_equals(cluuid, &obd->obd_uuid)) {
+		spin_lock(&obd->obd_dev_lock);
+		/* shouldn't happen, but might race */
+		if (obd->obd_stopping)
+			GOTO(exit_unlock, rc = -ENODEV);
 
-	hash = cfs_hash_getref(obd->obd_uuid_hash);
-	if (hash == NULL)
-		GOTO(exit_unlock, rc = -ENODEV);
-	spin_unlock(&obd->obd_dev_lock);
+		hash = cfs_hash_getref(obd->obd_uuid_hash);
+		if (hash == NULL)
+			GOTO(exit_unlock, rc = -ENODEV);
+		spin_unlock(&obd->obd_dev_lock);
 
-        if (!obd_uuid_equals(cluuid, &obd->obd_uuid)) {
                 rc = cfs_hash_add_unique(hash, cluuid, &export->exp_uuid_hash);
                 if (rc != 0) {
                         LCONSOLE_WARN("%s: denying duplicate export for %s, %d\n",
@@ -903,17 +1115,24 @@ struct obd_export *class_new_export(struct obd_device *obd,
 	at_init(&export->exp_bl_lock_at, obd_timeout, 0);
 	spin_lock(&obd->obd_dev_lock);
         if (obd->obd_stopping) {
-                cfs_hash_del(hash, cluuid, &export->exp_uuid_hash);
-                GOTO(exit_unlock, rc = -ENODEV);
+		if (hash)
+			cfs_hash_del(hash, cluuid, &export->exp_uuid_hash);
+		GOTO(exit_unlock, rc = -ESHUTDOWN);
         }
 
-        class_incref(obd, "export", export);
-	list_add(&export->exp_obd_chain, &export->exp_obd->obd_exports);
-	list_add_tail(&export->exp_obd_chain_timed,
-		      &export->exp_obd->obd_exports_timed);
-        export->exp_obd->obd_num_exports++;
+	if (!is_self) {
+		class_incref(obd, "export", export);
+		list_add_tail(&export->exp_obd_chain_timed,
+			      &obd->obd_exports_timed);
+		list_add(&export->exp_obd_chain, &obd->obd_exports);
+		obd->obd_num_exports++;
+	} else {
+		INIT_LIST_HEAD(&export->exp_obd_chain_timed);
+		INIT_LIST_HEAD(&export->exp_obd_chain);
+	}
 	spin_unlock(&obd->obd_dev_lock);
-	cfs_hash_putref(hash);
+	if (hash)
+		cfs_hash_putref(hash);
 	RETURN(export);
 
 exit_unlock:
@@ -927,12 +1146,29 @@ exit_err:
         OBD_FREE_PTR(export);
         return ERR_PTR(rc);
 }
+
+struct obd_export *class_new_export(struct obd_device *obd,
+				    struct obd_uuid *uuid)
+{
+	return __class_new_export(obd, uuid, false);
+}
 EXPORT_SYMBOL(class_new_export);
 
+struct obd_export *class_new_export_self(struct obd_device *obd,
+					 struct obd_uuid *uuid)
+{
+	return __class_new_export(obd, uuid, true);
+}
+
 void class_unlink_export(struct obd_export *exp)
 {
 	class_handle_unhash(&exp->exp_handle);
 
+	if (exp->exp_obd->obd_self_export == exp) {
+		class_export_put(exp);
+		return;
+	}
+
 	spin_lock(&exp->exp_obd->obd_dev_lock);
 	/* delete an uuid-export hashitem from hashtables */
 	if (!hlist_unhashed(&exp->exp_uuid_hash))
@@ -940,15 +1176,20 @@ void class_unlink_export(struct obd_export *exp)
 			     &exp->exp_client_uuid,
 			     &exp->exp_uuid_hash);
 
+#ifdef HAVE_SERVER_SUPPORT
 	if (!hlist_unhashed(&exp->exp_gen_hash)) {
 		struct tg_export_data	*ted = &exp->exp_target_data;
 		struct cfs_hash		*hash;
 
+		/* Because obd_gen_hash will not be released until
+		 * class_cleanup(), so hash should never be NULL here */
 		hash = cfs_hash_getref(exp->exp_obd->obd_gen_hash);
+		LASSERT(hash != NULL);
 		cfs_hash_del(hash, &ted->ted_lcd->lcd_generation,
 			     &exp->exp_gen_hash);
 		cfs_hash_putref(hash);
 	}
+#endif /* HAVE_SERVER_SUPPORT */
 
 	list_move(&exp->exp_obd_chain, &exp->exp_obd->obd_unlinked_exports);
 	list_del_init(&exp->exp_obd_chain_timed);
@@ -962,7 +1203,7 @@ void class_unlink_export(struct obd_export *exp)
 EXPORT_SYMBOL(class_unlink_export);
 
 /* Import management functions */
-static void class_import_destroy(struct obd_import *imp)
+static void obd_zombie_import_free(struct obd_import *imp)
 {
         ENTRY;
 
@@ -985,20 +1226,10 @@ static void class_import_destroy(struct obd_import *imp)
 
         LASSERT(imp->imp_sec == NULL);
         class_decref(imp->imp_obd, "import", imp);
-        OBD_FREE_RCU(imp, sizeof(*imp), &imp->imp_handle);
-        EXIT;
-}
-
-static void import_handle_addref(void *import)
-{
-        class_import_get(import);
+	OBD_FREE_PTR(imp);
+	EXIT;
 }
 
-static struct portals_handle_ops import_handle_ops = {
-	.hop_addref = import_handle_addref,
-	.hop_free   = NULL,
-};
-
 struct obd_import *class_import_get(struct obd_import *import)
 {
 	atomic_inc(&import->imp_refcount);
@@ -1013,7 +1244,6 @@ void class_import_put(struct obd_import *imp)
 {
 	ENTRY;
 
-	LASSERT(list_empty(&imp->imp_zombie_chain));
         LASSERT_ATOMIC_GT_LT(&imp->imp_refcount, 0, LI_POISON);
 
         CDEBUG(D_INFO, "import %p refcount=%d obd=%s\n", imp,
@@ -1043,16 +1273,24 @@ static void init_imp_at(struct imp_at *at) {
         }
 }
 
+static void obd_zombie_imp_cull(struct work_struct *ws)
+{
+	struct obd_import *import;
+
+	import = container_of(ws, struct obd_import, imp_zombie_work);
+	obd_zombie_import_free(import);
+}
+
 struct obd_import *class_new_import(struct obd_device *obd)
 {
 	struct obd_import *imp;
+	struct pid_namespace *curr_pid_ns = ll_task_pid_ns(current);
 
 	OBD_ALLOC(imp, sizeof(*imp));
 	if (imp == NULL)
 		return NULL;
 
 	INIT_LIST_HEAD(&imp->imp_pinger_chain);
-	INIT_LIST_HEAD(&imp->imp_zombie_chain);
 	INIT_LIST_HEAD(&imp->imp_replay_list);
 	INIT_LIST_HEAD(&imp->imp_sending_list);
 	INIT_LIST_HEAD(&imp->imp_delayed_list);
@@ -1064,8 +1302,14 @@ struct obd_import *class_new_import(struct obd_device *obd)
 	imp->imp_last_success_conn = 0;
 	imp->imp_state = LUSTRE_IMP_NEW;
 	imp->imp_obd = class_incref(obd, "import", imp);
-	mutex_init(&imp->imp_sec_mutex);
+	rwlock_init(&imp->imp_sec_lock);
 	init_waitqueue_head(&imp->imp_recovery_waitq);
+	INIT_WORK(&imp->imp_zombie_work, obd_zombie_imp_cull);
+
+	if (curr_pid_ns->child_reaper)
+		imp->imp_sec_refpid = curr_pid_ns->child_reaper->pid;
+	else
+		imp->imp_sec_refpid = 1;
 
 	atomic_set(&imp->imp_refcount, 2);
 	atomic_set(&imp->imp_unregistering, 0);
@@ -1073,8 +1317,6 @@ struct obd_import *class_new_import(struct obd_device *obd)
 	atomic_set(&imp->imp_replay_inflight, 0);
 	atomic_set(&imp->imp_inval_count, 0);
 	INIT_LIST_HEAD(&imp->imp_conn_list);
-	INIT_LIST_HEAD(&imp->imp_handle.h_link);
-	class_handle_hash(&imp->imp_handle, &import_handle_ops);
 	init_imp_at(&imp->imp_at);
 
 	/* the default magic is V2, will be used in connect RPC, and
@@ -1090,8 +1332,6 @@ void class_destroy_import(struct obd_import *import)
 	LASSERT(import != NULL);
 	LASSERT(import != LP_POISON);
 
-	class_handle_unhash(&import->imp_handle);
-
 	spin_lock(&import->imp_lock);
 	import->imp_generation++;
 	spin_unlock(&import->imp_lock);
@@ -1120,6 +1360,7 @@ void __class_export_add_lock_ref(struct obd_export *exp, struct ldlm_lock *lock)
                lock, exp, lock->l_exp_refs_nr);
 	spin_unlock(&exp->exp_locks_list_guard);
 }
+EXPORT_SYMBOL(__class_export_add_lock_ref);
 
 void __class_export_del_lock_ref(struct obd_export *exp, struct ldlm_lock *lock)
 {
@@ -1138,6 +1379,7 @@ void __class_export_del_lock_ref(struct obd_export *exp, struct ldlm_lock *lock)
                lock, exp, lock->l_exp_refs_nr);
 	spin_unlock(&exp->exp_locks_list_guard);
 }
+EXPORT_SYMBOL(__class_export_del_lock_ref);
 #endif
 
 /* A connection defines an export context in which preallocation can
@@ -1160,7 +1402,7 @@ int class_connect(struct lustre_handle *conn, struct obd_device *obd,
         conn->cookie = export->exp_handle.h_cookie;
         class_export_put(export);
 
-        CDEBUG(D_IOCTL, "connect: client %s, cookie "LPX64"\n",
+	CDEBUG(D_IOCTL, "connect: client %s, cookie %#llx\n",
                cluuid->uuid, conn->cookie);
         RETURN(0);
 }
@@ -1227,6 +1469,13 @@ int class_disconnect(struct obd_export *export)
 	spin_lock(&export->exp_lock);
 	already_disconnected = export->exp_disconnected;
 	export->exp_disconnected = 1;
+	/*  We hold references of export for uuid hash
+	 *  and nid_hash and export link at least. So
+	 *  it is safe to call cfs_hash_del in there.  */
+	if (!hlist_unhashed(&export->exp_nid_hash))
+		cfs_hash_del(export->exp_obd->obd_nid_hash,
+			     &export->exp_connection->c_peer.nid,
+			     &export->exp_nid_hash);
 	spin_unlock(&export->exp_lock);
 
         /* class_cleanup(), abort_recovery(), and class_fail_export()
@@ -1237,14 +1486,9 @@ int class_disconnect(struct obd_export *export)
                 GOTO(no_disconn, already_disconnected);
         }
 
-        CDEBUG(D_IOCTL, "disconnect: cookie "LPX64"\n",
+	CDEBUG(D_IOCTL, "disconnect: cookie %#llx\n",
                export->exp_handle.h_cookie);
 
-	if (!hlist_unhashed(&export->exp_nid_hash))
-                cfs_hash_del(export->exp_obd->obd_nid_hash,
-                             &export->exp_connection->c_peer.nid,
-                             &export->exp_nid_hash);
-
         class_export_recovery_cleanup(export);
         class_unlink_export(export);
 no_disconn:
@@ -1300,7 +1544,7 @@ static void class_disconnect_export_list(struct list_head *list,
 
                 class_export_get(exp);
                 CDEBUG(D_HA, "%s: disconnecting export at %s (%p), "
-                       "last request at "CFS_TIME_T"\n",
+		       "last request at %lld\n",
                        exp->exp_obd->obd_name, obd_export_nid2str(exp),
                        exp, exp->exp_last_request_time);
                 /* release one export reference anyway */
@@ -1370,13 +1614,12 @@ void class_disconnect_stale_exports(struct obd_device *obd,
 		spin_unlock(&exp->exp_lock);
 
 		list_move(&exp->exp_obd_chain, &work_list);
-                evicted++;
-                CDEBUG(D_HA, "%s: disconnect stale client %s@%s\n",
-                       obd->obd_name, exp->exp_client_uuid.uuid,
-                       exp->exp_connection == NULL ? "<unknown>" :
-                       libcfs_nid2str(exp->exp_connection->c_peer.nid));
-                print_export_data(exp, "EVICTING", 0);
-        }
+		evicted++;
+		CDEBUG(D_HA, "%s: disconnect stale client %s@%s\n",
+		       obd->obd_name, exp->exp_client_uuid.uuid,
+		       obd_export_nid2str(exp));
+		print_export_data(exp, "EVICTING", 0, D_HA);
+	}
 	spin_unlock(&obd->obd_dev_lock);
 
 	if (evicted)
@@ -1427,15 +1670,6 @@ void class_fail_export(struct obd_export *exp)
 }
 EXPORT_SYMBOL(class_fail_export);
 
-char *obd_export_nid2str(struct obd_export *exp)
-{
-        if (exp->exp_connection != NULL)
-                return libcfs_nid2str(exp->exp_connection->c_peer.nid);
-
-        return "(no nid)";
-}
-EXPORT_SYMBOL(obd_export_nid2str);
-
 int obd_export_evict_by_nid(struct obd_device *obd, const char *nid)
 {
 	struct cfs_hash *nid_hash;
@@ -1526,10 +1760,11 @@ int obd_export_evict_by_uuid(struct obd_device *obd, const char *uuid)
 
 #if LUSTRE_TRACKS_LOCK_EXP_REFS
 void (*class_export_dump_hook)(struct obd_export*) = NULL;
+EXPORT_SYMBOL(class_export_dump_hook);
 #endif
 
 static void print_export_data(struct obd_export *exp, const char *status,
-			      int locks)
+			      int locks, int debug_level)
 {
 	struct ptlrpc_reply_state *rs;
 	struct ptlrpc_reply_state *first_reply = NULL;
@@ -1544,37 +1779,35 @@ static void print_export_data(struct obd_export *exp, const char *status,
 	}
 	spin_unlock(&exp->exp_lock);
 
-        CDEBUG(D_HA, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: %p %s "LPU64"\n",
-               exp->exp_obd->obd_name, status, exp, exp->exp_client_uuid.uuid,
-	       obd_export_nid2str(exp), atomic_read(&exp->exp_refcount),
+	CDEBUG(debug_level, "%s: %s %p %s %s %d (%d %d %d) %d %d %d %d: "
+	       "%p %s %llu stale:%d\n",
+	       exp->exp_obd->obd_name, status, exp, exp->exp_client_uuid.uuid,
+	       obd_export_nid2str(exp),
+	       refcount_read(&exp->exp_handle.h_ref),
 	       atomic_read(&exp->exp_rpc_count),
 	       atomic_read(&exp->exp_cb_count),
 	       atomic_read(&exp->exp_locks_count),
-               exp->exp_disconnected, exp->exp_delayed, exp->exp_failed,
-               nreplies, first_reply, nreplies > 3 ? "..." : "",
-               exp->exp_last_committed);
+	       exp->exp_disconnected, exp->exp_delayed, exp->exp_failed,
+	       nreplies, first_reply, nreplies > 3 ? "..." : "",
+	       exp->exp_last_committed, !list_empty(&exp->exp_stale_list));
 #if LUSTRE_TRACKS_LOCK_EXP_REFS
-        if (locks && class_export_dump_hook != NULL)
-                class_export_dump_hook(exp);
+	if (locks && class_export_dump_hook != NULL)
+		class_export_dump_hook(exp);
 #endif
 }
 
-void dump_exports(struct obd_device *obd, int locks)
+void dump_exports(struct obd_device *obd, int locks, int debug_level)
 {
         struct obd_export *exp;
 
 	spin_lock(&obd->obd_dev_lock);
 	list_for_each_entry(exp, &obd->obd_exports, exp_obd_chain)
-		print_export_data(exp, "ACTIVE", locks);
+		print_export_data(exp, "ACTIVE", locks, debug_level);
 	list_for_each_entry(exp, &obd->obd_unlinked_exports, exp_obd_chain)
-		print_export_data(exp, "UNLINKED", locks);
+		print_export_data(exp, "UNLINKED", locks, debug_level);
 	list_for_each_entry(exp, &obd->obd_delayed_exports, exp_obd_chain)
-		print_export_data(exp, "DELAYED", locks);
+		print_export_data(exp, "DELAYED", locks, debug_level);
 	spin_unlock(&obd->obd_dev_lock);
-	spin_lock(&obd_zombie_impexp_lock);
-	list_for_each_entry(exp, &obd_zombie_exports, exp_obd_chain)
-		print_export_data(exp, "ZOMBIE", locks);
-	spin_unlock(&obd_zombie_impexp_lock);
 }
 
 void obd_exports_barrier(struct obd_device *obd)
@@ -1586,13 +1819,13 @@ void obd_exports_barrier(struct obd_device *obd)
 		spin_unlock(&obd->obd_dev_lock);
 		set_current_state(TASK_UNINTERRUPTIBLE);
 		schedule_timeout(cfs_time_seconds(waited));
-		if (waited > 5 && IS_PO2(waited)) {
+		if (waited > 5 && is_power_of_2(waited)) {
 			LCONSOLE_WARN("%s is waiting for obd_unlinked_exports "
 				      "more than %d seconds. "
 				      "The obd refcount = %d. Is it stuck?\n",
 				      obd->obd_name, waited,
 				      atomic_read(&obd->obd_refcount));
-			dump_exports(obd, 1);
+			dump_exports(obd, 1, D_CONSOLE | D_WARNING);
 		}
 		waited *= 2;
 		spin_lock(&obd->obd_dev_lock);
@@ -1601,83 +1834,6 @@ void obd_exports_barrier(struct obd_device *obd)
 }
 EXPORT_SYMBOL(obd_exports_barrier);
 
-/* Total amount of zombies to be destroyed */
-static int zombies_count = 0;
-
-/**
- * kill zombie imports and exports
- */
-void obd_zombie_impexp_cull(void)
-{
-	struct obd_import *import;
-	struct obd_export *export;
-	ENTRY;
-
-	do {
-		spin_lock(&obd_zombie_impexp_lock);
-
-		import = NULL;
-		if (!list_empty(&obd_zombie_imports)) {
-			import = list_entry(obd_zombie_imports.next,
-					    struct obd_import,
-					    imp_zombie_chain);
-			list_del_init(&import->imp_zombie_chain);
-		}
-
-		export = NULL;
-		if (!list_empty(&obd_zombie_exports)) {
-			export = list_entry(obd_zombie_exports.next,
-					    struct obd_export,
-					    exp_obd_chain);
-			list_del_init(&export->exp_obd_chain);
-		}
-
-		spin_unlock(&obd_zombie_impexp_lock);
-
-		if (import != NULL) {
-			class_import_destroy(import);
-			spin_lock(&obd_zombie_impexp_lock);
-			zombies_count--;
-			spin_unlock(&obd_zombie_impexp_lock);
-		}
-
-		if (export != NULL) {
-			class_export_destroy(export);
-			spin_lock(&obd_zombie_impexp_lock);
-			zombies_count--;
-			spin_unlock(&obd_zombie_impexp_lock);
-		}
-
-		cond_resched();
-	} while (import != NULL || export != NULL);
-	EXIT;
-}
-
-static struct completion	obd_zombie_start;
-static struct completion	obd_zombie_stop;
-static unsigned long		obd_zombie_flags;
-static wait_queue_head_t	obd_zombie_waitq;
-static pid_t			obd_zombie_pid;
-
-enum {
-	OBD_ZOMBIE_STOP		= 0x0001,
-};
-
-/**
- * check for work for kill zombie import/export thread.
- */
-static int obd_zombie_impexp_check(void *arg)
-{
-	int rc;
-
-	spin_lock(&obd_zombie_impexp_lock);
-	rc = (zombies_count == 0) &&
-	     !test_bit(OBD_ZOMBIE_STOP, &obd_zombie_flags);
-	spin_unlock(&obd_zombie_impexp_lock);
-
-	RETURN(rc);
-}
-
 /**
  * Add export to the obd_zombe thread and notify it.
  */
@@ -1687,12 +1843,8 @@ static void obd_zombie_export_add(struct obd_export *exp) {
 	LASSERT(!list_empty(&exp->exp_obd_chain));
 	list_del_init(&exp->exp_obd_chain);
 	spin_unlock(&exp->exp_obd->obd_dev_lock);
-	spin_lock(&obd_zombie_impexp_lock);
-	zombies_count++;
-	list_add(&exp->exp_obd_chain, &obd_zombie_exports);
-	spin_unlock(&obd_zombie_impexp_lock);
 
-	obd_zombie_impexp_notify();
+	queue_work(zombie_wq, &exp->exp_zombie_work);
 }
 
 /**
@@ -1700,40 +1852,8 @@ static void obd_zombie_export_add(struct obd_export *exp) {
  */
 static void obd_zombie_import_add(struct obd_import *imp) {
 	LASSERT(imp->imp_sec == NULL);
-	spin_lock(&obd_zombie_impexp_lock);
-	LASSERT(list_empty(&imp->imp_zombie_chain));
-	zombies_count++;
-	list_add(&imp->imp_zombie_chain, &obd_zombie_imports);
-	spin_unlock(&obd_zombie_impexp_lock);
-
-	obd_zombie_impexp_notify();
-}
 
-/**
- * notify import/export destroy thread about new zombie.
- */
-static void obd_zombie_impexp_notify(void)
-{
-	/*
-	 * Make sure obd_zomebie_impexp_thread get this notification.
-	 * It is possible this signal only get by obd_zombie_barrier, and
-	 * barrier gulps this notification and sleeps away and hangs ensues
-	 */
-	wake_up_all(&obd_zombie_waitq);
-}
-
-/**
- * check whether obd_zombie is idle
- */
-static int obd_zombie_is_idle(void)
-{
-	int rc;
-
-	LASSERT(!test_bit(OBD_ZOMBIE_STOP, &obd_zombie_flags));
-	spin_lock(&obd_zombie_impexp_lock);
-	rc = (zombies_count == 0);
-	spin_unlock(&obd_zombie_impexp_lock);
-	return rc;
+	queue_work(zombie_wq, &imp->imp_zombie_work);
 }
 
 /**
@@ -1741,12 +1861,7 @@ static int obd_zombie_is_idle(void)
  */
 void obd_zombie_barrier(void)
 {
-	struct l_wait_info lwi = { 0 };
-
-	if (obd_zombie_pid == current_pid())
-		/* don't wait for myself */
-		return;
-	l_wait_event(obd_zombie_waitq, obd_zombie_is_idle(), &lwi);
+	flush_workqueue(zombie_wq);
 }
 EXPORT_SYMBOL(obd_zombie_barrier);
 
@@ -1822,66 +1937,24 @@ void obd_stale_export_adjust(struct obd_export *exp)
 EXPORT_SYMBOL(obd_stale_export_adjust);
 
 /**
- * destroy zombie export/import thread.
- */
-static int obd_zombie_impexp_thread(void *unused)
-{
-	unshare_fs_struct();
-	complete(&obd_zombie_start);
-
-	obd_zombie_pid = current_pid();
-
-	while (!test_bit(OBD_ZOMBIE_STOP, &obd_zombie_flags)) {
-		struct l_wait_info lwi = { 0 };
-
-		l_wait_event(obd_zombie_waitq,
-			     !obd_zombie_impexp_check(NULL), &lwi);
-		obd_zombie_impexp_cull();
-
-		/*
-		 * Notify obd_zombie_barrier callers that queues
-		 * may be empty.
-		 */
-		wake_up(&obd_zombie_waitq);
-	}
-
-	complete(&obd_zombie_stop);
-
-	RETURN(0);
-}
-
-
-/**
  * start destroy zombie import/export thread
  */
 int obd_zombie_impexp_init(void)
 {
-	struct task_struct *task;
-
-	INIT_LIST_HEAD(&obd_zombie_imports);
-
-	INIT_LIST_HEAD(&obd_zombie_exports);
-	spin_lock_init(&obd_zombie_impexp_lock);
-	init_completion(&obd_zombie_start);
-	init_completion(&obd_zombie_stop);
-	init_waitqueue_head(&obd_zombie_waitq);
-	obd_zombie_pid = 0;
+	zombie_wq = alloc_workqueue("obd_zombid", 0, 0);
+	if (!zombie_wq)
+		return -ENOMEM;
 
-	task = kthread_run(obd_zombie_impexp_thread, NULL, "obd_zombid");
-	if (IS_ERR(task))
-		RETURN(PTR_ERR(task));
-
-	wait_for_completion(&obd_zombie_start);
-	RETURN(0);
+	return 0;
 }
+
 /**
  * stop destroy zombie import/export thread
  */
 void obd_zombie_impexp_stop(void)
 {
-	set_bit(OBD_ZOMBIE_STOP, &obd_zombie_flags);
-        obd_zombie_impexp_notify();
-	wait_for_completion(&obd_zombie_stop);
+	destroy_workqueue(zombie_wq);
+	LASSERT(list_empty(&obd_stale_exports));
 }
 
 /***** Kernel-userspace comm helpers *******/
@@ -1905,21 +1978,6 @@ struct kuc_hdr * kuc_ptr(void *p)
 }
 EXPORT_SYMBOL(kuc_ptr);
 
-/* Test if payload is part of kuc message
- * @param p Pointer to payload area
- * @returns boolean
- */
-int kuc_ispayload(void *p)
-{
-        struct kuc_hdr *kh = ((struct kuc_hdr *)p) - 1;
-
-        if (kh->kuc_magic == KUC_MAGIC)
-                return 1;
-        else
-                return 0;
-}
-EXPORT_SYMBOL(kuc_ispayload);
-
 /* Alloc space for a message, and fill in header
  * @return Pointer to payload area
  */
@@ -1942,7 +2000,7 @@ void *kuc_alloc(int payload_len, int transport, int type)
 EXPORT_SYMBOL(kuc_alloc);
 
 /* Takes pointer to payload area */
-inline void kuc_free(void *p, int payload_len)
+void kuc_free(void *p, int payload_len)
 {
         struct kuc_hdr *lh = kuc_ptr(p);
         OBD_FREE(lh, kuc_len(payload_len));
@@ -1981,14 +2039,14 @@ int obd_get_request_slot(struct client_obd *cli)
 	int				 rc;
 
 	spin_lock(&cli->cl_loi_list_lock);
-	if (cli->cl_r_in_flight < cli->cl_max_rpcs_in_flight) {
-		cli->cl_r_in_flight++;
+	if (cli->cl_rpcs_in_flight < cli->cl_max_rpcs_in_flight) {
+		cli->cl_rpcs_in_flight++;
 		spin_unlock(&cli->cl_loi_list_lock);
 		return 0;
 	}
 
 	init_waitqueue_head(&orsw.orsw_waitq);
-	list_add_tail(&orsw.orsw_entry, &cli->cl_loi_read_list);
+	list_add_tail(&orsw.orsw_entry, &cli->cl_flight_waiters);
 	orsw.orsw_signaled = false;
 	spin_unlock(&cli->cl_loi_list_lock);
 
@@ -2004,7 +2062,7 @@ int obd_get_request_slot(struct client_obd *cli)
 	if (rc != 0) {
 		if (!orsw.orsw_signaled) {
 			if (list_empty(&orsw.orsw_entry))
-				cli->cl_r_in_flight--;
+				cli->cl_rpcs_in_flight--;
 			else
 				list_del(&orsw.orsw_entry);
 		}
@@ -2026,15 +2084,15 @@ void obd_put_request_slot(struct client_obd *cli)
 	struct obd_request_slot_waiter *orsw;
 
 	spin_lock(&cli->cl_loi_list_lock);
-	cli->cl_r_in_flight--;
+	cli->cl_rpcs_in_flight--;
 
 	/* If there is free slot, wakeup the first waiter. */
-	if (!list_empty(&cli->cl_loi_read_list) &&
-	    likely(cli->cl_r_in_flight < cli->cl_max_rpcs_in_flight)) {
-		orsw = list_entry(cli->cl_loi_read_list.next,
+	if (!list_empty(&cli->cl_flight_waiters) &&
+	    likely(cli->cl_rpcs_in_flight < cli->cl_max_rpcs_in_flight)) {
+		orsw = list_entry(cli->cl_flight_waiters.next,
 				  struct obd_request_slot_waiter, orsw_entry);
 		list_del_init(&orsw->orsw_entry);
-		cli->cl_r_in_flight++;
+		cli->cl_rpcs_in_flight++;
 		wake_up(&orsw->orsw_waitq);
 	}
 	spin_unlock(&cli->cl_loi_list_lock);
@@ -2053,14 +2111,14 @@ int obd_set_max_rpcs_in_flight(struct client_obd *cli, __u32 max)
 	__u32				old;
 	int				diff;
 	int				i;
-	char				*typ_name;
+	const char *type_name;
 	int				rc;
 
 	if (max > OBD_MAX_RIF_MAX || max < 1)
 		return -ERANGE;
 
-	typ_name = cli->cl_import->imp_obd->obd_type->typ_name;
-	if (strcmp(typ_name, LUSTRE_MDC_NAME) == 0) {
+	type_name = cli->cl_import->imp_obd->obd_type->typ_name;
+	if (strcmp(type_name, LUSTRE_MDC_NAME) == 0) {
 		/* adjust max_mod_rpcs_in_flight to ensure it is always
 		 * strictly lower that max_rpcs_in_flight */
 		if (max < 2) {
@@ -2080,17 +2138,19 @@ int obd_set_max_rpcs_in_flight(struct client_obd *cli, __u32 max)
 	spin_lock(&cli->cl_loi_list_lock);
 	old = cli->cl_max_rpcs_in_flight;
 	cli->cl_max_rpcs_in_flight = max;
+	client_adjust_max_dirty(cli);
+
 	diff = max - old;
 
 	/* We increase the max_rpcs_in_flight, then wakeup some waiters. */
 	for (i = 0; i < diff; i++) {
-		if (list_empty(&cli->cl_loi_read_list))
+		if (list_empty(&cli->cl_flight_waiters))
 			break;
 
-		orsw = list_entry(cli->cl_loi_read_list.next,
+		orsw = list_entry(cli->cl_flight_waiters.next,
 				  struct obd_request_slot_waiter, orsw_entry);
 		list_del_init(&orsw->orsw_entry);
-		cli->cl_r_in_flight++;
+		cli->cl_rpcs_in_flight++;
 		wake_up(&orsw->orsw_waitq);
 	}
 	spin_unlock(&cli->cl_loi_list_lock);
@@ -2153,21 +2213,19 @@ int obd_set_max_mod_rpcs_in_flight(struct client_obd *cli, __u16 max)
 }
 EXPORT_SYMBOL(obd_set_max_mod_rpcs_in_flight);
 
-
-#define pct(a, b) (b ? a * 100 / b : 0)
 int obd_mod_rpc_stats_seq_show(struct client_obd *cli,
 			       struct seq_file *seq)
 {
-	struct timeval now;
 	unsigned long mod_tot = 0, mod_cum;
+	struct timespec64 now;
 	int i;
 
-	do_gettimeofday(&now);
+	ktime_get_real_ts64(&now);
 
 	spin_lock(&cli->cl_mod_rpcs_lock);
 
-	seq_printf(seq, "snapshot_time:         %lu.%lu (secs.usecs)\n",
-		   now.tv_sec, now.tv_usec);
+	seq_printf(seq, "snapshot_time:         %llu.%9lu (secs.nsecs)\n",
+		   (s64)now.tv_sec, now.tv_nsec);
 	seq_printf(seq, "modify_RPCs_in_flight:  %hu\n",
 		   cli->cl_mod_rpcs_in_flight);
 
@@ -2180,9 +2238,9 @@ int obd_mod_rpc_stats_seq_show(struct client_obd *cli,
 	for (i = 0; i < OBD_HIST_MAX; i++) {
 		unsigned long mod = cli->cl_mod_rpcs_hist.oh_buckets[i];
 		mod_cum += mod;
-		seq_printf(seq, "%d:\t\t%10lu %3lu %3lu\n",
-				 i, mod, pct(mod, mod_tot),
-				 pct(mod_cum, mod_tot));
+		seq_printf(seq, "%d:\t\t%10lu %3u %3u\n",
+			   i, mod, pct(mod, mod_tot),
+			   pct(mod_cum, mod_tot));
 		if (mod_cum == mod_tot)
 			break;
 	}
@@ -2192,8 +2250,6 @@ int obd_mod_rpc_stats_seq_show(struct client_obd *cli,
 	return 0;
 }
 EXPORT_SYMBOL(obd_mod_rpc_stats_seq_show);
-#undef pct
-
 
 /* The number of modify RPCs sent in parallel is limited
  * because the server has a finite number of slots per client to
@@ -2230,6 +2286,16 @@ static inline bool obd_mod_rpc_slot_avail(struct client_obd *cli,
 	return avail;
 }
 
+static inline bool obd_skip_mod_rpc_slot(const struct lookup_intent *it)
+{
+	if (it != NULL &&
+	    (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP ||
+	     it->it_op == IT_READDIR ||
+	     (it->it_op == IT_LAYOUT && !(it->it_flags & MDS_FMODE_WRITE))))
+			return true;
+	return false;
+}
+
 /* Get a modify RPC slot from the obd client @cli according
  * to the kind of operation @opc that is going to be sent
  * and the intent @it of the operation if it applies.
@@ -2241,15 +2307,13 @@ static inline bool obd_mod_rpc_slot_avail(struct client_obd *cli,
 __u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc,
 			   struct lookup_intent *it)
 {
-	struct l_wait_info	lwi = LWI_INTR(NULL, NULL);
 	bool			close_req = false;
 	__u16			i, max;
 
 	/* read-only metadata RPCs don't consume a slot on MDT
 	 * for reply reconstruction
 	 */
-	if (it != NULL && (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP ||
-			   it->it_op == IT_LAYOUT || it->it_op == IT_READDIR))
+	if (obd_skip_mod_rpc_slot(it))
 		return 0;
 
 	if (opc == MDS_CLOSE)
@@ -2272,6 +2336,12 @@ __u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc,
 			LASSERT(!test_and_set_bit(i, cli->cl_mod_tag_bitmap));
 			spin_unlock(&cli->cl_mod_rpcs_lock);
 			/* tag 0 is reserved for non-modify RPCs */
+
+			CDEBUG(D_RPCTRACE, "%s: modify RPC slot %u is allocated"
+			       "opc %u, max %hu\n",
+			       cli->cl_import->imp_obd->obd_name,
+			       i + 1, opc, max);
+
 			return i + 1;
 		}
 		spin_unlock(&cli->cl_mod_rpcs_lock);
@@ -2280,8 +2350,9 @@ __u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc,
 		       "opc %u, max %hu\n",
 		       cli->cl_import->imp_obd->obd_name, opc, max);
 
-		l_wait_event(cli->cl_mod_rpcs_waitq,
-			     obd_mod_rpc_slot_avail(cli, close_req), &lwi);
+		wait_event_idle_exclusive(cli->cl_mod_rpcs_waitq,
+					  obd_mod_rpc_slot_avail(cli,
+								 close_req));
 	} while (true);
 }
 EXPORT_SYMBOL(obd_get_mod_rpc_slot);
@@ -2295,8 +2366,7 @@ void obd_put_mod_rpc_slot(struct client_obd *cli, __u32 opc,
 {
 	bool			close_req = false;
 
-	if (it != NULL && (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP ||
-			   it->it_op == IT_LAYOUT || it->it_op == IT_READDIR))
+	if (obd_skip_mod_rpc_slot(it))
 		return;
 
 	if (opc == MDS_CLOSE)