66  * Base amount of descriptor blocks we reserve for each transaction.
80 	 * Revoke descriptors are accounted separately so we need to reserve  in jbd2_descriptor_blocks_per_trans()
92  * have an existing running transaction: we only make a new transaction
93  * once we have started to commit the old one).
96  *	The journal MUST be locked.  We don't perform atomic mallocs on the
97  *	new transaction	and we can't block without protecting against other
145  * unless debugging is enabled, we no longer update t_max_wait, which
206 	 * We don't call jbd2_might_wait_for_commit() here as there's no  in wait_transaction_switching()
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
246 	 * potential buffers requested by this operation, we need to  in add_transaction_credits()
253 		 * then start to commit it: we can then go back and  in add_transaction_credits()
283 	 * We must therefore ensure the necessary space in the journal  in add_transaction_credits()
299 	/* No reservation? We are done... */  in add_transaction_credits()
304 	/* We allow at most half of a transaction to be reserved */  in add_transaction_credits()
354 		 * If __GFP_FS is not present, then we may be being called from  in start_this_handle()
355 		 * inside the fs writeback layer, so we MUST NOT fail.  in start_this_handle()
368 	 * We need to hold j_state_lock until t_updates has been incremented,  in start_this_handle()
383 	 * we allow reserved handles to proceed because otherwise commit could  in start_this_handle()
410 		/* We may have dropped j_state_lock - restart in that case */  in start_this_handle()
415 		 * We have handle reserved so we are allowed to join T_LOCKED  in start_this_handle()
416 		 * transaction and we don't have to check for transaction size  in start_this_handle()
417 		 * and journal space. But we still have to wait while running  in start_this_handle()
524  * @nblocks: number of block buffer we might modify
526  * We make sure that the transaction can guarantee at least nblocks of
527  * modified buffers in the log.  We block until the log can guarantee
528  * that much space. Additionally, if rsv_blocks > 0, we also create another
712 	 * Subtract necessary revoke descriptor blocks from handle credits. We  in stop_this_handle()
741 	 * Scope of the GFP_NOFS context is over here and so we can restore the  in stop_this_handle()
761  * credits. We preserve reserved handle if there's any attached to the
773 	/* If we've had an abort of any type, don't even think about  in jbd2__journal_restart()
789 	 * TODO: If we use READ_ONCE / WRITE_ONCE for j_commit_request we can  in jbd2__journal_restart()
868 	 * We have now established a barrier against other normal updates, but  in jbd2_journal_lock_updates()
869 	 * we also need to barrier against other jbd2_journal_lock_updates() calls  in jbd2_journal_lock_updates()
870 	 * to make sure that we serialise special journal-locked operations  in jbd2_journal_lock_updates()
916 	/* Fire data frozen trigger just before we copy the data */  in jbd2_freeze_jh_data()
922 	 * Now that the frozen data is saved off, we need to store any matching  in jbd2_freeze_jh_data()
930  * is nothing we need to do.  If it is already part of a prior
931  * transaction which we are still committing to disk, then we need to
932  * make sure that we do not overwrite the old copy: we do copy-out to
933  * preserve the copy going to disk.  We also account the buffer against
969 	/* We now hold the buffer lock so it is safe to query the buffer  in do_get_write_access()
974 	 * Otherwise, it is journaled, and we don't expect dirty buffers  in do_get_write_access()
998 		 * In any case we need to clean the dirty flag and we must  in do_get_write_access()
999 		 * do it under the buffer lock to be sure we don't race  in do_get_write_access()
1031 	 * If the buffer is not journaled right now, we need to make sure it  in do_get_write_access()
1051 	 * If there is already a copy-out version of this buffer, then we don't  in do_get_write_access()
1065 	 * There is one case we have to be very careful about.  If the  in do_get_write_access()
1067 	 * and has NOT made a copy-out, then we cannot modify the buffer  in do_get_write_access()
1070 	 * primary copy is already going to disk then we cannot do copy-out  in do_get_write_access()
1083 	 * past that stage (here we use the fact that BH_Shadow is set under  in do_get_write_access()
1085 	 * point we know the buffer doesn't have BH_Shadow set).  in do_get_write_access()
1087 	 * Subtle point, though: if this is a get_undo_access, then we will be  in do_get_write_access()
1089 	 * committed_data record after the transaction, so we HAVE to force the  in do_get_write_access()
1118 	 * If we are about to journal a buffer, then any revoke pending on it is  in do_get_write_access()
1143 	 * RCU protects us from dereferencing freed pages. So the checks we do  in jbd2_write_access_granted()
1145 	 * & reallocated while we work with it. So we have to be careful. When  in jbd2_write_access_granted()
1146 	 * we see jh attached to the running transaction, we know it must stay  in jbd2_write_access_granted()
1148 	 * will be attached to the same bh while we run.  However it can  in jbd2_write_access_granted()
1150 	 * just after we get pointer to it from bh. So we have to be careful  in jbd2_write_access_granted()
1151 	 * and recheck jh still belongs to our bh before we return success.  in jbd2_write_access_granted()
1168 	 * 1) Make sure to fetch b_bh after we did previous checks so that we  in jbd2_write_access_granted()
1170 	 * while we were checking. Paired with implicit barrier in that path.  in jbd2_write_access_granted()
1193  * because we're ``write()ing`` a buffer which is also part of a shared mapping.
1208 	/* We do not want to get caught playing with fields which the  in jbd2_journal_get_write_access()
1219  * (ie. getblk() returned a new buffer and we are going to populate it
1220  * manually rather than reading off disk), then we need to keep the
1222  * data.  In this case, we should be able to make the assertion that
1271 		 * the commit finished, we've filed the buffer for  in jbd2_journal_get_create_access()
1272 		 * checkpointing and marked it dirty. Now we are reallocating  in jbd2_journal_get_create_access()
1297 	 * blocks which contain freed but then revoked metadata.  We need  in jbd2_journal_get_create_access()
1298 	 * to cancel the revoke in case we end up freeing it yet again  in jbd2_journal_get_create_access()
1317  * this for freeing and allocating space, we have to make sure that we
1319  * since if we overwrote that space we would make the delete
1326  * as we know that the buffer has definitely been committed to disk.
1328  * We never need to know which transaction the committed data is part
1331  * we can discard the old committed data pointer.
1351 	 * Do this first --- it can drop the journal lock, so we want to  in jbd2_journal_get_undo_access()
1446  * current committing transaction (in which case we should have frozen
1447  * data present for that commit).  In that case, we don't relink the
1464 	 * We don't grab jh reference here since the buffer must be part  in jbd2_journal_dirty_metadata()
1472 	 * This and the following assertions are unreliable since we may see jh  in jbd2_journal_dirty_metadata()
1473 	 * in inconsistent state unless we grab bh_state lock. But this is  in jbd2_journal_dirty_metadata()
1524 	 * I _think_ we're OK here with SMP barriers - a mistaken decision will  in jbd2_journal_dirty_metadata()
1525 	 * result in this test being false, so we go in and take the locks.  in jbd2_journal_dirty_metadata()
1577 		/* And this case is illegal: we can't reuse another  in jbd2_journal_dirty_metadata()
1601  * We can only do the bforget if there are no commits pending against the
1602  * buffer.  If the buffer is dirty in the current running transaction we
1648 	 * The buffer's going from the transaction, we must drop  in jbd2_journal_forget()
1656 		/* If we are forgetting a buffer which is already part  in jbd2_journal_forget()
1657 		 * of this transaction, then we can just drop it from  in jbd2_journal_forget()
1665 		 * we only want to drop a reference if this transaction  in jbd2_journal_forget()
1672 		 * We are no longer going to journal this buffer.  in jbd2_journal_forget()
1674 		 * important to the buffer: the delete that we are now  in jbd2_journal_forget()
1676 		 * committing, we can satisfy the buffer's checkpoint.  in jbd2_journal_forget()
1678 		 * So, if we have a checkpoint on the buffer, we should  in jbd2_journal_forget()
1680 		 * we know to remove the checkpoint after we commit.  in jbd2_journal_forget()
1696 		 * (committing) transaction, we can't drop it yet... */  in jbd2_journal_forget()
1698 		/* ... but we CAN drop it from the new transaction through  in jbd2_journal_forget()
1724 		 * transaction, we can just drop it now if it has no  in jbd2_journal_forget()
1745 		 * The buffer is still not written to disk, we should  in jbd2_journal_forget()
1771  * There is not much action needed here.  We just return any remaining
1773  * complication is that we need to start a commit operation if the
1823 	 * arrive.  It doesn't cost much - we're about to run a commit  in jbd2_journal_stop()
1827 	 * We try and optimize the sleep time against what the  in jbd2_journal_stop()
1833 	 * join the transaction.  We achieve this by measuring how  in jbd2_journal_stop()
1836 	 * < commit time then we sleep for the delta and commit.  This  in jbd2_journal_stop()
1841 	 * to perform a synchronous write.  We do this to detect the  in jbd2_journal_stop()
1878 	 * If the handle is marked SYNC, we need to set another commit  in jbd2_journal_stop()
1879 	 * going!  We also want to force a commit if the transaction is too  in jbd2_journal_stop()
1903 	 * committing on us and eventually disappear.  So we must not  in jbd2_journal_stop()
2043 	/* Get reference so that buffer cannot be freed before we unlock it */  in jbd2_journal_unfile_buffer()
2092  * This function returns non-zero if we wish try_to_free_buffers()
2093  * to be called. We do this if the page is releasable by try_to_free_buffers().
2094  * We also do it if the page has locked or dirty buffers and the caller wants
2097  * This complicates JBD locking somewhat.  We aren't protected by the
2098  * BKL here.  We wish to remove the buffer from its committing or
2105  * buffer.  So we need to lock against that.  jbd2_journal_dirty_data()
2112  * cannot happen because we never reallocate freed data as metadata
2132 		 * We take our own ref against the journal_head here to avoid  in jbd2_journal_try_to_free_buffers()
2148 		 * If we free a metadata buffer which has been failed to  in jbd2_journal_try_to_free_buffers()
2171  * checkpoint list we need to record it on this transaction's forget list
2173  * this transaction commits.  If the buffer isn't on a checkpoint list, we
2190 		 * We don't want to write the buffer anymore, clear the  in __dispose_buffer()
2191 		 * bit so that we don't confuse checks in  in __dispose_buffer()
2212  * i_size must be updated on disk before we start calling invalidatepage on the
2217  *  invariant, we can be sure that it is safe to throw away any buffers
2219  *  we know that the data will not be needed.
2221  *  Note however that we can *not* throw away data belonging to the
2237  * The above applies mainly to ordered data mode.  In writeback mode we
2239  * particular we don't guarantee that new dirty data is flushed before
2249  * We're outside-transaction here.  Either or both of j_running_transaction
2263 	 * buffers cannot be stolen by try_to_free_buffers as long as we are  in journal_unmap_buffer()
2271 	/* OK, we have data buffer in journaled mode */  in journal_unmap_buffer()
2277 	 * We cannot remove the buffer from checkpoint lists until the  in journal_unmap_buffer()
2282 	 * the buffer will be lost.  On the other hand we have to  in journal_unmap_buffer()
2291 	 * Also we have to clear buffer_mapped flag of a truncated buffer  in journal_unmap_buffer()
2294 	 * buffer_head can be reused when the file is extended again. So we end  in journal_unmap_buffer()
2302 		 * has no checkpoint link, then we can zap it:  in journal_unmap_buffer()
2303 		 * it's a writeback-mode buffer so we don't care  in journal_unmap_buffer()
2311 			/* bdflush has written it.  We can drop it now */  in journal_unmap_buffer()
2330 			 * orphan record which we wrote for this file must have  in journal_unmap_buffer()
2331 			 * passed into commit.  We must attach this buffer to  in journal_unmap_buffer()
2340 				 * committed.  We can cleanse this buffer */  in journal_unmap_buffer()
2349 		 * The buffer is committing, we simply cannot touch  in journal_unmap_buffer()
2350 		 * it. If the page is straddling i_size we have to wait  in journal_unmap_buffer()
2361 		 * OK, buffer won't be reachable after truncate. We just clear  in journal_unmap_buffer()
2378 		 * We are writing our own transaction's data, not any  in journal_unmap_buffer()
2380 		 * (remember that we expect the filesystem to have set  in journal_unmap_buffer()
2382 		 * expose the disk blocks we are discarding here.) */  in journal_unmap_buffer()
2445 	/* We will potentially be playing with lists other than just the  in jbd2_journal_invalidatepage()
2501 		 * For metadata buffers, we track dirty bit in buffer_jbddirty  in __jbd2_journal_file_buffer()
2502 		 * instead of buffer_dirty. We should not see a dirty bit set  in __jbd2_journal_file_buffer()
2503 		 * here because we clear it in do_get_write_access but e.g.  in __jbd2_journal_file_buffer()
2505 		 * so we try to gracefully handle that.  in __jbd2_journal_file_buffer()
2600 	 * We set b_transaction here because b_next_transaction will inherit  in __jbd2_journal_refile_buffer()
2621  * __jbd2_journal_refile_buffer() with necessary locking added. We take our
2622  * bh reference so that we can safely unlock bh.
2666 	/* Is inode already attached where we need it? */  in jbd2_journal_file_inode()
2672 	 * We only ever set this variable to 1 so the test is safe. Since  in jbd2_journal_file_inode()
2673 	 * t_need_data_flush is likely to be set, we do the test to save some  in jbd2_journal_file_inode()
2715  * committing, we cannot discard the data by truncate until we have
2716  * written them.  Otherwise if we crashed after the transaction with
2718  * committed, we could see stale data in block A.  This function is a
2725  * avoids the race that someone writes new data and we start
2729  * happens in the same transaction as write --- we don't have to write
2743 	 * enough that the transaction was not committing before we started  in jbd2_journal_begin_ordered_truncate()