]> git.karo-electronics.de Git - karo-tx-linux.git/commitdiff
ext4: clean up compiler warning in start_this_handle()
authorTheodore Ts'o <tytso@mit.edu>
Mon, 9 Aug 2010 21:28:38 +0000 (17:28 -0400)
committerTheodore Ts'o <tytso@mit.edu>
Mon, 9 Aug 2010 21:28:38 +0000 (17:28 -0400)
Fix the compiler warning:

  fs/jbd2/transaction.c: In function ‘start_this_handle’:
  fs/jbd2/transaction.c:98: warning: unused variable ‘ts’

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
fs/jbd2/transaction.c

index d95cc9d0401dda527b6c202ca2b3da11f73eb992..f3479d6e0a83a31c616ab19f260a9062a5a5a5db 100644 (file)
@@ -81,6 +81,32 @@ jbd2_get_transaction(journal_t *journal, transaction_t *transaction)
  * of that one update.
  */
 
+/*
+ * Update transiaction's maximum wait time, if debugging is enabled.
+ *
+ * In order for t_max_wait to be reliable, it must be protected by a
+ * lock.  But doing so will mean that start_this_handle() can not be
+ * run in parallel on SMP systems, which limits our scalability.  So
+ * unless debugging is enabled, we no longer update t_max_wait, which
+ * means that maximum wait time reported by the jbd2_run_stats
+ * tracepoint will always be zero.
+ */
+static inline void update_t_max_wait(transaction_t *transaction)
+{
+#ifdef CONFIG_JBD2_DEBUG
+       unsigned long ts = jiffies;
+
+       if (jbd2_journal_enable_debug &&
+           time_after(transaction->t_start, ts)) {
+               ts = jbd2_time_diff(ts, transaction->t_start);
+               spin_lock(&transaction->t_handle_lock);
+               if (ts > transaction->t_max_wait)
+                       transaction->t_max_wait = ts;
+               spin_unlock(&transaction->t_handle_lock);
+       }
+#endif
+}
+
 /*
  * start_this_handle: Given a handle, deal with any locking or stalling
  * needed to make sure that there is enough journal space for the handle
@@ -95,7 +121,6 @@ static int start_this_handle(journal_t *journal, handle_t *handle,
        int needed;
        int nblocks = handle->h_buffer_credits;
        transaction_t *new_transaction = NULL;
-       unsigned long ts = jiffies;
 
        if (nblocks > journal->j_max_transaction_buffers) {
                printk(KERN_ERR "JBD: %s wants too many credits (%d > %d)\n",
@@ -241,25 +266,8 @@ repeat:
 
        /* OK, account for the buffers that this operation expects to
         * use and add the handle to the running transaction. 
-        *
-        * In order for t_max_wait to be reliable, it must be
-        * protected by a lock.  But doing so will mean that
-        * start_this_handle() can not be run in parallel on SMP
-        * systems, which limits our scalability.  So we only enable
-        * it when debugging is enabled.  We may want to use a
-        * separate flag, eventually, so we can enable this
-        * independently of debugging.
         */
-#ifdef CONFIG_JBD2_DEBUG
-       if (jbd2_journal_enable_debug &&
-           time_after(transaction->t_start, ts)) {
-               ts = jbd2_time_diff(ts, transaction->t_start);
-               spin_lock(&transaction->t_handle_lock);
-               if (ts > transaction->t_max_wait)
-                       transaction->t_max_wait = ts;
-               spin_unlock(&transaction->t_handle_lock);
-       }
-#endif
+       update_t_max_wait(transaction);
        handle->h_transaction = transaction;
        atomic_inc(&transaction->t_updates);
        atomic_inc(&transaction->t_handle_count);