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()
990 		 * transaction or the existing committing transaction?  in do_get_write_access()
994 				jh->b_transaction == transaction ||  in do_get_write_access()
999 							transaction);  in do_get_write_access()
1022 	 * The buffer is already part of this transaction if b_transaction or  in do_get_write_access()
1025 	if (jh->b_transaction == transaction ||  in do_get_write_access()
1026 	    jh->b_next_transaction == transaction)  in do_get_write_access()
1030 	 * this is the first time this transaction is touching this buffer,  in do_get_write_access()
1041 		JBUFFER_TRACE(jh, "no transaction");  in do_get_write_access()
1046 		 * visible before attaching it to the running transaction.  in do_get_write_access()
1051 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in do_get_write_access()
1065 	JBUFFER_TRACE(jh, "owned by older transaction");  in do_get_write_access()
1071 	 * committing transaction is currently writing this buffer out to disk  in do_get_write_access()
1086 	 * Only do the copy if the currently-owning transaction still needs it.  in do_get_write_access()
1087 	 * If buffer isn't on BJ_Metadata list, the committing transaction is  in do_get_write_access()
1094 	 * committed_data record after the transaction, so we HAVE to force the  in do_get_write_access()
1113 	 * before attaching it to the running transaction. Paired with barrier  in do_get_write_access()
1117 	jh->b_next_transaction = transaction;  in do_get_write_access()
1136 /* Fast check whether buffer is already attached to the required transaction */
1151 	 * we see jh attached to the running transaction, we know it must stay  in jbd2_write_access_granted()
1152 	 * so until the transaction is committed. Thus jh won't be freed and  in jbd2_write_access_granted()
1154 	 * happen jh gets freed, reallocated, and attached to the transaction  in jbd2_write_access_granted()
1174 	 * detect when jh went through free, realloc, attach to transaction  in jbd2_write_access_granted()
1192  * @handle: transaction to add buffer modifications to
1228  * the bh is not already part of an existing transaction.
1236  * @handle: transaction to new buffer to
1243 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_get_create_access()  local
1252 	journal = transaction->t_journal;  in jbd2_journal_get_create_access()
1257 	 * The buffer may already belong to this transaction due to pre-zeroing  in jbd2_journal_get_create_access()
1259 	 * committing transaction's lists, but it HAS to be in Forget state in  in jbd2_journal_get_create_access()
1260 	 * that case: the transaction must have deleted the buffer for it to be  in jbd2_journal_get_create_access()
1264 	J_ASSERT_JH(jh, (jh->b_transaction == transaction ||  in jbd2_journal_get_create_access()
1278 		 * the buffer so the transaction freeing it must have  in jbd2_journal_get_create_access()
1282 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1287 		__jbd2_journal_file_buffer(jh, transaction, BJ_Reserved);  in jbd2_journal_get_create_access()
1290 		/* first access by this transaction */  in jbd2_journal_get_create_access()
1293 		JBUFFER_TRACE(jh, "set next transaction");  in jbd2_journal_get_create_access()
1295 		jh->b_next_transaction = transaction;  in jbd2_journal_get_create_access()
1317  * @handle: transaction
1333  * We never need to know which transaction the committed data is part
1335  * will be committed to a new transaction in due course, at which point
1398  * a running transaction will match the buffer in that transaction.
1435  * @handle: transaction to add buffer to.
1439  * transaction.
1445  * The buffer is placed on the transaction's metadata list and is marked
1446  * as belonging to the transaction.
1451  * current committing transaction (in which case we should have frozen
1453  * buffer: that only gets done when the old transaction finally
1458 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_dirty_metadata()  local
1470 	 * of the running transaction.  in jbd2_journal_dirty_metadata()
1482 	if (data_race(jh->b_transaction != transaction &&  in jbd2_journal_dirty_metadata()
1483 	    jh->b_next_transaction != transaction)) {  in jbd2_journal_dirty_metadata()
1485 		J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in jbd2_journal_dirty_metadata()
1486 				jh->b_next_transaction == transaction);  in jbd2_journal_dirty_metadata()
1490 		/* If it's in our transaction it must be in BJ_Metadata list. */  in jbd2_journal_dirty_metadata()
1491 		if (data_race(jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1494 			if (jh->b_transaction == transaction &&  in jbd2_journal_dirty_metadata()
1501 			J_ASSERT_JH(jh, jh->b_transaction != transaction ||  in jbd2_journal_dirty_metadata()
1508 	journal = transaction->t_journal;  in jbd2_journal_dirty_metadata()
1514 		 * of the transaction. This needs to be done  in jbd2_journal_dirty_metadata()
1515 		 * once a transaction -bzzz  in jbd2_journal_dirty_metadata()
1527 	 * on the running transaction's metadata list there is nothing to do.  in jbd2_journal_dirty_metadata()
1532 	if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) {  in jbd2_journal_dirty_metadata()
1554 	 * Metadata already on the current transaction list doesn't  in jbd2_journal_dirty_metadata()
1555 	 * need to be filed.  Metadata on another transaction's list must  in jbd2_journal_dirty_metadata()
1559 	if (jh->b_transaction != transaction) {  in jbd2_journal_dirty_metadata()
1560 		JBUFFER_TRACE(jh, "already on other transaction");  in jbd2_journal_dirty_metadata()
1563 			     (jh->b_next_transaction != transaction))) {  in jbd2_journal_dirty_metadata()
1566 			       "transaction (%p, %u), "  in jbd2_journal_dirty_metadata()
1571 			       transaction, transaction->t_tid,  in jbd2_journal_dirty_metadata()
1583 		 * transaction's data buffer, ever. */  in jbd2_journal_dirty_metadata()
1592 	__jbd2_journal_file_buffer(jh, transaction, BJ_Metadata);  in jbd2_journal_dirty_metadata()
1603  * @handle: transaction handle
1607  * buffer.  If the buffer is dirty in the current running transaction we
1620 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_forget()  local
1629 	journal = transaction->t_journal;  in jbd2_journal_forget()
1649 	/* keep track of whether or not this transaction modified us */  in jbd2_journal_forget()
1653 	 * The buffer's going from the transaction, we must drop  in jbd2_journal_forget()
1658 	if (jh->b_transaction == transaction) {  in jbd2_journal_forget()
1662 		 * of this transaction, then we can just drop it from  in jbd2_journal_forget()
1663 		 * the transaction immediately. */  in jbd2_journal_forget()
1667 		JBUFFER_TRACE(jh, "belongs to current transaction: unfile");  in jbd2_journal_forget()
1670 		 * we only want to drop a reference if this transaction  in jbd2_journal_forget()
1678 		 * However, the commit of this transaction is still  in jbd2_journal_forget()
1691 			__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1701 		 * (committing) transaction, we can't drop it yet... */  in jbd2_journal_forget()
1702 		JBUFFER_TRACE(jh, "belongs to older transaction");  in jbd2_journal_forget()
1703 		/* ... but we CAN drop it from the new transaction through  in jbd2_journal_forget()
1705 		 * the new transaction, so that not only the commit code  in jbd2_journal_forget()
1708 		 * after the new transaction commits. */  in jbd2_journal_forget()
1714 			jh->b_next_transaction = transaction;  in jbd2_journal_forget()
1717 			J_ASSERT(jh->b_next_transaction == transaction);  in jbd2_journal_forget()
1720 			 * only drop a reference if this transaction modified  in jbd2_journal_forget()
1729 		 * transaction, we can just drop it now if it has no  in jbd2_journal_forget()
1734 			JBUFFER_TRACE(jh, "belongs to none transaction");  in jbd2_journal_forget()
1751 		 * attach this buffer to current transaction so that the  in jbd2_journal_forget()
1753 		 * transaction commits.  in jbd2_journal_forget()
1756 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in jbd2_journal_forget()
1771  * jbd2_journal_stop() - complete a transaction
1772  * @handle: transaction to complete.
1777  * buffer credits to the transaction and remove the handle.  The only
1784  * transaction began.
1788 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_stop()  local
1801 	if (!transaction) {  in jbd2_journal_stop()
1803 		 * Handle is already detached from the transaction so there is  in jbd2_journal_stop()
1809 	journal = transaction->t_journal;  in jbd2_journal_stop()
1810 	tid = transaction->t_tid;  in jbd2_journal_stop()
1824 	 * Implement synchronous transaction batching.  If the handle  in jbd2_journal_stop()
1827 	 * transaction.  Keep doing that while new threads continue to  in jbd2_journal_stop()
1836 	 * and wait for the transaction to be committed than it is to  in jbd2_journal_stop()
1838 	 * join the transaction.  We achieve this by measuring how  in jbd2_journal_stop()
1839 	 * long it takes to commit a transaction, and compare it with  in jbd2_journal_stop()
1840 	 * how long this transaction has been running, and if run time  in jbd2_journal_stop()
1864 						   transaction->t_start_time));  in jbd2_journal_stop()
1880 		transaction->t_synchronous_commit = 1;  in jbd2_journal_stop()
1884 	 * going!  We also want to force a commit if the transaction is too  in jbd2_journal_stop()
1888 	    time_after_eq(jiffies, transaction->t_expires)) {  in jbd2_journal_stop()
1893 		jbd_debug(2, "transaction too old, requesting commit for "  in jbd2_journal_stop()
1907 	 * Once stop_this_handle() drops t_updates, the transaction could start  in jbd2_journal_stop()
1909 	 * dereference transaction pointer again after calling  in jbd2_journal_stop()
1927  * transaction buffer lists.
1932  * Append a buffer to a transaction list, given the transaction's list head
1956  * Remove a buffer from a transaction list, given the transaction's list
1977  * Remove a buffer from the appropriate transaction list.
1990 	transaction_t *transaction;  in __jbd2_journal_temp_unlink_buffer()  local
1994 	transaction = jh->b_transaction;  in __jbd2_journal_temp_unlink_buffer()
1995 	if (transaction)  in __jbd2_journal_temp_unlink_buffer()
1996 		assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_temp_unlink_buffer()
2000 		J_ASSERT_JH(jh, transaction != NULL);  in __jbd2_journal_temp_unlink_buffer()
2006 		transaction->t_nr_buffers--;  in __jbd2_journal_temp_unlink_buffer()
2007 		J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0);  in __jbd2_journal_temp_unlink_buffer()
2008 		list = &transaction->t_buffers;  in __jbd2_journal_temp_unlink_buffer()
2011 		list = &transaction->t_forget;  in __jbd2_journal_temp_unlink_buffer()
2014 		list = &transaction->t_shadow_list;  in __jbd2_journal_temp_unlink_buffer()
2017 		list = &transaction->t_reserved_list;  in __jbd2_journal_temp_unlink_buffer()
2023 	if (transaction && is_journal_aborted(transaction->t_journal))  in __jbd2_journal_temp_unlink_buffer()
2031  * the jh reference that belonged to the transaction.
2104  * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
2118  * while the data is part of a transaction.  Yes?
2158  * This buffer is no longer needed.  If it is on an older transaction's
2159  * checkpoint list we need to record it on this transaction's forget list
2160  * to pin this buffer (and hence its checkpointing transaction) down until
2161  * this transaction commits.  If the buffer isn't on a checkpoint list, we
2169 static int __dispose_buffer(struct journal_head *jh, transaction_t *transaction)  in __dispose_buffer()  argument
2175 		JBUFFER_TRACE(jh, "on running+cp transaction");  in __dispose_buffer()
2183 		__jbd2_journal_file_buffer(jh, transaction, BJ_Forget);  in __dispose_buffer()
2186 		JBUFFER_TRACE(jh, "on running transaction");  in __dispose_buffer()
2206  *  attached to the current transaction: once the transaction commits,
2210  *  previous, committing transaction!
2213  * transaction (and which therefore cannot be discarded immediately) are
2214  * not going to be reused in the new running transaction
2217  *  allocated in one transaction and removed in the next will be marked
2219  *  the next transaction to delete the block commits.  This means that
2228  * transaction commit --- so it is always safe just to discard data
2235  * transaction.
2237  * We're outside-transaction here.  Either or both of j_running_transaction
2243 	transaction_t *transaction;  in journal_unmap_buffer()  local
2266 	 * transaction adding inode to orphan list (let's call it T)  in journal_unmap_buffer()
2267 	 * is committed.  Otherwise if the transaction changing the  in journal_unmap_buffer()
2272 	 * transaction marking the buffer as freed in the filesystem  in journal_unmap_buffer()
2277 	 * the buffer to BJ_Forget list of the newest transaction.  in journal_unmap_buffer()
2285 	 * the transaction this buffer was modified in.  in journal_unmap_buffer()
2287 	transaction = jh->b_transaction;  in journal_unmap_buffer()
2288 	if (transaction == NULL) {  in journal_unmap_buffer()
2289 		/* First case: not on any transaction.  If it  in journal_unmap_buffer()
2294 			JBUFFER_TRACE(jh, "not on any transaction: zap");  in journal_unmap_buffer()
2309 			/* ... and once the current transaction has  in journal_unmap_buffer()
2317 			/* There is no currently-running transaction. So the  in journal_unmap_buffer()
2320 			 * the committing transaction, if it exists. */  in journal_unmap_buffer()
2327 				/* The orphan record's transaction has  in journal_unmap_buffer()
2334 	} else if (transaction == journal->j_committing_transaction) {  in journal_unmap_buffer()
2335 		JBUFFER_TRACE(jh, "on committing transaction");  in journal_unmap_buffer()
2350 		 * b_modified to not confuse transaction credit accounting, and  in journal_unmap_buffer()
2351 		 * set j_next_transaction to the running transaction (if there  in journal_unmap_buffer()
2365 		/* Good, the buffer belongs to the running transaction.  in journal_unmap_buffer()
2366 		 * We are writing our own transaction's data, not any  in journal_unmap_buffer()
2371 		J_ASSERT_JH(jh, transaction == journal->j_running_transaction);  in journal_unmap_buffer()
2372 		JBUFFER_TRACE(jh, "on running transaction");  in journal_unmap_buffer()
2373 		may_free = __dispose_buffer(jh, transaction);  in journal_unmap_buffer()
2381 	 * running transaction, journal_get_write_access() won't clear  in journal_unmap_buffer()
2410  * Can return -EBUSY if buffers are part of the committing transaction and
2467  * File a buffer on the given transaction list.
2470 			transaction_t *transaction, int jlist)  in __jbd2_journal_file_buffer()  argument
2477 	assert_spin_locked(&transaction->t_journal->j_list_lock);  in __jbd2_journal_file_buffer()
2480 	J_ASSERT_JH(jh, jh->b_transaction == transaction ||  in __jbd2_journal_file_buffer()
2506 	jh->b_transaction = transaction;  in __jbd2_journal_file_buffer()
2514 		transaction->t_nr_buffers++;  in __jbd2_journal_file_buffer()
2515 		list = &transaction->t_buffers;  in __jbd2_journal_file_buffer()
2518 		list = &transaction->t_forget;  in __jbd2_journal_file_buffer()
2521 		list = &transaction->t_shadow_list;  in __jbd2_journal_file_buffer()
2524 		list = &transaction->t_reserved_list;  in __jbd2_journal_file_buffer()
2536 				transaction_t *transaction, int jlist)  in jbd2_journal_file_buffer()  argument
2539 	spin_lock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2540 	__jbd2_journal_file_buffer(jh, transaction, jlist);  in jbd2_journal_file_buffer()
2541 	spin_unlock(&transaction->t_journal->j_list_lock);  in jbd2_journal_file_buffer()
2547  * dropping it from its current transaction entirely.  If the buffer has
2548  * already started to be used by a subsequent transaction, refile the
2549  * buffer on that transaction's metadata list.
2554  * When this function returns true, there's no next transaction to refile to
2574 	 * It has been modified by a later transaction: add it to the new  in __jbd2_journal_refile_buffer()
2575 	 * transaction's metadata list.  in __jbd2_journal_refile_buffer()
2628  * File inode in the inode list of the handle's transaction
2633 	transaction_t *transaction = handle->h_transaction;  in jbd2_journal_file_inode()  local
2638 	journal = transaction->t_journal;  in jbd2_journal_file_inode()
2641 			transaction->t_tid);  in jbd2_journal_file_inode()
2655 	if (jinode->i_transaction == transaction ||  in jbd2_journal_file_inode()
2656 	    jinode->i_next_transaction == transaction)  in jbd2_journal_file_inode()
2664 	if (!transaction->t_need_data_flush)  in jbd2_journal_file_inode()
2665 		transaction->t_need_data_flush = 1;  in jbd2_journal_file_inode()
2666 	/* On some different transaction's list - should be  in jbd2_journal_file_inode()
2672 		jinode->i_next_transaction = transaction;  in jbd2_journal_file_inode()
2675 	/* Not on any transaction list... */  in jbd2_journal_file_inode()
2677 	jinode->i_transaction = transaction;  in jbd2_journal_file_inode()
2678 	list_add(&jinode->i_list, &transaction->t_inode_list);  in jbd2_journal_file_inode()
2701  * File truncate and transaction commit interact with each other in a
2702  * non-trivial way.  If a transaction writing data block A is
2704  * written them.  Otherwise if we crashed after the transaction with
2705  * write has committed but before the transaction with truncate has
2708  * part in case it is in the committing transaction.
2714  * committing the transaction after this function has been called but
2715  * before a transaction for truncate is started (and furthermore it
2717  * happens in the same transaction as write --- we don't have to write
2731 	 * enough that the transaction was not committing before we started  in jbd2_journal_begin_ordered_truncate()
2732 	 * a transaction adding the inode to orphan list */  in jbd2_journal_begin_ordered_truncate()