memcpy(newbuf, req->rq_reqbuf, req->rq_reqlen);
OBD_FREE(req->rq_reqbuf, req->rq_reqbuf_len);
req->rq_reqbuf = req->rq_reqmsg = newbuf;
req->rq_reqbuf_len = alloc_size;
}
_sptlrpc_enlarge_msg_inplace(req->rq_reqmsg, segment, newsize);
req->rq_reqlen = newmsg_size;
return 0;
}
static struct ptlrpc_svc_ctx null_svc_ctx = {
.sc_refcount = CFS_ATOMIC_INIT(1),
.sc_policy = &null_policy,
};
static
int null_accept(struct ptlrpc_request *req)
{
LASSERT(SPTLRPC_FLVR_POLICY(req->rq_flvr.sf_rpc) ==
SPTLRPC_POLICY_NULL);
if (req->rq_flvr.sf_rpc != SPTLRPC_FLVR_NULL) {
CERROR("Invalid rpc flavor 0x%x\n", req->rq_flvr.sf_rpc);
return SECSVC_DROP;
}
req->rq_sp_from = null_decode_sec_part(req->rq_reqbuf);
/* for obd_capa.c_list, client capa might stay in three places:
* 1. ll_capa_list.
* 2. ll_idle_capas.
* 3. stand alone: just allocated.
*/
/* capas for oss writeback and those failed to renew */
static CFS_LIST_HEAD(ll_idle_capas);
static struct ptlrpc_thread ll_capa_thread;
static cfs_list_t *ll_capa_list = &capa_list[CAPA_SITE_CLIENT];
/* llite capa renewal timer */
struct timer_list ll_capa_timer;
/* for debug: indicate whether capa on llite is enabled or not */
static cfs_atomic_t ll_capa_debug = CFS_ATOMIC_INIT(0);
static unsigned long long ll_capa_renewed = 0;
static unsigned long long ll_capa_renewal_noent = 0;
static unsigned long long ll_capa_renewal_failed = 0;
static unsigned long long ll_capa_renewal_retries = 0;
static inline void update_capa_timer(struct obd_capa *ocapa, cfs_time_t expiry)
{
if (cfs_time_before(expiry, ll_capa_timer.expires) ||
!timer_pending(&ll_capa_timer)) {
mod_timer(&ll_capa_timer, expiry);
DEBUG_CAPA(D_SEC, &ocapa->c_capa,
"ll_capa_timer update: %lu/%lu by", expiry, jiffies);
}
}
int __obd_fail_check_set(__u32 id, __u32 value, int set)
{
static cfs_atomic_t obd_fail_count = CFS_ATOMIC_INIT(0);
LASSERT(!(id & OBD_FAIL_ONCE));
if ((obd_fail_loc & (OBD_FAILED | OBD_FAIL_ONCE)) ==
(OBD_FAILED | OBD_FAIL_ONCE)) {
cfs_atomic_set(&obd_fail_count, 0); /* paranoia */
return 0;
}
/* Fail 1/obd_fail_val times */
if (obd_fail_loc & OBD_FAIL_RAND) {
if (obd_fail_val < 2 || cfs_rand() % obd_fail_val > 0)
return 0;
}
/* Skip the first obd_fail_val, then fail */
if (obd_fail_loc & OBD_FAIL_SKIP) {
if (cfs_atomic_inc_return(&obd_fail_count) <= obd_fail_val)
return 0;
}
/* Fail obd_fail_val times, overridden by FAIL_ONCE */
if (obd_fail_loc & OBD_FAIL_SOME &&
(!(obd_fail_loc & OBD_FAIL_ONCE) || obd_fail_val <= 1)) {
int count = cfs_atomic_inc_return(&obd_fail_count);
if (count >= obd_fail_val) {
cfs_set_bit(OBD_FAIL_ONCE_BIT, &obd_fail_loc);
cfs_atomic_set(&obd_fail_count, 0);
/* we are lost race to increase obd_fail_count */
if (count > obd_fail_val)
return 0;
}
}
if ((set == OBD_FAIL_LOC_ORSET || set == OBD_FAIL_LOC_RESET) &&
(value & OBD_FAIL_ONCE))
cfs_set_bit(OBD_FAIL_ONCE_BIT, &obd_fail_loc);
/* Lost race to set OBD_FAILED_BIT. */
if (cfs_test_and_set_bit(OBD_FAILED_BIT, &obd_fail_loc)) {
/* If OBD_FAIL_ONCE is valid, only one process can fail,
* otherwise multi-process can fail at the same time. */
if (obd_fail_loc & OBD_FAIL_ONCE)
return 0;
}
switch (set) {
case OBD_FAIL_LOC_NOSET:
break;
case OBD_FAIL_LOC_ORSET:
obd_fail_loc |= value & ~(OBD_FAILED | OBD_FAIL_ONCE);
break;
case OBD_FAIL_LOC_RESET:
obd_fail_loc = value;
break;
default:
LASSERTF(0, "called with bad set %u\n", set);
break;
}
return 1;
}
int __cfs_fail_check_set(__u32 id, __u32 value, int set)
{
static cfs_atomic_t cfs_fail_count = CFS_ATOMIC_INIT(0);
LASSERT(!(id & CFS_FAIL_ONCE));
if ((cfs_fail_loc & (CFS_FAILED | CFS_FAIL_ONCE)) ==
(CFS_FAILED | CFS_FAIL_ONCE)) {
cfs_atomic_set(&cfs_fail_count, 0); /* paranoia */
return 0;
}
/* Fail 1/cfs_fail_val times */
if (cfs_fail_loc & CFS_FAIL_RAND) {
if (cfs_fail_val < 2 || cfs_rand() % cfs_fail_val > 0)
return 0;
}
/* Skip the first cfs_fail_val, then fail */
if (cfs_fail_loc & CFS_FAIL_SKIP) {
if (cfs_atomic_inc_return(&cfs_fail_count) <= cfs_fail_val)
return 0;
}
/* check cfs_fail_val... */
if (set == CFS_FAIL_LOC_VALUE) {
if (cfs_fail_val != -1 && cfs_fail_val != value)
return 0;
}
/* Fail cfs_fail_val times, overridden by FAIL_ONCE */
if (cfs_fail_loc & CFS_FAIL_SOME &&
(!(cfs_fail_loc & CFS_FAIL_ONCE) || cfs_fail_val <= 1)) {
int count = cfs_atomic_inc_return(&cfs_fail_count);
if (count >= cfs_fail_val) {
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
cfs_atomic_set(&cfs_fail_count, 0);
/* we are lost race to increase */
if (count > cfs_fail_val)
return 0;
}
}
if ((set == CFS_FAIL_LOC_ORSET || set == CFS_FAIL_LOC_RESET) &&
(value & CFS_FAIL_ONCE))
set_bit(CFS_FAIL_ONCE_BIT, &cfs_fail_loc);
/* Lost race to set CFS_FAILED_BIT. */
if (test_and_set_bit(CFS_FAILED_BIT, &cfs_fail_loc)) {
/* If CFS_FAIL_ONCE is valid, only one process can fail,
* otherwise multi-process can fail at the same time. */
if (cfs_fail_loc & CFS_FAIL_ONCE)
return 0;
}
switch (set) {
case CFS_FAIL_LOC_NOSET:
case CFS_FAIL_LOC_VALUE:
break;
case CFS_FAIL_LOC_ORSET:
cfs_fail_loc |= value & ~(CFS_FAILED | CFS_FAIL_ONCE);
break;
case CFS_FAIL_LOC_RESET:
cfs_fail_loc = value;
break;
default:
LASSERTF(0, "called with bad set %u\n", set);
break;
}
return 1;
}
#define DEBUG_SUBSYSTEM S_LNET
#define LUSTRE_TRACEFILE_PRIVATE
#include "tracefile.h"
#include <libcfs/libcfs.h>
/* XXX move things up to the top, comment */
union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[CFS_NR_CPUS] __cacheline_aligned;
char cfs_tracefile[TRACEFILE_NAME_SIZE];
long long cfs_tracefile_size = CFS_TRACEFILE_SIZE;
static struct tracefiled_ctl trace_tctl;
cfs_semaphore_t cfs_trace_thread_sem;
static int thread_running = 0;
cfs_atomic_t cfs_tage_allocated = CFS_ATOMIC_INIT(0);
static void put_pages_on_tcd_daemon_list(struct page_collection *pc,
struct cfs_trace_cpu_data *tcd);
static inline struct cfs_trace_page *
cfs_tage_from_list(cfs_list_t *list)
{
return cfs_list_entry(list, struct cfs_trace_page, linkage);
}
static struct cfs_trace_page *cfs_tage_alloc(int gfp)
{
cfs_page_t *page;
struct cfs_trace_page *tage;
unsigned int portal_enter_debugger;
EXPORT_SYMBOL(portal_enter_debugger);
unsigned int libcfs_catastrophe;
EXPORT_SYMBOL(libcfs_catastrophe);
unsigned int libcfs_watchdog_ratelimit = 300;
EXPORT_SYMBOL(libcfs_watchdog_ratelimit);
unsigned int libcfs_panic_on_lbug = 1;
CFS_MODULE_PARM(libcfs_panic_on_lbug, "i", uint, 0644,
"Lustre kernel panic on LBUG");
EXPORT_SYMBOL(libcfs_panic_on_lbug);
cfs_atomic_t libcfs_kmemory = CFS_ATOMIC_INIT(0);
EXPORT_SYMBOL(libcfs_kmemory);
static cfs_waitq_t debug_ctlwq;
char libcfs_debug_file_path_arr[PATH_MAX] = LIBCFS_DEBUG_FILE_PATH_DEFAULT;
/* We need to pass a pointer here, but elsewhere this must be a const */
char *libcfs_debug_file_path;
CFS_MODULE_PARM(libcfs_debug_file_path, "s", charp, 0644,
"Path for dumping debug logs, "
"set 'NONE' to prevent log dumping");
int libcfs_panic_in_progress;
/* libcfs_debug_token2mask() expects the returned
*/ #define DEBUG_SUBSYSTEM S_LDLM #ifdef __KERNEL__ # include <lustre_dlm.h> #else # include <liblustre.h> #endif #include <lustre_fid.h> #include <obd_class.h> #include "ldlm_internal.h" cfs_mem_cache_t *ldlm_resource_slab, *ldlm_lock_slab; cfs_atomic_t ldlm_srv_namespace_nr = CFS_ATOMIC_INIT(0); cfs_atomic_t ldlm_cli_namespace_nr = CFS_ATOMIC_INIT(0); struct mutex ldlm_srv_namespace_lock; CFS_LIST_HEAD(ldlm_srv_namespace_list); struct mutex ldlm_cli_namespace_lock; CFS_LIST_HEAD(ldlm_cli_namespace_list); cfs_proc_dir_entry_t *ldlm_type_proc_dir = NULL; cfs_proc_dir_entry_t *ldlm_ns_proc_dir = NULL; cfs_proc_dir_entry_t *ldlm_svc_proc_dir = NULL; extern unsigned int ldlm_cancel_unused_locks_before_replay; /* during debug dump certain amount of granted locks for one resource to avoid
#include "gss_api.h"
static struct proc_dir_entry *gss_proc_root = NULL;
static struct proc_dir_entry *gss_proc_lk = NULL;
/*
* statistic of "out-of-sequence-window"
*/
static struct {
cfs_spinlock_t oos_lock;
cfs_atomic_t oos_cli_count; /* client occurrence */
int oos_cli_behind; /* client max seqs behind */
cfs_atomic_t oos_svc_replay[3]; /* server replay detected */
cfs_atomic_t oos_svc_pass[3]; /* server verified ok */
} gss_stat_oos = {
.oos_cli_count = CFS_ATOMIC_INIT(0),
.oos_cli_behind = 0,
.oos_svc_replay = { CFS_ATOMIC_INIT(0), },
.oos_svc_pass = { CFS_ATOMIC_INIT(0), },
};
void gss_stat_oos_record_cli(int behind)
{
cfs_atomic_inc(&gss_stat_oos.oos_cli_count);
cfs_spin_lock(&gss_stat_oos.oos_lock);
if (behind > gss_stat_oos.oos_cli_behind)
gss_stat_oos.oos_cli_behind = behind;
cfs_spin_unlock(&gss_stat_oos.oos_lock);
}