70  * have an existing running transaction: we only make a new transaction
71  * once we have started to commit the old one).
74  *	The journal MUST be locked.  We don't perform atomic mallocs on the
75  *	new transaction	and we can't block without protecting against other
175 	 * We don't call jbd2_might_wait_for_commit() here as there's no  in wait_transaction_switching()
198  * Wait until we can add credits for handle to the running transaction.  Called
200  * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
204  * value, we need to fake out sparse so ti doesn't complain about a
229 	 * potential buffers requested by this operation, we need to  in add_transaction_credits()
236 		 * then start to commit it: we can then go back and  in add_transaction_credits()
268 	 * We must therefore ensure the necessary space in the journal  in add_transaction_credits()
285 	/* No reservation? We are done... */  in add_transaction_credits()
290 	/* We allow at most half of a transaction to be reserved */  in add_transaction_credits()
341 	 * transaction early if there are high chances we'll need it. If we  in start_this_handle()
342 	 * guess wrong, we'll retry or free unused transaction.  in start_this_handle()
346 		 * If __GFP_FS is not present, then we may be being called from  in start_this_handle()
347 		 * inside the fs writeback layer, so we MUST NOT fail.  in start_this_handle()
360 	 * We need to hold j_state_lock until t_updates has been incremented,  in start_this_handle()
375 	 * we allow reserved handles to proceed because otherwise commit could  in start_this_handle()
402 		/* We may have dropped j_state_lock - restart in that case */  in start_this_handle()
413 		 * We have handle reserved so we are allowed to join T_LOCKED  in start_this_handle()
414 		 * transaction and we don't have to check for transaction size  in start_this_handle()
415 		 * and journal space. But we still have to wait while running  in start_this_handle()
522  * @nblocks: number of block buffer we might modify
524  * We make sure that the transaction can guarantee at least nblocks of
525  * modified buffers in the log.  We block until the log can guarantee
526  * that much space. Additionally, if rsv_blocks > 0, we also create another
707 	 * Subtract necessary revoke descriptor blocks from handle credits. We  in stop_this_handle()
736 	 * Scope of the GFP_NOFS context is over here and so we can restore the  in stop_this_handle()
756  * credits. We preserve reserved handle if there's any attached to the
768 	/* If we've had an abort of any type, don't even think about  in jbd2__journal_restart()
784 	 * TODO: If we use READ_ONCE / WRITE_ONCE for j_commit_request we can  in jbd2__journal_restart()
825 		 * jbd2_journal_free_transaction(). This can only happen when we  in jbd2_journal_wait_updates()
827 		 * Hence we should everytime retrieve new j_running_transaction  in jbd2_journal_wait_updates()
880 	 * We have now established a barrier against other normal updates, but  in jbd2_journal_lock_updates()
881 	 * we also need to barrier against other jbd2_journal_lock_updates() calls  in jbd2_journal_lock_updates()
882 	 * to make sure that we serialise special journal-locked operations  in jbd2_journal_lock_updates()
924 	/* Fire data frozen trigger just before we copy the data */  in jbd2_freeze_jh_data()
930 	 * Now that the frozen data is saved off, we need to store any matching  in jbd2_freeze_jh_data()
938  * is nothing we need to do.  If it is already part of a prior
939  * transaction which we are still committing to disk, then we need to
940  * make sure that we do not overwrite the old copy: we do copy-out to
941  * preserve the copy going to disk.  We also account the buffer against
977 	/* We now hold the buffer lock so it is safe to query the buffer  in do_get_write_access()
982 	 * Otherwise, it is journaled, and we don't expect dirty buffers  in do_get_write_access()
993 		 * We need to clean the dirty flag and we must do it under the  in do_get_write_access()
994 		 * buffer lock to be sure we don't race with running write-out.  in do_get_write_access()
1001 		 * ever called for it. So we need to set jbddirty bit here to  in do_get_write_access()
1033 	 * If the buffer is not journaled right now, we need to make sure it  in do_get_write_access()
1067 	 * If there is already a copy-out version of this buffer, then we don't  in do_get_write_access()
1081 	 * There is one case we have to be very careful about.  If the  in do_get_write_access()
1083 	 * and has NOT made a copy-out, then we cannot modify the buffer  in do_get_write_access()
1086 	 * primary copy is already going to disk then we cannot do copy-out  in do_get_write_access()
1099 	 * past that stage (here we use the fact that BH_Shadow is set under  in do_get_write_access()
1101 	 * point we know the buffer doesn't have BH_Shadow set).  in do_get_write_access()
1103 	 * Subtle point, though: if this is a get_undo_access, then we will be  in do_get_write_access()
1105 	 * committed_data record after the transaction, so we HAVE to force the  in do_get_write_access()
1134 	 * If we are about to journal a buffer, then any revoke pending on it is  in do_get_write_access()
1159 	 * RCU protects us from dereferencing freed pages. So the checks we do  in jbd2_write_access_granted()
1161 	 * & reallocated while we work with it. So we have to be careful. When  in jbd2_write_access_granted()
1162 	 * we see jh attached to the running transaction, we know it must stay  in jbd2_write_access_granted()
1164 	 * will be attached to the same bh while we run.  However it can  in jbd2_write_access_granted()
1166 	 * just after we get pointer to it from bh. So we have to be careful  in jbd2_write_access_granted()
1167 	 * and recheck jh still belongs to our bh before we return success.  in jbd2_write_access_granted()
1184 	 * 1) Make sure to fetch b_bh after we did previous checks so that we  in jbd2_write_access_granted()
1186 	 * while we were checking. Paired with implicit barrier in that path.  in jbd2_write_access_granted()
1209  * because we're ``write()ing`` a buffer which is also part of a shared mapping.
1226 		 * In this case, we could read old data from disk and write  in jbd2_journal_get_write_access()
1238 	/* We do not want to get caught playing with fields which the  in jbd2_journal_get_write_access()
1249  * (ie. getblk() returned a new buffer and we are going to populate it
1250  * manually rather than reading off disk), then we need to keep the
1252  * data.  In this case, we should be able to make the assertion that
1301 		 * the commit finished, we've filed the buffer for  in jbd2_journal_get_create_access()
1302 		 * checkpointing and marked it dirty. Now we are reallocating  in jbd2_journal_get_create_access()
1327 	 * blocks which contain freed but then revoked metadata.  We need  in jbd2_journal_get_create_access()
1328 	 * to cancel the revoke in case we end up freeing it yet again  in jbd2_journal_get_create_access()
1347  * this for freeing and allocating space, we have to make sure that we
1349  * since if we overwrote that space we would make the delete
1356  * as we know that the buffer has definitely been committed to disk.
1358  * We never need to know which transaction the committed data is part
1361  * we can discard the old committed data pointer.
1381 	 * Do this first --- it can drop the journal lock, so we want to  in jbd2_journal_get_undo_access()
1476  * current committing transaction (in which case we should have frozen
1477  * data present for that commit).  In that case, we don't relink the
1492 	 * We don't grab jh reference here since the buffer must be part  in jbd2_journal_dirty_metadata()
1500 	 * This and the following assertions are unreliable since we may see jh  in jbd2_journal_dirty_metadata()
1501 	 * in inconsistent state unless we grab bh_state lock. But this is  in jbd2_journal_dirty_metadata()
1564 	 * I _think_ we're OK here with SMP barriers - a mistaken decision will  in jbd2_journal_dirty_metadata()
1565 	 * result in this test being false, so we go in and take the locks.  in jbd2_journal_dirty_metadata()
1617 		/* And this case is illegal: we can't reuse another  in jbd2_journal_dirty_metadata()
1641  * We can only do the bforget if there are no commits pending against the
1642  * buffer.  If the buffer is dirty in the current running transaction we
1688 	 * The buffer's going from the transaction, we must drop  in jbd2_journal_forget()
1696 		/* If we are forgetting a buffer which is already part  in jbd2_journal_forget()
1697 		 * of this transaction, then we can just drop it from  in jbd2_journal_forget()
1705 		 * we only want to drop a reference if this transaction  in jbd2_journal_forget()
1712 		 * We are no longer going to journal this buffer.  in jbd2_journal_forget()
1714 		 * important to the buffer: the delete that we are now  in jbd2_journal_forget()
1716 		 * committing, we can satisfy the buffer's checkpoint.  in jbd2_journal_forget()
1718 		 * So, if we have a checkpoint on the buffer, we should  in jbd2_journal_forget()
1720 		 * we know to remove the checkpoint after we commit.  in jbd2_journal_forget()
1736 		 * (committing) transaction, we can't drop it yet... */  in jbd2_journal_forget()
1738 		/* ... but we CAN drop it from the new transaction through  in jbd2_journal_forget()
1764 		 * transaction, we can just drop it now if it has no  in jbd2_journal_forget()
1784 		 * The buffer is still not written to disk, we should  in jbd2_journal_forget()
1810  * There is not much action needed here.  We just return any remaining
1812  * complication is that we need to start a commit operation if the
1862 	 * arrive.  It doesn't cost much - we're about to run a commit  in jbd2_journal_stop()
1866 	 * We try and optimize the sleep time against what the  in jbd2_journal_stop()
1872 	 * join the transaction.  We achieve this by measuring how  in jbd2_journal_stop()
1875 	 * < commit time then we sleep for the delta and commit.  This  in jbd2_journal_stop()
1880 	 * to perform a synchronous write.  We do this to detect the  in jbd2_journal_stop()
1917 	 * If the handle is marked SYNC, we need to set another commit  in jbd2_journal_stop()
1918 	 * going!  We also want to force a commit if the transaction is too  in jbd2_journal_stop()
1942 	 * committing on us and eventually disappear.  So we must not  in jbd2_journal_stop()
2087  * This function returns non-zero if we wish try_to_free_buffers()
2088  * to be called. We do this if the page is releasable by try_to_free_buffers().
2089  * We also do it if the page has locked or dirty buffers and the caller wants
2092  * This complicates JBD locking somewhat.  We aren't protected by the
2093  * BKL here.  We wish to remove the buffer from its committing or
2100  * buffer.  So we need to lock against that.  jbd2_journal_dirty_data()
2107  * cannot happen because we never reallocate freed data as metadata
2126 		 * We take our own ref against the journal_head here to avoid  in jbd2_journal_try_to_free_buffers()
2155  * checkpoint list we need to record it on this transaction's forget list
2157  * this transaction commits.  If the buffer isn't on a checkpoint list, we
2174 		 * We don't want to write the buffer anymore, clear the  in __dispose_buffer()
2175 		 * bit so that we don't confuse checks in  in __dispose_buffer()
2196  * i_size must be updated on disk before we start calling invalidate_folio
2201  *  invariant, we can be sure that it is safe to throw away any buffers
2203  *  we know that the data will not be needed.
2205  *  Note however that we can *not* throw away data belonging to the
2221  * The above applies mainly to ordered data mode.  In writeback mode we
2223  * particular we don't guarantee that new dirty data is flushed before
2233  * We're outside-transaction here.  Either or both of j_running_transaction
2247 	 * buffers cannot be stolen by try_to_free_buffers as long as we are  in journal_unmap_buffer()
2255 	/* OK, we have data buffer in journaled mode */  in journal_unmap_buffer()
2261 	 * We cannot remove the buffer from checkpoint lists until the  in journal_unmap_buffer()
2266 	 * the buffer will be lost.  On the other hand we have to  in journal_unmap_buffer()
2275 	 * Also we have to clear buffer_mapped flag of a truncated buffer  in journal_unmap_buffer()
2278 	 * buffer_head can be reused when the file is extended again. So we end  in journal_unmap_buffer()
2286 		 * has no checkpoint link, then we can zap it:  in journal_unmap_buffer()
2287 		 * it's a writeback-mode buffer so we don't care  in journal_unmap_buffer()
2295 			/* bdflush has written it.  We can drop it now */  in journal_unmap_buffer()
2314 			 * orphan record which we wrote for this file must have  in journal_unmap_buffer()
2315 			 * passed into commit.  We must attach this buffer to  in journal_unmap_buffer()
2324 				 * committed.  We can cleanse this buffer */  in journal_unmap_buffer()
2333 		 * The buffer is committing, we simply cannot touch  in journal_unmap_buffer()
2334 		 * it. If the page is straddling i_size we have to wait  in journal_unmap_buffer()
2348 		 * OK, buffer won't be reachable after truncate. We just clear  in journal_unmap_buffer()
2365 		 * We are writing our own transaction's data, not any  in journal_unmap_buffer()
2367 		 * (remember that we expect the filesystem to have set  in journal_unmap_buffer()
2369 		 * expose the disk blocks we are discarding here.) */  in journal_unmap_buffer()
2431 	/* We will potentially be playing with lists other than just the  in jbd2_journal_invalidate_folio()
2487 		 * For metadata buffers, we track dirty bit in buffer_jbddirty  in __jbd2_journal_file_buffer()
2488 		 * instead of buffer_dirty. We should not see a dirty bit set  in __jbd2_journal_file_buffer()
2489 		 * here because we clear it in do_get_write_access but e.g.  in __jbd2_journal_file_buffer()
2491 		 * so we try to gracefully handle that.  in __jbd2_journal_file_buffer()
2586 	 * We set b_transaction here because b_next_transaction will inherit  in __jbd2_journal_refile_buffer()
2607  * __jbd2_journal_refile_buffer() with necessary locking added. We take our
2608  * bh reference so that we can safely unlock bh.
2652 	/* Is inode already attached where we need it? */  in jbd2_journal_file_inode()
2658 	 * We only ever set this variable to 1 so the test is safe. Since  in jbd2_journal_file_inode()
2659 	 * t_need_data_flush is likely to be set, we do the test to save some  in jbd2_journal_file_inode()
2701  * committing, we cannot discard the data by truncate until we have
2702  * written them.  Otherwise if we crashed after the transaction with
2704  * committed, we could see stale data in block A.  This function is a
2711  * avoids the race that someone writes new data and we start
2715  * happens in the same transaction as write --- we don't have to write
2729 	 * enough that the transaction was not committing before we started  in jbd2_journal_begin_ordered_truncate()