*
* 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
*/
* 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, 2015, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define DEBUG_SUBSYSTEM S_CLASS
+#include <linux/pid_namespace.h>
#include <linux/kthread.h>
#include <obd_class.h>
#include <lprocfs_status.h>
+#include <lustre_disk.h>
#include <lustre_kernelcomm.h>
spinlock_t obd_types_lock;
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;
int (*ptlrpc_put_connection_superhack)(struct ptlrpc_connection *c);
EXPORT_SYMBOL(ptlrpc_put_connection_superhack);
LASSERT(namelen > 0);
read_lock(&obd_dev_lock);
- for (i = 0; i < class_devno_max(); i++) {
- obd = class_num2obd(i);
+ for (i = 0; i < class_devno_max(); i++) {
+ obd = class_num2obd(i);
- if (obd == NULL || obd->obd_set_up == 0 || obd->obd_stopping)
- continue;
+ if (obd == NULL || obd->obd_set_up == 0 || obd->obd_stopping)
+ continue;
- /* only notify mdc, osc, mdt, ost */
- type = obd->obd_type->typ_name;
- if (strcmp(type, LUSTRE_MDC_NAME) != 0 &&
- strcmp(type, LUSTRE_OSC_NAME) != 0 &&
- strcmp(type, LUSTRE_MDT_NAME) != 0 &&
- strcmp(type, LUSTRE_OST_NAME) != 0)
- continue;
+ /* only notify mdc, osc, osp, lwp, mdt, ost
+ * because only these have a -sptlrpc llog */
+ type = obd->obd_type->typ_name;
+ if (strcmp(type, LUSTRE_MDC_NAME) != 0 &&
+ strcmp(type, LUSTRE_OSC_NAME) != 0 &&
+ strcmp(type, LUSTRE_OSP_NAME) != 0 &&
+ strcmp(type, LUSTRE_LWP_NAME) != 0 &&
+ strcmp(type, LUSTRE_MDT_NAME) != 0 &&
+ strcmp(type, LUSTRE_OST_NAME) != 0)
+ continue;
if (strncmp(obd->obd_name, fsname, namelen))
continue;
RETURN(NULL);
}
- CDEBUG(D_INFO, "looking for export cookie "LPX64"\n", conn->cookie);
+ CDEBUG(D_INFO, "looking for export cookie %#llx\n", conn->cookie);
export = class_handle2object(conn->cookie, NULL);
RETURN(export);
}
if (atomic_dec_and_test(&exp->exp_refcount)) {
LASSERT(!list_empty(&exp->exp_obd_chain));
- CDEBUG(D_IOCTL, "final put %p/%s\n",
- exp, exp->exp_client_uuid.uuid);
+ 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);
+ /* release nid stat refererence */
+ lprocfs_exp_cleanup(exp);
- obd_zombie_export_add(exp);
- }
+ obd_zombie_export_add(exp);
+ }
}
EXPORT_SYMBOL(class_export_put);
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);
+ INIT_LIST_HEAD(&export->exp_stale_list);
export->exp_sp_peer = LUSTRE_SP_ANY;
export->exp_flvr.sf_rpc = SPTLRPC_FLVR_INVALID;
&exp->exp_client_uuid,
&exp->exp_uuid_hash);
+ 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);
+ }
+
list_move(&exp->exp_obd_chain, &exp->exp_obd->obd_unlinked_exports);
list_del_init(&exp->exp_obd_chain_timed);
exp->exp_obd->obd_num_exports--;
spin_unlock(&exp->exp_obd->obd_dev_lock);
- class_export_put(exp);
+ atomic_inc(&obd_stale_export_num);
+
+ /* A reference is kept by obd_stale_exports list */
+ obd_stale_export_put(exp);
}
+EXPORT_SYMBOL(class_unlink_export);
/* Import management functions */
static void class_import_destroy(struct obd_import *imp)
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)
INIT_LIST_HEAD(&imp->imp_sending_list);
INIT_LIST_HEAD(&imp->imp_delayed_list);
INIT_LIST_HEAD(&imp->imp_committed_list);
+ INIT_LIST_HEAD(&imp->imp_unreplied_list);
+ imp->imp_known_replied_xid = 0;
imp->imp_replay_cursor = &imp->imp_committed_list;
spin_lock_init(&imp->imp_lock);
imp->imp_last_success_conn = 0;
mutex_init(&imp->imp_sec_mutex);
init_waitqueue_head(&imp->imp_recovery_waitq);
+ 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);
atomic_set(&imp->imp_inflight, 0);
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)
{
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
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);
}
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))
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);
+ print_export_data(exp, "EVICTING", 0, D_HA);
}
spin_unlock(&obd->obd_dev_lock);
#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;
}
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,
+ 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),
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);
+ print_export_data(exp, "ZOMBIE", locks, debug_level);
spin_unlock(&obd_zombie_impexp_lock);
}
"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);
* Add export to the obd_zombe thread and notify it.
*/
static void obd_zombie_export_add(struct obd_export *exp) {
+ atomic_dec(&obd_stale_export_num);
spin_lock(&exp->exp_obd->obd_dev_lock);
LASSERT(!list_empty(&exp->exp_obd_chain));
list_del_init(&exp->exp_obd_chain);
*/
static void obd_zombie_import_add(struct obd_import *imp) {
LASSERT(imp->imp_sec == NULL);
- LASSERT(imp->imp_rq_pool == NULL);
spin_lock(&obd_zombie_impexp_lock);
LASSERT(list_empty(&imp->imp_zombie_chain));
zombies_count++;
EXPORT_SYMBOL(obd_zombie_barrier);
+struct obd_export *obd_stale_export_get(void)
+{
+ struct obd_export *exp = NULL;
+ ENTRY;
+
+ 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);
+ list_del_init(&exp->exp_stale_list);
+ }
+ spin_unlock(&obd_stale_export_lock);
+
+ if (exp) {
+ CDEBUG(D_DLMTRACE, "Get export %p: total %d\n", exp,
+ atomic_read(&obd_stale_export_num));
+ }
+ RETURN(exp);
+}
+EXPORT_SYMBOL(obd_stale_export_get);
+
+void obd_stale_export_put(struct obd_export *exp)
+{
+ ENTRY;
+
+ LASSERT(list_empty(&exp->exp_stale_list));
+ if (exp->exp_lock_hash &&
+ atomic_read(&exp->exp_lock_hash->hs_count)) {
+ CDEBUG(D_DLMTRACE, "Put export %p: total %d\n", exp,
+ atomic_read(&obd_stale_export_num));
+
+ spin_lock_bh(&exp->exp_bl_list_lock);
+ spin_lock(&obd_stale_export_lock);
+ /* Add to the tail if there is no blocked locks,
+ * to the head otherwise. */
+ if (list_empty(&exp->exp_bl_list))
+ list_add_tail(&exp->exp_stale_list,
+ &obd_stale_exports);
+ else
+ list_add(&exp->exp_stale_list,
+ &obd_stale_exports);
+
+ spin_unlock(&obd_stale_export_lock);
+ spin_unlock_bh(&exp->exp_bl_list_lock);
+ } else {
+ class_export_put(exp);
+ }
+ EXIT;
+}
+EXPORT_SYMBOL(obd_stale_export_put);
+
+/**
+ * Adjust the position of the export in the stale list,
+ * i.e. move to the head of the list if is needed.
+ **/
+void obd_stale_export_adjust(struct obd_export *exp)
+{
+ LASSERT(exp != NULL);
+ spin_lock_bh(&exp->exp_bl_list_lock);
+ spin_lock(&obd_stale_export_lock);
+
+ if (!list_empty(&exp->exp_stale_list) &&
+ !list_empty(&exp->exp_bl_list))
+ list_move(&exp->exp_stale_list, &obd_stale_exports);
+
+ spin_unlock(&obd_stale_export_lock);
+ spin_unlock_bh(&exp->exp_bl_list_lock);
+}
+EXPORT_SYMBOL(obd_stale_export_adjust);
+
/**
* destroy zombie export/import thread.
*/
}
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
*/
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));
+ i, mod, pct(mod, mod_tot),
+ pct(mod_cum, mod_tot));
if (mod_cum == mod_tot)
break;
}