Whamcloud - gitweb
LU-5443 lustre: replace direct HZ access with kernel APIs
[fs/lustre-release.git] / lustre / mdt / mdt_capa.c
index 567a0f8..5696808 100644 (file)
 
 static inline void set_capa_key_expiry(struct mdt_device *mdt)
 {
-        mdt->mdt_ck_expiry = jiffies + mdt->mdt_ck_timeout * CFS_HZ;
+       mdt->mdt_ck_expiry = jiffies + msecs_to_jiffies(mdt->mdt_ck_timeout *
+                                                       MSEC_PER_SEC);
 }
 
-static void make_capa_key(struct lustre_capa_key *key,
-                          mdsno_t mdsnum, int keyid)
+static void make_capa_key(struct lustre_capa_key *key, u32 mdsnum, int keyid)
 {
         key->lk_seq = mdsnum;
         key->lk_keyid = keyid + 1;
@@ -91,7 +91,8 @@ static int write_capa_keys(const struct lu_env *env,
                RETURN(PTR_ERR(th));
 
        rc = dt_declare_record_write(env, mdt->mdt_ck_obj,
-                                    sizeof(*tmp) * 3, 0, th);
+                                    mdt_buf_const(env, NULL,
+                                    sizeof(*tmp) * 3), 0, th);
        if (rc)
                goto stop;
 
@@ -149,7 +150,7 @@ int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt)
         struct mdt_thread_info  *mti;
         struct dt_object        *obj;
         struct lu_attr          *la;
-        mdsno_t                  mdsnum;
+       u32                      mdsnum;
         unsigned long            size;
         int                      rc;
         ENTRY;
@@ -194,68 +195,68 @@ int mdt_capa_keys_init(const struct lu_env *env, struct mdt_device *mdt)
 
 void mdt_ck_timer_callback(unsigned long castmeharder)
 {
-        struct mdt_device *mdt = (struct mdt_device *)castmeharder;
-        struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
+       struct mdt_device *mdt = (struct mdt_device *)castmeharder;
+       struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
 
-        ENTRY;
-        thread_add_flags(thread, SVC_EVENT);
-        cfs_waitq_signal(&thread->t_ctl_waitq);
-        EXIT;
+       ENTRY;
+       thread_add_flags(thread, SVC_EVENT);
+       wake_up(&thread->t_ctl_waitq);
+       EXIT;
 }
 
 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;
-
-        cfs_daemonize_ctxt("mdt_ck");
-        cfs_block_allsigs();
-
-        thread_set_flags(thread, SVC_RUNNING);
-        cfs_waitq_signal(&thread->t_ctl_waitq);
-
-        rc = lu_env_init(&env, LCT_MD_THREAD|LCT_REMEMBER|LCT_NOREF);
-        if (rc)
-                RETURN(rc);
+       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 };
+       u32                     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;
+       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);
+       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);
+       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 (thread_is_stopping(thread))
+                       break;
+               thread_clear_flags(thread, SVC_EVENT);
 
-                if (cfs_time_before(cfs_time_current(), mdt->mdt_ck_expiry))
-                        break;
+               if (cfs_time_before(cfs_time_current(), mdt->mdt_ck_expiry))
+                       break;
 
-                *tmp = *rkey;
-                make_capa_key(tmp, mdsnum, rkey->lk_keyid);
+               *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) {
+               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;
@@ -267,51 +268,53 @@ static int mdt_ck_thread_main(void *args)
                                *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 * CFS_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);
-        cfs_waitq_signal(&thread->t_ctl_waitq);
-        RETURN(0);
+                       } 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 +
+                                            msecs_to_jiffies(300 *
+                                                             MSEC_PER_SEC);
+               }
+
+               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);
 }
 
 int mdt_ck_thread_start(struct mdt_device *mdt)
 {
-        struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
-        int rc;
-
-        cfs_waitq_init(&thread->t_ctl_waitq);
-        rc = cfs_create_thread(mdt_ck_thread_main, mdt, CFS_DAEMON_FLAGS);
-        if (rc < 0) {
-                CERROR("cannot start mdt_ck thread, rc = %d\n", rc);
-                return rc;
-        }
-
-        l_wait_condition(thread->t_ctl_waitq, thread_is_running(thread));
-        return 0;
+       struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
+       struct task_struct *task;
+
+       init_waitqueue_head(&thread->t_ctl_waitq);
+       task = kthread_run(mdt_ck_thread_main, mdt, "mdt_ck");
+       if (IS_ERR(task)) {
+               CERROR("cannot start mdt_ck thread, rc = %ld\n", PTR_ERR(task));
+               return PTR_ERR(task);
+       }
+
+       l_wait_condition(thread->t_ctl_waitq, thread_is_running(thread));
+       return 0;
 }
 
 void mdt_ck_thread_stop(struct mdt_device *mdt)
 {
-        struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
+       struct ptlrpc_thread *thread = &mdt->mdt_ck_thread;
 
-        if (!thread_is_running(thread))
-                return;
+       if (!thread_is_running(thread))
+               return;
 
-        thread_set_flags(thread, SVC_STOPPING);
-        cfs_waitq_signal(&thread->t_ctl_waitq);
-        l_wait_condition(thread->t_ctl_waitq, thread_is_stopped(thread));
+       thread_set_flags(thread, SVC_STOPPING);
+       wake_up(&thread->t_ctl_waitq);
+       l_wait_condition(thread->t_ctl_waitq, thread_is_stopped(thread));
 }