1 // SPDX-License-Identifier: GPL-2.0
3 #include <linux/random.h>
4 #include <linux/buffer_head.h>
5 #include <linux/utsname.h>
6 #include <linux/kthread.h>
10 /* Checksumming functions */
11 static __le32 ext4_mmp_csum(struct super_block *sb, struct mmp_struct *mmp)
13 struct ext4_sb_info *sbi = EXT4_SB(sb);
14 int offset = offsetof(struct mmp_struct, mmp_checksum);
17 csum = ext4_chksum(sbi, sbi->s_csum_seed, (char *)mmp, offset);
19 return cpu_to_le32(csum);
22 static int ext4_mmp_csum_verify(struct super_block *sb, struct mmp_struct *mmp)
24 if (!ext4_has_metadata_csum(sb))
27 return mmp->mmp_checksum == ext4_mmp_csum(sb, mmp);
30 static void ext4_mmp_csum_set(struct super_block *sb, struct mmp_struct *mmp)
32 if (!ext4_has_metadata_csum(sb))
35 mmp->mmp_checksum = ext4_mmp_csum(sb, mmp);
39 * Write the MMP block using REQ_SYNC to try to get the block on-disk
42 static int write_mmp_block_thawed(struct super_block *sb,
43 struct buffer_head *bh)
45 struct mmp_struct *mmp = (struct mmp_struct *)(bh->b_data);
47 ext4_mmp_csum_set(sb, mmp);
49 bh->b_end_io = end_buffer_write_sync;
51 submit_bh(REQ_OP_WRITE, REQ_SYNC | REQ_META | REQ_PRIO, bh);
53 if (unlikely(!buffer_uptodate(bh)))
58 static int write_mmp_block(struct super_block *sb, struct buffer_head *bh)
63 * We protect against freezing so that we don't create dirty buffers
64 * on frozen filesystem.
67 err = write_mmp_block_thawed(sb, bh);
73 * Read the MMP block. It _must_ be read from disk and hence we clear the
74 * uptodate flag on the buffer.
76 static int read_mmp_block(struct super_block *sb, struct buffer_head **bh,
77 ext4_fsblk_t mmp_block)
79 struct mmp_struct *mmp;
83 clear_buffer_uptodate(*bh);
85 /* This would be sb_bread(sb, mmp_block), except we need to be sure
86 * that the MD RAID device cache has been bypassed, and that the read
87 * is not blocked in the elevator. */
89 *bh = sb_getblk(sb, mmp_block);
97 ret = ext4_read_bh(*bh, REQ_META | REQ_PRIO, NULL);
101 mmp = (struct mmp_struct *)((*bh)->b_data);
102 if (le32_to_cpu(mmp->mmp_magic) != EXT4_MMP_MAGIC) {
106 if (!ext4_mmp_csum_verify(sb, mmp)) {
114 ext4_warning(sb, "Error %d while reading MMP block %llu",
120 * Dump as much information as possible to help the admin.
122 void __dump_mmp_msg(struct super_block *sb, struct mmp_struct *mmp,
123 const char *function, unsigned int line, const char *msg)
125 __ext4_warning(sb, function, line, "%s", msg);
126 __ext4_warning(sb, function, line,
127 "MMP failure info: last update time: %llu, last update node: %.*s, last update device: %.*s",
128 (unsigned long long)le64_to_cpu(mmp->mmp_time),
129 (int)sizeof(mmp->mmp_nodename), mmp->mmp_nodename,
130 (int)sizeof(mmp->mmp_bdevname), mmp->mmp_bdevname);
134 * kmmpd will update the MMP sequence every s_mmp_update_interval seconds
136 static int kmmpd(void *data)
138 struct super_block *sb = (struct super_block *) data;
139 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
140 struct buffer_head *bh = EXT4_SB(sb)->s_mmp_bh;
141 struct mmp_struct *mmp;
142 ext4_fsblk_t mmp_block;
144 unsigned long failed_writes = 0;
145 int mmp_update_interval = le16_to_cpu(es->s_mmp_update_interval);
146 unsigned mmp_check_interval;
147 unsigned long last_update_time;
151 mmp_block = le64_to_cpu(es->s_mmp_block);
152 mmp = (struct mmp_struct *)(bh->b_data);
153 mmp->mmp_time = cpu_to_le64(ktime_get_real_seconds());
155 * Start with the higher mmp_check_interval and reduce it if
156 * the MMP block is being updated on time.
158 mmp_check_interval = max(EXT4_MMP_CHECK_MULT * mmp_update_interval,
159 EXT4_MMP_MIN_CHECK_INTERVAL);
160 mmp->mmp_check_interval = cpu_to_le16(mmp_check_interval);
161 BUILD_BUG_ON(sizeof(mmp->mmp_bdevname) < BDEVNAME_SIZE);
162 bdevname(bh->b_bdev, mmp->mmp_bdevname);
164 memcpy(mmp->mmp_nodename, init_utsname()->nodename,
165 sizeof(mmp->mmp_nodename));
167 while (!kthread_should_stop() && !sb_rdonly(sb)) {
168 if (!ext4_has_feature_mmp(sb)) {
169 ext4_warning(sb, "kmmpd being stopped since MMP feature"
170 " has been disabled.");
173 if (++seq > EXT4_MMP_SEQ_MAX)
176 mmp->mmp_seq = cpu_to_le32(seq);
177 mmp->mmp_time = cpu_to_le64(ktime_get_real_seconds());
178 last_update_time = jiffies;
180 retval = write_mmp_block(sb, bh);
182 * Don't spew too many error messages. Print one every
183 * (s_mmp_update_interval * 60) seconds.
186 if ((failed_writes % 60) == 0) {
187 ext4_error_err(sb, -retval,
188 "Error writing to MMP block");
193 diff = jiffies - last_update_time;
194 if (diff < mmp_update_interval * HZ)
195 schedule_timeout_interruptible(mmp_update_interval *
199 * We need to make sure that more than mmp_check_interval
200 * seconds have not passed since writing. If that has happened
201 * we need to check if the MMP block is as we left it.
203 diff = jiffies - last_update_time;
204 if (diff > mmp_check_interval * HZ) {
205 struct buffer_head *bh_check = NULL;
206 struct mmp_struct *mmp_check;
208 retval = read_mmp_block(sb, &bh_check, mmp_block);
210 ext4_error_err(sb, -retval,
211 "error reading MMP data: %d",
216 mmp_check = (struct mmp_struct *)(bh_check->b_data);
217 if (mmp->mmp_seq != mmp_check->mmp_seq ||
218 memcmp(mmp->mmp_nodename, mmp_check->mmp_nodename,
219 sizeof(mmp->mmp_nodename))) {
220 dump_mmp_msg(sb, mmp_check,
221 "Error while updating MMP info. "
222 "The filesystem seems to have been"
223 " multiply mounted.");
224 ext4_error_err(sb, EBUSY, "abort");
233 * Adjust the mmp_check_interval depending on how much time
234 * it took for the MMP block to be written.
236 mmp_check_interval = max(min(EXT4_MMP_CHECK_MULT * diff / HZ,
237 EXT4_MMP_MAX_CHECK_INTERVAL),
238 EXT4_MMP_MIN_CHECK_INTERVAL);
239 mmp->mmp_check_interval = cpu_to_le16(mmp_check_interval);
243 * Unmount seems to be clean.
245 mmp->mmp_seq = cpu_to_le32(EXT4_MMP_SEQ_CLEAN);
246 mmp->mmp_time = cpu_to_le64(ktime_get_real_seconds());
248 retval = write_mmp_block(sb, bh);
251 while (!kthread_should_stop()) {
252 set_current_state(TASK_INTERRUPTIBLE);
253 if (!kthread_should_stop())
256 set_current_state(TASK_RUNNING);
260 void ext4_stop_mmpd(struct ext4_sb_info *sbi)
262 if (sbi->s_mmp_tsk) {
263 kthread_stop(sbi->s_mmp_tsk);
264 brelse(sbi->s_mmp_bh);
265 sbi->s_mmp_tsk = NULL;
270 * Get a random new sequence number but make sure it is not greater than
273 static unsigned int mmp_new_seq(void)
278 new_seq = prandom_u32();
279 } while (new_seq > EXT4_MMP_SEQ_MAX);
285 * Protect the filesystem from being mounted more than once.
287 int ext4_multi_mount_protect(struct super_block *sb,
288 ext4_fsblk_t mmp_block)
290 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
291 struct buffer_head *bh = NULL;
292 struct mmp_struct *mmp = NULL;
294 unsigned int mmp_check_interval = le16_to_cpu(es->s_mmp_update_interval);
295 unsigned int wait_time = 0;
298 if (mmp_block < le32_to_cpu(es->s_first_data_block) ||
299 mmp_block >= ext4_blocks_count(es)) {
300 ext4_warning(sb, "Invalid MMP block in superblock");
305 retval = read_mmp_block(sb, &bh, mmp_block);
309 mmp = (struct mmp_struct *)(bh->b_data);
311 if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL)
312 mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL;
315 * If check_interval in MMP block is larger, use that instead of
316 * update_interval from the superblock.
318 if (le16_to_cpu(mmp->mmp_check_interval) > mmp_check_interval)
319 mmp_check_interval = le16_to_cpu(mmp->mmp_check_interval);
321 seq = le32_to_cpu(mmp->mmp_seq);
322 if (seq == EXT4_MMP_SEQ_CLEAN)
325 if (seq == EXT4_MMP_SEQ_FSCK) {
326 dump_mmp_msg(sb, mmp, "fsck is running on the filesystem");
331 wait_time = min(mmp_check_interval * 2 + 1,
332 mmp_check_interval + 60);
334 /* Print MMP interval if more than 20 secs. */
335 if (wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4)
336 ext4_warning(sb, "MMP interval %u higher than expected, please"
337 " wait.\n", wait_time * 2);
339 if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
340 ext4_warning(sb, "MMP startup interrupted, failing mount\n");
345 retval = read_mmp_block(sb, &bh, mmp_block);
348 mmp = (struct mmp_struct *)(bh->b_data);
349 if (seq != le32_to_cpu(mmp->mmp_seq)) {
350 dump_mmp_msg(sb, mmp,
351 "Device is already active on another node.");
358 * write a new random sequence number.
361 mmp->mmp_seq = cpu_to_le32(seq);
364 * On mount / remount we are protected against fs freezing (by s_umount
365 * semaphore) and grabbing freeze protection upsets lockdep
367 retval = write_mmp_block_thawed(sb, bh);
372 * wait for MMP interval and check mmp_seq.
374 if (schedule_timeout_interruptible(HZ * wait_time) != 0) {
375 ext4_warning(sb, "MMP startup interrupted, failing mount");
380 retval = read_mmp_block(sb, &bh, mmp_block);
383 mmp = (struct mmp_struct *)(bh->b_data);
384 if (seq != le32_to_cpu(mmp->mmp_seq)) {
385 dump_mmp_msg(sb, mmp,
386 "Device is already active on another node.");
391 EXT4_SB(sb)->s_mmp_bh = bh;
394 * Start a kernel thread to update the MMP block periodically.
396 EXT4_SB(sb)->s_mmp_tsk = kthread_run(kmmpd, sb, "kmmpd-%.*s",
397 (int)sizeof(mmp->mmp_bdevname),
400 if (IS_ERR(EXT4_SB(sb)->s_mmp_tsk)) {
401 EXT4_SB(sb)->s_mmp_tsk = NULL;
402 ext4_warning(sb, "Unable to create kmmpd thread for %s.",