LU-3540 lod: update recovery thread

[fs/lustre-release.git] / lustre / fid / fid_request.c

diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c
index 544b6ce..528bed7 100644 (file)
--- a/lustre/fid/fid_request.c
+++ b/lustre/fid/fid_request.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -42,13 +42,8 @@
 
 #define DEBUG_SUBSYSTEM S_FID
 
-#ifdef __KERNEL__
-# include <libcfs/libcfs.h>
-# include <linux/module.h>
-#else /* __KERNEL__ */
-# include <liblustre.h>
-#endif
-
+#include <linux/module.h>
+#include <libcfs/libcfs.h>
 #include <obd.h>
 #include <obd_class.h>
 #include <obd_support.h>
@@ -104,13 +99,20 @@ static int seq_client_rpc(struct lu_client_seq *seq,
                        req->rq_no_delay = req->rq_no_resend = 1;
                debug_mask = D_CONSOLE;
        } else {
-               if (seq->lcs_type == LUSTRE_SEQ_METADATA)
+               if (seq->lcs_type == LUSTRE_SEQ_METADATA) {
+                       req->rq_reply_portal = MDC_REPLY_PORTAL;
                        req->rq_request_portal = SEQ_METADATA_PORTAL;
-               else
+               } else {
+                       req->rq_reply_portal = OSC_REPLY_PORTAL;
                        req->rq_request_portal = SEQ_DATA_PORTAL;
+               }
+
                debug_mask = D_INFO;
        }
 
+       /* Allow seq client RPC during recovery time. */
+       req->rq_allow_replay = 1;
+
        ptlrpc_at_set_req_timeout(req);
 
        if (opc != SEQ_ALLOC_SUPER && seq->lcs_type == LUSTRE_SEQ_METADATA)
