3  * linux/fs/jbd2/transaction.c
9  * Generic filesystem transaction handling code; part of the ext2fs
46 		pr_emerg("JBD2: failed to create transaction cache\n");  in jbd2_journal_init_transaction_cache()
58 void jbd2_journal_free_transaction(transaction_t *transaction)  in jbd2_journal_free_transaction()  argument
60 	if (unlikely(ZERO_OR_NULL_PTR(transaction)))  in jbd2_journal_free_transaction()
62 	kmem_cache_free(transaction_cache, transaction);  in jbd2_journal_free_transaction()
66  * Base amount of descriptor blocks we reserve for each transaction.
81 	 * space for commit block and normal transaction descriptor blocks.  in jbd2_descriptor_blocks_per_trans()
90  * Simply initialise a new transaction. Initialize it in
92  * have an existing running transaction: we only make a new transaction
97  *	new transaction	and we can't block without protecting against other
103 				transaction_t *transaction)  in jbd2_get_transaction()  argument
105 	transaction->t_journal = journal;  in jbd2_get_transaction()
106 	transaction->t_state = T_RUNNING;  in jbd2_get_transaction()
107 	transaction->t_start_time = ktime_get();  in jbd2_get_transaction()
108 	transaction->t_tid = journal->j_transaction_sequence++;  in jbd2_get_transaction()
109 	transaction->t_expires = jiffies + journal->j_commit_interval;  in jbd2_get_transaction()
110 	atomic_set(&transaction->t_updates, 0);  in jbd2_get_transaction()
111 	atomic_set(&transaction->t_outstanding_credits,  in jbd2_get_transaction()
114 	atomic_set(&transaction->t_outstanding_revokes, 0);  in jbd2_get_transaction()
115 	atomic_set(&transaction->t_handle_count, 0);  in jbd2_get_transaction()
116 	INIT_LIST_HEAD(&transaction->t_inode_list);  in jbd2_get_transaction()
117 	INIT_LIST_HEAD(&transaction->t_private_list);  in jbd2_get_transaction()
119 	/* Set up the commit timer for the new transaction. */  in jbd2_get_transaction()
120 	journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);  in jbd2_get_transaction()
124 	journal->j_running_transaction = transaction;  in jbd2_get_transaction()
125 	transaction->t_max_wait = 0;  in jbd2_get_transaction()
126 	transaction->t_start = jiffies;  in jbd2_get_transaction()
127 	transaction->t_requested = 0;  in jbd2_get_transaction()
139  * Update transaction's maximum wait time, if debugging is enabled.
146 static inline void update_t_max_wait(transaction_t *transaction,  in update_t_max_wait()  argument
151 	if (time_after(transaction->t_start, ts)) {  in update_t_max_wait()
152 		newts = jbd2_time_diff(ts, transaction->t_start);  in update_t_max_wait()
153 		oldts = READ_ONCE(transaction->t_max_wait);  in update_t_max_wait()
155 			oldts = cmpxchg(&transaction->t_max_wait, oldts, newts);  in update_t_max_wait()
160  * Wait until running transaction passes to T_FLUSH state and new transaction
162  * running transaction to exist and releases j_state_lock.
183  * Wait until running transaction transitions from T_SWITCH to T_FLUSH
184  * state and new transaction can thus be started. The function releases
217  * Wait until we can add credits for handle to the running transaction.  Called
219  * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
236 	 * If the current transaction is locked down for commit, wait  in add_transaction_credits()
254 		 * If the current transaction is already too large,  in add_transaction_credits()
256 		 * attach this handle to a new transaction.  in add_transaction_credits()
261 		 * Is the number of reserved credits in the current transaction too  in add_transaction_credits()
284 	 * associated with a committing transaction creates a deadlock,  in add_transaction_credits()
289 	 * in the new transaction.  in add_transaction_credits()
309 	/* We allow at most half of a transaction to be reserved */  in add_transaction_credits()
327  * to begin.  Attach the handle to a transaction and set up the
328  * transaction's buffer credits.
334 	transaction_t	*transaction, *new_transaction = NULL;  in start_this_handle()  local
343 	 * Limit the number of reserved credits to 1/2 of maximum transaction  in start_this_handle()
345 	 * transaction size per operation.  in start_this_handle()
360 	 * transaction early if there are high chances we'll need it. If we  in start_this_handle()
361 	 * guess wrong, we'll retry or free unused transaction.  in start_this_handle()
393 	 * Wait on the journal's transaction barrier if necessary. Specifically  in start_this_handle()
418 	transaction = journal->j_running_transaction;  in start_this_handle()
433 		 * transaction and we don't have to check for transaction size  in start_this_handle()
435 		 * transaction is being switched to a committing one as it  in start_this_handle()
438 		if (transaction->t_state == T_SWITCH) {  in start_this_handle()
447 	 * use and add the handle to the running transaction.  in start_this_handle()
449 	update_t_max_wait(transaction, ts);  in start_this_handle()
450 	handle->h_transaction = transaction;  in start_this_handle()
454 	atomic_inc(&transaction->t_updates);  in start_this_handle()
455 	atomic_inc(&transaction->t_handle_count);  in start_this_handle()
458 		  atomic_read(&transaction->t_outstanding_credits),  in start_this_handle()
466 	 * Ensure that no allocations done while the transaction is open are  in start_this_handle()
540  * @journal: Journal to start transaction on.
543  * We make sure that the transaction can guarantee at least nblocks of
547  * stored in h_rsv_handle. It is not attached to any particular transaction
548  * and thus doesn't block transaction commit. If the caller uses this reserved
577 	/* Get j_state_lock to pin running transaction if it exists */  in jbd2_journal_free_reserved()
592  * This attaches @handle to the running transaction (or creates one if there's
593  * not transaction running). Unlike jbd2_journal_start() this function cannot
658  * return code > 0 implies normal transaction-full status.
662 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_extend()  local
669 	journal = transaction->t_journal;  in jbd2_journal_extend()
675 	/* Don't extend a locked-down transaction! */  in jbd2_journal_extend()
676 	if (transaction->t_state != T_RUNNING) {  in jbd2_journal_extend()
678 			  "transaction not running\n", handle, nblocks);  in jbd2_journal_extend()
689 				   &transaction->t_outstanding_credits);  in jbd2_journal_extend()
693 			  "transaction too large\n", handle, nblocks);  in jbd2_journal_extend()
694 		atomic_sub(nblocks, &transaction->t_outstanding_credits);  in jbd2_journal_extend()
699 				 transaction->t_tid,  in jbd2_journal_extend()
718 	transaction_t *transaction = handle->h_transaction;  in stop_this_handle()  local
719 	journal_t *journal = transaction->t_journal;  in stop_this_handle()
723 	J_ASSERT(atomic_read(&transaction->t_updates) > 0);  in stop_this_handle()
728 	 * transaction will really need as large sequences of transactions with  in stop_this_handle()
739 				&transaction->t_outstanding_revokes);  in stop_this_handle()
746 		   &transaction->t_outstanding_credits);  in stop_this_handle()
749 						transaction);  in stop_this_handle()
750 	if (atomic_dec_and_test(&transaction->t_updates))  in stop_this_handle()
768  * Restart a handle for a multi-transaction filesystem
773  * handle's transaction so far and reattach the handle to a new
774  * transaction capable of guaranteeing the requested number of
781 	transaction_t *transaction = handle->h_transaction;  in jbd2__journal_restart()  local
791 	journal = transaction->t_journal;  in jbd2__journal_restart()
792 	tid = transaction->t_tid;  in jbd2__journal_restart()
795 	 * First unlink the handle from its current transaction, and start the  in jbd2__journal_restart()
841 		 * Note that the running transaction can get freed under us if  in jbd2_journal_wait_updates()
842 		 * this transaction is getting committed in  in jbd2_journal_wait_updates()
848 		 * lead to use-after-free of old freed transaction.  in jbd2_journal_wait_updates()
850 		transaction_t *transaction = journal->j_running_transaction;  in jbd2_journal_wait_updates()  local
852 		if (!transaction)  in jbd2_journal_wait_updates()
857 		if (!atomic_read(&transaction->t_updates)) {  in jbd2_journal_wait_updates()
869  * jbd2_journal_lock_updates () - establish a transaction barrier.
911  * Release a transaction barrier obtained with jbd2_journal_lock_updates().
960  * If the buffer is already part of the current transaction, then there
962  * transaction which we are still committing to disk, then we need to
966  * part of the transaction, that is).
974 	transaction_t *transaction = handle->h_transaction;  in do_get_write_access()  local
980 	journal = transaction->t_journal;  in do_get_write_access()
1016 		 * transaction or the existing committing transaction?  in do_get_write_access()
1020 				jh->b_transaction == transaction ||  in do_get_write_access()
1025 							transaction);  in do_get_write_access()
1048 	 * The buffer is already part of this transaction if b_transaction or  in do_get_write_access()
1051 	if (jh->b_transaction == transaction ||  in do_get_write_access()
1052 	    jh->b_next_transaction == transaction)  in do_get_write_access()
1056 	 * this is the first time this transaction is touching this buffer,  in do_get_write_access()
1067 		JBUFFER_TRACE(jh, "no transaction");  in do_get_write_access()
1072 		 * visible before attaching it to the running transaction.  in do_get_write_access()
1077 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in do_get_write_access()
1091 	JBUFFER_TRACE(jh, "owned by older transaction");  in do_get_write_access()
1097 	 * committing transaction is currently writing this buffer out to disk  in do_get_write_access()
1112 	 * Only do the copy if the currently-owning transaction still needs it.  in do_get_write_access()
1113 	 * If buffer isn't on BJ_Metadata list, the committing transaction is  in do_get_write_access()
1120 	 * committed_data record after the transaction, so we HAVE to force the  in do_get_write_access()
1139 	 * before attaching it to the running transaction. Paired with barrier  in do_get_write_access()
1143 	jh->b_next_transaction = transaction;  in do_get_write_access()
1162 /* Fast check whether buffer is already attached to the required transaction */
1177 	 * we see jh attached to the running transaction, we know it must stay  in jbd2_write_access_granted()
1178 	 * so until the transaction is committed. Thus jh won't be freed and  in jbd2_write_access_granted()
1180 	 * happen jh gets freed, reallocated, and attached to the transaction  in jbd2_write_access_granted()
1200 	 * detect when jh went through free, realloc, attach to transaction  in jbd2_write_access_granted()
1218  * @handle: transaction to add buffer modifications to
1254  * the bh is not already part of an existing transaction.
1262  * @handle: transaction to new buffer to
1269 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_get_create_access()  local
1278 	journal = transaction->t_journal;  in jbd2_journal_get_create_access()
1283 	 * The buffer may already belong to this transaction due to pre-zeroing  in jbd2_journal_get_create_access()
1285 	 * committing transaction's lists, but it HAS to be in Forget state in  in jbd2_journal_get_create_access()
1286 	 * that case: the transaction must have deleted the buffer for it to be  in jbd2_journal_get_create_access()
1290 	J_ASSERT_JH(jh, (jh->b_transaction == transaction ||  in jbd2_journal_get_create_access()
1304 		 * the buffer so the transaction freeing it must have  in jbd2_journal_get_create_access()
1308 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1313 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in jbd2_journal_get_create_access()
1316 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1319 		JBUFFER_TRACE(jh, "set next transaction");  in jbd2_journal_get_create_access()
1321 		jh->b_next_transaction = transaction;  in jbd2_journal_get_create_access()
1343  * @handle: transaction
1359  * We never need to know which transaction the committed data is part
1361  * will be committed to a new transaction in due course, at which point
1424  * a running transaction will match the buffer in that transaction.
1461  * @handle: transaction to add buffer to.
1465  * transaction.
1471  * The buffer is placed on the transaction's metadata list and is marked
1472  * as belonging to the transaction.
1477  * current committing transaction (in which case we should have frozen
1479  * buffer: that only gets done when the old transaction finally
1484 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_dirty_metadata()  local
1494 	 * of the running transaction.  in jbd2_journal_dirty_metadata()
1506 	if (data_race(jh->b_transaction != transaction &&  in jbd2_journal_dirty_metadata()
1507 	    jh->b_next_transaction != transaction)) {  in jbd2_journal_dirty_metadata()
1509 		J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in jbd2_journal_dirty_metadata()
1510 				jh->b_next_transaction == transaction);  in jbd2_journal_dirty_metadata()
1514 		/* If it's in our transaction it must be in BJ_Metadata list. */  in jbd2_journal_dirty_metadata()
1515 		if (data_race(jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1518 			if (jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1525 			J_ASSERT_JH(jh, jh->b_transaction != transaction ||  in jbd2_journal_dirty_metadata()
1532 	journal = transaction->t_journal;  in jbd2_journal_dirty_metadata()
1539 		 * 'jh->b_next_transaction' during old transaction  in jbd2_journal_dirty_metadata()
1550 		 * of the transaction. This needs to be done  in jbd2_journal_dirty_metadata()
1551 		 * once a transaction -bzzz  in jbd2_journal_dirty_metadata()
1563 	 * on the running transaction's metadata list there is nothing to do.  in jbd2_journal_dirty_metadata()
1568 	if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {  in jbd2_journal_dirty_metadata()
1590 	 * Metadata already on the current transaction list doesn't  in jbd2_journal_dirty_metadata()
1591 	 * need to be filed.  Metadata on another transaction's list must  in jbd2_journal_dirty_metadata()
1595 	if (jh->b_transaction != transaction) {  in jbd2_journal_dirty_metadata()
1596 		JBUFFER_TRACE(jh, "already on other transaction");  in jbd2_journal_dirty_metadata()
1599 			     (jh->b_next_transaction != transaction))) {  in jbd2_journal_dirty_metadata()
1602 			       "transaction (%p, %u), "  in jbd2_journal_dirty_metadata()
1607 			       transaction, transaction->t_tid,  in jbd2_journal_dirty_metadata()
1619 		 * transaction's data buffer, ever. */  in jbd2_journal_dirty_metadata()
1628 	__jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);  in jbd2_journal_dirty_metadata()
1639  * @handle: transaction handle
1643  * buffer.  If the buffer is dirty in the current running transaction we
1656 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_forget()  local
1665 	journal = transaction->t_journal;  in jbd2_journal_forget()
1685 	/* keep track of whether or not this transaction modified us */  in jbd2_journal_forget()
1689 	 * The buffer's going from the transaction, we must drop  in jbd2_journal_forget()
1694 	if (jh->b_transaction == transaction) {  in jbd2_journal_forget()
1698 		 * of this transaction, then we can just drop it from  in jbd2_journal_forget()
1699 		 * the transaction immediately. */  in jbd2_journal_forget()
1703 		JBUFFER_TRACE(jh, "belongs to current transaction: unfile");  in jbd2_journal_forget()
1706 		 * we only want to drop a reference if this transaction  in jbd2_journal_forget()
1714 		 * However, the commit of this transaction is still  in jbd2_journal_forget()
1727 			__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1737 		 * (committing) transaction, we can't drop it yet... */  in jbd2_journal_forget()
1738 		JBUFFER_TRACE(jh, "belongs to older transaction");  in jbd2_journal_forget()
1739 		/* ... but we CAN drop it from the new transaction through  in jbd2_journal_forget()
1741 		 * the new transaction, so that not only the commit code  in jbd2_journal_forget()
1744 		 * after the new transaction commits. */  in jbd2_journal_forget()
1750 			jh->b_next_transaction = transaction;  in jbd2_journal_forget()
1753 			J_ASSERT(jh->b_next_transaction == transaction);  in jbd2_journal_forget()
1756 			 * only drop a reference if this transaction modified  in jbd2_journal_forget()
1765 		 * transaction, we can just drop it now if it has no  in jbd2_journal_forget()
1770 			JBUFFER_TRACE(jh, "belongs to none transaction");  in jbd2_journal_forget()
1787 		 * attach this buffer to current transaction so that the  in jbd2_journal_forget()
1789 		 * transaction commits.  in jbd2_journal_forget()
1792 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1807  * jbd2_journal_stop() - complete a transaction
1808  * @handle: transaction to complete.
1813  * buffer credits to the transaction and remove the handle.  The only
1820  * transaction began.
1824 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_stop()  local
1837 	if (!transaction) {  in jbd2_journal_stop()
1839 		 * Handle is already detached from the transaction so there is  in jbd2_journal_stop()
1845 	journal = transaction->t_journal;  in jbd2_journal_stop()
1846 	tid = transaction->t_tid;  in jbd2_journal_stop()
1860 	 * Implement synchronous transaction batching.  If the handle  in jbd2_journal_stop()
1863 	 * transaction.  Keep doing that while new threads continue to  in jbd2_journal_stop()
1872 	 * and wait for the transaction to be committed than it is to  in jbd2_journal_stop()
1874 	 * join the transaction.  We achieve this by measuring how  in jbd2_journal_stop()
1875 	 * long it takes to commit a transaction, and compare it with  in jbd2_journal_stop()
1876 	 * how long this transaction has been running, and if run time  in jbd2_journal_stop()
1900 						   transaction->t_start_time));  in jbd2_journal_stop()
1916 		transaction->t_synchronous_commit = 1;  in jbd2_journal_stop()
1920 	 * going!  We also want to force a commit if the transaction is too  in jbd2_journal_stop()
1924 	    time_after_eq(jiffies, transaction->t_expires)) {  in jbd2_journal_stop()
1929 		jbd2_debug(2, "transaction too old, requesting commit for "  in jbd2_journal_stop()
1943 	 * Once stop_this_handle() drops t_updates, the transaction could start  in jbd2_journal_stop()
1945 	 * dereference transaction pointer again after calling  in jbd2_journal_stop()
1963  * transaction buffer lists.
1968  * Append a buffer to a transaction list, given the transaction's list head
1992  * Remove a buffer from a transaction list, given the transaction's list
2013  * Remove a buffer from the appropriate transaction list.
2026 	transaction_t *transaction;  in __jbd2_journal_temp_unlink_buffer()  local
2030 	transaction = jh->b_transaction;  in __jbd2_journal_temp_unlink_buffer()
2031 	if (transaction)  in __jbd2_journal_temp_unlink_buffer()
2032 		assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_temp_unlink_buffer()
2036 		J_ASSERT_JH(jh, transaction != NULL);  in __jbd2_journal_temp_unlink_buffer()
2042 		transaction->t_nr_buffers--;  in __jbd2_journal_temp_unlink_buffer()
2043 		J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);  in __jbd2_journal_temp_unlink_buffer()
2044 		list = &transaction->t_buffers;  in __jbd2_journal_temp_unlink_buffer()
2047 		list = &transaction->t_forget;  in __jbd2_journal_temp_unlink_buffer()
2050 		list = &transaction->t_shadow_list;  in __jbd2_journal_temp_unlink_buffer()
2053 		list = &transaction->t_reserved_list;  in __jbd2_journal_temp_unlink_buffer()
2059 	if (transaction && is_journal_aborted(transaction->t_journal))  in __jbd2_journal_temp_unlink_buffer()
2067  * the jh reference that belonged to the transaction.
2140  * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
2154  * while the data is part of a transaction.  Yes?
2194  * This buffer is no longer needed.  If it is on an older transaction's
2195  * checkpoint list we need to record it on this transaction's forget list
2196  * to pin this buffer (and hence its checkpointing transaction) down until
2197  * this transaction commits.  If the buffer isn't on a checkpoint list, we
2205 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)  in __dispose_buffer()  argument
2211 		JBUFFER_TRACE(jh, "on running+cp transaction");  in __dispose_buffer()
2219 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in __dispose_buffer()
2222 		JBUFFER_TRACE(jh, "on running transaction");  in __dispose_buffer()
2242  *  attached to the current transaction: once the transaction commits,
2246  *  previous, committing transaction!
2249  * transaction (and which therefore cannot be discarded immediately) are
2250  * not going to be reused in the new running transaction
2253  *  allocated in one transaction and removed in the next will be marked
2255  *  the next transaction to delete the block commits.  This means that
2264  * transaction commit --- so it is always safe just to discard data
2271  * transaction.
2273  * We're outside-transaction here.  Either or both of j_running_transaction
2279 	transaction_t *transaction;  in journal_unmap_buffer()  local
2302 	 * transaction adding inode to orphan list (let's call it T)  in journal_unmap_buffer()
2303 	 * is committed.  Otherwise if the transaction changing the  in journal_unmap_buffer()
2308 	 * transaction marking the buffer as freed in the filesystem  in journal_unmap_buffer()
2313 	 * the buffer to BJ_Forget list of the newest transaction.  in journal_unmap_buffer()
2321 	 * the transaction this buffer was modified in.  in journal_unmap_buffer()
2323 	transaction = jh->b_transaction;  in journal_unmap_buffer()
2324 	if (transaction == NULL) {  in journal_unmap_buffer()
2325 		/* First case: not on any transaction.  If it  in journal_unmap_buffer()
2330 			JBUFFER_TRACE(jh, "not on any transaction: zap");  in journal_unmap_buffer()
2345 			/* ... and once the current transaction has  in journal_unmap_buffer()
2353 			/* There is no currently-running transaction. So the  in journal_unmap_buffer()
2356 			 * the committing transaction, if it exists. */  in journal_unmap_buffer()
2363 				/* The orphan record's transaction has  in journal_unmap_buffer()
2370 	} else if (transaction == journal->j_committing_transaction) {  in journal_unmap_buffer()
2371 		JBUFFER_TRACE(jh, "on committing transaction");  in journal_unmap_buffer()
2386 		 * b_modified to not confuse transaction credit accounting, and  in journal_unmap_buffer()
2387 		 * set j_next_transaction to the running transaction (if there  in journal_unmap_buffer()
2401 		/* Good, the buffer belongs to the running transaction.  in journal_unmap_buffer()
2402 		 * We are writing our own transaction's data, not any  in journal_unmap_buffer()
2407 		J_ASSERT_JH(jh, transaction == journal->j_running_transaction);  in journal_unmap_buffer()
2408 		JBUFFER_TRACE(jh, "on running transaction");  in journal_unmap_buffer()
2409 		may_free = __dispose_buffer(jh, transaction);  in journal_unmap_buffer()
2417 	 * running transaction, journal_get_write_access() won't clear  in journal_unmap_buffer()
2446  * Can return -EBUSY if buffers are part of the committing transaction and
2502  * File a buffer on the given transaction list.
2505 			transaction_t *transaction, int jlist)  in __jbd2_journal_file_buffer()  argument
2512 	assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_file_buffer()
2515 	J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in __jbd2_journal_file_buffer()
2541 	jh->b_transaction = transaction;  in __jbd2_journal_file_buffer()
2549 		transaction->t_nr_buffers++;  in __jbd2_journal_file_buffer()
2550 		list = &transaction->t_buffers;  in __jbd2_journal_file_buffer()
2553 		list = &transaction->t_forget;  in __jbd2_journal_file_buffer()
2556 		list = &transaction->t_shadow_list;  in __jbd2_journal_file_buffer()
2559 		list = &transaction->t_reserved_list;  in __jbd2_journal_file_buffer()
2571 				transaction_t *transaction, int jlist)  in jbd2_journal_file_buffer()  argument
2574 	spin_lock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2575 	__jbd2_journal_file_buffer(jh, transaction, jlist);  in jbd2_journal_file_buffer()
2576 	spin_unlock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2582  * dropping it from its current transaction entirely.  If the buffer has
2583  * already started to be used by a subsequent transaction, refile the
2584  * buffer on that transaction's metadata list.
2589  * When this function returns true, there's no next transaction to refile to
2609 	 * It has been modified by a later transaction: add it to the new  in __jbd2_journal_refile_buffer()
2610 	 * transaction's metadata list.  in __jbd2_journal_refile_buffer()
2663  * File inode in the inode list of the handle's transaction
2668 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_file_inode()  local
2673 	journal = transaction->t_journal;  in jbd2_journal_file_inode()
2676 			transaction->t_tid);  in jbd2_journal_file_inode()
2690 	if (jinode->i_transaction == transaction ||  in jbd2_journal_file_inode()
2691 	    jinode->i_next_transaction == transaction)  in jbd2_journal_file_inode()
2699 	if (!transaction->t_need_data_flush)  in jbd2_journal_file_inode()
2700 		transaction->t_need_data_flush = 1;  in jbd2_journal_file_inode()
2701 	/* On some different transaction's list - should be  in jbd2_journal_file_inode()
2707 		jinode->i_next_transaction = transaction;  in jbd2_journal_file_inode()
2710 	/* Not on any transaction list... */  in jbd2_journal_file_inode()
2712 	jinode->i_transaction = transaction;  in jbd2_journal_file_inode()
2713 	list_add(&jinode->i_list, &transaction->t_inode_list);  in jbd2_journal_file_inode()
2736  * File truncate and transaction commit interact with each other in a
2737  * non-trivial way.  If a transaction writing data block A is
2739  * written them.  Otherwise if we crashed after the transaction with
2740  * write has committed but before the transaction with truncate has
2743  * part in case it is in the committing transaction.
2749  * committing the transaction after this function has been called but
2750  * before a transaction for truncate is started (and furthermore it
2752  * happens in the same transaction as write --- we don't have to write
2766 	 * enough that the transaction was not committing before we started  in jbd2_journal_begin_ordered_truncate()
2767 	 * a transaction adding the inode to orphan list */  in jbd2_journal_begin_ordered_truncate()