LU-694 config: make 'jobid_var' global

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

diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c
index 5419f8c..d97d396 100644 (file)
--- a/lustre/fid/fid_request.c
+++ b/lustre/fid/fid_request.c
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
@@ -28,6 +26,8 @@
 /*
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2012, Whamcloud, Inc.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -149,7 +149,7 @@ int seq_client_alloc_super(struct lu_client_seq *seq,
         int rc;
         ENTRY;
 
-        cfs_down(&seq->lcs_sem);
+        cfs_mutex_lock(&seq->lcs_mutex);
 
 #ifdef __KERNEL__
         if (seq->lcs_srv) {
@@ -163,13 +163,13 @@ int seq_client_alloc_super(struct lu_client_seq *seq,
 #ifdef __KERNEL__
         }
 #endif
-        cfs_up(&seq->lcs_sem);
+        cfs_mutex_unlock(&seq->lcs_mutex);
         RETURN(rc);
 }
 
 /* Request sequence-controller node to allocate new meta-sequence. */
-static int seq_client_alloc_meta(struct lu_client_seq *seq,
-                                 const struct lu_env *env)
+static int seq_client_alloc_meta(const struct lu_env *env,
+                                 struct lu_client_seq *seq)
 {
         int rc;
         ENTRY;
@@ -189,7 +189,8 @@ static int seq_client_alloc_meta(struct lu_client_seq *seq,
 }
 
 /* Allocate new sequence for client. */
-static int seq_client_alloc_seq(struct lu_client_seq *seq, seqno_t *seqnr)
+static int seq_client_alloc_seq(const struct lu_env *env,
+                                struct lu_client_seq *seq, seqno_t *seqnr)
 {
         int rc;
         ENTRY;
@@ -197,9 +198,9 @@ static int seq_client_alloc_seq(struct lu_client_seq *seq, seqno_t *seqnr)
         LASSERT(range_is_sane(&seq->lcs_space));
 
         if (range_is_exhausted(&seq->lcs_space)) {
-                rc = seq_client_alloc_meta(seq, NULL);
+                rc = seq_client_alloc_meta(env, seq);
                 if (rc) {
-                        CERROR("%s: Can't allocate new meta-sequence, "
+                        CERROR("%s: Can't allocate new meta-sequence,"
                                "rc %d\n", seq->lcs_name, rc);
                         RETURN(rc);
                 } else {
@@ -226,30 +227,77 @@ static int seq_fid_alloc_prep(struct lu_client_seq *seq,
         if (seq->lcs_update) {
                 cfs_waitq_add(&seq->lcs_waitq, link);
                 cfs_set_current_state(CFS_TASK_UNINT);
-                cfs_up(&seq->lcs_sem);
+                cfs_mutex_unlock(&seq->lcs_mutex);
 
                 cfs_waitq_wait(link, CFS_TASK_UNINT);
 
-                cfs_down(&seq->lcs_sem);
+                cfs_mutex_lock(&seq->lcs_mutex);
                 cfs_waitq_del(&seq->lcs_waitq, link);
                 cfs_set_current_state(CFS_TASK_RUNNING);
                 return -EAGAIN;
         }
         ++seq->lcs_update;
-        cfs_up(&seq->lcs_sem);
+        cfs_mutex_unlock(&seq->lcs_mutex);
         return 0;
 }
 
 static void seq_fid_alloc_fini(struct lu_client_seq *seq)
 {
         LASSERT(seq->lcs_update == 1);
-        cfs_down(&seq->lcs_sem);
+        cfs_mutex_lock(&seq->lcs_mutex);
         --seq->lcs_update;
         cfs_waitq_signal(&seq->lcs_waitq);
 }
 
+/* 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)
+{
+        cfs_waitlink_t link;
+        int rc;
+
+        LASSERT(seqnr != NULL);
+        cfs_mutex_lock(&seq->lcs_mutex);
+        cfs_waitlink_init(&link);
+
+        while (1) {
+                rc = seq_fid_alloc_prep(seq, &link);
+                if (rc == 0)
+                        break;
+        }
+
+        rc = seq_client_alloc_seq(env, seq, seqnr);
+        if (rc) {
+                CERROR("%s: Can't allocate new sequence, "
+                       "rc %d\n", seq->lcs_name, rc);
+                seq_fid_alloc_fini(seq);
+                cfs_mutex_unlock(&seq->lcs_mutex);
+                return rc;
+        }
+
+        CDEBUG(D_INFO, "%s: allocate sequence "
+               "[0x%16.16"LPF64"x]\n", seq->lcs_name, *seqnr);
+
+        /*Since the caller require the whole seq,
+         *so marked this seq to be used*/
+        seq->lcs_fid.f_oid = LUSTRE_SEQ_MAX_WIDTH;
+        seq->lcs_fid.f_seq = *seqnr;
+        seq->lcs_fid.f_ver = 0;
+
+        /*
+         * Inform caller that sequence switch is performed to allow it
+         * to setup FLD for it.
+         */
+        seq_fid_alloc_fini(seq);
+        cfs_mutex_unlock(&seq->lcs_mutex);
+
+        return rc;
+}
+EXPORT_SYMBOL(seq_client_get_seq);
+
 /* Allocate new fid on passed client @seq and save it to @fid. */
-int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid)
+int seq_client_alloc_fid(const struct lu_env *env,
+                         struct lu_client_seq *seq, struct lu_fid *fid)
 {
         cfs_waitlink_t link;
         int rc;
@@ -259,7 +307,7 @@ int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid)
         LASSERT(fid != NULL);
 
         cfs_waitlink_init(&link);
-        cfs_down(&seq->lcs_sem);
+        cfs_mutex_lock(&seq->lcs_mutex);
 
         while (1) {
                 seqno_t seqnr;
@@ -276,12 +324,12 @@ int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid)
                 if (rc)
                         continue;
 
-                rc = seq_client_alloc_seq(seq, &seqnr);
+                rc = seq_client_alloc_seq(env, seq, &seqnr);
                 if (rc) {
                         CERROR("%s: Can't allocate new sequence, "
                                "rc %d\n", seq->lcs_name, rc);
                         seq_fid_alloc_fini(seq);
-                        cfs_up(&seq->lcs_sem);
+                        cfs_mutex_unlock(&seq->lcs_mutex);
                         RETURN(rc);
                 }
 
@@ -303,7 +351,7 @@ int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid)
         }
 
         *fid = seq->lcs_fid;
-        cfs_up(&seq->lcs_sem);
+        cfs_mutex_unlock(&seq->lcs_mutex);
 
         CDEBUG(D_INFO, "%s: Allocated FID "DFID"\n", seq->lcs_name,  PFID(fid));
         RETURN(rc);
@@ -316,8 +364,24 @@ EXPORT_SYMBOL(seq_client_alloc_fid);
  */
 void seq_client_flush(struct lu_client_seq *seq)
 {
+        cfs_waitlink_t link;
+
         LASSERT(seq != NULL);
-        cfs_down(&seq->lcs_sem);
+        cfs_waitlink_init(&link);
+        cfs_mutex_lock(&seq->lcs_mutex);
+
+        while (seq->lcs_update) {
+                cfs_waitq_add(&seq->lcs_waitq, &link);
+                cfs_set_current_state(CFS_TASK_UNINT);
+                cfs_mutex_unlock(&seq->lcs_mutex);
+
+                cfs_waitq_wait(&link, CFS_TASK_UNINT);
+
+                cfs_mutex_lock(&seq->lcs_mutex);
+                cfs_waitq_del(&seq->lcs_waitq, &link);
+                cfs_set_current_state(CFS_TASK_RUNNING);
+        }
+
         fid_zero(&seq->lcs_fid);
         /**
          * this id shld not be used for seq range allocation.
@@ -327,7 +391,7 @@ void seq_client_flush(struct lu_client_seq *seq)
         seq->lcs_space.lsr_index = -1;
 
         range_init(&seq->lcs_space);
-        cfs_up(&seq->lcs_sem);
+        cfs_mutex_unlock(&seq->lcs_mutex);
 }
 EXPORT_SYMBOL(seq_client_flush);
 
@@ -402,7 +466,7 @@ int seq_client_init(struct lu_client_seq *seq,
         seq->lcs_exp = exp;
         seq->lcs_srv = srv;
         seq->lcs_type = type;
-        cfs_sema_init(&seq->lcs_sem, 1);
+        cfs_mutex_init(&seq->lcs_mutex);
         seq->lcs_width = LUSTRE_SEQ_MAX_WIDTH;
         cfs_waitq_init(&seq->lcs_waitq);