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
);
90 (*bh
)->b_end_io
= end_buffer_read_sync
;
91 submit_bh(REQ_OP_READ
, REQ_META
| REQ_PRIO
, *bh
);
93 if (!buffer_uptodate(*bh
)) {
97 mmp
= (struct mmp_struct
*)((*bh
)->b_data
);
98 if (le32_to_cpu(mmp
->mmp_magic
) != EXT4_MMP_MAGIC
) {
102 if (!ext4_mmp_csum_verify(sb
, mmp
)) {
110 ext4_warning(sb
, "Error %d while reading MMP block %llu",
116 * Dump as much information as possible to help the admin.
118 void __dump_mmp_msg(struct super_block
*sb
, struct mmp_struct
*mmp
,
119 const char *function
, unsigned int line
, const char *msg
)
121 __ext4_warning(sb
, function
, line
, "%s", msg
);
122 __ext4_warning(sb
, function
, line
,
123 "MMP failure info: last update time: %llu, last update node: %.*s, last update device: %.*s",
124 (unsigned long long)le64_to_cpu(mmp
->mmp_time
),
125 (int)sizeof(mmp
->mmp_nodename
), mmp
->mmp_nodename
,
126 (int)sizeof(mmp
->mmp_bdevname
), mmp
->mmp_bdevname
);
130 * kmmpd will update the MMP sequence every s_mmp_update_interval seconds
132 static int kmmpd(void *data
)
134 struct super_block
*sb
= ((struct mmpd_data
*) data
)->sb
;
135 struct buffer_head
*bh
= ((struct mmpd_data
*) data
)->bh
;
136 struct ext4_super_block
*es
= EXT4_SB(sb
)->s_es
;
137 struct mmp_struct
*mmp
;
138 ext4_fsblk_t mmp_block
;
140 unsigned long failed_writes
= 0;
141 int mmp_update_interval
= le16_to_cpu(es
->s_mmp_update_interval
);
142 unsigned mmp_check_interval
;
143 unsigned long last_update_time
;
147 mmp_block
= le64_to_cpu(es
->s_mmp_block
);
148 mmp
= (struct mmp_struct
*)(bh
->b_data
);
149 mmp
->mmp_time
= cpu_to_le64(get_seconds());
151 * Start with the higher mmp_check_interval and reduce it if
152 * the MMP block is being updated on time.
154 mmp_check_interval
= max(EXT4_MMP_CHECK_MULT
* mmp_update_interval
,
155 EXT4_MMP_MIN_CHECK_INTERVAL
);
156 mmp
->mmp_check_interval
= cpu_to_le16(mmp_check_interval
);
157 BUILD_BUG_ON(sizeof(mmp
->mmp_bdevname
) < BDEVNAME_SIZE
);
158 bdevname(bh
->b_bdev
, mmp
->mmp_bdevname
);
160 memcpy(mmp
->mmp_nodename
, init_utsname()->nodename
,
161 sizeof(mmp
->mmp_nodename
));
163 while (!kthread_should_stop()) {
164 if (++seq
> EXT4_MMP_SEQ_MAX
)
167 mmp
->mmp_seq
= cpu_to_le32(seq
);
168 mmp
->mmp_time
= cpu_to_le64(get_seconds());
169 last_update_time
= jiffies
;
171 retval
= write_mmp_block(sb
, bh
);
173 * Don't spew too many error messages. Print one every
174 * (s_mmp_update_interval * 60) seconds.
177 if ((failed_writes
% 60) == 0)
178 ext4_error(sb
, "Error writing to MMP block");
182 if (!(le32_to_cpu(es
->s_feature_incompat
) &
183 EXT4_FEATURE_INCOMPAT_MMP
)) {
184 ext4_warning(sb
, "kmmpd being stopped since MMP feature"
185 " has been disabled.");
192 diff
= jiffies
- last_update_time
;
193 if (diff
< mmp_update_interval
* HZ
)
194 schedule_timeout_interruptible(mmp_update_interval
*
198 * We need to make sure that more than mmp_check_interval
199 * seconds have not passed since writing. If that has happened
200 * we need to check if the MMP block is as we left it.
202 diff
= jiffies
- last_update_time
;
203 if (diff
> mmp_check_interval
* HZ
) {
204 struct buffer_head
*bh_check
= NULL
;
205 struct mmp_struct
*mmp_check
;
207 retval
= read_mmp_block(sb
, &bh_check
, mmp_block
);
209 ext4_error(sb
, "error reading MMP data: %d",
214 mmp_check
= (struct mmp_struct
*)(bh_check
->b_data
);
215 if (mmp
->mmp_seq
!= mmp_check
->mmp_seq
||
216 memcmp(mmp
->mmp_nodename
, mmp_check
->mmp_nodename
,
217 sizeof(mmp
->mmp_nodename
))) {
218 dump_mmp_msg(sb
, mmp_check
,
219 "Error while updating MMP info. "
220 "The filesystem seems to have been"
221 " multiply mounted.");
222 ext4_error(sb
, "abort");
231 * Adjust the mmp_check_interval depending on how much time
232 * it took for the MMP block to be written.
234 mmp_check_interval
= max(min(EXT4_MMP_CHECK_MULT
* diff
/ HZ
,
235 EXT4_MMP_MAX_CHECK_INTERVAL
),
236 EXT4_MMP_MIN_CHECK_INTERVAL
);
237 mmp
->mmp_check_interval
= cpu_to_le16(mmp_check_interval
);
241 * Unmount seems to be clean.
243 mmp
->mmp_seq
= cpu_to_le32(EXT4_MMP_SEQ_CLEAN
);
244 mmp
->mmp_time
= cpu_to_le64(get_seconds());
246 retval
= write_mmp_block(sb
, bh
);
249 EXT4_SB(sb
)->s_mmp_tsk
= NULL
;
256 * Get a random new sequence number but make sure it is not greater than
259 static unsigned int mmp_new_seq(void)
264 new_seq
= prandom_u32();
265 } while (new_seq
> EXT4_MMP_SEQ_MAX
);
271 * Protect the filesystem from being mounted more than once.
273 int ext4_multi_mount_protect(struct super_block
*sb
,
274 ext4_fsblk_t mmp_block
)
276 struct ext4_super_block
*es
= EXT4_SB(sb
)->s_es
;
277 struct buffer_head
*bh
= NULL
;
278 struct mmp_struct
*mmp
= NULL
;
279 struct mmpd_data
*mmpd_data
;
281 unsigned int mmp_check_interval
= le16_to_cpu(es
->s_mmp_update_interval
);
282 unsigned int wait_time
= 0;
285 if (mmp_block
< le32_to_cpu(es
->s_first_data_block
) ||
286 mmp_block
>= ext4_blocks_count(es
)) {
287 ext4_warning(sb
, "Invalid MMP block in superblock");
291 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
295 mmp
= (struct mmp_struct
*)(bh
->b_data
);
297 if (mmp_check_interval
< EXT4_MMP_MIN_CHECK_INTERVAL
)
298 mmp_check_interval
= EXT4_MMP_MIN_CHECK_INTERVAL
;
301 * If check_interval in MMP block is larger, use that instead of
302 * update_interval from the superblock.
304 if (le16_to_cpu(mmp
->mmp_check_interval
) > mmp_check_interval
)
305 mmp_check_interval
= le16_to_cpu(mmp
->mmp_check_interval
);
307 seq
= le32_to_cpu(mmp
->mmp_seq
);
308 if (seq
== EXT4_MMP_SEQ_CLEAN
)
311 if (seq
== EXT4_MMP_SEQ_FSCK
) {
312 dump_mmp_msg(sb
, mmp
, "fsck is running on the filesystem");
316 wait_time
= min(mmp_check_interval
* 2 + 1,
317 mmp_check_interval
+ 60);
319 /* Print MMP interval if more than 20 secs. */
320 if (wait_time
> EXT4_MMP_MIN_CHECK_INTERVAL
* 4)
321 ext4_warning(sb
, "MMP interval %u higher than expected, please"
322 " wait.\n", wait_time
* 2);
324 if (schedule_timeout_interruptible(HZ
* wait_time
) != 0) {
325 ext4_warning(sb
, "MMP startup interrupted, failing mount\n");
329 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
332 mmp
= (struct mmp_struct
*)(bh
->b_data
);
333 if (seq
!= le32_to_cpu(mmp
->mmp_seq
)) {
334 dump_mmp_msg(sb
, mmp
,
335 "Device is already active on another node.");
341 * write a new random sequence number.
344 mmp
->mmp_seq
= cpu_to_le32(seq
);
346 retval
= write_mmp_block(sb
, bh
);
351 * wait for MMP interval and check mmp_seq.
353 if (schedule_timeout_interruptible(HZ
* wait_time
) != 0) {
354 ext4_warning(sb
, "MMP startup interrupted, failing mount");
358 retval
= read_mmp_block(sb
, &bh
, mmp_block
);
361 mmp
= (struct mmp_struct
*)(bh
->b_data
);
362 if (seq
!= le32_to_cpu(mmp
->mmp_seq
)) {
363 dump_mmp_msg(sb
, mmp
,
364 "Device is already active on another node.");
368 mmpd_data
= kmalloc(sizeof(*mmpd_data
), GFP_KERNEL
);
370 ext4_warning(sb
, "not enough memory for mmpd_data");
377 * Start a kernel thread to update the MMP block periodically.
379 EXT4_SB(sb
)->s_mmp_tsk
= kthread_run(kmmpd
, mmpd_data
, "kmmpd-%.*s",
380 (int)sizeof(mmp
->mmp_bdevname
),
383 if (IS_ERR(EXT4_SB(sb
)->s_mmp_tsk
)) {
384 EXT4_SB(sb
)->s_mmp_tsk
= NULL
;
386 ext4_warning(sb
, "Unable to create kmmpd thread for %s.",