Lines Matching +full:wait +full:- +full:free +full:- +full:us
1 // SPDX-License-Identifier: GPL-2.0+
7 * Copyright 1998 Red Hat corp --- All Rights Reserved
26 #include <linux/backing-dev.h>
47 return -ENOMEM; in jbd2_journal_init_transaction_cache()
83 transaction->t_journal = journal; in jbd2_get_transaction()
84 transaction->t_state = T_RUNNING; in jbd2_get_transaction()
85 transaction->t_start_time = ktime_get(); in jbd2_get_transaction()
86 transaction->t_tid = journal->j_transaction_sequence++; in jbd2_get_transaction()
87 transaction->t_expires = jiffies + journal->j_commit_interval; in jbd2_get_transaction()
88 atomic_set(&transaction->t_updates, 0); in jbd2_get_transaction()
89 atomic_set(&transaction->t_outstanding_credits, in jbd2_get_transaction()
90 journal->j_transaction_overhead_buffers + in jbd2_get_transaction()
91 atomic_read(&journal->j_reserved_credits)); in jbd2_get_transaction()
92 atomic_set(&transaction->t_outstanding_revokes, 0); in jbd2_get_transaction()
93 atomic_set(&transaction->t_handle_count, 0); in jbd2_get_transaction()
94 INIT_LIST_HEAD(&transaction->t_inode_list); in jbd2_get_transaction()
97 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires); in jbd2_get_transaction()
98 add_timer(&journal->j_commit_timer); in jbd2_get_transaction()
100 J_ASSERT(journal->j_running_transaction == NULL); in jbd2_get_transaction()
101 journal->j_running_transaction = transaction; in jbd2_get_transaction()
102 transaction->t_max_wait = 0; in jbd2_get_transaction()
103 transaction->t_start = jiffies; in jbd2_get_transaction()
104 transaction->t_requested = 0; in jbd2_get_transaction()
125 if (time_after(transaction->t_start, ts)) { in update_t_max_wait()
126 newts = jbd2_time_diff(ts, transaction->t_start); in update_t_max_wait()
127 oldts = READ_ONCE(transaction->t_max_wait); in update_t_max_wait()
129 oldts = cmpxchg(&transaction->t_max_wait, oldts, newts); in update_t_max_wait()
134 * Wait until running transaction passes to T_FLUSH state and new transaction
139 __releases(journal->j_state_lock) in wait_transaction_locked()
141 DEFINE_WAIT(wait); in wait_transaction_locked()
143 tid_t tid = journal->j_running_transaction->t_tid; in wait_transaction_locked()
145 prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait, in wait_transaction_locked()
147 need_to_start = !tid_geq(journal->j_commit_request, tid); in wait_transaction_locked()
148 read_unlock(&journal->j_state_lock); in wait_transaction_locked()
153 finish_wait(&journal->j_wait_transaction_locked, &wait); in wait_transaction_locked()
157 * Wait until running transaction transitions from T_SWITCH to T_FLUSH
162 __releases(journal->j_state_lock) in wait_transaction_switching()
164 DEFINE_WAIT(wait); in wait_transaction_switching()
166 if (WARN_ON(!journal->j_running_transaction || in wait_transaction_switching()
167 journal->j_running_transaction->t_state != T_SWITCH)) { in wait_transaction_switching()
168 read_unlock(&journal->j_state_lock); in wait_transaction_switching()
171 prepare_to_wait_exclusive(&journal->j_wait_transaction_locked, &wait, in wait_transaction_switching()
173 read_unlock(&journal->j_state_lock); in wait_transaction_switching()
181 finish_wait(&journal->j_wait_transaction_locked, &wait); in wait_transaction_switching()
186 atomic_sub(blocks, &journal->j_reserved_credits); in sub_reserved_credits()
187 wake_up(&journal->j_wait_reserved); in sub_reserved_credits()
193 return journal->j_max_transaction_buffers - in jbd2_max_user_trans_buffers()
194 journal->j_transaction_overhead_buffers; in jbd2_max_user_trans_buffers()
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
210 __must_hold(&journal->j_state_lock) in add_transaction_credits()
212 transaction_t *t = journal->j_running_transaction; in add_transaction_credits()
217 * If the current transaction is locked down for commit, wait in add_transaction_credits()
220 if (t->t_state != T_RUNNING) { in add_transaction_credits()
221 WARN_ON_ONCE(t->t_state >= T_FLUSH); in add_transaction_credits()
223 __acquire(&journal->j_state_lock); /* fake out sparse */ in add_transaction_credits()
230 * stall pending a log checkpoint to free some more log space. in add_transaction_credits()
232 needed = atomic_add_return(total, &t->t_outstanding_credits); in add_transaction_credits()
233 if (needed > journal->j_max_transaction_buffers) { in add_transaction_credits()
239 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
243 * big to fit this handle? Wait until reserved credits are freed. in add_transaction_credits()
245 if (atomic_read(&journal->j_reserved_credits) + total > in add_transaction_credits()
247 read_unlock(&journal->j_state_lock); in add_transaction_credits()
249 wait_event(journal->j_wait_reserved, in add_transaction_credits()
250 atomic_read(&journal->j_reserved_credits) + total <= in add_transaction_credits()
252 __acquire(&journal->j_state_lock); /* fake out sparse */ in add_transaction_credits()
257 __acquire(&journal->j_state_lock); /* fake out sparse */ in add_transaction_credits()
272 if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) { in add_transaction_credits()
273 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
274 read_unlock(&journal->j_state_lock); in add_transaction_credits()
276 write_lock(&journal->j_state_lock); in add_transaction_credits()
278 journal->j_max_transaction_buffers) in add_transaction_credits()
280 write_unlock(&journal->j_state_lock); in add_transaction_credits()
281 __acquire(&journal->j_state_lock); /* fake out sparse */ in add_transaction_credits()
289 needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits); in add_transaction_credits()
293 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
294 read_unlock(&journal->j_state_lock); in add_transaction_credits()
296 wait_event(journal->j_wait_reserved, in add_transaction_credits()
297 atomic_read(&journal->j_reserved_credits) + rsv_blocks in add_transaction_credits()
299 __acquire(&journal->j_state_lock); /* fake out sparse */ in add_transaction_credits()
316 int blocks = handle->h_total_credits; in start_this_handle()
320 if (handle->h_rsv_handle) in start_this_handle()
321 rsv_blocks = handle->h_rsv_handle->h_total_credits; in start_this_handle()
332 current->comm, blocks, rsv_blocks, in start_this_handle()
335 return -ENOSPC; in start_this_handle()
342 * guess wrong, we'll retry or free unused transaction. in start_this_handle()
344 if (!data_race(journal->j_running_transaction)) { in start_this_handle()
354 return -ENOMEM; in start_this_handle()
364 read_lock(&journal->j_state_lock); in start_this_handle()
365 BUG_ON(journal->j_flags & JBD2_UNMOUNT); in start_this_handle()
367 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) { in start_this_handle()
368 read_unlock(&journal->j_state_lock); in start_this_handle()
370 return -EROFS; in start_this_handle()
374 * Wait on the journal's transaction barrier if necessary. Specifically in start_this_handle()
378 if (!handle->h_reserved && journal->j_barrier_count) { in start_this_handle()
379 read_unlock(&journal->j_state_lock); in start_this_handle()
380 wait_event(journal->j_wait_transaction_locked, in start_this_handle()
381 journal->j_barrier_count == 0); in start_this_handle()
385 if (!journal->j_running_transaction) { in start_this_handle()
386 read_unlock(&journal->j_state_lock); in start_this_handle()
389 write_lock(&journal->j_state_lock); in start_this_handle()
390 if (!journal->j_running_transaction && in start_this_handle()
391 (handle->h_reserved || !journal->j_barrier_count)) { in start_this_handle()
395 write_unlock(&journal->j_state_lock); in start_this_handle()
399 transaction = journal->j_running_transaction; in start_this_handle()
401 if (!handle->h_reserved) { in start_this_handle()
402 /* We may have dropped j_state_lock - restart in that case */ in start_this_handle()
406 * j_state_lock on a non-zero return in start_this_handle()
408 __release(&journal->j_state_lock); in start_this_handle()
415 * and journal space. But we still have to wait while running in start_this_handle()
417 * won't wait for any handles anymore. in start_this_handle()
419 if (transaction->t_state == T_SWITCH) { in start_this_handle()
424 handle->h_reserved = 0; in start_this_handle()
431 handle->h_transaction = transaction; in start_this_handle()
432 handle->h_requested_credits = blocks; in start_this_handle()
433 handle->h_revoke_credits_requested = handle->h_revoke_credits; in start_this_handle()
434 handle->h_start_jiffies = jiffies; in start_this_handle()
435 atomic_inc(&transaction->t_updates); in start_this_handle()
436 atomic_inc(&transaction->t_handle_count); in start_this_handle()
437 jbd2_debug(4, "Handle %p given %d credits (total %d, free %lu)\n", in start_this_handle()
439 atomic_read(&transaction->t_outstanding_credits), in start_this_handle()
441 read_unlock(&journal->j_state_lock); in start_this_handle()
442 current->journal_info = handle; in start_this_handle()
444 rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_); in start_this_handle()
450 handle->saved_alloc_context = memalloc_nofs_save(); in start_this_handle()
460 handle->h_total_credits = nblocks; in new_handle()
461 handle->h_ref = 1; in new_handle()
474 return ERR_PTR(-EROFS); in jbd2__journal_start()
477 J_ASSERT(handle->h_transaction->t_journal == journal); in jbd2__journal_start()
478 handle->h_ref++; in jbd2__journal_start()
483 journal->j_revoke_records_per_block); in jbd2__journal_start()
486 return ERR_PTR(-ENOMEM); in jbd2__journal_start()
493 return ERR_PTR(-ENOMEM); in jbd2__journal_start()
495 rsv_handle->h_reserved = 1; in jbd2__journal_start()
496 rsv_handle->h_journal = journal; in jbd2__journal_start()
497 handle->h_rsv_handle = rsv_handle; in jbd2__journal_start()
499 handle->h_revoke_credits = revoke_records; in jbd2__journal_start()
503 if (handle->h_rsv_handle) in jbd2__journal_start()
504 jbd2_free_handle(handle->h_rsv_handle); in jbd2__journal_start()
508 handle->h_type = type; in jbd2__journal_start()
509 handle->h_line_no = line_no; in jbd2__journal_start()
510 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, in jbd2__journal_start()
511 handle->h_transaction->t_tid, type, in jbd2__journal_start()
520 * jbd2_journal_start() - Obtain a new handle.
546 journal_t *journal = handle->h_journal; in __jbd2_journal_unreserve_handle()
548 WARN_ON(!handle->h_reserved); in __jbd2_journal_unreserve_handle()
549 sub_reserved_credits(journal, handle->h_total_credits); in __jbd2_journal_unreserve_handle()
551 atomic_sub(handle->h_total_credits, &t->t_outstanding_credits); in __jbd2_journal_unreserve_handle()
556 journal_t *journal = handle->h_journal; in jbd2_journal_free_reserved()
559 read_lock(&journal->j_state_lock); in jbd2_journal_free_reserved()
560 __jbd2_journal_unreserve_handle(handle, journal->j_running_transaction); in jbd2_journal_free_reserved()
561 read_unlock(&journal->j_state_lock); in jbd2_journal_free_reserved()
567 * jbd2_journal_start_reserved() - start reserved handle
578 * Return 0 on success, non-zero on error - handle is freed in that case.
583 journal_t *journal = handle->h_journal; in jbd2_journal_start_reserved()
584 int ret = -EIO; in jbd2_journal_start_reserved()
586 if (WARN_ON(!handle->h_reserved)) { in jbd2_journal_start_reserved()
595 if (WARN_ON(current->journal_info)) { in jbd2_journal_start_reserved()
600 handle->h_journal = NULL; in jbd2_journal_start_reserved()
607 handle->h_journal = journal; in jbd2_journal_start_reserved()
611 handle->h_type = type; in jbd2_journal_start_reserved()
612 handle->h_line_no = line_no; in jbd2_journal_start_reserved()
613 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, in jbd2_journal_start_reserved()
614 handle->h_transaction->t_tid, type, in jbd2_journal_start_reserved()
615 line_no, handle->h_total_credits); in jbd2_journal_start_reserved()
621 * jbd2_journal_extend() - extend buffer credits.
632 * It does not guarantee that allocation - this is a best-effort only.
636 * Return 0 on success, non-zero on failure.
639 * return code > 0 implies normal transaction-full status.
643 transaction_t *transaction = handle->h_transaction; in jbd2_journal_extend()
649 return -EROFS; in jbd2_journal_extend()
650 journal = transaction->t_journal; in jbd2_journal_extend()
654 read_lock(&journal->j_state_lock); in jbd2_journal_extend()
656 /* Don't extend a locked-down transaction! */ in jbd2_journal_extend()
657 if (transaction->t_state != T_RUNNING) { in jbd2_journal_extend()
664 handle->h_revoke_credits_requested + revoke_records, in jbd2_journal_extend()
665 journal->j_revoke_records_per_block) - in jbd2_journal_extend()
667 handle->h_revoke_credits_requested, in jbd2_journal_extend()
668 journal->j_revoke_records_per_block); in jbd2_journal_extend()
670 &transaction->t_outstanding_credits); in jbd2_journal_extend()
672 if (wanted > journal->j_max_transaction_buffers) { in jbd2_journal_extend()
675 atomic_sub(nblocks, &transaction->t_outstanding_credits); in jbd2_journal_extend()
679 trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev, in jbd2_journal_extend()
680 transaction->t_tid, in jbd2_journal_extend()
681 handle->h_type, handle->h_line_no, in jbd2_journal_extend()
682 handle->h_total_credits, in jbd2_journal_extend()
685 handle->h_total_credits += nblocks; in jbd2_journal_extend()
686 handle->h_requested_credits += nblocks; in jbd2_journal_extend()
687 handle->h_revoke_credits += revoke_records; in jbd2_journal_extend()
688 handle->h_revoke_credits_requested += revoke_records; in jbd2_journal_extend()
693 read_unlock(&journal->j_state_lock); in jbd2_journal_extend()
699 transaction_t *transaction = handle->h_transaction; in stop_this_handle()
700 journal_t *journal = transaction->t_journal; in stop_this_handle()
704 J_ASSERT(atomic_read(&transaction->t_updates) > 0); in stop_this_handle()
705 current->journal_info = NULL; in stop_this_handle()
712 revokes = handle->h_revoke_credits_requested - handle->h_revoke_credits; in stop_this_handle()
715 int rr_per_blk = journal->j_revoke_records_per_block; in stop_this_handle()
718 > handle->h_total_credits); in stop_this_handle()
720 &transaction->t_outstanding_revokes); in stop_this_handle()
722 DIV_ROUND_UP(t_revokes, rr_per_blk) - in stop_this_handle()
723 DIV_ROUND_UP(t_revokes - revokes, rr_per_blk); in stop_this_handle()
724 handle->h_total_credits -= revoke_descriptors; in stop_this_handle()
726 atomic_sub(handle->h_total_credits, in stop_this_handle()
727 &transaction->t_outstanding_credits); in stop_this_handle()
728 if (handle->h_rsv_handle) in stop_this_handle()
729 __jbd2_journal_unreserve_handle(handle->h_rsv_handle, in stop_this_handle()
731 if (atomic_dec_and_test(&transaction->t_updates)) in stop_this_handle()
732 wake_up(&journal->j_wait_updates); in stop_this_handle()
734 rwsem_release(&journal->j_trans_commit_map, _THIS_IP_); in stop_this_handle()
739 memalloc_nofs_restore(handle->saved_alloc_context); in stop_this_handle()
743 * jbd2__journal_restart() - restart a handle .
749 * Restart a handle for a multi-transaction filesystem
762 transaction_t *transaction = handle->h_transaction; in jbd2__journal_restart()
772 journal = transaction->t_journal; in jbd2__journal_restart()
773 tid = transaction->t_tid; in jbd2__journal_restart()
781 handle->h_transaction = NULL; in jbd2__journal_restart()
787 read_lock(&journal->j_state_lock); in jbd2__journal_restart()
788 need_to_start = !tid_geq(journal->j_commit_request, tid); in jbd2__journal_restart()
789 read_unlock(&journal->j_state_lock); in jbd2__journal_restart()
792 handle->h_total_credits = nblocks + in jbd2__journal_restart()
794 journal->j_revoke_records_per_block); in jbd2__journal_restart()
795 handle->h_revoke_credits = revoke_records; in jbd2__journal_restart()
797 trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev, in jbd2__journal_restart()
798 ret ? 0 : handle->h_transaction->t_tid, in jbd2__journal_restart()
799 handle->h_type, handle->h_line_no, in jbd2__journal_restart()
800 handle->h_total_credits); in jbd2__journal_restart()
818 DEFINE_WAIT(wait); in jbd2_journal_wait_updates()
822 * Note that the running transaction can get freed under us if in jbd2_journal_wait_updates()
824 * jbd2_journal_commit_transaction() -> in jbd2_journal_wait_updates()
826 * release j_state_lock -> schedule() -> acquire j_state_lock. in jbd2_journal_wait_updates()
829 * lead to use-after-free of old freed transaction. in jbd2_journal_wait_updates()
831 transaction_t *transaction = journal->j_running_transaction; in jbd2_journal_wait_updates()
836 prepare_to_wait(&journal->j_wait_updates, &wait, in jbd2_journal_wait_updates()
838 if (!atomic_read(&transaction->t_updates)) { in jbd2_journal_wait_updates()
839 finish_wait(&journal->j_wait_updates, &wait); in jbd2_journal_wait_updates()
842 write_unlock(&journal->j_state_lock); in jbd2_journal_wait_updates()
844 finish_wait(&journal->j_wait_updates, &wait); in jbd2_journal_wait_updates()
845 write_lock(&journal->j_state_lock); in jbd2_journal_wait_updates()
850 * jbd2_journal_lock_updates () - establish a transaction barrier.
863 write_lock(&journal->j_state_lock); in jbd2_journal_lock_updates()
864 ++journal->j_barrier_count; in jbd2_journal_lock_updates()
866 /* Wait until there are no reserved handles */ in jbd2_journal_lock_updates()
867 if (atomic_read(&journal->j_reserved_credits)) { in jbd2_journal_lock_updates()
868 write_unlock(&journal->j_state_lock); in jbd2_journal_lock_updates()
869 wait_event(journal->j_wait_reserved, in jbd2_journal_lock_updates()
870 atomic_read(&journal->j_reserved_credits) == 0); in jbd2_journal_lock_updates()
871 write_lock(&journal->j_state_lock); in jbd2_journal_lock_updates()
874 /* Wait until there are no running t_updates */ in jbd2_journal_lock_updates()
877 write_unlock(&journal->j_state_lock); in jbd2_journal_lock_updates()
882 * to make sure that we serialise special journal-locked operations in jbd2_journal_lock_updates()
885 mutex_lock(&journal->j_barrier); in jbd2_journal_lock_updates()
889 * jbd2_journal_unlock_updates () - release barrier
898 J_ASSERT(journal->j_barrier_count != 0); in jbd2_journal_unlock_updates()
900 mutex_unlock(&journal->j_barrier); in jbd2_journal_unlock_updates()
901 write_lock(&journal->j_state_lock); in jbd2_journal_unlock_updates()
902 --journal->j_barrier_count; in jbd2_journal_unlock_updates()
903 write_unlock(&journal->j_state_lock); in jbd2_journal_unlock_updates()
904 wake_up_all(&journal->j_wait_transaction_locked); in jbd2_journal_unlock_updates()
913 bh->b_bdev, (unsigned long long)bh->b_blocknr); in warn_dirty_buffer()
916 /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
923 source = kmap_local_folio(bh->b_folio, bh_offset(bh)); in jbd2_freeze_jh_data()
925 jbd2_buffer_frozen_trigger(jh, source, jh->b_triggers); in jbd2_freeze_jh_data()
926 memcpy(jh->b_frozen_data, source, bh->b_size); in jbd2_freeze_jh_data()
933 jh->b_frozen_triggers = jh->b_triggers; in jbd2_freeze_jh_data()
940 * make sure that we do not overwrite the old copy: we do copy-out to
951 transaction_t *transaction = handle->h_transaction; in do_get_write_access()
957 journal = transaction->t_journal; in do_get_write_access()
969 spin_lock(&jh->b_state_lock); in do_get_write_access()
974 trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev, in do_get_write_access()
981 * non-journaled, and undergoing a quite legitimate writeback. in do_get_write_access()
986 * dump(8) (which may leave the buffer scheduled for read --- in do_get_write_access()
990 if (buffer_dirty(bh) && jh->b_transaction) { in do_get_write_access()
994 * buffer lock to be sure we don't race with running write-out. in do_get_write_access()
1008 error = -EROFS; in do_get_write_access()
1010 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1020 if (jh->b_transaction == transaction || in do_get_write_access()
1021 jh->b_next_transaction == transaction) { in do_get_write_access()
1030 jh->b_modified = 0; in do_get_write_access()
1037 if (!jh->b_transaction) { in do_get_write_access()
1039 J_ASSERT_JH(jh, !jh->b_next_transaction); in do_get_write_access()
1047 spin_lock(&journal->j_list_lock); in do_get_write_access()
1050 * Execute buffer dirty clearing and jh->b_transaction in do_get_write_access()
1051 * assignment under journal->j_list_lock locked to in do_get_write_access()
1054 * and jh->b_transaction is NULL). in do_get_write_access()
1060 spin_unlock(&journal->j_list_lock); 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()
1070 if (jh->b_frozen_data) { in do_get_write_access()
1072 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in do_get_write_access()
1077 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in do_get_write_access()
1078 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction); in do_get_write_access()
1083 * and has NOT made a copy-out, then we cannot modify the buffer in do_get_write_access()
1084 * contents at all right now. The essence of copy-out is that it is in do_get_write_access()
1086 * primary copy is already going to disk then we cannot do copy-out in do_get_write_access()
1091 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1092 wait_on_bit_io(&bh->b_state, BH_Shadow, TASK_UNINTERRUPTIBLE); in do_get_write_access()
1097 * Only do the copy if the currently-owning transaction still needs it. in do_get_write_access()
1108 if (jh->b_jlist == BJ_Metadata || force_copy) { in do_get_write_access()
1112 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1113 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size, in do_get_write_access()
1117 jh->b_frozen_data = frozen_buffer; in do_get_write_access()
1128 jh->b_next_transaction = transaction; in do_get_write_access()
1131 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1141 jbd2_free(frozen_buffer, bh->b_size); in do_get_write_access()
1159 * RCU protects us from dereferencing freed pages. So the checks we do in jbd2_write_access_granted()
1173 jh = READ_ONCE(bh->b_private); in jbd2_write_access_granted()
1177 if (undo && !jh->b_committed_data) in jbd2_write_access_granted()
1179 if (READ_ONCE(jh->b_transaction) != handle->h_transaction && in jbd2_write_access_granted()
1180 READ_ONCE(jh->b_next_transaction) != handle->h_transaction) in jbd2_write_access_granted()
1185 * detect when jh went through free, realloc, attach to transaction in jbd2_write_access_granted()
1192 if (unlikely(jh->b_bh != bh)) in jbd2_write_access_granted()
1201 * jbd2_journal_get_write_access() - notify intent to modify a buffer
1219 return -EROFS; in jbd2_journal_get_write_access()
1221 journal = handle->h_transaction->t_journal; in jbd2_journal_get_write_access()
1227 * it out again, which may lead to on-disk filesystem in jbd2_journal_get_write_access()
1230 jbd2_journal_abort(journal, -EIO); in jbd2_journal_get_write_access()
1231 return -EIO; in jbd2_journal_get_write_access()
1260 * jbd2_journal_get_create_access () - notify intent to use newly created bh
1268 transaction_t *transaction = handle->h_transaction; in jbd2_journal_get_create_access()
1274 err = -EROFS; in jbd2_journal_get_create_access()
1277 journal = transaction->t_journal; in jbd2_journal_get_create_access()
1282 * The buffer may already belong to this transaction due to pre-zeroing in jbd2_journal_get_create_access()
1288 spin_lock(&jh->b_state_lock); in jbd2_journal_get_create_access()
1289 J_ASSERT_JH(jh, (jh->b_transaction == transaction || in jbd2_journal_get_create_access()
1290 jh->b_transaction == NULL || in jbd2_journal_get_create_access()
1291 (jh->b_transaction == journal->j_committing_transaction && in jbd2_journal_get_create_access()
1292 jh->b_jlist == BJ_Forget))); in jbd2_journal_get_create_access()
1294 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in jbd2_journal_get_create_access()
1297 if (jh->b_transaction == NULL) { in jbd2_journal_get_create_access()
1308 jh->b_modified = 0; in jbd2_journal_get_create_access()
1311 spin_lock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1313 spin_unlock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1314 } else if (jh->b_transaction == journal->j_committing_transaction) { in jbd2_journal_get_create_access()
1316 jh->b_modified = 0; in jbd2_journal_get_create_access()
1319 spin_lock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1320 jh->b_next_transaction = transaction; in jbd2_journal_get_create_access()
1321 spin_unlock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1323 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_create_access()
1329 * and the reallocating as data - this would cause a second revoke, in jbd2_journal_get_create_access()
1340 * jbd2_journal_get_undo_access() - Notify intent to modify metadata with
1341 * non-rewindable consequences
1350 * un-rewindable in case of a crash.
1353 * buffer for parts of non-rewindable operations such as delete
1372 return -EROFS; in jbd2_journal_get_undo_access()
1381 * Do this first --- it can drop the journal lock, so we want to in jbd2_journal_get_undo_access()
1390 if (!jh->b_committed_data) in jbd2_journal_get_undo_access()
1391 committed_data = jbd2_alloc(jh2bh(jh)->b_size, in jbd2_journal_get_undo_access()
1394 spin_lock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1395 if (!jh->b_committed_data) { in jbd2_journal_get_undo_access()
1400 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1404 jh->b_committed_data = committed_data; in jbd2_journal_get_undo_access()
1406 memcpy(jh->b_committed_data, bh->b_data, bh->b_size); in jbd2_journal_get_undo_access()
1408 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1412 jbd2_free(committed_data, bh->b_size); in jbd2_journal_get_undo_access()
1417 * jbd2_journal_set_triggers() - Add triggers for commit writeout
1434 jh->b_triggers = type; in jbd2_journal_set_triggers()
1443 if (!triggers || !triggers->t_frozen) in jbd2_buffer_frozen_trigger()
1446 triggers->t_frozen(triggers, bh, mapped_data, bh->b_size); in jbd2_buffer_frozen_trigger()
1452 if (!triggers || !triggers->t_abort) in jbd2_buffer_abort_trigger()
1455 triggers->t_abort(triggers, jh2bh(jh)); in jbd2_buffer_abort_trigger()
1459 * jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata
1483 transaction_t *transaction = handle->h_transaction; in jbd2_journal_dirty_metadata()
1489 return -EUCLEAN; in jbd2_journal_dirty_metadata()
1505 if (data_race(jh->b_transaction != transaction && in jbd2_journal_dirty_metadata()
1506 jh->b_next_transaction != transaction)) { in jbd2_journal_dirty_metadata()
1507 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1508 J_ASSERT_JH(jh, jh->b_transaction == transaction || in jbd2_journal_dirty_metadata()
1509 jh->b_next_transaction == transaction); in jbd2_journal_dirty_metadata()
1510 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1512 if (data_race(jh->b_modified == 1)) { in jbd2_journal_dirty_metadata()
1514 if (data_race(jh->b_transaction == transaction && in jbd2_journal_dirty_metadata()
1515 jh->b_jlist != BJ_Metadata)) { in jbd2_journal_dirty_metadata()
1516 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1517 if (jh->b_transaction == transaction && in jbd2_journal_dirty_metadata()
1518 jh->b_jlist != BJ_Metadata) in jbd2_journal_dirty_metadata()
1521 handle->h_type, handle->h_line_no, in jbd2_journal_dirty_metadata()
1522 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1523 jh->b_jlist); in jbd2_journal_dirty_metadata()
1524 J_ASSERT_JH(jh, jh->b_transaction != transaction || in jbd2_journal_dirty_metadata()
1525 jh->b_jlist == BJ_Metadata); in jbd2_journal_dirty_metadata()
1526 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1531 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1535 * Check journal aborting with @jh->b_state_lock locked, in jbd2_journal_dirty_metadata()
1536 * since 'jh->b_transaction' could be replaced with in jbd2_journal_dirty_metadata()
1537 * 'jh->b_next_transaction' during old transaction in jbd2_journal_dirty_metadata()
1539 * assertion on 'jh->b_frozen_data == NULL'. in jbd2_journal_dirty_metadata()
1541 ret = -EROFS; in jbd2_journal_dirty_metadata()
1545 journal = transaction->t_journal; in jbd2_journal_dirty_metadata()
1547 if (jh->b_modified == 0) { in jbd2_journal_dirty_metadata()
1551 * once a transaction -bzzz in jbd2_journal_dirty_metadata()
1554 ret = -ENOSPC; in jbd2_journal_dirty_metadata()
1557 jh->b_modified = 1; in jbd2_journal_dirty_metadata()
1558 handle->h_total_credits--; in jbd2_journal_dirty_metadata()
1565 * I _think_ we're OK here with SMP barriers - a mistaken decision will in jbd2_journal_dirty_metadata()
1568 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) { in jbd2_journal_dirty_metadata()
1570 if (unlikely(jh->b_transaction != in jbd2_journal_dirty_metadata()
1571 journal->j_running_transaction)) { in jbd2_journal_dirty_metadata()
1573 "jh->b_transaction (%llu, %p, %u) != " in jbd2_journal_dirty_metadata()
1574 "journal->j_running_transaction (%p, %u)\n", in jbd2_journal_dirty_metadata()
1575 journal->j_devname, in jbd2_journal_dirty_metadata()
1576 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1577 jh->b_transaction, in jbd2_journal_dirty_metadata()
1578 jh->b_transaction ? jh->b_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1579 journal->j_running_transaction, in jbd2_journal_dirty_metadata()
1580 journal->j_running_transaction ? in jbd2_journal_dirty_metadata()
1581 journal->j_running_transaction->t_tid : 0); in jbd2_journal_dirty_metadata()
1582 ret = -EINVAL; in jbd2_journal_dirty_metadata()
1595 if (jh->b_transaction != transaction) { in jbd2_journal_dirty_metadata()
1597 if (unlikely(((jh->b_transaction != in jbd2_journal_dirty_metadata()
1598 journal->j_committing_transaction)) || in jbd2_journal_dirty_metadata()
1599 (jh->b_next_transaction != transaction))) { in jbd2_journal_dirty_metadata()
1603 "jh->b_transaction (%p, %u), " in jbd2_journal_dirty_metadata()
1604 "jh->b_next_transaction (%p, %u), jlist %u\n", in jbd2_journal_dirty_metadata()
1605 journal->j_devname, in jbd2_journal_dirty_metadata()
1606 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1607 transaction, transaction->t_tid, in jbd2_journal_dirty_metadata()
1608 jh->b_transaction, in jbd2_journal_dirty_metadata()
1609 jh->b_transaction ? in jbd2_journal_dirty_metadata()
1610 jh->b_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1611 jh->b_next_transaction, in jbd2_journal_dirty_metadata()
1612 jh->b_next_transaction ? in jbd2_journal_dirty_metadata()
1613 jh->b_next_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1614 jh->b_jlist); in jbd2_journal_dirty_metadata()
1616 ret = -EINVAL; in jbd2_journal_dirty_metadata()
1624 J_ASSERT_JH(jh, jh->b_frozen_data == NULL); in jbd2_journal_dirty_metadata()
1627 spin_lock(&journal->j_list_lock); in jbd2_journal_dirty_metadata()
1629 spin_unlock(&journal->j_list_lock); in jbd2_journal_dirty_metadata()
1631 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1638 * jbd2_journal_forget() - bforget() for potentially-journaled buffers.
1646 * bh may not be a journalled buffer at all - it may be a non-JBD
1649 * Decrements bh->b_count by one.
1651 * Allow this call even if the handle has aborted --- it may be part of
1656 transaction_t *transaction = handle->h_transaction; in jbd2_journal_forget()
1665 return -EROFS; in jbd2_journal_forget()
1666 journal = transaction->t_journal; in jbd2_journal_forget()
1676 spin_lock(&jh->b_state_lock); in jbd2_journal_forget()
1680 if (!J_EXPECT_JH(jh, !jh->b_committed_data, in jbd2_journal_forget()
1682 err = -EIO; in jbd2_journal_forget()
1686 /* keep track of whether or not this transaction modified us */ in jbd2_journal_forget()
1687 was_modified = jh->b_modified; in jbd2_journal_forget()
1691 * all references -bzzz in jbd2_journal_forget()
1693 jh->b_modified = 0; in jbd2_journal_forget()
1695 if (jh->b_transaction == transaction) { in jbd2_journal_forget()
1696 J_ASSERT_JH(jh, !jh->b_frozen_data); in jbd2_journal_forget()
1725 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1726 if (jh->b_cp_transaction) { in jbd2_journal_forget()
1733 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1734 } else if (jh->b_transaction) { in jbd2_journal_forget()
1735 J_ASSERT_JH(jh, (jh->b_transaction == in jbd2_journal_forget()
1736 journal->j_committing_transaction)); in jbd2_journal_forget()
1749 if (!jh->b_next_transaction) { in jbd2_journal_forget()
1750 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1751 jh->b_next_transaction = transaction; in jbd2_journal_forget()
1752 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1754 J_ASSERT(jh->b_next_transaction == transaction); in jbd2_journal_forget()
1769 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1770 if (!jh->b_cp_transaction) { in jbd2_journal_forget()
1772 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1781 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1795 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1799 spin_unlock(&jh->b_state_lock); in jbd2_journal_forget()
1804 /* no need to reserve log space for this block -bzzz */ in jbd2_journal_forget()
1805 handle->h_total_credits++; in jbd2_journal_forget()
1811 * jbd2_journal_stop() - complete a transaction
1823 * return -EIO if a jbd2_journal_abort has been executed since the
1828 transaction_t *transaction = handle->h_transaction; in jbd2_journal_stop()
1834 if (--handle->h_ref > 0) { in jbd2_journal_stop()
1835 jbd2_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1, in jbd2_journal_stop()
1836 handle->h_ref); in jbd2_journal_stop()
1838 return -EIO; in jbd2_journal_stop()
1844 * nothing to do other than free the handle. in jbd2_journal_stop()
1846 memalloc_nofs_restore(handle->saved_alloc_context); in jbd2_journal_stop()
1849 journal = transaction->t_journal; in jbd2_journal_stop()
1850 tid = transaction->t_tid; in jbd2_journal_stop()
1853 err = -EIO; in jbd2_journal_stop()
1856 trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev, in jbd2_journal_stop()
1857 tid, handle->h_type, handle->h_line_no, in jbd2_journal_stop()
1858 jiffies - handle->h_start_jiffies, in jbd2_journal_stop()
1859 handle->h_sync, handle->h_requested_credits, in jbd2_journal_stop()
1860 (handle->h_requested_credits - in jbd2_journal_stop()
1861 handle->h_total_credits)); in jbd2_journal_stop()
1868 * arrive. It doesn't cost much - we're about to run a commit in jbd2_journal_stop()
1869 * and sleep on IO anyway. Speeds up many-threaded, many-dir in jbd2_journal_stop()
1876 * and wait for the transaction to be committed than it is to in jbd2_journal_stop()
1877 * wait for an arbitrary amount of time for new writers to in jbd2_journal_stop()
1892 pid = current->pid; in jbd2_journal_stop()
1893 if (handle->h_sync && journal->j_last_sync_writer != pid && in jbd2_journal_stop()
1894 journal->j_max_batch_time) { in jbd2_journal_stop()
1897 journal->j_last_sync_writer = pid; in jbd2_journal_stop()
1899 read_lock(&journal->j_state_lock); in jbd2_journal_stop()
1900 commit_time = journal->j_average_commit_time; in jbd2_journal_stop()
1901 read_unlock(&journal->j_state_lock); in jbd2_journal_stop()
1904 transaction->t_start_time)); in jbd2_journal_stop()
1907 1000*journal->j_min_batch_time); in jbd2_journal_stop()
1909 1000*journal->j_max_batch_time); in jbd2_journal_stop()
1919 if (handle->h_sync) in jbd2_journal_stop()
1920 transaction->t_synchronous_commit = 1; in jbd2_journal_stop()
1927 if (handle->h_sync || in jbd2_journal_stop()
1928 time_after_eq(jiffies, transaction->t_expires)) { in jbd2_journal_stop()
1935 /* This is non-blocking */ in jbd2_journal_stop()
1939 * Special case: JBD2_SYNC synchronous updates require us in jbd2_journal_stop()
1940 * to wait for the commit to complete. in jbd2_journal_stop()
1942 if (handle->h_sync && !(current->flags & PF_MEMALLOC)) in jbd2_journal_stop()
1948 * committing on us and eventually disappear. So we must not in jbd2_journal_stop()
1958 if (handle->h_rsv_handle) in jbd2_journal_stop()
1959 jbd2_free_handle(handle->h_rsv_handle); in jbd2_journal_stop()
1977 * jh->b_state_lock is held.
1984 jh->b_tnext = jh->b_tprev = jh; in __blist_add_buffer()
1988 struct journal_head *first = *list, *last = first->b_tprev; in __blist_add_buffer()
1989 jh->b_tprev = last; in __blist_add_buffer()
1990 jh->b_tnext = first; in __blist_add_buffer()
1991 last->b_tnext = first->b_tprev = jh; in __blist_add_buffer()
2001 * jh->b_state_lock is held.
2008 *list = jh->b_tnext; in __blist_del_buffer()
2012 jh->b_tprev->b_tnext = jh->b_tnext; in __blist_del_buffer()
2013 jh->b_tnext->b_tprev = jh->b_tprev; in __blist_del_buffer()
2020 * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or
2022 * pointers, it could go bad. Generally the caller needs to re-read the
2033 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_temp_unlink_buffer()
2034 transaction = jh->b_transaction; in __jbd2_journal_temp_unlink_buffer()
2036 assert_spin_locked(&transaction->t_journal->j_list_lock); in __jbd2_journal_temp_unlink_buffer()
2038 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); in __jbd2_journal_temp_unlink_buffer()
2039 if (jh->b_jlist != BJ_None) in __jbd2_journal_temp_unlink_buffer()
2042 switch (jh->b_jlist) { in __jbd2_journal_temp_unlink_buffer()
2046 transaction->t_nr_buffers--; in __jbd2_journal_temp_unlink_buffer()
2047 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0); in __jbd2_journal_temp_unlink_buffer()
2048 list = &transaction->t_buffers; in __jbd2_journal_temp_unlink_buffer()
2051 list = &transaction->t_forget; in __jbd2_journal_temp_unlink_buffer()
2054 list = &transaction->t_shadow_list; in __jbd2_journal_temp_unlink_buffer()
2057 list = &transaction->t_reserved_list; in __jbd2_journal_temp_unlink_buffer()
2062 jh->b_jlist = BJ_None; in __jbd2_journal_temp_unlink_buffer()
2063 if (transaction && is_journal_aborted(transaction->t_journal)) in __jbd2_journal_temp_unlink_buffer()
2077 J_ASSERT_JH(jh, jh->b_transaction != NULL); in __jbd2_journal_unfile_buffer()
2078 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in __jbd2_journal_unfile_buffer()
2081 jh->b_transaction = NULL; in __jbd2_journal_unfile_buffer()
2085 * jbd2_journal_try_to_free_buffers() - try to free page buffers.
2093 * This function returns non-zero if we wish try_to_free_buffers()
2096 * us to perform sync or async writeout.
2100 * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
2102 * This may *change* the value of transaction_t->t_datalist, so anyone
2111 * is do_get_write_access() - it could be looking at the buffer while
2140 spin_lock(&jh->b_state_lock); in jbd2_journal_try_to_free_buffers()
2141 if (!jh->b_transaction && !jh->b_next_transaction) { in jbd2_journal_try_to_free_buffers()
2142 spin_lock(&journal->j_list_lock); in jbd2_journal_try_to_free_buffers()
2143 /* Remove written-back checkpointed metadata buffer */ in jbd2_journal_try_to_free_buffers()
2144 if (jh->b_cp_transaction != NULL) in jbd2_journal_try_to_free_buffers()
2146 spin_unlock(&journal->j_list_lock); in jbd2_journal_try_to_free_buffers()
2148 spin_unlock(&jh->b_state_lock); in jbd2_journal_try_to_free_buffers()
2152 } while ((bh = bh->b_this_page) != head); in jbd2_journal_try_to_free_buffers()
2165 * Returns non-zero if JBD no longer has an interest in the buffer.
2169 * Called under jh->b_state_lock.
2176 if (jh->b_cp_transaction) { in __dispose_buffer()
2220 * as in-use in the committed_data bitmap, so cannot be reused until
2228 * don't make guarantees about the order in which data hits disk --- in
2230 * transaction commit --- so it is always safe just to discard data
2231 * immediately in that mode. --sct
2239 * We're outside-transaction here. Either or both of j_running_transaction
2254 * holding the page lock. --sct in journal_unmap_buffer()
2262 write_lock(&journal->j_state_lock); in journal_unmap_buffer()
2263 spin_lock(&jh->b_state_lock); in journal_unmap_buffer()
2264 spin_lock(&journal->j_list_lock); in journal_unmap_buffer()
2278 * already been added to orphan list, it is safe for us to add in journal_unmap_buffer()
2289 transaction = jh->b_transaction; in journal_unmap_buffer()
2293 * it's a writeback-mode buffer so we don't care in journal_unmap_buffer()
2295 if (!jh->b_cp_transaction) { in journal_unmap_buffer()
2310 if (journal->j_running_transaction) { in journal_unmap_buffer()
2316 journal->j_running_transaction); in journal_unmap_buffer()
2319 /* There is no currently-running transaction. So the in journal_unmap_buffer()
2323 if (journal->j_committing_transaction) { in journal_unmap_buffer()
2326 journal->j_committing_transaction); in journal_unmap_buffer()
2336 } else if (transaction == journal->j_committing_transaction) { in journal_unmap_buffer()
2340 * it. If the page is straddling i_size we have to wait in journal_unmap_buffer()
2344 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2345 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2346 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2349 if (!bh->b_bdev) in journal_unmap_buffer()
2351 return -EBUSY; in journal_unmap_buffer()
2361 if (journal->j_running_transaction && buffer_jbddirty(bh)) in journal_unmap_buffer()
2362 jh->b_next_transaction = journal->j_running_transaction; in journal_unmap_buffer()
2363 jh->b_modified = 0; in journal_unmap_buffer()
2364 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2365 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2366 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2376 J_ASSERT_JH(jh, transaction == journal->j_running_transaction); in journal_unmap_buffer()
2390 jh->b_modified = 0; in journal_unmap_buffer()
2391 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2392 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2393 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2403 bh->b_bdev = NULL; in journal_unmap_buffer()
2415 * Can return -EBUSY if buffers are part of the committing transaction and
2416 * the page is straddling i_size. Caller then has to wait for current commit
2443 unsigned int next_off = curr_off + bh->b_size; in jbd2_journal_invalidate_folio()
2444 next = bh->b_this_page; in jbd2_journal_invalidate_folio()
2480 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_file_buffer()
2481 assert_spin_locked(&transaction->t_journal->j_list_lock); in __jbd2_journal_file_buffer()
2483 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); in __jbd2_journal_file_buffer()
2484 J_ASSERT_JH(jh, jh->b_transaction == transaction || in __jbd2_journal_file_buffer()
2485 jh->b_transaction == NULL); in __jbd2_journal_file_buffer()
2487 if (jh->b_transaction && jh->b_jlist == jlist) in __jbd2_journal_file_buffer()
2506 if (jh->b_transaction) in __jbd2_journal_file_buffer()
2510 jh->b_transaction = transaction; in __jbd2_journal_file_buffer()
2514 J_ASSERT_JH(jh, !jh->b_committed_data); in __jbd2_journal_file_buffer()
2515 J_ASSERT_JH(jh, !jh->b_frozen_data); in __jbd2_journal_file_buffer()
2518 transaction->t_nr_buffers++; in __jbd2_journal_file_buffer()
2519 list = &transaction->t_buffers; in __jbd2_journal_file_buffer()
2522 list = &transaction->t_forget; in __jbd2_journal_file_buffer()
2525 list = &transaction->t_shadow_list; in __jbd2_journal_file_buffer()
2528 list = &transaction->t_reserved_list; in __jbd2_journal_file_buffer()
2533 jh->b_jlist = jlist; in __jbd2_journal_file_buffer()
2542 spin_lock(&jh->b_state_lock); in jbd2_journal_file_buffer()
2543 spin_lock(&transaction->t_journal->j_list_lock); in jbd2_journal_file_buffer()
2545 spin_unlock(&transaction->t_journal->j_list_lock); in jbd2_journal_file_buffer()
2546 spin_unlock(&jh->b_state_lock); in jbd2_journal_file_buffer()
2556 * Called under jh->b_state_lock
2567 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_refile_buffer()
2568 if (jh->b_transaction) in __jbd2_journal_refile_buffer()
2569 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock); in __jbd2_journal_refile_buffer()
2572 if (jh->b_next_transaction == NULL) { in __jbd2_journal_refile_buffer()
2589 J_ASSERT_JH(jh, jh->b_transaction != NULL); in __jbd2_journal_refile_buffer()
2596 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction); in __jbd2_journal_refile_buffer()
2597 WRITE_ONCE(jh->b_next_transaction, NULL); in __jbd2_journal_refile_buffer()
2600 else if (jh->b_modified) in __jbd2_journal_refile_buffer()
2604 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist); in __jbd2_journal_refile_buffer()
2605 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING); in __jbd2_journal_refile_buffer()
2622 spin_lock(&jh->b_state_lock); in jbd2_journal_refile_buffer()
2623 spin_lock(&journal->j_list_lock); in jbd2_journal_refile_buffer()
2625 spin_unlock(&jh->b_state_lock); in jbd2_journal_refile_buffer()
2626 spin_unlock(&journal->j_list_lock); in jbd2_journal_refile_buffer()
2637 transaction_t *transaction = handle->h_transaction; in jbd2_journal_file_inode()
2641 return -EROFS; in jbd2_journal_file_inode()
2642 journal = transaction->t_journal; in jbd2_journal_file_inode()
2644 jbd2_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino, in jbd2_journal_file_inode()
2645 transaction->t_tid); in jbd2_journal_file_inode()
2647 spin_lock(&journal->j_list_lock); in jbd2_journal_file_inode()
2648 jinode->i_flags |= flags; in jbd2_journal_file_inode()
2650 if (jinode->i_dirty_end) { in jbd2_journal_file_inode()
2651 jinode->i_dirty_start = min(jinode->i_dirty_start, start_byte); in jbd2_journal_file_inode()
2652 jinode->i_dirty_end = max(jinode->i_dirty_end, end_byte); in jbd2_journal_file_inode()
2654 jinode->i_dirty_start = start_byte; in jbd2_journal_file_inode()
2655 jinode->i_dirty_end = end_byte; in jbd2_journal_file_inode()
2659 if (jinode->i_transaction == transaction || in jbd2_journal_file_inode()
2660 jinode->i_next_transaction == transaction) in jbd2_journal_file_inode()
2668 if (!transaction->t_need_data_flush) in jbd2_journal_file_inode()
2669 transaction->t_need_data_flush = 1; in jbd2_journal_file_inode()
2670 /* On some different transaction's list - should be in jbd2_journal_file_inode()
2672 if (jinode->i_transaction) { in jbd2_journal_file_inode()
2673 J_ASSERT(jinode->i_next_transaction == NULL); in jbd2_journal_file_inode()
2674 J_ASSERT(jinode->i_transaction == in jbd2_journal_file_inode()
2675 journal->j_committing_transaction); in jbd2_journal_file_inode()
2676 jinode->i_next_transaction = transaction; in jbd2_journal_file_inode()
2680 J_ASSERT(!jinode->i_next_transaction); in jbd2_journal_file_inode()
2681 jinode->i_transaction = transaction; in jbd2_journal_file_inode()
2682 list_add(&jinode->i_list, &transaction->t_inode_list); in jbd2_journal_file_inode()
2684 spin_unlock(&journal->j_list_lock); in jbd2_journal_file_inode()
2694 start_byte + length - 1); in jbd2_journal_inode_ranged_write()
2701 start_byte, start_byte + length - 1); in jbd2_journal_inode_ranged_wait()
2706 * non-trivial way. If a transaction writing data block A is
2720 * allows us to optimize the case where the addition to orphan list
2721 * happens in the same transaction as write --- we don't have to write
2732 if (!jinode->i_transaction) in jbd2_journal_begin_ordered_truncate()
2737 read_lock(&journal->j_state_lock); in jbd2_journal_begin_ordered_truncate()
2738 commit_trans = journal->j_committing_transaction; in jbd2_journal_begin_ordered_truncate()
2739 read_unlock(&journal->j_state_lock); in jbd2_journal_begin_ordered_truncate()
2740 spin_lock(&journal->j_list_lock); in jbd2_journal_begin_ordered_truncate()
2741 inode_trans = jinode->i_transaction; in jbd2_journal_begin_ordered_truncate()
2742 spin_unlock(&journal->j_list_lock); in jbd2_journal_begin_ordered_truncate()
2744 ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping, in jbd2_journal_begin_ordered_truncate()