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(struct super_block
*sb
, struct buffer_head
*bh
)
44 struct mmp_struct
*mmp
= (struct mmp_struct
*)(bh
->b_data
);
47 * We protect against freezing so that we don't create dirty buffers
48 * on frozen filesystem.
51 ext4_mmp_csum_set(sb
, mmp
);
53 bh
->b_end_io
= end_buffer_write_sync
;
55 submit_bh(REQ_OP_WRITE
| REQ_SYNC
| REQ_META
| REQ_PRIO
, bh
);
58 if (unlikely(!buffer_uptodate(bh
)))
65 * Read the MMP block. It _must_ be read from disk and hence we clear the
66 * uptodate flag on the buffer.
68 static int read_mmp_block(struct super_block
*sb
, struct buffer_head
**bh
,
69 ext4_fsblk_t mmp_block
)
71 struct mmp_struct
*mmp
;
75 clear_buffer_uptodate(*bh
);
77 /* This would be sb_bread(sb, mmp_block), except we need to be sure
78 * that the MD RAID device cache has been bypassed, and that the read
79 * is not blocked in the elevator. */
81 *bh
= sb_getblk(sb
, mmp_block
);
89 ret
= ext4_read_bh(*bh
, REQ_META
| REQ_PRIO
, NULL
);
93 mmp
= (struct mmp_struct
*)((*bh
)->b_data
);
94 if (le32_to_cpu(mmp
->mmp_magic
) != EXT4_MMP_MAGIC
) {
98 if (!ext4_mmp_csum_verify(sb
, mmp
)) {
106 ext4_warning(sb
, "Error %d while reading MMP block %llu",
112 * Dump as much information as possible to help the admin.
114 void __dump_mmp_msg(struct super_block
*sb
, struct mmp_struct
*mmp
,
115 const char *function
, unsigned int line
, const char *msg
)
117 __ext4_warning(sb
, function
, line
, "%s", msg
);
118 __ext4_warning(sb
, function
, line
,
119 "MMP failure info: last update time: %llu, last update node: %.*s, last update device: %.*s",
120 (unsigned long long)le64_to_cpu(mmp
->mmp_time
),
121 (int)sizeof(mmp
->mmp_nodename
), mmp
->mmp_nodename
,
122 (int)sizeof(mmp
->mmp_bdevname
), mmp
->mmp_bdevname
);
126 * kmmpd will update the MMP sequence every s_mmp_update_interval seconds
128 static int kmmpd(void *data
)
130 struct super_block
*sb
= data
;
131 struct ext4_super_block
*es
= EXT4_SB(sb
)->s_es
;
132 struct buffer_head
*bh
= EXT4_SB(sb
)->s_mmp_bh
;
133 struct mmp_struct
*mmp
;
134 ext4_fsblk_t mmp_block
;
136 unsigned long failed_writes
= 0;
137 int mmp_update_interval
= le16_to_cpu(es
->s_mmp_update_interval
);
138 unsigned mmp_check_interval
;
139 unsigned long last_update_time
;
143 mmp_block
= le64_to_cpu(es
->s_mmp_block
);
144 mmp
= (struct mmp_struct
*)(bh
->b_data
);
145 mmp
->mmp_time
= cpu_to_le64(ktime_get_real_seconds());
147 * Start with the higher mmp_check_interval and reduce it if
148 * the MMP block is being updated on time.
150 mmp_check_interval
= max(EXT4_MMP_CHECK_MULT
* mmp_update_interval
,
151 EXT4_MMP_MIN_CHECK_INTERVAL
);
152 mmp
->mmp_check_interval
= cpu_to_le16(mmp_check_interval
);
154 memcpy(mmp
->mmp_nodename
, init_utsname()->nodename
,
155 sizeof(mmp
->mmp_nodename
));
157 while (!kthread_should_stop() && !sb_rdonly(sb
)) {
158 if (!ext4_has_feature_mmp(sb
)) {
159 ext4_warning(sb
, "kmmpd being stopped since MMP feature"
160 " has been disabled.");
163 if (++seq
> EXT4_MMP_SEQ_MAX
)
166 mmp
->mmp_seq
= cpu_to_le32(seq
);
167 mmp
->mmp_time
= cpu_to_le64(ktime_get_real_seconds());
168 last_update_time
= jiffies
;
170 retval
= write_mmp_block(sb
, bh
);
172 * Don't spew too many error messages. Print one every
173 * (s_mmp_update_interval * 60) seconds.
176 if ((failed_writes
% 60) == 0) {
177 ext4_error_err(sb
, -retval
,
178 "Error writing to MMP block");
183 diff
= jiffies
- last_update_time
;
184 if (diff
< mmp_update_interval
* HZ
)
185 schedule_timeout_interruptible(mmp_update_interval
*
189 * We need to make sure that more than mmp_check_interval
190 * seconds have not passed since writing. If that has happened
191 * we need to check if the MMP block is as we left it.
193 diff
= jiffies
- last_update_time
;
194 if (diff
> mmp_check_interval
* HZ
) {
195 struct buffer_head
*bh_check
= NULL
;
196 struct mmp_struct
*mmp_check
;
198 retval
= read_mmp_block(sb
, &bh_check
, mmp_block
);
200 ext4_error_err(sb
, -retval
,
201 "error reading MMP data: %d",
206 mmp_check
= (struct mmp_struct
*)(bh_check
->b_data
);
207 if (mmp
->mmp_seq
!= mmp_check
->mmp_seq
||
208 memcmp(mmp
->mmp_nodename
, mmp_check
->mmp_nodename
,
209 sizeof(mmp
->mmp_nodename
))) {
210 dump_mmp_msg(sb
, mmp_check
,
211 "Error while updating MMP info. "
212 "The filesystem seems to have been"
213 " multiply mounted.");
214 ext4_error_err(sb
, EBUSY
, "abort");
223 * Adjust the mmp_check_interval depending on how much time
224 * it took for the MMP block to be written.
226 mmp_check_interval
= max(min(EXT4_MMP_CHECK_MULT
* diff
/ HZ
,
227 EXT4_MMP_MAX_CHECK_INTERVAL
),
228 EXT4_MMP_MIN_CHECK_INTERVAL
);
229 mmp
->mmp_check_interval
= cpu_to_le16(mmp_check_interval
);
233 * Unmount seems to be clean.
235 mmp
->mmp_seq
= cpu_to_le32(EXT4_MMP_SEQ_CLEAN
);
236 mmp
->mmp_time
= cpu_to_le64(ktime_get_real_seconds());
238 retval
= write_mmp_block(sb
, bh
);
241 while (!kthread_should_stop()) {
242 set_current_state(TASK_INTERRUPTIBLE
);
243 if (!kthread_should_stop())
246 set_current_state(TASK_RUNNING
);
250 void ext4_stop_mmpd(struct ext4_sb_info
*sbi
)
252 if (sbi
->s_mmp_tsk
) {
253 kthread_stop(sbi
->s_mmp_tsk
);
254 brelse(sbi
->s_mmp_bh
);
255 sbi
->s_mmp_tsk
= NULL
;
260 * Get a random new sequence number but make sure it is not greater than
263 static unsigned int mmp_new_seq(void)
268 new_seq
= prandom_u32();
269 } while (new_seq
> EXT4_MMP_SEQ_MAX
);
275 * Protect the filesystem from being mounted more than once.
277 int ext4_multi_mount_protect(struct super_block
*sb
,
278 ext4_fsblk_t mmp_block
)
280 struct ext4_super_block
*es
= EXT4_SB(sb
)->s_es
;
281 struct buffer_head
*bh
= NULL
;
282 struct mmp_struct
*mmp
= NULL
;
284 unsigned int mmp_check_interval
= le16_to_cpu(es
->s_mmp_update_interval
);
285 unsigned int wait_time
= 0;
288 if (mmp_block
< le32_to_cpu(es
->s_first_data_block
) ||
289 mmp_block
>= ext4_blocks_count(es
)) {
290 ext4_warning(sb
, "Invalid MMP block in superblock");
294 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
298 mmp
= (struct mmp_struct
*)(bh
->b_data
);
300 if (mmp_check_interval
< EXT4_MMP_MIN_CHECK_INTERVAL
)
301 mmp_check_interval
= EXT4_MMP_MIN_CHECK_INTERVAL
;
304 * If check_interval in MMP block is larger, use that instead of
305 * update_interval from the superblock.
307 if (le16_to_cpu(mmp
->mmp_check_interval
) > mmp_check_interval
)
308 mmp_check_interval
= le16_to_cpu(mmp
->mmp_check_interval
);
310 seq
= le32_to_cpu(mmp
->mmp_seq
);
311 if (seq
== EXT4_MMP_SEQ_CLEAN
)
314 if (seq
== EXT4_MMP_SEQ_FSCK
) {
315 dump_mmp_msg(sb
, mmp
, "fsck is running on the filesystem");
319 wait_time
= min(mmp_check_interval
* 2 + 1,
320 mmp_check_interval
+ 60);
322 /* Print MMP interval if more than 20 secs. */
323 if (wait_time
> EXT4_MMP_MIN_CHECK_INTERVAL
* 4)
324 ext4_warning(sb
, "MMP interval %u higher than expected, please"
325 " wait.\n", wait_time
* 2);
327 if (schedule_timeout_interruptible(HZ
* wait_time
) != 0) {
328 ext4_warning(sb
, "MMP startup interrupted, failing mount\n");
332 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
335 mmp
= (struct mmp_struct
*)(bh
->b_data
);
336 if (seq
!= le32_to_cpu(mmp
->mmp_seq
)) {
337 dump_mmp_msg(sb
, mmp
,
338 "Device is already active on another node.");
344 * write a new random sequence number.
347 mmp
->mmp_seq
= cpu_to_le32(seq
);
349 retval
= write_mmp_block(sb
, bh
);
354 * wait for MMP interval and check mmp_seq.
356 if (schedule_timeout_interruptible(HZ
* wait_time
) != 0) {
357 ext4_warning(sb
, "MMP startup interrupted, failing mount");
361 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
364 mmp
= (struct mmp_struct
*)(bh
->b_data
);
365 if (seq
!= le32_to_cpu(mmp
->mmp_seq
)) {
366 dump_mmp_msg(sb
, mmp
,
367 "Device is already active on another node.");
371 EXT4_SB(sb
)->s_mmp_bh
= bh
;
373 BUILD_BUG_ON(sizeof(mmp
->mmp_bdevname
) < BDEVNAME_SIZE
);
374 snprintf(mmp
->mmp_bdevname
, sizeof(mmp
->mmp_bdevname
),
378 * Start a kernel thread to update the MMP block periodically.
380 EXT4_SB(sb
)->s_mmp_tsk
= kthread_run(kmmpd
, sb
, "kmmpd-%.*s",
381 (int)sizeof(mmp
->mmp_bdevname
),
383 if (IS_ERR(EXT4_SB(sb
)->s_mmp_tsk
)) {
384 EXT4_SB(sb
)->s_mmp_tsk
= NULL
;
385 ext4_warning(sb
, "Unable to create kmmpd thread for %s.",