175 	transaction_t *transaction;  in kjournald2()  local
192 	 * transaction commit and any fs involvement might get stuck waiting for  in kjournald2()
241 		transaction = journal->j_running_transaction;  in kjournald2()
242 		if (transaction && time_after_eq(jiffies,  in kjournald2()
243 						transaction->t_expires))  in kjournald2()
260 	transaction = journal->j_running_transaction;  in kjournald2()
261 	if (transaction && time_after_eq(jiffies, transaction->t_expires)) {  in kjournald2()
262 		journal->j_commit_request = transaction->t_tid;  in kjournald2()
320  * If the source buffer has already been modified by a new transaction
338 int jbd2_journal_write_metadata_buffer(transaction_t *transaction,  in jbd2_journal_write_metadata_buffer()  argument
351 	journal_t *journal = transaction->t_journal;  in jbd2_journal_write_metadata_buffer()
355 	 * transaction is allowed to write it, so nobody else is allowed  in jbd2_journal_write_metadata_buffer()
372 	 * If a new transaction has already done a buffer copy-out, then  in jbd2_journal_write_metadata_buffer()
463 	 * copying is moved to the transaction's shadow queue.  in jbd2_journal_write_metadata_buffer()
467 	__jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);  in jbd2_journal_write_metadata_buffer()
482  * Returns true if a transaction commit was started.
491 	 * The only transaction we can possibly wait upon is the  in __jbd2_log_start_commit()
492 	 * currently running transaction (if it exists).  Otherwise,  in __jbd2_log_start_commit()
533  * transaction if we don't have an active handle, otherwise, we will deadlock.
536  *           1 if transaction was successfully committed.
540 	transaction_t *transaction = NULL;  in __jbd2_journal_force_commit()  local
546 		transaction = journal->j_running_transaction;  in __jbd2_journal_force_commit()
547 		if (!tid_geq(journal->j_commit_request, transaction->t_tid))  in __jbd2_journal_force_commit()
550 		transaction = journal->j_committing_transaction;  in __jbd2_journal_force_commit()
552 	if (!transaction) {  in __jbd2_journal_force_commit()
557 	tid = transaction->t_tid;  in __jbd2_journal_force_commit()
570  * calling process is not within transaction.
590  * Caller want unconditional commit. We can only force the running transaction
605  * Start a commit of the current running transaction (if any).  Returns true
606  * if a transaction is going to be committed (or is currently already
618 		/* There's a running transaction and we've just made sure  in jbd2_journal_start_commit()
626 		 * completion of that transaction.  in jbd2_journal_start_commit()
637  * Return 1 if a given transaction has not yet sent barrier request
638  * connected with a transaction commit. If 0 is returned, transaction
650 	/* Transaction already committed? */  in jbd2_trans_will_send_data_barrier()
659 	 * Transaction is being committed and we already proceeded to  in jbd2_trans_will_send_data_barrier()
688 	 * Some callers make sure transaction is already committing and in that  in jbd2_log_wait_commit()
802 /* Return 1 when transaction with given tid has already committed. */
820  * When this function returns the transaction corresponding to tid
821  * will be completed.  If the transaction has currently running, start
822  * committing that transaction before waiting for it to complete.  If
823  * the transaction id is stale, it is by definition already completed,
834 			/* transaction not yet started, so request it */  in jbd2_complete_transaction()
1009 jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)  in jbd2_journal_get_descriptor_buffer()  argument
1011 	journal_t *journal = transaction->t_journal;  in jbd2_journal_get_descriptor_buffer()
1025 	atomic_dec(&transaction->t_outstanding_credits);  in jbd2_journal_get_descriptor_buffer()
1031 	header->h_sequence = cpu_to_be32(transaction->t_tid);  in jbd2_journal_get_descriptor_buffer()
1054  * Return tid of the oldest transaction in the journal and block in the journal
1055  * where the transaction starts.
1057  * If the journal is now empty, return which will be the next transaction ID
1058  * we will write and where will that transaction start.
1066 	transaction_t *transaction;  in jbd2_journal_get_log_tail()  local
1071 	transaction = journal->j_checkpoint_transactions;  in jbd2_journal_get_log_tail()
1072 	if (transaction) {  in jbd2_journal_get_log_tail()
1073 		*tid = transaction->t_tid;  in jbd2_journal_get_log_tail()
1074 		*block = transaction->t_log_start;  in jbd2_journal_get_log_tail()
1075 	} else if ((transaction = journal->j_committing_transaction) != NULL) {  in jbd2_journal_get_log_tail()
1076 		*tid = transaction->t_tid;  in jbd2_journal_get_log_tail()
1077 		*block = transaction->t_log_start;  in jbd2_journal_get_log_tail()
1078 	} else if ((transaction = journal->j_running_transaction) != NULL) {  in jbd2_journal_get_log_tail()
1079 		*tid = transaction->t_tid;  in jbd2_journal_get_log_tail()
1111 	 * soon as we update j_tail, next transaction can start reusing journal  in __jbd2_update_log_tail()
1113 	 * old transaction with possibly newly overwritten data.  in __jbd2_update_log_tail()
1183 	seq_printf(seq, "average: \n  %ums waiting for transaction\n",  in jbd2_seq_info_show()
1189 	seq_printf(seq, "  %ums running transaction\n",  in jbd2_seq_info_show()
1191 	seq_printf(seq, "  %ums transaction was being locked\n",  in jbd2_seq_info_show()
1195 	seq_printf(seq, "  %ums logging transaction\n",  in jbd2_seq_info_show()
1197 	seq_printf(seq, "  %lluus average transaction commit time\n",  in jbd2_seq_info_show()
1199 	seq_printf(seq, "  %lu handles per transaction\n",  in jbd2_seq_info_show()
1201 	seq_printf(seq, "  %lu blocks per transaction\n",  in jbd2_seq_info_show()
1203 	seq_printf(seq, "  %lu logged blocks per transaction\n",  in jbd2_seq_info_show()
1534 		 * transaction will start reusing journal space and so we  in journal_reset()
1606  * @tail_tid: TID of the new transaction at the tail of the log
1607  * @tail_block: The first block of the transaction at the tail of the log
1930 		printk(KERN_ERR "JBD2: journal transaction %u on %s "  in jbd2_journal_load()
2262 	transaction_t *transaction = NULL;  in jbd2_journal_flush()  local
2268 		transaction = journal->j_running_transaction;  in jbd2_journal_flush()
2269 		__jbd2_log_start_commit(journal, transaction->t_tid);  in jbd2_journal_flush()
2271 		transaction = journal->j_committing_transaction;  in jbd2_journal_flush()
2274 	if (transaction) {  in jbd2_journal_flush()
2275 		tid_t tid = transaction->t_tid;  in jbd2_journal_flush()
2373  * journal (not of a single transaction).  This operation cannot be
2383  * immediately and no further transaction commits will be honoured.
2390  * Any attempt to get a new transaction handle on a journal which is in
2401  * transaction without having to complete the transaction to record the
2409 	transaction_t *transaction;  in jbd2_journal_abort()  local
2437 	 * Mark the abort as occurred and start current running transaction  in jbd2_journal_abort()
2444 	transaction = journal->j_running_transaction;  in jbd2_journal_abort()
2445 	if (transaction)  in jbd2_journal_abort()
2446 		__jbd2_log_start_commit(journal, transaction->t_tid);  in jbd2_journal_abort()
2719  * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
2720  * transaction (b_cp_transaction) hold their references to b_jcount.
2723  * _before_ attaching the journal_head to a transaction.  To protect the
2733  *      (Get another reference for transaction)
2868  * transaction's lists.