#include <lustre_disk.h>
#include <lustre_kernelcomm.h>
-static DEFINE_SPINLOCK(obd_types_lock);
-static LIST_HEAD(obd_types);
DEFINE_RWLOCK(obd_dev_lock);
static struct obd_device *obd_devs[MAX_OBD_DEVICES];
static struct kmem_cache *obd_device_cachep;
-
+static struct kobj_type class_ktype;
static struct workqueue_struct *zombie_wq;
static void obd_zombie_export_add(struct obd_export *exp);
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);
-
/*
* support functions: we could use inter-module communication, but this
* is more portable to other OS's
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";
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);
}
#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;
}
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);
-#ifdef HAVE_SERVER_SUPPORT
- if (type->typ_sym_filter)
- type->typ_debugfs_entry = NULL;
-#endif
debugfs_remove_recursive(type->typ_debugfs_entry);
type->typ_debugfs_entry = NULL;
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);
-
#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));
}
{
struct dentry *symlink;
struct obd_type *type;
- struct kobject *kobj;
int rc;
- kobj = kset_find_obj(lustre_kset, name);
- if (kobj) {
- kobject_put(kobj);
+ type = class_search_type(name);
+ if (type) {
+ kobject_put(&type->typ_kobj);
return ERR_PTR(-EEXIST);
}
if (!type)
return ERR_PTR(-ENOMEM);
- INIT_LIST_HEAD(&type->typ_chain);
-
type->typ_kobj.kset = lustre_kset;
rc = kobject_init_and_add(&type->typ_kobj, &class_ktype,
&lustre_kset->kobj, "%s", name);
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;
#define CLASS_MAX_NAME 1024
-int class_register_type(struct obd_ops *dt_ops, struct md_ops *md_ops,
- bool enable_proc, struct lprocfs_vars *vars,
+int class_register_type(const struct obd_ops *dt_ops,
+ const struct md_ops *md_ops,
+ bool enable_proc, struct ldebugfs_vars *vars,
const char *name, struct lu_device_type *ldt)
{
struct obd_type *type;
/* sanity check */
LASSERT(strnlen(name, CLASS_MAX_NAME) < CLASS_MAX_NAME);
- if (class_search_type(name)) {
+ type = class_search_type(name);
+ if (type) {
#ifdef HAVE_SERVER_SUPPORT
- if (strcmp(name, LUSTRE_LOV_NAME) == 0 ||
- strcmp(name, LUSTRE_OSC_NAME) == 0) {
- struct kobject *kobj;
-
- kobj = kset_find_obj(lustre_kset, name);
- if (kobj) {
- type = container_of(kobj, struct obd_type,
- typ_kobj);
- goto dir_exist;
- }
- }
+ 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);
}
if (type == NULL)
RETURN(-ENOMEM);
- INIT_LIST_HEAD(&type->typ_chain);
+ type->typ_lu = ldt ? OBD_LU_TYPE_SETUP : NULL;
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);
-
- if (type->typ_dt_ops == NULL ||
- 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;
- spin_lock_init(&type->obd_type_lock);
+ type->typ_dt_ops = dt_ops;
+ type->typ_md_ops = md_ops;
#ifdef HAVE_SERVER_SUPPORT
- if (type->typ_sym_filter)
+ 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) {
}
}
#endif
- 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);
- }
+ type->typ_debugfs_entry = debugfs_create_dir(name, debugfs_lustre_root);
+ ldebugfs_add_vars(type->typ_debugfs_entry, vars, type);
rc = kobject_add(&type->typ_kobj, &lustre_kset->kobj, "%s", name);
if (rc)
setup_ldt:
#endif
if (ldt) {
- type->typ_lu = ldt;
rc = lu_device_type_init(ldt);
+ smp_store_release(&type->typ_lu, rc ? NULL : ldt);
+ wake_up_var(&type->typ_lu);
if (rc)
GOTO(failed, rc);
}
- spin_lock(&obd_types_lock);
- list_add(&type->typ_chain, &obd_types);
- spin_unlock(&obd_types_lock);
-
RETURN(0);
failed:
int class_unregister_type(const char *name)
{
struct obd_type *type = class_search_type(name);
+ int rc = 0;
ENTRY;
if (!type) {
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);
+ type->typ_dt_ops = NULL;
+ type->typ_md_ops = NULL;
+ GOTO(out_put, rc = -EBUSY);
}
+ /* 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(0);
+ RETURN(rc);
} /* class_unregister_type */
EXPORT_SYMBOL(class_unregister_type);
return obd;
}
+EXPORT_SYMBOL(class_num2obd);
/**
* Find obd in obd_dev[] by name or uuid.
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 *type_name,
- struct obd_uuid *grp_uuid)
+ * 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 *type_name,
+ struct obd_uuid *grp_uuid)
{
int i;
EXPORT_SYMBOL(class_find_client_obd);
/* Iterate the obd_device list looking devices have grp_uuid. Start
- searching at *next, and if a device is found, the next index to look
- at is saved in *next. If next is NULL, then the first matching device
- will always be returned. */
-struct obd_device * class_devices_in_group(struct obd_uuid *grp_uuid, int *next)
+ * searching at *next, and if a device is found, the next index to look
+ * at is saved in *next. If next is NULL, then the first matching device
+ * will always be returned.
+ */
+struct obd_device *class_devices_in_group(struct obd_uuid *grp_uuid, int *next)
{
int i;
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);
RETURN(rc);
}
+static const char export_handle_owner[] = "export";
+
/* map connection to client */
struct obd_export *class_conn2export(struct lustre_handle *conn)
{
}
CDEBUG(D_INFO, "looking for export cookie %#llx\n", conn->cookie);
- export = class_handle2object(conn->cookie, NULL);
+ export = class_handle2object(conn->cookie, export_handle_owner);
RETURN(export);
}
EXPORT_SYMBOL(class_conn2export);
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,
exp->exp_client_uuid.uuid, obd->obd_name);
/* "Local" exports (lctl, LOV->{mdc,osc}) have no connection. */
- if (exp->exp_connection)
- ptlrpc_put_connection_superhack(exp->exp_connection);
+ ptlrpc_connection_put(exp->exp_connection);
LASSERT(list_empty(&exp->exp_outstanding_replies));
LASSERT(list_empty(&exp->exp_uncommitted_replies));
if (exp != obd->obd_self_export)
class_decref(obd, "export", exp);
- OBD_FREE_RCU(exp, sizeof(*exp), &exp->exp_handle);
+ OBD_FREE_PRE(exp, sizeof(*exp), "rcu");
+ kfree_rcu(exp, exp_handle.h_rcu);
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,
-};
-
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);
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 (atomic_dec_and_test(&exp->exp_refcount)) {
+ if (refcount_dec_and_test(&exp->exp_handle.h_ref)) {
struct obd_device *obd = exp->exp_obd;
CDEBUG(D_IOCTL, "final put %p/%s\n",
struct obd_uuid *cluuid, bool is_self)
{
struct obd_export *export;
- struct cfs_hash *hash = NULL;
int rc = 0;
ENTRY;
export->exp_lock_hash = NULL;
export->exp_flock_hash = NULL;
/* 2 = class_handle_hash + last */
- atomic_set(&export->exp_refcount, 2);
+ 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);
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_RCU(&export->exp_handle.h_link);
+ INIT_HLIST_NODE(&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);
+ class_handle_hash(&export->exp_handle, export_handle_owner);
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);
- INIT_HLIST_NODE(&export->exp_nid_hash);
INIT_HLIST_NODE(&export->exp_gen_hash);
spin_lock_init(&export->exp_bl_list_lock);
INIT_LIST_HEAD(&export->exp_bl_list);
export->exp_client_uuid = *cluuid;
obd_init_export(export);
+ at_init(&export->exp_bl_lock_at, obd_timeout, 0);
+
+ spin_lock(&obd->obd_dev_lock);
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);
-
- rc = cfs_hash_add_unique(hash, cluuid, &export->exp_uuid_hash);
+ rc = obd_uuid_add(obd, export);
if (rc != 0) {
- LCONSOLE_WARN("%s: denying duplicate export for %s, %d\n",
+ LCONSOLE_WARN("%s: denying duplicate export for %s: rc = %d\n",
obd->obd_name, cluuid->uuid, rc);
- GOTO(exit_err, rc = -EALREADY);
+ GOTO(exit_unlock, rc = -EALREADY);
}
}
- at_init(&export->exp_bl_lock_at, obd_timeout, 0);
- spin_lock(&obd->obd_dev_lock);
- if (obd->obd_stopping) {
- if (hash)
- cfs_hash_del(hash, cluuid, &export->exp_uuid_hash);
- GOTO(exit_unlock, rc = -ESHUTDOWN);
- }
-
if (!is_self) {
class_incref(obd, "export", export);
list_add_tail(&export->exp_obd_chain_timed,
INIT_LIST_HEAD(&export->exp_obd_chain);
}
spin_unlock(&obd->obd_dev_lock);
- if (hash)
- cfs_hash_putref(hash);
RETURN(export);
exit_unlock:
spin_unlock(&obd->obd_dev_lock);
-exit_err:
- if (hash)
- cfs_hash_putref(hash);
class_handle_unhash(&export->exp_handle);
- LASSERT(hlist_unhashed(&export->exp_uuid_hash));
obd_destroy_export(export);
OBD_FREE_PTR(export);
return ERR_PTR(rc);
spin_lock(&exp->exp_obd->obd_dev_lock);
/* delete an uuid-export hashitem from hashtables */
- if (!hlist_unhashed(&exp->exp_uuid_hash))
- cfs_hash_del(exp->exp_obd->obd_uuid_hash,
- &exp->exp_client_uuid,
- &exp->exp_uuid_hash);
+ if (exp != exp->exp_obd->obd_self_export)
+ obd_uuid_del(exp->exp_obd, exp);
#ifdef HAVE_SERVER_SUPPORT
if (!hlist_unhashed(&exp->exp_gen_hash)) {
/* Import management functions */
static void obd_zombie_import_free(struct obd_import *imp)
{
- ENTRY;
+ ENTRY;
- CDEBUG(D_IOCTL, "destroying import %p for %s\n", imp,
- imp->imp_obd->obd_name);
+ CDEBUG(D_IOCTL, "destroying import %p for %s\n", imp,
+ imp->imp_obd->obd_name);
- LASSERT_ATOMIC_ZERO(&imp->imp_refcount);
+ LASSERT(refcount_read(&imp->imp_refcount) == 0);
- ptlrpc_put_connection_superhack(imp->imp_connection);
+ ptlrpc_connection_put(imp->imp_connection);
while (!list_empty(&imp->imp_conn_list)) {
struct obd_import_conn *imp_conn;
- imp_conn = list_entry(imp->imp_conn_list.next,
- struct obd_import_conn, oic_item);
+ imp_conn = list_first_entry(&imp->imp_conn_list,
+ struct obd_import_conn, oic_item);
list_del_init(&imp_conn->oic_item);
- ptlrpc_put_connection_superhack(imp_conn->oic_conn);
- OBD_FREE(imp_conn, sizeof(*imp_conn));
- }
+ ptlrpc_connection_put(imp_conn->oic_conn);
+ OBD_FREE(imp_conn, sizeof(*imp_conn));
+ }
- LASSERT(imp->imp_sec == NULL);
- class_decref(imp->imp_obd, "import", imp);
+ LASSERT(imp->imp_sec == NULL);
+ LASSERTF(atomic_read(&imp->imp_reqs) == 0, "%s: imp_reqs = %d\n",
+ imp->imp_obd->obd_name, atomic_read(&imp->imp_reqs));
+ class_decref(imp->imp_obd, "import", imp);
OBD_FREE_PTR(imp);
EXIT;
}
struct obd_import *class_import_get(struct obd_import *import)
{
- atomic_inc(&import->imp_refcount);
+ refcount_inc(&import->imp_refcount);
CDEBUG(D_INFO, "import %p refcount=%d obd=%s\n", import,
- atomic_read(&import->imp_refcount),
+ refcount_read(&import->imp_refcount),
import->imp_obd->obd_name);
return import;
}
{
ENTRY;
- LASSERT_ATOMIC_GT_LT(&imp->imp_refcount, 0, LI_POISON);
+ LASSERT(refcount_read(&imp->imp_refcount) > 0);
CDEBUG(D_INFO, "import %p refcount=%d obd=%s\n", imp,
- atomic_read(&imp->imp_refcount) - 1,
+ refcount_read(&imp->imp_refcount) - 1,
imp->imp_obd->obd_name);
- if (atomic_dec_and_test(&imp->imp_refcount)) {
+ if (refcount_dec_and_test(&imp->imp_refcount)) {
CDEBUG(D_INFO, "final put import %p\n", imp);
obd_zombie_import_add(imp);
}
- /* catch possible import put race */
- LASSERT_ATOMIC_GE_LT(&imp->imp_refcount, 0, LI_POISON);
EXIT;
}
EXPORT_SYMBOL(class_import_put);
init_waitqueue_head(&imp->imp_recovery_waitq);
INIT_WORK(&imp->imp_zombie_work, obd_zombie_imp_cull);
- if (curr_pid_ns->child_reaper)
+ if (curr_pid_ns && 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);
+ refcount_set(&imp->imp_refcount, 2);
atomic_set(&imp->imp_unregistering, 0);
+ atomic_set(&imp->imp_reqs, 0);
atomic_set(&imp->imp_inflight, 0);
atomic_set(&imp->imp_replay_inflight, 0);
+ init_waitqueue_head(&imp->imp_replay_waitq);
atomic_set(&imp->imp_inval_count, 0);
INIT_LIST_HEAD(&imp->imp_conn_list);
init_imp_at(&imp->imp_at);
spin_lock(&export->exp_lock);
already_disconnected = export->exp_disconnected;
export->exp_disconnected = 1;
+#ifdef HAVE_SERVER_SUPPORT
/* 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);
+ * it is safe to call rh*table_remove_fast in
+ * there.
+ */
+ obd_nid_del(export->exp_obd, export);
+#endif /* HAVE_SERVER_SUPPORT */
spin_unlock(&export->exp_lock);
/* class_cleanup(), abort_recovery(), and class_fail_export()
* all end up in here, and if any of them race we shouldn't
* call extra class_export_puts(). */
- if (already_disconnected) {
- LASSERT(hlist_unhashed(&export->exp_nid_hash));
+ if (already_disconnected)
GOTO(no_disconn, already_disconnected);
- }
CDEBUG(D_IOCTL, "disconnect: cookie %#llx\n",
export->exp_handle.h_cookie);
/* It's possible that an export may disconnect itself, but
* nothing else will be added to this list. */
while (!list_empty(list)) {
- exp = list_entry(list->next, struct obd_export,
- exp_obd_chain);
+ exp = list_first_entry(list, struct obd_export,
+ exp_obd_chain);
/* need for safe call CDEBUG after obd_disconnect */
class_export_get(exp);
void class_disconnect_exports(struct obd_device *obd)
{
- struct list_head work_list;
+ LIST_HEAD(work_list);
ENTRY;
/* Move all of the exports from obd_exports to a work list, en masse. */
- INIT_LIST_HEAD(&work_list);
spin_lock(&obd->obd_dev_lock);
list_splice_init(&obd->obd_exports, &work_list);
list_splice_init(&obd->obd_delayed_exports, &work_list);
void class_disconnect_stale_exports(struct obd_device *obd,
int (*test_export)(struct obd_export *))
{
- struct list_head work_list;
+ LIST_HEAD(work_list);
struct obd_export *exp, *n;
- int evicted = 0;
- ENTRY;
+ int evicted = 0;
+ ENTRY;
- INIT_LIST_HEAD(&work_list);
spin_lock(&obd->obd_dev_lock);
list_for_each_entry_safe(exp, n, &obd->obd_exports,
exp_obd_chain) {
}
EXPORT_SYMBOL(class_fail_export);
-int obd_export_evict_by_nid(struct obd_device *obd, const char *nid)
+#ifdef HAVE_SERVER_SUPPORT
+
+static int take_first(struct obd_export *exp, void *data)
{
- struct cfs_hash *nid_hash;
- struct obd_export *doomed_exp = NULL;
- int exports_evicted = 0;
+ struct obd_export **expp = data;
+ if (*expp)
+ /* already have one */
+ return 0;
+ if (exp->exp_failed)
+ /* Don't want this one */
+ return 0;
+ if (!refcount_inc_not_zero(&exp->exp_handle.h_ref))
+ /* Cannot get a ref on this one */
+ return 0;
+ *expp = exp;
+ return 1;
+}
+
+int obd_export_evict_by_nid(struct obd_device *obd, const char *nid)
+{
lnet_nid_t nid_key = libcfs_str2nid((char *)nid);
+ struct obd_export *doomed_exp;
+ int exports_evicted = 0;
spin_lock(&obd->obd_dev_lock);
/* umount has run already, so evict thread should leave
spin_unlock(&obd->obd_dev_lock);
return exports_evicted;
}
- nid_hash = obd->obd_nid_hash;
- cfs_hash_getref(nid_hash);
spin_unlock(&obd->obd_dev_lock);
- do {
- doomed_exp = cfs_hash_lookup(nid_hash, &nid_key);
- if (doomed_exp == NULL)
- break;
+ doomed_exp = NULL;
+ while (obd_nid_export_for_each(obd, nid_key,
+ take_first, &doomed_exp) > 0) {
- LASSERTF(doomed_exp->exp_connection->c_peer.nid == nid_key,
- "nid %s found, wanted nid %s, requested nid %s\n",
- obd_export_nid2str(doomed_exp),
- libcfs_nid2str(nid_key), nid);
- LASSERTF(doomed_exp != obd->obd_self_export,
- "self-export is hashed by NID?\n");
- exports_evicted++;
- LCONSOLE_WARN("%s: evicting %s (at %s) by administrative "
- "request\n", obd->obd_name,
+ LASSERTF(doomed_exp != obd->obd_self_export,
+ "self-export is hashed by NID?\n");
+
+ LCONSOLE_WARN("%s: evicting %s (at %s) by administrative request\n",
+ obd->obd_name,
obd_uuid2str(&doomed_exp->exp_client_uuid),
obd_export_nid2str(doomed_exp));
- class_fail_export(doomed_exp);
- class_export_put(doomed_exp);
- } while (1);
- cfs_hash_putref(nid_hash);
+ class_fail_export(doomed_exp);
+ class_export_put(doomed_exp);
+ exports_evicted++;
+ doomed_exp = NULL;
+ }
- if (!exports_evicted)
- CDEBUG(D_HA,"%s: can't disconnect NID '%s': no exports found\n",
- obd->obd_name, nid);
- return exports_evicted;
+ if (!exports_evicted)
+ CDEBUG(D_HA,
+ "%s: can't disconnect NID '%s': no exports found\n",
+ obd->obd_name, nid);
+ return exports_evicted;
}
EXPORT_SYMBOL(obd_export_evict_by_nid);
int obd_export_evict_by_uuid(struct obd_device *obd, const char *uuid)
{
- struct cfs_hash *uuid_hash;
struct obd_export *doomed_exp = NULL;
struct obd_uuid doomed_uuid;
int exports_evicted = 0;
spin_unlock(&obd->obd_dev_lock);
return exports_evicted;
}
- uuid_hash = obd->obd_uuid_hash;
- cfs_hash_getref(uuid_hash);
spin_unlock(&obd->obd_dev_lock);
obd_str2uuid(&doomed_uuid, uuid);
if (obd_uuid_equals(&doomed_uuid, &obd->obd_uuid)) {
CERROR("%s: can't evict myself\n", obd->obd_name);
- cfs_hash_putref(uuid_hash);
return exports_evicted;
}
- doomed_exp = cfs_hash_lookup(uuid_hash, &doomed_uuid);
-
+ doomed_exp = obd_uuid_lookup(obd, &doomed_uuid);
if (doomed_exp == NULL) {
CERROR("%s: can't disconnect %s: no exports found\n",
obd->obd_name, uuid);
obd->obd_name, doomed_exp->exp_client_uuid.uuid);
class_fail_export(doomed_exp);
class_export_put(doomed_exp);
+ obd_uuid_del(obd, doomed_exp);
exports_evicted++;
}
- cfs_hash_putref(uuid_hash);
return exports_evicted;
}
+#endif /* HAVE_SERVER_SUPPORT */
#if LUSTRE_TRACKS_LOCK_EXP_REFS
void (*class_export_dump_hook)(struct obd_export*) = NULL;
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), atomic_read(&exp->exp_refcount),
+ 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),
spin_lock(&obd->obd_dev_lock);
while (!list_empty(&obd->obd_unlinked_exports)) {
spin_unlock(&obd->obd_dev_lock);
- set_current_state(TASK_UNINTERRUPTIBLE);
- schedule_timeout(cfs_time_seconds(waited));
+ schedule_timeout_uninterruptible(cfs_time_seconds(waited));
if (waited > 5 && is_power_of_2(waited)) {
LCONSOLE_WARN("%s is waiting for obd_unlinked_exports "
"more than %d seconds. "
spin_lock(&obd_stale_export_lock);
if (!list_empty(&obd_stale_exports)) {
- exp = list_entry(obd_stale_exports.next,
- struct obd_export, exp_stale_list);
+ exp = list_first_entry(&obd_stale_exports,
+ struct obd_export, exp_stale_list);
list_del_init(&exp->exp_stale_list);
}
spin_unlock(&obd_stale_export_lock);
*/
int obd_zombie_impexp_init(void)
{
- zombie_wq = alloc_workqueue("obd_zombid", 0, 0);
- if (!zombie_wq)
- return -ENOMEM;
+ zombie_wq = cfs_cpt_bind_workqueue("obd_zombid", cfs_cpt_tab,
+ 0, CFS_CPT_ANY,
+ cfs_cpt_number(cfs_cpt_tab));
- return 0;
+ return IS_ERR(zombie_wq) ? PTR_ERR(zombie_wq) : 0;
}
/**
int obd_get_request_slot(struct client_obd *cli)
{
struct obd_request_slot_waiter orsw;
- struct l_wait_info lwi;
int rc;
spin_lock(&cli->cl_loi_list_lock);
orsw.orsw_signaled = false;
spin_unlock(&cli->cl_loi_list_lock);
- lwi = LWI_INTR(LWI_ON_SIGNAL_NOOP, NULL);
- rc = l_wait_event(orsw.orsw_waitq,
- obd_request_slot_avail(cli, &orsw) ||
- orsw.orsw_signaled,
- &lwi);
+ rc = l_wait_event_abortable(orsw.orsw_waitq,
+ obd_request_slot_avail(cli, &orsw) ||
+ orsw.orsw_signaled);
/* Here, we must take the lock to avoid the on-stack 'orsw' to be
* freed but other (such as obd_put_request_slot) is using it. */
else
list_del(&orsw.orsw_entry);
}
+ rc = -EINTR;
}
if (orsw.orsw_signaled) {
/* If there is free slot, wakeup the first waiter. */
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);
+ orsw = list_first_entry(&cli->cl_flight_waiters,
+ struct obd_request_slot_waiter,
+ orsw_entry);
list_del_init(&orsw->orsw_entry);
cli->cl_rpcs_in_flight++;
wake_up(&orsw->orsw_waitq);
__u32 old;
int diff;
int i;
- const char *type_name;
int rc;
if (max > OBD_MAX_RIF_MAX || max < 1)
return -ERANGE;
- type_name = cli->cl_import->imp_obd->obd_type->typ_name;
- if (strcmp(type_name, LUSTRE_MDC_NAME) == 0) {
+ CDEBUG(D_INFO, "%s: max = %hu max_mod = %u rif = %u\n",
+ cli->cl_import->imp_obd->obd_name, max,
+ cli->cl_max_mod_rpcs_in_flight, cli->cl_max_rpcs_in_flight);
+
+ if (strcmp(cli->cl_import->imp_obd->obd_type->typ_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) {
- CERROR("%s: cannot set max_rpcs_in_flight to 1 "
- "because it must be higher than "
- "max_mod_rpcs_in_flight value",
+ CERROR("%s: cannot set mdc.*.max_rpcs_in_flight=1\n",
cli->cl_import->imp_obd->obd_name);
return -ERANGE;
}
if (list_empty(&cli->cl_flight_waiters))
break;
- orsw = list_entry(cli->cl_flight_waiters.next,
- struct obd_request_slot_waiter, orsw_entry);
+ orsw = list_first_entry(&cli->cl_flight_waiters,
+ struct obd_request_slot_waiter,
+ orsw_entry);
list_del_init(&orsw->orsw_entry);
cli->cl_rpcs_in_flight++;
wake_up(&orsw->orsw_waitq);
int obd_set_max_mod_rpcs_in_flight(struct client_obd *cli, __u16 max)
{
- struct obd_connect_data *ocd;
+ struct obd_connect_data *ocd;
__u16 maxmodrpcs;
__u16 prev;
if (max > OBD_MAX_RIF_MAX || max < 1)
return -ERANGE;
- /* cannot exceed or equal max_rpcs_in_flight */
+ ocd = &cli->cl_import->imp_connect_data;
+ CDEBUG(D_INFO, "%s: max = %hu flags = %llx, max_mod = %u rif = %u\n",
+ cli->cl_import->imp_obd->obd_name, max, ocd->ocd_connect_flags,
+ ocd->ocd_maxmodrpcs, cli->cl_max_rpcs_in_flight);
+
+ if (max == OBD_MAX_RIF_MAX)
+ max = OBD_MAX_RIF_MAX - 1;
+
+ /* Cannot exceed or equal max_rpcs_in_flight. If we are asked to
+ * increase this value, also bump up max_rpcs_in_flight to match.
+ */
if (max >= cli->cl_max_rpcs_in_flight) {
- CERROR("%s: can't set max_mod_rpcs_in_flight to a value (%hu) "
- "higher or equal to max_rpcs_in_flight value (%u)\n",
- cli->cl_import->imp_obd->obd_name,
- max, cli->cl_max_rpcs_in_flight);
- return -ERANGE;
+ CDEBUG(D_INFO,
+ "%s: increasing max_rpcs_in_flight=%hu to allow larger max_mod_rpcs_in_flight=%u\n",
+ cli->cl_import->imp_obd->obd_name, max + 1, max);
+ obd_set_max_rpcs_in_flight(cli, max + 1);
}
- /* cannot exceed max modify RPCs in flight supported by the server */
- ocd = &cli->cl_import->imp_connect_data;
- if (ocd->ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS)
+ /* cannot exceed max modify RPCs in flight supported by the server,
+ * but verify ocd_connect_flags is at least initialized first. If
+ * not, allow it and fix value later in ptlrpc_connect_set_flags().
+ */
+ if (!ocd->ocd_connect_flags) {
+ maxmodrpcs = cli->cl_max_rpcs_in_flight - 1;
+ } else if (ocd->ocd_connect_flags & OBD_CONNECT_MULTIMODRPCS) {
maxmodrpcs = ocd->ocd_maxmodrpcs;
- else
+ if (maxmodrpcs == 0) { /* connection not finished yet */
+ maxmodrpcs = cli->cl_max_rpcs_in_flight - 1;
+ CDEBUG(D_INFO,
+ "%s: partial connect, assume maxmodrpcs=%hu\n",
+ cli->cl_import->imp_obd->obd_name, maxmodrpcs);
+ }
+ } else {
maxmodrpcs = 1;
+ }
if (max > maxmodrpcs) {
- CERROR("%s: can't set max_mod_rpcs_in_flight to a value (%hu) "
- "higher than max_mod_rpcs_per_client value (%hu) "
- "returned by the server at connection\n",
+ CERROR("%s: can't set max_mod_rpcs_in_flight=%hu higher than ocd_maxmodrpcs=%hu returned by the server at connection\n",
cli->cl_import->imp_obd->obd_name,
max, maxmodrpcs);
return -ERANGE;
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
* Returns the tag to be set in the request message. Tag 0
* is reserved for non-modifying requests.
*/
-__u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc,
- struct lookup_intent *it)
+__u16 obd_get_mod_rpc_slot(struct client_obd *cli, __u32 opc)
{
- 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 (obd_skip_mod_rpc_slot(it))
- return 0;
-
if (opc == MDS_CLOSE)
close_req = true;
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);
"opc %u, max %hu\n",
cli->cl_import->imp_obd->obd_name, opc, max);
- l_wait_event_exclusive(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);
/* Put a modify RPC slot from the obd client @cli according
- * to the kind of operation @opc that has been sent and the
- * intent @it of the operation if it applies.
+ * to the kind of operation @opc that has been sent.
*/
-void obd_put_mod_rpc_slot(struct client_obd *cli, __u32 opc,
- struct lookup_intent *it, __u16 tag)
+void obd_put_mod_rpc_slot(struct client_obd *cli, __u32 opc, __u16 tag)
{
bool close_req = false;
- if (obd_skip_mod_rpc_slot(it))
+ if (tag == 0)
return;
if (opc == MDS_CLOSE)
git://git.whamcloud.com / fs / lustre-release.git / blobdiff