Lines Matching +full:ts +full:- +full:attached
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()
70 int tag_space = journal->j_blocksize - sizeof(journal_header_t); in jbd2_descriptor_blocks_per_trans()
74 tag_space -= 16; in jbd2_descriptor_blocks_per_trans()
76 tag_space -= sizeof(struct jbd2_journal_block_tail); in jbd2_descriptor_blocks_per_trans()
78 tags_per_block = (tag_space - 16) / journal_tag_bytes(journal); in jbd2_descriptor_blocks_per_trans()
83 return 1 + DIV_ROUND_UP(journal->j_max_transaction_buffers, in jbd2_descriptor_blocks_per_trans()
105 transaction->t_journal = journal; in jbd2_get_transaction()
106 transaction->t_state = T_RUNNING; in jbd2_get_transaction()
107 transaction->t_start_time = ktime_get(); in jbd2_get_transaction()
108 transaction->t_tid = journal->j_transaction_sequence++; in jbd2_get_transaction()
109 transaction->t_expires = jiffies + journal->j_commit_interval; in jbd2_get_transaction()
110 spin_lock_init(&transaction->t_handle_lock); in jbd2_get_transaction()
111 atomic_set(&transaction->t_updates, 0); in jbd2_get_transaction()
112 atomic_set(&transaction->t_outstanding_credits, in jbd2_get_transaction()
114 atomic_read(&journal->j_reserved_credits)); in jbd2_get_transaction()
115 atomic_set(&transaction->t_outstanding_revokes, 0); in jbd2_get_transaction()
116 atomic_set(&transaction->t_handle_count, 0); in jbd2_get_transaction()
117 INIT_LIST_HEAD(&transaction->t_inode_list); in jbd2_get_transaction()
118 INIT_LIST_HEAD(&transaction->t_private_list); in jbd2_get_transaction()
121 journal->j_commit_timer.expires = round_jiffies_up(transaction->t_expires); in jbd2_get_transaction()
122 add_timer(&journal->j_commit_timer); in jbd2_get_transaction()
124 J_ASSERT(journal->j_running_transaction == NULL); in jbd2_get_transaction()
125 journal->j_running_transaction = transaction; in jbd2_get_transaction()
126 transaction->t_max_wait = 0; in jbd2_get_transaction()
127 transaction->t_start = jiffies; in jbd2_get_transaction()
128 transaction->t_requested = 0; in jbd2_get_transaction()
150 unsigned long ts) in update_t_max_wait() argument
154 time_after(transaction->t_start, ts)) { in update_t_max_wait()
155 ts = jbd2_time_diff(ts, transaction->t_start); in update_t_max_wait()
156 spin_lock(&transaction->t_handle_lock); in update_t_max_wait()
157 if (ts > transaction->t_max_wait) in update_t_max_wait()
158 transaction->t_max_wait = ts; in update_t_max_wait()
159 spin_unlock(&transaction->t_handle_lock); in update_t_max_wait()
170 __releases(journal->j_state_lock) in wait_transaction_locked()
174 tid_t tid = journal->j_running_transaction->t_tid; in wait_transaction_locked()
176 prepare_to_wait(&journal->j_wait_transaction_locked, &wait, in wait_transaction_locked()
178 need_to_start = !tid_geq(journal->j_commit_request, tid); in wait_transaction_locked()
179 read_unlock(&journal->j_state_lock); in wait_transaction_locked()
184 finish_wait(&journal->j_wait_transaction_locked, &wait); in wait_transaction_locked()
193 __releases(journal->j_state_lock) in wait_transaction_switching()
197 if (WARN_ON(!journal->j_running_transaction || in wait_transaction_switching()
198 journal->j_running_transaction->t_state != T_SWITCH)) { in wait_transaction_switching()
199 read_unlock(&journal->j_state_lock); in wait_transaction_switching()
202 prepare_to_wait(&journal->j_wait_transaction_locked, &wait, in wait_transaction_switching()
204 read_unlock(&journal->j_state_lock); in wait_transaction_switching()
212 finish_wait(&journal->j_wait_transaction_locked, &wait); in wait_transaction_switching()
217 atomic_sub(blocks, &journal->j_reserved_credits); in sub_reserved_credits()
218 wake_up(&journal->j_wait_reserved); in sub_reserved_credits()
230 transaction_t *t = journal->j_running_transaction; in add_transaction_credits()
238 if (t->t_state != T_RUNNING) { in add_transaction_credits()
239 WARN_ON_ONCE(t->t_state >= T_FLUSH); in add_transaction_credits()
249 needed = atomic_add_return(total, &t->t_outstanding_credits); in add_transaction_credits()
250 if (needed > journal->j_max_transaction_buffers) { in add_transaction_credits()
256 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
262 if (atomic_read(&journal->j_reserved_credits) + total > in add_transaction_credits()
263 journal->j_max_transaction_buffers) { in add_transaction_credits()
264 read_unlock(&journal->j_state_lock); in add_transaction_credits()
266 wait_event(journal->j_wait_reserved, in add_transaction_credits()
267 atomic_read(&journal->j_reserved_credits) + total <= in add_transaction_credits()
268 journal->j_max_transaction_buffers); in add_transaction_credits()
287 if (jbd2_log_space_left(journal) < journal->j_max_transaction_buffers) { in add_transaction_credits()
288 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
289 read_unlock(&journal->j_state_lock); in add_transaction_credits()
291 write_lock(&journal->j_state_lock); in add_transaction_credits()
293 journal->j_max_transaction_buffers) in add_transaction_credits()
295 write_unlock(&journal->j_state_lock); in add_transaction_credits()
303 needed = atomic_add_return(rsv_blocks, &journal->j_reserved_credits); in add_transaction_credits()
305 if (needed > journal->j_max_transaction_buffers / 2) { in add_transaction_credits()
307 atomic_sub(total, &t->t_outstanding_credits); in add_transaction_credits()
308 read_unlock(&journal->j_state_lock); in add_transaction_credits()
310 wait_event(journal->j_wait_reserved, in add_transaction_credits()
311 atomic_read(&journal->j_reserved_credits) + rsv_blocks in add_transaction_credits()
312 <= journal->j_max_transaction_buffers / 2); in add_transaction_credits()
329 int blocks = handle->h_total_credits; in start_this_handle()
331 unsigned long ts = jiffies; in start_this_handle() local
333 if (handle->h_rsv_handle) in start_this_handle()
334 rsv_blocks = handle->h_rsv_handle->h_total_credits; in start_this_handle()
341 if ((rsv_blocks > journal->j_max_transaction_buffers / 2) || in start_this_handle()
342 (rsv_blocks + blocks > journal->j_max_transaction_buffers)) { in start_this_handle()
345 current->comm, blocks, rsv_blocks, in start_this_handle()
346 journal->j_max_transaction_buffers); in start_this_handle()
348 return -ENOSPC; in start_this_handle()
357 if (!data_race(journal->j_running_transaction)) { in start_this_handle()
367 return -ENOMEM; in start_this_handle()
377 read_lock(&journal->j_state_lock); in start_this_handle()
378 BUG_ON(journal->j_flags & JBD2_UNMOUNT); in start_this_handle()
380 (journal->j_errno != 0 && !(journal->j_flags & JBD2_ACK_ERR))) { in start_this_handle()
381 read_unlock(&journal->j_state_lock); in start_this_handle()
383 return -EROFS; in start_this_handle()
391 if (!handle->h_reserved && journal->j_barrier_count) { in start_this_handle()
392 read_unlock(&journal->j_state_lock); in start_this_handle()
393 wait_event(journal->j_wait_transaction_locked, in start_this_handle()
394 journal->j_barrier_count == 0); in start_this_handle()
398 if (!journal->j_running_transaction) { in start_this_handle()
399 read_unlock(&journal->j_state_lock); in start_this_handle()
402 write_lock(&journal->j_state_lock); in start_this_handle()
403 if (!journal->j_running_transaction && in start_this_handle()
404 (handle->h_reserved || !journal->j_barrier_count)) { in start_this_handle()
408 write_unlock(&journal->j_state_lock); in start_this_handle()
412 transaction = journal->j_running_transaction; in start_this_handle()
414 if (!handle->h_reserved) { in start_this_handle()
415 /* We may have dropped j_state_lock - restart in that case */ in start_this_handle()
426 if (transaction->t_state == T_SWITCH) { in start_this_handle()
431 handle->h_reserved = 0; in start_this_handle()
437 update_t_max_wait(transaction, ts); in start_this_handle()
438 handle->h_transaction = transaction; in start_this_handle()
439 handle->h_requested_credits = blocks; in start_this_handle()
440 handle->h_revoke_credits_requested = handle->h_revoke_credits; in start_this_handle()
441 handle->h_start_jiffies = jiffies; in start_this_handle()
442 atomic_inc(&transaction->t_updates); in start_this_handle()
443 atomic_inc(&transaction->t_handle_count); in start_this_handle()
446 atomic_read(&transaction->t_outstanding_credits), in start_this_handle()
448 read_unlock(&journal->j_state_lock); in start_this_handle()
449 current->journal_info = handle; in start_this_handle()
451 rwsem_acquire_read(&journal->j_trans_commit_map, 0, 0, _THIS_IP_); in start_this_handle()
457 handle->saved_alloc_context = memalloc_nofs_save(); in start_this_handle()
467 handle->h_total_credits = nblocks; in new_handle()
468 handle->h_ref = 1; in new_handle()
481 return ERR_PTR(-EROFS); in jbd2__journal_start()
484 J_ASSERT(handle->h_transaction->t_journal == journal); in jbd2__journal_start()
485 handle->h_ref++; in jbd2__journal_start()
490 journal->j_revoke_records_per_block); in jbd2__journal_start()
493 return ERR_PTR(-ENOMEM); in jbd2__journal_start()
500 return ERR_PTR(-ENOMEM); in jbd2__journal_start()
502 rsv_handle->h_reserved = 1; in jbd2__journal_start()
503 rsv_handle->h_journal = journal; in jbd2__journal_start()
504 handle->h_rsv_handle = rsv_handle; in jbd2__journal_start()
506 handle->h_revoke_credits = revoke_records; in jbd2__journal_start()
510 if (handle->h_rsv_handle) in jbd2__journal_start()
511 jbd2_free_handle(handle->h_rsv_handle); in jbd2__journal_start()
515 handle->h_type = type; in jbd2__journal_start()
516 handle->h_line_no = line_no; in jbd2__journal_start()
517 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, in jbd2__journal_start()
518 handle->h_transaction->t_tid, type, in jbd2__journal_start()
527 * jbd2_journal_start() - Obtain a new handle.
535 * stored in h_rsv_handle. It is not attached to any particular transaction
553 journal_t *journal = handle->h_journal; in __jbd2_journal_unreserve_handle()
555 WARN_ON(!handle->h_reserved); in __jbd2_journal_unreserve_handle()
556 sub_reserved_credits(journal, handle->h_total_credits); in __jbd2_journal_unreserve_handle()
558 atomic_sub(handle->h_total_credits, &t->t_outstanding_credits); in __jbd2_journal_unreserve_handle()
563 journal_t *journal = handle->h_journal; in jbd2_journal_free_reserved()
566 read_lock(&journal->j_state_lock); in jbd2_journal_free_reserved()
567 __jbd2_journal_unreserve_handle(handle, journal->j_running_transaction); in jbd2_journal_free_reserved()
568 read_unlock(&journal->j_state_lock); in jbd2_journal_free_reserved()
574 * jbd2_journal_start_reserved() - start reserved handle
585 * Return 0 on success, non-zero on error - handle is freed in that case.
590 journal_t *journal = handle->h_journal; in jbd2_journal_start_reserved()
591 int ret = -EIO; in jbd2_journal_start_reserved()
593 if (WARN_ON(!handle->h_reserved)) { in jbd2_journal_start_reserved()
602 if (WARN_ON(current->journal_info)) { in jbd2_journal_start_reserved()
607 handle->h_journal = NULL; in jbd2_journal_start_reserved()
614 handle->h_journal = journal; in jbd2_journal_start_reserved()
618 handle->h_type = type; in jbd2_journal_start_reserved()
619 handle->h_line_no = line_no; in jbd2_journal_start_reserved()
620 trace_jbd2_handle_start(journal->j_fs_dev->bd_dev, in jbd2_journal_start_reserved()
621 handle->h_transaction->t_tid, type, in jbd2_journal_start_reserved()
622 line_no, handle->h_total_credits); in jbd2_journal_start_reserved()
628 * jbd2_journal_extend() - extend buffer credits.
639 * It does not guarantee that allocation - this is a best-effort only.
643 * Return 0 on success, non-zero on failure.
646 * return code > 0 implies normal transaction-full status.
650 transaction_t *transaction = handle->h_transaction; in jbd2_journal_extend()
656 return -EROFS; in jbd2_journal_extend()
657 journal = transaction->t_journal; in jbd2_journal_extend()
661 read_lock(&journal->j_state_lock); in jbd2_journal_extend()
663 /* Don't extend a locked-down transaction! */ in jbd2_journal_extend()
664 if (transaction->t_state != T_RUNNING) { in jbd2_journal_extend()
671 handle->h_revoke_credits_requested + revoke_records, in jbd2_journal_extend()
672 journal->j_revoke_records_per_block) - in jbd2_journal_extend()
674 handle->h_revoke_credits_requested, in jbd2_journal_extend()
675 journal->j_revoke_records_per_block); in jbd2_journal_extend()
676 spin_lock(&transaction->t_handle_lock); in jbd2_journal_extend()
678 &transaction->t_outstanding_credits); in jbd2_journal_extend()
680 if (wanted > journal->j_max_transaction_buffers) { in jbd2_journal_extend()
683 atomic_sub(nblocks, &transaction->t_outstanding_credits); in jbd2_journal_extend()
687 trace_jbd2_handle_extend(journal->j_fs_dev->bd_dev, in jbd2_journal_extend()
688 transaction->t_tid, in jbd2_journal_extend()
689 handle->h_type, handle->h_line_no, in jbd2_journal_extend()
690 handle->h_total_credits, in jbd2_journal_extend()
693 handle->h_total_credits += nblocks; in jbd2_journal_extend()
694 handle->h_requested_credits += nblocks; in jbd2_journal_extend()
695 handle->h_revoke_credits += revoke_records; in jbd2_journal_extend()
696 handle->h_revoke_credits_requested += revoke_records; in jbd2_journal_extend()
701 spin_unlock(&transaction->t_handle_lock); in jbd2_journal_extend()
703 read_unlock(&journal->j_state_lock); in jbd2_journal_extend()
709 transaction_t *transaction = handle->h_transaction; in stop_this_handle()
710 journal_t *journal = transaction->t_journal; in stop_this_handle()
714 J_ASSERT(atomic_read(&transaction->t_updates) > 0); in stop_this_handle()
715 current->journal_info = NULL; in stop_this_handle()
722 revokes = handle->h_revoke_credits_requested - handle->h_revoke_credits; in stop_this_handle()
725 int rr_per_blk = journal->j_revoke_records_per_block; in stop_this_handle()
728 > handle->h_total_credits); in stop_this_handle()
730 &transaction->t_outstanding_revokes); in stop_this_handle()
732 DIV_ROUND_UP(t_revokes, rr_per_blk) - in stop_this_handle()
733 DIV_ROUND_UP(t_revokes - revokes, rr_per_blk); in stop_this_handle()
734 handle->h_total_credits -= revoke_descriptors; in stop_this_handle()
736 atomic_sub(handle->h_total_credits, in stop_this_handle()
737 &transaction->t_outstanding_credits); in stop_this_handle()
738 if (handle->h_rsv_handle) in stop_this_handle()
739 __jbd2_journal_unreserve_handle(handle->h_rsv_handle, in stop_this_handle()
741 if (atomic_dec_and_test(&transaction->t_updates)) in stop_this_handle()
742 wake_up(&journal->j_wait_updates); in stop_this_handle()
744 rwsem_release(&journal->j_trans_commit_map, _THIS_IP_); in stop_this_handle()
749 memalloc_nofs_restore(handle->saved_alloc_context); in stop_this_handle()
753 * jbd2__journal_restart() - restart a handle .
759 * Restart a handle for a multi-transaction filesystem
766 * credits. We preserve reserved handle if there's any attached to the
772 transaction_t *transaction = handle->h_transaction; in jbd2__journal_restart()
782 journal = transaction->t_journal; in jbd2__journal_restart()
783 tid = transaction->t_tid; in jbd2__journal_restart()
791 handle->h_transaction = NULL; in jbd2__journal_restart()
797 read_lock(&journal->j_state_lock); in jbd2__journal_restart()
798 need_to_start = !tid_geq(journal->j_commit_request, tid); in jbd2__journal_restart()
799 read_unlock(&journal->j_state_lock); in jbd2__journal_restart()
802 handle->h_total_credits = nblocks + in jbd2__journal_restart()
804 journal->j_revoke_records_per_block); in jbd2__journal_restart()
805 handle->h_revoke_credits = revoke_records; in jbd2__journal_restart()
807 trace_jbd2_handle_restart(journal->j_fs_dev->bd_dev, in jbd2__journal_restart()
808 ret ? 0 : handle->h_transaction->t_tid, in jbd2__journal_restart()
809 handle->h_type, handle->h_line_no, in jbd2__journal_restart()
810 handle->h_total_credits); in jbd2__journal_restart()
823 * jbd2_journal_lock_updates () - establish a transaction barrier.
838 write_lock(&journal->j_state_lock); in jbd2_journal_lock_updates()
839 ++journal->j_barrier_count; in jbd2_journal_lock_updates()
842 if (atomic_read(&journal->j_reserved_credits)) { in jbd2_journal_lock_updates()
843 write_unlock(&journal->j_state_lock); in jbd2_journal_lock_updates()
844 wait_event(journal->j_wait_reserved, in jbd2_journal_lock_updates()
845 atomic_read(&journal->j_reserved_credits) == 0); in jbd2_journal_lock_updates()
846 write_lock(&journal->j_state_lock); in jbd2_journal_lock_updates()
851 transaction_t *transaction = journal->j_running_transaction; in jbd2_journal_lock_updates()
856 spin_lock(&transaction->t_handle_lock); in jbd2_journal_lock_updates()
857 prepare_to_wait(&journal->j_wait_updates, &wait, in jbd2_journal_lock_updates()
859 if (!atomic_read(&transaction->t_updates)) { in jbd2_journal_lock_updates()
860 spin_unlock(&transaction->t_handle_lock); in jbd2_journal_lock_updates()
861 finish_wait(&journal->j_wait_updates, &wait); in jbd2_journal_lock_updates()
864 spin_unlock(&transaction->t_handle_lock); in jbd2_journal_lock_updates()
865 write_unlock(&journal->j_state_lock); in jbd2_journal_lock_updates()
867 finish_wait(&journal->j_wait_updates, &wait); in jbd2_journal_lock_updates()
868 write_lock(&journal->j_state_lock); in jbd2_journal_lock_updates()
870 write_unlock(&journal->j_state_lock); in jbd2_journal_lock_updates()
875 * to make sure that we serialise special journal-locked operations in jbd2_journal_lock_updates()
878 mutex_lock(&journal->j_barrier); in jbd2_journal_lock_updates()
882 * jbd2_journal_unlock_updates () - release barrier
891 J_ASSERT(journal->j_barrier_count != 0); in jbd2_journal_unlock_updates()
893 mutex_unlock(&journal->j_barrier); in jbd2_journal_unlock_updates()
894 write_lock(&journal->j_state_lock); in jbd2_journal_unlock_updates()
895 --journal->j_barrier_count; in jbd2_journal_unlock_updates()
896 write_unlock(&journal->j_state_lock); in jbd2_journal_unlock_updates()
897 wake_up(&journal->j_wait_transaction_locked); in jbd2_journal_unlock_updates()
906 bh->b_bdev, (unsigned long long)bh->b_blocknr); in warn_dirty_buffer()
909 /* Call t_frozen trigger and copy buffer data into jh->b_frozen_data. */
918 page = bh->b_page; in jbd2_freeze_jh_data()
919 offset = offset_in_page(bh->b_data); in jbd2_freeze_jh_data()
922 jbd2_buffer_frozen_trigger(jh, source + offset, jh->b_triggers); in jbd2_freeze_jh_data()
923 memcpy(jh->b_frozen_data, source + offset, bh->b_size); in jbd2_freeze_jh_data()
930 jh->b_frozen_triggers = jh->b_triggers; in jbd2_freeze_jh_data()
937 * make sure that we do not overwrite the old copy: we do copy-out to
948 transaction_t *transaction = handle->h_transaction; in do_get_write_access()
954 journal = transaction->t_journal; in do_get_write_access()
966 spin_lock(&jh->b_state_lock); in do_get_write_access()
971 trace_jbd2_lock_buffer_stall(bh->b_bdev->bd_dev, in do_get_write_access()
978 * non-journaled, and undergoing a quite legitimate writeback. in do_get_write_access()
983 * dump(8) (which may leave the buffer scheduled for read --- in do_get_write_access()
992 if (jh->b_transaction) { in do_get_write_access()
994 jh->b_transaction == transaction || in do_get_write_access()
995 jh->b_transaction == in do_get_write_access()
996 journal->j_committing_transaction); in do_get_write_access()
997 if (jh->b_next_transaction) in do_get_write_access()
998 J_ASSERT_JH(jh, jh->b_next_transaction == in do_get_write_access()
1005 * with running write-out. in do_get_write_access()
1014 error = -EROFS; in do_get_write_access()
1016 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1025 if (jh->b_transaction == transaction || in do_get_write_access()
1026 jh->b_next_transaction == transaction) in do_get_write_access()
1033 jh->b_modified = 0; in do_get_write_access()
1040 if (!jh->b_transaction) { in do_get_write_access()
1042 J_ASSERT_JH(jh, !jh->b_next_transaction); in do_get_write_access()
1050 spin_lock(&journal->j_list_lock); in do_get_write_access()
1052 spin_unlock(&journal->j_list_lock); in do_get_write_access()
1056 * If there is already a copy-out version of this buffer, then we don't in do_get_write_access()
1059 if (jh->b_frozen_data) { in do_get_write_access()
1061 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in do_get_write_access()
1066 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in do_get_write_access()
1067 J_ASSERT_JH(jh, jh->b_transaction == journal->j_committing_transaction); in do_get_write_access()
1072 * and has NOT made a copy-out, then we cannot modify the buffer in do_get_write_access()
1073 * contents at all right now. The essence of copy-out is that it is in do_get_write_access()
1075 * primary copy is already going to disk then we cannot do copy-out in do_get_write_access()
1080 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1081 wait_on_bit_io(&bh->b_state, BH_Shadow, TASK_UNINTERRUPTIBLE); in do_get_write_access()
1086 * Only do the copy if the currently-owning transaction still needs it. in do_get_write_access()
1097 if (jh->b_jlist == BJ_Metadata || force_copy) { in do_get_write_access()
1101 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1102 frozen_buffer = jbd2_alloc(jh2bh(jh)->b_size, in do_get_write_access()
1106 jh->b_frozen_data = frozen_buffer; in do_get_write_access()
1117 jh->b_next_transaction = transaction; in do_get_write_access()
1120 spin_unlock(&jh->b_state_lock); in do_get_write_access()
1130 jbd2_free(frozen_buffer, bh->b_size); in do_get_write_access()
1136 /* Fast check whether buffer is already attached to the required transaction */
1151 * we see jh attached to the running transaction, we know it must stay in jbd2_write_access_granted()
1153 * will be attached to the same bh while we run. However it can in jbd2_write_access_granted()
1154 * happen jh gets freed, reallocated, and attached to the transaction in jbd2_write_access_granted()
1162 jh = READ_ONCE(bh->b_private); in jbd2_write_access_granted()
1166 if (undo && !jh->b_committed_data) in jbd2_write_access_granted()
1168 if (READ_ONCE(jh->b_transaction) != handle->h_transaction && in jbd2_write_access_granted()
1169 READ_ONCE(jh->b_next_transaction) != handle->h_transaction) in jbd2_write_access_granted()
1181 if (unlikely(jh->b_bh != bh)) in jbd2_write_access_granted()
1190 * jbd2_journal_get_write_access() - notify intent to modify a buffer
1207 return -EROFS; in jbd2_journal_get_write_access()
1235 * jbd2_journal_get_create_access () - notify intent to use newly created bh
1243 transaction_t *transaction = handle->h_transaction; in jbd2_journal_get_create_access()
1249 err = -EROFS; in jbd2_journal_get_create_access()
1252 journal = transaction->t_journal; in jbd2_journal_get_create_access()
1257 * The buffer may already belong to this transaction due to pre-zeroing in jbd2_journal_get_create_access()
1263 spin_lock(&jh->b_state_lock); in jbd2_journal_get_create_access()
1264 J_ASSERT_JH(jh, (jh->b_transaction == transaction || in jbd2_journal_get_create_access()
1265 jh->b_transaction == NULL || in jbd2_journal_get_create_access()
1266 (jh->b_transaction == journal->j_committing_transaction && in jbd2_journal_get_create_access()
1267 jh->b_jlist == BJ_Forget))); in jbd2_journal_get_create_access()
1269 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in jbd2_journal_get_create_access()
1272 if (jh->b_transaction == NULL) { in jbd2_journal_get_create_access()
1283 jh->b_modified = 0; in jbd2_journal_get_create_access()
1286 spin_lock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1288 spin_unlock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1289 } else if (jh->b_transaction == journal->j_committing_transaction) { in jbd2_journal_get_create_access()
1291 jh->b_modified = 0; in jbd2_journal_get_create_access()
1294 spin_lock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1295 jh->b_next_transaction = transaction; in jbd2_journal_get_create_access()
1296 spin_unlock(&journal->j_list_lock); in jbd2_journal_get_create_access()
1298 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_create_access()
1304 * and the reallocating as data - this would cause a second revoke, in jbd2_journal_get_create_access()
1315 * jbd2_journal_get_undo_access() - Notify intent to modify metadata with
1316 * non-rewindable consequences
1325 * un-rewindable in case of a crash.
1328 * buffer for parts of non-rewindable operations such as delete
1347 return -EROFS; in jbd2_journal_get_undo_access()
1356 * Do this first --- it can drop the journal lock, so we want to in jbd2_journal_get_undo_access()
1365 if (!jh->b_committed_data) in jbd2_journal_get_undo_access()
1366 committed_data = jbd2_alloc(jh2bh(jh)->b_size, in jbd2_journal_get_undo_access()
1369 spin_lock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1370 if (!jh->b_committed_data) { in jbd2_journal_get_undo_access()
1375 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1379 jh->b_committed_data = committed_data; in jbd2_journal_get_undo_access()
1381 memcpy(jh->b_committed_data, bh->b_data, bh->b_size); in jbd2_journal_get_undo_access()
1383 spin_unlock(&jh->b_state_lock); in jbd2_journal_get_undo_access()
1387 jbd2_free(committed_data, bh->b_size); in jbd2_journal_get_undo_access()
1392 * jbd2_journal_set_triggers() - Add triggers for commit writeout
1409 jh->b_triggers = type; in jbd2_journal_set_triggers()
1418 if (!triggers || !triggers->t_frozen) in jbd2_buffer_frozen_trigger()
1421 triggers->t_frozen(triggers, bh, mapped_data, bh->b_size); in jbd2_buffer_frozen_trigger()
1427 if (!triggers || !triggers->t_abort) in jbd2_buffer_abort_trigger()
1430 triggers->t_abort(triggers, jh2bh(jh)); in jbd2_buffer_abort_trigger()
1434 * jbd2_journal_dirty_metadata() - mark a buffer as containing dirty metadata
1442 * called so that it has a valid journal_head attached to the buffer
1458 transaction_t *transaction = handle->h_transaction; in jbd2_journal_dirty_metadata()
1464 return -EROFS; in jbd2_journal_dirty_metadata()
1466 return -EUCLEAN; in jbd2_journal_dirty_metadata()
1482 if (data_race(jh->b_transaction != transaction && in jbd2_journal_dirty_metadata()
1483 jh->b_next_transaction != transaction)) { in jbd2_journal_dirty_metadata()
1484 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1485 J_ASSERT_JH(jh, jh->b_transaction == transaction || in jbd2_journal_dirty_metadata()
1486 jh->b_next_transaction == transaction); in jbd2_journal_dirty_metadata()
1487 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1489 if (jh->b_modified == 1) { in jbd2_journal_dirty_metadata()
1491 if (data_race(jh->b_transaction == transaction && in jbd2_journal_dirty_metadata()
1492 jh->b_jlist != BJ_Metadata)) { in jbd2_journal_dirty_metadata()
1493 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1494 if (jh->b_transaction == transaction && in jbd2_journal_dirty_metadata()
1495 jh->b_jlist != BJ_Metadata) in jbd2_journal_dirty_metadata()
1498 handle->h_type, handle->h_line_no, in jbd2_journal_dirty_metadata()
1499 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1500 jh->b_jlist); in jbd2_journal_dirty_metadata()
1501 J_ASSERT_JH(jh, jh->b_transaction != transaction || in jbd2_journal_dirty_metadata()
1502 jh->b_jlist == BJ_Metadata); in jbd2_journal_dirty_metadata()
1503 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1508 journal = transaction->t_journal; in jbd2_journal_dirty_metadata()
1509 spin_lock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1511 if (jh->b_modified == 0) { in jbd2_journal_dirty_metadata()
1515 * once a transaction -bzzz in jbd2_journal_dirty_metadata()
1518 ret = -ENOSPC; in jbd2_journal_dirty_metadata()
1521 jh->b_modified = 1; in jbd2_journal_dirty_metadata()
1522 handle->h_total_credits--; in jbd2_journal_dirty_metadata()
1529 * I _think_ we're OK here with SMP barriers - a mistaken decision will in jbd2_journal_dirty_metadata()
1532 if (jh->b_transaction == transaction && jh->b_jlist == BJ_Metadata) { in jbd2_journal_dirty_metadata()
1534 if (unlikely(jh->b_transaction != in jbd2_journal_dirty_metadata()
1535 journal->j_running_transaction)) { in jbd2_journal_dirty_metadata()
1537 "jh->b_transaction (%llu, %p, %u) != " in jbd2_journal_dirty_metadata()
1538 "journal->j_running_transaction (%p, %u)\n", in jbd2_journal_dirty_metadata()
1539 journal->j_devname, in jbd2_journal_dirty_metadata()
1540 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1541 jh->b_transaction, in jbd2_journal_dirty_metadata()
1542 jh->b_transaction ? jh->b_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1543 journal->j_running_transaction, in jbd2_journal_dirty_metadata()
1544 journal->j_running_transaction ? in jbd2_journal_dirty_metadata()
1545 journal->j_running_transaction->t_tid : 0); in jbd2_journal_dirty_metadata()
1546 ret = -EINVAL; in jbd2_journal_dirty_metadata()
1559 if (jh->b_transaction != transaction) { in jbd2_journal_dirty_metadata()
1561 if (unlikely(((jh->b_transaction != in jbd2_journal_dirty_metadata()
1562 journal->j_committing_transaction)) || in jbd2_journal_dirty_metadata()
1563 (jh->b_next_transaction != transaction))) { in jbd2_journal_dirty_metadata()
1567 "jh->b_transaction (%p, %u), " in jbd2_journal_dirty_metadata()
1568 "jh->b_next_transaction (%p, %u), jlist %u\n", in jbd2_journal_dirty_metadata()
1569 journal->j_devname, in jbd2_journal_dirty_metadata()
1570 (unsigned long long) bh->b_blocknr, in jbd2_journal_dirty_metadata()
1571 transaction, transaction->t_tid, in jbd2_journal_dirty_metadata()
1572 jh->b_transaction, in jbd2_journal_dirty_metadata()
1573 jh->b_transaction ? in jbd2_journal_dirty_metadata()
1574 jh->b_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1575 jh->b_next_transaction, in jbd2_journal_dirty_metadata()
1576 jh->b_next_transaction ? in jbd2_journal_dirty_metadata()
1577 jh->b_next_transaction->t_tid : 0, in jbd2_journal_dirty_metadata()
1578 jh->b_jlist); in jbd2_journal_dirty_metadata()
1580 ret = -EINVAL; in jbd2_journal_dirty_metadata()
1588 J_ASSERT_JH(jh, jh->b_frozen_data == NULL); in jbd2_journal_dirty_metadata()
1591 spin_lock(&journal->j_list_lock); in jbd2_journal_dirty_metadata()
1593 spin_unlock(&journal->j_list_lock); in jbd2_journal_dirty_metadata()
1595 spin_unlock(&jh->b_state_lock); in jbd2_journal_dirty_metadata()
1602 * jbd2_journal_forget() - bforget() for potentially-journaled buffers.
1610 * bh may not be a journalled buffer at all - it may be a non-JBD
1613 * Decrements bh->b_count by one.
1615 * Allow this call even if the handle has aborted --- it may be part of
1620 transaction_t *transaction = handle->h_transaction; in jbd2_journal_forget()
1628 return -EROFS; in jbd2_journal_forget()
1629 journal = transaction->t_journal; in jbd2_journal_forget()
1639 spin_lock(&jh->b_state_lock); in jbd2_journal_forget()
1643 if (!J_EXPECT_JH(jh, !jh->b_committed_data, in jbd2_journal_forget()
1645 err = -EIO; in jbd2_journal_forget()
1650 was_modified = jh->b_modified; in jbd2_journal_forget()
1654 * all references -bzzz in jbd2_journal_forget()
1656 jh->b_modified = 0; in jbd2_journal_forget()
1658 if (jh->b_transaction == transaction) { in jbd2_journal_forget()
1659 J_ASSERT_JH(jh, !jh->b_frozen_data); in jbd2_journal_forget()
1688 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1689 if (jh->b_cp_transaction) { in jbd2_journal_forget()
1696 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1697 } else if (jh->b_transaction) { in jbd2_journal_forget()
1698 J_ASSERT_JH(jh, (jh->b_transaction == in jbd2_journal_forget()
1699 journal->j_committing_transaction)); in jbd2_journal_forget()
1712 if (!jh->b_next_transaction) { in jbd2_journal_forget()
1713 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1714 jh->b_next_transaction = transaction; in jbd2_journal_forget()
1715 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1717 J_ASSERT(jh->b_next_transaction == transaction); in jbd2_journal_forget()
1732 spin_lock(&journal->j_list_lock); in jbd2_journal_forget()
1733 if (!jh->b_cp_transaction) { in jbd2_journal_forget()
1735 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1745 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1757 spin_unlock(&journal->j_list_lock); in jbd2_journal_forget()
1761 spin_unlock(&jh->b_state_lock); in jbd2_journal_forget()
1764 /* no need to reserve log space for this block -bzzz */ in jbd2_journal_forget()
1765 handle->h_total_credits++; in jbd2_journal_forget()
1771 * jbd2_journal_stop() - complete a transaction
1783 * return -EIO if a jbd2_journal_abort has been executed since the
1788 transaction_t *transaction = handle->h_transaction; in jbd2_journal_stop()
1794 if (--handle->h_ref > 0) { in jbd2_journal_stop()
1795 jbd_debug(4, "h_ref %d -> %d\n", handle->h_ref + 1, in jbd2_journal_stop()
1796 handle->h_ref); in jbd2_journal_stop()
1798 return -EIO; in jbd2_journal_stop()
1806 memalloc_nofs_restore(handle->saved_alloc_context); in jbd2_journal_stop()
1809 journal = transaction->t_journal; in jbd2_journal_stop()
1810 tid = transaction->t_tid; in jbd2_journal_stop()
1813 err = -EIO; in jbd2_journal_stop()
1816 trace_jbd2_handle_stats(journal->j_fs_dev->bd_dev, in jbd2_journal_stop()
1817 tid, handle->h_type, handle->h_line_no, in jbd2_journal_stop()
1818 jiffies - handle->h_start_jiffies, in jbd2_journal_stop()
1819 handle->h_sync, handle->h_requested_credits, in jbd2_journal_stop()
1820 (handle->h_requested_credits - in jbd2_journal_stop()
1821 handle->h_total_credits)); in jbd2_journal_stop()
1828 * arrive. It doesn't cost much - we're about to run a commit in jbd2_journal_stop()
1829 * and sleep on IO anyway. Speeds up many-threaded, many-dir in jbd2_journal_stop()
1852 pid = current->pid; in jbd2_journal_stop()
1853 if (handle->h_sync && journal->j_last_sync_writer != pid && in jbd2_journal_stop()
1854 journal->j_max_batch_time) { in jbd2_journal_stop()
1857 journal->j_last_sync_writer = pid; in jbd2_journal_stop()
1859 read_lock(&journal->j_state_lock); in jbd2_journal_stop()
1860 commit_time = journal->j_average_commit_time; in jbd2_journal_stop()
1861 read_unlock(&journal->j_state_lock); in jbd2_journal_stop()
1864 transaction->t_start_time)); in jbd2_journal_stop()
1867 1000*journal->j_min_batch_time); in jbd2_journal_stop()
1869 1000*journal->j_max_batch_time); in jbd2_journal_stop()
1879 if (handle->h_sync) in jbd2_journal_stop()
1880 transaction->t_synchronous_commit = 1; in jbd2_journal_stop()
1887 if (handle->h_sync || in jbd2_journal_stop()
1888 time_after_eq(jiffies, transaction->t_expires)) { in jbd2_journal_stop()
1895 /* This is non-blocking */ in jbd2_journal_stop()
1902 if (handle->h_sync && !(current->flags & PF_MEMALLOC)) in jbd2_journal_stop()
1918 if (handle->h_rsv_handle) in jbd2_journal_stop()
1919 jbd2_free_handle(handle->h_rsv_handle); in jbd2_journal_stop()
1937 * jh->b_state_lock is held.
1944 jh->b_tnext = jh->b_tprev = jh; in __blist_add_buffer()
1948 struct journal_head *first = *list, *last = first->b_tprev; in __blist_add_buffer()
1949 jh->b_tprev = last; in __blist_add_buffer()
1950 jh->b_tnext = first; in __blist_add_buffer()
1951 last->b_tnext = first->b_tprev = jh; in __blist_add_buffer()
1961 * jh->b_state_lock is held.
1968 *list = jh->b_tnext; in __blist_del_buffer()
1972 jh->b_tprev->b_tnext = jh->b_tnext; in __blist_del_buffer()
1973 jh->b_tnext->b_tprev = jh->b_tprev; in __blist_del_buffer()
1980 * bh->b_transaction->t_buffers, t_forget, t_shadow_list, t_log_list or
1982 * pointers, it could go bad. Generally the caller needs to re-read the
1993 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_temp_unlink_buffer()
1994 transaction = jh->b_transaction; in __jbd2_journal_temp_unlink_buffer()
1996 assert_spin_locked(&transaction->t_journal->j_list_lock); in __jbd2_journal_temp_unlink_buffer()
1998 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); in __jbd2_journal_temp_unlink_buffer()
1999 if (jh->b_jlist != BJ_None) in __jbd2_journal_temp_unlink_buffer()
2002 switch (jh->b_jlist) { in __jbd2_journal_temp_unlink_buffer()
2006 transaction->t_nr_buffers--; in __jbd2_journal_temp_unlink_buffer()
2007 J_ASSERT_JH(jh, transaction->t_nr_buffers >= 0); in __jbd2_journal_temp_unlink_buffer()
2008 list = &transaction->t_buffers; in __jbd2_journal_temp_unlink_buffer()
2011 list = &transaction->t_forget; in __jbd2_journal_temp_unlink_buffer()
2014 list = &transaction->t_shadow_list; in __jbd2_journal_temp_unlink_buffer()
2017 list = &transaction->t_reserved_list; in __jbd2_journal_temp_unlink_buffer()
2022 jh->b_jlist = BJ_None; in __jbd2_journal_temp_unlink_buffer()
2023 if (transaction && is_journal_aborted(transaction->t_journal)) in __jbd2_journal_temp_unlink_buffer()
2037 J_ASSERT_JH(jh, jh->b_transaction != NULL); in __jbd2_journal_unfile_buffer()
2038 J_ASSERT_JH(jh, jh->b_next_transaction == NULL); in __jbd2_journal_unfile_buffer()
2041 jh->b_transaction = NULL; in __jbd2_journal_unfile_buffer()
2050 spin_lock(&jh->b_state_lock); in jbd2_journal_unfile_buffer()
2051 spin_lock(&journal->j_list_lock); in jbd2_journal_unfile_buffer()
2053 spin_unlock(&journal->j_list_lock); in jbd2_journal_unfile_buffer()
2054 spin_unlock(&jh->b_state_lock); in jbd2_journal_unfile_buffer()
2062 * Called under jh->b_state_lock
2074 if (jh->b_next_transaction != NULL || jh->b_transaction != NULL) in __journal_try_to_free_buffer()
2077 spin_lock(&journal->j_list_lock); in __journal_try_to_free_buffer()
2078 if (jh->b_cp_transaction != NULL) { in __journal_try_to_free_buffer()
2079 /* written-back checkpointed metadata buffer */ in __journal_try_to_free_buffer()
2083 spin_unlock(&journal->j_list_lock); in __journal_try_to_free_buffer()
2089 * jbd2_journal_try_to_free_buffers() - try to free page buffers.
2097 * This function returns non-zero if we wish try_to_free_buffers()
2104 * running transaction's ->t_datalist via __jbd2_journal_unfile_buffer.
2106 * This may *change* the value of transaction_t->t_datalist, so anyone
2115 * is do_get_write_access() - it could be looking at the buffer while
2144 spin_lock(&jh->b_state_lock); in jbd2_journal_try_to_free_buffers()
2146 spin_unlock(&jh->b_state_lock); in jbd2_journal_try_to_free_buffers()
2150 } while ((bh = bh->b_this_page) != head); in jbd2_journal_try_to_free_buffers()
2163 * Returns non-zero if JBD no longer has an interest in the buffer.
2167 * Called under jh->b_state_lock.
2174 if (jh->b_cp_transaction) { in __dispose_buffer()
2206 * attached to the current transaction: once the transaction commits,
2218 * as in-use in the committed_data bitmap, so cannot be reused until
2226 * don't make guarantees about the order in which data hits disk --- in
2228 * transaction commit --- so it is always safe just to discard data
2229 * immediately in that mode. --sct
2237 * We're outside-transaction here. Either or both of j_running_transaction
2252 * holding the page lock. --sct in journal_unmap_buffer()
2260 write_lock(&journal->j_state_lock); in journal_unmap_buffer()
2261 spin_lock(&jh->b_state_lock); in journal_unmap_buffer()
2262 spin_lock(&journal->j_list_lock); in journal_unmap_buffer()
2280 * because the buffer_head may be attached to the page straddling in journal_unmap_buffer()
2283 * up keeping around invalidated buffers attached to transactions' in journal_unmap_buffer()
2287 transaction = jh->b_transaction; in journal_unmap_buffer()
2291 * it's a writeback-mode buffer so we don't care in journal_unmap_buffer()
2293 if (!jh->b_cp_transaction) { in journal_unmap_buffer()
2308 if (journal->j_running_transaction) { in journal_unmap_buffer()
2314 journal->j_running_transaction); in journal_unmap_buffer()
2317 /* There is no currently-running transaction. So the in journal_unmap_buffer()
2321 if (journal->j_committing_transaction) { in journal_unmap_buffer()
2324 journal->j_committing_transaction); in journal_unmap_buffer()
2334 } else if (transaction == journal->j_committing_transaction) { in journal_unmap_buffer()
2342 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2343 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2344 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2346 return -EBUSY; in journal_unmap_buffer()
2356 if (journal->j_running_transaction && buffer_jbddirty(bh)) in journal_unmap_buffer()
2357 jh->b_next_transaction = journal->j_running_transaction; in journal_unmap_buffer()
2358 jh->b_modified = 0; in journal_unmap_buffer()
2359 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2360 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2361 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2371 J_ASSERT_JH(jh, transaction == journal->j_running_transaction); in journal_unmap_buffer()
2379 * if blocksize < pagesize and it is attached to the page straddling in journal_unmap_buffer()
2385 jh->b_modified = 0; in journal_unmap_buffer()
2386 spin_unlock(&journal->j_list_lock); in journal_unmap_buffer()
2387 spin_unlock(&jh->b_state_lock); in journal_unmap_buffer()
2388 write_unlock(&journal->j_state_lock); in journal_unmap_buffer()
2398 bh->b_bdev = NULL; in journal_unmap_buffer()
2410 * Can return -EBUSY if buffers are part of the committing transaction and
2439 unsigned int next_off = curr_off + bh->b_size; in jbd2_journal_invalidatepage()
2440 next = bh->b_this_page; in jbd2_journal_invalidatepage()
2476 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_file_buffer()
2477 assert_spin_locked(&transaction->t_journal->j_list_lock); in __jbd2_journal_file_buffer()
2479 J_ASSERT_JH(jh, jh->b_jlist < BJ_Types); in __jbd2_journal_file_buffer()
2480 J_ASSERT_JH(jh, jh->b_transaction == transaction || in __jbd2_journal_file_buffer()
2481 jh->b_transaction == NULL); in __jbd2_journal_file_buffer()
2483 if (jh->b_transaction && jh->b_jlist == jlist) in __jbd2_journal_file_buffer()
2502 if (jh->b_transaction) in __jbd2_journal_file_buffer()
2506 jh->b_transaction = transaction; in __jbd2_journal_file_buffer()
2510 J_ASSERT_JH(jh, !jh->b_committed_data); in __jbd2_journal_file_buffer()
2511 J_ASSERT_JH(jh, !jh->b_frozen_data); in __jbd2_journal_file_buffer()
2514 transaction->t_nr_buffers++; in __jbd2_journal_file_buffer()
2515 list = &transaction->t_buffers; in __jbd2_journal_file_buffer()
2518 list = &transaction->t_forget; in __jbd2_journal_file_buffer()
2521 list = &transaction->t_shadow_list; in __jbd2_journal_file_buffer()
2524 list = &transaction->t_reserved_list; in __jbd2_journal_file_buffer()
2529 jh->b_jlist = jlist; in __jbd2_journal_file_buffer()
2538 spin_lock(&jh->b_state_lock); in jbd2_journal_file_buffer()
2539 spin_lock(&transaction->t_journal->j_list_lock); in jbd2_journal_file_buffer()
2541 spin_unlock(&transaction->t_journal->j_list_lock); in jbd2_journal_file_buffer()
2542 spin_unlock(&jh->b_state_lock); in jbd2_journal_file_buffer()
2552 * Called under jh->b_state_lock
2563 lockdep_assert_held(&jh->b_state_lock); in __jbd2_journal_refile_buffer()
2564 if (jh->b_transaction) in __jbd2_journal_refile_buffer()
2565 assert_spin_locked(&jh->b_transaction->t_journal->j_list_lock); in __jbd2_journal_refile_buffer()
2568 if (jh->b_next_transaction == NULL) { in __jbd2_journal_refile_buffer()
2585 J_ASSERT_JH(jh, jh->b_transaction != NULL); in __jbd2_journal_refile_buffer()
2592 WRITE_ONCE(jh->b_transaction, jh->b_next_transaction); in __jbd2_journal_refile_buffer()
2593 WRITE_ONCE(jh->b_next_transaction, NULL); in __jbd2_journal_refile_buffer()
2596 else if (jh->b_modified) in __jbd2_journal_refile_buffer()
2600 __jbd2_journal_file_buffer(jh, jh->b_transaction, jlist); in __jbd2_journal_refile_buffer()
2601 J_ASSERT_JH(jh, jh->b_transaction->t_state == T_RUNNING); in __jbd2_journal_refile_buffer()
2618 spin_lock(&jh->b_state_lock); in jbd2_journal_refile_buffer()
2619 spin_lock(&journal->j_list_lock); in jbd2_journal_refile_buffer()
2621 spin_unlock(&jh->b_state_lock); in jbd2_journal_refile_buffer()
2622 spin_unlock(&journal->j_list_lock); in jbd2_journal_refile_buffer()
2633 transaction_t *transaction = handle->h_transaction; in jbd2_journal_file_inode()
2637 return -EROFS; in jbd2_journal_file_inode()
2638 journal = transaction->t_journal; in jbd2_journal_file_inode()
2640 jbd_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino, in jbd2_journal_file_inode()
2641 transaction->t_tid); in jbd2_journal_file_inode()
2643 spin_lock(&journal->j_list_lock); in jbd2_journal_file_inode()
2644 jinode->i_flags |= flags; in jbd2_journal_file_inode()
2646 if (jinode->i_dirty_end) { in jbd2_journal_file_inode()
2647 jinode->i_dirty_start = min(jinode->i_dirty_start, start_byte); in jbd2_journal_file_inode()
2648 jinode->i_dirty_end = max(jinode->i_dirty_end, end_byte); in jbd2_journal_file_inode()
2650 jinode->i_dirty_start = start_byte; in jbd2_journal_file_inode()
2651 jinode->i_dirty_end = end_byte; in jbd2_journal_file_inode()
2654 /* Is inode already attached where we need it? */ in jbd2_journal_file_inode()
2655 if (jinode->i_transaction == transaction || in jbd2_journal_file_inode()
2656 jinode->i_next_transaction == transaction) in jbd2_journal_file_inode()
2664 if (!transaction->t_need_data_flush) in jbd2_journal_file_inode()
2665 transaction->t_need_data_flush = 1; in jbd2_journal_file_inode()
2666 /* On some different transaction's list - should be in jbd2_journal_file_inode()
2668 if (jinode->i_transaction) { in jbd2_journal_file_inode()
2669 J_ASSERT(jinode->i_next_transaction == NULL); in jbd2_journal_file_inode()
2670 J_ASSERT(jinode->i_transaction == in jbd2_journal_file_inode()
2671 journal->j_committing_transaction); in jbd2_journal_file_inode()
2672 jinode->i_next_transaction = transaction; in jbd2_journal_file_inode()
2676 J_ASSERT(!jinode->i_next_transaction); in jbd2_journal_file_inode()
2677 jinode->i_transaction = transaction; in jbd2_journal_file_inode()
2678 list_add(&jinode->i_list, &transaction->t_inode_list); in jbd2_journal_file_inode()
2680 spin_unlock(&journal->j_list_lock); in jbd2_journal_file_inode()
2690 start_byte + length - 1); in jbd2_journal_inode_ranged_write()
2697 start_byte, start_byte + length - 1); in jbd2_journal_inode_ranged_wait()
2702 * non-trivial way. If a transaction writing data block A is
2717 * happens in the same transaction as write --- we don't have to write
2728 if (!jinode->i_transaction) in jbd2_journal_begin_ordered_truncate()
2733 read_lock(&journal->j_state_lock); in jbd2_journal_begin_ordered_truncate()
2734 commit_trans = journal->j_committing_transaction; in jbd2_journal_begin_ordered_truncate()
2735 read_unlock(&journal->j_state_lock); in jbd2_journal_begin_ordered_truncate()
2736 spin_lock(&journal->j_list_lock); in jbd2_journal_begin_ordered_truncate()
2737 inode_trans = jinode->i_transaction; in jbd2_journal_begin_ordered_truncate()
2738 spin_unlock(&journal->j_list_lock); in jbd2_journal_begin_ordered_truncate()
2740 ret = filemap_fdatawrite_range(jinode->i_vfs_inode->i_mapping, in jbd2_journal_begin_ordered_truncate()