^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1) // SPDX-License-Identifier: GPL-2.0+
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3) * linux/fs/jbd2/journal.c
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 4) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 5) * Written by Stephen C. Tweedie <sct@redhat.com>, 1998
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 6) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 7) * Copyright 1998 Red Hat corp --- All Rights Reserved
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 8) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 9) * Generic filesystem journal-writing code; part of the ext2fs
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 10) * journaling system.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 11) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 12) * This file manages journals: areas of disk reserved for logging
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 13) * transactional updates. This includes the kernel journaling thread
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 14) * which is responsible for scheduling updates to the log.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 15) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 16) * We do not actually manage the physical storage of the journal in this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 17) * file: that is left to a per-journal policy function, which allows us
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 18) * to store the journal within a filesystem-specified area for ext2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 19) * journaling (ext2 can use a reserved inode for storing the log).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 20) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 21)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 22) #include <linux/module.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 23) #include <linux/time.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 24) #include <linux/fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 25) #include <linux/jbd2.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 26) #include <linux/errno.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 27) #include <linux/slab.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 28) #include <linux/init.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 29) #include <linux/mm.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 30) #include <linux/freezer.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 31) #include <linux/pagemap.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 32) #include <linux/kthread.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 33) #include <linux/poison.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 34) #include <linux/proc_fs.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 35) #include <linux/seq_file.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 36) #include <linux/math64.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 37) #include <linux/hash.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 38) #include <linux/log2.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 39) #include <linux/vmalloc.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 40) #include <linux/backing-dev.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 41) #include <linux/bitops.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 42) #include <linux/ratelimit.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 43) #include <linux/sched/mm.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 44)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 45) #define CREATE_TRACE_POINTS
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 46) #include <trace/events/jbd2.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 47)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 48) #include <linux/uaccess.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 49) #include <asm/page.h>
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 50)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 51) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 52) ushort jbd2_journal_enable_debug __read_mostly;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 53) EXPORT_SYMBOL(jbd2_journal_enable_debug);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 54)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 55) module_param_named(jbd2_debug, jbd2_journal_enable_debug, ushort, 0644);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 56) MODULE_PARM_DESC(jbd2_debug, "Debugging level for jbd2");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 57) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 58)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 59) EXPORT_SYMBOL(jbd2_journal_extend);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 60) EXPORT_SYMBOL(jbd2_journal_stop);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 61) EXPORT_SYMBOL(jbd2_journal_lock_updates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 62) EXPORT_SYMBOL(jbd2_journal_unlock_updates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 63) EXPORT_SYMBOL(jbd2_journal_get_write_access);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 64) EXPORT_SYMBOL(jbd2_journal_get_create_access);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 65) EXPORT_SYMBOL(jbd2_journal_get_undo_access);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 66) EXPORT_SYMBOL(jbd2_journal_set_triggers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 67) EXPORT_SYMBOL(jbd2_journal_dirty_metadata);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 68) EXPORT_SYMBOL(jbd2_journal_forget);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 69) EXPORT_SYMBOL(jbd2_journal_flush);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 70) EXPORT_SYMBOL(jbd2_journal_revoke);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 71)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 72) EXPORT_SYMBOL(jbd2_journal_init_dev);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 73) EXPORT_SYMBOL(jbd2_journal_init_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 74) EXPORT_SYMBOL(jbd2_journal_check_used_features);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 75) EXPORT_SYMBOL(jbd2_journal_check_available_features);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 76) EXPORT_SYMBOL(jbd2_journal_set_features);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 77) EXPORT_SYMBOL(jbd2_journal_load);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 78) EXPORT_SYMBOL(jbd2_journal_destroy);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 79) EXPORT_SYMBOL(jbd2_journal_abort);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 80) EXPORT_SYMBOL(jbd2_journal_errno);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 81) EXPORT_SYMBOL(jbd2_journal_ack_err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 82) EXPORT_SYMBOL(jbd2_journal_clear_err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 83) EXPORT_SYMBOL(jbd2_log_wait_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 84) EXPORT_SYMBOL(jbd2_log_start_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 85) EXPORT_SYMBOL(jbd2_journal_start_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 86) EXPORT_SYMBOL(jbd2_journal_force_commit_nested);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 87) EXPORT_SYMBOL(jbd2_journal_wipe);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 88) EXPORT_SYMBOL(jbd2_journal_blocks_per_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 89) EXPORT_SYMBOL(jbd2_journal_invalidatepage);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 90) EXPORT_SYMBOL(jbd2_journal_try_to_free_buffers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 91) EXPORT_SYMBOL(jbd2_journal_force_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 92) EXPORT_SYMBOL(jbd2_journal_inode_ranged_write);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 93) EXPORT_SYMBOL(jbd2_journal_inode_ranged_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 94) EXPORT_SYMBOL(jbd2_journal_submit_inode_data_buffers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 95) EXPORT_SYMBOL(jbd2_journal_finish_inode_data_buffers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 96) EXPORT_SYMBOL(jbd2_journal_init_jbd_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 97) EXPORT_SYMBOL(jbd2_journal_release_jbd_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 98) EXPORT_SYMBOL(jbd2_journal_begin_ordered_truncate);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 99) EXPORT_SYMBOL(jbd2_inode_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 100)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 101) static int jbd2_journal_create_slab(size_t slab_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 102)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 103) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 104) void __jbd2_debug(int level, const char *file, const char *func,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 105) unsigned int line, const char *fmt, ...)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 106) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 107) struct va_format vaf;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 108) va_list args;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 109)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 110) if (level > jbd2_journal_enable_debug)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 111) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 112) va_start(args, fmt);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 113) vaf.fmt = fmt;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 114) vaf.va = &args;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 115) printk(KERN_DEBUG "%s: (%s, %u): %pV", file, func, line, &vaf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 116) va_end(args);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 117) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 118) EXPORT_SYMBOL(__jbd2_debug);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 119) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 120)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 121) /* Checksumming functions */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 122) static int jbd2_verify_csum_type(journal_t *j, journal_superblock_t *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 123) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 124) if (!jbd2_journal_has_csum_v2or3_feature(j))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 125) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 127) return sb->s_checksum_type == JBD2_CRC32C_CHKSUM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 128) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 129)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 130) static __be32 jbd2_superblock_csum(journal_t *j, journal_superblock_t *sb)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 131) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 132) __u32 csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 133) __be32 old_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 134)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 135) old_csum = sb->s_checksum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 136) sb->s_checksum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 137) csum = jbd2_chksum(j, ~0, (char *)sb, sizeof(journal_superblock_t));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 138) sb->s_checksum = old_csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 139)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 140) return cpu_to_be32(csum);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 141) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 142)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 143) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 144) * Helper function used to manage commit timeouts
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 145) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 146)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 147) static void commit_timeout(struct timer_list *t)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 148) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 149) journal_t *journal = from_timer(journal, t, j_commit_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 150)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 151) wake_up_process(journal->j_task);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 152) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 153)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 154) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 155) * kjournald2: The main thread function used to manage a logging device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 156) * journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 157) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 158) * This kernel thread is responsible for two things:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 159) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 160) * 1) COMMIT: Every so often we need to commit the current state of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 161) * filesystem to disk. The journal thread is responsible for writing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 162) * all of the metadata buffers to disk. If a fast commit is ongoing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 163) * journal thread waits until it's done and then continues from
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 164) * there on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 165) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 166) * 2) CHECKPOINT: We cannot reuse a used section of the log file until all
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 167) * of the data in that part of the log has been rewritten elsewhere on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 168) * the disk. Flushing these old buffers to reclaim space in the log is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 169) * known as checkpointing, and this thread is responsible for that job.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 170) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 171)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 172) static int kjournald2(void *arg)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 173) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 174) journal_t *journal = arg;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 175) transaction_t *transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 176)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 177) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 178) * Set up an interval timer which can be used to trigger a commit wakeup
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 179) * after the commit interval expires
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 180) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 181) timer_setup(&journal->j_commit_timer, commit_timeout, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 182)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 183) set_freezable();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 184)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 185) /* Record that the journal thread is running */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 186) journal->j_task = current;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 187) wake_up(&journal->j_wait_done_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 188)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 189) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 190) * Make sure that no allocations from this kernel thread will ever
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 191) * recurse to the fs layer because we are responsible for the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 192) * transaction commit and any fs involvement might get stuck waiting for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 193) * the trasn. commit.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 194) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 195) memalloc_nofs_save();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 196)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 197) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 198) * And now, wait forever for commit wakeup events.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 199) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 200) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 201)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 202) loop:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 203) if (journal->j_flags & JBD2_UNMOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 204) goto end_loop;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 205)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 206) jbd_debug(1, "commit_sequence=%u, commit_request=%u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 207) journal->j_commit_sequence, journal->j_commit_request);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 208)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 209) if (journal->j_commit_sequence != journal->j_commit_request) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 210) jbd_debug(1, "OK, requests differ\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 211) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 212) del_timer_sync(&journal->j_commit_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 213) jbd2_journal_commit_transaction(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 214) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 215) goto loop;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 216) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 217)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 218) wake_up(&journal->j_wait_done_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 219) if (freezing(current)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 220) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 221) * The simpler the better. Flushing journal isn't a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 222) * good idea, because that depends on threads that may
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 223) * be already stopped.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 224) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 225) jbd_debug(1, "Now suspending kjournald2\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 226) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 227) try_to_freeze();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 228) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 229) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 230) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 231) * We assume on resume that commits are already there,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 232) * so we don't sleep
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 233) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 234) DEFINE_WAIT(wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 235) int should_sleep = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 236)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 237) prepare_to_wait(&journal->j_wait_commit, &wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 238) TASK_INTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 239) if (journal->j_commit_sequence != journal->j_commit_request)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 240) should_sleep = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 241) transaction = journal->j_running_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 242) if (transaction && time_after_eq(jiffies,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 243) transaction->t_expires))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 244) should_sleep = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 245) if (journal->j_flags & JBD2_UNMOUNT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 246) should_sleep = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 247) if (should_sleep) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 248) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 249) schedule();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 250) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 251) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 252) finish_wait(&journal->j_wait_commit, &wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 253) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 254)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 255) jbd_debug(1, "kjournald2 wakes\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 256)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 257) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 258) * Were we woken up by a commit wakeup event?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 259) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 260) transaction = journal->j_running_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 261) if (transaction && time_after_eq(jiffies, transaction->t_expires)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 262) journal->j_commit_request = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 263) jbd_debug(1, "woke because of timeout\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 264) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 265) goto loop;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 266)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 267) end_loop:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 268) del_timer_sync(&journal->j_commit_timer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 269) journal->j_task = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 270) wake_up(&journal->j_wait_done_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 271) jbd_debug(1, "Journal thread exiting.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 272) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 273) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 274) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 275)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 276) static int jbd2_journal_start_thread(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 277) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 278) struct task_struct *t;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 279)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 280) t = kthread_run(kjournald2, journal, "jbd2/%s",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 281) journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 282) if (IS_ERR(t))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 283) return PTR_ERR(t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 284)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 285) wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 286) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 287) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 288)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 289) static void journal_kill_thread(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 290) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 291) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 292) journal->j_flags |= JBD2_UNMOUNT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 294) while (journal->j_task) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 295) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 296) wake_up(&journal->j_wait_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 297) wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 298) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 299) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 300) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 301) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 302)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 303) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 304) * jbd2_journal_write_metadata_buffer: write a metadata buffer to the journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 305) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 306) * Writes a metadata buffer to a given disk block. The actual IO is not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 307) * performed but a new buffer_head is constructed which labels the data
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 308) * to be written with the correct destination disk block.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 309) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 310) * Any magic-number escaping which needs to be done will cause a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 311) * copy-out here. If the buffer happens to start with the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 312) * JBD2_MAGIC_NUMBER, then we can't write it to the log directly: the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 313) * magic number is only written to the log for descripter blocks. In
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 314) * this case, we copy the data and replace the first word with 0, and we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 315) * return a result code which indicates that this buffer needs to be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 316) * marked as an escaped buffer in the corresponding log descriptor
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 317) * block. The missing word can then be restored when the block is read
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 318) * during recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 319) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 320) * If the source buffer has already been modified by a new transaction
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 321) * since we took the last commit snapshot, we use the frozen copy of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 322) * that data for IO. If we end up using the existing buffer_head's data
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 323) * for the write, then we have to make sure nobody modifies it while the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 324) * IO is in progress. do_get_write_access() handles this.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 325) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 326) * The function returns a pointer to the buffer_head to be used for IO.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 327) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 328) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 329) * Return value:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 330) * <0: Error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 331) * >=0: Finished OK
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 332) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 333) * On success:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 334) * Bit 0 set == escape performed on the data
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 335) * Bit 1 set == buffer copy-out performed (kfree the data after IO)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 336) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 337)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 338) int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 339) struct journal_head *jh_in,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 340) struct buffer_head **bh_out,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 341) sector_t blocknr)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 342) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 343) int need_copy_out = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 344) int done_copy_out = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 345) int do_escape = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 346) char *mapped_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 347) struct buffer_head *new_bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 348) struct page *new_page;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 349) unsigned int new_offset;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 350) struct buffer_head *bh_in = jh2bh(jh_in);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 351) journal_t *journal = transaction->t_journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 352)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 353) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 354) * The buffer really shouldn't be locked: only the current committing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 355) * transaction is allowed to write it, so nobody else is allowed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 356) * to do any IO.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 357) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 358) * akpm: except if we're journalling data, and write() output is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 359) * also part of a shared mapping, and another thread has
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 360) * decided to launch a writepage() against this buffer.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 361) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 362) J_ASSERT_BH(bh_in, buffer_jbddirty(bh_in));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 363)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 364) new_bh = alloc_buffer_head(GFP_NOFS|__GFP_NOFAIL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 365)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 366) /* keep subsequent assertions sane */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 367) atomic_set(&new_bh->b_count, 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 368)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 369) spin_lock(&jh_in->b_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 370) repeat:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 371) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 372) * If a new transaction has already done a buffer copy-out, then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 373) * we use that version of the data for the commit.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 374) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 375) if (jh_in->b_frozen_data) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 376) done_copy_out = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 377) new_page = virt_to_page(jh_in->b_frozen_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 378) new_offset = offset_in_page(jh_in->b_frozen_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 379) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 380) new_page = jh2bh(jh_in)->b_page;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 381) new_offset = offset_in_page(jh2bh(jh_in)->b_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 382) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 383)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 384) mapped_data = kmap_atomic(new_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 385) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 386) * Fire data frozen trigger if data already wasn't frozen. Do this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 387) * before checking for escaping, as the trigger may modify the magic
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 388) * offset. If a copy-out happens afterwards, it will have the correct
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 389) * data in the buffer.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 390) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 391) if (!done_copy_out)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 392) jbd2_buffer_frozen_trigger(jh_in, mapped_data + new_offset,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 393) jh_in->b_triggers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 394)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 395) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 396) * Check for escaping
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 397) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 398) if (*((__be32 *)(mapped_data + new_offset)) ==
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 399) cpu_to_be32(JBD2_MAGIC_NUMBER)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 400) need_copy_out = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 401) do_escape = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 402) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 403) kunmap_atomic(mapped_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 404)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 405) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 406) * Do we need to do a data copy?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 407) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 408) if (need_copy_out && !done_copy_out) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 409) char *tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 410)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 411) spin_unlock(&jh_in->b_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 412) tmp = jbd2_alloc(bh_in->b_size, GFP_NOFS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 413) if (!tmp) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 414) brelse(new_bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 415) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 416) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 417) spin_lock(&jh_in->b_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 418) if (jh_in->b_frozen_data) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 419) jbd2_free(tmp, bh_in->b_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 420) goto repeat;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 421) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 422)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 423) jh_in->b_frozen_data = tmp;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 424) mapped_data = kmap_atomic(new_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 425) memcpy(tmp, mapped_data + new_offset, bh_in->b_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 426) kunmap_atomic(mapped_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 427)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 428) new_page = virt_to_page(tmp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 429) new_offset = offset_in_page(tmp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 430) done_copy_out = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 431)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 432) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 433) * This isn't strictly necessary, as we're using frozen
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 434) * data for the escaping, but it keeps consistency with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 435) * b_frozen_data usage.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 436) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 437) jh_in->b_frozen_triggers = jh_in->b_triggers;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 438) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 439)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 440) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 441) * Did we need to do an escaping? Now we've done all the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 442) * copying, we can finally do so.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 443) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 444) if (do_escape) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 445) mapped_data = kmap_atomic(new_page);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 446) *((unsigned int *)(mapped_data + new_offset)) = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 447) kunmap_atomic(mapped_data);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 448) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 449)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 450) set_bh_page(new_bh, new_page, new_offset);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 451) new_bh->b_size = bh_in->b_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 452) new_bh->b_bdev = journal->j_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 453) new_bh->b_blocknr = blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 454) new_bh->b_private = bh_in;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 455) set_buffer_mapped(new_bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 456) set_buffer_dirty(new_bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 457)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 458) *bh_out = new_bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 459)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 460) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 461) * The to-be-written buffer needs to get moved to the io queue,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 462) * and the original buffer whose contents we are shadowing or
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 463) * copying is moved to the transaction's shadow queue.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 464) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 465) JBUFFER_TRACE(jh_in, "file as BJ_Shadow");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 466) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 467) __jbd2_journal_file_buffer(jh_in, transaction, BJ_Shadow);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 468) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 469) set_buffer_shadow(bh_in);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 470) spin_unlock(&jh_in->b_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 471)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 472) return do_escape | (done_copy_out << 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 473) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 474)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 475) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 476) * Allocation code for the journal file. Manage the space left in the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 477) * journal, so that we can begin checkpointing when appropriate.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 478) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 479)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 480) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 481) * Called with j_state_lock locked for writing.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 482) * Returns true if a transaction commit was started.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 483) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 484) int __jbd2_log_start_commit(journal_t *journal, tid_t target)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 485) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 486) /* Return if the txn has already requested to be committed */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 487) if (journal->j_commit_request == target)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 488) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 489)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 490) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 491) * The only transaction we can possibly wait upon is the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 492) * currently running transaction (if it exists). Otherwise,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 493) * the target tid must be an old one.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 494) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 495) if (journal->j_running_transaction &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 496) journal->j_running_transaction->t_tid == target) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 497) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 498) * We want a new commit: OK, mark the request and wakeup the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 499) * commit thread. We do _not_ do the commit ourselves.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 500) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 501)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 502) journal->j_commit_request = target;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 503) jbd_debug(1, "JBD2: requesting commit %u/%u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 504) journal->j_commit_request,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 505) journal->j_commit_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 506) journal->j_running_transaction->t_requested = jiffies;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 507) wake_up(&journal->j_wait_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 508) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 509) } else if (!tid_geq(journal->j_commit_request, target))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 510) /* This should never happen, but if it does, preserve
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 511) the evidence before kjournald goes into a loop and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 512) increments j_commit_sequence beyond all recognition. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 513) WARN_ONCE(1, "JBD2: bad log_start_commit: %u %u %u %u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 514) journal->j_commit_request,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 515) journal->j_commit_sequence,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 516) target, journal->j_running_transaction ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 517) journal->j_running_transaction->t_tid : 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 518) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 519) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 520)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 521) int jbd2_log_start_commit(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 522) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 523) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 524)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 525) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 526) ret = __jbd2_log_start_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 527) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 528) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 529) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 530)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 531) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 532) * Force and wait any uncommitted transactions. We can only force the running
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 533) * transaction if we don't have an active handle, otherwise, we will deadlock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 534) * Returns: <0 in case of error,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 535) * 0 if nothing to commit,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 536) * 1 if transaction was successfully committed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 537) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 538) static int __jbd2_journal_force_commit(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 539) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 540) transaction_t *transaction = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 541) tid_t tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 542) int need_to_start = 0, ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 543)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 544) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 545) if (journal->j_running_transaction && !current->journal_info) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 546) transaction = journal->j_running_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 547) if (!tid_geq(journal->j_commit_request, transaction->t_tid))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 548) need_to_start = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 549) } else if (journal->j_committing_transaction)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 550) transaction = journal->j_committing_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 551)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 552) if (!transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 553) /* Nothing to commit */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 554) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 555) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 556) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 557) tid = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 558) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 559) if (need_to_start)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 560) jbd2_log_start_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 561) ret = jbd2_log_wait_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 562) if (!ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 563) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 565) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 566) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 567)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 568) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 569) * jbd2_journal_force_commit_nested - Force and wait upon a commit if the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 570) * calling process is not within transaction.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 571) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 572) * @journal: journal to force
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 573) * Returns true if progress was made.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 574) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 575) * This is used for forcing out undo-protected data which contains
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 576) * bitmaps, when the fs is running out of space.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 577) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 578) int jbd2_journal_force_commit_nested(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 579) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 580) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 581)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 582) ret = __jbd2_journal_force_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 583) return ret > 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 584) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 585)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 586) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 587) * jbd2_journal_force_commit() - force any uncommitted transactions
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 588) * @journal: journal to force
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 589) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 590) * Caller want unconditional commit. We can only force the running transaction
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 591) * if we don't have an active handle, otherwise, we will deadlock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 592) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 593) int jbd2_journal_force_commit(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 594) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 595) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 596)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 597) J_ASSERT(!current->journal_info);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 598) ret = __jbd2_journal_force_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 599) if (ret > 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 600) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 601) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 602) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 603)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 604) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 605) * Start a commit of the current running transaction (if any). Returns true
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 606) * if a transaction is going to be committed (or is currently already
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 607) * committing), and fills its tid in at *ptid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 608) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 609) int jbd2_journal_start_commit(journal_t *journal, tid_t *ptid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 610) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 611) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 612)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 613) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 614) if (journal->j_running_transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 615) tid_t tid = journal->j_running_transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 616)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 617) __jbd2_log_start_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 618) /* There's a running transaction and we've just made sure
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 619) * it's commit has been scheduled. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 620) if (ptid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 621) *ptid = tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 622) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 623) } else if (journal->j_committing_transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 624) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 625) * If commit has been started, then we have to wait for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 626) * completion of that transaction.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 627) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 628) if (ptid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 629) *ptid = journal->j_committing_transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 630) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 631) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 632) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 633) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 634) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 635)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 636) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 637) * Return 1 if a given transaction has not yet sent barrier request
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 638) * connected with a transaction commit. If 0 is returned, transaction
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 639) * may or may not have sent the barrier. Used to avoid sending barrier
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 640) * twice in common cases.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 641) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 642) int jbd2_trans_will_send_data_barrier(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 643) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 644) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 645) transaction_t *commit_trans;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 646)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 647) if (!(journal->j_flags & JBD2_BARRIER))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 648) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 649) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 650) /* Transaction already committed? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 651) if (tid_geq(journal->j_commit_sequence, tid))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 652) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 653) commit_trans = journal->j_committing_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 654) if (!commit_trans || commit_trans->t_tid != tid) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 655) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 656) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 657) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 658) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 659) * Transaction is being committed and we already proceeded to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 660) * submitting a flush to fs partition?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 661) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 662) if (journal->j_fs_dev != journal->j_dev) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 663) if (!commit_trans->t_need_data_flush ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 664) commit_trans->t_state >= T_COMMIT_DFLUSH)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 665) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 666) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 667) if (commit_trans->t_state >= T_COMMIT_JFLUSH)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 668) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 669) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 670) ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 671) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 672) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 673) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 674) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 675) EXPORT_SYMBOL(jbd2_trans_will_send_data_barrier);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 676)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 677) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 678) * Wait for a specified commit to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 679) * The caller may not hold the journal lock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 680) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 681) int jbd2_log_wait_commit(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 682) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 683) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 684)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 685) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 686) #ifdef CONFIG_PROVE_LOCKING
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 687) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 688) * Some callers make sure transaction is already committing and in that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 689) * case we cannot block on open handles anymore. So don't warn in that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 690) * case.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 691) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 692) if (tid_gt(tid, journal->j_commit_sequence) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 693) (!journal->j_committing_transaction ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 694) journal->j_committing_transaction->t_tid != tid)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 695) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 696) jbd2_might_wait_for_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 697) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 698) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 699) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 700) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 701) if (!tid_geq(journal->j_commit_request, tid)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 702) printk(KERN_ERR
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 703) "%s: error: j_commit_request=%u, tid=%u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 704) __func__, journal->j_commit_request, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 705) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 706) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 707) while (tid_gt(tid, journal->j_commit_sequence)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 708) jbd_debug(1, "JBD2: want %u, j_commit_sequence=%u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 709) tid, journal->j_commit_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 710) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 711) wake_up(&journal->j_wait_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 712) wait_event(journal->j_wait_done_commit,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 713) !tid_gt(tid, journal->j_commit_sequence));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 714) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 715) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 716) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 717)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 718) if (unlikely(is_journal_aborted(journal)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 719) err = -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 720) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 721) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 722)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 723) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 724) * Start a fast commit. If there's an ongoing fast or full commit wait for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 725) * it to complete. Returns 0 if a new fast commit was started. Returns -EALREADY
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 726) * if a fast commit is not needed, either because there's an already a commit
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 727) * going on or this tid has already been committed. Returns -EINVAL if no jbd2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 728) * commit has yet been performed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 729) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 730) int jbd2_fc_begin_commit(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 731) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 732) if (unlikely(is_journal_aborted(journal)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 733) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 734) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 735) * Fast commits only allowed if at least one full commit has
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 736) * been processed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 737) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 738) if (!journal->j_stats.ts_tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 739) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 740)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 741) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 742) if (tid <= journal->j_commit_sequence) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 743) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 744) return -EALREADY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 745) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 746)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 747) if (journal->j_flags & JBD2_FULL_COMMIT_ONGOING ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 748) (journal->j_flags & JBD2_FAST_COMMIT_ONGOING)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 749) DEFINE_WAIT(wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 751) prepare_to_wait(&journal->j_fc_wait, &wait,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 752) TASK_UNINTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 753) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 754) schedule();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 755) finish_wait(&journal->j_fc_wait, &wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 756) return -EALREADY;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 757) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 758) journal->j_flags |= JBD2_FAST_COMMIT_ONGOING;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 759) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 760)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 761) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 762) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 763) EXPORT_SYMBOL(jbd2_fc_begin_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 764)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 765) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 766) * Stop a fast commit. If fallback is set, this function starts commit of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 767) * TID tid before any other fast commit can start.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 768) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 769) static int __jbd2_fc_end_commit(journal_t *journal, tid_t tid, bool fallback)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 770) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 771) if (journal->j_fc_cleanup_callback)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 772) journal->j_fc_cleanup_callback(journal, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 773) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 774) journal->j_flags &= ~JBD2_FAST_COMMIT_ONGOING;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 775) if (fallback)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 776) journal->j_flags |= JBD2_FULL_COMMIT_ONGOING;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 777) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 778) wake_up(&journal->j_fc_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 779) if (fallback)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 780) return jbd2_complete_transaction(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 781) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 782) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 783)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 784) int jbd2_fc_end_commit(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 785) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 786) return __jbd2_fc_end_commit(journal, 0, false);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 787) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 788) EXPORT_SYMBOL(jbd2_fc_end_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 789)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 790) int jbd2_fc_end_commit_fallback(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 791) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 792) tid_t tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 793)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 794) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 795) tid = journal->j_running_transaction ?
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 796) journal->j_running_transaction->t_tid : 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 797) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 798) return __jbd2_fc_end_commit(journal, tid, true);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 799) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 800) EXPORT_SYMBOL(jbd2_fc_end_commit_fallback);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 801)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 802) /* Return 1 when transaction with given tid has already committed. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 803) int jbd2_transaction_committed(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 804) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 805) int ret = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 806)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 807) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 808) if (journal->j_running_transaction &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 809) journal->j_running_transaction->t_tid == tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 810) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 811) if (journal->j_committing_transaction &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 812) journal->j_committing_transaction->t_tid == tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 813) ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 814) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 815) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 816) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 817) EXPORT_SYMBOL(jbd2_transaction_committed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 818)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 819) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 820) * When this function returns the transaction corresponding to tid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 821) * will be completed. If the transaction has currently running, start
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 822) * committing that transaction before waiting for it to complete. If
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 823) * the transaction id is stale, it is by definition already completed,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 824) * so just return SUCCESS.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 825) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 826) int jbd2_complete_transaction(journal_t *journal, tid_t tid)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 827) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 828) int need_to_wait = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 829)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 830) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 831) if (journal->j_running_transaction &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 832) journal->j_running_transaction->t_tid == tid) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 833) if (journal->j_commit_request != tid) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 834) /* transaction not yet started, so request it */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 835) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 836) jbd2_log_start_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 837) goto wait_commit;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 838) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 839) } else if (!(journal->j_committing_transaction &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 840) journal->j_committing_transaction->t_tid == tid))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 841) need_to_wait = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 842) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 843) if (!need_to_wait)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 844) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 845) wait_commit:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 846) return jbd2_log_wait_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 847) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 848) EXPORT_SYMBOL(jbd2_complete_transaction);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 849)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 850) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 851) * Log buffer allocation routines:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 852) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 853)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 854) int jbd2_journal_next_log_block(journal_t *journal, unsigned long long *retp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 855) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 856) unsigned long blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 857)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 858) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 859) J_ASSERT(journal->j_free > 1);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 860)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 861) blocknr = journal->j_head;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 862) journal->j_head++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 863) journal->j_free--;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 864) if (journal->j_head == journal->j_last)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 865) journal->j_head = journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 866) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 867) return jbd2_journal_bmap(journal, blocknr, retp);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 868) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 869)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 870) /* Map one fast commit buffer for use by the file system */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 871) int jbd2_fc_get_buf(journal_t *journal, struct buffer_head **bh_out)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 872) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 873) unsigned long long pblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 874) unsigned long blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 875) int ret = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 876) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 877) int fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 878)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 879) *bh_out = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 880)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 881) if (journal->j_fc_off + journal->j_fc_first < journal->j_fc_last) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 882) fc_off = journal->j_fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 883) blocknr = journal->j_fc_first + fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 884) journal->j_fc_off++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 885) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 886) ret = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 887) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 888)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 889) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 890) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 891)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 892) ret = jbd2_journal_bmap(journal, blocknr, &pblock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 893) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 894) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 895)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 896) bh = __getblk(journal->j_dev, pblock, journal->j_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 897) if (!bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 898) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 899)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 900)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 901) journal->j_fc_wbuf[fc_off] = bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 902)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 903) *bh_out = bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 904)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 905) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 906) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 907) EXPORT_SYMBOL(jbd2_fc_get_buf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 908)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 909) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 910) * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 911) * for completion.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 912) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 913) int jbd2_fc_wait_bufs(journal_t *journal, int num_blks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 914) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 915) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 916) int i, j_fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 917)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 918) j_fc_off = journal->j_fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 919)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 920) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 921) * Wait in reverse order to minimize chances of us being woken up before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 922) * all IOs have completed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 923) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 924) for (i = j_fc_off - 1; i >= j_fc_off - num_blks; i--) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 925) bh = journal->j_fc_wbuf[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 926) wait_on_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 927) put_bh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 928) journal->j_fc_wbuf[i] = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 929) if (unlikely(!buffer_uptodate(bh)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 930) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 931) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 932)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 933) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 934) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 935) EXPORT_SYMBOL(jbd2_fc_wait_bufs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 936)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 937) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 938) * Wait on fast commit buffers that were allocated by jbd2_fc_get_buf
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 939) * for completion.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 940) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 941) int jbd2_fc_release_bufs(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 942) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 943) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 944) int i, j_fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 945)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 946) j_fc_off = journal->j_fc_off;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 947)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 948) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 949) * Wait in reverse order to minimize chances of us being woken up before
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 950) * all IOs have completed
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 951) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 952) for (i = j_fc_off - 1; i >= 0; i--) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 953) bh = journal->j_fc_wbuf[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 954) if (!bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 955) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 956) put_bh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 957) journal->j_fc_wbuf[i] = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 958) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 959)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 960) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 961) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 962) EXPORT_SYMBOL(jbd2_fc_release_bufs);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 963)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 964) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 965) * Conversion of logical to physical block numbers for the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 966) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 967) * On external journals the journal blocks are identity-mapped, so
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 968) * this is a no-op. If needed, we can use j_blk_offset - everything is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 969) * ready.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 970) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 971) int jbd2_journal_bmap(journal_t *journal, unsigned long blocknr,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 972) unsigned long long *retp)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 973) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 974) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 975) unsigned long long ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 976) sector_t block = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 977)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 978) if (journal->j_inode) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 979) block = blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 980) ret = bmap(journal->j_inode, &block);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 981)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 982) if (ret || !block) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 983) printk(KERN_ALERT "%s: journal block not found "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 984) "at offset %lu on %s\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 985) __func__, blocknr, journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 986) err = -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 987) jbd2_journal_abort(journal, err);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 988) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 989) *retp = block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 990) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 991)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 992) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 993) *retp = blocknr; /* +journal->j_blk_offset */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 994) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 995) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 996) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 997)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 998) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 999) * We play buffer_head aliasing tricks to write data/metadata blocks to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1000) * the journal without copying their contents, but for journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1001) * descriptor blocks we do need to generate bona fide buffers.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1002) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1003) * After the caller of jbd2_journal_get_descriptor_buffer() has finished modifying
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1004) * the buffer's contents they really should run flush_dcache_page(bh->b_page).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1005) * But we don't bother doing that, so there will be coherency problems with
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1006) * mmaps of blockdevs which hold live JBD-controlled filesystems.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1007) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1008) struct buffer_head *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1009) jbd2_journal_get_descriptor_buffer(transaction_t *transaction, int type)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1010) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1011) journal_t *journal = transaction->t_journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1012) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1013) unsigned long long blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1014) journal_header_t *header;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1015) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1016)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1017) err = jbd2_journal_next_log_block(journal, &blocknr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1018)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1019) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1020) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1021)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1022) bh = __getblk(journal->j_dev, blocknr, journal->j_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1023) if (!bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1024) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1025) atomic_dec(&transaction->t_outstanding_credits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1026) lock_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1027) memset(bh->b_data, 0, journal->j_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1028) header = (journal_header_t *)bh->b_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1029) header->h_magic = cpu_to_be32(JBD2_MAGIC_NUMBER);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1030) header->h_blocktype = cpu_to_be32(type);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1031) header->h_sequence = cpu_to_be32(transaction->t_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1032) set_buffer_uptodate(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1033) unlock_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1034) BUFFER_TRACE(bh, "return this buffer");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1035) return bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1036) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1037)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1038) void jbd2_descriptor_block_csum_set(journal_t *j, struct buffer_head *bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1039) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1040) struct jbd2_journal_block_tail *tail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1041) __u32 csum;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1043) if (!jbd2_journal_has_csum_v2or3(j))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1044) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1045)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1046) tail = (struct jbd2_journal_block_tail *)(bh->b_data + j->j_blocksize -
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1047) sizeof(struct jbd2_journal_block_tail));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1048) tail->t_checksum = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1049) csum = jbd2_chksum(j, j->j_csum_seed, bh->b_data, j->j_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1050) tail->t_checksum = cpu_to_be32(csum);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1051) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1052)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1053) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1054) * Return tid of the oldest transaction in the journal and block in the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1055) * where the transaction starts.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1056) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1057) * If the journal is now empty, return which will be the next transaction ID
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1058) * we will write and where will that transaction start.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1059) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1060) * The return value is 0 if journal tail cannot be pushed any further, 1 if
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1061) * it can.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1062) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1063) int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1064) unsigned long *block)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1065) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1066) transaction_t *transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1067) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1068)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1069) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1070) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1071) transaction = journal->j_checkpoint_transactions;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1072) if (transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1073) *tid = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1074) *block = transaction->t_log_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1075) } else if ((transaction = journal->j_committing_transaction) != NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1076) *tid = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1077) *block = transaction->t_log_start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1078) } else if ((transaction = journal->j_running_transaction) != NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1079) *tid = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1080) *block = journal->j_head;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1081) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1082) *tid = journal->j_transaction_sequence;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1083) *block = journal->j_head;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1084) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1085) ret = tid_gt(*tid, journal->j_tail_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1086) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1087) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1088)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1089) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1090) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1091)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1092) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1093) * Update information in journal structure and in on disk journal superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1094) * about log tail. This function does not check whether information passed in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1095) * really pushes log tail further. It's responsibility of the caller to make
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1096) * sure provided log tail information is valid (e.g. by holding
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1097) * j_checkpoint_mutex all the time between computing log tail and calling this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1098) * function as is the case with jbd2_cleanup_journal_tail()).
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1099) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1100) * Requires j_checkpoint_mutex
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1101) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1102) int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1103) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1104) unsigned long freed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1105) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1106)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1107) BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1108)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1109) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1110) * We cannot afford for write to remain in drive's caches since as
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1111) * soon as we update j_tail, next transaction can start reusing journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1112) * space and if we lose sb update during power failure we'd replay
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1113) * old transaction with possibly newly overwritten data.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1114) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1115) ret = jbd2_journal_update_sb_log_tail(journal, tid, block,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1116) REQ_SYNC | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1117) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1118) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1119)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1120) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1121) freed = block - journal->j_tail;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1122) if (block < journal->j_tail)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1123) freed += journal->j_last - journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1124)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1125) trace_jbd2_update_log_tail(journal, tid, block, freed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1126) jbd_debug(1,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1127) "Cleaning journal tail from %u to %u (offset %lu), "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1128) "freeing %lu\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1129) journal->j_tail_sequence, tid, block, freed);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1130)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1131) journal->j_free += freed;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1132) journal->j_tail_sequence = tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1133) journal->j_tail = block;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1134) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1135)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1136) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1137) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1138) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1139)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1140) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1141) * This is a variation of __jbd2_update_log_tail which checks for validity of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1142) * provided log tail and locks j_checkpoint_mutex. So it is safe against races
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1143) * with other threads updating log tail.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1144) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1145) void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1146) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1147) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1148) if (tid_gt(tid, journal->j_tail_sequence))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1149) __jbd2_update_log_tail(journal, tid, block);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1150) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1151) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1152)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1153) struct jbd2_stats_proc_session {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1154) journal_t *journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1155) struct transaction_stats_s *stats;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1156) int start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1157) int max;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1158) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1159)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1160) static void *jbd2_seq_info_start(struct seq_file *seq, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1161) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1162) return *pos ? NULL : SEQ_START_TOKEN;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1163) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1164)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1165) static void *jbd2_seq_info_next(struct seq_file *seq, void *v, loff_t *pos)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1166) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1167) (*pos)++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1168) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1169) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1171) static int jbd2_seq_info_show(struct seq_file *seq, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1172) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1173) struct jbd2_stats_proc_session *s = seq->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1174)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1175) if (v != SEQ_START_TOKEN)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1176) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1177) seq_printf(seq, "%lu transactions (%lu requested), "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1178) "each up to %u blocks\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1179) s->stats->ts_tid, s->stats->ts_requested,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1180) s->journal->j_max_transaction_buffers);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1181) if (s->stats->ts_tid == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1182) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1183) seq_printf(seq, "average: \n %ums waiting for transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1184) jiffies_to_msecs(s->stats->run.rs_wait / s->stats->ts_tid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1185) seq_printf(seq, " %ums request delay\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1186) (s->stats->ts_requested == 0) ? 0 :
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1187) jiffies_to_msecs(s->stats->run.rs_request_delay /
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1188) s->stats->ts_requested));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1189) seq_printf(seq, " %ums running transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1190) jiffies_to_msecs(s->stats->run.rs_running / s->stats->ts_tid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1191) seq_printf(seq, " %ums transaction was being locked\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1192) jiffies_to_msecs(s->stats->run.rs_locked / s->stats->ts_tid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1193) seq_printf(seq, " %ums flushing data (in ordered mode)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1194) jiffies_to_msecs(s->stats->run.rs_flushing / s->stats->ts_tid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1195) seq_printf(seq, " %ums logging transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1196) jiffies_to_msecs(s->stats->run.rs_logging / s->stats->ts_tid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1197) seq_printf(seq, " %lluus average transaction commit time\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1198) div_u64(s->journal->j_average_commit_time, 1000));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1199) seq_printf(seq, " %lu handles per transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1200) s->stats->run.rs_handle_count / s->stats->ts_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1201) seq_printf(seq, " %lu blocks per transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1202) s->stats->run.rs_blocks / s->stats->ts_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1203) seq_printf(seq, " %lu logged blocks per transaction\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1204) s->stats->run.rs_blocks_logged / s->stats->ts_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1205) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1206) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1207)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1208) static void jbd2_seq_info_stop(struct seq_file *seq, void *v)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1209) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1210) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1211)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1212) static const struct seq_operations jbd2_seq_info_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1213) .start = jbd2_seq_info_start,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1214) .next = jbd2_seq_info_next,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1215) .stop = jbd2_seq_info_stop,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1216) .show = jbd2_seq_info_show,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1217) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1218)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1219) static int jbd2_seq_info_open(struct inode *inode, struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1220) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1221) journal_t *journal = PDE_DATA(inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1222) struct jbd2_stats_proc_session *s;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1223) int rc, size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1224)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1225) s = kmalloc(sizeof(*s), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1226) if (s == NULL)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1227) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1228) size = sizeof(struct transaction_stats_s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1229) s->stats = kmalloc(size, GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1230) if (s->stats == NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1231) kfree(s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1232) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1233) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1234) spin_lock(&journal->j_history_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1235) memcpy(s->stats, &journal->j_stats, size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1236) s->journal = journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1237) spin_unlock(&journal->j_history_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1238)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1239) rc = seq_open(file, &jbd2_seq_info_ops);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1240) if (rc == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1241) struct seq_file *m = file->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1242) m->private = s;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1243) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1244) kfree(s->stats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1245) kfree(s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1246) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1247) return rc;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1248)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1249) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1250)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1251) static int jbd2_seq_info_release(struct inode *inode, struct file *file)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1252) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1253) struct seq_file *seq = file->private_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1254) struct jbd2_stats_proc_session *s = seq->private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1255) kfree(s->stats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1256) kfree(s);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1257) return seq_release(inode, file);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1258) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1259)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1260) static const struct proc_ops jbd2_info_proc_ops = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1261) .proc_open = jbd2_seq_info_open,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1262) .proc_read = seq_read,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1263) .proc_lseek = seq_lseek,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1264) .proc_release = jbd2_seq_info_release,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1265) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1266)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1267) static struct proc_dir_entry *proc_jbd2_stats;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1268)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1269) static void jbd2_stats_proc_init(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1270) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1271) journal->j_proc_entry = proc_mkdir(journal->j_devname, proc_jbd2_stats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1272) if (journal->j_proc_entry) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1273) proc_create_data("info", S_IRUGO, journal->j_proc_entry,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1274) &jbd2_info_proc_ops, journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1275) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1276) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1277)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1278) static void jbd2_stats_proc_exit(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1279) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1280) remove_proc_entry("info", journal->j_proc_entry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1281) remove_proc_entry(journal->j_devname, proc_jbd2_stats);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1282) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1283)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1284) /* Minimum size of descriptor tag */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1285) static int jbd2_min_tag_size(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1286) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1287) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1288) * Tag with 32-bit block numbers does not use last four bytes of the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1289) * structure
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1290) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1291) return sizeof(journal_block_tag_t) - 4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1292) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1294) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1295) * Management for journal control blocks: functions to create and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1296) * destroy journal_t structures, and to initialise and read existing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1297) * journal blocks from disk. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1298)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1299) /* First: create and setup a journal_t object in memory. We initialise
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1300) * very few fields yet: that has to wait until we have created the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1301) * journal structures from from scratch, or loaded them from disk. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1302)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1303) static journal_t *journal_init_common(struct block_device *bdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1304) struct block_device *fs_dev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1305) unsigned long long start, int len, int blocksize)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1306) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1307) static struct lock_class_key jbd2_trans_commit_key;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1308) journal_t *journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1309) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1310) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1311) int n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1312)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1313) journal = kzalloc(sizeof(*journal), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1314) if (!journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1315) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1316)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1317) init_waitqueue_head(&journal->j_wait_transaction_locked);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1318) init_waitqueue_head(&journal->j_wait_done_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1319) init_waitqueue_head(&journal->j_wait_commit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1320) init_waitqueue_head(&journal->j_wait_updates);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1321) init_waitqueue_head(&journal->j_wait_reserved);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1322) init_waitqueue_head(&journal->j_fc_wait);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1323) mutex_init(&journal->j_abort_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1324) mutex_init(&journal->j_barrier);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1325) mutex_init(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1326) spin_lock_init(&journal->j_revoke_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1327) spin_lock_init(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1328) rwlock_init(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1329)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1330) journal->j_commit_interval = (HZ * JBD2_DEFAULT_MAX_COMMIT_AGE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1331) journal->j_min_batch_time = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1332) journal->j_max_batch_time = 15000; /* 15ms */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1333) atomic_set(&journal->j_reserved_credits, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1334)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1335) /* The journal is marked for error until we succeed with recovery! */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1336) journal->j_flags = JBD2_ABORT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1337)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1338) /* Set up a default-sized revoke table for the new mount. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1339) err = jbd2_journal_init_revoke(journal, JOURNAL_REVOKE_DEFAULT_HASH);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1340) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1341) goto err_cleanup;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1342)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1343) spin_lock_init(&journal->j_history_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1344)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1345) lockdep_init_map(&journal->j_trans_commit_map, "jbd2_handle",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1346) &jbd2_trans_commit_key, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1347)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1348) /* journal descriptor can store up to n blocks -bzzz */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1349) journal->j_blocksize = blocksize;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1350) journal->j_dev = bdev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1351) journal->j_fs_dev = fs_dev;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1352) journal->j_blk_offset = start;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1353) journal->j_total_len = len;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1354) /* We need enough buffers to write out full descriptor block. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1355) n = journal->j_blocksize / jbd2_min_tag_size();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1356) journal->j_wbufsize = n;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1357) journal->j_fc_wbuf = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1358) journal->j_wbuf = kmalloc_array(n, sizeof(struct buffer_head *),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1359) GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1360) if (!journal->j_wbuf)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1361) goto err_cleanup;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1362)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1363) bh = getblk_unmovable(journal->j_dev, start, journal->j_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1364) if (!bh) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1365) pr_err("%s: Cannot get buffer for journal superblock\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1366) __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1367) goto err_cleanup;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1368) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1369) journal->j_sb_buffer = bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1370) journal->j_superblock = (journal_superblock_t *)bh->b_data;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1371)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1372) return journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1373)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1374) err_cleanup:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1375) kfree(journal->j_wbuf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1376) jbd2_journal_destroy_revoke(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1377) kfree(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1378) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1379) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1380)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1381) /* jbd2_journal_init_dev and jbd2_journal_init_inode:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1382) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1383) * Create a journal structure assigned some fixed set of disk blocks to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1384) * the journal. We don't actually touch those disk blocks yet, but we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1385) * need to set up all of the mapping information to tell the journaling
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1386) * system where the journal blocks are.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1387) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1388) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1389)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1390) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1391) * journal_t * jbd2_journal_init_dev() - creates and initialises a journal structure
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1392) * @bdev: Block device on which to create the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1393) * @fs_dev: Device which hold journalled filesystem for this journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1394) * @start: Block nr Start of journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1395) * @len: Length of the journal in blocks.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1396) * @blocksize: blocksize of journalling device
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1397) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1398) * Returns: a newly created journal_t *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1399) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1400) * jbd2_journal_init_dev creates a journal which maps a fixed contiguous
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1401) * range of blocks on an arbitrary block device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1402) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1403) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1404) journal_t *jbd2_journal_init_dev(struct block_device *bdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1405) struct block_device *fs_dev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1406) unsigned long long start, int len, int blocksize)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1407) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1408) journal_t *journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1409)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1410) journal = journal_init_common(bdev, fs_dev, start, len, blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1411) if (!journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1412) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1413)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1414) bdevname(journal->j_dev, journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1415) strreplace(journal->j_devname, '/', '!');
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1416) jbd2_stats_proc_init(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1417)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1418) return journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1419) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1420)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1421) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1422) * journal_t * jbd2_journal_init_inode () - creates a journal which maps to a inode.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1423) * @inode: An inode to create the journal in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1424) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1425) * jbd2_journal_init_inode creates a journal which maps an on-disk inode as
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1426) * the journal. The inode must exist already, must support bmap() and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1427) * must have all data blocks preallocated.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1428) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1429) journal_t *jbd2_journal_init_inode(struct inode *inode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1430) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1431) journal_t *journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1432) sector_t blocknr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1433) char *p;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1434) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1435)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1436) blocknr = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1437) err = bmap(inode, &blocknr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1438)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1439) if (err || !blocknr) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1440) pr_err("%s: Cannot locate journal superblock\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1441) __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1442) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1443) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1444)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1445) jbd_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1446) inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1447) inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1448)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1449) journal = journal_init_common(inode->i_sb->s_bdev, inode->i_sb->s_bdev,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1450) blocknr, inode->i_size >> inode->i_sb->s_blocksize_bits,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1451) inode->i_sb->s_blocksize);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1452) if (!journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1453) return NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1454)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1455) journal->j_inode = inode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1456) bdevname(journal->j_dev, journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1457) p = strreplace(journal->j_devname, '/', '!');
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1458) sprintf(p, "-%lu", journal->j_inode->i_ino);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1459) jbd2_stats_proc_init(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1460)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1461) return journal;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1462) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1463)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1464) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1465) * If the journal init or create aborts, we need to mark the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1466) * superblock as being NULL to prevent the journal destroy from writing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1467) * back a bogus superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1468) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1469) static void journal_fail_superblock(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1470) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1471) struct buffer_head *bh = journal->j_sb_buffer;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1472) brelse(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1473) journal->j_sb_buffer = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1474) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1475)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1476) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1477) * Given a journal_t structure, initialise the various fields for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1478) * startup of a new journaling session. We use this both when creating
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1479) * a journal, and after recovering an old journal to reset it for
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1480) * subsequent use.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1481) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1482)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1483) static int journal_reset(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1484) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1485) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1486) unsigned long long first, last;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1487)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1488) first = be32_to_cpu(sb->s_first);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1489) last = be32_to_cpu(sb->s_maxlen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1490) if (first + JBD2_MIN_JOURNAL_BLOCKS > last + 1) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1491) printk(KERN_ERR "JBD2: Journal too short (blocks %llu-%llu).\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1492) first, last);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1493) journal_fail_superblock(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1494) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1495) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1496)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1497) journal->j_first = first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1498) journal->j_last = last;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1499)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1500) journal->j_head = journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1501) journal->j_tail = journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1502) journal->j_free = journal->j_last - journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1503)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1504) journal->j_tail_sequence = journal->j_transaction_sequence;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1505) journal->j_commit_sequence = journal->j_transaction_sequence - 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1506) journal->j_commit_request = journal->j_commit_sequence;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1507)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1508) journal->j_max_transaction_buffers = jbd2_journal_get_max_txn_bufs(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1509)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1510) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1511) * Now that journal recovery is done, turn fast commits off here. This
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1512) * way, if fast commit was enabled before the crash but if now FS has
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1513) * disabled it, we don't enable fast commits.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1514) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1515) jbd2_clear_feature_fast_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1516)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1517) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1518) * As a special case, if the on-disk copy is already marked as needing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1519) * no recovery (s_start == 0), then we can safely defer the superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1520) * update until the next commit by setting JBD2_FLUSHED. This avoids
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1521) * attempting a write to a potential-readonly device.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1522) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1523) if (sb->s_start == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1524) jbd_debug(1, "JBD2: Skipping superblock update on recovered sb "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1525) "(start %ld, seq %u, errno %d)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1526) journal->j_tail, journal->j_tail_sequence,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1527) journal->j_errno);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1528) journal->j_flags |= JBD2_FLUSHED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1529) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1530) /* Lock here to make assertions happy... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1531) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1532) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1533) * Update log tail information. We use REQ_FUA since new
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1534) * transaction will start reusing journal space and so we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1535) * must make sure information about current log tail is on
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1536) * disk before that.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1537) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1538) jbd2_journal_update_sb_log_tail(journal,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1539) journal->j_tail_sequence,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1540) journal->j_tail,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1541) REQ_SYNC | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1542) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1543) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1544) return jbd2_journal_start_thread(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1545) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1546)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1547) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1548) * This function expects that the caller will have locked the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1549) * buffer head, and will return with it unlocked
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1550) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1551) static int jbd2_write_superblock(journal_t *journal, int write_flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1552) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1553) struct buffer_head *bh = journal->j_sb_buffer;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1554) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1555) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1556)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1557) /* Buffer got discarded which means block device got invalidated */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1558) if (!buffer_mapped(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1559) unlock_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1560) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1561) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1562)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1563) trace_jbd2_write_superblock(journal, write_flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1564) if (!(journal->j_flags & JBD2_BARRIER))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1565) write_flags &= ~(REQ_FUA | REQ_PREFLUSH);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1566) if (buffer_write_io_error(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1567) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1568) * Oh, dear. A previous attempt to write the journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1569) * superblock failed. This could happen because the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1570) * USB device was yanked out. Or it could happen to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1571) * be a transient write error and maybe the block will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1572) * be remapped. Nothing we can do but to retry the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1573) * write and hope for the best.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1574) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1575) printk(KERN_ERR "JBD2: previous I/O error detected "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1576) "for journal superblock update for %s.\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1577) journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1578) clear_buffer_write_io_error(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1579) set_buffer_uptodate(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1580) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1581) if (jbd2_journal_has_csum_v2or3(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1582) sb->s_checksum = jbd2_superblock_csum(journal, sb);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1583) get_bh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1584) bh->b_end_io = end_buffer_write_sync;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1585) ret = submit_bh(REQ_OP_WRITE, write_flags, bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1586) wait_on_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1587) if (buffer_write_io_error(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1588) clear_buffer_write_io_error(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1589) set_buffer_uptodate(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1590) ret = -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1591) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1592) if (ret) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1593) printk(KERN_ERR "JBD2: Error %d detected when updating "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1594) "journal superblock for %s.\n", ret,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1595) journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1596) if (!is_journal_aborted(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1597) jbd2_journal_abort(journal, ret);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1598) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1599)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1600) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1601) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1602)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1603) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1604) * jbd2_journal_update_sb_log_tail() - Update log tail in journal sb on disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1605) * @journal: The journal to update.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1606) * @tail_tid: TID of the new transaction at the tail of the log
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1607) * @tail_block: The first block of the transaction at the tail of the log
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1608) * @write_op: With which operation should we write the journal sb
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1609) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1610) * Update a journal's superblock information about log tail and write it to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1611) * disk, waiting for the IO to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1612) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1613) int jbd2_journal_update_sb_log_tail(journal_t *journal, tid_t tail_tid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1614) unsigned long tail_block, int write_op)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1615) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1616) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1617) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1618)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1619) if (is_journal_aborted(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1620) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1621)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1622) BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1623) jbd_debug(1, "JBD2: updating superblock (start %lu, seq %u)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1624) tail_block, tail_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1625)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1626) lock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1627) sb->s_sequence = cpu_to_be32(tail_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1628) sb->s_start = cpu_to_be32(tail_block);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1629)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1630) ret = jbd2_write_superblock(journal, write_op);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1631) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1632) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1633)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1634) /* Log is no longer empty */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1635) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1636) WARN_ON(!sb->s_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1637) journal->j_flags &= ~JBD2_FLUSHED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1638) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1639)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1640) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1641) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1642) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1643)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1644) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1645) * jbd2_mark_journal_empty() - Mark on disk journal as empty.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1646) * @journal: The journal to update.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1647) * @write_op: With which operation should we write the journal sb
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1648) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1649) * Update a journal's dynamic superblock fields to show that journal is empty.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1650) * Write updated superblock to disk waiting for IO to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1651) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1652) static void jbd2_mark_journal_empty(journal_t *journal, int write_op)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1653) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1654) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1655) bool had_fast_commit = false;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1656)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1657) BUG_ON(!mutex_is_locked(&journal->j_checkpoint_mutex));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1658) lock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1659) if (sb->s_start == 0) { /* Is it already empty? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1660) unlock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1661) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1662) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1663)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1664) jbd_debug(1, "JBD2: Marking journal as empty (seq %u)\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1665) journal->j_tail_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1666)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1667) sb->s_sequence = cpu_to_be32(journal->j_tail_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1668) sb->s_start = cpu_to_be32(0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1669) if (jbd2_has_feature_fast_commit(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1670) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1671) * When journal is clean, no need to commit fast commit flag and
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1672) * make file system incompatible with older kernels.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1673) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1674) jbd2_clear_feature_fast_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1675) had_fast_commit = true;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1676) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1677)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1678) jbd2_write_superblock(journal, write_op);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1679)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1680) if (had_fast_commit)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1681) jbd2_set_feature_fast_commit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1682)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1683) /* Log is no longer empty */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1684) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1685) journal->j_flags |= JBD2_FLUSHED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1686) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1687) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1688)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1689)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1690) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1691) * jbd2_journal_update_sb_errno() - Update error in the journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1692) * @journal: The journal to update.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1693) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1694) * Update a journal's errno. Write updated superblock to disk waiting for IO
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1695) * to complete.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1696) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1697) void jbd2_journal_update_sb_errno(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1698) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1699) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1700) int errcode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1701)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1702) lock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1703) errcode = journal->j_errno;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1704) if (errcode == -ESHUTDOWN)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1705) errcode = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1706) jbd_debug(1, "JBD2: updating superblock error (errno %d)\n", errcode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1707) sb->s_errno = cpu_to_be32(errcode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1708)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1709) jbd2_write_superblock(journal, REQ_SYNC | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1710) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1711) EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1712)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1713) static int journal_revoke_records_per_block(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1714) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1715) int record_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1716) int space = journal->j_blocksize - sizeof(jbd2_journal_revoke_header_t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1717)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1718) if (jbd2_has_feature_64bit(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1719) record_size = 8;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1720) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1721) record_size = 4;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1722)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1723) if (jbd2_journal_has_csum_v2or3(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1724) space -= sizeof(struct jbd2_journal_block_tail);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1725) return space / record_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1726) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1727)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1728) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1729) * Read the superblock for a given journal, performing initial
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1730) * validation of the format.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1731) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1732) static int journal_get_superblock(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1733) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1734) struct buffer_head *bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1735) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1736) int err = -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1737)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1738) bh = journal->j_sb_buffer;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1739)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1740) J_ASSERT(bh != NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1741) if (!buffer_uptodate(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1742) ll_rw_block(REQ_OP_READ, 0, 1, &bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1743) wait_on_buffer(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1744) if (!buffer_uptodate(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1745) printk(KERN_ERR
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1746) "JBD2: IO error reading journal superblock\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1747) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1748) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1749) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1750)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1751) if (buffer_verified(bh))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1752) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1753)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1754) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1755)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1756) err = -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1757)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1758) if (sb->s_header.h_magic != cpu_to_be32(JBD2_MAGIC_NUMBER) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1759) sb->s_blocksize != cpu_to_be32(journal->j_blocksize)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1760) printk(KERN_WARNING "JBD2: no valid journal superblock found\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1761) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1762) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1763)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1764) switch(be32_to_cpu(sb->s_header.h_blocktype)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1765) case JBD2_SUPERBLOCK_V1:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1766) journal->j_format_version = 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1767) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1768) case JBD2_SUPERBLOCK_V2:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1769) journal->j_format_version = 2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1770) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1771) default:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1772) printk(KERN_WARNING "JBD2: unrecognised superblock format ID\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1773) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1774) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1775)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1776) if (be32_to_cpu(sb->s_maxlen) < journal->j_total_len)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1777) journal->j_total_len = be32_to_cpu(sb->s_maxlen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1778) else if (be32_to_cpu(sb->s_maxlen) > journal->j_total_len) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1779) printk(KERN_WARNING "JBD2: journal file too short\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1780) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1781) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1782)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1783) if (be32_to_cpu(sb->s_first) == 0 ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1784) be32_to_cpu(sb->s_first) >= journal->j_total_len) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1785) printk(KERN_WARNING
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1786) "JBD2: Invalid start block of journal: %u\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1787) be32_to_cpu(sb->s_first));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1788) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1789) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1790)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1791) if (jbd2_has_feature_csum2(journal) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1792) jbd2_has_feature_csum3(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1793) /* Can't have checksum v2 and v3 at the same time! */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1794) printk(KERN_ERR "JBD2: Can't enable checksumming v2 and v3 "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1795) "at the same time!\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1796) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1797) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1798)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1799) if (jbd2_journal_has_csum_v2or3_feature(journal) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1800) jbd2_has_feature_checksum(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1801) /* Can't have checksum v1 and v2 on at the same time! */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1802) printk(KERN_ERR "JBD2: Can't enable checksumming v1 and v2/3 "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1803) "at the same time!\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1804) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1805) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1806)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1807) if (!jbd2_verify_csum_type(journal, sb)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1808) printk(KERN_ERR "JBD2: Unknown checksum type\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1809) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1810) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1811)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1812) /* Load the checksum driver */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1813) if (jbd2_journal_has_csum_v2or3_feature(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1814) journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1815) if (IS_ERR(journal->j_chksum_driver)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1816) printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1817) err = PTR_ERR(journal->j_chksum_driver);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1818) journal->j_chksum_driver = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1819) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1820) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1821) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1822)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1823) if (jbd2_journal_has_csum_v2or3(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1824) /* Check superblock checksum */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1825) if (sb->s_checksum != jbd2_superblock_csum(journal, sb)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1826) printk(KERN_ERR "JBD2: journal checksum error\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1827) err = -EFSBADCRC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1828) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1829) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1830)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1831) /* Precompute checksum seed for all metadata */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1832) journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1833) sizeof(sb->s_uuid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1834) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1835)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1836) journal->j_revoke_records_per_block =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1837) journal_revoke_records_per_block(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1838) set_buffer_verified(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1839)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1840) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1841)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1842) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1843) journal_fail_superblock(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1844) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1845) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1846)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1847) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1848) * Load the on-disk journal superblock and read the key fields into the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1849) * journal_t.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1850) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1851)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1852) static int load_superblock(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1853) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1854) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1855) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1856) int num_fc_blocks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1857)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1858) err = journal_get_superblock(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1859) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1860) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1861)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1862) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1863)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1864) journal->j_tail_sequence = be32_to_cpu(sb->s_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1865) journal->j_tail = be32_to_cpu(sb->s_start);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1866) journal->j_first = be32_to_cpu(sb->s_first);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1867) journal->j_errno = be32_to_cpu(sb->s_errno);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1868) journal->j_last = be32_to_cpu(sb->s_maxlen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1869)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1870) if (jbd2_has_feature_fast_commit(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1871) journal->j_fc_last = be32_to_cpu(sb->s_maxlen);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1872) num_fc_blocks = be32_to_cpu(sb->s_num_fc_blks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1873) if (!num_fc_blocks)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1874) num_fc_blocks = JBD2_MIN_FC_BLOCKS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1875) if (journal->j_last - num_fc_blocks >= JBD2_MIN_JOURNAL_BLOCKS)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1876) journal->j_last = journal->j_fc_last - num_fc_blocks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1877) journal->j_fc_first = journal->j_last + 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1878) journal->j_fc_off = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1879) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1880)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1881) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1882) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1883)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1884)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1885) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1886) * jbd2_journal_load() - Read journal from disk.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1887) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1888) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1889) * Given a journal_t structure which tells us which disk blocks contain
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1890) * a journal, read the journal from disk to initialise the in-memory
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1891) * structures.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1892) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1893) int jbd2_journal_load(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1894) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1895) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1896) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1897)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1898) err = load_superblock(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1899) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1900) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1901)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1902) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1903) /* If this is a V2 superblock, then we have to check the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1904) * features flags on it. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1905)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1906) if (journal->j_format_version >= 2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1907) if ((sb->s_feature_ro_compat &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1908) ~cpu_to_be32(JBD2_KNOWN_ROCOMPAT_FEATURES)) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1909) (sb->s_feature_incompat &
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1910) ~cpu_to_be32(JBD2_KNOWN_INCOMPAT_FEATURES))) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1911) printk(KERN_WARNING
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1912) "JBD2: Unrecognised features on journal\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1913) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1914) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1915) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1916)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1917) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1918) * Create a slab for this blocksize
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1919) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1920) err = jbd2_journal_create_slab(be32_to_cpu(sb->s_blocksize));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1921) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1922) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1923)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1924) /* Let the recovery code check whether it needs to recover any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1925) * data from the journal. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1926) if (jbd2_journal_recover(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1927) goto recovery_error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1928)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1929) if (journal->j_failed_commit) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1930) printk(KERN_ERR "JBD2: journal transaction %u on %s "
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1931) "is corrupt.\n", journal->j_failed_commit,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1932) journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1933) return -EFSCORRUPTED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1934) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1935) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1936) * clear JBD2_ABORT flag initialized in journal_init_common
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1937) * here to update log tail information with the newest seq.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1938) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1939) journal->j_flags &= ~JBD2_ABORT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1940)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1941) /* OK, we've finished with the dynamic journal bits:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1942) * reinitialise the dynamic contents of the superblock in memory
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1943) * and reset them on disk. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1944) if (journal_reset(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1945) goto recovery_error;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1946)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1947) journal->j_flags |= JBD2_LOADED;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1948) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1949)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1950) recovery_error:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1951) printk(KERN_WARNING "JBD2: recovery failed\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1952) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1953) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1954)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1955) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1956) * jbd2_journal_destroy() - Release a journal_t structure.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1957) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1958) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1959) * Release a journal_t structure once it is no longer in use by the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1960) * journaled object.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1961) * Return <0 if we couldn't clean up the journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1962) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1963) int jbd2_journal_destroy(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1964) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1965) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1966)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1967) /* Wait for the commit thread to wake up and die. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1968) journal_kill_thread(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1969)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1970) /* Force a final log commit */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1971) if (journal->j_running_transaction)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1972) jbd2_journal_commit_transaction(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1973)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1974) /* Force any old transactions to disk */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1975)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1976) /* Totally anal locking here... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1977) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1978) while (journal->j_checkpoint_transactions != NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1979) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1980) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1981) err = jbd2_log_do_checkpoint(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1982) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1983) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1984) * If checkpointing failed, just free the buffers to avoid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1985) * looping forever
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1986) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1987) if (err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1988) jbd2_journal_destroy_checkpoint(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1989) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1990) break;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1991) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1992) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1993) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1994)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1995) J_ASSERT(journal->j_running_transaction == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1996) J_ASSERT(journal->j_committing_transaction == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1997) J_ASSERT(journal->j_checkpoint_transactions == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1998) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 1999)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2000) if (journal->j_sb_buffer) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2001) if (!is_journal_aborted(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2002) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2003)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2004) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2005) journal->j_tail_sequence =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2006) ++journal->j_transaction_sequence;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2007) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2008)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2009) jbd2_mark_journal_empty(journal,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2010) REQ_SYNC | REQ_PREFLUSH | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2011) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2012) } else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2013) err = -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2014) brelse(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2015) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2016)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2017) if (journal->j_proc_entry)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2018) jbd2_stats_proc_exit(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2019) iput(journal->j_inode);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2020) if (journal->j_revoke)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2021) jbd2_journal_destroy_revoke(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2022) if (journal->j_chksum_driver)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2023) crypto_free_shash(journal->j_chksum_driver);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2024) kfree(journal->j_fc_wbuf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2025) kfree(journal->j_wbuf);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2026) kfree(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2027)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2028) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2029) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2030)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2031)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2032) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2033) * jbd2_journal_check_used_features() - Check if features specified are used.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2034) * @journal: Journal to check.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2035) * @compat: bitmask of compatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2036) * @ro: bitmask of features that force read-only mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2037) * @incompat: bitmask of incompatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2038) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2039) * Check whether the journal uses all of a given set of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2040) * features. Return true (non-zero) if it does.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2041) **/
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2042)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2043) int jbd2_journal_check_used_features(journal_t *journal, unsigned long compat,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2044) unsigned long ro, unsigned long incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2045) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2046) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2047)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2048) if (!compat && !ro && !incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2049) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2050) /* Load journal superblock if it is not loaded yet. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2051) if (journal->j_format_version == 0 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2052) journal_get_superblock(journal) != 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2053) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2054) if (journal->j_format_version == 1)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2055) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2056)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2057) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2058)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2059) if (((be32_to_cpu(sb->s_feature_compat) & compat) == compat) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2060) ((be32_to_cpu(sb->s_feature_ro_compat) & ro) == ro) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2061) ((be32_to_cpu(sb->s_feature_incompat) & incompat) == incompat))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2062) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2063)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2064) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2065) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2066)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2067) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2068) * jbd2_journal_check_available_features() - Check feature set in journalling layer
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2069) * @journal: Journal to check.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2070) * @compat: bitmask of compatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2071) * @ro: bitmask of features that force read-only mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2072) * @incompat: bitmask of incompatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2073) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2074) * Check whether the journaling code supports the use of
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2075) * all of a given set of features on this journal. Return true
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2076) * (non-zero) if it can. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2077)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2078) int jbd2_journal_check_available_features(journal_t *journal, unsigned long compat,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2079) unsigned long ro, unsigned long incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2080) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2081) if (!compat && !ro && !incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2082) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2083)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2084) /* We can support any known requested features iff the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2085) * superblock is in version 2. Otherwise we fail to support any
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2086) * extended sb features. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2087)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2088) if (journal->j_format_version != 2)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2089) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2090)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2091) if ((compat & JBD2_KNOWN_COMPAT_FEATURES) == compat &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2092) (ro & JBD2_KNOWN_ROCOMPAT_FEATURES) == ro &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2093) (incompat & JBD2_KNOWN_INCOMPAT_FEATURES) == incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2094) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2095)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2096) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2097) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2098)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2099) static int
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2100) jbd2_journal_initialize_fast_commit(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2101) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2102) journal_superblock_t *sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2103) unsigned long long num_fc_blks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2104)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2105) num_fc_blks = be32_to_cpu(sb->s_num_fc_blks);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2106) if (num_fc_blks == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2107) num_fc_blks = JBD2_MIN_FC_BLOCKS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2108) if (journal->j_last - num_fc_blks < JBD2_MIN_JOURNAL_BLOCKS)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2109) return -ENOSPC;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2110)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2111) /* Are we called twice? */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2112) WARN_ON(journal->j_fc_wbuf != NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2113) journal->j_fc_wbuf = kmalloc_array(num_fc_blks,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2114) sizeof(struct buffer_head *), GFP_KERNEL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2115) if (!journal->j_fc_wbuf)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2116) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2117)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2118) journal->j_fc_wbufsize = num_fc_blks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2119) journal->j_fc_last = journal->j_last;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2120) journal->j_last = journal->j_fc_last - num_fc_blks;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2121) journal->j_fc_first = journal->j_last + 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2122) journal->j_fc_off = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2123) journal->j_free = journal->j_last - journal->j_first;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2124) journal->j_max_transaction_buffers =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2125) jbd2_journal_get_max_txn_bufs(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2126)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2127) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2128) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2129)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2130) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2131) * jbd2_journal_set_features() - Mark a given journal feature in the superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2132) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2133) * @compat: bitmask of compatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2134) * @ro: bitmask of features that force read-only mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2135) * @incompat: bitmask of incompatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2136) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2137) * Mark a given journal feature as present on the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2138) * superblock. Returns true if the requested features could be set.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2139) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2140) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2141)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2142) int jbd2_journal_set_features(journal_t *journal, unsigned long compat,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2143) unsigned long ro, unsigned long incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2144) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2145) #define INCOMPAT_FEATURE_ON(f) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2146) ((incompat & (f)) && !(sb->s_feature_incompat & cpu_to_be32(f)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2147) #define COMPAT_FEATURE_ON(f) \
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2148) ((compat & (f)) && !(sb->s_feature_compat & cpu_to_be32(f)))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2149) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2150)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2151) if (jbd2_journal_check_used_features(journal, compat, ro, incompat))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2152) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2153)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2154) if (!jbd2_journal_check_available_features(journal, compat, ro, incompat))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2155) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2156)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2157) /* If enabling v2 checksums, turn on v3 instead */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2158) if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V2) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2159) incompat &= ~JBD2_FEATURE_INCOMPAT_CSUM_V2;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2160) incompat |= JBD2_FEATURE_INCOMPAT_CSUM_V3;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2161) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2162)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2163) /* Asking for checksumming v3 and v1? Only give them v3. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2164) if (incompat & JBD2_FEATURE_INCOMPAT_CSUM_V3 &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2165) compat & JBD2_FEATURE_COMPAT_CHECKSUM)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2166) compat &= ~JBD2_FEATURE_COMPAT_CHECKSUM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2167)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2168) jbd_debug(1, "Setting new features 0x%lx/0x%lx/0x%lx\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2169) compat, ro, incompat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2170)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2171) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2172)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2173) if (incompat & JBD2_FEATURE_INCOMPAT_FAST_COMMIT) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2174) if (jbd2_journal_initialize_fast_commit(journal)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2175) pr_err("JBD2: Cannot enable fast commits.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2176) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2177) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2178) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2179)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2180) /* Load the checksum driver if necessary */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2181) if ((journal->j_chksum_driver == NULL) &&
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2182) INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2183) journal->j_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2184) if (IS_ERR(journal->j_chksum_driver)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2185) printk(KERN_ERR "JBD2: Cannot load crc32c driver.\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2186) journal->j_chksum_driver = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2187) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2188) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2189) /* Precompute checksum seed for all metadata */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2190) journal->j_csum_seed = jbd2_chksum(journal, ~0, sb->s_uuid,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2191) sizeof(sb->s_uuid));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2192) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2193)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2194) lock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2195)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2196) /* If enabling v3 checksums, update superblock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2197) if (INCOMPAT_FEATURE_ON(JBD2_FEATURE_INCOMPAT_CSUM_V3)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2198) sb->s_checksum_type = JBD2_CRC32C_CHKSUM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2199) sb->s_feature_compat &=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2200) ~cpu_to_be32(JBD2_FEATURE_COMPAT_CHECKSUM);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2201) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2202)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2203) /* If enabling v1 checksums, downgrade superblock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2204) if (COMPAT_FEATURE_ON(JBD2_FEATURE_COMPAT_CHECKSUM))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2205) sb->s_feature_incompat &=
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2206) ~cpu_to_be32(JBD2_FEATURE_INCOMPAT_CSUM_V2 |
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2207) JBD2_FEATURE_INCOMPAT_CSUM_V3);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2208)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2209) sb->s_feature_compat |= cpu_to_be32(compat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2210) sb->s_feature_ro_compat |= cpu_to_be32(ro);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2211) sb->s_feature_incompat |= cpu_to_be32(incompat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2212) unlock_buffer(journal->j_sb_buffer);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2213) journal->j_revoke_records_per_block =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2214) journal_revoke_records_per_block(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2215)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2216) return 1;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2217) #undef COMPAT_FEATURE_ON
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2218) #undef INCOMPAT_FEATURE_ON
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2219) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2220)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2221) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2222) * jbd2_journal_clear_features() - Clear a given journal feature in the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2223) * superblock
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2224) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2225) * @compat: bitmask of compatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2226) * @ro: bitmask of features that force read-only mount
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2227) * @incompat: bitmask of incompatible features
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2228) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2229) * Clear a given journal feature as present on the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2230) * superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2231) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2232) void jbd2_journal_clear_features(journal_t *journal, unsigned long compat,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2233) unsigned long ro, unsigned long incompat)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2234) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2235) journal_superblock_t *sb;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2236)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2237) jbd_debug(1, "Clear features 0x%lx/0x%lx/0x%lx\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2238) compat, ro, incompat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2239)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2240) sb = journal->j_superblock;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2241)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2242) sb->s_feature_compat &= ~cpu_to_be32(compat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2243) sb->s_feature_ro_compat &= ~cpu_to_be32(ro);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2244) sb->s_feature_incompat &= ~cpu_to_be32(incompat);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2245) journal->j_revoke_records_per_block =
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2246) journal_revoke_records_per_block(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2247) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2248) EXPORT_SYMBOL(jbd2_journal_clear_features);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2249)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2250) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2251) * jbd2_journal_flush() - Flush journal
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2252) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2253) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2254) * Flush all data for a given journal to disk and empty the journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2255) * Filesystems can use this when remounting readonly to ensure that
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2256) * recovery does not need to happen on remount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2257) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2258)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2259) int jbd2_journal_flush(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2260) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2261) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2262) transaction_t *transaction = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2263)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2264) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2265)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2266) /* Force everything buffered to the log... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2267) if (journal->j_running_transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2268) transaction = journal->j_running_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2269) __jbd2_log_start_commit(journal, transaction->t_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2270) } else if (journal->j_committing_transaction)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2271) transaction = journal->j_committing_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2272)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2273) /* Wait for the log commit to complete... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2274) if (transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2275) tid_t tid = transaction->t_tid;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2276)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2277) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2278) jbd2_log_wait_commit(journal, tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2279) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2280) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2281) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2282)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2283) /* ...and flush everything in the log out to disk. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2284) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2285) while (!err && journal->j_checkpoint_transactions != NULL) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2286) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2287) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2288) err = jbd2_log_do_checkpoint(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2289) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2290) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2291) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2292) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2293)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2294) if (is_journal_aborted(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2295) return -EIO;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2296)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2297) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2298) if (!err) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2299) err = jbd2_cleanup_journal_tail(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2300) if (err < 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2301) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2302) goto out;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2303) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2304) err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2305) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2306)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2307) /* Finally, mark the journal as really needing no recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2308) * This sets s_start==0 in the underlying superblock, which is
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2309) * the magic code for a fully-recovered superblock. Any future
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2310) * commits of data to the journal will restore the current
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2311) * s_start value. */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2312) jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2313) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2314) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2315) J_ASSERT(!journal->j_running_transaction);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2316) J_ASSERT(!journal->j_committing_transaction);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2317) J_ASSERT(!journal->j_checkpoint_transactions);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2318) J_ASSERT(journal->j_head == journal->j_tail);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2319) J_ASSERT(journal->j_tail_sequence == journal->j_transaction_sequence);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2320) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2321) out:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2322) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2323) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2324)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2325) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2326) * jbd2_journal_wipe() - Wipe journal contents
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2327) * @journal: Journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2328) * @write: flag (see below)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2329) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2330) * Wipe out all of the contents of a journal, safely. This will produce
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2331) * a warning if the journal contains any valid recovery information.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2332) * Must be called between journal_init_*() and jbd2_journal_load().
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2333) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2334) * If 'write' is non-zero, then we wipe out the journal on disk; otherwise
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2335) * we merely suppress recovery.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2336) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2337)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2338) int jbd2_journal_wipe(journal_t *journal, int write)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2339) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2340) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2341)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2342) J_ASSERT (!(journal->j_flags & JBD2_LOADED));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2343)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2344) err = load_superblock(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2345) if (err)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2346) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2347)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2348) if (!journal->j_tail)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2349) goto no_recovery;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2350)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2351) printk(KERN_WARNING "JBD2: %s recovery information on journal\n",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2352) write ? "Clearing" : "Ignoring");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2353)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2354) err = jbd2_journal_skip_recovery(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2355) if (write) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2356) /* Lock to make assertions happy... */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2357) mutex_lock_io(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2358) jbd2_mark_journal_empty(journal, REQ_SYNC | REQ_FUA);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2359) mutex_unlock(&journal->j_checkpoint_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2360) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2361)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2362) no_recovery:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2363) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2364) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2365)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2366) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2367) * jbd2_journal_abort () - Shutdown the journal immediately.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2368) * @journal: the journal to shutdown.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2369) * @errno: an error number to record in the journal indicating
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2370) * the reason for the shutdown.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2371) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2372) * Perform a complete, immediate shutdown of the ENTIRE
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2373) * journal (not of a single transaction). This operation cannot be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2374) * undone without closing and reopening the journal.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2375) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2376) * The jbd2_journal_abort function is intended to support higher level error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2377) * recovery mechanisms such as the ext2/ext3 remount-readonly error
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2378) * mode.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2379) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2380) * Journal abort has very specific semantics. Any existing dirty,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2381) * unjournaled buffers in the main filesystem will still be written to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2382) * disk by bdflush, but the journaling mechanism will be suspended
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2383) * immediately and no further transaction commits will be honoured.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2384) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2385) * Any dirty, journaled buffers will be written back to disk without
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2386) * hitting the journal. Atomicity cannot be guaranteed on an aborted
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2387) * filesystem, but we _do_ attempt to leave as much data as possible
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2388) * behind for fsck to use for cleanup.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2389) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2390) * Any attempt to get a new transaction handle on a journal which is in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2391) * ABORT state will just result in an -EROFS error return. A
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2392) * jbd2_journal_stop on an existing handle will return -EIO if we have
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2393) * entered abort state during the update.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2394) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2395) * Recursive transactions are not disturbed by journal abort until the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2396) * final jbd2_journal_stop, which will receive the -EIO error.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2397) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2398) * Finally, the jbd2_journal_abort call allows the caller to supply an errno
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2399) * which will be recorded (if possible) in the journal superblock. This
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2400) * allows a client to record failure conditions in the middle of a
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2401) * transaction without having to complete the transaction to record the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2402) * failure to disk. ext3_error, for example, now uses this
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2403) * functionality.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2404) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2405) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2406)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2407) void jbd2_journal_abort(journal_t *journal, int errno)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2408) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2409) transaction_t *transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2410)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2411) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2412) * Lock the aborting procedure until everything is done, this avoid
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2413) * races between filesystem's error handling flow (e.g. ext4_abort()),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2414) * ensure panic after the error info is written into journal's
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2415) * superblock.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2416) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2417) mutex_lock(&journal->j_abort_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2418) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2419) * ESHUTDOWN always takes precedence because a file system check
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2420) * caused by any other journal abort error is not required after
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2421) * a shutdown triggered.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2422) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2423) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2424) if (journal->j_flags & JBD2_ABORT) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2425) int old_errno = journal->j_errno;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2426)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2427) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2428) if (old_errno != -ESHUTDOWN && errno == -ESHUTDOWN) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2429) journal->j_errno = errno;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2430) jbd2_journal_update_sb_errno(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2431) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2432) mutex_unlock(&journal->j_abort_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2433) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2434) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2435)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2436) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2437) * Mark the abort as occurred and start current running transaction
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2438) * to release all journaled buffer.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2439) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2440) pr_err("Aborting journal on device %s.\n", journal->j_devname);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2441)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2442) journal->j_flags |= JBD2_ABORT;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2443) journal->j_errno = errno;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2444) transaction = journal->j_running_transaction;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2445) if (transaction)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2446) __jbd2_log_start_commit(journal, transaction->t_tid);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2447) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2448)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2449) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2450) * Record errno to the journal super block, so that fsck and jbd2
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2451) * layer could realise that a filesystem check is needed.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2452) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2453) jbd2_journal_update_sb_errno(journal);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2454) mutex_unlock(&journal->j_abort_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2455) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2456)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2457) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2458) * jbd2_journal_errno() - returns the journal's error state.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2459) * @journal: journal to examine.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2460) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2461) * This is the errno number set with jbd2_journal_abort(), the last
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2462) * time the journal was mounted - if the journal was stopped
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2463) * without calling abort this will be 0.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2464) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2465) * If the journal has been aborted on this mount time -EROFS will
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2466) * be returned.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2467) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2468) int jbd2_journal_errno(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2469) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2470) int err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2471)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2472) read_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2473) if (journal->j_flags & JBD2_ABORT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2474) err = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2475) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2476) err = journal->j_errno;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2477) read_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2478) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2479) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2480)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2481) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2482) * jbd2_journal_clear_err() - clears the journal's error state
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2483) * @journal: journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2484) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2485) * An error must be cleared or acked to take a FS out of readonly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2486) * mode.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2487) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2488) int jbd2_journal_clear_err(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2489) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2490) int err = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2491)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2492) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2493) if (journal->j_flags & JBD2_ABORT)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2494) err = -EROFS;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2495) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2496) journal->j_errno = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2497) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2498) return err;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2499) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2500)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2501) /**
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2502) * jbd2_journal_ack_err() - Ack journal err.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2503) * @journal: journal to act on.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2504) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2505) * An error must be cleared or acked to take a FS out of readonly
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2506) * mode.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2507) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2508) void jbd2_journal_ack_err(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2509) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2510) write_lock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2511) if (journal->j_errno)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2512) journal->j_flags |= JBD2_ACK_ERR;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2513) write_unlock(&journal->j_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2514) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2515)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2516) int jbd2_journal_blocks_per_page(struct inode *inode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2517) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2518) return 1 << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2519) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2520)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2521) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2522) * helper functions to deal with 32 or 64bit block numbers.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2523) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2524) size_t journal_tag_bytes(journal_t *journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2525) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2526) size_t sz;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2527)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2528) if (jbd2_has_feature_csum3(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2529) return sizeof(journal_block_tag3_t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2530)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2531) sz = sizeof(journal_block_tag_t);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2532)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2533) if (jbd2_has_feature_csum2(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2534) sz += sizeof(__u16);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2535)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2536) if (jbd2_has_feature_64bit(journal))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2537) return sz;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2538) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2539) return sz - sizeof(__u32);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2540) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2541)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2542) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2543) * JBD memory management
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2544) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2545) * These functions are used to allocate block-sized chunks of memory
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2546) * used for making copies of buffer_head data. Very often it will be
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2547) * page-sized chunks of data, but sometimes it will be in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2548) * sub-page-size chunks. (For example, 16k pages on Power systems
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2549) * with a 4k block file system.) For blocks smaller than a page, we
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2550) * use a SLAB allocator. There are slab caches for each block size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2551) * which are allocated at mount time, if necessary, and we only free
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2552) * (all of) the slab caches when/if the jbd2 module is unloaded. For
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2553) * this reason we don't need to a mutex to protect access to
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2554) * jbd2_slab[] allocating or releasing memory; only in
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2555) * jbd2_journal_create_slab().
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2556) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2557) #define JBD2_MAX_SLABS 8
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2558) static struct kmem_cache *jbd2_slab[JBD2_MAX_SLABS];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2559)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2560) static const char *jbd2_slab_names[JBD2_MAX_SLABS] = {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2561) "jbd2_1k", "jbd2_2k", "jbd2_4k", "jbd2_8k",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2562) "jbd2_16k", "jbd2_32k", "jbd2_64k", "jbd2_128k"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2563) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2564)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2565)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2566) static void jbd2_journal_destroy_slabs(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2567) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2568) int i;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2569)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2570) for (i = 0; i < JBD2_MAX_SLABS; i++) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2571) kmem_cache_destroy(jbd2_slab[i]);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2572) jbd2_slab[i] = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2573) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2574) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2575)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2576) static int jbd2_journal_create_slab(size_t size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2577) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2578) static DEFINE_MUTEX(jbd2_slab_create_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2579) int i = order_base_2(size) - 10;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2580) size_t slab_size;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2581)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2582) if (size == PAGE_SIZE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2583) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2584)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2585) if (i >= JBD2_MAX_SLABS)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2586) return -EINVAL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2587)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2588) if (unlikely(i < 0))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2589) i = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2590) mutex_lock(&jbd2_slab_create_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2591) if (jbd2_slab[i]) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2592) mutex_unlock(&jbd2_slab_create_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2593) return 0; /* Already created */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2594) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2595)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2596) slab_size = 1 << (i+10);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2597) jbd2_slab[i] = kmem_cache_create(jbd2_slab_names[i], slab_size,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2598) slab_size, 0, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2599) mutex_unlock(&jbd2_slab_create_mutex);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2600) if (!jbd2_slab[i]) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2601) printk(KERN_EMERG "JBD2: no memory for jbd2_slab cache\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2602) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2603) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2604) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2605) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2606)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2607) static struct kmem_cache *get_slab(size_t size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2608) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2609) int i = order_base_2(size) - 10;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2610)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2611) BUG_ON(i >= JBD2_MAX_SLABS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2612) if (unlikely(i < 0))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2613) i = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2614) BUG_ON(jbd2_slab[i] == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2615) return jbd2_slab[i];
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2616) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2617)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2618) void *jbd2_alloc(size_t size, gfp_t flags)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2619) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2620) void *ptr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2621)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2622) BUG_ON(size & (size-1)); /* Must be a power of 2 */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2623)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2624) if (size < PAGE_SIZE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2625) ptr = kmem_cache_alloc(get_slab(size), flags);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2626) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2627) ptr = (void *)__get_free_pages(flags, get_order(size));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2628)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2629) /* Check alignment; SLUB has gotten this wrong in the past,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2630) * and this can lead to user data corruption! */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2631) BUG_ON(((unsigned long) ptr) & (size-1));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2632)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2633) return ptr;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2634) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2635)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2636) void jbd2_free(void *ptr, size_t size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2637) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2638) if (size < PAGE_SIZE)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2639) kmem_cache_free(get_slab(size), ptr);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2640) else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2641) free_pages((unsigned long)ptr, get_order(size));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2642) };
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2643)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2644) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2645) * Journal_head storage management
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2646) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2647) static struct kmem_cache *jbd2_journal_head_cache;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2648) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2649) static atomic_t nr_journal_heads = ATOMIC_INIT(0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2650) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2651)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2652) static int __init jbd2_journal_init_journal_head_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2653) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2654) J_ASSERT(!jbd2_journal_head_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2655) jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2656) sizeof(struct journal_head),
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2657) 0, /* offset */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2658) SLAB_TEMPORARY | SLAB_TYPESAFE_BY_RCU,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2659) NULL); /* ctor */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2660) if (!jbd2_journal_head_cache) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2661) printk(KERN_EMERG "JBD2: no memory for journal_head cache\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2662) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2663) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2664) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2665) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2666)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2667) static void jbd2_journal_destroy_journal_head_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2668) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2669) kmem_cache_destroy(jbd2_journal_head_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2670) jbd2_journal_head_cache = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2671) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2672)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2673) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2674) * journal_head splicing and dicing
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2675) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2676) static struct journal_head *journal_alloc_journal_head(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2677) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2678) struct journal_head *ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2679)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2680) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2681) atomic_inc(&nr_journal_heads);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2682) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2683) ret = kmem_cache_zalloc(jbd2_journal_head_cache, GFP_NOFS);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2684) if (!ret) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2685) jbd_debug(1, "out of memory for journal_head\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2686) pr_notice_ratelimited("ENOMEM in %s, retrying.\n", __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2687) ret = kmem_cache_zalloc(jbd2_journal_head_cache,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2688) GFP_NOFS | __GFP_NOFAIL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2689) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2690) if (ret)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2691) spin_lock_init(&ret->b_state_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2692) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2693) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2694)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2695) static void journal_free_journal_head(struct journal_head *jh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2696) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2697) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2698) atomic_dec(&nr_journal_heads);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2699) memset(jh, JBD2_POISON_FREE, sizeof(*jh));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2700) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2701) kmem_cache_free(jbd2_journal_head_cache, jh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2702) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2703)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2704) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2705) * A journal_head is attached to a buffer_head whenever JBD has an
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2706) * interest in the buffer.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2707) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2708) * Whenever a buffer has an attached journal_head, its ->b_state:BH_JBD bit
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2709) * is set. This bit is tested in core kernel code where we need to take
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2710) * JBD-specific actions. Testing the zeroness of ->b_private is not reliable
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2711) * there.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2712) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2713) * When a buffer has its BH_JBD bit set, its ->b_count is elevated by one.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2714) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2715) * When a buffer has its BH_JBD bit set it is immune from being released by
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2716) * core kernel code, mainly via ->b_count.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2717) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2718) * A journal_head is detached from its buffer_head when the journal_head's
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2719) * b_jcount reaches zero. Running transaction (b_transaction) and checkpoint
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2720) * transaction (b_cp_transaction) hold their references to b_jcount.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2721) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2722) * Various places in the kernel want to attach a journal_head to a buffer_head
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2723) * _before_ attaching the journal_head to a transaction. To protect the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2724) * journal_head in this situation, jbd2_journal_add_journal_head elevates the
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2725) * journal_head's b_jcount refcount by one. The caller must call
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2726) * jbd2_journal_put_journal_head() to undo this.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2727) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2728) * So the typical usage would be:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2729) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2730) * (Attach a journal_head if needed. Increments b_jcount)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2731) * struct journal_head *jh = jbd2_journal_add_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2732) * ...
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2733) * (Get another reference for transaction)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2734) * jbd2_journal_grab_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2735) * jh->b_transaction = xxx;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2736) * (Put original reference)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2737) * jbd2_journal_put_journal_head(jh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2738) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2739)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2740) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2741) * Give a buffer_head a journal_head.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2742) *
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2743) * May sleep.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2744) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2745) struct journal_head *jbd2_journal_add_journal_head(struct buffer_head *bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2746) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2747) struct journal_head *jh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2748) struct journal_head *new_jh = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2749)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2750) repeat:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2751) if (!buffer_jbd(bh))
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2752) new_jh = journal_alloc_journal_head();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2753)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2754) jbd_lock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2755) if (buffer_jbd(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2756) jh = bh2jh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2757) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2758) J_ASSERT_BH(bh,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2759) (atomic_read(&bh->b_count) > 0) ||
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2760) (bh->b_page && bh->b_page->mapping));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2761)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2762) if (!new_jh) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2763) jbd_unlock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2764) goto repeat;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2765) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2766)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2767) jh = new_jh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2768) new_jh = NULL; /* We consumed it */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2769) set_buffer_jbd(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2770) bh->b_private = jh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2771) jh->b_bh = bh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2772) get_bh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2773) BUFFER_TRACE(bh, "added journal_head");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2774) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2775) jh->b_jcount++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2776) jbd_unlock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2777) if (new_jh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2778) journal_free_journal_head(new_jh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2779) return bh->b_private;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2780) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2781)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2782) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2783) * Grab a ref against this buffer_head's journal_head. If it ended up not
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2784) * having a journal_head, return NULL
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2785) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2786) struct journal_head *jbd2_journal_grab_journal_head(struct buffer_head *bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2787) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2788) struct journal_head *jh = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2789)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2790) jbd_lock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2791) if (buffer_jbd(bh)) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2792) jh = bh2jh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2793) jh->b_jcount++;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2794) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2795) jbd_unlock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2796) return jh;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2797) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2798) EXPORT_SYMBOL(jbd2_journal_grab_journal_head);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2799)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2800) static void __journal_remove_journal_head(struct buffer_head *bh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2801) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2802) struct journal_head *jh = bh2jh(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2803)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2804) J_ASSERT_JH(jh, jh->b_transaction == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2805) J_ASSERT_JH(jh, jh->b_next_transaction == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2806) J_ASSERT_JH(jh, jh->b_cp_transaction == NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2807) J_ASSERT_JH(jh, jh->b_jlist == BJ_None);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2808) J_ASSERT_BH(bh, buffer_jbd(bh));
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2809) J_ASSERT_BH(bh, jh2bh(jh) == bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2810) BUFFER_TRACE(bh, "remove journal_head");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2811)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2812) /* Unlink before dropping the lock */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2813) bh->b_private = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2814) jh->b_bh = NULL; /* debug, really */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2815) clear_buffer_jbd(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2816) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2817)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2818) static void journal_release_journal_head(struct journal_head *jh, size_t b_size)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2819) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2820) if (jh->b_frozen_data) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2821) printk(KERN_WARNING "%s: freeing b_frozen_data\n", __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2822) jbd2_free(jh->b_frozen_data, b_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2823) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2824) if (jh->b_committed_data) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2825) printk(KERN_WARNING "%s: freeing b_committed_data\n", __func__);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2826) jbd2_free(jh->b_committed_data, b_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2827) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2828) journal_free_journal_head(jh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2829) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2830)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2831) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2832) * Drop a reference on the passed journal_head. If it fell to zero then
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2833) * release the journal_head from the buffer_head.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2834) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2835) void jbd2_journal_put_journal_head(struct journal_head *jh)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2836) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2837) struct buffer_head *bh = jh2bh(jh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2838)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2839) jbd_lock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2840) J_ASSERT_JH(jh, jh->b_jcount > 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2841) --jh->b_jcount;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2842) if (!jh->b_jcount) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2843) __journal_remove_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2844) jbd_unlock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2845) journal_release_journal_head(jh, bh->b_size);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2846) __brelse(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2847) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2848) jbd_unlock_bh_journal_head(bh);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2849) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2850) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2851) EXPORT_SYMBOL(jbd2_journal_put_journal_head);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2852)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2853) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2854) * Initialize jbd inode head
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2855) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2856) void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2857) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2858) jinode->i_transaction = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2859) jinode->i_next_transaction = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2860) jinode->i_vfs_inode = inode;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2861) jinode->i_flags = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2862) jinode->i_dirty_start = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2863) jinode->i_dirty_end = 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2864) INIT_LIST_HEAD(&jinode->i_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2865) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2866)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2867) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2868) * Function to be called before we start removing inode from memory (i.e.,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2869) * clear_inode() is a fine place to be called from). It removes inode from
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2870) * transaction's lists.
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2871) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2872) void jbd2_journal_release_jbd_inode(journal_t *journal,
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2873) struct jbd2_inode *jinode)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2874) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2875) if (!journal)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2876) return;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2877) restart:
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2878) spin_lock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2879) /* Is commit writing out inode - we have to wait */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2880) if (jinode->i_flags & JI_COMMIT_RUNNING) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2881) wait_queue_head_t *wq;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2882) DEFINE_WAIT_BIT(wait, &jinode->i_flags, __JI_COMMIT_RUNNING);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2883) wq = bit_waitqueue(&jinode->i_flags, __JI_COMMIT_RUNNING);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2884) prepare_to_wait(wq, &wait.wq_entry, TASK_UNINTERRUPTIBLE);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2885) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2886) schedule();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2887) finish_wait(wq, &wait.wq_entry);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2888) goto restart;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2889) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2890)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2891) if (jinode->i_transaction) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2892) list_del(&jinode->i_list);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2893) jinode->i_transaction = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2894) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2895) spin_unlock(&journal->j_list_lock);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2896) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2897)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2898)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2899) #ifdef CONFIG_PROC_FS
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2900)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2901) #define JBD2_STATS_PROC_NAME "fs/jbd2"
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2902)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2903) static void __init jbd2_create_jbd_stats_proc_entry(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2904) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2905) proc_jbd2_stats = proc_mkdir(JBD2_STATS_PROC_NAME, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2906) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2907)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2908) static void __exit jbd2_remove_jbd_stats_proc_entry(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2909) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2910) if (proc_jbd2_stats)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2911) remove_proc_entry(JBD2_STATS_PROC_NAME, NULL);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2912) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2913)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2914) #else
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2915)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2916) #define jbd2_create_jbd_stats_proc_entry() do {} while (0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2917) #define jbd2_remove_jbd_stats_proc_entry() do {} while (0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2918)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2919) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2920)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2921) struct kmem_cache *jbd2_handle_cache, *jbd2_inode_cache;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2922)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2923) static int __init jbd2_journal_init_inode_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2924) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2925) J_ASSERT(!jbd2_inode_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2926) jbd2_inode_cache = KMEM_CACHE(jbd2_inode, 0);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2927) if (!jbd2_inode_cache) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2928) pr_emerg("JBD2: failed to create inode cache\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2929) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2930) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2931) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2932) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2933)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2934) static int __init jbd2_journal_init_handle_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2935) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2936) J_ASSERT(!jbd2_handle_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2937) jbd2_handle_cache = KMEM_CACHE(jbd2_journal_handle, SLAB_TEMPORARY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2938) if (!jbd2_handle_cache) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2939) printk(KERN_EMERG "JBD2: failed to create handle cache\n");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2940) return -ENOMEM;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2941) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2942) return 0;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2943) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2944)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2945) static void jbd2_journal_destroy_inode_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2946) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2947) kmem_cache_destroy(jbd2_inode_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2948) jbd2_inode_cache = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2949) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2950)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2951) static void jbd2_journal_destroy_handle_cache(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2952) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2953) kmem_cache_destroy(jbd2_handle_cache);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2954) jbd2_handle_cache = NULL;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2955) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2956)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2957) /*
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2958) * Module startup and shutdown
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2959) */
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2960)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2961) static int __init journal_init_caches(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2962) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2963) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2964)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2965) ret = jbd2_journal_init_revoke_record_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2966) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2967) ret = jbd2_journal_init_revoke_table_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2968) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2969) ret = jbd2_journal_init_journal_head_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2970) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2971) ret = jbd2_journal_init_handle_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2972) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2973) ret = jbd2_journal_init_inode_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2974) if (ret == 0)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2975) ret = jbd2_journal_init_transaction_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2976) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2977) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2978)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2979) static void jbd2_journal_destroy_caches(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2980) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2981) jbd2_journal_destroy_revoke_record_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2982) jbd2_journal_destroy_revoke_table_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2983) jbd2_journal_destroy_journal_head_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2984) jbd2_journal_destroy_handle_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2985) jbd2_journal_destroy_inode_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2986) jbd2_journal_destroy_transaction_cache();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2987) jbd2_journal_destroy_slabs();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2988) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2989)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2990) static int __init journal_init(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2991) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2992) int ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2993)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2994) BUILD_BUG_ON(sizeof(struct journal_superblock_s) != 1024);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2995)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2996) ret = journal_init_caches();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2997) if (ret == 0) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2998) jbd2_create_jbd_stats_proc_entry();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 2999) } else {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3000) jbd2_journal_destroy_caches();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3001) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3002) return ret;
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3003) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3004)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3005) static void __exit journal_exit(void)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3006) {
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3007) #ifdef CONFIG_JBD2_DEBUG
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3008) int n = atomic_read(&nr_journal_heads);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3009) if (n)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3010) printk(KERN_ERR "JBD2: leaked %d journal_heads!\n", n);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3011) #endif
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3012) jbd2_remove_jbd_stats_proc_entry();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3013) jbd2_journal_destroy_caches();
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3014) }
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3015)
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3016) MODULE_LICENSE("GPL");
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3017) MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3018) module_init(journal_init);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3019) module_exit(journal_exit);
^8f3ce5b39 (kx 2023-10-28 12:00:06 +0300 3020)
Orange Pi5 kernel
Deprecated Linux kernel 5.10.110 for OrangePi 5/5B/5+ boards
3 Commits
0 Branches
0 Tags