@@ -209,7 +211,7 @@ static int seq_client_alloc_meta(const struct lu_env *env,
 
 /* Allocate new sequence for client. */
 static int seq_client_alloc_seq(const struct lu_env *env,
-                                struct lu_client_seq *seq, seqno_t *seqnr)
+                               struct lu_client_seq *seq, u64 *seqnr)
 {
         int rc;
         ENTRY;
@@ -248,7 +250,7 @@ static int seq_fid_alloc_prep(struct lu_client_seq *seq,
                set_current_state(TASK_UNINTERRUPTIBLE);
                mutex_unlock(&seq->lcs_mutex);
 
-               waitq_wait(link, TASK_UNINTERRUPTIBLE);
+               schedule();
 
                mutex_lock(&seq->lcs_mutex);
                remove_wait_queue(&seq->lcs_waitq, link);
@@ -272,14 +274,14 @@ static void seq_fid_alloc_fini(struct lu_client_seq *seq)
  * Allocate the whole seq to the caller.
  **/
 int seq_client_get_seq(const struct lu_env *env,
-                      struct lu_client_seq *seq, seqno_t *seqnr)
+                      struct lu_client_seq *seq, u64 *seqnr)
 {
        wait_queue_t link;
        int rc;
 
        LASSERT(seqnr != NULL);
        mutex_lock(&seq->lcs_mutex);
-       init_waitqueue_entry_current(&link);
+       init_waitqueue_entry(&link, current);
 
         while (1) {
                 rc = seq_fid_alloc_prep(seq, &link);
@@ -330,14 +332,14 @@ int seq_client_alloc_fid(const struct lu_env *env,
        LASSERT(seq != NULL);
        LASSERT(fid != NULL);
 
-       init_waitqueue_entry_current(&link);
+       init_waitqueue_entry(&link, current);
        mutex_lock(&seq->lcs_mutex);
 
        if (OBD_FAIL_CHECK(OBD_FAIL_SEQ_EXHAUST))
                seq->lcs_fid.f_oid = seq->lcs_width;
 
         while (1) {
-                seqno_t seqnr;
+               u64 seqnr;
 
                 if (!fid_is_zero(&seq->lcs_fid) &&
                     fid_oid(&seq->lcs_fid) < seq->lcs_width) {
@@ -394,7 +396,7 @@ void seq_client_flush(struct lu_client_seq *seq)
        wait_queue_t link;
 
        LASSERT(seq != NULL);
-       init_waitqueue_entry_current(&link);
+       init_waitqueue_entry(&link, current);
        mutex_lock(&seq->lcs_mutex);
 
        while (seq->lcs_update) {
@@ -402,7 +404,7 @@ void seq_client_flush(struct lu_client_seq *seq)
                set_current_state(TASK_UNINTERRUPTIBLE);
                mutex_unlock(&seq->lcs_mutex);
 
-               waitq_wait(&link, TASK_UNINTERRUPTIBLE);
+               schedule();
 
                mutex_lock(&seq->lcs_mutex);
                remove_wait_queue(&seq->lcs_waitq, &link);
@@ -424,7 +426,7 @@ EXPORT_SYMBOL(seq_client_flush);
 
 static void seq_client_proc_fini(struct lu_client_seq *seq)
 {
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
        ENTRY;
        if (seq->lcs_proc_dir) {
                if (!IS_ERR(seq->lcs_proc_dir))
@@ -432,18 +434,17 @@ static void seq_client_proc_fini(struct lu_client_seq *seq)
                seq->lcs_proc_dir = NULL;
        }
        EXIT;
-#endif /* LPROCFS */
+#endif /* CONFIG_PROC_FS */
 }
 
 static int seq_client_proc_init(struct lu_client_seq *seq)
 {
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
         int rc;
         ENTRY;
 
-       seq->lcs_proc_dir = lprocfs_seq_register(seq->lcs_name,
-                                                seq_type_proc_dir,
-                                                NULL, NULL);
+       seq->lcs_proc_dir = lprocfs_register(seq->lcs_name, seq_type_proc_dir,
+                                            NULL, NULL);
         if (IS_ERR(seq->lcs_proc_dir)) {
                 CERROR("%s: LProcFS failed in seq-init\n",
                        seq->lcs_name);
@@ -451,8 +452,7 @@ static int seq_client_proc_init(struct lu_client_seq *seq)
                 RETURN(rc);
         }
 
-       rc = lprocfs_seq_add_vars(seq->lcs_proc_dir,
-                                 seq_client_proc_list, seq);
+       rc = lprocfs_add_vars(seq->lcs_proc_dir, seq_client_proc_list, seq);
         if (rc) {
                 CERROR("%s: Can't init sequence manager "
                        "proc, rc %d\n", seq->lcs_name, rc);
@@ -465,9 +465,9 @@ out_cleanup:
         seq_client_proc_fini(seq);
         return rc;
 
-#else /* LPROCFS */
+#else /* !CONFIG_PROC_FS */
        return 0;
-#endif
+#endif /* CONFIG_PROC_FS */
 }
 
 int seq_client_init(struct lu_client_seq *seq,
@@ -571,14 +571,13 @@ int client_fid_fini(struct obd_device *obd)
 }
 EXPORT_SYMBOL(client_fid_fini);
 
-#ifdef __KERNEL__
 struct proc_dir_entry *seq_type_proc_dir;
 
 static int __init fid_mod_init(void)
 {
-       seq_type_proc_dir = lprocfs_seq_register(LUSTRE_SEQ_NAME,
-                                                proc_lustre_root,
-                                                NULL, NULL);
+       seq_type_proc_dir = lprocfs_register(LUSTRE_SEQ_NAME,
+                                            proc_lustre_root,
+                                            NULL, NULL);
        if (IS_ERR(seq_type_proc_dir))
                return PTR_ERR(seq_type_proc_dir);
 
@@ -603,7 +602,8 @@ static void __exit fid_mod_exit(void)
 
 MODULE_AUTHOR("Sun Microsystems, Inc. <http://www.lustre.org/>");
 MODULE_DESCRIPTION("Lustre FID Module");
+MODULE_VERSION(LUSTRE_VERSION_STRING);
 MODULE_LICENSE("GPL");
 
-cfs_module(fid, "0.1.0", fid_mod_init, fid_mod_exit);
-#endif /* __KERNEL__ */
+module_init(fid_mod_init);
+module_exit(fid_mod_exit);