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 	spin_lock_init(&transaction->t_handle_lock);  in jbd2_get_transaction()
111 	atomic_set(&transaction->t_updates, 0);  in jbd2_get_transaction()
112 	atomic_set(&transaction->t_outstanding_credits,  in jbd2_get_transaction()
115 	atomic_set(&transaction->t_outstanding_revokes, 0);  in jbd2_get_transaction()
116 	atomic_set(&transaction->t_handle_count, 0);  in jbd2_get_transaction()
117 	INIT_LIST_HEAD(&transaction->t_inode_list);  in jbd2_get_transaction()
118 	INIT_LIST_HEAD(&transaction->t_private_list);  in jbd2_get_transaction()
120 	/* Set up the commit timer for the new transaction. */  in jbd2_get_transaction()
121 	journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires);  in jbd2_get_transaction()
125 	journal->j_running_transaction = transaction;  in jbd2_get_transaction()
126 	transaction->t_max_wait = 0;  in jbd2_get_transaction()
127 	transaction->t_start = jiffies;  in jbd2_get_transaction()
128 	transaction->t_requested = 0;  in jbd2_get_transaction()
140  * Update transaction's maximum wait time, if debugging is enabled.
149 static inline void update_t_max_wait(transaction_t *transaction,  in update_t_max_wait()  argument
154 	    time_after(transaction->t_start, ts)) {  in update_t_max_wait()
155 		ts = jbd2_time_diff(ts, transaction->t_start);  in update_t_max_wait()
156 		spin_lock(&transaction->t_handle_lock);  in update_t_max_wait()
157 		if (ts > transaction->t_max_wait)  in update_t_max_wait()
158 			transaction->t_max_wait = ts;  in update_t_max_wait()
159 		spin_unlock(&transaction->t_handle_lock);  in update_t_max_wait()
165  * Wait until running transaction passes to T_FLUSH state and new transaction
167  * running transaction to exist and releases j_state_lock.
188  * Wait until running transaction transitions from T_SWITCH to T_FLUSH
189  * state and new transaction can thus be started. The function releases
222  * Wait until we can add credits for handle to the running transaction.  Called
224  * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
235 	 * If the current transaction is locked down for commit, wait  in add_transaction_credits()
252 		 * If the current transaction is already too large,  in add_transaction_credits()
254 		 * attach this handle to a new transaction.  in add_transaction_credits()
259 		 * Is the number of reserved credits in the current transaction too  in add_transaction_credits()
280 	 * associated with a committing transaction creates a deadlock,  in add_transaction_credits()
285 	 * in the new transaction.  in add_transaction_credits()
304 	/* We allow at most half of a transaction to be reserved */  in add_transaction_credits()
321  * to begin.  Attach the handle to a transaction and set up the
322  * transaction's buffer credits.
328 	transaction_t	*transaction, *new_transaction = NULL;  in start_this_handle()  local
337 	 * Limit the number of reserved credits to 1/2 of maximum transaction  in start_this_handle()
339 	 * transaction size per operation.  in start_this_handle()
354 	 * transaction early if there are high chances we'll need it. If we  in start_this_handle()
355 	 * guess wrong, we'll retry or free unused transaction.  in start_this_handle()
387 	 * Wait on the journal's transaction barrier if necessary. Specifically  in start_this_handle()
412 	transaction = journal->j_running_transaction;  in start_this_handle()
421 		 * transaction and we don't have to check for transaction size  in start_this_handle()
423 		 * transaction is being switched to a committing one as it  in start_this_handle()
426 		if (transaction->t_state == T_SWITCH) {  in start_this_handle()
435 	 * use and add the handle to the running transaction.   in start_this_handle()
437 	update_t_max_wait(transaction, ts);  in start_this_handle()
438 	handle->h_transaction = transaction;  in start_this_handle()
442 	atomic_inc(&transaction->t_updates);  in start_this_handle()
443 	atomic_inc(&transaction->t_handle_count);  in start_this_handle()
446 		  atomic_read(&transaction->t_outstanding_credits),  in start_this_handle()
454 	 * Ensure that no allocations done while the transaction is open are  in start_this_handle()
528  * @journal: Journal to start transaction on.
531  * We make sure that the transaction can guarantee at least nblocks of
535  * stored in h_rsv_handle. It is not attached to any particular transaction
536  * and thus doesn't block transaction commit. If the caller uses this reserved
565 	/* Get j_state_lock to pin running transaction if it exists */  in jbd2_journal_free_reserved()
580  * This attaches @handle to the running transaction (or creates one if there's
581  * not transaction running). Unlike jbd2_journal_start() this function cannot
646  * return code > 0 implies normal transaction-full status.
650 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_extend()  local
657 	journal = transaction->t_journal;  in jbd2_journal_extend()
663 	/* Don't extend a locked-down transaction! */  in jbd2_journal_extend()
664 	if (transaction->t_state != T_RUNNING) {  in jbd2_journal_extend()
666 			  "transaction not running\n", handle, nblocks);  in jbd2_journal_extend()
676 	spin_lock(&transaction->t_handle_lock);  in jbd2_journal_extend()
678 				   &transaction->t_outstanding_credits);  in jbd2_journal_extend()
682 			  "transaction too large\n", handle, nblocks);  in jbd2_journal_extend()
683 		atomic_sub(nblocks, &transaction->t_outstanding_credits);  in jbd2_journal_extend()
688 				 transaction->t_tid,  in jbd2_journal_extend()
701 	spin_unlock(&transaction->t_handle_lock);  in jbd2_journal_extend()
709 	transaction_t *transaction = handle->h_transaction;  in stop_this_handle()  local
710 	journal_t *journal = transaction->t_journal;  in stop_this_handle()
714 	J_ASSERT(atomic_read(&transaction->t_updates) > 0);  in stop_this_handle()
719 	 * transaction will really need as large sequences of transactions with  in stop_this_handle()
730 				&transaction->t_outstanding_revokes);  in stop_this_handle()
737 		   &transaction->t_outstanding_credits);  in stop_this_handle()
740 						transaction);  in stop_this_handle()
741 	if (atomic_dec_and_test(&transaction->t_updates))  in stop_this_handle()
759  * Restart a handle for a multi-transaction filesystem
764  * handle's transaction so far and reattach the handle to a new
765  * transaction capable of guaranteeing the requested number of
772 	transaction_t *transaction = handle->h_transaction;  in jbd2__journal_restart()  local
782 	journal = transaction->t_journal;  in jbd2__journal_restart()
783 	tid = transaction->t_tid;  in jbd2__journal_restart()
786 	 * First unlink the handle from its current transaction, and start the  in jbd2__journal_restart()
823  * jbd2_journal_lock_updates () - establish a transaction barrier.
851 		transaction_t *transaction = journal->j_running_transaction;  in jbd2_journal_lock_updates()  local
853 		if (!transaction)  in jbd2_journal_lock_updates()
856 		spin_lock(&transaction->t_handle_lock);  in jbd2_journal_lock_updates()
859 		if (!atomic_read(&transaction->t_updates)) {  in jbd2_journal_lock_updates()
860 			spin_unlock(&transaction->t_handle_lock);  in jbd2_journal_lock_updates()
864 		spin_unlock(&transaction->t_handle_lock);  in jbd2_journal_lock_updates()
885  * Release a transaction barrier obtained with jbd2_journal_lock_updates().
934  * If the buffer is already part of the current transaction, then there
936  * transaction which we are still committing to disk, then we need to
940  * part of the transaction, that is).
948 	transaction_t *transaction = handle->h_transaction;  in do_get_write_access()  local
954 	journal = transaction->t_journal;  in do_get_write_access()
1014 	 * The buffer is already part of this transaction if b_transaction or  in do_get_write_access()
1017 	if (jh->b_transaction == transaction ||  in do_get_write_access()
1018 	    jh->b_next_transaction == transaction) {  in do_get_write_access()
1024 	 * this is the first time this transaction is touching this buffer,  in do_get_write_access()
1035 		JBUFFER_TRACE(jh, "no transaction");  in do_get_write_access()
1040 		 * visible before attaching it to the running transaction.  in do_get_write_access()
1056 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in do_get_write_access()
1073 	JBUFFER_TRACE(jh, "owned by older transaction");  in do_get_write_access()
1079 	 * committing transaction is currently writing this buffer out to disk  in do_get_write_access()
1094 	 * Only do the copy if the currently-owning transaction still needs it.  in do_get_write_access()
1095 	 * If buffer isn't on BJ_Metadata list, the committing transaction is  in do_get_write_access()
1102 	 * committed_data record after the transaction, so we HAVE to force the  in do_get_write_access()
1121 	 * before attaching it to the running transaction. Paired with barrier  in do_get_write_access()
1125 	jh->b_next_transaction = transaction;  in do_get_write_access()
1144 /* Fast check whether buffer is already attached to the required transaction */
1159 	 * we see jh attached to the running transaction, we know it must stay  in jbd2_write_access_granted()
1160 	 * so until the transaction is committed. Thus jh won't be freed and  in jbd2_write_access_granted()
1162 	 * happen jh gets freed, reallocated, and attached to the transaction  in jbd2_write_access_granted()
1182 	 * detect when jh went through free, realloc, attach to transaction  in jbd2_write_access_granted()
1200  * @handle: transaction to add buffer modifications to
1236  * the bh is not already part of an existing transaction.
1244  * @handle: transaction to new buffer to
1251 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_get_create_access()  local
1260 	journal = transaction->t_journal;  in jbd2_journal_get_create_access()
1265 	 * The buffer may already belong to this transaction due to pre-zeroing  in jbd2_journal_get_create_access()
1267 	 * committing transaction's lists, but it HAS to be in Forget state in  in jbd2_journal_get_create_access()
1268 	 * that case: the transaction must have deleted the buffer for it to be  in jbd2_journal_get_create_access()
1272 	J_ASSERT_JH(jh, (jh->b_transaction == transaction ||  in jbd2_journal_get_create_access()
1286 		 * the buffer so the transaction freeing it must have  in jbd2_journal_get_create_access()
1290 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1295 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in jbd2_journal_get_create_access()
1298 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1301 		JBUFFER_TRACE(jh, "set next transaction");  in jbd2_journal_get_create_access()
1303 		jh->b_next_transaction = transaction;  in jbd2_journal_get_create_access()
1325  * @handle: transaction
1341  * We never need to know which transaction the committed data is part
1343  * will be committed to a new transaction in due course, at which point
1406  * a running transaction will match the buffer in that transaction.
1443  * @handle: transaction to add buffer to.
1447  * transaction.
1453  * The buffer is placed on the transaction's metadata list and is marked
1454  * as belonging to the transaction.
1459  * current committing transaction (in which case we should have frozen
1461  * buffer: that only gets done when the old transaction finally
1466 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_dirty_metadata()  local
1476 	 * of the running transaction.  in jbd2_journal_dirty_metadata()
1488 	if (data_race(jh->b_transaction != transaction &&  in jbd2_journal_dirty_metadata()
1489 	    jh->b_next_transaction != transaction)) {  in jbd2_journal_dirty_metadata()
1491 		J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in jbd2_journal_dirty_metadata()
1492 				jh->b_next_transaction == transaction);  in jbd2_journal_dirty_metadata()
1496 		/* If it's in our transaction it must be in BJ_Metadata list. */  in jbd2_journal_dirty_metadata()
1497 		if (data_race(jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1500 			if (jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1507 			J_ASSERT_JH(jh, jh->b_transaction != transaction ||  in jbd2_journal_dirty_metadata()
1520 		 * 'jh->b_next_transaction' during old transaction  in jbd2_journal_dirty_metadata()
1528 	journal = transaction->t_journal;  in jbd2_journal_dirty_metadata()
1533 		 * of the transaction. This needs to be done  in jbd2_journal_dirty_metadata()
1534 		 * once a transaction -bzzz  in jbd2_journal_dirty_metadata()
1546 	 * on the running transaction's metadata list there is nothing to do.  in jbd2_journal_dirty_metadata()
1551 	if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {  in jbd2_journal_dirty_metadata()
1573 	 * Metadata already on the current transaction list doesn't  in jbd2_journal_dirty_metadata()
1574 	 * need to be filed.  Metadata on another transaction's list must  in jbd2_journal_dirty_metadata()
1578 	if (jh->b_transaction != transaction) {  in jbd2_journal_dirty_metadata()
1579 		JBUFFER_TRACE(jh, "already on other transaction");  in jbd2_journal_dirty_metadata()
1582 			     (jh->b_next_transaction != transaction))) {  in jbd2_journal_dirty_metadata()
1585 			       "transaction (%p, %u), "  in jbd2_journal_dirty_metadata()
1590 			       transaction, transaction->t_tid,  in jbd2_journal_dirty_metadata()
1602 		 * transaction's data buffer, ever. */  in jbd2_journal_dirty_metadata()
1611 	__jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);  in jbd2_journal_dirty_metadata()
1622  * @handle: transaction handle
1626  * buffer.  If the buffer is dirty in the current running transaction we
1639 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_forget()  local
1648 	journal = transaction->t_journal;  in jbd2_journal_forget()
1668 	/* keep track of whether or not this transaction modified us */  in jbd2_journal_forget()
1672 	 * The buffer's going from the transaction, we must drop  in jbd2_journal_forget()
1677 	if (jh->b_transaction == transaction) {  in jbd2_journal_forget()
1681 		 * of this transaction, then we can just drop it from  in jbd2_journal_forget()
1682 		 * the transaction immediately. */  in jbd2_journal_forget()
1686 		JBUFFER_TRACE(jh, "belongs to current transaction: unfile");  in jbd2_journal_forget()
1689 		 * we only want to drop a reference if this transaction  in jbd2_journal_forget()
1697 		 * However, the commit of this transaction is still  in jbd2_journal_forget()
1710 			__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1720 		 * (committing) transaction, we can't drop it yet... */  in jbd2_journal_forget()
1721 		JBUFFER_TRACE(jh, "belongs to older transaction");  in jbd2_journal_forget()
1722 		/* ... but we CAN drop it from the new transaction through  in jbd2_journal_forget()
1724 		 * the new transaction, so that not only the commit code  in jbd2_journal_forget()
1727 		 * after the new transaction commits. */  in jbd2_journal_forget()
1733 			jh->b_next_transaction = transaction;  in jbd2_journal_forget()
1736 			J_ASSERT(jh->b_next_transaction == transaction);  in jbd2_journal_forget()
1739 			 * only drop a reference if this transaction modified  in jbd2_journal_forget()
1748 		 * transaction, we can just drop it now if it has no  in jbd2_journal_forget()
1753 			JBUFFER_TRACE(jh, "belongs to none transaction");  in jbd2_journal_forget()
1770 		 * attach this buffer to current transaction so that the  in jbd2_journal_forget()
1772 		 * transaction commits.  in jbd2_journal_forget()
1775 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1790  * jbd2_journal_stop() - complete a transaction
1791  * @handle: transaction to complete.
1796  * buffer credits to the transaction and remove the handle.  The only
1803  * transaction began.
1807 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_stop()  local
1820 	if (!transaction) {  in jbd2_journal_stop()
1822 		 * Handle is already detached from the transaction so there is  in jbd2_journal_stop()
1828 	journal = transaction->t_journal;  in jbd2_journal_stop()
1829 	tid = transaction->t_tid;  in jbd2_journal_stop()
1843 	 * Implement synchronous transaction batching.  If the handle  in jbd2_journal_stop()
1846 	 * transaction.  Keep doing that while new threads continue to  in jbd2_journal_stop()
1855 	 * and wait for the transaction to be committed than it is to  in jbd2_journal_stop()
1857 	 * join the transaction.  We achieve this by measuring how  in jbd2_journal_stop()
1858 	 * long it takes to commit a transaction, and compare it with  in jbd2_journal_stop()
1859 	 * how long this transaction has been running, and if run time  in jbd2_journal_stop()
1883 						   transaction->t_start_time));  in jbd2_journal_stop()
1899 		transaction->t_synchronous_commit = 1;  in jbd2_journal_stop()
1903 	 * going!  We also want to force a commit if the transaction is too  in jbd2_journal_stop()
1907 	    time_after_eq(jiffies, transaction->t_expires)) {  in jbd2_journal_stop()
1912 		jbd_debug(2, "transaction too old, requesting commit for "  in jbd2_journal_stop()
1926 	 * Once stop_this_handle() drops t_updates, the transaction could start  in jbd2_journal_stop()
1928 	 * dereference transaction pointer again after calling  in jbd2_journal_stop()
1946  * transaction buffer lists.
1951  * Append a buffer to a transaction list, given the transaction's list head
1975  * Remove a buffer from a transaction list, given the transaction's list
1996  * Remove a buffer from the appropriate transaction list.
2009 	transaction_t *transaction;  in __jbd2_journal_temp_unlink_buffer()  local
2013 	transaction = jh->b_transaction;  in __jbd2_journal_temp_unlink_buffer()
2014 	if (transaction)  in __jbd2_journal_temp_unlink_buffer()
2015 		assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_temp_unlink_buffer()
2019 		J_ASSERT_JH(jh, transaction != NULL);  in __jbd2_journal_temp_unlink_buffer()
2025 		transaction->t_nr_buffers--;  in __jbd2_journal_temp_unlink_buffer()
2026 		J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);  in __jbd2_journal_temp_unlink_buffer()
2027 		list = &transaction->t_buffers;  in __jbd2_journal_temp_unlink_buffer()
2030 		list = &transaction->t_forget;  in __jbd2_journal_temp_unlink_buffer()
2033 		list = &transaction->t_shadow_list;  in __jbd2_journal_temp_unlink_buffer()
2036 		list = &transaction->t_reserved_list;  in __jbd2_journal_temp_unlink_buffer()
2042 	if (transaction && is_journal_aborted(transaction->t_journal))  in __jbd2_journal_temp_unlink_buffer()
2050  * the jh reference that belonged to the transaction.
2123  * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
2137  * while the data is part of a transaction.  Yes?
2177  * This buffer is no longer needed.  If it is on an older transaction's
2178  * checkpoint list we need to record it on this transaction's forget list
2179  * to pin this buffer (and hence its checkpointing transaction) down until
2180  * this transaction commits.  If the buffer isn't on a checkpoint list, we
2188 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)  in __dispose_buffer()  argument
2194 		JBUFFER_TRACE(jh, "on running+cp transaction");  in __dispose_buffer()
2202 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in __dispose_buffer()
2205 		JBUFFER_TRACE(jh, "on running transaction");  in __dispose_buffer()
2225  *  attached to the current transaction: once the transaction commits,
2229  *  previous, committing transaction!
2232  * transaction (and which therefore cannot be discarded immediately) are
2233  * not going to be reused in the new running transaction
2236  *  allocated in one transaction and removed in the next will be marked
2238  *  the next transaction to delete the block commits.  This means that
2247  * transaction commit --- so it is always safe just to discard data
2254  * transaction.
2256  * We're outside-transaction here.  Either or both of j_running_transaction
2262 	transaction_t *transaction;  in journal_unmap_buffer()  local
2285 	 * transaction adding inode to orphan list (let's call it T)  in journal_unmap_buffer()
2286 	 * is committed.  Otherwise if the transaction changing the  in journal_unmap_buffer()
2291 	 * transaction marking the buffer as freed in the filesystem  in journal_unmap_buffer()
2296 	 * the buffer to BJ_Forget list of the newest transaction.  in journal_unmap_buffer()
2304 	 * the transaction this buffer was modified in.  in journal_unmap_buffer()
2306 	transaction = jh->b_transaction;  in journal_unmap_buffer()
2307 	if (transaction == NULL) {  in journal_unmap_buffer()
2308 		/* First case: not on any transaction.  If it  in journal_unmap_buffer()
2313 			JBUFFER_TRACE(jh, "not on any transaction: zap");  in journal_unmap_buffer()
2328 			/* ... and once the current transaction has  in journal_unmap_buffer()
2336 			/* There is no currently-running transaction. So the  in journal_unmap_buffer()
2339 			 * the committing transaction, if it exists. */  in journal_unmap_buffer()
2346 				/* The orphan record's transaction has  in journal_unmap_buffer()
2353 	} else if (transaction == journal->j_committing_transaction) {  in journal_unmap_buffer()
2354 		JBUFFER_TRACE(jh, "on committing transaction");  in journal_unmap_buffer()
2372 		 * b_modified to not confuse transaction credit accounting, and  in journal_unmap_buffer()
2373 		 * set j_next_transaction to the running transaction (if there  in journal_unmap_buffer()
2387 		/* Good, the buffer belongs to the running transaction.  in journal_unmap_buffer()
2388 		 * We are writing our own transaction's data, not any  in journal_unmap_buffer()
2393 		J_ASSERT_JH(jh, transaction == journal->j_running_transaction);  in journal_unmap_buffer()
2394 		JBUFFER_TRACE(jh, "on running transaction");  in journal_unmap_buffer()
2395 		may_free = __dispose_buffer(jh, transaction);  in journal_unmap_buffer()
2403 	 * running transaction, journal_get_write_access() won't clear  in journal_unmap_buffer()
2432  * Can return -EBUSY if buffers are part of the committing transaction and
2489  * File a buffer on the given transaction list.
2492 			transaction_t *transaction, int jlist)  in __jbd2_journal_file_buffer()  argument
2499 	assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_file_buffer()
2502 	J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in __jbd2_journal_file_buffer()
2528 	jh->b_transaction = transaction;  in __jbd2_journal_file_buffer()
2536 		transaction->t_nr_buffers++;  in __jbd2_journal_file_buffer()
2537 		list = &transaction->t_buffers;  in __jbd2_journal_file_buffer()
2540 		list = &transaction->t_forget;  in __jbd2_journal_file_buffer()
2543 		list = &transaction->t_shadow_list;  in __jbd2_journal_file_buffer()
2546 		list = &transaction->t_reserved_list;  in __jbd2_journal_file_buffer()
2558 				transaction_t *transaction, int jlist)  in jbd2_journal_file_buffer()  argument
2561 	spin_lock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2562 	__jbd2_journal_file_buffer(jh, transaction, jlist);  in jbd2_journal_file_buffer()
2563 	spin_unlock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2569  * dropping it from its current transaction entirely.  If the buffer has
2570  * already started to be used by a subsequent transaction, refile the
2571  * buffer on that transaction's metadata list.
2576  * When this function returns true, there's no next transaction to refile to
2596 	 * It has been modified by a later transaction: add it to the new  in __jbd2_journal_refile_buffer()
2597 	 * transaction's metadata list.  in __jbd2_journal_refile_buffer()
2650  * File inode in the inode list of the handle's transaction
2655 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_file_inode()  local
2660 	journal = transaction->t_journal;  in jbd2_journal_file_inode()
2663 			transaction->t_tid);  in jbd2_journal_file_inode()
2677 	if (jinode->i_transaction == transaction ||  in jbd2_journal_file_inode()
2678 	    jinode->i_next_transaction == transaction)  in jbd2_journal_file_inode()
2686 	if (!transaction->t_need_data_flush)  in jbd2_journal_file_inode()
2687 		transaction->t_need_data_flush = 1;  in jbd2_journal_file_inode()
2688 	/* On some different transaction's list - should be  in jbd2_journal_file_inode()
2694 		jinode->i_next_transaction = transaction;  in jbd2_journal_file_inode()
2697 	/* Not on any transaction list... */  in jbd2_journal_file_inode()
2699 	jinode->i_transaction = transaction;  in jbd2_journal_file_inode()
2700 	list_add(&jinode->i_list, &transaction->t_inode_list);  in jbd2_journal_file_inode()
2723  * File truncate and transaction commit interact with each other in a
2724  * non-trivial way.  If a transaction writing data block A is
2726  * written them.  Otherwise if we crashed after the transaction with
2727  * write has committed but before the transaction with truncate has
2730  * part in case it is in the committing transaction.
2736  * committing the transaction after this function has been called but
2737  * before a transaction for truncate is started (and furthermore it
2739  * happens in the same transaction as write --- we don't have to write
2753 	 * enough that the transaction was not committing before we started  in jbd2_journal_begin_ordered_truncate()
2754 	 * a transaction adding the inode to orphan list */  in jbd2_journal_begin_ordered_truncate()