

Recast this as a formal JBD entry point.


---

 25-akpm/fs/ext3/balloc.c    |   28 ++--------------------------
 25-akpm/fs/jbd/journal.c    |   34 ++++++++++++++++++++++++++++++++++
 25-akpm/include/linux/jbd.h |    1 +
 3 files changed, 37 insertions(+), 26 deletions(-)

diff -puN fs/jbd/journal.c~ext3-retry-allocation-after-transaction-commit-v2-jbd-api fs/jbd/journal.c
--- 25/fs/jbd/journal.c~ext3-retry-allocation-after-transaction-commit-v2-jbd-api	2004-05-20 00:04:58.390761800 -0700
+++ 25-akpm/fs/jbd/journal.c	2004-05-20 00:11:04.682077056 -0700
@@ -73,6 +73,7 @@ EXPORT_SYMBOL(journal_ack_err);
 EXPORT_SYMBOL(journal_clear_err);
 EXPORT_SYMBOL(log_wait_commit);
 EXPORT_SYMBOL(journal_start_commit);
+EXPORT_SYMBOL(journal_force_commit_nested);
 EXPORT_SYMBOL(journal_wipe);
 EXPORT_SYMBOL(journal_blocks_per_page);
 EXPORT_SYMBOL(journal_invalidatepage);
@@ -465,6 +466,39 @@ int log_start_commit(journal_t *journal,
 }
 
 /*
+ * Force and wait upon a commit if the calling process is not within
+ * transaction.  This is used for forcing out undo-protected data which contains
+ * bitmaps, when the fs is running out of space.
+ *
+ * We can only force the running transaction if we don't have an active handle;
+ * otherwise, we will deadlock.
+ *
+ * Returns true if a transaction was started.
+ */
+int journal_force_commit_nested(journal_t *journal)
+{
+	transaction_t *transaction = NULL;
+	tid_t tid;
+
+	spin_lock(&journal->j_state_lock);
+	if (journal->j_running_transaction && !current->journal_info) {
+		transaction = journal->j_running_transaction;
+		__log_start_commit(journal, transaction->t_tid);
+	} else if (journal->j_committing_transaction)
+		transaction = journal->j_committing_transaction;
+
+	if (!transaction) {
+		spin_unlock(&journal->j_state_lock);
+		return 0;	/* Nothing to retry */
+	}
+
+	tid = transaction->t_tid;
+	spin_unlock(&journal->j_state_lock);
+	log_wait_commit(journal, tid);
+	return 1;
+}
+
+/*
  * Start a commit of the current running transaction (if any).  Returns true
  * if a transaction was started, and fills its tid in at *ptid
  */
diff -puN fs/ext3/balloc.c~ext3-retry-allocation-after-transaction-commit-v2-jbd-api fs/ext3/balloc.c
--- 25/fs/ext3/balloc.c~ext3-retry-allocation-after-transaction-commit-v2-jbd-api	2004-05-20 00:04:58.411758608 -0700
+++ 25-akpm/fs/ext3/balloc.c	2004-05-20 00:12:10.623052504 -0700
@@ -977,43 +977,19 @@ static int ext3_has_free_blocks(struct e
 }
 
 /*
- * Ext3_should_retry_alloc is called when ENOSPC is returned, and if
+ * ext3_should_retry_alloc() is called when ENOSPC is returned, and if
  * it is profitable to retry the operation, this function will wait
  * for the current or commiting transaction to complete, and then
  * return TRUE.
  */
 int ext3_should_retry_alloc(struct super_block *sb, int *retries)
 {
-	transaction_t *transaction = NULL;
-	journal_t *journal = EXT3_SB(sb)->s_journal;
-	tid_t tid;
-
 	if (!ext3_has_free_blocks(EXT3_SB(sb)) || (*retries)++ > 3)
 		return 0;
 
 	jbd_debug(1, "%s: retrying operation after ENOSPC\n", sb->s_id);
 
-	/*
-	 * We can only force the running transaction if we don't have
-	 * an active handle; otherwise, we will deadlock.
-	 */
-	spin_lock(&journal->j_state_lock);
-	if (journal->j_running_transaction && !current->journal_info) {
-		transaction = journal->j_running_transaction;
-		__log_start_commit(journal, transaction->t_tid);
-	} else if (journal->j_committing_transaction)
-		transaction = journal->j_committing_transaction;
-
-	if (!transaction) {
-		spin_unlock(&journal->j_state_lock);
-		return 0;	/* Nothing to retry */
-	}
-
-	tid = transaction->t_tid;
-	spin_unlock(&journal->j_state_lock);
-	log_wait_commit(journal, tid);
-
-	return 1;
+	return journal_force_commit_nested(EXT3_SB(sb)->s_journal);
 }
 
 /*
diff -puN include/linux/jbd.h~ext3-retry-allocation-after-transaction-commit-v2-jbd-api include/linux/jbd.h
--- 25/include/linux/jbd.h~ext3-retry-allocation-after-transaction-commit-v2-jbd-api	2004-05-20 00:11:09.466349736 -0700
+++ 25-akpm/include/linux/jbd.h	2004-05-20 00:11:33.140750680 -0700
@@ -1006,6 +1006,7 @@ int __log_space_left(journal_t *); /* Ca
 int log_start_commit(journal_t *journal, tid_t tid);
 int __log_start_commit(journal_t *journal, tid_t tid);
 int journal_start_commit(journal_t *journal, tid_t *tid);
+int journal_force_commit_nested(journal_t *journal);
 int log_wait_commit(journal_t *journal, tid_t tid);
 int log_do_checkpoint(journal_t *journal);
 

_
