Lines Matching full:journal
3 * linux/fs/jbd2/journal.c
9 * Generic filesystem journal-writing code; part of the ext2fs
16 * We do not actually manage the physical storage of the journal in this
17 * file: that is left to a per-journal policy function, which allows us
18 * to store the journal within a filesystem-specified area for ext2
137 journal_t *journal = from_timer(journal, t, j_commit_timer); in commit_timeout() local
139 wake_up_process(journal->j_task); in commit_timeout()
144 * journal.
149 * filesystem to disk. The journal thread is responsible for writing
151 * journal thread waits until it's done and then continues from
162 journal_t *journal = arg; in kjournald2() local
169 timer_setup(&journal->j_commit_timer, commit_timeout, 0); in kjournald2()
173 /* Record that the journal thread is running */ in kjournald2()
174 journal->j_task = current; in kjournald2()
175 wake_up(&journal->j_wait_done_commit); in kjournald2()
188 write_lock(&journal->j_state_lock); in kjournald2()
191 if (journal->j_flags & JBD2_UNMOUNT) in kjournald2()
195 journal->j_commit_sequence, journal->j_commit_request); in kjournald2()
197 if (journal->j_commit_sequence != journal->j_commit_request) { in kjournald2()
199 write_unlock(&journal->j_state_lock); in kjournald2()
200 del_timer_sync(&journal->j_commit_timer); in kjournald2()
201 jbd2_journal_commit_transaction(journal); in kjournald2()
202 write_lock(&journal->j_state_lock); in kjournald2()
206 wake_up(&journal->j_wait_done_commit); in kjournald2()
209 * The simpler the better. Flushing journal isn't a in kjournald2()
214 write_unlock(&journal->j_state_lock); in kjournald2()
216 write_lock(&journal->j_state_lock); in kjournald2()
225 prepare_to_wait(&journal->j_wait_commit, &wait, in kjournald2()
227 if (journal->j_commit_sequence != journal->j_commit_request) in kjournald2()
229 transaction = journal->j_running_transaction; in kjournald2()
233 if (journal->j_flags & JBD2_UNMOUNT) in kjournald2()
236 write_unlock(&journal->j_state_lock); in kjournald2()
238 write_lock(&journal->j_state_lock); in kjournald2()
240 finish_wait(&journal->j_wait_commit, &wait); in kjournald2()
248 transaction = journal->j_running_transaction; in kjournald2()
250 journal->j_commit_request = transaction->t_tid; in kjournald2()
256 del_timer_sync(&journal->j_commit_timer); in kjournald2()
257 journal->j_task = NULL; in kjournald2()
258 wake_up(&journal->j_wait_done_commit); in kjournald2()
259 jbd2_debug(1, "Journal thread exiting.\n"); in kjournald2()
260 write_unlock(&journal->j_state_lock); in kjournald2()
264 static int jbd2_journal_start_thread(journal_t *journal) in jbd2_journal_start_thread() argument
268 t = kthread_run(kjournald2, journal, "jbd2/%s", in jbd2_journal_start_thread()
269 journal->j_devname); in jbd2_journal_start_thread()
273 wait_event(journal->j_wait_done_commit, journal->j_task != NULL); in jbd2_journal_start_thread()
277 static void journal_kill_thread(journal_t *journal) in journal_kill_thread() argument
279 write_lock(&journal->j_state_lock); in journal_kill_thread()
280 journal->j_flags |= JBD2_UNMOUNT; in journal_kill_thread()
282 while (journal->j_task) { in journal_kill_thread()
283 write_unlock(&journal->j_state_lock); in journal_kill_thread()
284 wake_up(&journal->j_wait_commit); in journal_kill_thread()
285 wait_event(journal->j_wait_done_commit, journal->j_task == NULL); in journal_kill_thread()
286 write_lock(&journal->j_state_lock); in journal_kill_thread()
288 write_unlock(&journal->j_state_lock); in journal_kill_thread()
292 * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
339 journal_t *journal = transaction->t_journal; in jbd2_journal_write_metadata_buffer() local
438 new_bh->b_bdev = journal->j_dev; in jbd2_journal_write_metadata_buffer()
452 spin_lock(&journal->j_list_lock); in jbd2_journal_write_metadata_buffer()
454 spin_unlock(&journal->j_list_lock); in jbd2_journal_write_metadata_buffer()
462 * Allocation code for the journal file. Manage the space left in the
463 * journal, so that we can begin checkpointing when appropriate.
470 static int __jbd2_log_start_commit(journal_t *journal, tid_t target) in __jbd2_log_start_commit() argument
473 if (journal->j_commit_request == target) in __jbd2_log_start_commit()
481 if (journal->j_running_transaction && in __jbd2_log_start_commit()
482 journal->j_running_transaction->t_tid == target) { in __jbd2_log_start_commit()
488 journal->j_commit_request = target; in __jbd2_log_start_commit()
490 journal->j_commit_request, in __jbd2_log_start_commit()
491 journal->j_commit_sequence); in __jbd2_log_start_commit()
492 journal->j_running_transaction->t_requested = jiffies; in __jbd2_log_start_commit()
493 wake_up(&journal->j_wait_commit); in __jbd2_log_start_commit()
495 } else if (!tid_geq(journal->j_commit_request, target)) in __jbd2_log_start_commit()
500 journal->j_commit_request, in __jbd2_log_start_commit()
501 journal->j_commit_sequence, in __jbd2_log_start_commit()
502 target, journal->j_running_transaction ? in __jbd2_log_start_commit()
503 journal->j_running_transaction->t_tid : 0); in __jbd2_log_start_commit()
507 int jbd2_log_start_commit(journal_t *journal, tid_t tid) in jbd2_log_start_commit() argument
511 write_lock(&journal->j_state_lock); in jbd2_log_start_commit()
512 ret = __jbd2_log_start_commit(journal, tid); in jbd2_log_start_commit()
513 write_unlock(&journal->j_state_lock); in jbd2_log_start_commit()
524 static int __jbd2_journal_force_commit(journal_t *journal) in __jbd2_journal_force_commit() argument
530 read_lock(&journal->j_state_lock); in __jbd2_journal_force_commit()
531 if (journal->j_running_transaction && !current->journal_info) { in __jbd2_journal_force_commit()
532 transaction = journal->j_running_transaction; in __jbd2_journal_force_commit()
533 if (!tid_geq(journal->j_commit_request, transaction->t_tid)) in __jbd2_journal_force_commit()
535 } else if (journal->j_committing_transaction) in __jbd2_journal_force_commit()
536 transaction = journal->j_committing_transaction; in __jbd2_journal_force_commit()
540 read_unlock(&journal->j_state_lock); in __jbd2_journal_force_commit()
544 read_unlock(&journal->j_state_lock); in __jbd2_journal_force_commit()
546 jbd2_log_start_commit(journal, tid); in __jbd2_journal_force_commit()
547 ret = jbd2_log_wait_commit(journal, tid); in __jbd2_journal_force_commit()
558 * @journal: journal to force
564 int jbd2_journal_force_commit_nested(journal_t *journal) in jbd2_journal_force_commit_nested() argument
568 ret = __jbd2_journal_force_commit(journal); in jbd2_journal_force_commit_nested()
574 * @journal: journal to force
579 int jbd2_journal_force_commit(journal_t *journal) in jbd2_journal_force_commit() argument
584 ret = __jbd2_journal_force_commit(journal); in jbd2_journal_force_commit()
595 int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid) in jbd2_journal_start_commit() argument
599 write_lock(&journal->j_state_lock); in jbd2_journal_start_commit()
600 if (journal->j_running_transaction) { in jbd2_journal_start_commit()
601 tid_t tid = journal->j_running_transaction->t_tid; in jbd2_journal_start_commit()
603 __jbd2_log_start_commit(journal, tid); in jbd2_journal_start_commit()
609 } else if (journal->j_committing_transaction) { in jbd2_journal_start_commit()
615 *ptid = journal->j_committing_transaction->t_tid; in jbd2_journal_start_commit()
618 write_unlock(&journal->j_state_lock); in jbd2_journal_start_commit()
628 int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid) in jbd2_trans_will_send_data_barrier() argument
633 if (!(journal->j_flags & JBD2_BARRIER)) in jbd2_trans_will_send_data_barrier()
635 read_lock(&journal->j_state_lock); in jbd2_trans_will_send_data_barrier()
637 if (tid_geq(journal->j_commit_sequence, tid)) in jbd2_trans_will_send_data_barrier()
639 commit_trans = journal->j_committing_transaction; in jbd2_trans_will_send_data_barrier()
648 if (journal->j_fs_dev != journal->j_dev) { in jbd2_trans_will_send_data_barrier()
658 read_unlock(&journal->j_state_lock); in jbd2_trans_will_send_data_barrier()
665 * The caller may not hold the journal lock.
667 int jbd2_log_wait_commit(journal_t *journal, tid_t tid) in jbd2_log_wait_commit() argument
671 read_lock(&journal->j_state_lock); in jbd2_log_wait_commit()
678 if (tid_gt(tid, journal->j_commit_sequence) && in jbd2_log_wait_commit()
679 (!journal->j_committing_transaction || in jbd2_log_wait_commit()
680 journal->j_committing_transaction->t_tid != tid)) { in jbd2_log_wait_commit()
681 read_unlock(&journal->j_state_lock); in jbd2_log_wait_commit()
682 jbd2_might_wait_for_commit(journal); in jbd2_log_wait_commit()
683 read_lock(&journal->j_state_lock); in jbd2_log_wait_commit()
687 if (!tid_geq(journal->j_commit_request, tid)) { in jbd2_log_wait_commit()
690 __func__, journal->j_commit_request, tid); in jbd2_log_wait_commit()
693 while (tid_gt(tid, journal->j_commit_sequence)) { in jbd2_log_wait_commit()
695 tid, journal->j_commit_sequence); in jbd2_log_wait_commit()
696 read_unlock(&journal->j_state_lock); in jbd2_log_wait_commit()
697 wake_up(&journal->j_wait_commit); in jbd2_log_wait_commit()
698 wait_event(journal->j_wait_done_commit, in jbd2_log_wait_commit()
699 !tid_gt(tid, journal->j_commit_sequence)); in jbd2_log_wait_commit()
700 read_lock(&journal->j_state_lock); in jbd2_log_wait_commit()
702 read_unlock(&journal->j_state_lock); in jbd2_log_wait_commit()
704 if (unlikely(is_journal_aborted(journal))) in jbd2_log_wait_commit()
716 int jbd2_fc_begin_commit(journal_t *journal, tid_t tid) in jbd2_fc_begin_commit() argument
718 if (unlikely(is_journal_aborted(journal))) in jbd2_fc_begin_commit()
724 if (!journal->j_stats.ts_tid) in jbd2_fc_begin_commit()
727 write_lock(&journal->j_state_lock); in jbd2_fc_begin_commit()
728 if (tid_geq(journal->j_commit_sequence, tid)) { in jbd2_fc_begin_commit()
729 write_unlock(&journal->j_state_lock); in jbd2_fc_begin_commit()
733 if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING || in jbd2_fc_begin_commit()
734 (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) { in jbd2_fc_begin_commit()
737 prepare_to_wait(&journal->j_fc_wait, &wait, in jbd2_fc_begin_commit()
739 write_unlock(&journal->j_state_lock); in jbd2_fc_begin_commit()
741 finish_wait(&journal->j_fc_wait, &wait); in jbd2_fc_begin_commit()
744 journal->j_flags |= JBD2_FAST_COMMIT_ONGOING; in jbd2_fc_begin_commit()
745 write_unlock(&journal->j_state_lock); in jbd2_fc_begin_commit()
746 jbd2_journal_lock_updates(journal); in jbd2_fc_begin_commit()
756 static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback) in __jbd2_fc_end_commit() argument
758 if (journal->j_fc_cleanup_callback) in __jbd2_fc_end_commit()
759 journal->j_fc_cleanup_callback(journal, 0, tid); in __jbd2_fc_end_commit()
760 jbd2_journal_unlock_updates(journal); in __jbd2_fc_end_commit()
761 write_lock(&journal->j_state_lock); in __jbd2_fc_end_commit()
762 journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING; in __jbd2_fc_end_commit()
764 journal->j_flags |= JBD2_FULL_COMMIT_ONGOING; in __jbd2_fc_end_commit()
765 write_unlock(&journal->j_state_lock); in __jbd2_fc_end_commit()
766 wake_up(&journal->j_fc_wait); in __jbd2_fc_end_commit()
768 return jbd2_complete_transaction(journal, tid); in __jbd2_fc_end_commit()
772 int jbd2_fc_end_commit(journal_t *journal) in jbd2_fc_end_commit() argument
774 return __jbd2_fc_end_commit(journal, 0, false); in jbd2_fc_end_commit()
778 int jbd2_fc_end_commit_fallback(journal_t *journal) in jbd2_fc_end_commit_fallback() argument
782 read_lock(&journal->j_state_lock); in jbd2_fc_end_commit_fallback()
783 tid = journal->j_running_transaction ? in jbd2_fc_end_commit_fallback()
784 journal->j_running_transaction->t_tid : 0; in jbd2_fc_end_commit_fallback()
785 read_unlock(&journal->j_state_lock); in jbd2_fc_end_commit_fallback()
786 return __jbd2_fc_end_commit(journal, tid, true); in jbd2_fc_end_commit_fallback()
791 int jbd2_transaction_committed(journal_t *journal, tid_t tid) in jbd2_transaction_committed() argument
795 read_lock(&journal->j_state_lock); in jbd2_transaction_committed()
796 if (journal->j_running_transaction && in jbd2_transaction_committed()
797 journal->j_running_transaction->t_tid == tid) in jbd2_transaction_committed()
799 if (journal->j_committing_transaction && in jbd2_transaction_committed()
800 journal->j_committing_transaction->t_tid == tid) in jbd2_transaction_committed()
802 read_unlock(&journal->j_state_lock); in jbd2_transaction_committed()
814 int jbd2_complete_transaction(journal_t *journal, tid_t tid) in jbd2_complete_transaction() argument
818 read_lock(&journal->j_state_lock); in jbd2_complete_transaction()
819 if (journal->j_running_transaction && in jbd2_complete_transaction()
820 journal->j_running_transaction->t_tid == tid) { in jbd2_complete_transaction()
821 if (journal->j_commit_request != tid) { in jbd2_complete_transaction()
823 read_unlock(&journal->j_state_lock); in jbd2_complete_transaction()
824 jbd2_log_start_commit(journal, tid); in jbd2_complete_transaction()
827 } else if (!(journal->j_committing_transaction && in jbd2_complete_transaction()
828 journal->j_committing_transaction->t_tid == tid)) in jbd2_complete_transaction()
830 read_unlock(&journal->j_state_lock); in jbd2_complete_transaction()
834 return jbd2_log_wait_commit(journal, tid); in jbd2_complete_transaction()
842 int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp) in jbd2_journal_next_log_block() argument
846 write_lock(&journal->j_state_lock); in jbd2_journal_next_log_block()
847 J_ASSERT(journal->j_free > 1); in jbd2_journal_next_log_block()
849 blocknr = journal->j_head; in jbd2_journal_next_log_block()
850 journal->j_head++; in jbd2_journal_next_log_block()
851 journal->j_free--; in jbd2_journal_next_log_block()
852 if (journal->j_head == journal->j_last) in jbd2_journal_next_log_block()
853 journal->j_head = journal->j_first; in jbd2_journal_next_log_block()
854 write_unlock(&journal->j_state_lock); in jbd2_journal_next_log_block()
855 return jbd2_journal_bmap(journal, blocknr, retp); in jbd2_journal_next_log_block()
859 int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out) in jbd2_fc_get_buf() argument
869 if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) { in jbd2_fc_get_buf()
870 fc_off = journal->j_fc_off; in jbd2_fc_get_buf()
871 blocknr = journal->j_fc_first + fc_off; in jbd2_fc_get_buf()
872 journal->j_fc_off++; in jbd2_fc_get_buf()
880 ret = jbd2_journal_bmap(journal, blocknr, &pblock); in jbd2_fc_get_buf()
884 bh = __getblk(journal->j_dev, pblock, journal->j_blocksize); in jbd2_fc_get_buf()
889 journal->j_fc_wbuf[fc_off] = bh; in jbd2_fc_get_buf()
901 int jbd2_fc_wait_bufs(journal_t *journal, int num_blks) in jbd2_fc_wait_bufs() argument
906 j_fc_off = journal->j_fc_off; in jbd2_fc_wait_bufs()
913 bh = journal->j_fc_wbuf[i]; in jbd2_fc_wait_bufs()
920 journal->j_fc_off = i + 1; in jbd2_fc_wait_bufs()
924 journal->j_fc_wbuf[i] = NULL; in jbd2_fc_wait_bufs()
931 int jbd2_fc_release_bufs(journal_t *journal) in jbd2_fc_release_bufs() argument
936 j_fc_off = journal->j_fc_off; in jbd2_fc_release_bufs()
939 bh = journal->j_fc_wbuf[i]; in jbd2_fc_release_bufs()
943 journal->j_fc_wbuf[i] = NULL; in jbd2_fc_release_bufs()
951 * Conversion of logical to physical block numbers for the journal
953 * On external journals the journal blocks are identity-mapped, so
957 int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr, in jbd2_journal_bmap() argument
964 if (journal->j_bmap) { in jbd2_journal_bmap()
965 err = journal->j_bmap(journal, &block); in jbd2_journal_bmap()
968 } else if (journal->j_inode) { in jbd2_journal_bmap()
969 ret = bmap(journal->j_inode, &block); in jbd2_journal_bmap()
972 printk(KERN_ALERT "%s: journal block not found " in jbd2_journal_bmap()
974 __func__, blocknr, journal->j_devname); in jbd2_journal_bmap()
976 jbd2_journal_abort(journal, err); in jbd2_journal_bmap()
982 *retp = blocknr; /* +journal->j_blk_offset */ in jbd2_journal_bmap()
989 * the journal without copying their contents, but for journal
1000 journal_t *journal = transaction->t_journal; in jbd2_journal_get_descriptor_buffer() local
1006 err = jbd2_journal_next_log_block(journal, &blocknr); in jbd2_journal_get_descriptor_buffer()
1011 bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize); in jbd2_journal_get_descriptor_buffer()
1016 memset(bh->b_data, 0, journal->j_blocksize); in jbd2_journal_get_descriptor_buffer()
1043 * Return tid of the oldest transaction in the journal and block in the journal
1046 * If the journal is now empty, return which will be the next transaction ID
1049 * The return value is 0 if journal tail cannot be pushed any further, 1 if
1052 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid, in jbd2_journal_get_log_tail() argument
1058 read_lock(&journal->j_state_lock); in jbd2_journal_get_log_tail()
1059 spin_lock(&journal->j_list_lock); in jbd2_journal_get_log_tail()
1060 transaction = journal->j_checkpoint_transactions; in jbd2_journal_get_log_tail()
1064 } else if ((transaction = journal->j_committing_transaction) != NULL) { in jbd2_journal_get_log_tail()
1067 } else if ((transaction = journal->j_running_transaction) != NULL) { in jbd2_journal_get_log_tail()
1069 *block = journal->j_head; in jbd2_journal_get_log_tail()
1071 *tid = journal->j_transaction_sequence; in jbd2_journal_get_log_tail()
1072 *block = journal->j_head; in jbd2_journal_get_log_tail()
1074 ret = tid_gt(*tid, journal->j_tail_sequence); in jbd2_journal_get_log_tail()
1075 spin_unlock(&journal->j_list_lock); in jbd2_journal_get_log_tail()
1076 read_unlock(&journal->j_state_lock); in jbd2_journal_get_log_tail()
1082 * Update information in journal structure and in on disk journal superblock
1091 int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) in __jbd2_update_log_tail() argument
1096 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); in __jbd2_update_log_tail()
1100 * soon as we update j_tail, next transaction can start reusing journal in __jbd2_update_log_tail()
1104 ret = jbd2_journal_update_sb_log_tail(journal, tid, block, REQ_FUA); in __jbd2_update_log_tail()
1108 write_lock(&journal->j_state_lock); in __jbd2_update_log_tail()
1109 freed = block - journal->j_tail; in __jbd2_update_log_tail()
1110 if (block < journal->j_tail) in __jbd2_update_log_tail()
1111 freed += journal->j_last - journal->j_first; in __jbd2_update_log_tail()
1113 trace_jbd2_update_log_tail(journal, tid, block, freed); in __jbd2_update_log_tail()
1115 "Cleaning journal tail from %u to %u (offset %lu), " in __jbd2_update_log_tail()
1117 journal->j_tail_sequence, tid, block, freed); in __jbd2_update_log_tail()
1119 journal->j_free += freed; in __jbd2_update_log_tail()
1120 journal->j_tail_sequence = tid; in __jbd2_update_log_tail()
1121 journal->j_tail = block; in __jbd2_update_log_tail()
1122 write_unlock(&journal->j_state_lock); in __jbd2_update_log_tail()
1133 void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block) in jbd2_update_log_tail() argument
1135 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_update_log_tail()
1136 if (tid_gt(tid, journal->j_tail_sequence)) in jbd2_update_log_tail()
1137 __jbd2_update_log_tail(journal, tid, block); in jbd2_update_log_tail()
1138 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_update_log_tail()
1142 journal_t *journal; member
1168 s->journal->j_max_transaction_buffers); in jbd2_seq_info_show()
1186 div_u64(s->journal->j_average_commit_time, 1000)); in jbd2_seq_info_show()
1209 journal_t *journal = pde_data(inode); in jbd2_seq_info_open() local
1222 spin_lock(&journal->j_history_lock); in jbd2_seq_info_open()
1223 memcpy(s->stats, &journal->j_stats, size); in jbd2_seq_info_open()
1224 s->journal = journal; in jbd2_seq_info_open()
1225 spin_unlock(&journal->j_history_lock); in jbd2_seq_info_open()
1257 static void jbd2_stats_proc_init(journal_t *journal) in jbd2_stats_proc_init() argument
1259 journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats); in jbd2_stats_proc_init()
1260 if (journal->j_proc_entry) { in jbd2_stats_proc_init()
1261 proc_create_data("info", S_IRUGO, journal->j_proc_entry, in jbd2_stats_proc_init()
1262 &jbd2_info_proc_ops, journal); in jbd2_stats_proc_init()
1266 static void jbd2_stats_proc_exit(journal_t *journal) in jbd2_stats_proc_exit() argument
1268 remove_proc_entry("info", journal->j_proc_entry); in jbd2_stats_proc_exit()
1269 remove_proc_entry(journal->j_devname, proc_jbd2_stats); in jbd2_stats_proc_exit()
1293 journal_t *journal = container_of(shrink, journal_t, j_shrinker); in jbd2_journal_shrink_scan() local
1298 count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); in jbd2_journal_shrink_scan()
1299 trace_jbd2_shrink_scan_enter(journal, sc->nr_to_scan, count); in jbd2_journal_shrink_scan()
1301 nr_shrunk = jbd2_journal_shrink_checkpoint_list(journal, &nr_to_scan); in jbd2_journal_shrink_scan()
1303 count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); in jbd2_journal_shrink_scan()
1304 trace_jbd2_shrink_scan_exit(journal, nr_to_scan, nr_shrunk, count); in jbd2_journal_shrink_scan()
1319 journal_t *journal = container_of(shrink, journal_t, j_shrinker); in jbd2_journal_shrink_count() local
1322 count = percpu_counter_read_positive(&journal->j_checkpoint_jh_count); in jbd2_journal_shrink_count()
1323 trace_jbd2_shrink_count(journal, sc->nr_to_scan, count); in jbd2_journal_shrink_count()
1329 * If the journal init or create aborts, we need to mark the journal
1330 * superblock as being NULL to prevent the journal destroy from writing
1333 static void journal_fail_superblock(journal_t *journal) in journal_fail_superblock() argument
1335 struct buffer_head *bh = journal->j_sb_buffer; in journal_fail_superblock()
1337 journal->j_sb_buffer = NULL; in journal_fail_superblock()
1341 * Check the superblock for a given journal, performing initial
1344 static int journal_check_superblock(journal_t *journal) in journal_check_superblock() argument
1346 journal_superblock_t *sb = journal->j_superblock; in journal_check_superblock()
1351 sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) { in journal_check_superblock()
1352 printk(KERN_WARNING "JBD2: no valid journal superblock found\n"); in journal_check_superblock()
1362 if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) { in journal_check_superblock()
1363 printk(KERN_WARNING "JBD2: journal file too short\n"); in journal_check_superblock()
1368 be32_to_cpu(sb->s_first) >= journal->j_total_len) { in journal_check_superblock()
1370 "JBD2: Invalid start block of journal: %u\n", in journal_check_superblock()
1379 if (!jbd2_format_support_feature(journal)) in journal_check_superblock()
1386 printk(KERN_WARNING "JBD2: Unrecognised features on journal\n"); in journal_check_superblock()
1390 num_fc_blks = jbd2_has_feature_fast_commit(journal) ? in journal_check_superblock()
1394 printk(KERN_ERR "JBD2: journal file too short %u,%d\n", in journal_check_superblock()
1399 if (jbd2_has_feature_csum2(journal) && in journal_check_superblock()
1400 jbd2_has_feature_csum3(journal)) { in journal_check_superblock()
1407 if (jbd2_journal_has_csum_v2or3_feature(journal) && in journal_check_superblock()
1408 jbd2_has_feature_checksum(journal)) { in journal_check_superblock()
1416 if (jbd2_journal_has_csum_v2or3_feature(journal)) { in journal_check_superblock()
1422 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); in journal_check_superblock()
1423 if (IS_ERR(journal->j_chksum_driver)) { in journal_check_superblock()
1425 err = PTR_ERR(journal->j_chksum_driver); in journal_check_superblock()
1426 journal->j_chksum_driver = NULL; in journal_check_superblock()
1430 if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) { in journal_check_superblock()
1431 printk(KERN_ERR "JBD2: journal checksum error\n"); in journal_check_superblock()
1440 static int journal_revoke_records_per_block(journal_t *journal) in journal_revoke_records_per_block() argument
1443 int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t); in journal_revoke_records_per_block()
1445 if (jbd2_has_feature_64bit(journal)) in journal_revoke_records_per_block()
1450 if (jbd2_journal_has_csum_v2or3(journal)) in journal_revoke_records_per_block()
1455 static int jbd2_journal_get_max_txn_bufs(journal_t *journal) in jbd2_journal_get_max_txn_bufs() argument
1457 return (journal->j_total_len - journal->j_fc_wbufsize) / 4; in jbd2_journal_get_max_txn_bufs()
1463 static int jbd2_descriptor_blocks_per_trans(journal_t *journal) in jbd2_descriptor_blocks_per_trans() argument
1465 int tag_space = journal->j_blocksize - sizeof(journal_header_t); in jbd2_descriptor_blocks_per_trans()
1470 if (jbd2_journal_has_csum_v2or3(journal)) in jbd2_descriptor_blocks_per_trans()
1473 tags_per_block = (tag_space - 16) / journal_tag_bytes(journal); in jbd2_descriptor_blocks_per_trans()
1478 return 1 + DIV_ROUND_UP(jbd2_journal_get_max_txn_bufs(journal), in jbd2_descriptor_blocks_per_trans()
1485 * after the journal size and the fastcommit area size are initialized.
1487 static void jbd2_journal_init_transaction_limits(journal_t *journal) in jbd2_journal_init_transaction_limits() argument
1489 journal->j_revoke_records_per_block = in jbd2_journal_init_transaction_limits()
1490 journal_revoke_records_per_block(journal); in jbd2_journal_init_transaction_limits()
1491 journal->j_transaction_overhead_buffers = in jbd2_journal_init_transaction_limits()
1492 jbd2_descriptor_blocks_per_trans(journal); in jbd2_journal_init_transaction_limits()
1493 journal->j_max_transaction_buffers = in jbd2_journal_init_transaction_limits()
1494 jbd2_journal_get_max_txn_bufs(journal); in jbd2_journal_init_transaction_limits()
1498 * Load the on-disk journal superblock and read the key fields into the
1501 static int journal_load_superblock(journal_t *journal) in journal_load_superblock() argument
1507 bh = getblk_unmovable(journal->j_dev, journal->j_blk_offset, in journal_load_superblock()
1508 journal->j_blocksize); in journal_load_superblock()
1512 pr_err("%s: Cannot read journal superblock\n", __func__); in journal_load_superblock()
1517 journal->j_sb_buffer = bh; in journal_load_superblock()
1519 journal->j_superblock = sb; in journal_load_superblock()
1520 err = journal_check_superblock(journal); in journal_load_superblock()
1522 journal_fail_superblock(journal); in journal_load_superblock()
1526 journal->j_tail_sequence = be32_to_cpu(sb->s_sequence); in journal_load_superblock()
1527 journal->j_tail = be32_to_cpu(sb->s_start); in journal_load_superblock()
1528 journal->j_first = be32_to_cpu(sb->s_first); in journal_load_superblock()
1529 journal->j_errno = be32_to_cpu(sb->s_errno); in journal_load_superblock()
1530 journal->j_last = be32_to_cpu(sb->s_maxlen); in journal_load_superblock()
1532 if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len) in journal_load_superblock()
1533 journal->j_total_len = be32_to_cpu(sb->s_maxlen); in journal_load_superblock()
1535 if (jbd2_journal_has_csum_v2or3(journal)) in journal_load_superblock()
1536 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, in journal_load_superblock()
1538 /* After journal features are set, we can compute transaction limits */ in journal_load_superblock()
1539 jbd2_journal_init_transaction_limits(journal); in journal_load_superblock()
1541 if (jbd2_has_feature_fast_commit(journal)) { in journal_load_superblock()
1542 journal->j_fc_last = be32_to_cpu(sb->s_maxlen); in journal_load_superblock()
1543 journal->j_last = journal->j_fc_last - in journal_load_superblock()
1545 journal->j_fc_first = journal->j_last + 1; in journal_load_superblock()
1546 journal->j_fc_off = 0; in journal_load_superblock()
1554 * Management for journal control blocks: functions to create and
1556 * journal blocks from disk. */
1560 * journal structures from from scratch, or loaded them from disk. */
1567 journal_t *journal; in journal_init_common() local
1571 journal = kzalloc(sizeof(*journal), GFP_KERNEL); in journal_init_common()
1572 if (!journal) in journal_init_common()
1575 journal->j_blocksize = blocksize; in journal_init_common()
1576 journal->j_dev = bdev; in journal_init_common()
1577 journal->j_fs_dev = fs_dev; in journal_init_common()
1578 journal->j_blk_offset = start; in journal_init_common()
1579 journal->j_total_len = len; in journal_init_common()
1581 err = journal_load_superblock(journal); in journal_init_common()
1585 init_waitqueue_head(&journal->j_wait_transaction_locked); in journal_init_common()
1586 init_waitqueue_head(&journal->j_wait_done_commit); in journal_init_common()
1587 init_waitqueue_head(&journal->j_wait_commit); in journal_init_common()
1588 init_waitqueue_head(&journal->j_wait_updates); in journal_init_common()
1589 init_waitqueue_head(&journal->j_wait_reserved); in journal_init_common()
1590 init_waitqueue_head(&journal->j_fc_wait); in journal_init_common()
1591 mutex_init(&journal->j_abort_mutex); in journal_init_common()
1592 mutex_init(&journal->j_barrier); in journal_init_common()
1593 mutex_init(&journal->j_checkpoint_mutex); in journal_init_common()
1594 spin_lock_init(&journal->j_revoke_lock); in journal_init_common()
1595 spin_lock_init(&journal->j_list_lock); in journal_init_common()
1596 spin_lock_init(&journal->j_history_lock); in journal_init_common()
1597 rwlock_init(&journal->j_state_lock); in journal_init_common()
1599 journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE); in journal_init_common()
1600 journal->j_min_batch_time = 0; in journal_init_common()
1601 journal->j_max_batch_time = 15000; /* 15ms */ in journal_init_common()
1602 atomic_set(&journal->j_reserved_credits, 0); in journal_init_common()
1603 lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle", in journal_init_common()
1606 /* The journal is marked for error until we succeed with recovery! */ in journal_init_common()
1607 journal->j_flags = JBD2_ABORT; in journal_init_common()
1610 err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH); in journal_init_common()
1615 * journal descriptor can store up to n blocks, we need enough in journal_init_common()
1619 n = journal->j_blocksize / jbd2_min_tag_size(); in journal_init_common()
1620 journal->j_wbufsize = n; in journal_init_common()
1621 journal->j_fc_wbuf = NULL; in journal_init_common()
1622 journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *), in journal_init_common()
1624 if (!journal->j_wbuf) in journal_init_common()
1627 err = percpu_counter_init(&journal->j_checkpoint_jh_count, 0, in journal_init_common()
1632 journal->j_shrink_transaction = NULL; in journal_init_common()
1633 journal->j_shrinker.scan_objects = jbd2_journal_shrink_scan; in journal_init_common()
1634 journal->j_shrinker.count_objects = jbd2_journal_shrink_count; in journal_init_common()
1635 journal->j_shrinker.seeks = DEFAULT_SEEKS; in journal_init_common()
1636 journal->j_shrinker.batch = journal->j_max_transaction_buffers; in journal_init_common()
1637 err = register_shrinker(&journal->j_shrinker, "jbd2-journal:(%u:%u)", in journal_init_common()
1642 return journal; in journal_init_common()
1645 percpu_counter_destroy(&journal->j_checkpoint_jh_count); in journal_init_common()
1646 if (journal->j_chksum_driver) in journal_init_common()
1647 crypto_free_shash(journal->j_chksum_driver); in journal_init_common()
1648 kfree(journal->j_wbuf); in journal_init_common()
1649 jbd2_journal_destroy_revoke(journal); in journal_init_common()
1650 journal_fail_superblock(journal); in journal_init_common()
1651 kfree(journal); in journal_init_common()
1657 * Create a journal structure assigned some fixed set of disk blocks to
1658 * the journal. We don't actually touch those disk blocks yet, but we
1660 * system where the journal blocks are.
1665 * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
1666 * @bdev: Block device on which to create the journal
1667 * @fs_dev: Device which hold journalled filesystem for this journal.
1668 * @start: Block nr Start of journal.
1669 * @len: Length of the journal in blocks.
1674 * jbd2_journal_init_dev creates a journal which maps a fixed contiguous
1682 journal_t *journal; in jbd2_journal_init_dev() local
1684 journal = journal_init_common(bdev, fs_dev, start, len, blocksize); in jbd2_journal_init_dev()
1685 if (IS_ERR(journal)) in jbd2_journal_init_dev()
1686 return ERR_CAST(journal); in jbd2_journal_init_dev()
1688 snprintf(journal->j_devname, sizeof(journal->j_devname), in jbd2_journal_init_dev()
1689 "%pg", journal->j_dev); in jbd2_journal_init_dev()
1690 strreplace(journal->j_devname, '/', '!'); in jbd2_journal_init_dev()
1691 jbd2_stats_proc_init(journal); in jbd2_journal_init_dev()
1693 return journal; in jbd2_journal_init_dev()
1697 * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
1698 * @inode: An inode to create the journal in
1700 * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
1701 * the journal. The inode must exist already, must support bmap() and
1706 journal_t *journal; in jbd2_journal_init_inode() local
1713 pr_err("%s: Cannot locate journal superblock\n", __func__); in jbd2_journal_init_inode()
1721 journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev, in jbd2_journal_init_inode()
1724 if (IS_ERR(journal)) in jbd2_journal_init_inode()
1725 return ERR_CAST(journal); in jbd2_journal_init_inode()
1727 journal->j_inode = inode; in jbd2_journal_init_inode()
1728 snprintf(journal->j_devname, sizeof(journal->j_devname), in jbd2_journal_init_inode()
1729 "%pg-%lu", journal->j_dev, journal->j_inode->i_ino); in jbd2_journal_init_inode()
1730 strreplace(journal->j_devname, '/', '!'); in jbd2_journal_init_inode()
1731 jbd2_stats_proc_init(journal); in jbd2_journal_init_inode()
1733 return journal; in jbd2_journal_init_inode()
1739 * a journal, and after recovering an old journal to reset it for
1743 static int journal_reset(journal_t *journal) in journal_reset() argument
1745 journal_superblock_t *sb = journal->j_superblock; in journal_reset()
1751 printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n", in journal_reset()
1753 journal_fail_superblock(journal); in journal_reset()
1757 journal->j_first = first; in journal_reset()
1758 journal->j_last = last; in journal_reset()
1760 if (journal->j_head != 0 && journal->j_flags & JBD2_CYCLE_RECORD) { in journal_reset()
1762 * Disable the cycled recording mode if the journal head block in journal_reset()
1765 if (journal->j_head < first || journal->j_head >= last) { in journal_reset()
1766 printk(KERN_WARNING "JBD2: Incorrect Journal head block %lu, " in journal_reset()
1768 journal->j_head); in journal_reset()
1769 journal->j_head = journal->j_first; in journal_reset()
1772 journal->j_head = journal->j_first; in journal_reset()
1774 journal->j_tail = journal->j_head; in journal_reset()
1775 journal->j_free = journal->j_last - journal->j_first; in journal_reset()
1777 journal->j_tail_sequence = journal->j_transaction_sequence; in journal_reset()
1778 journal->j_commit_sequence = journal->j_transaction_sequence - 1; in journal_reset()
1779 journal->j_commit_request = journal->j_commit_sequence; in journal_reset()
1782 * Now that journal recovery is done, turn fast commits off here. This in journal_reset()
1786 jbd2_clear_feature_fast_commit(journal); in journal_reset()
1797 journal->j_tail, journal->j_tail_sequence, in journal_reset()
1798 journal->j_errno); in journal_reset()
1799 journal->j_flags |= JBD2_FLUSHED; in journal_reset()
1802 mutex_lock_io(&journal->j_checkpoint_mutex); in journal_reset()
1805 * transaction will start reusing journal space and so we in journal_reset()
1809 jbd2_journal_update_sb_log_tail(journal, in journal_reset()
1810 journal->j_tail_sequence, in journal_reset()
1811 journal->j_tail, REQ_FUA); in journal_reset()
1812 mutex_unlock(&journal->j_checkpoint_mutex); in journal_reset()
1814 return jbd2_journal_start_thread(journal); in journal_reset()
1818 * This function expects that the caller will have locked the journal
1821 static int jbd2_write_superblock(journal_t *journal, blk_opf_t write_flags) in jbd2_write_superblock() argument
1823 struct buffer_head *bh = journal->j_sb_buffer; in jbd2_write_superblock()
1824 journal_superblock_t *sb = journal->j_superblock; in jbd2_write_superblock()
1838 if (!(journal->j_flags & JBD2_BARRIER)) in jbd2_write_superblock()
1841 trace_jbd2_write_superblock(journal, write_flags); in jbd2_write_superblock()
1845 * Oh, dear. A previous attempt to write the journal in jbd2_write_superblock()
1853 "for journal superblock update for %s.\n", in jbd2_write_superblock()
1854 journal->j_devname); in jbd2_write_superblock()
1858 if (jbd2_journal_has_csum_v2or3(journal)) in jbd2_write_superblock()
1859 sb->s_checksum = jbd2_superblock_csum(journal, sb); in jbd2_write_superblock()
1870 printk(KERN_ERR "JBD2: I/O error when updating journal superblock for %s.\n", in jbd2_write_superblock()
1871 journal->j_devname); in jbd2_write_superblock()
1872 if (!is_journal_aborted(journal)) in jbd2_write_superblock()
1873 jbd2_journal_abort(journal, ret); in jbd2_write_superblock()
1880 * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
1881 * @journal: The journal to update.
1884 * @write_flags: Flags for the journal sb write operation
1886 * Update a journal's superblock information about log tail and write it to
1889 int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid, in jbd2_journal_update_sb_log_tail() argument
1893 journal_superblock_t *sb = journal->j_superblock; in jbd2_journal_update_sb_log_tail()
1896 if (is_journal_aborted(journal)) in jbd2_journal_update_sb_log_tail()
1898 if (test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) { in jbd2_journal_update_sb_log_tail()
1899 jbd2_journal_abort(journal, -EIO); in jbd2_journal_update_sb_log_tail()
1903 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); in jbd2_journal_update_sb_log_tail()
1907 lock_buffer(journal->j_sb_buffer); in jbd2_journal_update_sb_log_tail()
1911 ret = jbd2_write_superblock(journal, write_flags); in jbd2_journal_update_sb_log_tail()
1916 write_lock(&journal->j_state_lock); in jbd2_journal_update_sb_log_tail()
1918 journal->j_flags &= ~JBD2_FLUSHED; in jbd2_journal_update_sb_log_tail()
1919 write_unlock(&journal->j_state_lock); in jbd2_journal_update_sb_log_tail()
1926 * jbd2_mark_journal_empty() - Mark on disk journal as empty.
1927 * @journal: The journal to update.
1928 * @write_flags: Flags for the journal sb write operation
1930 * Update a journal's dynamic superblock fields to show that journal is empty.
1933 static void jbd2_mark_journal_empty(journal_t *journal, blk_opf_t write_flags) in jbd2_mark_journal_empty() argument
1935 journal_superblock_t *sb = journal->j_superblock; in jbd2_mark_journal_empty()
1938 BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex)); in jbd2_mark_journal_empty()
1939 lock_buffer(journal->j_sb_buffer); in jbd2_mark_journal_empty()
1941 unlock_buffer(journal->j_sb_buffer); in jbd2_mark_journal_empty()
1945 jbd2_debug(1, "JBD2: Marking journal as empty (seq %u)\n", in jbd2_mark_journal_empty()
1946 journal->j_tail_sequence); in jbd2_mark_journal_empty()
1948 sb->s_sequence = cpu_to_be32(journal->j_tail_sequence); in jbd2_mark_journal_empty()
1950 sb->s_head = cpu_to_be32(journal->j_head); in jbd2_mark_journal_empty()
1951 if (jbd2_has_feature_fast_commit(journal)) { in jbd2_mark_journal_empty()
1953 * When journal is clean, no need to commit fast commit flag and in jbd2_mark_journal_empty()
1956 jbd2_clear_feature_fast_commit(journal); in jbd2_mark_journal_empty()
1960 jbd2_write_superblock(journal, write_flags); in jbd2_mark_journal_empty()
1963 jbd2_set_feature_fast_commit(journal); in jbd2_mark_journal_empty()
1966 write_lock(&journal->j_state_lock); in jbd2_mark_journal_empty()
1967 journal->j_flags |= JBD2_FLUSHED; in jbd2_mark_journal_empty()
1968 write_unlock(&journal->j_state_lock); in jbd2_mark_journal_empty()
1972 * __jbd2_journal_erase() - Discard or zeroout journal blocks (excluding superblock)
1973 * @journal: The journal to erase.
1975 * region of the journal. Either JBD2_JOURNAL_FLUSH_DISCARD or
1983 static int __jbd2_journal_erase(journal_t *journal, unsigned int flags) in __jbd2_journal_erase() argument
1997 !bdev_max_discard_sectors(journal->j_dev)) in __jbd2_journal_erase()
2004 log_offset = be32_to_cpu(journal->j_superblock->s_first); in __jbd2_journal_erase()
2006 for (block = log_offset; block < journal->j_total_len; block++) { in __jbd2_journal_erase()
2007 err = jbd2_journal_bmap(journal, block, &phys_block); in __jbd2_journal_erase()
2028 * if this isn't the last block of journal, in __jbd2_journal_erase()
2032 if (block != journal->j_total_len - 1) in __jbd2_journal_erase()
2037 * end of contiguous region or this is last block of journal, in __jbd2_journal_erase()
2040 byte_start = block_start * journal->j_blocksize; in __jbd2_journal_erase()
2041 byte_stop = block_stop * journal->j_blocksize; in __jbd2_journal_erase()
2043 journal->j_blocksize; in __jbd2_journal_erase()
2045 truncate_inode_pages_range(journal->j_dev->bd_inode->i_mapping, in __jbd2_journal_erase()
2049 err = blkdev_issue_discard(journal->j_dev, in __jbd2_journal_erase()
2054 err = blkdev_issue_zeroout(journal->j_dev, in __jbd2_journal_erase()
2061 pr_err("JBD2: (error %d) unable to wipe journal at physical blocks %llu - %llu", in __jbd2_journal_erase()
2070 return blkdev_issue_flush(journal->j_dev); in __jbd2_journal_erase()
2074 * jbd2_journal_update_sb_errno() - Update error in the journal.
2075 * @journal: The journal to update.
2077 * Update a journal's errno. Write updated superblock to disk waiting for IO
2080 void jbd2_journal_update_sb_errno(journal_t *journal) in jbd2_journal_update_sb_errno() argument
2082 journal_superblock_t *sb = journal->j_superblock; in jbd2_journal_update_sb_errno()
2085 lock_buffer(journal->j_sb_buffer); in jbd2_journal_update_sb_errno()
2086 errcode = journal->j_errno; in jbd2_journal_update_sb_errno()
2092 jbd2_write_superblock(journal, REQ_FUA); in jbd2_journal_update_sb_errno()
2097 * jbd2_journal_load() - Read journal from disk.
2098 * @journal: Journal to act on.
2101 * a journal, read the journal from disk to initialise the in-memory
2104 int jbd2_journal_load(journal_t *journal) in jbd2_journal_load() argument
2107 journal_superblock_t *sb = journal->j_superblock; in jbd2_journal_load()
2117 * data from the journal. */ in jbd2_journal_load()
2118 err = jbd2_journal_recover(journal); in jbd2_journal_load()
2120 pr_warn("JBD2: journal recovery failed\n"); in jbd2_journal_load()
2124 if (journal->j_failed_commit) { in jbd2_journal_load()
2125 printk(KERN_ERR "JBD2: journal transaction %u on %s " in jbd2_journal_load()
2126 "is corrupt.\n", journal->j_failed_commit, in jbd2_journal_load()
2127 journal->j_devname); in jbd2_journal_load()
2134 journal->j_flags &= ~JBD2_ABORT; in jbd2_journal_load()
2136 /* OK, we've finished with the dynamic journal bits: in jbd2_journal_load()
2139 err = journal_reset(journal); in jbd2_journal_load()
2141 pr_warn("JBD2: journal reset failed\n"); in jbd2_journal_load()
2145 journal->j_flags |= JBD2_LOADED; in jbd2_journal_load()
2151 * @journal: Journal to act on.
2155 * Return <0 if we couldn't clean up the journal.
2157 int jbd2_journal_destroy(journal_t *journal) in jbd2_journal_destroy() argument
2162 journal_kill_thread(journal); in jbd2_journal_destroy()
2165 if (journal->j_running_transaction) in jbd2_journal_destroy()
2166 jbd2_journal_commit_transaction(journal); in jbd2_journal_destroy()
2171 spin_lock(&journal->j_list_lock); in jbd2_journal_destroy()
2172 while (journal->j_checkpoint_transactions != NULL) { in jbd2_journal_destroy()
2173 spin_unlock(&journal->j_list_lock); in jbd2_journal_destroy()
2174 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_journal_destroy()
2175 err = jbd2_log_do_checkpoint(journal); in jbd2_journal_destroy()
2176 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_destroy()
2182 jbd2_journal_destroy_checkpoint(journal); in jbd2_journal_destroy()
2183 spin_lock(&journal->j_list_lock); in jbd2_journal_destroy()
2186 spin_lock(&journal->j_list_lock); in jbd2_journal_destroy()
2189 J_ASSERT(journal->j_running_transaction == NULL); in jbd2_journal_destroy()
2190 J_ASSERT(journal->j_committing_transaction == NULL); in jbd2_journal_destroy()
2191 J_ASSERT(journal->j_checkpoint_transactions == NULL); in jbd2_journal_destroy()
2192 spin_unlock(&journal->j_list_lock); in jbd2_journal_destroy()
2196 * write out io error flag and abort the journal if some buffer failed in jbd2_journal_destroy()
2200 if (!is_journal_aborted(journal) && in jbd2_journal_destroy()
2201 test_bit(JBD2_CHECKPOINT_IO_ERROR, &journal->j_atomic_flags)) in jbd2_journal_destroy()
2202 jbd2_journal_abort(journal, -EIO); in jbd2_journal_destroy()
2204 if (journal->j_sb_buffer) { in jbd2_journal_destroy()
2205 if (!is_journal_aborted(journal)) { in jbd2_journal_destroy()
2206 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_journal_destroy()
2208 write_lock(&journal->j_state_lock); in jbd2_journal_destroy()
2209 journal->j_tail_sequence = in jbd2_journal_destroy()
2210 ++journal->j_transaction_sequence; in jbd2_journal_destroy()
2211 write_unlock(&journal->j_state_lock); in jbd2_journal_destroy()
2213 jbd2_mark_journal_empty(journal, REQ_PREFLUSH | REQ_FUA); in jbd2_journal_destroy()
2214 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_destroy()
2217 brelse(journal->j_sb_buffer); in jbd2_journal_destroy()
2220 if (journal->j_shrinker.flags & SHRINKER_REGISTERED) { in jbd2_journal_destroy()
2221 percpu_counter_destroy(&journal->j_checkpoint_jh_count); in jbd2_journal_destroy()
2222 unregister_shrinker(&journal->j_shrinker); in jbd2_journal_destroy()
2224 if (journal->j_proc_entry) in jbd2_journal_destroy()
2225 jbd2_stats_proc_exit(journal); in jbd2_journal_destroy()
2226 iput(journal->j_inode); in jbd2_journal_destroy()
2227 if (journal->j_revoke) in jbd2_journal_destroy()
2228 jbd2_journal_destroy_revoke(journal); in jbd2_journal_destroy()
2229 if (journal->j_chksum_driver) in jbd2_journal_destroy()
2230 crypto_free_shash(journal->j_chksum_driver); in jbd2_journal_destroy()
2231 kfree(journal->j_fc_wbuf); in jbd2_journal_destroy()
2232 kfree(journal->j_wbuf); in jbd2_journal_destroy()
2233 kfree(journal); in jbd2_journal_destroy()
2241 * @journal: Journal to check.
2246 * Check whether the journal uses all of a given set of
2250 int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat, in jbd2_journal_check_used_features() argument
2257 if (!jbd2_format_support_feature(journal)) in jbd2_journal_check_used_features()
2260 sb = journal->j_superblock; in jbd2_journal_check_used_features()
2272 * @journal: Journal to check.
2278 * all of a given set of features on this journal. Return true
2281 int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat, in jbd2_journal_check_available_features() argument
2287 if (!jbd2_format_support_feature(journal)) in jbd2_journal_check_available_features()
2299 jbd2_journal_initialize_fast_commit(journal_t *journal) in jbd2_journal_initialize_fast_commit() argument
2301 journal_superblock_t *sb = journal->j_superblock; in jbd2_journal_initialize_fast_commit()
2305 if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS) in jbd2_journal_initialize_fast_commit()
2309 WARN_ON(journal->j_fc_wbuf != NULL); in jbd2_journal_initialize_fast_commit()
2310 journal->j_fc_wbuf = kmalloc_array(num_fc_blks, in jbd2_journal_initialize_fast_commit()
2312 if (!journal->j_fc_wbuf) in jbd2_journal_initialize_fast_commit()
2315 journal->j_fc_wbufsize = num_fc_blks; in jbd2_journal_initialize_fast_commit()
2316 journal->j_fc_last = journal->j_last; in jbd2_journal_initialize_fast_commit()
2317 journal->j_last = journal->j_fc_last - num_fc_blks; in jbd2_journal_initialize_fast_commit()
2318 journal->j_fc_first = journal->j_last + 1; in jbd2_journal_initialize_fast_commit()
2319 journal->j_fc_off = 0; in jbd2_journal_initialize_fast_commit()
2320 journal->j_free = journal->j_last - journal->j_first; in jbd2_journal_initialize_fast_commit()
2326 * jbd2_journal_set_features() - Mark a given journal feature in the superblock
2327 * @journal: Journal to act on.
2332 * Mark a given journal feature as present on the
2337 int jbd2_journal_set_features(journal_t *journal, unsigned long compat, in jbd2_journal_set_features() argument
2346 if (jbd2_journal_check_used_features(journal, compat, ro, incompat)) in jbd2_journal_set_features()
2349 if (!jbd2_journal_check_available_features(journal, compat, ro, incompat)) in jbd2_journal_set_features()
2366 sb = journal->j_superblock; in jbd2_journal_set_features()
2369 if (jbd2_journal_initialize_fast_commit(journal)) { in jbd2_journal_set_features()
2376 if ((journal->j_chksum_driver == NULL) && in jbd2_journal_set_features()
2378 journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0); in jbd2_journal_set_features()
2379 if (IS_ERR(journal->j_chksum_driver)) { in jbd2_journal_set_features()
2381 journal->j_chksum_driver = NULL; in jbd2_journal_set_features()
2385 journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid, in jbd2_journal_set_features()
2389 lock_buffer(journal->j_sb_buffer); in jbd2_journal_set_features()
2407 unlock_buffer(journal->j_sb_buffer); in jbd2_journal_set_features()
2408 jbd2_journal_init_transaction_limits(journal); in jbd2_journal_set_features()
2416 * jbd2_journal_clear_features() - Clear a given journal feature in the
2418 * @journal: Journal to act on.
2423 * Clear a given journal feature as present on the
2426 void jbd2_journal_clear_features(journal_t *journal, unsigned long compat, in jbd2_journal_clear_features() argument
2434 sb = journal->j_superblock; in jbd2_journal_clear_features()
2439 jbd2_journal_init_transaction_limits(journal); in jbd2_journal_clear_features()
2444 * jbd2_journal_flush() - Flush journal
2445 * @journal: Journal to act on.
2446 * @flags: optional operation on the journal blocks after the flush (see below)
2448 * Flush all data for a given journal to disk and empty the journal.
2451 * can be issued on the journal blocks after flushing.
2454 * JBD2_JOURNAL_FLUSH_DISCARD: issues discards for the journal blocks
2455 * JBD2_JOURNAL_FLUSH_ZEROOUT: issues zeroouts for the journal blocks
2457 int jbd2_journal_flush(journal_t *journal, unsigned int flags) in jbd2_journal_flush() argument
2462 write_lock(&journal->j_state_lock); in jbd2_journal_flush()
2465 if (journal->j_running_transaction) { in jbd2_journal_flush()
2466 transaction = journal->j_running_transaction; in jbd2_journal_flush()
2467 __jbd2_log_start_commit(journal, transaction->t_tid); in jbd2_journal_flush()
2468 } else if (journal->j_committing_transaction) in jbd2_journal_flush()
2469 transaction = journal->j_committing_transaction; in jbd2_journal_flush()
2475 write_unlock(&journal->j_state_lock); in jbd2_journal_flush()
2476 jbd2_log_wait_commit(journal, tid); in jbd2_journal_flush()
2478 write_unlock(&journal->j_state_lock); in jbd2_journal_flush()
2482 spin_lock(&journal->j_list_lock); in jbd2_journal_flush()
2483 while (!err && journal->j_checkpoint_transactions != NULL) { in jbd2_journal_flush()
2484 spin_unlock(&journal->j_list_lock); in jbd2_journal_flush()
2485 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_journal_flush()
2486 err = jbd2_log_do_checkpoint(journal); in jbd2_journal_flush()
2487 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_flush()
2488 spin_lock(&journal->j_list_lock); in jbd2_journal_flush()
2490 spin_unlock(&journal->j_list_lock); in jbd2_journal_flush()
2492 if (is_journal_aborted(journal)) in jbd2_journal_flush()
2495 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_journal_flush()
2497 err = jbd2_cleanup_journal_tail(journal); in jbd2_journal_flush()
2499 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_flush()
2505 /* Finally, mark the journal as really needing no recovery. in jbd2_journal_flush()
2508 * commits of data to the journal will restore the current in jbd2_journal_flush()
2510 jbd2_mark_journal_empty(journal, REQ_FUA); in jbd2_journal_flush()
2513 err = __jbd2_journal_erase(journal, flags); in jbd2_journal_flush()
2515 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_flush()
2516 write_lock(&journal->j_state_lock); in jbd2_journal_flush()
2517 J_ASSERT(!journal->j_running_transaction); in jbd2_journal_flush()
2518 J_ASSERT(!journal->j_committing_transaction); in jbd2_journal_flush()
2519 J_ASSERT(!journal->j_checkpoint_transactions); in jbd2_journal_flush()
2520 J_ASSERT(journal->j_head == journal->j_tail); in jbd2_journal_flush()
2521 J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence); in jbd2_journal_flush()
2522 write_unlock(&journal->j_state_lock); in jbd2_journal_flush()
2528 * jbd2_journal_wipe() - Wipe journal contents
2529 * @journal: Journal to act on.
2532 * Wipe out all of the contents of a journal, safely. This will produce
2533 * a warning if the journal contains any valid recovery information.
2536 * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
2540 int jbd2_journal_wipe(journal_t *journal, int write) in jbd2_journal_wipe() argument
2544 J_ASSERT (!(journal->j_flags & JBD2_LOADED)); in jbd2_journal_wipe()
2546 if (!journal->j_tail) in jbd2_journal_wipe()
2549 printk(KERN_WARNING "JBD2: %s recovery information on journal\n", in jbd2_journal_wipe()
2552 err = jbd2_journal_skip_recovery(journal); in jbd2_journal_wipe()
2555 mutex_lock_io(&journal->j_checkpoint_mutex); in jbd2_journal_wipe()
2556 jbd2_mark_journal_empty(journal, REQ_FUA); in jbd2_journal_wipe()
2557 mutex_unlock(&journal->j_checkpoint_mutex); in jbd2_journal_wipe()
2564 * jbd2_journal_abort () - Shutdown the journal immediately.
2565 * @journal: the journal to shutdown.
2566 * @errno: an error number to record in the journal indicating
2570 * journal (not of a single transaction). This operation cannot be
2571 * undone without closing and reopening the journal.
2577 * Journal abort has very specific semantics. Any existing dirty,
2583 * hitting the journal. Atomicity cannot be guaranteed on an aborted
2587 * Any attempt to get a new transaction handle on a journal which is in
2592 * Recursive transactions are not disturbed by journal abort until the
2596 * which will be recorded (if possible) in the journal superblock. This
2604 void jbd2_journal_abort(journal_t *journal, int errno) in jbd2_journal_abort() argument
2611 * ensure panic after the error info is written into journal's in jbd2_journal_abort()
2614 mutex_lock(&journal->j_abort_mutex); in jbd2_journal_abort()
2617 * caused by any other journal abort error is not required after in jbd2_journal_abort()
2620 write_lock(&journal->j_state_lock); in jbd2_journal_abort()
2621 if (journal->j_flags & JBD2_ABORT) { in jbd2_journal_abort()
2622 int old_errno = journal->j_errno; in jbd2_journal_abort()
2624 write_unlock(&journal->j_state_lock); in jbd2_journal_abort()
2626 journal->j_errno = errno; in jbd2_journal_abort()
2627 jbd2_journal_update_sb_errno(journal); in jbd2_journal_abort()
2629 mutex_unlock(&journal->j_abort_mutex); in jbd2_journal_abort()
2637 pr_err("Aborting journal on device %s.\n", journal->j_devname); in jbd2_journal_abort()
2639 journal->j_flags |= JBD2_ABORT; in jbd2_journal_abort()
2640 journal->j_errno = errno; in jbd2_journal_abort()
2641 transaction = journal->j_running_transaction; in jbd2_journal_abort()
2643 __jbd2_log_start_commit(journal, transaction->t_tid); in jbd2_journal_abort()
2644 write_unlock(&journal->j_state_lock); in jbd2_journal_abort()
2647 * Record errno to the journal super block, so that fsck and jbd2 in jbd2_journal_abort()
2650 jbd2_journal_update_sb_errno(journal); in jbd2_journal_abort()
2651 mutex_unlock(&journal->j_abort_mutex); in jbd2_journal_abort()
2655 * jbd2_journal_errno() - returns the journal's error state.
2656 * @journal: journal to examine.
2659 * time the journal was mounted - if the journal was stopped
2662 * If the journal has been aborted on this mount time -EROFS will
2665 int jbd2_journal_errno(journal_t *journal) in jbd2_journal_errno() argument
2669 read_lock(&journal->j_state_lock); in jbd2_journal_errno()
2670 if (journal->j_flags & JBD2_ABORT) in jbd2_journal_errno()
2673 err = journal->j_errno; in jbd2_journal_errno()
2674 read_unlock(&journal->j_state_lock); in jbd2_journal_errno()
2679 * jbd2_journal_clear_err() - clears the journal's error state
2680 * @journal: journal to act on.
2685 int jbd2_journal_clear_err(journal_t *journal) in jbd2_journal_clear_err() argument
2689 write_lock(&journal->j_state_lock); in jbd2_journal_clear_err()
2690 if (journal->j_flags & JBD2_ABORT) in jbd2_journal_clear_err()
2693 journal->j_errno = 0; in jbd2_journal_clear_err()
2694 write_unlock(&journal->j_state_lock); in jbd2_journal_clear_err()
2699 * jbd2_journal_ack_err() - Ack journal err.
2700 * @journal: journal to act on.
2705 void jbd2_journal_ack_err(journal_t *journal) in jbd2_journal_ack_err() argument
2707 write_lock(&journal->j_state_lock); in jbd2_journal_ack_err()
2708 if (journal->j_errno) in jbd2_journal_ack_err()
2709 journal->j_flags |= JBD2_ACK_ERR; in jbd2_journal_ack_err()
2710 write_unlock(&journal->j_state_lock); in jbd2_journal_ack_err()
2721 size_t journal_tag_bytes(journal_t *journal) in journal_tag_bytes() argument
2725 if (jbd2_has_feature_csum3(journal)) in journal_tag_bytes()
2730 if (jbd2_has_feature_csum2(journal)) in journal_tag_bytes()
2733 if (jbd2_has_feature_64bit(journal)) in journal_tag_bytes()
3069 void jbd2_journal_release_jbd_inode(journal_t *journal, in jbd2_journal_release_jbd_inode() argument
3072 if (!journal) in jbd2_journal_release_jbd_inode()
3075 spin_lock(&journal->j_list_lock); in jbd2_journal_release_jbd_inode()
3082 spin_unlock(&journal->j_list_lock); in jbd2_journal_release_jbd_inode()
3092 spin_unlock(&journal->j_list_lock); in jbd2_journal_release_jbd_inode()