int start_shrinker_timer()
{
/* initialize shriner timer */
cfs_timer_init(&shrinker_timer, shrinker_timer_proc, NULL);
/* start the timer to trigger in 5 minutes */
cfs_timer_arm(&shrinker_timer, 300);
return 0;
}
/* time ut test proc */
void shrinker_timer_proc(ulong_ptr_t arg)
{
struct shrinker *s;
spin_lock(&shrinker_guard);
cfs_list_for_each_entry_typed(s, &shrinker_hdr,
struct shrinker, list) {
s->cb(s->nr, __GFP_FS);
}
spin_unlock(&shrinker_guard);
cfs_timer_arm(&shrinker_timer, 300);
}
void lc_watchdog_touch(struct lc_watchdog *lcw, int timeout)
{
ENTRY;
LASSERT(lcw != NULL);
lc_watchdog_del_pending(lcw);
lcw_update_time(lcw, "resumed");
lcw->lcw_state = LC_WATCHDOG_ENABLED;
cfs_timer_arm(&lcw->lcw_timer, cfs_time_current() +
cfs_time_seconds(timeout));
EXIT;
}
int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt)
{
struct lustre_capa_key *keys = mdt->mdt_capa_keys;
struct mdt_thread_info *mti;
struct dt_object *obj;
struct lu_attr *la;
mdsno_t mdsnum;
unsigned long size;
int rc;
ENTRY;
mdsnum = mdt_seq_site(mdt)->ss_node_id;
mti = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
LASSERT(mti != NULL);
la = &mti->mti_attr.ma_attr;
obj = mdt->mdt_ck_obj;
rc = obj->do_ops->do_attr_get(env, mdt->mdt_ck_obj, la, BYPASS_CAPA);
if (rc)
RETURN(rc);
size = (unsigned long)la->la_size;
if (size == 0) {
int i;
for (i = 0; i < 2; i++) {
make_capa_key(&keys[i], mdsnum, i);
DEBUG_CAPA_KEY(D_SEC, &keys[i], "initializing");
}
rc = write_capa_keys(env, mdt, keys);
if (rc) {
CERROR("error writing MDS %s: rc %d\n", CAPA_KEYS, rc);
RETURN(rc);
}
} else {
rc = read_capa_keys(env, mdt, keys);
if (rc) {
CERROR("error reading MDS %s: rc %d\n", CAPA_KEYS, rc);
RETURN(rc);
}
}
set_capa_key_expiry(mdt);
cfs_timer_arm(&mdt->mdt_ck_timer, mdt->mdt_ck_expiry);
CDEBUG(D_SEC, "mds_ck_timer %lu\n", mdt->mdt_ck_expiry);
RETURN(0);
}
static int osp_statfs_interpret(const struct lu_env *env,
struct ptlrpc_request *req,
union ptlrpc_async_args *aa, int rc)
{
struct obd_import *imp = req->rq_import;
struct obd_statfs *msfs;
struct osp_device *d;
ENTRY;
aa = ptlrpc_req_async_args(req);
d = aa->pointer_arg[0];
LASSERT(d);
if (rc != 0)
GOTO(out, rc);
msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
if (msfs == NULL)
GOTO(out, rc = -EPROTO);
d->opd_statfs = *msfs;
osp_pre_update_status(d, rc);
/* schedule next update */
d->opd_statfs_fresh_till = cfs_time_shift(d->opd_statfs_maxage);
cfs_timer_arm(&d->opd_statfs_timer, d->opd_statfs_fresh_till);
d->opd_statfs_update_in_progress = 0;
CDEBUG(D_CACHE, "updated statfs %p\n", d);
RETURN(0);
out:
/* couldn't update statfs, try again as soon as possible */
if (d->opd_pre != NULL && osp_precreate_running(d))
wake_up(&d->opd_pre_waitq);
if (req->rq_import_generation == imp->imp_generation)
CDEBUG(D_CACHE, "%s: couldn't update statfs: rc = %d\n",
d->opd_obd->obd_name, rc);
RETURN(rc);
}
struct lc_watchdog *lc_watchdog_add(int timeout,
void (*callback)(pid_t, void *),
void *data)
{
struct lc_watchdog *lcw = NULL;
ENTRY;
LIBCFS_ALLOC(lcw, sizeof(*lcw));
if (lcw == NULL) {
CDEBUG(D_INFO, "Could not allocate new lc_watchdog\n");
RETURN(ERR_PTR(-ENOMEM));
}
cfs_spin_lock_init(&lcw->lcw_lock);
lcw->lcw_refcount = 1; /* refcount for owner */
lcw->lcw_task = cfs_current();
lcw->lcw_pid = cfs_curproc_pid();
lcw->lcw_callback = (callback != NULL) ? callback : lc_watchdog_dumplog;
lcw->lcw_data = data;
lcw->lcw_state = LC_WATCHDOG_DISABLED;
CFS_INIT_LIST_HEAD(&lcw->lcw_list);
cfs_timer_init(&lcw->lcw_timer, lcw_cb, lcw);
cfs_down(&lcw_refcount_sem);
if (++lcw_refcount == 1)
lcw_dispatch_start();
cfs_up(&lcw_refcount_sem);
/* Keep this working in case we enable them by default */
if (lcw->lcw_state == LC_WATCHDOG_ENABLED) {
lcw->lcw_last_touched = cfs_time_current();
cfs_timer_arm(&lcw->lcw_timer, cfs_time_seconds(timeout) +
cfs_time_current());
}
RETURN(lcw);
}
static int mdt_ck_thread_main(void *args)
{
struct mdt_device *mdt = args;
struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
struct lustre_capa_key *bkey = &mdt->mdt_capa_keys[0],
*rkey = &mdt->mdt_capa_keys[1];
struct lustre_capa_key *tmp;
struct lu_env env;
struct mdt_thread_info *info;
struct md_device *next;
struct l_wait_info lwi = { 0 };
mdsno_t mdsnum;
int rc;
ENTRY;
unshare_fs_struct();
cfs_block_allsigs();
thread_set_flags(thread, SVC_RUNNING);
wake_up(&thread->t_ctl_waitq);
rc = lu_env_init(&env, LCT_MD_THREAD|LCT_REMEMBER|LCT_NOREF);
if (rc)
RETURN(rc);
thread->t_env = &env;
env.le_ctx.lc_thread = thread;
env.le_ctx.lc_cookie = 0x1;
info = lu_context_key_get(&env.le_ctx, &mdt_thread_key);
LASSERT(info != NULL);
tmp = &info->mti_capa_key;
mdsnum = mdt_seq_site(mdt)->ss_node_id;
while (1) {
l_wait_event(thread->t_ctl_waitq,
thread_is_stopping(thread) ||
thread_is_event(thread),
&lwi);
if (thread_is_stopping(thread))
break;
thread_clear_flags(thread, SVC_EVENT);
if (cfs_time_before(cfs_time_current(), mdt->mdt_ck_expiry))
break;
*tmp = *rkey;
make_capa_key(tmp, mdsnum, rkey->lk_keyid);
next = mdt->mdt_child;
rc = next->md_ops->mdo_update_capa_key(&env, next, tmp);
if (!rc) {
spin_lock(&capa_lock);
*bkey = *rkey;
*rkey = *tmp;
spin_unlock(&capa_lock);
rc = write_capa_keys(&env, mdt, mdt->mdt_capa_keys);
if (rc) {
spin_lock(&capa_lock);
*rkey = *bkey;
memset(bkey, 0, sizeof(*bkey));
spin_unlock(&capa_lock);
} else {
set_capa_key_expiry(mdt);
DEBUG_CAPA_KEY(D_SEC, rkey, "new");
}
}
if (rc) {
DEBUG_CAPA_KEY(D_ERROR, rkey, "update failed for");
/* next retry is in 300 sec */
mdt->mdt_ck_expiry = jiffies + 300 * HZ;
}
cfs_timer_arm(&mdt->mdt_ck_timer, mdt->mdt_ck_expiry);
CDEBUG(D_SEC, "mdt_ck_timer %lu\n", mdt->mdt_ck_expiry);
}
lu_env_fini(&env);
thread_set_flags(thread, SVC_STOPPED);
wake_up(&thread->t_ctl_waitq);
RETURN(0);
}
