struct ldlm_namespace *ns = data;
char dummy[MAX_STRING_SIZE + 1], *end;
unsigned long tmp;
+ int lru_resize;
dummy[MAX_STRING_SIZE] = '\0';
if (copy_from_user(dummy, buffer, MAX_STRING_SIZE))
int canceled, unused = ns->ns_nr_unused;
/* Try to cancel all @ns_nr_unused locks. */
- canceled = ldlm_cancel_lru(ns, unused, LDLM_SYNC);
+ canceled = ldlm_cancel_lru(ns, unused, LDLM_SYNC,
+ LDLM_CANCEL_PASSED);
if (canceled < unused) {
CERROR("not all requested locks are canceled, "
"requested: %d, canceled: %d\n", unused,
} else {
tmp = ns->ns_max_unused;
ns->ns_max_unused = 0;
- ldlm_cancel_lru(ns, 0, LDLM_SYNC);
+ ldlm_cancel_lru(ns, 0, LDLM_SYNC, LDLM_CANCEL_PASSED);
ns->ns_max_unused = tmp;
}
return count;
CERROR("invalid value written\n");
return -EINVAL;
}
-
+ lru_resize = (tmp == 0);
+
if (ns_connect_lru_resize(ns)) {
+ if (!lru_resize)
+ ns->ns_max_unused = (unsigned int)tmp;
+
if (tmp > ns->ns_nr_unused)
tmp = ns->ns_nr_unused;
tmp = ns->ns_nr_unused - tmp;
CDEBUG(D_DLMTRACE, "changing namespace %s unused locks from %u to %u\n",
ns->ns_name, ns->ns_nr_unused, (unsigned int)tmp);
- ldlm_cancel_lru(ns, (unsigned int)tmp, LDLM_ASYNC);
+ ldlm_cancel_lru(ns, (unsigned int)tmp, LDLM_ASYNC, LDLM_CANCEL_PASSED);
+
+ if (!lru_resize) {
+ CDEBUG(D_DLMTRACE, "disable lru_resize for namespace %s\n",
+ ns->ns_name);
+ ns->ns_connect_flags &= ~OBD_CONNECT_LRU_RESIZE;
+ }
} else {
CDEBUG(D_DLMTRACE, "changing namespace %s max_unused from %u to %u\n",
ns->ns_name, ns->ns_max_unused, (unsigned int)tmp);
ns->ns_max_unused = (unsigned int)tmp;
- ldlm_cancel_lru(ns, 0, LDLM_ASYNC);
+ ldlm_cancel_lru(ns, 0, LDLM_ASYNC, LDLM_CANCEL_PASSED);
+
+ /* Make sure that originally lru resize was supported before
+ * turning it on here. */
+ if (lru_resize &&
+ (ns->ns_orig_connect_flags & OBD_CONNECT_LRU_RESIZE)) {
+ CDEBUG(D_DLMTRACE, "enable lru_resize for namespace %s\n",
+ ns->ns_name);
+ ns->ns_connect_flags |= OBD_CONNECT_LRU_RESIZE;
+ }
}
return count;
lock_vars[0].read_fptr = lprocfs_rd_atomic;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
- if (ns->ns_client) {
+ if (ns_is_client(ns)) {
snprintf(lock_name, MAX_STRING_SIZE, "%s/lock_unused_count",
ns->ns_name);
lock_vars[0].data = &ns->ns_nr_unused;
lock_vars[0].write_fptr = lprocfs_wr_lru_size;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+ snprintf(lock_name, MAX_STRING_SIZE, "%s/shrink_thumb",
+ ns->ns_name);
+ lock_vars[0].data = ns;
+ lock_vars[0].read_fptr = lprocfs_rd_uint;
+ lock_vars[0].write_fptr = lprocfs_wr_uint;
+ lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
+
snprintf(lock_name, MAX_STRING_SIZE, "%s/lru_max_age",
ns->ns_name);
lock_vars[0].data = &ns->ns_max_age;
lock_vars[0].read_fptr = lprocfs_rd_uint;
lock_vars[0].write_fptr = lprocfs_wr_uint;
lprocfs_add_vars(ldlm_ns_proc_dir, lock_vars, 0);
-
}
}
#undef MAX_STRING_SIZE
{
struct ldlm_namespace *ns = NULL;
struct list_head *bucket;
- int rc, idx;
+ int rc, idx, namelen;
ENTRY;
- rc = ldlm_get_ref(client);
+ rc = ldlm_get_ref();
if (rc) {
CERROR("ldlm_get_ref failed: %d\n", rc);
RETURN(NULL);
if (!ns->ns_hash)
GOTO(out_ns, NULL);
+ ns->ns_shrink_thumb = LDLM_LOCK_SHRINK_THUMB;
ns->ns_appetite = apt;
- OBD_ALLOC(ns->ns_name, strlen(name) + 1);
+ namelen = strlen(name);
+ OBD_ALLOC(ns->ns_name, namelen + 1);
if (!ns->ns_name)
GOTO(out_hash, NULL);
ns->ns_max_unused = LDLM_DEFAULT_LRU_SIZE;
ns->ns_max_age = LDLM_DEFAULT_MAX_ALIVE;
spin_lock_init(&ns->ns_unused_lock);
-
+ ns->ns_orig_connect_flags = 0;
ns->ns_connect_flags = 0;
- mutex_down(ldlm_namespace_lock(client));
- list_add(&ns->ns_list_chain, ldlm_namespace_list(client));
- idx = atomic_read(ldlm_namespace_nr(client));
- atomic_inc(ldlm_namespace_nr(client));
- mutex_up(ldlm_namespace_lock(client));
ldlm_proc_namespace(ns);
-
+
+ idx = atomic_read(ldlm_namespace_nr(client));
rc = ldlm_pool_init(&ns->ns_pool, ns, idx, client);
if (rc) {
- CERROR("can't initialize lock pool, rc %d\n", rc);
- GOTO(out_del, rc);
+ CERROR("Can't initialize lock pool, rc %d\n", rc);
+ GOTO(out_proc, rc);
}
- RETURN(ns);
-out_del:
mutex_down(ldlm_namespace_lock(client));
- list_del(&ns->ns_list_chain);
- atomic_dec(ldlm_namespace_nr(client));
+ list_add(&ns->ns_list_chain, ldlm_namespace_list(client));
+ atomic_inc(ldlm_namespace_nr(client));
mutex_up(ldlm_namespace_lock(client));
+
+ RETURN(ns);
+out_proc:
+ ldlm_namespace_cleanup(ns, 0);
+ OBD_FREE(ns->ns_name, namelen + 1);
out_hash:
- POISON(ns->ns_hash, 0x5a, sizeof(*ns->ns_hash) * RES_HASH_SIZE);
OBD_VFREE(ns->ns_hash, sizeof(*ns->ns_hash) * RES_HASH_SIZE);
out_ns:
OBD_FREE_PTR(ns);
out_ref:
- ldlm_put_ref(client, 0);
+ ldlm_put_ref(0);
RETURN(NULL);
}
int flags)
{
struct list_head *tmp;
- int rc = 0, client = res->lr_namespace->ns_client;
+ int rc = 0, client = ns_is_client(res->lr_namespace);
int local_only = (flags & LDLM_FL_LOCAL_ONLY);
ENTRY;
}
/* Cleanup, but also free, the namespace */
-int ldlm_namespace_free(struct ldlm_namespace *ns, int force)
+int ldlm_namespace_free_prior(struct ldlm_namespace *ns)
{
- ldlm_side_t client;
ENTRY;
if (!ns)
RETURN(ELDLM_OK);
- client = ns->ns_client;
- mutex_down(ldlm_namespace_lock(client));
+ mutex_down(ldlm_namespace_lock(ns->ns_client));
list_del(&ns->ns_list_chain);
atomic_dec(ldlm_namespace_nr(ns->ns_client));
ldlm_pool_fini(&ns->ns_pool);
- mutex_up(ldlm_namespace_lock(client));
+ mutex_up(ldlm_namespace_lock(ns->ns_client));
/* At shutdown time, don't call the cancellation callback */
ldlm_namespace_cleanup(ns, 0);
-#ifdef LPROCFS
- {
- struct proc_dir_entry *dir;
- dir = lprocfs_srch(ldlm_ns_proc_dir, ns->ns_name);
- if (dir == NULL) {
- CERROR("dlm namespace %s has no procfs dir?\n",
- ns->ns_name);
- } else {
- lprocfs_remove(&dir);
- }
- }
-#endif
-
if (ns->ns_refcount > 0) {
struct l_wait_info lwi = LWI_INTR(LWI_ON_SIGNAL_NOOP, NULL);
int rc;
"dlm namespace %s free done waiting\n", ns->ns_name);
}
- POISON(ns->ns_hash, 0x5a, sizeof(*ns->ns_hash) * RES_HASH_SIZE);
+ RETURN(ELDLM_OK);
+}
+
+int ldlm_namespace_free_post(struct ldlm_namespace *ns, int force)
+{
+ ENTRY;
+ if (!ns)
+ RETURN(ELDLM_OK);
+
+#ifdef LPROCFS
+ {
+ struct proc_dir_entry *dir;
+ dir = lprocfs_srch(ldlm_ns_proc_dir, ns->ns_name);
+ if (dir == NULL) {
+ CERROR("dlm namespace %s has no procfs dir?\n",
+ ns->ns_name);
+ } else {
+ lprocfs_remove(&dir);
+ }
+ }
+#endif
OBD_VFREE(ns->ns_hash, sizeof(*ns->ns_hash) * RES_HASH_SIZE);
OBD_FREE(ns->ns_name, strlen(ns->ns_name) + 1);
OBD_FREE_PTR(ns);
+ ldlm_put_ref(force);
+ RETURN(ELDLM_OK);
+}
- ldlm_put_ref(client, force);
- RETURN(ELDLM_OK);
+/* Cleanup the resource, and free namespace.
+ * bug 12864:
+ * Deadlock issue:
+ * proc1: destroy import
+ * class_disconnect_export(grab cl_sem) ->
+ * -> ldlm_namespace_free ->
+ * -> lprocfs_remove(grab _lprocfs_lock).
+ * proc2: read proc info
+ * lprocfs_fops_read(grab _lprocfs_lock) ->
+ * -> osc_rd_active, etc(grab cl_sem).
+ *
+ * So that I have to split the ldlm_namespace_free into two parts - the first
+ * part ldlm_namespace_free_prior is used to cleanup the resource which is
+ * being used; the 2nd part ldlm_namespace_free_post is used to unregister the
+ * lprocfs entries, and then free memory. It will be called w/o cli->cl_sem
+ * held.
+ */
+int ldlm_namespace_free(struct ldlm_namespace *ns, int force)
+{
+ ldlm_namespace_free_prior(ns);
+ ldlm_namespace_free_post(ns, force);
+ return ELDLM_OK;
}
+
void ldlm_namespace_get_nolock(struct ldlm_namespace *ns)
{
LASSERT(ns->ns_refcount >= 0);
if (!((libcfs_debug | D_ERROR) & level))
return;
- CDEBUG(level, "--- Namespace: %s (rc: %d, client: %d)\n",
- ns->ns_name, ns->ns_refcount, ns->ns_client);
+ CDEBUG(level, "--- Namespace: %s (rc: %d, side: %s)\n",
+ ns->ns_name, ns->ns_refcount,
+ ns_is_client(ns) ? "client" : "server");
if (cfs_time_before(cfs_time_current(), ns->ns_next_dump))
return;