Lines Matching full:we
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
121 * unless debugging is enabled, we no longer update t_max_wait, which
180 * We don't call jbd2_might_wait_for_commit() here as there's no in wait_transaction_switching()
196 * Wait until we can add credits for handle to the running transaction. Called
198 * transaction. Returns 1 if we had to wait, j_state_lock is dropped, and
220 * potential buffers requested by this operation, we need to in add_transaction_credits()
227 * then start to commit it: we can then go back and in add_transaction_credits()
257 * We must therefore ensure the necessary space in the journal in add_transaction_credits()
272 /* No reservation? We are done... */ in add_transaction_credits()
277 /* We allow at most half of a transaction to be reserved */ in add_transaction_credits()
327 * If __GFP_FS is not present, then we may be being called from in start_this_handle()
328 * inside the fs writeback layer, so we MUST NOT fail. in start_this_handle()
341 * We need to hold j_state_lock until t_updates has been incremented, in start_this_handle()
356 * we allow reserved handles to proceed because otherwise commit could in start_this_handle()
383 /* We may have dropped j_state_lock - restart in that case */ in start_this_handle()
388 * We have handle reserved so we are allowed to join T_LOCKED in start_this_handle()
389 * transaction and we don't have to check for transaction size in start_this_handle()
390 * and journal space. But we still have to wait while running in start_this_handle()
493 * @nblocks: number of block buffer we might modify
495 * We make sure that the transaction can guarantee at least nblocks of
496 * modified buffers in the log. We block until the log can guarantee
497 * that much space. Additionally, if rsv_blocks > 0, we also create another
672 * credits. We preserve reserved handle if there's any attached to the
682 /* If we've had an abort of any type, don't even think about in jbd2__journal_restart()
787 * We have now established a barrier against other normal updates, but in jbd2_journal_lock_updates()
788 * we also need to barrier against other jbd2_journal_lock_updates() calls in jbd2_journal_lock_updates()
789 * to make sure that we serialise special journal-locked operations in jbd2_journal_lock_updates()
835 /* Fire data frozen trigger just before we copy the data */ in jbd2_freeze_jh_data()
841 * Now that the frozen data is saved off, we need to store any matching in jbd2_freeze_jh_data()
849 * is nothing we need to do. If it is already part of a prior
850 * transaction which we are still committing to disk, then we need to
851 * make sure that we do not overwrite the old copy: we do copy-out to
852 * preserve the copy going to disk. We also account the buffer against
890 /* We now hold the buffer lock so it is safe to query the buffer in do_get_write_access()
895 * Otherwise, it is journaled, and we don't expect dirty buffers in do_get_write_access()
919 * In any case we need to clean the dirty flag and we must in do_get_write_access()
920 * do it under the buffer lock to be sure we don't race in do_get_write_access()
952 * If the buffer is not journaled right now, we need to make sure it in do_get_write_access()
972 * If there is already a copy-out version of this buffer, then we don't in do_get_write_access()
986 * There is one case we have to be very careful about. If the in do_get_write_access()
988 * and has NOT made a copy-out, then we cannot modify the buffer in do_get_write_access()
991 * primary copy is already going to disk then we cannot do copy-out in do_get_write_access()
1004 * past that stage (here we use the fact that BH_Shadow is set under in do_get_write_access()
1006 * point we know the buffer doesn't have BH_Shadow set). in do_get_write_access()
1008 * Subtle point, though: if this is a get_undo_access, then we will be in do_get_write_access()
1010 * committed_data record after the transaction, so we HAVE to force the in do_get_write_access()
1039 * If we are about to journal a buffer, then any revoke pending on it is in do_get_write_access()
1064 * RCU protects us from dereferencing freed pages. So the checks we do in jbd2_write_access_granted()
1066 * & reallocated while we work with it. So we have to be careful. When in jbd2_write_access_granted()
1067 * we see jh attached to the running transaction, we know it must stay in jbd2_write_access_granted()
1069 * will be attached to the same bh while we run. However it can in jbd2_write_access_granted()
1071 * just after we get pointer to it from bh. So we have to be careful in jbd2_write_access_granted()
1072 * and recheck jh still belongs to our bh before we return success. in jbd2_write_access_granted()
1089 * 1) Make sure to fetch b_bh after we did previous checks so that we in jbd2_write_access_granted()
1091 * while we were checking. Paired with implicit barrier in that path. in jbd2_write_access_granted()
1113 * because we're ``write()ing`` a buffer which is also part of a shared mapping.
1125 /* We do not want to get caught playing with fields which the in jbd2_journal_get_write_access()
1136 * (ie. getblk() returned a new buffer and we are going to populate it
1137 * manually rather than reading off disk), then we need to keep the
1139 * data. In this case, we should be able to make the assertion that
1188 * the commit finished, we've filed the buffer for in jbd2_journal_get_create_access()
1189 * checkpointing and marked it dirty. Now we are reallocating in jbd2_journal_get_create_access()
1214 * blocks which contain freed but then revoked metadata. We need in jbd2_journal_get_create_access()
1215 * to cancel the revoke in case we end up freeing it yet again in jbd2_journal_get_create_access()
1234 * this for freeing and allocating space, we have to make sure that we
1236 * since if we overwrote that space we would make the delete
1243 * as we know that the buffer has definitely been committed to disk.
1245 * We never need to know which transaction the committed data is part
1248 * we can discard the old committed data pointer.
1265 * Do this first --- it can drop the journal lock, so we want to in jbd2_journal_get_undo_access()
1360 * current committing transaction (in which case we should have frozen
1361 * data present for that commit). In that case, we don't relink the
1378 * We don't grab jh reference here since the buffer must be part in jbd2_journal_dirty_metadata()
1386 * This and the following assertions are unreliable since we may see jh in jbd2_journal_dirty_metadata()
1387 * in inconsistent state unless we grab bh_state lock. But this is in jbd2_journal_dirty_metadata()
1438 * I _think_ we're OK here with SMP barriers - a mistaken decision will in jbd2_journal_dirty_metadata()
1439 * result in this test being false, so we go in and take the locks. in jbd2_journal_dirty_metadata()
1491 /* And this case is illegal: we can't reuse another in jbd2_journal_dirty_metadata()
1515 * We can only do the bforget if there are no commits pending against the
1516 * buffer. If the buffer is dirty in the current running transaction we
1560 * The buffer's going from the transaction, we must drop in jbd2_journal_forget()
1568 /* If we are forgetting a buffer which is already part in jbd2_journal_forget()
1569 * of this transaction, then we can just drop it from in jbd2_journal_forget()
1577 * we only want to drop a reference if this transaction in jbd2_journal_forget()
1584 * We are no longer going to journal this buffer. in jbd2_journal_forget()
1586 * important to the buffer: the delete that we are now in jbd2_journal_forget()
1588 * committing, we can satisfy the buffer's checkpoint. in jbd2_journal_forget()
1590 * So, if we have a checkpoint on the buffer, we should in jbd2_journal_forget()
1592 * we know to remove the checkpoint after we commit. in jbd2_journal_forget()
1611 * (committing) transaction, we can't drop it yet... */ in jbd2_journal_forget()
1613 /* ... but we CAN drop it from the new transaction through in jbd2_journal_forget()
1639 * transaction, we can just drop it now if it has no in jbd2_journal_forget()
1660 * The buffer is still not written to disk, we should in jbd2_journal_forget()
1691 * There is not much action needed here. We just return any remaining
1693 * complication is that we need to start a commit operation if the
1754 * arrive. It doesn't cost much - we're about to run a commit in jbd2_journal_stop()
1758 * We try and optimize the sleep time against what the in jbd2_journal_stop()
1764 * join the transaction. We achieve this by measuring how in jbd2_journal_stop()
1767 * < commit time then we sleep for the delta and commit. This in jbd2_journal_stop()
1772 * to perform a synchronous write. We do this to detect the in jbd2_journal_stop()
1812 * If the handle is marked SYNC, we need to set another commit in jbd2_journal_stop()
1813 * going! We also want to force a commit if the current in jbd2_journal_stop()
1839 * Once we drop t_updates, if it goes to zero the transaction in jbd2_journal_stop()
1841 * once we do this, we must not dereference transaction in jbd2_journal_stop()
1860 * Scope of the GFP_NOFS context is over here and so we can restore the in jbd2_journal_stop()
1991 /* Get reference so that buffer cannot be freed before we unlock it */ in jbd2_journal_unfile_buffer()
2034 * @gfp_mask: we use the mask to detect how hard should we try to release
2035 * buffers. If __GFP_DIRECT_RECLAIM and __GFP_FS is set, we wait for commit
2043 * This function returns non-zero if we wish try_to_free_buffers()
2044 * to be called. We do this if the page is releasable by try_to_free_buffers().
2045 * We also do it if the page has locked or dirty buffers and the caller wants
2048 * This complicates JBD locking somewhat. We aren't protected by the
2049 * BKL here. We wish to remove the buffer from its committing or
2056 * buffer. So we need to lock against that. jbd2_journal_dirty_data()
2063 * cannot happen because we never reallocate freed data as metadata
2083 * We take our own ref against the journal_head here to avoid in jbd2_journal_try_to_free_buffers()
2107 * checkpoint list we need to record it on this transaction's forget list
2109 * this transaction commits. If the buffer isn't on a checkpoint list, we
2126 * We don't want to write the buffer anymore, clear the in __dispose_buffer()
2127 * bit so that we don't confuse checks in in __dispose_buffer()
2147 * i_size must be updated on disk before we start calling invalidatepage on the
2152 * invariant, we can be sure that it is safe to throw away any buffers
2154 * we know that the data will not be needed.
2156 * Note however that we can *not* throw away data belonging to the
2172 * The above applies mainly to ordered data mode. In writeback mode we
2174 * particular we don't guarantee that new dirty data is flushed before
2184 * We're outside-transaction here. Either or both of j_running_transaction
2198 * buffers cannot be stolen by try_to_free_buffers as long as we are in journal_unmap_buffer()
2205 /* OK, we have data buffer in journaled mode */ in journal_unmap_buffer()
2215 * We cannot remove the buffer from checkpoint lists until the in journal_unmap_buffer()
2220 * the buffer will be lost. On the other hand we have to in journal_unmap_buffer()
2229 * Also we have to clear buffer_mapped flag of a truncated buffer in journal_unmap_buffer()
2232 * buffer_head can be reused when the file is extended again. So we end in journal_unmap_buffer()
2240 * has no checkpoint link, then we can zap it: in journal_unmap_buffer()
2241 * it's a writeback-mode buffer so we don't care in journal_unmap_buffer()
2249 /* bdflush has written it. We can drop it now */ in journal_unmap_buffer()
2268 * orphan record which we wrote for this file must have in journal_unmap_buffer()
2269 * passed into commit. We must attach this buffer to in journal_unmap_buffer()
2278 * committed. We can cleanse this buffer */ in journal_unmap_buffer()
2287 * The buffer is committing, we simply cannot touch in journal_unmap_buffer()
2288 * it. If the page is straddling i_size we have to wait in journal_unmap_buffer()
2299 * OK, buffer won't be reachable after truncate. We just set in journal_unmap_buffer()
2314 * We are writing our own transaction's data, not any in journal_unmap_buffer()
2316 * (remember that we expect the filesystem to have set in journal_unmap_buffer()
2318 * expose the disk blocks we are discarding here.) */ in journal_unmap_buffer()
2382 /* We will potentially be playing with lists other than just the in jbd2_journal_invalidatepage()
2438 * For metadata buffers, we track dirty bit in buffer_jbddirty in __jbd2_journal_file_buffer()
2439 * instead of buffer_dirty. We should not see a dirty bit set in __jbd2_journal_file_buffer()
2440 * here because we clear it in do_get_write_access but e.g. in __jbd2_journal_file_buffer()
2442 * so we try to gracefully handle that. in __jbd2_journal_file_buffer()
2528 * We set b_transaction here because b_next_transaction will inherit in __jbd2_journal_refile_buffer()
2548 * __jbd2_journal_refile_buffer() with necessary locking added. We take our
2549 * bh reference so that we can safely unlock bh.
2557 /* Get reference so that buffer cannot be freed before we unlock it */ in jbd2_journal_refile_buffer()
2594 /* Is inode already attached where we need it? */ in jbd2_journal_file_inode()
2600 * We only ever set this variable to 1 so the test is safe. Since in jbd2_journal_file_inode()
2601 * t_need_data_flush is likely to be set, we do the test to save some in jbd2_journal_file_inode()
2643 * committing, we cannot discard the data by truncate until we have
2644 * written them. Otherwise if we crashed after the transaction with
2646 * committed, we could see stale data in block A. This function is a
2653 * avoids the race that someone writes new data and we start
2657 * happens in the same transaction as write --- we don't have to write
2671 * enough that the transaction was not committing before we started in jbd2_journal_begin_ordered_truncate()