1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/fs/ext4/super.c
4 *
5 * Copyright (C) 1992, 1993, 1994, 1995
6 * Remy Card (card@masi.ibp.fr)
7 * Laboratoire MASI - Institut Blaise Pascal
8 * Universite Pierre et Marie Curie (Paris VI)
9 *
10 * from
11 *
12 * linux/fs/minix/inode.c
13 *
14 * Copyright (C) 1991, 1992 Linus Torvalds
15 *
16 * Big-endian to little-endian byte-swapping/bitmaps by
17 * David S. Miller (davem@caip.rutgers.edu), 1995
18 */
19
20 #include <linux/module.h>
21 #include <linux/string.h>
22 #include <linux/fs.h>
23 #include <linux/time.h>
24 #include <linux/vmalloc.h>
25 #include <linux/slab.h>
26 #include <linux/init.h>
27 #include <linux/blkdev.h>
28 #include <linux/backing-dev.h>
29 #include <linux/parser.h>
30 #include <linux/buffer_head.h>
31 #include <linux/exportfs.h>
32 #include <linux/vfs.h>
33 #include <linux/random.h>
34 #include <linux/mount.h>
35 #include <linux/namei.h>
36 #include <linux/quotaops.h>
37 #include <linux/seq_file.h>
38 #include <linux/ctype.h>
39 #include <linux/log2.h>
40 #include <linux/crc16.h>
41 #include <linux/dax.h>
42 #include <linux/cleancache.h>
43 #include <linux/uaccess.h>
44 #include <linux/iversion.h>
45 #include <linux/unicode.h>
46 #include <linux/part_stat.h>
47 #include <linux/kthread.h>
48 #include <linux/freezer.h>
49 #include <linux/fsnotify.h>
50 #include <linux/fs_context.h>
51 #include <linux/fs_parser.h>
52
53 #include "ext4.h"
54 #include "ext4_extents.h" /* Needed for trace points definition */
55 #include "ext4_jbd2.h"
56 #include "xattr.h"
57 #include "acl.h"
58 #include "mballoc.h"
59 #include "fsmap.h"
60
61 #define CREATE_TRACE_POINTS
62 #include <trace/events/ext4.h>
63
64 static struct ext4_lazy_init *ext4_li_info;
65 static DEFINE_MUTEX(ext4_li_mtx);
66 static struct ratelimit_state ext4_mount_msg_ratelimit;
67
68 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
69 unsigned long journal_devnum);
70 static int ext4_show_options(struct seq_file *seq, struct dentry *root);
71 static void ext4_update_super(struct super_block *sb);
72 static int ext4_commit_super(struct super_block *sb);
73 static int ext4_mark_recovery_complete(struct super_block *sb,
74 struct ext4_super_block *es);
75 static int ext4_clear_journal_err(struct super_block *sb,
76 struct ext4_super_block *es);
77 static int ext4_sync_fs(struct super_block *sb, int wait);
78 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
79 static int ext4_unfreeze(struct super_block *sb);
80 static int ext4_freeze(struct super_block *sb);
81 static inline int ext2_feature_set_ok(struct super_block *sb);
82 static inline int ext3_feature_set_ok(struct super_block *sb);
83 static void ext4_destroy_lazyinit_thread(void);
84 static void ext4_unregister_li_request(struct super_block *sb);
85 static void ext4_clear_request_list(void);
86 static struct inode *ext4_get_journal_inode(struct super_block *sb,
87 unsigned int journal_inum);
88 static int ext4_validate_options(struct fs_context *fc);
89 static int ext4_check_opt_consistency(struct fs_context *fc,
90 struct super_block *sb);
91 static void ext4_apply_options(struct fs_context *fc, struct super_block *sb);
92 static int ext4_parse_param(struct fs_context *fc, struct fs_parameter *param);
93 static int ext4_get_tree(struct fs_context *fc);
94 static int ext4_reconfigure(struct fs_context *fc);
95 static void ext4_fc_free(struct fs_context *fc);
96 static int ext4_init_fs_context(struct fs_context *fc);
97 static void ext4_kill_sb(struct super_block *sb);
98 static const struct fs_parameter_spec ext4_param_specs[];
99
100 /*
101 * Lock ordering
102 *
103 * page fault path:
104 * mmap_lock -> sb_start_pagefault -> invalidate_lock (r) -> transaction start
105 * -> page lock -> i_data_sem (rw)
106 *
107 * buffered write path:
108 * sb_start_write -> i_mutex -> mmap_lock
109 * sb_start_write -> i_mutex -> transaction start -> page lock ->
110 * i_data_sem (rw)
111 *
112 * truncate:
113 * sb_start_write -> i_mutex -> invalidate_lock (w) -> i_mmap_rwsem (w) ->
114 * page lock
115 * sb_start_write -> i_mutex -> invalidate_lock (w) -> transaction start ->
116 * i_data_sem (rw)
117 *
118 * direct IO:
119 * sb_start_write -> i_mutex -> mmap_lock
120 * sb_start_write -> i_mutex -> transaction start -> i_data_sem (rw)
121 *
122 * writepages:
123 * transaction start -> page lock(s) -> i_data_sem (rw)
124 */
125
126 static const struct fs_context_operations ext4_context_ops = {
127 .parse_param = ext4_parse_param,
128 .get_tree = ext4_get_tree,
129 .reconfigure = ext4_reconfigure,
130 .free = ext4_fc_free,
131 };
132
133
134 #if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
135 static struct file_system_type ext2_fs_type = {
136 .owner = THIS_MODULE,
137 .name = "ext2",
138 .init_fs_context = ext4_init_fs_context,
139 .parameters = ext4_param_specs,
140 .kill_sb = ext4_kill_sb,
141 .fs_flags = FS_REQUIRES_DEV,
142 };
143 MODULE_ALIAS_FS("ext2");
144 MODULE_ALIAS("ext2");
145 #define IS_EXT2_SB(sb) ((sb)->s_type == &ext2_fs_type)
146 #else
147 #define IS_EXT2_SB(sb) (0)
148 #endif
149
150
151 static struct file_system_type ext3_fs_type = {
152 .owner = THIS_MODULE,
153 .name = "ext3",
154 .init_fs_context = ext4_init_fs_context,
155 .parameters = ext4_param_specs,
156 .kill_sb = ext4_kill_sb,
157 .fs_flags = FS_REQUIRES_DEV,
158 };
159 MODULE_ALIAS_FS("ext3");
160 MODULE_ALIAS("ext3");
161 #define IS_EXT3_SB(sb) ((sb)->s_type == &ext3_fs_type)
162
163
__ext4_read_bh(struct buffer_head * bh,blk_opf_t op_flags,bh_end_io_t * end_io)164 static inline void __ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags,
165 bh_end_io_t *end_io)
166 {
167 /*
168 * buffer's verified bit is no longer valid after reading from
169 * disk again due to write out error, clear it to make sure we
170 * recheck the buffer contents.
171 */
172 clear_buffer_verified(bh);
173
174 bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
175 get_bh(bh);
176 submit_bh(REQ_OP_READ | op_flags, bh);
177 }
178
ext4_read_bh_nowait(struct buffer_head * bh,blk_opf_t op_flags,bh_end_io_t * end_io)179 void ext4_read_bh_nowait(struct buffer_head *bh, blk_opf_t op_flags,
180 bh_end_io_t *end_io)
181 {
182 BUG_ON(!buffer_locked(bh));
183
184 if (ext4_buffer_uptodate(bh)) {
185 unlock_buffer(bh);
186 return;
187 }
188 __ext4_read_bh(bh, op_flags, end_io);
189 }
190
ext4_read_bh(struct buffer_head * bh,blk_opf_t op_flags,bh_end_io_t * end_io)191 int ext4_read_bh(struct buffer_head *bh, blk_opf_t op_flags, bh_end_io_t *end_io)
192 {
193 BUG_ON(!buffer_locked(bh));
194
195 if (ext4_buffer_uptodate(bh)) {
196 unlock_buffer(bh);
197 return 0;
198 }
199
200 __ext4_read_bh(bh, op_flags, end_io);
201
202 wait_on_buffer(bh);
203 if (buffer_uptodate(bh))
204 return 0;
205 return -EIO;
206 }
207
ext4_read_bh_lock(struct buffer_head * bh,blk_opf_t op_flags,bool wait)208 int ext4_read_bh_lock(struct buffer_head *bh, blk_opf_t op_flags, bool wait)
209 {
210 lock_buffer(bh);
211 if (!wait) {
212 ext4_read_bh_nowait(bh, op_flags, NULL);
213 return 0;
214 }
215 return ext4_read_bh(bh, op_flags, NULL);
216 }
217
218 /*
219 * This works like __bread_gfp() except it uses ERR_PTR for error
220 * returns. Currently with sb_bread it's impossible to distinguish
221 * between ENOMEM and EIO situations (since both result in a NULL
222 * return.
223 */
__ext4_sb_bread_gfp(struct super_block * sb,sector_t block,blk_opf_t op_flags,gfp_t gfp)224 static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
225 sector_t block,
226 blk_opf_t op_flags, gfp_t gfp)
227 {
228 struct buffer_head *bh;
229 int ret;
230
231 bh = sb_getblk_gfp(sb, block, gfp);
232 if (bh == NULL)
233 return ERR_PTR(-ENOMEM);
234 if (ext4_buffer_uptodate(bh))
235 return bh;
236
237 ret = ext4_read_bh_lock(bh, REQ_META | op_flags, true);
238 if (ret) {
239 put_bh(bh);
240 return ERR_PTR(ret);
241 }
242 return bh;
243 }
244
ext4_sb_bread(struct super_block * sb,sector_t block,blk_opf_t op_flags)245 struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,
246 blk_opf_t op_flags)
247 {
248 return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
249 }
250
ext4_sb_bread_unmovable(struct super_block * sb,sector_t block)251 struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
252 sector_t block)
253 {
254 return __ext4_sb_bread_gfp(sb, block, 0, 0);
255 }
256
ext4_sb_breadahead_unmovable(struct super_block * sb,sector_t block)257 void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block)
258 {
259 struct buffer_head *bh = sb_getblk_gfp(sb, block, 0);
260
261 if (likely(bh)) {
262 if (trylock_buffer(bh))
263 ext4_read_bh_nowait(bh, REQ_RAHEAD, NULL);
264 brelse(bh);
265 }
266 }
267
ext4_verify_csum_type(struct super_block * sb,struct ext4_super_block * es)268 static int ext4_verify_csum_type(struct super_block *sb,
269 struct ext4_super_block *es)
270 {
271 if (!ext4_has_feature_metadata_csum(sb))
272 return 1;
273
274 return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
275 }
276
ext4_superblock_csum(struct super_block * sb,struct ext4_super_block * es)277 __le32 ext4_superblock_csum(struct super_block *sb,
278 struct ext4_super_block *es)
279 {
280 struct ext4_sb_info *sbi = EXT4_SB(sb);
281 int offset = offsetof(struct ext4_super_block, s_checksum);
282 __u32 csum;
283
284 csum = ext4_chksum(sbi, ~0, (char *)es, offset);
285
286 return cpu_to_le32(csum);
287 }
288
ext4_superblock_csum_verify(struct super_block * sb,struct ext4_super_block * es)289 static int ext4_superblock_csum_verify(struct super_block *sb,
290 struct ext4_super_block *es)
291 {
292 if (!ext4_has_metadata_csum(sb))
293 return 1;
294
295 return es->s_checksum == ext4_superblock_csum(sb, es);
296 }
297
ext4_superblock_csum_set(struct super_block * sb)298 void ext4_superblock_csum_set(struct super_block *sb)
299 {
300 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
301
302 if (!ext4_has_metadata_csum(sb))
303 return;
304
305 es->s_checksum = ext4_superblock_csum(sb, es);
306 }
307
ext4_block_bitmap(struct super_block * sb,struct ext4_group_desc * bg)308 ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
309 struct ext4_group_desc *bg)
310 {
311 return le32_to_cpu(bg->bg_block_bitmap_lo) |
312 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
313 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
314 }
315
ext4_inode_bitmap(struct super_block * sb,struct ext4_group_desc * bg)316 ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
317 struct ext4_group_desc *bg)
318 {
319 return le32_to_cpu(bg->bg_inode_bitmap_lo) |
320 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
321 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
322 }
323
ext4_inode_table(struct super_block * sb,struct ext4_group_desc * bg)324 ext4_fsblk_t ext4_inode_table(struct super_block *sb,
325 struct ext4_group_desc *bg)
326 {
327 return le32_to_cpu(bg->bg_inode_table_lo) |
328 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
329 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
330 }
331
ext4_free_group_clusters(struct super_block * sb,struct ext4_group_desc * bg)332 __u32 ext4_free_group_clusters(struct super_block *sb,
333 struct ext4_group_desc *bg)
334 {
335 return le16_to_cpu(bg->bg_free_blocks_count_lo) |
336 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
337 (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
338 }
339
ext4_free_inodes_count(struct super_block * sb,struct ext4_group_desc * bg)340 __u32 ext4_free_inodes_count(struct super_block *sb,
341 struct ext4_group_desc *bg)
342 {
343 return le16_to_cpu(bg->bg_free_inodes_count_lo) |
344 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
345 (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
346 }
347
ext4_used_dirs_count(struct super_block * sb,struct ext4_group_desc * bg)348 __u32 ext4_used_dirs_count(struct super_block *sb,
349 struct ext4_group_desc *bg)
350 {
351 return le16_to_cpu(bg->bg_used_dirs_count_lo) |
352 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
353 (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
354 }
355
ext4_itable_unused_count(struct super_block * sb,struct ext4_group_desc * bg)356 __u32 ext4_itable_unused_count(struct super_block *sb,
357 struct ext4_group_desc *bg)
358 {
359 return le16_to_cpu(bg->bg_itable_unused_lo) |
360 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
361 (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
362 }
363
ext4_block_bitmap_set(struct super_block * sb,struct ext4_group_desc * bg,ext4_fsblk_t blk)364 void ext4_block_bitmap_set(struct super_block *sb,
365 struct ext4_group_desc *bg, ext4_fsblk_t blk)
366 {
367 bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
368 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
369 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
370 }
371
ext4_inode_bitmap_set(struct super_block * sb,struct ext4_group_desc * bg,ext4_fsblk_t blk)372 void ext4_inode_bitmap_set(struct super_block *sb,
373 struct ext4_group_desc *bg, ext4_fsblk_t blk)
374 {
375 bg->bg_inode_bitmap_lo = cpu_to_le32((u32)blk);
376 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
377 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
378 }
379
ext4_inode_table_set(struct super_block * sb,struct ext4_group_desc * bg,ext4_fsblk_t blk)380 void ext4_inode_table_set(struct super_block *sb,
381 struct ext4_group_desc *bg, ext4_fsblk_t blk)
382 {
383 bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
384 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
385 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
386 }
387
ext4_free_group_clusters_set(struct super_block * sb,struct ext4_group_desc * bg,__u32 count)388 void ext4_free_group_clusters_set(struct super_block *sb,
389 struct ext4_group_desc *bg, __u32 count)
390 {
391 bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
392 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
393 bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
394 }
395
ext4_free_inodes_set(struct super_block * sb,struct ext4_group_desc * bg,__u32 count)396 void ext4_free_inodes_set(struct super_block *sb,
397 struct ext4_group_desc *bg, __u32 count)
398 {
399 bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
400 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
401 bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
402 }
403
ext4_used_dirs_set(struct super_block * sb,struct ext4_group_desc * bg,__u32 count)404 void ext4_used_dirs_set(struct super_block *sb,
405 struct ext4_group_desc *bg, __u32 count)
406 {
407 bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
408 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
409 bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
410 }
411
ext4_itable_unused_set(struct super_block * sb,struct ext4_group_desc * bg,__u32 count)412 void ext4_itable_unused_set(struct super_block *sb,
413 struct ext4_group_desc *bg, __u32 count)
414 {
415 bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
416 if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
417 bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
418 }
419
__ext4_update_tstamp(__le32 * lo,__u8 * hi,time64_t now)420 static void __ext4_update_tstamp(__le32 *lo, __u8 *hi, time64_t now)
421 {
422 now = clamp_val(now, 0, (1ull << 40) - 1);
423
424 *lo = cpu_to_le32(lower_32_bits(now));
425 *hi = upper_32_bits(now);
426 }
427
__ext4_get_tstamp(__le32 * lo,__u8 * hi)428 static time64_t __ext4_get_tstamp(__le32 *lo, __u8 *hi)
429 {
430 return ((time64_t)(*hi) << 32) + le32_to_cpu(*lo);
431 }
432 #define ext4_update_tstamp(es, tstamp) \
433 __ext4_update_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi, \
434 ktime_get_real_seconds())
435 #define ext4_get_tstamp(es, tstamp) \
436 __ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
437
438 #define EXT4_SB_REFRESH_INTERVAL_SEC (3600) /* seconds (1 hour) */
439 #define EXT4_SB_REFRESH_INTERVAL_KB (16384) /* kilobytes (16MB) */
440
441 /*
442 * The ext4_maybe_update_superblock() function checks and updates the
443 * superblock if needed.
444 *
445 * This function is designed to update the on-disk superblock only under
446 * certain conditions to prevent excessive disk writes and unnecessary
447 * waking of the disk from sleep. The superblock will be updated if:
448 * 1. More than an hour has passed since the last superblock update, and
449 * 2. More than 16MB have been written since the last superblock update.
450 *
451 * @sb: The superblock
452 */
ext4_maybe_update_superblock(struct super_block * sb)453 static void ext4_maybe_update_superblock(struct super_block *sb)
454 {
455 struct ext4_sb_info *sbi = EXT4_SB(sb);
456 struct ext4_super_block *es = sbi->s_es;
457 journal_t *journal = sbi->s_journal;
458 time64_t now;
459 __u64 last_update;
460 __u64 lifetime_write_kbytes;
461 __u64 diff_size;
462
463 if (sb_rdonly(sb) || !(sb->s_flags & SB_ACTIVE) ||
464 !journal || (journal->j_flags & JBD2_UNMOUNT))
465 return;
466
467 now = ktime_get_real_seconds();
468 last_update = ext4_get_tstamp(es, s_wtime);
469
470 if (likely(now - last_update < EXT4_SB_REFRESH_INTERVAL_SEC))
471 return;
472
473 lifetime_write_kbytes = sbi->s_kbytes_written +
474 ((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
475 sbi->s_sectors_written_start) >> 1);
476
477 /* Get the number of kilobytes not written to disk to account
478 * for statistics and compare with a multiple of 16 MB. This
479 * is used to determine when the next superblock commit should
480 * occur (i.e. not more often than once per 16MB if there was
481 * less written in an hour).
482 */
483 diff_size = lifetime_write_kbytes - le64_to_cpu(es->s_kbytes_written);
484
485 if (diff_size > EXT4_SB_REFRESH_INTERVAL_KB)
486 schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
487 }
488
489 /*
490 * The del_gendisk() function uninitializes the disk-specific data
491 * structures, including the bdi structure, without telling anyone
492 * else. Once this happens, any attempt to call mark_buffer_dirty()
493 * (for example, by ext4_commit_super), will cause a kernel OOPS.
494 * This is a kludge to prevent these oops until we can put in a proper
495 * hook in del_gendisk() to inform the VFS and file system layers.
496 */
block_device_ejected(struct super_block * sb)497 static int block_device_ejected(struct super_block *sb)
498 {
499 struct inode *bd_inode = sb->s_bdev->bd_inode;
500 struct backing_dev_info *bdi = inode_to_bdi(bd_inode);
501
502 return bdi->dev == NULL;
503 }
504
ext4_journal_commit_callback(journal_t * journal,transaction_t * txn)505 static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
506 {
507 struct super_block *sb = journal->j_private;
508 struct ext4_sb_info *sbi = EXT4_SB(sb);
509 int error = is_journal_aborted(journal);
510 struct ext4_journal_cb_entry *jce;
511
512 BUG_ON(txn->t_state == T_FINISHED);
513
514 ext4_process_freed_data(sb, txn->t_tid);
515 ext4_maybe_update_superblock(sb);
516
517 spin_lock(&sbi->s_md_lock);
518 while (!list_empty(&txn->t_private_list)) {
519 jce = list_entry(txn->t_private_list.next,
520 struct ext4_journal_cb_entry, jce_list);
521 list_del_init(&jce->jce_list);
522 spin_unlock(&sbi->s_md_lock);
523 jce->jce_func(sb, jce, error);
524 spin_lock(&sbi->s_md_lock);
525 }
526 spin_unlock(&sbi->s_md_lock);
527 }
528
529 /*
530 * This writepage callback for write_cache_pages()
531 * takes care of a few cases after page cleaning.
532 *
533 * write_cache_pages() already checks for dirty pages
534 * and calls clear_page_dirty_for_io(), which we want,
535 * to write protect the pages.
536 *
537 * However, we may have to redirty a page (see below.)
538 */
ext4_journalled_writepage_callback(struct folio * folio,struct writeback_control * wbc,void * data)539 static int ext4_journalled_writepage_callback(struct folio *folio,
540 struct writeback_control *wbc,
541 void *data)
542 {
543 transaction_t *transaction = (transaction_t *) data;
544 struct buffer_head *bh, *head;
545 struct journal_head *jh;
546
547 bh = head = folio_buffers(folio);
548 do {
549 /*
550 * We have to redirty a page in these cases:
551 * 1) If buffer is dirty, it means the page was dirty because it
552 * contains a buffer that needs checkpointing. So the dirty bit
553 * needs to be preserved so that checkpointing writes the buffer
554 * properly.
555 * 2) If buffer is not part of the committing transaction
556 * (we may have just accidentally come across this buffer because
557 * inode range tracking is not exact) or if the currently running
558 * transaction already contains this buffer as well, dirty bit
559 * needs to be preserved so that the buffer gets writeprotected
560 * properly on running transaction's commit.
561 */
562 jh = bh2jh(bh);
563 if (buffer_dirty(bh) ||
564 (jh && (jh->b_transaction != transaction ||
565 jh->b_next_transaction))) {
566 folio_redirty_for_writepage(wbc, folio);
567 goto out;
568 }
569 } while ((bh = bh->b_this_page) != head);
570
571 out:
572 return AOP_WRITEPAGE_ACTIVATE;
573 }
574
ext4_journalled_submit_inode_data_buffers(struct jbd2_inode * jinode)575 static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
576 {
577 struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
578 struct writeback_control wbc = {
579 .sync_mode = WB_SYNC_ALL,
580 .nr_to_write = LONG_MAX,
581 .range_start = jinode->i_dirty_start,
582 .range_end = jinode->i_dirty_end,
583 };
584
585 return write_cache_pages(mapping, &wbc,
586 ext4_journalled_writepage_callback,
587 jinode->i_transaction);
588 }
589
ext4_journal_submit_inode_data_buffers(struct jbd2_inode * jinode)590 static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
591 {
592 int ret;
593
594 if (ext4_should_journal_data(jinode->i_vfs_inode))
595 ret = ext4_journalled_submit_inode_data_buffers(jinode);
596 else
597 ret = ext4_normal_submit_inode_data_buffers(jinode);
598 return ret;
599 }
600
ext4_journal_finish_inode_data_buffers(struct jbd2_inode * jinode)601 static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
602 {
603 int ret = 0;
604
605 if (!ext4_should_journal_data(jinode->i_vfs_inode))
606 ret = jbd2_journal_finish_inode_data_buffers(jinode);
607
608 return ret;
609 }
610
system_going_down(void)611 static bool system_going_down(void)
612 {
613 return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
614 || system_state == SYSTEM_RESTART;
615 }
616
617 struct ext4_err_translation {
618 int code;
619 int errno;
620 };
621
622 #define EXT4_ERR_TRANSLATE(err) { .code = EXT4_ERR_##err, .errno = err }
623
624 static struct ext4_err_translation err_translation[] = {
625 EXT4_ERR_TRANSLATE(EIO),
626 EXT4_ERR_TRANSLATE(ENOMEM),
627 EXT4_ERR_TRANSLATE(EFSBADCRC),
628 EXT4_ERR_TRANSLATE(EFSCORRUPTED),
629 EXT4_ERR_TRANSLATE(ENOSPC),
630 EXT4_ERR_TRANSLATE(ENOKEY),
631 EXT4_ERR_TRANSLATE(EROFS),
632 EXT4_ERR_TRANSLATE(EFBIG),
633 EXT4_ERR_TRANSLATE(EEXIST),
634 EXT4_ERR_TRANSLATE(ERANGE),
635 EXT4_ERR_TRANSLATE(EOVERFLOW),
636 EXT4_ERR_TRANSLATE(EBUSY),
637 EXT4_ERR_TRANSLATE(ENOTDIR),
638 EXT4_ERR_TRANSLATE(ENOTEMPTY),
639 EXT4_ERR_TRANSLATE(ESHUTDOWN),
640 EXT4_ERR_TRANSLATE(EFAULT),
641 };
642
ext4_errno_to_code(int errno)643 static int ext4_errno_to_code(int errno)
644 {
645 int i;
646
647 for (i = 0; i < ARRAY_SIZE(err_translation); i++)
648 if (err_translation[i].errno == errno)
649 return err_translation[i].code;
650 return EXT4_ERR_UNKNOWN;
651 }
652
save_error_info(struct super_block * sb,int error,__u32 ino,__u64 block,const char * func,unsigned int line)653 static void save_error_info(struct super_block *sb, int error,
654 __u32 ino, __u64 block,
655 const char *func, unsigned int line)
656 {
657 struct ext4_sb_info *sbi = EXT4_SB(sb);
658
659 /* We default to EFSCORRUPTED error... */
660 if (error == 0)
661 error = EFSCORRUPTED;
662
663 spin_lock(&sbi->s_error_lock);
664 sbi->s_add_error_count++;
665 sbi->s_last_error_code = error;
666 sbi->s_last_error_line = line;
667 sbi->s_last_error_ino = ino;
668 sbi->s_last_error_block = block;
669 sbi->s_last_error_func = func;
670 sbi->s_last_error_time = ktime_get_real_seconds();
671 if (!sbi->s_first_error_time) {
672 sbi->s_first_error_code = error;
673 sbi->s_first_error_line = line;
674 sbi->s_first_error_ino = ino;
675 sbi->s_first_error_block = block;
676 sbi->s_first_error_func = func;
677 sbi->s_first_error_time = sbi->s_last_error_time;
678 }
679 spin_unlock(&sbi->s_error_lock);
680 }
681
682 /* Deal with the reporting of failure conditions on a filesystem such as
683 * inconsistencies detected or read IO failures.
684 *
685 * On ext2, we can store the error state of the filesystem in the
686 * superblock. That is not possible on ext4, because we may have other
687 * write ordering constraints on the superblock which prevent us from
688 * writing it out straight away; and given that the journal is about to
689 * be aborted, we can't rely on the current, or future, transactions to
690 * write out the superblock safely.
691 *
692 * We'll just use the jbd2_journal_abort() error code to record an error in
693 * the journal instead. On recovery, the journal will complain about
694 * that error until we've noted it down and cleared it.
695 *
696 * If force_ro is set, we unconditionally force the filesystem into an
697 * ABORT|READONLY state, unless the error response on the fs has been set to
698 * panic in which case we take the easy way out and panic immediately. This is
699 * used to deal with unrecoverable failures such as journal IO errors or ENOMEM
700 * at a critical moment in log management.
701 */
ext4_handle_error(struct super_block * sb,bool force_ro,int error,__u32 ino,__u64 block,const char * func,unsigned int line)702 static void ext4_handle_error(struct super_block *sb, bool force_ro, int error,
703 __u32 ino, __u64 block,
704 const char *func, unsigned int line)
705 {
706 journal_t *journal = EXT4_SB(sb)->s_journal;
707 bool continue_fs = !force_ro && test_opt(sb, ERRORS_CONT);
708
709 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
710 if (test_opt(sb, WARN_ON_ERROR))
711 WARN_ON_ONCE(1);
712
713 if (!continue_fs && !sb_rdonly(sb)) {
714 set_bit(EXT4_FLAGS_SHUTDOWN, &EXT4_SB(sb)->s_ext4_flags);
715 if (journal)
716 jbd2_journal_abort(journal, -EIO);
717 }
718
719 if (!bdev_read_only(sb->s_bdev)) {
720 save_error_info(sb, error, ino, block, func, line);
721 /*
722 * In case the fs should keep running, we need to writeout
723 * superblock through the journal. Due to lock ordering
724 * constraints, it may not be safe to do it right here so we
725 * defer superblock flushing to a workqueue.
726 */
727 if (continue_fs && journal)
728 schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
729 else
730 ext4_commit_super(sb);
731 }
732
733 /*
734 * We force ERRORS_RO behavior when system is rebooting. Otherwise we
735 * could panic during 'reboot -f' as the underlying device got already
736 * disabled.
737 */
738 if (test_opt(sb, ERRORS_PANIC) && !system_going_down()) {
739 panic("EXT4-fs (device %s): panic forced after error\n",
740 sb->s_id);
741 }
742
743 if (sb_rdonly(sb) || continue_fs)
744 return;
745
746 ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
747 /*
748 * Make sure updated value of ->s_mount_flags will be visible before
749 * ->s_flags update
750 */
751 smp_wmb();
752 sb->s_flags |= SB_RDONLY;
753 }
754
update_super_work(struct work_struct * work)755 static void update_super_work(struct work_struct *work)
756 {
757 struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info,
758 s_sb_upd_work);
759 journal_t *journal = sbi->s_journal;
760 handle_t *handle;
761
762 /*
763 * If the journal is still running, we have to write out superblock
764 * through the journal to avoid collisions of other journalled sb
765 * updates.
766 *
767 * We use directly jbd2 functions here to avoid recursing back into
768 * ext4 error handling code during handling of previous errors.
769 */
770 if (!sb_rdonly(sbi->s_sb) && journal) {
771 struct buffer_head *sbh = sbi->s_sbh;
772 bool call_notify_err = false;
773
774 handle = jbd2_journal_start(journal, 1);
775 if (IS_ERR(handle))
776 goto write_directly;
777 if (jbd2_journal_get_write_access(handle, sbh)) {
778 jbd2_journal_stop(handle);
779 goto write_directly;
780 }
781
782 if (sbi->s_add_error_count > 0)
783 call_notify_err = true;
784
785 ext4_update_super(sbi->s_sb);
786 if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
787 ext4_msg(sbi->s_sb, KERN_ERR, "previous I/O error to "
788 "superblock detected");
789 clear_buffer_write_io_error(sbh);
790 set_buffer_uptodate(sbh);
791 }
792
793 if (jbd2_journal_dirty_metadata(handle, sbh)) {
794 jbd2_journal_stop(handle);
795 goto write_directly;
796 }
797 jbd2_journal_stop(handle);
798
799 if (call_notify_err)
800 ext4_notify_error_sysfs(sbi);
801
802 return;
803 }
804 write_directly:
805 /*
806 * Write through journal failed. Write sb directly to get error info
807 * out and hope for the best.
808 */
809 ext4_commit_super(sbi->s_sb);
810 ext4_notify_error_sysfs(sbi);
811 }
812
813 #define ext4_error_ratelimit(sb) \
814 ___ratelimit(&(EXT4_SB(sb)->s_err_ratelimit_state), \
815 "EXT4-fs error")
816
__ext4_error(struct super_block * sb,const char * function,unsigned int line,bool force_ro,int error,__u64 block,const char * fmt,...)817 void __ext4_error(struct super_block *sb, const char *function,
818 unsigned int line, bool force_ro, int error, __u64 block,
819 const char *fmt, ...)
820 {
821 struct va_format vaf;
822 va_list args;
823
824 if (unlikely(ext4_forced_shutdown(sb)))
825 return;
826
827 trace_ext4_error(sb, function, line);
828 if (ext4_error_ratelimit(sb)) {
829 va_start(args, fmt);
830 vaf.fmt = fmt;
831 vaf.va = &args;
832 printk(KERN_CRIT
833 "EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
834 sb->s_id, function, line, current->comm, &vaf);
835 va_end(args);
836 }
837 fsnotify_sb_error(sb, NULL, error ? error : EFSCORRUPTED);
838
839 ext4_handle_error(sb, force_ro, error, 0, block, function, line);
840 }
841
__ext4_error_inode(struct inode * inode,const char * function,unsigned int line,ext4_fsblk_t block,int error,const char * fmt,...)842 void __ext4_error_inode(struct inode *inode, const char *function,
843 unsigned int line, ext4_fsblk_t block, int error,
844 const char *fmt, ...)
845 {
846 va_list args;
847 struct va_format vaf;
848
849 if (unlikely(ext4_forced_shutdown(inode->i_sb)))
850 return;
851
852 trace_ext4_error(inode->i_sb, function, line);
853 if (ext4_error_ratelimit(inode->i_sb)) {
854 va_start(args, fmt);
855 vaf.fmt = fmt;
856 vaf.va = &args;
857 if (block)
858 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
859 "inode #%lu: block %llu: comm %s: %pV\n",
860 inode->i_sb->s_id, function, line, inode->i_ino,
861 block, current->comm, &vaf);
862 else
863 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
864 "inode #%lu: comm %s: %pV\n",
865 inode->i_sb->s_id, function, line, inode->i_ino,
866 current->comm, &vaf);
867 va_end(args);
868 }
869 fsnotify_sb_error(inode->i_sb, inode, error ? error : EFSCORRUPTED);
870
871 ext4_handle_error(inode->i_sb, false, error, inode->i_ino, block,
872 function, line);
873 }
874
__ext4_error_file(struct file * file,const char * function,unsigned int line,ext4_fsblk_t block,const char * fmt,...)875 void __ext4_error_file(struct file *file, const char *function,
876 unsigned int line, ext4_fsblk_t block,
877 const char *fmt, ...)
878 {
879 va_list args;
880 struct va_format vaf;
881 struct inode *inode = file_inode(file);
882 char pathname[80], *path;
883
884 if (unlikely(ext4_forced_shutdown(inode->i_sb)))
885 return;
886
887 trace_ext4_error(inode->i_sb, function, line);
888 if (ext4_error_ratelimit(inode->i_sb)) {
889 path = file_path(file, pathname, sizeof(pathname));
890 if (IS_ERR(path))
891 path = "(unknown)";
892 va_start(args, fmt);
893 vaf.fmt = fmt;
894 vaf.va = &args;
895 if (block)
896 printk(KERN_CRIT
897 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
898 "block %llu: comm %s: path %s: %pV\n",
899 inode->i_sb->s_id, function, line, inode->i_ino,
900 block, current->comm, path, &vaf);
901 else
902 printk(KERN_CRIT
903 "EXT4-fs error (device %s): %s:%d: inode #%lu: "
904 "comm %s: path %s: %pV\n",
905 inode->i_sb->s_id, function, line, inode->i_ino,
906 current->comm, path, &vaf);
907 va_end(args);
908 }
909 fsnotify_sb_error(inode->i_sb, inode, EFSCORRUPTED);
910
911 ext4_handle_error(inode->i_sb, false, EFSCORRUPTED, inode->i_ino, block,
912 function, line);
913 }
914
ext4_decode_error(struct super_block * sb,int errno,char nbuf[16])915 const char *ext4_decode_error(struct super_block *sb, int errno,
916 char nbuf[16])
917 {
918 char *errstr = NULL;
919
920 switch (errno) {
921 case -EFSCORRUPTED:
922 errstr = "Corrupt filesystem";
923 break;
924 case -EFSBADCRC:
925 errstr = "Filesystem failed CRC";
926 break;
927 case -EIO:
928 errstr = "IO failure";
929 break;
930 case -ENOMEM:
931 errstr = "Out of memory";
932 break;
933 case -EROFS:
934 if (!sb || (EXT4_SB(sb)->s_journal &&
935 EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT))
936 errstr = "Journal has aborted";
937 else
938 errstr = "Readonly filesystem";
939 break;
940 default:
941 /* If the caller passed in an extra buffer for unknown
942 * errors, textualise them now. Else we just return
943 * NULL. */
944 if (nbuf) {
945 /* Check for truncated error codes... */
946 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
947 errstr = nbuf;
948 }
949 break;
950 }
951
952 return errstr;
953 }
954
955 /* __ext4_std_error decodes expected errors from journaling functions
956 * automatically and invokes the appropriate error response. */
957
__ext4_std_error(struct super_block * sb,const char * function,unsigned int line,int errno)958 void __ext4_std_error(struct super_block *sb, const char *function,
959 unsigned int line, int errno)
960 {
961 char nbuf[16];
962 const char *errstr;
963
964 if (unlikely(ext4_forced_shutdown(sb)))
965 return;
966
967 /* Special case: if the error is EROFS, and we're not already
968 * inside a transaction, then there's really no point in logging
969 * an error. */
970 if (errno == -EROFS && journal_current_handle() == NULL && sb_rdonly(sb))
971 return;
972
973 if (ext4_error_ratelimit(sb)) {
974 errstr = ext4_decode_error(sb, errno, nbuf);
975 printk(KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n",
976 sb->s_id, function, line, errstr);
977 }
978 fsnotify_sb_error(sb, NULL, errno ? errno : EFSCORRUPTED);
979
980 ext4_handle_error(sb, false, -errno, 0, 0, function, line);
981 }
982
__ext4_msg(struct super_block * sb,const char * prefix,const char * fmt,...)983 void __ext4_msg(struct super_block *sb,
984 const char *prefix, const char *fmt, ...)
985 {
986 struct va_format vaf;
987 va_list args;
988
989 if (sb) {
990 atomic_inc(&EXT4_SB(sb)->s_msg_count);
991 if (!___ratelimit(&(EXT4_SB(sb)->s_msg_ratelimit_state),
992 "EXT4-fs"))
993 return;
994 }
995
996 va_start(args, fmt);
997 vaf.fmt = fmt;
998 vaf.va = &args;
999 if (sb)
1000 printk("%sEXT4-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
1001 else
1002 printk("%sEXT4-fs: %pV\n", prefix, &vaf);
1003 va_end(args);
1004 }
1005
ext4_warning_ratelimit(struct super_block * sb)1006 static int ext4_warning_ratelimit(struct super_block *sb)
1007 {
1008 atomic_inc(&EXT4_SB(sb)->s_warning_count);
1009 return ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state),
1010 "EXT4-fs warning");
1011 }
1012
__ext4_warning(struct super_block * sb,const char * function,unsigned int line,const char * fmt,...)1013 void __ext4_warning(struct super_block *sb, const char *function,
1014 unsigned int line, const char *fmt, ...)
1015 {
1016 struct va_format vaf;
1017 va_list args;
1018
1019 if (!ext4_warning_ratelimit(sb))
1020 return;
1021
1022 va_start(args, fmt);
1023 vaf.fmt = fmt;
1024 vaf.va = &args;
1025 printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: %pV\n",
1026 sb->s_id, function, line, &vaf);
1027 va_end(args);
1028 }
1029
__ext4_warning_inode(const struct inode * inode,const char * function,unsigned int line,const char * fmt,...)1030 void __ext4_warning_inode(const struct inode *inode, const char *function,
1031 unsigned int line, const char *fmt, ...)
1032 {
1033 struct va_format vaf;
1034 va_list args;
1035
1036 if (!ext4_warning_ratelimit(inode->i_sb))
1037 return;
1038
1039 va_start(args, fmt);
1040 vaf.fmt = fmt;
1041 vaf.va = &args;
1042 printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
1043 "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
1044 function, line, inode->i_ino, current->comm, &vaf);
1045 va_end(args);
1046 }
1047
__ext4_grp_locked_error(const char * function,unsigned int line,struct super_block * sb,ext4_group_t grp,unsigned long ino,ext4_fsblk_t block,const char * fmt,...)1048 void __ext4_grp_locked_error(const char *function, unsigned int line,
1049 struct super_block *sb, ext4_group_t grp,
1050 unsigned long ino, ext4_fsblk_t block,
1051 const char *fmt, ...)
1052 __releases(bitlock)
1053 __acquires(bitlock)
1054 {
1055 struct va_format vaf;
1056 va_list args;
1057
1058 if (unlikely(ext4_forced_shutdown(sb)))
1059 return;
1060
1061 trace_ext4_error(sb, function, line);
1062 if (ext4_error_ratelimit(sb)) {
1063 va_start(args, fmt);
1064 vaf.fmt = fmt;
1065 vaf.va = &args;
1066 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
1067 sb->s_id, function, line, grp);
1068 if (ino)
1069 printk(KERN_CONT "inode %lu: ", ino);
1070 if (block)
1071 printk(KERN_CONT "block %llu:",
1072 (unsigned long long) block);
1073 printk(KERN_CONT "%pV\n", &vaf);
1074 va_end(args);
1075 }
1076
1077 if (test_opt(sb, ERRORS_CONT)) {
1078 if (test_opt(sb, WARN_ON_ERROR))
1079 WARN_ON_ONCE(1);
1080 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
1081 if (!bdev_read_only(sb->s_bdev)) {
1082 save_error_info(sb, EFSCORRUPTED, ino, block, function,
1083 line);
1084 schedule_work(&EXT4_SB(sb)->s_sb_upd_work);
1085 }
1086 return;
1087 }
1088 ext4_unlock_group(sb, grp);
1089 ext4_handle_error(sb, false, EFSCORRUPTED, ino, block, function, line);
1090 /*
1091 * We only get here in the ERRORS_RO case; relocking the group
1092 * may be dangerous, but nothing bad will happen since the
1093 * filesystem will have already been marked read/only and the
1094 * journal has been aborted. We return 1 as a hint to callers
1095 * who might what to use the return value from
1096 * ext4_grp_locked_error() to distinguish between the
1097 * ERRORS_CONT and ERRORS_RO case, and perhaps return more
1098 * aggressively from the ext4 function in question, with a
1099 * more appropriate error code.
1100 */
1101 ext4_lock_group(sb, grp);
1102 return;
1103 }
1104
ext4_mark_group_bitmap_corrupted(struct super_block * sb,ext4_group_t group,unsigned int flags)1105 void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
1106 ext4_group_t group,
1107 unsigned int flags)
1108 {
1109 struct ext4_sb_info *sbi = EXT4_SB(sb);
1110 struct ext4_group_info *grp = ext4_get_group_info(sb, group);
1111 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
1112 int ret;
1113
1114 if (!grp || !gdp)
1115 return;
1116 if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
1117 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
1118 &grp->bb_state);
1119 if (!ret)
1120 percpu_counter_sub(&sbi->s_freeclusters_counter,
1121 grp->bb_free);
1122 }
1123
1124 if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT) {
1125 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
1126 &grp->bb_state);
1127 if (!ret && gdp) {
1128 int count;
1129
1130 count = ext4_free_inodes_count(sb, gdp);
1131 percpu_counter_sub(&sbi->s_freeinodes_counter,
1132 count);
1133 }
1134 }
1135 }
1136
ext4_update_dynamic_rev(struct super_block * sb)1137 void ext4_update_dynamic_rev(struct super_block *sb)
1138 {
1139 struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1140
1141 if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1142 return;
1143
1144 ext4_warning(sb,
1145 "updating to rev %d because of new feature flag, "
1146 "running e2fsck is recommended",
1147 EXT4_DYNAMIC_REV);
1148
1149 es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
1150 es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
1151 es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
1152 /* leave es->s_feature_*compat flags alone */
1153 /* es->s_uuid will be set by e2fsck if empty */
1154
1155 /*
1156 * The rest of the superblock fields should be zero, and if not it
1157 * means they are likely already in use, so leave them alone. We
1158 * can leave it up to e2fsck to clean up any inconsistencies there.
1159 */
1160 }
1161
orphan_list_entry(struct list_head * l)1162 static inline struct inode *orphan_list_entry(struct list_head *l)
1163 {
1164 return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
1165 }
1166
dump_orphan_list(struct super_block * sb,struct ext4_sb_info * sbi)1167 static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
1168 {
1169 struct list_head *l;
1170
1171 ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
1172 le32_to_cpu(sbi->s_es->s_last_orphan));
1173
1174 printk(KERN_ERR "sb_info orphan list:\n");
1175 list_for_each(l, &sbi->s_orphan) {
1176 struct inode *inode = orphan_list_entry(l);
1177 printk(KERN_ERR " "
1178 "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1179 inode->i_sb->s_id, inode->i_ino, inode,
1180 inode->i_mode, inode->i_nlink,
1181 NEXT_ORPHAN(inode));
1182 }
1183 }
1184
1185 #ifdef CONFIG_QUOTA
1186 static int ext4_quota_off(struct super_block *sb, int type);
1187
ext4_quotas_off(struct super_block * sb,int type)1188 static inline void ext4_quotas_off(struct super_block *sb, int type)
1189 {
1190 BUG_ON(type > EXT4_MAXQUOTAS);
1191
1192 /* Use our quota_off function to clear inode flags etc. */
1193 for (type--; type >= 0; type--)
1194 ext4_quota_off(sb, type);
1195 }
1196
1197 /*
1198 * This is a helper function which is used in the mount/remount
1199 * codepaths (which holds s_umount) to fetch the quota file name.
1200 */
get_qf_name(struct super_block * sb,struct ext4_sb_info * sbi,int type)1201 static inline char *get_qf_name(struct super_block *sb,
1202 struct ext4_sb_info *sbi,
1203 int type)
1204 {
1205 return rcu_dereference_protected(sbi->s_qf_names[type],
1206 lockdep_is_held(&sb->s_umount));
1207 }
1208 #else
ext4_quotas_off(struct super_block * sb,int type)1209 static inline void ext4_quotas_off(struct super_block *sb, int type)
1210 {
1211 }
1212 #endif
1213
ext4_percpu_param_init(struct ext4_sb_info * sbi)1214 static int ext4_percpu_param_init(struct ext4_sb_info *sbi)
1215 {
1216 ext4_fsblk_t block;
1217 int err;
1218
1219 block = ext4_count_free_clusters(sbi->s_sb);
1220 ext4_free_blocks_count_set(sbi->s_es, EXT4_C2B(sbi, block));
1221 err = percpu_counter_init(&sbi->s_freeclusters_counter, block,
1222 GFP_KERNEL);
1223 if (!err) {
1224 unsigned long freei = ext4_count_free_inodes(sbi->s_sb);
1225 sbi->s_es->s_free_inodes_count = cpu_to_le32(freei);
1226 err = percpu_counter_init(&sbi->s_freeinodes_counter, freei,
1227 GFP_KERNEL);
1228 }
1229 if (!err)
1230 err = percpu_counter_init(&sbi->s_dirs_counter,
1231 ext4_count_dirs(sbi->s_sb), GFP_KERNEL);
1232 if (!err)
1233 err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
1234 GFP_KERNEL);
1235 if (!err)
1236 err = percpu_counter_init(&sbi->s_sra_exceeded_retry_limit, 0,
1237 GFP_KERNEL);
1238 if (!err)
1239 err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
1240
1241 if (err)
1242 ext4_msg(sbi->s_sb, KERN_ERR, "insufficient memory");
1243
1244 return err;
1245 }
1246
ext4_percpu_param_destroy(struct ext4_sb_info * sbi)1247 static void ext4_percpu_param_destroy(struct ext4_sb_info *sbi)
1248 {
1249 percpu_counter_destroy(&sbi->s_freeclusters_counter);
1250 percpu_counter_destroy(&sbi->s_freeinodes_counter);
1251 percpu_counter_destroy(&sbi->s_dirs_counter);
1252 percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
1253 percpu_counter_destroy(&sbi->s_sra_exceeded_retry_limit);
1254 percpu_free_rwsem(&sbi->s_writepages_rwsem);
1255 }
1256
ext4_group_desc_free(struct ext4_sb_info * sbi)1257 static void ext4_group_desc_free(struct ext4_sb_info *sbi)
1258 {
1259 struct buffer_head **group_desc;
1260 int i;
1261
1262 rcu_read_lock();
1263 group_desc = rcu_dereference(sbi->s_group_desc);
1264 for (i = 0; i < sbi->s_gdb_count; i++)
1265 brelse(group_desc[i]);
1266 kvfree(group_desc);
1267 rcu_read_unlock();
1268 }
1269
ext4_flex_groups_free(struct ext4_sb_info * sbi)1270 static void ext4_flex_groups_free(struct ext4_sb_info *sbi)
1271 {
1272 struct flex_groups **flex_groups;
1273 int i;
1274
1275 rcu_read_lock();
1276 flex_groups = rcu_dereference(sbi->s_flex_groups);
1277 if (flex_groups) {
1278 for (i = 0; i < sbi->s_flex_groups_allocated; i++)
1279 kvfree(flex_groups[i]);
1280 kvfree(flex_groups);
1281 }
1282 rcu_read_unlock();
1283 }
1284
ext4_put_super(struct super_block * sb)1285 static void ext4_put_super(struct super_block *sb)
1286 {
1287 struct ext4_sb_info *sbi = EXT4_SB(sb);
1288 struct ext4_super_block *es = sbi->s_es;
1289 int aborted = 0;
1290 int err;
1291
1292 /*
1293 * Unregister sysfs before destroying jbd2 journal.
1294 * Since we could still access attr_journal_task attribute via sysfs
1295 * path which could have sbi->s_journal->j_task as NULL
1296 * Unregister sysfs before flush sbi->s_sb_upd_work.
1297 * Since user may read /proc/fs/ext4/xx/mb_groups during umount, If
1298 * read metadata verify failed then will queue error work.
1299 * update_super_work will call start_this_handle may trigger
1300 * BUG_ON.
1301 */
1302 ext4_unregister_sysfs(sb);
1303
1304 if (___ratelimit(&ext4_mount_msg_ratelimit, "EXT4-fs unmount"))
1305 ext4_msg(sb, KERN_INFO, "unmounting filesystem %pU.",
1306 &sb->s_uuid);
1307
1308 ext4_unregister_li_request(sb);
1309 ext4_quotas_off(sb, EXT4_MAXQUOTAS);
1310
1311 flush_work(&sbi->s_sb_upd_work);
1312 destroy_workqueue(sbi->rsv_conversion_wq);
1313 ext4_release_orphan_info(sb);
1314
1315 if (sbi->s_journal) {
1316 aborted = is_journal_aborted(sbi->s_journal);
1317 err = jbd2_journal_destroy(sbi->s_journal);
1318 sbi->s_journal = NULL;
1319 if ((err < 0) && !aborted) {
1320 ext4_abort(sb, -err, "Couldn't clean up the journal");
1321 }
1322 }
1323
1324 ext4_es_unregister_shrinker(sbi);
1325 timer_shutdown_sync(&sbi->s_err_report);
1326 ext4_release_system_zone(sb);
1327 ext4_mb_release(sb);
1328 ext4_ext_release(sb);
1329
1330 if (!sb_rdonly(sb) && !aborted) {
1331 ext4_clear_feature_journal_needs_recovery(sb);
1332 ext4_clear_feature_orphan_present(sb);
1333 es->s_state = cpu_to_le16(sbi->s_mount_state);
1334 }
1335 if (!sb_rdonly(sb))
1336 ext4_commit_super(sb);
1337
1338 ext4_group_desc_free(sbi);
1339 ext4_flex_groups_free(sbi);
1340 ext4_percpu_param_destroy(sbi);
1341 #ifdef CONFIG_QUOTA
1342 for (int i = 0; i < EXT4_MAXQUOTAS; i++)
1343 kfree(get_qf_name(sb, sbi, i));
1344 #endif
1345
1346 /* Debugging code just in case the in-memory inode orphan list
1347 * isn't empty. The on-disk one can be non-empty if we've
1348 * detected an error and taken the fs readonly, but the
1349 * in-memory list had better be clean by this point. */
1350 if (!list_empty(&sbi->s_orphan))
1351 dump_orphan_list(sb, sbi);
1352 ASSERT(list_empty(&sbi->s_orphan));
1353
1354 sync_blockdev(sb->s_bdev);
1355 invalidate_bdev(sb->s_bdev);
1356 if (sbi->s_journal_bdev) {
1357 /*
1358 * Invalidate the journal device's buffers. We don't want them
1359 * floating about in memory - the physical journal device may
1360 * hotswapped, and it breaks the `ro-after' testing code.
1361 */
1362 sync_blockdev(sbi->s_journal_bdev);
1363 invalidate_bdev(sbi->s_journal_bdev);
1364 }
1365
1366 ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
1367 sbi->s_ea_inode_cache = NULL;
1368
1369 ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
1370 sbi->s_ea_block_cache = NULL;
1371
1372 ext4_stop_mmpd(sbi);
1373
1374 brelse(sbi->s_sbh);
1375 sb->s_fs_info = NULL;
1376 /*
1377 * Now that we are completely done shutting down the
1378 * superblock, we need to actually destroy the kobject.
1379 */
1380 kobject_put(&sbi->s_kobj);
1381 wait_for_completion(&sbi->s_kobj_unregister);
1382 if (sbi->s_chksum_driver)
1383 crypto_free_shash(sbi->s_chksum_driver);
1384 kfree(sbi->s_blockgroup_lock);
1385 fs_put_dax(sbi->s_daxdev, NULL);
1386 fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
1387 #if IS_ENABLED(CONFIG_UNICODE)
1388 utf8_unload(sb->s_encoding);
1389 #endif
1390 kfree(sbi);
1391 }
1392
1393 static struct kmem_cache *ext4_inode_cachep;
1394
1395 /*
1396 * Called inside transaction, so use GFP_NOFS
1397 */
ext4_alloc_inode(struct super_block * sb)1398 static struct inode *ext4_alloc_inode(struct super_block *sb)
1399 {
1400 struct ext4_inode_info *ei;
1401
1402 ei = alloc_inode_sb(sb, ext4_inode_cachep, GFP_NOFS);
1403 if (!ei)
1404 return NULL;
1405
1406 inode_set_iversion(&ei->vfs_inode, 1);
1407 ei->i_flags = 0;
1408 spin_lock_init(&ei->i_raw_lock);
1409 ei->i_prealloc_node = RB_ROOT;
1410 atomic_set(&ei->i_prealloc_active, 0);
1411 rwlock_init(&ei->i_prealloc_lock);
1412 ext4_es_init_tree(&ei->i_es_tree);
1413 rwlock_init(&ei->i_es_lock);
1414 INIT_LIST_HEAD(&ei->i_es_list);
1415 ei->i_es_all_nr = 0;
1416 ei->i_es_shk_nr = 0;
1417 ei->i_es_shrink_lblk = 0;
1418 ei->i_reserved_data_blocks = 0;
1419 spin_lock_init(&(ei->i_block_reservation_lock));
1420 ext4_init_pending_tree(&ei->i_pending_tree);
1421 #ifdef CONFIG_QUOTA
1422 ei->i_reserved_quota = 0;
1423 memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
1424 #endif
1425 ei->jinode = NULL;
1426 INIT_LIST_HEAD(&ei->i_rsv_conversion_list);
1427 spin_lock_init(&ei->i_completed_io_lock);
1428 ei->i_sync_tid = 0;
1429 ei->i_datasync_tid = 0;
1430 atomic_set(&ei->i_unwritten, 0);
1431 INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
1432 ext4_fc_init_inode(&ei->vfs_inode);
1433 mutex_init(&ei->i_fc_lock);
1434 return &ei->vfs_inode;
1435 }
1436
ext4_drop_inode(struct inode * inode)1437 static int ext4_drop_inode(struct inode *inode)
1438 {
1439 int drop = generic_drop_inode(inode);
1440
1441 if (!drop)
1442 drop = fscrypt_drop_inode(inode);
1443
1444 trace_ext4_drop_inode(inode, drop);
1445 return drop;
1446 }
1447
ext4_free_in_core_inode(struct inode * inode)1448 static void ext4_free_in_core_inode(struct inode *inode)
1449 {
1450 fscrypt_free_inode(inode);
1451 if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
1452 pr_warn("%s: inode %ld still in fc list",
1453 __func__, inode->i_ino);
1454 }
1455 kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1456 }
1457
ext4_destroy_inode(struct inode * inode)1458 static void ext4_destroy_inode(struct inode *inode)
1459 {
1460 if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
1461 ext4_msg(inode->i_sb, KERN_ERR,
1462 "Inode %lu (%p): orphan list check failed!",
1463 inode->i_ino, EXT4_I(inode));
1464 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
1465 EXT4_I(inode), sizeof(struct ext4_inode_info),
1466 true);
1467 dump_stack();
1468 }
1469
1470 if (EXT4_I(inode)->i_reserved_data_blocks)
1471 ext4_msg(inode->i_sb, KERN_ERR,
1472 "Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
1473 inode->i_ino, EXT4_I(inode),
1474 EXT4_I(inode)->i_reserved_data_blocks);
1475 }
1476
ext4_shutdown(struct super_block * sb)1477 static void ext4_shutdown(struct super_block *sb)
1478 {
1479 ext4_force_shutdown(sb, EXT4_GOING_FLAGS_NOLOGFLUSH);
1480 }
1481
init_once(void * foo)1482 static void init_once(void *foo)
1483 {
1484 struct ext4_inode_info *ei = foo;
1485
1486 INIT_LIST_HEAD(&ei->i_orphan);
1487 init_rwsem(&ei->xattr_sem);
1488 init_rwsem(&ei->i_data_sem);
1489 inode_init_once(&ei->vfs_inode);
1490 ext4_fc_init_inode(&ei->vfs_inode);
1491 }
1492
init_inodecache(void)1493 static int __init init_inodecache(void)
1494 {
1495 ext4_inode_cachep = kmem_cache_create_usercopy("ext4_inode_cache",
1496 sizeof(struct ext4_inode_info), 0,
1497 (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1498 SLAB_ACCOUNT),
1499 offsetof(struct ext4_inode_info, i_data),
1500 sizeof_field(struct ext4_inode_info, i_data),
1501 init_once);
1502 if (ext4_inode_cachep == NULL)
1503 return -ENOMEM;
1504 return 0;
1505 }
1506
destroy_inodecache(void)1507 static void destroy_inodecache(void)
1508 {
1509 /*
1510 * Make sure all delayed rcu free inodes are flushed before we
1511 * destroy cache.
1512 */
1513 rcu_barrier();
1514 kmem_cache_destroy(ext4_inode_cachep);
1515 }
1516
ext4_clear_inode(struct inode * inode)1517 void ext4_clear_inode(struct inode *inode)
1518 {
1519 ext4_fc_del(inode);
1520 invalidate_inode_buffers(inode);
1521 clear_inode(inode);
1522 ext4_discard_preallocations(inode, 0);
1523 ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
1524 dquot_drop(inode);
1525 if (EXT4_I(inode)->jinode) {
1526 jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1527 EXT4_I(inode)->jinode);
1528 jbd2_free_inode(EXT4_I(inode)->jinode);
1529 EXT4_I(inode)->jinode = NULL;
1530 }
1531 fscrypt_put_encryption_info(inode);
1532 fsverity_cleanup_inode(inode);
1533 }
1534
ext4_nfs_get_inode(struct super_block * sb,u64 ino,u32 generation)1535 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
1536 u64 ino, u32 generation)
1537 {
1538 struct inode *inode;
1539
1540 /*
1541 * Currently we don't know the generation for parent directory, so
1542 * a generation of 0 means "accept any"
1543 */
1544 inode = ext4_iget(sb, ino, EXT4_IGET_HANDLE);
1545 if (IS_ERR(inode))
1546 return ERR_CAST(inode);
1547 if (generation && inode->i_generation != generation) {
1548 iput(inode);
1549 return ERR_PTR(-ESTALE);
1550 }
1551
1552 return inode;
1553 }
1554
ext4_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)1555 static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
1556 int fh_len, int fh_type)
1557 {
1558 return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1559 ext4_nfs_get_inode);
1560 }
1561
ext4_fh_to_parent(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)1562 static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
1563 int fh_len, int fh_type)
1564 {
1565 return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1566 ext4_nfs_get_inode);
1567 }
1568
ext4_nfs_commit_metadata(struct inode * inode)1569 static int ext4_nfs_commit_metadata(struct inode *inode)
1570 {
1571 struct writeback_control wbc = {
1572 .sync_mode = WB_SYNC_ALL
1573 };
1574
1575 trace_ext4_nfs_commit_metadata(inode);
1576 return ext4_write_inode(inode, &wbc);
1577 }
1578
1579 #ifdef CONFIG_QUOTA
1580 static const char * const quotatypes[] = INITQFNAMES;
1581 #define QTYPE2NAME(t) (quotatypes[t])
1582
1583 static int ext4_write_dquot(struct dquot *dquot);
1584 static int ext4_acquire_dquot(struct dquot *dquot);
1585 static int ext4_release_dquot(struct dquot *dquot);
1586 static int ext4_mark_dquot_dirty(struct dquot *dquot);
1587 static int ext4_write_info(struct super_block *sb, int type);
1588 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
1589 const struct path *path);
1590 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
1591 size_t len, loff_t off);
1592 static ssize_t ext4_quota_write(struct super_block *sb, int type,
1593 const char *data, size_t len, loff_t off);
1594 static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1595 unsigned int flags);
1596
ext4_get_dquots(struct inode * inode)1597 static struct dquot __rcu **ext4_get_dquots(struct inode *inode)
1598 {
1599 return EXT4_I(inode)->i_dquot;
1600 }
1601
1602 static const struct dquot_operations ext4_quota_operations = {
1603 .get_reserved_space = ext4_get_reserved_space,
1604 .write_dquot = ext4_write_dquot,
1605 .acquire_dquot = ext4_acquire_dquot,
1606 .release_dquot = ext4_release_dquot,
1607 .mark_dirty = ext4_mark_dquot_dirty,
1608 .write_info = ext4_write_info,
1609 .alloc_dquot = dquot_alloc,
1610 .destroy_dquot = dquot_destroy,
1611 .get_projid = ext4_get_projid,
1612 .get_inode_usage = ext4_get_inode_usage,
1613 .get_next_id = dquot_get_next_id,
1614 };
1615
1616 static const struct quotactl_ops ext4_qctl_operations = {
1617 .quota_on = ext4_quota_on,
1618 .quota_off = ext4_quota_off,
1619 .quota_sync = dquot_quota_sync,
1620 .get_state = dquot_get_state,
1621 .set_info = dquot_set_dqinfo,
1622 .get_dqblk = dquot_get_dqblk,
1623 .set_dqblk = dquot_set_dqblk,
1624 .get_nextdqblk = dquot_get_next_dqblk,
1625 };
1626 #endif
1627
1628 static const struct super_operations ext4_sops = {
1629 .alloc_inode = ext4_alloc_inode,
1630 .free_inode = ext4_free_in_core_inode,
1631 .destroy_inode = ext4_destroy_inode,
1632 .write_inode = ext4_write_inode,
1633 .dirty_inode = ext4_dirty_inode,
1634 .drop_inode = ext4_drop_inode,
1635 .evict_inode = ext4_evict_inode,
1636 .put_super = ext4_put_super,
1637 .sync_fs = ext4_sync_fs,
1638 .freeze_fs = ext4_freeze,
1639 .unfreeze_fs = ext4_unfreeze,
1640 .statfs = ext4_statfs,
1641 .show_options = ext4_show_options,
1642 .shutdown = ext4_shutdown,
1643 #ifdef CONFIG_QUOTA
1644 .quota_read = ext4_quota_read,
1645 .quota_write = ext4_quota_write,
1646 .get_dquots = ext4_get_dquots,
1647 #endif
1648 };
1649
1650 static const struct export_operations ext4_export_ops = {
1651 .fh_to_dentry = ext4_fh_to_dentry,
1652 .fh_to_parent = ext4_fh_to_parent,
1653 .get_parent = ext4_get_parent,
1654 .commit_metadata = ext4_nfs_commit_metadata,
1655 };
1656
1657 enum {
1658 Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1659 Opt_resgid, Opt_resuid, Opt_sb,
1660 Opt_nouid32, Opt_debug, Opt_removed,
1661 Opt_user_xattr, Opt_acl,
1662 Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload,
1663 Opt_commit, Opt_min_batch_time, Opt_max_batch_time, Opt_journal_dev,
1664 Opt_journal_path, Opt_journal_checksum, Opt_journal_async_commit,
1665 Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1666 Opt_data_err_abort, Opt_data_err_ignore, Opt_test_dummy_encryption,
1667 Opt_inlinecrypt,
1668 Opt_usrjquota, Opt_grpjquota, Opt_quota,
1669 Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1670 Opt_usrquota, Opt_grpquota, Opt_prjquota,
1671 Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1672 Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1673 Opt_nowarn_on_error, Opt_mblk_io_submit, Opt_debug_want_extra_isize,
1674 Opt_nomblk_io_submit, Opt_block_validity, Opt_noblock_validity,
1675 Opt_inode_readahead_blks, Opt_journal_ioprio,
1676 Opt_dioread_nolock, Opt_dioread_lock,
1677 Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1678 Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
1679 Opt_no_prefetch_block_bitmaps, Opt_mb_optimize_scan,
1680 Opt_errors, Opt_data, Opt_data_err, Opt_jqfmt, Opt_dax_type,
1681 #ifdef CONFIG_EXT4_DEBUG
1682 Opt_fc_debug_max_replay, Opt_fc_debug_force
1683 #endif
1684 };
1685
1686 static const struct constant_table ext4_param_errors[] = {
1687 {"continue", EXT4_MOUNT_ERRORS_CONT},
1688 {"panic", EXT4_MOUNT_ERRORS_PANIC},
1689 {"remount-ro", EXT4_MOUNT_ERRORS_RO},
1690 {}
1691 };
1692
1693 static const struct constant_table ext4_param_data[] = {
1694 {"journal", EXT4_MOUNT_JOURNAL_DATA},
1695 {"ordered", EXT4_MOUNT_ORDERED_DATA},
1696 {"writeback", EXT4_MOUNT_WRITEBACK_DATA},
1697 {}
1698 };
1699
1700 static const struct constant_table ext4_param_data_err[] = {
1701 {"abort", Opt_data_err_abort},
1702 {"ignore", Opt_data_err_ignore},
1703 {}
1704 };
1705
1706 static const struct constant_table ext4_param_jqfmt[] = {
1707 {"vfsold", QFMT_VFS_OLD},
1708 {"vfsv0", QFMT_VFS_V0},
1709 {"vfsv1", QFMT_VFS_V1},
1710 {}
1711 };
1712
1713 static const struct constant_table ext4_param_dax[] = {
1714 {"always", Opt_dax_always},
1715 {"inode", Opt_dax_inode},
1716 {"never", Opt_dax_never},
1717 {}
1718 };
1719
1720 /* String parameter that allows empty argument */
1721 #define fsparam_string_empty(NAME, OPT) \
1722 __fsparam(fs_param_is_string, NAME, OPT, fs_param_can_be_empty, NULL)
1723
1724 /*
1725 * Mount option specification
1726 * We don't use fsparam_flag_no because of the way we set the
1727 * options and the way we show them in _ext4_show_options(). To
1728 * keep the changes to a minimum, let's keep the negative options
1729 * separate for now.
1730 */
1731 static const struct fs_parameter_spec ext4_param_specs[] = {
1732 fsparam_flag ("bsddf", Opt_bsd_df),
1733 fsparam_flag ("minixdf", Opt_minix_df),
1734 fsparam_flag ("grpid", Opt_grpid),
1735 fsparam_flag ("bsdgroups", Opt_grpid),
1736 fsparam_flag ("nogrpid", Opt_nogrpid),
1737 fsparam_flag ("sysvgroups", Opt_nogrpid),
1738 fsparam_u32 ("resgid", Opt_resgid),
1739 fsparam_u32 ("resuid", Opt_resuid),
1740 fsparam_u32 ("sb", Opt_sb),
1741 fsparam_enum ("errors", Opt_errors, ext4_param_errors),
1742 fsparam_flag ("nouid32", Opt_nouid32),
1743 fsparam_flag ("debug", Opt_debug),
1744 fsparam_flag ("oldalloc", Opt_removed),
1745 fsparam_flag ("orlov", Opt_removed),
1746 fsparam_flag ("user_xattr", Opt_user_xattr),
1747 fsparam_flag ("acl", Opt_acl),
1748 fsparam_flag ("norecovery", Opt_noload),
1749 fsparam_flag ("noload", Opt_noload),
1750 fsparam_flag ("bh", Opt_removed),
1751 fsparam_flag ("nobh", Opt_removed),
1752 fsparam_u32 ("commit", Opt_commit),
1753 fsparam_u32 ("min_batch_time", Opt_min_batch_time),
1754 fsparam_u32 ("max_batch_time", Opt_max_batch_time),
1755 fsparam_u32 ("journal_dev", Opt_journal_dev),
1756 fsparam_bdev ("journal_path", Opt_journal_path),
1757 fsparam_flag ("journal_checksum", Opt_journal_checksum),
1758 fsparam_flag ("nojournal_checksum", Opt_nojournal_checksum),
1759 fsparam_flag ("journal_async_commit",Opt_journal_async_commit),
1760 fsparam_flag ("abort", Opt_abort),
1761 fsparam_enum ("data", Opt_data, ext4_param_data),
1762 fsparam_enum ("data_err", Opt_data_err,
1763 ext4_param_data_err),
1764 fsparam_string_empty
1765 ("usrjquota", Opt_usrjquota),
1766 fsparam_string_empty
1767 ("grpjquota", Opt_grpjquota),
1768 fsparam_enum ("jqfmt", Opt_jqfmt, ext4_param_jqfmt),
1769 fsparam_flag ("grpquota", Opt_grpquota),
1770 fsparam_flag ("quota", Opt_quota),
1771 fsparam_flag ("noquota", Opt_noquota),
1772 fsparam_flag ("usrquota", Opt_usrquota),
1773 fsparam_flag ("prjquota", Opt_prjquota),
1774 fsparam_flag ("barrier", Opt_barrier),
1775 fsparam_u32 ("barrier", Opt_barrier),
1776 fsparam_flag ("nobarrier", Opt_nobarrier),
1777 fsparam_flag ("i_version", Opt_removed),
1778 fsparam_flag ("dax", Opt_dax),
1779 fsparam_enum ("dax", Opt_dax_type, ext4_param_dax),
1780 fsparam_u32 ("stripe", Opt_stripe),
1781 fsparam_flag ("delalloc", Opt_delalloc),
1782 fsparam_flag ("nodelalloc", Opt_nodelalloc),
1783 fsparam_flag ("warn_on_error", Opt_warn_on_error),
1784 fsparam_flag ("nowarn_on_error", Opt_nowarn_on_error),
1785 fsparam_u32 ("debug_want_extra_isize",
1786 Opt_debug_want_extra_isize),
1787 fsparam_flag ("mblk_io_submit", Opt_removed),
1788 fsparam_flag ("nomblk_io_submit", Opt_removed),
1789 fsparam_flag ("block_validity", Opt_block_validity),
1790 fsparam_flag ("noblock_validity", Opt_noblock_validity),
1791 fsparam_u32 ("inode_readahead_blks",
1792 Opt_inode_readahead_blks),
1793 fsparam_u32 ("journal_ioprio", Opt_journal_ioprio),
1794 fsparam_u32 ("auto_da_alloc", Opt_auto_da_alloc),
1795 fsparam_flag ("auto_da_alloc", Opt_auto_da_alloc),
1796 fsparam_flag ("noauto_da_alloc", Opt_noauto_da_alloc),
1797 fsparam_flag ("dioread_nolock", Opt_dioread_nolock),
1798 fsparam_flag ("nodioread_nolock", Opt_dioread_lock),
1799 fsparam_flag ("dioread_lock", Opt_dioread_lock),
1800 fsparam_flag ("discard", Opt_discard),
1801 fsparam_flag ("nodiscard", Opt_nodiscard),
1802 fsparam_u32 ("init_itable", Opt_init_itable),
1803 fsparam_flag ("init_itable", Opt_init_itable),
1804 fsparam_flag ("noinit_itable", Opt_noinit_itable),
1805 #ifdef CONFIG_EXT4_DEBUG
1806 fsparam_flag ("fc_debug_force", Opt_fc_debug_force),
1807 fsparam_u32 ("fc_debug_max_replay", Opt_fc_debug_max_replay),
1808 #endif
1809 fsparam_u32 ("max_dir_size_kb", Opt_max_dir_size_kb),
1810 fsparam_flag ("test_dummy_encryption",
1811 Opt_test_dummy_encryption),
1812 fsparam_string ("test_dummy_encryption",
1813 Opt_test_dummy_encryption),
1814 fsparam_flag ("inlinecrypt", Opt_inlinecrypt),
1815 fsparam_flag ("nombcache", Opt_nombcache),
1816 fsparam_flag ("no_mbcache", Opt_nombcache), /* for backward compatibility */
1817 fsparam_flag ("prefetch_block_bitmaps",
1818 Opt_removed),
1819 fsparam_flag ("no_prefetch_block_bitmaps",
1820 Opt_no_prefetch_block_bitmaps),
1821 fsparam_s32 ("mb_optimize_scan", Opt_mb_optimize_scan),
1822 fsparam_string ("check", Opt_removed), /* mount option from ext2/3 */
1823 fsparam_flag ("nocheck", Opt_removed), /* mount option from ext2/3 */
1824 fsparam_flag ("reservation", Opt_removed), /* mount option from ext2/3 */
1825 fsparam_flag ("noreservation", Opt_removed), /* mount option from ext2/3 */
1826 fsparam_u32 ("journal", Opt_removed), /* mount option from ext2/3 */
1827 {}
1828 };
1829
1830 #define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
1831
1832 #define MOPT_SET 0x0001
1833 #define MOPT_CLEAR 0x0002
1834 #define MOPT_NOSUPPORT 0x0004
1835 #define MOPT_EXPLICIT 0x0008
1836 #ifdef CONFIG_QUOTA
1837 #define MOPT_Q 0
1838 #define MOPT_QFMT 0x0010
1839 #else
1840 #define MOPT_Q MOPT_NOSUPPORT
1841 #define MOPT_QFMT MOPT_NOSUPPORT
1842 #endif
1843 #define MOPT_NO_EXT2 0x0020
1844 #define MOPT_NO_EXT3 0x0040
1845 #define MOPT_EXT4_ONLY (MOPT_NO_EXT2 | MOPT_NO_EXT3)
1846 #define MOPT_SKIP 0x0080
1847 #define MOPT_2 0x0100
1848
1849 static const struct mount_opts {
1850 int token;
1851 int mount_opt;
1852 int flags;
1853 } ext4_mount_opts[] = {
1854 {Opt_minix_df, EXT4_MOUNT_MINIX_DF, MOPT_SET},
1855 {Opt_bsd_df, EXT4_MOUNT_MINIX_DF, MOPT_CLEAR},
1856 {Opt_grpid, EXT4_MOUNT_GRPID, MOPT_SET},
1857 {Opt_nogrpid, EXT4_MOUNT_GRPID, MOPT_CLEAR},
1858 {Opt_block_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_SET},
1859 {Opt_noblock_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_CLEAR},
1860 {Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK,
1861 MOPT_EXT4_ONLY | MOPT_SET},
1862 {Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK,
1863 MOPT_EXT4_ONLY | MOPT_CLEAR},
1864 {Opt_discard, EXT4_MOUNT_DISCARD, MOPT_SET},
1865 {Opt_nodiscard, EXT4_MOUNT_DISCARD, MOPT_CLEAR},
1866 {Opt_delalloc, EXT4_MOUNT_DELALLOC,
1867 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1868 {Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
1869 MOPT_EXT4_ONLY | MOPT_CLEAR},
1870 {Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1871 {Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
1872 {Opt_commit, 0, MOPT_NO_EXT2},
1873 {Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1874 MOPT_EXT4_ONLY | MOPT_CLEAR},
1875 {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1876 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1877 {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
1878 EXT4_MOUNT_JOURNAL_CHECKSUM),
1879 MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1880 {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
1881 {Opt_data_err, EXT4_MOUNT_DATA_ERR_ABORT, MOPT_NO_EXT2},
1882 {Opt_barrier, EXT4_MOUNT_BARRIER, MOPT_SET},
1883 {Opt_nobarrier, EXT4_MOUNT_BARRIER, MOPT_CLEAR},
1884 {Opt_noauto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_SET},
1885 {Opt_auto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_CLEAR},
1886 {Opt_noinit_itable, EXT4_MOUNT_INIT_INODE_TABLE, MOPT_CLEAR},
1887 {Opt_dax_type, 0, MOPT_EXT4_ONLY},
1888 {Opt_journal_dev, 0, MOPT_NO_EXT2},
1889 {Opt_journal_path, 0, MOPT_NO_EXT2},
1890 {Opt_journal_ioprio, 0, MOPT_NO_EXT2},
1891 {Opt_data, 0, MOPT_NO_EXT2},
1892 {Opt_user_xattr, EXT4_MOUNT_XATTR_USER, MOPT_SET},
1893 #ifdef CONFIG_EXT4_FS_POSIX_ACL
1894 {Opt_acl, EXT4_MOUNT_POSIX_ACL, MOPT_SET},
1895 #else
1896 {Opt_acl, 0, MOPT_NOSUPPORT},
1897 #endif
1898 {Opt_nouid32, EXT4_MOUNT_NO_UID32, MOPT_SET},
1899 {Opt_debug, EXT4_MOUNT_DEBUG, MOPT_SET},
1900 {Opt_quota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA, MOPT_SET | MOPT_Q},
1901 {Opt_usrquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA,
1902 MOPT_SET | MOPT_Q},
1903 {Opt_grpquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_GRPQUOTA,
1904 MOPT_SET | MOPT_Q},
1905 {Opt_prjquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_PRJQUOTA,
1906 MOPT_SET | MOPT_Q},
1907 {Opt_noquota, (EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
1908 EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA),
1909 MOPT_CLEAR | MOPT_Q},
1910 {Opt_usrjquota, 0, MOPT_Q},
1911 {Opt_grpjquota, 0, MOPT_Q},
1912 {Opt_jqfmt, 0, MOPT_QFMT},
1913 {Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
1914 {Opt_no_prefetch_block_bitmaps, EXT4_MOUNT_NO_PREFETCH_BLOCK_BITMAPS,
1915 MOPT_SET},
1916 #ifdef CONFIG_EXT4_DEBUG
1917 {Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
1918 MOPT_SET | MOPT_2 | MOPT_EXT4_ONLY},
1919 #endif
1920 {Opt_abort, EXT4_MOUNT2_ABORT, MOPT_SET | MOPT_2},
1921 {Opt_err, 0, 0}
1922 };
1923
1924 #if IS_ENABLED(CONFIG_UNICODE)
1925 static const struct ext4_sb_encodings {
1926 __u16 magic;
1927 char *name;
1928 unsigned int version;
1929 } ext4_sb_encoding_map[] = {
1930 {EXT4_ENC_UTF8_12_1, "utf8", UNICODE_AGE(12, 1, 0)},
1931 };
1932
1933 static const struct ext4_sb_encodings *
ext4_sb_read_encoding(const struct ext4_super_block * es)1934 ext4_sb_read_encoding(const struct ext4_super_block *es)
1935 {
1936 __u16 magic = le16_to_cpu(es->s_encoding);
1937 int i;
1938
1939 for (i = 0; i < ARRAY_SIZE(ext4_sb_encoding_map); i++)
1940 if (magic == ext4_sb_encoding_map[i].magic)
1941 return &ext4_sb_encoding_map[i];
1942
1943 return NULL;
1944 }
1945 #endif
1946
1947 #define EXT4_SPEC_JQUOTA (1 << 0)
1948 #define EXT4_SPEC_JQFMT (1 << 1)
1949 #define EXT4_SPEC_DATAJ (1 << 2)
1950 #define EXT4_SPEC_SB_BLOCK (1 << 3)
1951 #define EXT4_SPEC_JOURNAL_DEV (1 << 4)
1952 #define EXT4_SPEC_JOURNAL_IOPRIO (1 << 5)
1953 #define EXT4_SPEC_s_want_extra_isize (1 << 7)
1954 #define EXT4_SPEC_s_max_batch_time (1 << 8)
1955 #define EXT4_SPEC_s_min_batch_time (1 << 9)
1956 #define EXT4_SPEC_s_inode_readahead_blks (1 << 10)
1957 #define EXT4_SPEC_s_li_wait_mult (1 << 11)
1958 #define EXT4_SPEC_s_max_dir_size_kb (1 << 12)
1959 #define EXT4_SPEC_s_stripe (1 << 13)
1960 #define EXT4_SPEC_s_resuid (1 << 14)
1961 #define EXT4_SPEC_s_resgid (1 << 15)
1962 #define EXT4_SPEC_s_commit_interval (1 << 16)
1963 #define EXT4_SPEC_s_fc_debug_max_replay (1 << 17)
1964 #define EXT4_SPEC_s_sb_block (1 << 18)
1965 #define EXT4_SPEC_mb_optimize_scan (1 << 19)
1966
1967 struct ext4_fs_context {
1968 char *s_qf_names[EXT4_MAXQUOTAS];
1969 struct fscrypt_dummy_policy dummy_enc_policy;
1970 int s_jquota_fmt; /* Format of quota to use */
1971 #ifdef CONFIG_EXT4_DEBUG
1972 int s_fc_debug_max_replay;
1973 #endif
1974 unsigned short qname_spec;
1975 unsigned long vals_s_flags; /* Bits to set in s_flags */
1976 unsigned long mask_s_flags; /* Bits changed in s_flags */
1977 unsigned long journal_devnum;
1978 unsigned long s_commit_interval;
1979 unsigned long s_stripe;
1980 unsigned int s_inode_readahead_blks;
1981 unsigned int s_want_extra_isize;
1982 unsigned int s_li_wait_mult;
1983 unsigned int s_max_dir_size_kb;
1984 unsigned int journal_ioprio;
1985 unsigned int vals_s_mount_opt;
1986 unsigned int mask_s_mount_opt;
1987 unsigned int vals_s_mount_opt2;
1988 unsigned int mask_s_mount_opt2;
1989 unsigned int opt_flags; /* MOPT flags */
1990 unsigned int spec;
1991 u32 s_max_batch_time;
1992 u32 s_min_batch_time;
1993 kuid_t s_resuid;
1994 kgid_t s_resgid;
1995 ext4_fsblk_t s_sb_block;
1996 };
1997
ext4_fc_free(struct fs_context * fc)1998 static void ext4_fc_free(struct fs_context *fc)
1999 {
2000 struct ext4_fs_context *ctx = fc->fs_private;
2001 int i;
2002
2003 if (!ctx)
2004 return;
2005
2006 for (i = 0; i < EXT4_MAXQUOTAS; i++)
2007 kfree(ctx->s_qf_names[i]);
2008
2009 fscrypt_free_dummy_policy(&ctx->dummy_enc_policy);
2010 kfree(ctx);
2011 }
2012
ext4_init_fs_context(struct fs_context * fc)2013 int ext4_init_fs_context(struct fs_context *fc)
2014 {
2015 struct ext4_fs_context *ctx;
2016
2017 ctx = kzalloc(sizeof(struct ext4_fs_context), GFP_KERNEL);
2018 if (!ctx)
2019 return -ENOMEM;
2020
2021 fc->fs_private = ctx;
2022 fc->ops = &ext4_context_ops;
2023
2024 return 0;
2025 }
2026
2027 #ifdef CONFIG_QUOTA
2028 /*
2029 * Note the name of the specified quota file.
2030 */
note_qf_name(struct fs_context * fc,int qtype,struct fs_parameter * param)2031 static int note_qf_name(struct fs_context *fc, int qtype,
2032 struct fs_parameter *param)
2033 {
2034 struct ext4_fs_context *ctx = fc->fs_private;
2035 char *qname;
2036
2037 if (param->size < 1) {
2038 ext4_msg(NULL, KERN_ERR, "Missing quota name");
2039 return -EINVAL;
2040 }
2041 if (strchr(param->string, '/')) {
2042 ext4_msg(NULL, KERN_ERR,
2043 "quotafile must be on filesystem root");
2044 return -EINVAL;
2045 }
2046 if (ctx->s_qf_names[qtype]) {
2047 if (strcmp(ctx->s_qf_names[qtype], param->string) != 0) {
2048 ext4_msg(NULL, KERN_ERR,
2049 "%s quota file already specified",
2050 QTYPE2NAME(qtype));
2051 return -EINVAL;
2052 }
2053 return 0;
2054 }
2055
2056 qname = kmemdup_nul(param->string, param->size, GFP_KERNEL);
2057 if (!qname) {
2058 ext4_msg(NULL, KERN_ERR,
2059 "Not enough memory for storing quotafile name");
2060 return -ENOMEM;
2061 }
2062 ctx->s_qf_names[qtype] = qname;
2063 ctx->qname_spec |= 1 << qtype;
2064 ctx->spec |= EXT4_SPEC_JQUOTA;
2065 return 0;
2066 }
2067
2068 /*
2069 * Clear the name of the specified quota file.
2070 */
unnote_qf_name(struct fs_context * fc,int qtype)2071 static int unnote_qf_name(struct fs_context *fc, int qtype)
2072 {
2073 struct ext4_fs_context *ctx = fc->fs_private;
2074
2075 if (ctx->s_qf_names[qtype])
2076 kfree(ctx->s_qf_names[qtype]);
2077
2078 ctx->s_qf_names[qtype] = NULL;
2079 ctx->qname_spec |= 1 << qtype;
2080 ctx->spec |= EXT4_SPEC_JQUOTA;
2081 return 0;
2082 }
2083 #endif
2084
ext4_parse_test_dummy_encryption(const struct fs_parameter * param,struct ext4_fs_context * ctx)2085 static int ext4_parse_test_dummy_encryption(const struct fs_parameter *param,
2086 struct ext4_fs_context *ctx)
2087 {
2088 int err;
2089
2090 if (!IS_ENABLED(CONFIG_FS_ENCRYPTION)) {
2091 ext4_msg(NULL, KERN_WARNING,
2092 "test_dummy_encryption option not supported");
2093 return -EINVAL;
2094 }
2095 err = fscrypt_parse_test_dummy_encryption(param,
2096 &ctx->dummy_enc_policy);
2097 if (err == -EINVAL) {
2098 ext4_msg(NULL, KERN_WARNING,
2099 "Value of option \"%s\" is unrecognized", param->key);
2100 } else if (err == -EEXIST) {
2101 ext4_msg(NULL, KERN_WARNING,
2102 "Conflicting test_dummy_encryption options");
2103 return -EINVAL;
2104 }
2105 return err;
2106 }
2107
2108 #define EXT4_SET_CTX(name) \
2109 static inline void ctx_set_##name(struct ext4_fs_context *ctx, \
2110 unsigned long flag) \
2111 { \
2112 ctx->mask_s_##name |= flag; \
2113 ctx->vals_s_##name |= flag; \
2114 }
2115
2116 #define EXT4_CLEAR_CTX(name) \
2117 static inline void ctx_clear_##name(struct ext4_fs_context *ctx, \
2118 unsigned long flag) \
2119 { \
2120 ctx->mask_s_##name |= flag; \
2121 ctx->vals_s_##name &= ~flag; \
2122 }
2123
2124 #define EXT4_TEST_CTX(name) \
2125 static inline unsigned long \
2126 ctx_test_##name(struct ext4_fs_context *ctx, unsigned long flag) \
2127 { \
2128 return (ctx->vals_s_##name & flag); \
2129 }
2130
2131 EXT4_SET_CTX(flags); /* set only */
2132 EXT4_SET_CTX(mount_opt);
2133 EXT4_CLEAR_CTX(mount_opt);
2134 EXT4_TEST_CTX(mount_opt);
2135 EXT4_SET_CTX(mount_opt2);
2136 EXT4_CLEAR_CTX(mount_opt2);
2137 EXT4_TEST_CTX(mount_opt2);
2138
ext4_parse_param(struct fs_context * fc,struct fs_parameter * param)2139 static int ext4_parse_param(struct fs_context *fc, struct fs_parameter *param)
2140 {
2141 struct ext4_fs_context *ctx = fc->fs_private;
2142 struct fs_parse_result result;
2143 const struct mount_opts *m;
2144 int is_remount;
2145 kuid_t uid;
2146 kgid_t gid;
2147 int token;
2148
2149 token = fs_parse(fc, ext4_param_specs, param, &result);
2150 if (token < 0)
2151 return token;
2152 is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
2153
2154 for (m = ext4_mount_opts; m->token != Opt_err; m++)
2155 if (token == m->token)
2156 break;
2157
2158 ctx->opt_flags |= m->flags;
2159
2160 if (m->flags & MOPT_EXPLICIT) {
2161 if (m->mount_opt & EXT4_MOUNT_DELALLOC) {
2162 ctx_set_mount_opt2(ctx, EXT4_MOUNT2_EXPLICIT_DELALLOC);
2163 } else if (m->mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) {
2164 ctx_set_mount_opt2(ctx,
2165 EXT4_MOUNT2_EXPLICIT_JOURNAL_CHECKSUM);
2166 } else
2167 return -EINVAL;
2168 }
2169
2170 if (m->flags & MOPT_NOSUPPORT) {
2171 ext4_msg(NULL, KERN_ERR, "%s option not supported",
2172 param->key);
2173 return 0;
2174 }
2175
2176 switch (token) {
2177 #ifdef CONFIG_QUOTA
2178 case Opt_usrjquota:
2179 if (!*param->string)
2180 return unnote_qf_name(fc, USRQUOTA);
2181 else
2182 return note_qf_name(fc, USRQUOTA, param);
2183 case Opt_grpjquota:
2184 if (!*param->string)
2185 return unnote_qf_name(fc, GRPQUOTA);
2186 else
2187 return note_qf_name(fc, GRPQUOTA, param);
2188 #endif
2189 case Opt_sb:
2190 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
2191 ext4_msg(NULL, KERN_WARNING,
2192 "Ignoring %s option on remount", param->key);
2193 } else {
2194 ctx->s_sb_block = result.uint_32;
2195 ctx->spec |= EXT4_SPEC_s_sb_block;
2196 }
2197 return 0;
2198 case Opt_removed:
2199 ext4_msg(NULL, KERN_WARNING, "Ignoring removed %s option",
2200 param->key);
2201 return 0;
2202 case Opt_inlinecrypt:
2203 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
2204 ctx_set_flags(ctx, SB_INLINECRYPT);
2205 #else
2206 ext4_msg(NULL, KERN_ERR, "inline encryption not supported");
2207 #endif
2208 return 0;
2209 case Opt_errors:
2210 ctx_clear_mount_opt(ctx, EXT4_MOUNT_ERRORS_MASK);
2211 ctx_set_mount_opt(ctx, result.uint_32);
2212 return 0;
2213 #ifdef CONFIG_QUOTA
2214 case Opt_jqfmt:
2215 ctx->s_jquota_fmt = result.uint_32;
2216 ctx->spec |= EXT4_SPEC_JQFMT;
2217 return 0;
2218 #endif
2219 case Opt_data:
2220 ctx_clear_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS);
2221 ctx_set_mount_opt(ctx, result.uint_32);
2222 ctx->spec |= EXT4_SPEC_DATAJ;
2223 return 0;
2224 case Opt_commit:
2225 if (result.uint_32 == 0)
2226 result.uint_32 = JBD2_DEFAULT_MAX_COMMIT_AGE;
2227 else if (result.uint_32 > INT_MAX / HZ) {
2228 ext4_msg(NULL, KERN_ERR,
2229 "Invalid commit interval %d, "
2230 "must be smaller than %d",
2231 result.uint_32, INT_MAX / HZ);
2232 return -EINVAL;
2233 }
2234 ctx->s_commit_interval = HZ * result.uint_32;
2235 ctx->spec |= EXT4_SPEC_s_commit_interval;
2236 return 0;
2237 case Opt_debug_want_extra_isize:
2238 if ((result.uint_32 & 1) || (result.uint_32 < 4)) {
2239 ext4_msg(NULL, KERN_ERR,
2240 "Invalid want_extra_isize %d", result.uint_32);
2241 return -EINVAL;
2242 }
2243 ctx->s_want_extra_isize = result.uint_32;
2244 ctx->spec |= EXT4_SPEC_s_want_extra_isize;
2245 return 0;
2246 case Opt_max_batch_time:
2247 ctx->s_max_batch_time = result.uint_32;
2248 ctx->spec |= EXT4_SPEC_s_max_batch_time;
2249 return 0;
2250 case Opt_min_batch_time:
2251 ctx->s_min_batch_time = result.uint_32;
2252 ctx->spec |= EXT4_SPEC_s_min_batch_time;
2253 return 0;
2254 case Opt_inode_readahead_blks:
2255 if (result.uint_32 &&
2256 (result.uint_32 > (1 << 30) ||
2257 !is_power_of_2(result.uint_32))) {
2258 ext4_msg(NULL, KERN_ERR,
2259 "EXT4-fs: inode_readahead_blks must be "
2260 "0 or a power of 2 smaller than 2^31");
2261 return -EINVAL;
2262 }
2263 ctx->s_inode_readahead_blks = result.uint_32;
2264 ctx->spec |= EXT4_SPEC_s_inode_readahead_blks;
2265 return 0;
2266 case Opt_init_itable:
2267 ctx_set_mount_opt(ctx, EXT4_MOUNT_INIT_INODE_TABLE);
2268 ctx->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
2269 if (param->type == fs_value_is_string)
2270 ctx->s_li_wait_mult = result.uint_32;
2271 ctx->spec |= EXT4_SPEC_s_li_wait_mult;
2272 return 0;
2273 case Opt_max_dir_size_kb:
2274 ctx->s_max_dir_size_kb = result.uint_32;
2275 ctx->spec |= EXT4_SPEC_s_max_dir_size_kb;
2276 return 0;
2277 #ifdef CONFIG_EXT4_DEBUG
2278 case Opt_fc_debug_max_replay:
2279 ctx->s_fc_debug_max_replay = result.uint_32;
2280 ctx->spec |= EXT4_SPEC_s_fc_debug_max_replay;
2281 return 0;
2282 #endif
2283 case Opt_stripe:
2284 ctx->s_stripe = result.uint_32;
2285 ctx->spec |= EXT4_SPEC_s_stripe;
2286 return 0;
2287 case Opt_resuid:
2288 uid = make_kuid(current_user_ns(), result.uint_32);
2289 if (!uid_valid(uid)) {
2290 ext4_msg(NULL, KERN_ERR, "Invalid uid value %d",
2291 result.uint_32);
2292 return -EINVAL;
2293 }
2294 ctx->s_resuid = uid;
2295 ctx->spec |= EXT4_SPEC_s_resuid;
2296 return 0;
2297 case Opt_resgid:
2298 gid = make_kgid(current_user_ns(), result.uint_32);
2299 if (!gid_valid(gid)) {
2300 ext4_msg(NULL, KERN_ERR, "Invalid gid value %d",
2301 result.uint_32);
2302 return -EINVAL;
2303 }
2304 ctx->s_resgid = gid;
2305 ctx->spec |= EXT4_SPEC_s_resgid;
2306 return 0;
2307 case Opt_journal_dev:
2308 if (is_remount) {
2309 ext4_msg(NULL, KERN_ERR,
2310 "Cannot specify journal on remount");
2311 return -EINVAL;
2312 }
2313 ctx->journal_devnum = result.uint_32;
2314 ctx->spec |= EXT4_SPEC_JOURNAL_DEV;
2315 return 0;
2316 case Opt_journal_path:
2317 {
2318 struct inode *journal_inode;
2319 struct path path;
2320 int error;
2321
2322 if (is_remount) {
2323 ext4_msg(NULL, KERN_ERR,
2324 "Cannot specify journal on remount");
2325 return -EINVAL;
2326 }
2327
2328 error = fs_lookup_param(fc, param, 1, LOOKUP_FOLLOW, &path);
2329 if (error) {
2330 ext4_msg(NULL, KERN_ERR, "error: could not find "
2331 "journal device path");
2332 return -EINVAL;
2333 }
2334
2335 journal_inode = d_inode(path.dentry);
2336 ctx->journal_devnum = new_encode_dev(journal_inode->i_rdev);
2337 ctx->spec |= EXT4_SPEC_JOURNAL_DEV;
2338 path_put(&path);
2339 return 0;
2340 }
2341 case Opt_journal_ioprio:
2342 if (result.uint_32 > 7) {
2343 ext4_msg(NULL, KERN_ERR, "Invalid journal IO priority"
2344 " (must be 0-7)");
2345 return -EINVAL;
2346 }
2347 ctx->journal_ioprio =
2348 IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, result.uint_32);
2349 ctx->spec |= EXT4_SPEC_JOURNAL_IOPRIO;
2350 return 0;
2351 case Opt_test_dummy_encryption:
2352 return ext4_parse_test_dummy_encryption(param, ctx);
2353 case Opt_dax:
2354 case Opt_dax_type:
2355 #ifdef CONFIG_FS_DAX
2356 {
2357 int type = (token == Opt_dax) ?
2358 Opt_dax : result.uint_32;
2359
2360 switch (type) {
2361 case Opt_dax:
2362 case Opt_dax_always:
2363 ctx_set_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2364 ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2365 break;
2366 case Opt_dax_never:
2367 ctx_set_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2368 ctx_clear_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2369 break;
2370 case Opt_dax_inode:
2371 ctx_clear_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS);
2372 ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER);
2373 /* Strictly for printing options */
2374 ctx_set_mount_opt2(ctx, EXT4_MOUNT2_DAX_INODE);
2375 break;
2376 }
2377 return 0;
2378 }
2379 #else
2380 ext4_msg(NULL, KERN_INFO, "dax option not supported");
2381 return -EINVAL;
2382 #endif
2383 case Opt_data_err:
2384 if (result.uint_32 == Opt_data_err_abort)
2385 ctx_set_mount_opt(ctx, m->mount_opt);
2386 else if (result.uint_32 == Opt_data_err_ignore)
2387 ctx_clear_mount_opt(ctx, m->mount_opt);
2388 return 0;
2389 case Opt_mb_optimize_scan:
2390 if (result.int_32 == 1) {
2391 ctx_set_mount_opt2(ctx, EXT4_MOUNT2_MB_OPTIMIZE_SCAN);
2392 ctx->spec |= EXT4_SPEC_mb_optimize_scan;
2393 } else if (result.int_32 == 0) {
2394 ctx_clear_mount_opt2(ctx, EXT4_MOUNT2_MB_OPTIMIZE_SCAN);
2395 ctx->spec |= EXT4_SPEC_mb_optimize_scan;
2396 } else {
2397 ext4_msg(NULL, KERN_WARNING,
2398 "mb_optimize_scan should be set to 0 or 1.");
2399 return -EINVAL;
2400 }
2401 return 0;
2402 }
2403
2404 /*
2405 * At this point we should only be getting options requiring MOPT_SET,
2406 * or MOPT_CLEAR. Anything else is a bug
2407 */
2408 if (m->token == Opt_err) {
2409 ext4_msg(NULL, KERN_WARNING, "buggy handling of option %s",
2410 param->key);
2411 WARN_ON(1);
2412 return -EINVAL;
2413 }
2414
2415 else {
2416 unsigned int set = 0;
2417
2418 if ((param->type == fs_value_is_flag) ||
2419 result.uint_32 > 0)
2420 set = 1;
2421
2422 if (m->flags & MOPT_CLEAR)
2423 set = !set;
2424 else if (unlikely(!(m->flags & MOPT_SET))) {
2425 ext4_msg(NULL, KERN_WARNING,
2426 "buggy handling of option %s",
2427 param->key);
2428 WARN_ON(1);
2429 return -EINVAL;
2430 }
2431 if (m->flags & MOPT_2) {
2432 if (set != 0)
2433 ctx_set_mount_opt2(ctx, m->mount_opt);
2434 else
2435 ctx_clear_mount_opt2(ctx, m->mount_opt);
2436 } else {
2437 if (set != 0)
2438 ctx_set_mount_opt(ctx, m->mount_opt);
2439 else
2440 ctx_clear_mount_opt(ctx, m->mount_opt);
2441 }
2442 }
2443
2444 return 0;
2445 }
2446
parse_options(struct fs_context * fc,char * options)2447 static int parse_options(struct fs_context *fc, char *options)
2448 {
2449 struct fs_parameter param;
2450 int ret;
2451 char *key;
2452
2453 if (!options)
2454 return 0;
2455
2456 while ((key = strsep(&options, ",")) != NULL) {
2457 if (*key) {
2458 size_t v_len = 0;
2459 char *value = strchr(key, '=');
2460
2461 param.type = fs_value_is_flag;
2462 param.string = NULL;
2463
2464 if (value) {
2465 if (value == key)
2466 continue;
2467
2468 *value++ = 0;
2469 v_len = strlen(value);
2470 param.string = kmemdup_nul(value, v_len,
2471 GFP_KERNEL);
2472 if (!param.string)
2473 return -ENOMEM;
2474 param.type = fs_value_is_string;
2475 }
2476
2477 param.key = key;
2478 param.size = v_len;
2479
2480 ret = ext4_parse_param(fc, ¶m);
2481 if (param.string)
2482 kfree(param.string);
2483 if (ret < 0)
2484 return ret;
2485 }
2486 }
2487
2488 ret = ext4_validate_options(fc);
2489 if (ret < 0)
2490 return ret;
2491
2492 return 0;
2493 }
2494
parse_apply_sb_mount_options(struct super_block * sb,struct ext4_fs_context * m_ctx)2495 static int parse_apply_sb_mount_options(struct super_block *sb,
2496 struct ext4_fs_context *m_ctx)
2497 {
2498 struct ext4_sb_info *sbi = EXT4_SB(sb);
2499 char *s_mount_opts = NULL;
2500 struct ext4_fs_context *s_ctx = NULL;
2501 struct fs_context *fc = NULL;
2502 int ret = -ENOMEM;
2503
2504 if (!sbi->s_es->s_mount_opts[0])
2505 return 0;
2506
2507 s_mount_opts = kstrndup(sbi->s_es->s_mount_opts,
2508 sizeof(sbi->s_es->s_mount_opts),
2509 GFP_KERNEL);
2510 if (!s_mount_opts)
2511 return ret;
2512
2513 fc = kzalloc(sizeof(struct fs_context), GFP_KERNEL);
2514 if (!fc)
2515 goto out_free;
2516
2517 s_ctx = kzalloc(sizeof(struct ext4_fs_context), GFP_KERNEL);
2518 if (!s_ctx)
2519 goto out_free;
2520
2521 fc->fs_private = s_ctx;
2522 fc->s_fs_info = sbi;
2523
2524 ret = parse_options(fc, s_mount_opts);
2525 if (ret < 0)
2526 goto parse_failed;
2527
2528 ret = ext4_check_opt_consistency(fc, sb);
2529 if (ret < 0) {
2530 parse_failed:
2531 ext4_msg(sb, KERN_WARNING,
2532 "failed to parse options in superblock: %s",
2533 s_mount_opts);
2534 ret = 0;
2535 goto out_free;
2536 }
2537
2538 if (s_ctx->spec & EXT4_SPEC_JOURNAL_DEV)
2539 m_ctx->journal_devnum = s_ctx->journal_devnum;
2540 if (s_ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO)
2541 m_ctx->journal_ioprio = s_ctx->journal_ioprio;
2542
2543 ext4_apply_options(fc, sb);
2544 ret = 0;
2545
2546 out_free:
2547 if (fc) {
2548 ext4_fc_free(fc);
2549 kfree(fc);
2550 }
2551 kfree(s_mount_opts);
2552 return ret;
2553 }
2554
ext4_apply_quota_options(struct fs_context * fc,struct super_block * sb)2555 static void ext4_apply_quota_options(struct fs_context *fc,
2556 struct super_block *sb)
2557 {
2558 #ifdef CONFIG_QUOTA
2559 bool quota_feature = ext4_has_feature_quota(sb);
2560 struct ext4_fs_context *ctx = fc->fs_private;
2561 struct ext4_sb_info *sbi = EXT4_SB(sb);
2562 char *qname;
2563 int i;
2564
2565 if (quota_feature)
2566 return;
2567
2568 if (ctx->spec & EXT4_SPEC_JQUOTA) {
2569 for (i = 0; i < EXT4_MAXQUOTAS; i++) {
2570 if (!(ctx->qname_spec & (1 << i)))
2571 continue;
2572
2573 qname = ctx->s_qf_names[i]; /* May be NULL */
2574 if (qname)
2575 set_opt(sb, QUOTA);
2576 ctx->s_qf_names[i] = NULL;
2577 qname = rcu_replace_pointer(sbi->s_qf_names[i], qname,
2578 lockdep_is_held(&sb->s_umount));
2579 if (qname)
2580 kfree_rcu_mightsleep(qname);
2581 }
2582 }
2583
2584 if (ctx->spec & EXT4_SPEC_JQFMT)
2585 sbi->s_jquota_fmt = ctx->s_jquota_fmt;
2586 #endif
2587 }
2588
2589 /*
2590 * Check quota settings consistency.
2591 */
ext4_check_quota_consistency(struct fs_context * fc,struct super_block * sb)2592 static int ext4_check_quota_consistency(struct fs_context *fc,
2593 struct super_block *sb)
2594 {
2595 #ifdef CONFIG_QUOTA
2596 struct ext4_fs_context *ctx = fc->fs_private;
2597 struct ext4_sb_info *sbi = EXT4_SB(sb);
2598 bool quota_feature = ext4_has_feature_quota(sb);
2599 bool quota_loaded = sb_any_quota_loaded(sb);
2600 bool usr_qf_name, grp_qf_name, usrquota, grpquota;
2601 int quota_flags, i;
2602
2603 /*
2604 * We do the test below only for project quotas. 'usrquota' and
2605 * 'grpquota' mount options are allowed even without quota feature
2606 * to support legacy quotas in quota files.
2607 */
2608 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_PRJQUOTA) &&
2609 !ext4_has_feature_project(sb)) {
2610 ext4_msg(NULL, KERN_ERR, "Project quota feature not enabled. "
2611 "Cannot enable project quota enforcement.");
2612 return -EINVAL;
2613 }
2614
2615 quota_flags = EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
2616 EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA;
2617 if (quota_loaded &&
2618 ctx->mask_s_mount_opt & quota_flags &&
2619 !ctx_test_mount_opt(ctx, quota_flags))
2620 goto err_quota_change;
2621
2622 if (ctx->spec & EXT4_SPEC_JQUOTA) {
2623
2624 for (i = 0; i < EXT4_MAXQUOTAS; i++) {
2625 if (!(ctx->qname_spec & (1 << i)))
2626 continue;
2627
2628 if (quota_loaded &&
2629 !!sbi->s_qf_names[i] != !!ctx->s_qf_names[i])
2630 goto err_jquota_change;
2631
2632 if (sbi->s_qf_names[i] && ctx->s_qf_names[i] &&
2633 strcmp(get_qf_name(sb, sbi, i),
2634 ctx->s_qf_names[i]) != 0)
2635 goto err_jquota_specified;
2636 }
2637
2638 if (quota_feature) {
2639 ext4_msg(NULL, KERN_INFO,
2640 "Journaled quota options ignored when "
2641 "QUOTA feature is enabled");
2642 return 0;
2643 }
2644 }
2645
2646 if (ctx->spec & EXT4_SPEC_JQFMT) {
2647 if (sbi->s_jquota_fmt != ctx->s_jquota_fmt && quota_loaded)
2648 goto err_jquota_change;
2649 if (quota_feature) {
2650 ext4_msg(NULL, KERN_INFO, "Quota format mount options "
2651 "ignored when QUOTA feature is enabled");
2652 return 0;
2653 }
2654 }
2655
2656 /* Make sure we don't mix old and new quota format */
2657 usr_qf_name = (get_qf_name(sb, sbi, USRQUOTA) ||
2658 ctx->s_qf_names[USRQUOTA]);
2659 grp_qf_name = (get_qf_name(sb, sbi, GRPQUOTA) ||
2660 ctx->s_qf_names[GRPQUOTA]);
2661
2662 usrquota = (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) ||
2663 test_opt(sb, USRQUOTA));
2664
2665 grpquota = (ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA) ||
2666 test_opt(sb, GRPQUOTA));
2667
2668 if (usr_qf_name) {
2669 ctx_clear_mount_opt(ctx, EXT4_MOUNT_USRQUOTA);
2670 usrquota = false;
2671 }
2672 if (grp_qf_name) {
2673 ctx_clear_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA);
2674 grpquota = false;
2675 }
2676
2677 if (usr_qf_name || grp_qf_name) {
2678 if (usrquota || grpquota) {
2679 ext4_msg(NULL, KERN_ERR, "old and new quota "
2680 "format mixing");
2681 return -EINVAL;
2682 }
2683
2684 if (!(ctx->spec & EXT4_SPEC_JQFMT || sbi->s_jquota_fmt)) {
2685 ext4_msg(NULL, KERN_ERR, "journaled quota format "
2686 "not specified");
2687 return -EINVAL;
2688 }
2689 }
2690
2691 return 0;
2692
2693 err_quota_change:
2694 ext4_msg(NULL, KERN_ERR,
2695 "Cannot change quota options when quota turned on");
2696 return -EINVAL;
2697 err_jquota_change:
2698 ext4_msg(NULL, KERN_ERR, "Cannot change journaled quota "
2699 "options when quota turned on");
2700 return -EINVAL;
2701 err_jquota_specified:
2702 ext4_msg(NULL, KERN_ERR, "%s quota file already specified",
2703 QTYPE2NAME(i));
2704 return -EINVAL;
2705 #else
2706 return 0;
2707 #endif
2708 }
2709
ext4_check_test_dummy_encryption(const struct fs_context * fc,struct super_block * sb)2710 static int ext4_check_test_dummy_encryption(const struct fs_context *fc,
2711 struct super_block *sb)
2712 {
2713 const struct ext4_fs_context *ctx = fc->fs_private;
2714 const struct ext4_sb_info *sbi = EXT4_SB(sb);
2715
2716 if (!fscrypt_is_dummy_policy_set(&ctx->dummy_enc_policy))
2717 return 0;
2718
2719 if (!ext4_has_feature_encrypt(sb)) {
2720 ext4_msg(NULL, KERN_WARNING,
2721 "test_dummy_encryption requires encrypt feature");
2722 return -EINVAL;
2723 }
2724 /*
2725 * This mount option is just for testing, and it's not worthwhile to
2726 * implement the extra complexity (e.g. RCU protection) that would be
2727 * needed to allow it to be set or changed during remount. We do allow
2728 * it to be specified during remount, but only if there is no change.
2729 */
2730 if (fc->purpose == FS_CONTEXT_FOR_RECONFIGURE) {
2731 if (fscrypt_dummy_policies_equal(&sbi->s_dummy_enc_policy,
2732 &ctx->dummy_enc_policy))
2733 return 0;
2734 ext4_msg(NULL, KERN_WARNING,
2735 "Can't set or change test_dummy_encryption on remount");
2736 return -EINVAL;
2737 }
2738 /* Also make sure s_mount_opts didn't contain a conflicting value. */
2739 if (fscrypt_is_dummy_policy_set(&sbi->s_dummy_enc_policy)) {
2740 if (fscrypt_dummy_policies_equal(&sbi->s_dummy_enc_policy,
2741 &ctx->dummy_enc_policy))
2742 return 0;
2743 ext4_msg(NULL, KERN_WARNING,
2744 "Conflicting test_dummy_encryption options");
2745 return -EINVAL;
2746 }
2747 return 0;
2748 }
2749
ext4_apply_test_dummy_encryption(struct ext4_fs_context * ctx,struct super_block * sb)2750 static void ext4_apply_test_dummy_encryption(struct ext4_fs_context *ctx,
2751 struct super_block *sb)
2752 {
2753 if (!fscrypt_is_dummy_policy_set(&ctx->dummy_enc_policy) ||
2754 /* if already set, it was already verified to be the same */
2755 fscrypt_is_dummy_policy_set(&EXT4_SB(sb)->s_dummy_enc_policy))
2756 return;
2757 EXT4_SB(sb)->s_dummy_enc_policy = ctx->dummy_enc_policy;
2758 memset(&ctx->dummy_enc_policy, 0, sizeof(ctx->dummy_enc_policy));
2759 ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
2760 }
2761
ext4_check_opt_consistency(struct fs_context * fc,struct super_block * sb)2762 static int ext4_check_opt_consistency(struct fs_context *fc,
2763 struct super_block *sb)
2764 {
2765 struct ext4_fs_context *ctx = fc->fs_private;
2766 struct ext4_sb_info *sbi = fc->s_fs_info;
2767 int is_remount = fc->purpose == FS_CONTEXT_FOR_RECONFIGURE;
2768 int err;
2769
2770 if ((ctx->opt_flags & MOPT_NO_EXT2) && IS_EXT2_SB(sb)) {
2771 ext4_msg(NULL, KERN_ERR,
2772 "Mount option(s) incompatible with ext2");
2773 return -EINVAL;
2774 }
2775 if ((ctx->opt_flags & MOPT_NO_EXT3) && IS_EXT3_SB(sb)) {
2776 ext4_msg(NULL, KERN_ERR,
2777 "Mount option(s) incompatible with ext3");
2778 return -EINVAL;
2779 }
2780
2781 if (ctx->s_want_extra_isize >
2782 (sbi->s_inode_size - EXT4_GOOD_OLD_INODE_SIZE)) {
2783 ext4_msg(NULL, KERN_ERR,
2784 "Invalid want_extra_isize %d",
2785 ctx->s_want_extra_isize);
2786 return -EINVAL;
2787 }
2788
2789 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DIOREAD_NOLOCK)) {
2790 int blocksize =
2791 BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
2792 if (blocksize < PAGE_SIZE)
2793 ext4_msg(NULL, KERN_WARNING, "Warning: mounting with an "
2794 "experimental mount option 'dioread_nolock' "
2795 "for blocksize < PAGE_SIZE");
2796 }
2797
2798 err = ext4_check_test_dummy_encryption(fc, sb);
2799 if (err)
2800 return err;
2801
2802 if ((ctx->spec & EXT4_SPEC_DATAJ) && is_remount) {
2803 if (!sbi->s_journal) {
2804 ext4_msg(NULL, KERN_WARNING,
2805 "Remounting file system with no journal "
2806 "so ignoring journalled data option");
2807 ctx_clear_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS);
2808 } else if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DATA_FLAGS) !=
2809 test_opt(sb, DATA_FLAGS)) {
2810 ext4_msg(NULL, KERN_ERR, "Cannot change data mode "
2811 "on remount");
2812 return -EINVAL;
2813 }
2814 }
2815
2816 if (is_remount) {
2817 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS) &&
2818 (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)) {
2819 ext4_msg(NULL, KERN_ERR, "can't mount with "
2820 "both data=journal and dax");
2821 return -EINVAL;
2822 }
2823
2824 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_DAX_ALWAYS) &&
2825 (!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2826 (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
2827 fail_dax_change_remount:
2828 ext4_msg(NULL, KERN_ERR, "can't change "
2829 "dax mount option while remounting");
2830 return -EINVAL;
2831 } else if (ctx_test_mount_opt2(ctx, EXT4_MOUNT2_DAX_NEVER) &&
2832 (!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2833 (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS))) {
2834 goto fail_dax_change_remount;
2835 } else if (ctx_test_mount_opt2(ctx, EXT4_MOUNT2_DAX_INODE) &&
2836 ((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2837 (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2838 !(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE))) {
2839 goto fail_dax_change_remount;
2840 }
2841 }
2842
2843 return ext4_check_quota_consistency(fc, sb);
2844 }
2845
ext4_apply_options(struct fs_context * fc,struct super_block * sb)2846 static void ext4_apply_options(struct fs_context *fc, struct super_block *sb)
2847 {
2848 struct ext4_fs_context *ctx = fc->fs_private;
2849 struct ext4_sb_info *sbi = fc->s_fs_info;
2850
2851 sbi->s_mount_opt &= ~ctx->mask_s_mount_opt;
2852 sbi->s_mount_opt |= ctx->vals_s_mount_opt;
2853 sbi->s_mount_opt2 &= ~ctx->mask_s_mount_opt2;
2854 sbi->s_mount_opt2 |= ctx->vals_s_mount_opt2;
2855 sb->s_flags &= ~ctx->mask_s_flags;
2856 sb->s_flags |= ctx->vals_s_flags;
2857
2858 #define APPLY(X) ({ if (ctx->spec & EXT4_SPEC_##X) sbi->X = ctx->X; })
2859 APPLY(s_commit_interval);
2860 APPLY(s_stripe);
2861 APPLY(s_max_batch_time);
2862 APPLY(s_min_batch_time);
2863 APPLY(s_want_extra_isize);
2864 APPLY(s_inode_readahead_blks);
2865 APPLY(s_max_dir_size_kb);
2866 APPLY(s_li_wait_mult);
2867 APPLY(s_resgid);
2868 APPLY(s_resuid);
2869
2870 #ifdef CONFIG_EXT4_DEBUG
2871 APPLY(s_fc_debug_max_replay);
2872 #endif
2873
2874 ext4_apply_quota_options(fc, sb);
2875 ext4_apply_test_dummy_encryption(ctx, sb);
2876 }
2877
2878
ext4_validate_options(struct fs_context * fc)2879 static int ext4_validate_options(struct fs_context *fc)
2880 {
2881 #ifdef CONFIG_QUOTA
2882 struct ext4_fs_context *ctx = fc->fs_private;
2883 char *usr_qf_name, *grp_qf_name;
2884
2885 usr_qf_name = ctx->s_qf_names[USRQUOTA];
2886 grp_qf_name = ctx->s_qf_names[GRPQUOTA];
2887
2888 if (usr_qf_name || grp_qf_name) {
2889 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) && usr_qf_name)
2890 ctx_clear_mount_opt(ctx, EXT4_MOUNT_USRQUOTA);
2891
2892 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA) && grp_qf_name)
2893 ctx_clear_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA);
2894
2895 if (ctx_test_mount_opt(ctx, EXT4_MOUNT_USRQUOTA) ||
2896 ctx_test_mount_opt(ctx, EXT4_MOUNT_GRPQUOTA)) {
2897 ext4_msg(NULL, KERN_ERR, "old and new quota "
2898 "format mixing");
2899 return -EINVAL;
2900 }
2901 }
2902 #endif
2903 return 1;
2904 }
2905
ext4_show_quota_options(struct seq_file * seq,struct super_block * sb)2906 static inline void ext4_show_quota_options(struct seq_file *seq,
2907 struct super_block *sb)
2908 {
2909 #if defined(CONFIG_QUOTA)
2910 struct ext4_sb_info *sbi = EXT4_SB(sb);
2911 char *usr_qf_name, *grp_qf_name;
2912
2913 if (sbi->s_jquota_fmt) {
2914 char *fmtname = "";
2915
2916 switch (sbi->s_jquota_fmt) {
2917 case QFMT_VFS_OLD:
2918 fmtname = "vfsold";
2919 break;
2920 case QFMT_VFS_V0:
2921 fmtname = "vfsv0";
2922 break;
2923 case QFMT_VFS_V1:
2924 fmtname = "vfsv1";
2925 break;
2926 }
2927 seq_printf(seq, ",jqfmt=%s", fmtname);
2928 }
2929
2930 rcu_read_lock();
2931 usr_qf_name = rcu_dereference(sbi->s_qf_names[USRQUOTA]);
2932 grp_qf_name = rcu_dereference(sbi->s_qf_names[GRPQUOTA]);
2933 if (usr_qf_name)
2934 seq_show_option(seq, "usrjquota", usr_qf_name);
2935 if (grp_qf_name)
2936 seq_show_option(seq, "grpjquota", grp_qf_name);
2937 rcu_read_unlock();
2938 #endif
2939 }
2940
token2str(int token)2941 static const char *token2str(int token)
2942 {
2943 const struct fs_parameter_spec *spec;
2944
2945 for (spec = ext4_param_specs; spec->name != NULL; spec++)
2946 if (spec->opt == token && !spec->type)
2947 break;
2948 return spec->name;
2949 }
2950
2951 /*
2952 * Show an option if
2953 * - it's set to a non-default value OR
2954 * - if the per-sb default is different from the global default
2955 */
_ext4_show_options(struct seq_file * seq,struct super_block * sb,int nodefs)2956 static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
2957 int nodefs)
2958 {
2959 struct ext4_sb_info *sbi = EXT4_SB(sb);
2960 struct ext4_super_block *es = sbi->s_es;
2961 int def_errors;
2962 const struct mount_opts *m;
2963 char sep = nodefs ? '\n' : ',';
2964
2965 #define SEQ_OPTS_PUTS(str) seq_printf(seq, "%c" str, sep)
2966 #define SEQ_OPTS_PRINT(str, arg) seq_printf(seq, "%c" str, sep, arg)
2967
2968 if (sbi->s_sb_block != 1)
2969 SEQ_OPTS_PRINT("sb=%llu", sbi->s_sb_block);
2970
2971 for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2972 int want_set = m->flags & MOPT_SET;
2973 int opt_2 = m->flags & MOPT_2;
2974 unsigned int mount_opt, def_mount_opt;
2975
2976 if (((m->flags & (MOPT_SET|MOPT_CLEAR)) == 0) ||
2977 m->flags & MOPT_SKIP)
2978 continue;
2979
2980 if (opt_2) {
2981 mount_opt = sbi->s_mount_opt2;
2982 def_mount_opt = sbi->s_def_mount_opt2;
2983 } else {
2984 mount_opt = sbi->s_mount_opt;
2985 def_mount_opt = sbi->s_def_mount_opt;
2986 }
2987 /* skip if same as the default */
2988 if (!nodefs && !(m->mount_opt & (mount_opt ^ def_mount_opt)))
2989 continue;
2990 /* select Opt_noFoo vs Opt_Foo */
2991 if ((want_set &&
2992 (mount_opt & m->mount_opt) != m->mount_opt) ||
2993 (!want_set && (mount_opt & m->mount_opt)))
2994 continue;
2995 SEQ_OPTS_PRINT("%s", token2str(m->token));
2996 }
2997
2998 if (nodefs || !uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT4_DEF_RESUID)) ||
2999 le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
3000 SEQ_OPTS_PRINT("resuid=%u",
3001 from_kuid_munged(&init_user_ns, sbi->s_resuid));
3002 if (nodefs || !gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT4_DEF_RESGID)) ||
3003 le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
3004 SEQ_OPTS_PRINT("resgid=%u",
3005 from_kgid_munged(&init_user_ns, sbi->s_resgid));
3006 def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
3007 if (test_opt(sb, ERRORS_RO) && def_errors != EXT4_ERRORS_RO)
3008 SEQ_OPTS_PUTS("errors=remount-ro");
3009 if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
3010 SEQ_OPTS_PUTS("errors=continue");
3011 if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
3012 SEQ_OPTS_PUTS("errors=panic");
3013 if (nodefs || sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ)
3014 SEQ_OPTS_PRINT("commit=%lu", sbi->s_commit_interval / HZ);
3015 if (nodefs || sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME)
3016 SEQ_OPTS_PRINT("min_batch_time=%u", sbi->s_min_batch_time);
3017 if (nodefs || sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME)
3018 SEQ_OPTS_PRINT("max_batch_time=%u", sbi->s_max_batch_time);
3019 if (nodefs || sbi->s_stripe)
3020 SEQ_OPTS_PRINT("stripe=%lu", sbi->s_stripe);
3021 if (nodefs || EXT4_MOUNT_DATA_FLAGS &
3022 (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
3023 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
3024 SEQ_OPTS_PUTS("data=journal");
3025 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
3026 SEQ_OPTS_PUTS("data=ordered");
3027 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
3028 SEQ_OPTS_PUTS("data=writeback");
3029 }
3030 if (nodefs ||
3031 sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
3032 SEQ_OPTS_PRINT("inode_readahead_blks=%u",
3033 sbi->s_inode_readahead_blks);
3034
3035 if (test_opt(sb, INIT_INODE_TABLE) && (nodefs ||
3036 (sbi->s_li_wait_mult != EXT4_DEF_LI_WAIT_MULT)))
3037 SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
3038 if (nodefs || sbi->s_max_dir_size_kb)
3039 SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
3040 if (test_opt(sb, DATA_ERR_ABORT))
3041 SEQ_OPTS_PUTS("data_err=abort");
3042
3043 fscrypt_show_test_dummy_encryption(seq, sep, sb);
3044
3045 if (sb->s_flags & SB_INLINECRYPT)
3046 SEQ_OPTS_PUTS("inlinecrypt");
3047
3048 if (test_opt(sb, DAX_ALWAYS)) {
3049 if (IS_EXT2_SB(sb))
3050 SEQ_OPTS_PUTS("dax");
3051 else
3052 SEQ_OPTS_PUTS("dax=always");
3053 } else if (test_opt2(sb, DAX_NEVER)) {
3054 SEQ_OPTS_PUTS("dax=never");
3055 } else if (test_opt2(sb, DAX_INODE)) {
3056 SEQ_OPTS_PUTS("dax=inode");
3057 }
3058
3059 if (sbi->s_groups_count >= MB_DEFAULT_LINEAR_SCAN_THRESHOLD &&
3060 !test_opt2(sb, MB_OPTIMIZE_SCAN)) {
3061 SEQ_OPTS_PUTS("mb_optimize_scan=0");
3062 } else if (sbi->s_groups_count < MB_DEFAULT_LINEAR_SCAN_THRESHOLD &&
3063 test_opt2(sb, MB_OPTIMIZE_SCAN)) {
3064 SEQ_OPTS_PUTS("mb_optimize_scan=1");
3065 }
3066
3067 ext4_show_quota_options(seq, sb);
3068 return 0;
3069 }
3070
ext4_show_options(struct seq_file * seq,struct dentry * root)3071 static int ext4_show_options(struct seq_file *seq, struct dentry *root)
3072 {
3073 return _ext4_show_options(seq, root->d_sb, 0);
3074 }
3075
ext4_seq_options_show(struct seq_file * seq,void * offset)3076 int ext4_seq_options_show(struct seq_file *seq, void *offset)
3077 {
3078 struct super_block *sb = seq->private;
3079 int rc;
3080
3081 seq_puts(seq, sb_rdonly(sb) ? "ro" : "rw");
3082 rc = _ext4_show_options(seq, sb, 1);
3083 seq_puts(seq, "\n");
3084 return rc;
3085 }
3086
ext4_setup_super(struct super_block * sb,struct ext4_super_block * es,int read_only)3087 static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
3088 int read_only)
3089 {
3090 struct ext4_sb_info *sbi = EXT4_SB(sb);
3091 int err = 0;
3092
3093 if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
3094 ext4_msg(sb, KERN_ERR, "revision level too high, "
3095 "forcing read-only mode");
3096 err = -EROFS;
3097 goto done;
3098 }
3099 if (read_only)
3100 goto done;
3101 if (!(sbi->s_mount_state & EXT4_VALID_FS))
3102 ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
3103 "running e2fsck is recommended");
3104 else if (sbi->s_mount_state & EXT4_ERROR_FS)
3105 ext4_msg(sb, KERN_WARNING,
3106 "warning: mounting fs with errors, "
3107 "running e2fsck is recommended");
3108 else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
3109 le16_to_cpu(es->s_mnt_count) >=
3110 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
3111 ext4_msg(sb, KERN_WARNING,
3112 "warning: maximal mount count reached, "
3113 "running e2fsck is recommended");
3114 else if (le32_to_cpu(es->s_checkinterval) &&
3115 (ext4_get_tstamp(es, s_lastcheck) +
3116 le32_to_cpu(es->s_checkinterval) <= ktime_get_real_seconds()))
3117 ext4_msg(sb, KERN_WARNING,
3118 "warning: checktime reached, "
3119 "running e2fsck is recommended");
3120 if (!sbi->s_journal)
3121 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
3122 if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
3123 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
3124 le16_add_cpu(&es->s_mnt_count, 1);
3125 ext4_update_tstamp(es, s_mtime);
3126 if (sbi->s_journal) {
3127 ext4_set_feature_journal_needs_recovery(sb);
3128 if (ext4_has_feature_orphan_file(sb))
3129 ext4_set_feature_orphan_present(sb);
3130 }
3131
3132 err = ext4_commit_super(sb);
3133 done:
3134 if (test_opt(sb, DEBUG))
3135 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
3136 "bpg=%lu, ipg=%lu, mo=%04x, mo2=%04x]\n",
3137 sb->s_blocksize,
3138 sbi->s_groups_count,
3139 EXT4_BLOCKS_PER_GROUP(sb),
3140 EXT4_INODES_PER_GROUP(sb),
3141 sbi->s_mount_opt, sbi->s_mount_opt2);
3142
3143 cleancache_init_fs(sb);
3144 return err;
3145 }
3146
ext4_alloc_flex_bg_array(struct super_block * sb,ext4_group_t ngroup)3147 int ext4_alloc_flex_bg_array(struct super_block *sb, ext4_group_t ngroup)
3148 {
3149 struct ext4_sb_info *sbi = EXT4_SB(sb);
3150 struct flex_groups **old_groups, **new_groups;
3151 int size, i, j;
3152
3153 if (!sbi->s_log_groups_per_flex)
3154 return 0;
3155
3156 size = ext4_flex_group(sbi, ngroup - 1) + 1;
3157 if (size <= sbi->s_flex_groups_allocated)
3158 return 0;
3159
3160 new_groups = kvzalloc(roundup_pow_of_two(size *
3161 sizeof(*sbi->s_flex_groups)), GFP_KERNEL);
3162 if (!new_groups) {
3163 ext4_msg(sb, KERN_ERR,
3164 "not enough memory for %d flex group pointers", size);
3165 return -ENOMEM;
3166 }
3167 for (i = sbi->s_flex_groups_allocated; i < size; i++) {
3168 new_groups[i] = kvzalloc(roundup_pow_of_two(
3169 sizeof(struct flex_groups)),
3170 GFP_KERNEL);
3171 if (!new_groups[i]) {
3172 for (j = sbi->s_flex_groups_allocated; j < i; j++)
3173 kvfree(new_groups[j]);
3174 kvfree(new_groups);
3175 ext4_msg(sb, KERN_ERR,
3176 "not enough memory for %d flex groups", size);
3177 return -ENOMEM;
3178 }
3179 }
3180 rcu_read_lock();
3181 old_groups = rcu_dereference(sbi->s_flex_groups);
3182 if (old_groups)
3183 memcpy(new_groups, old_groups,
3184 (sbi->s_flex_groups_allocated *
3185 sizeof(struct flex_groups *)));
3186 rcu_read_unlock();
3187 rcu_assign_pointer(sbi->s_flex_groups, new_groups);
3188 sbi->s_flex_groups_allocated = size;
3189 if (old_groups)
3190 ext4_kvfree_array_rcu(old_groups);
3191 return 0;
3192 }
3193
ext4_fill_flex_info(struct super_block * sb)3194 static int ext4_fill_flex_info(struct super_block *sb)
3195 {
3196 struct ext4_sb_info *sbi = EXT4_SB(sb);
3197 struct ext4_group_desc *gdp = NULL;
3198 struct flex_groups *fg;
3199 ext4_group_t flex_group;
3200 int i, err;
3201
3202 sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
3203 if (sbi->s_log_groups_per_flex < 1 || sbi->s_log_groups_per_flex > 31) {
3204 sbi->s_log_groups_per_flex = 0;
3205 return 1;
3206 }
3207
3208 err = ext4_alloc_flex_bg_array(sb, sbi->s_groups_count);
3209 if (err)
3210 goto failed;
3211
3212 for (i = 0; i < sbi->s_groups_count; i++) {
3213 gdp = ext4_get_group_desc(sb, i, NULL);
3214
3215 flex_group = ext4_flex_group(sbi, i);
3216 fg = sbi_array_rcu_deref(sbi, s_flex_groups, flex_group);
3217 atomic_add(ext4_free_inodes_count(sb, gdp), &fg->free_inodes);
3218 atomic64_add(ext4_free_group_clusters(sb, gdp),
3219 &fg->free_clusters);
3220 atomic_add(ext4_used_dirs_count(sb, gdp), &fg->used_dirs);
3221 }
3222
3223 return 1;
3224 failed:
3225 return 0;
3226 }
3227
ext4_group_desc_csum(struct super_block * sb,__u32 block_group,struct ext4_group_desc * gdp)3228 static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
3229 struct ext4_group_desc *gdp)
3230 {
3231 int offset = offsetof(struct ext4_group_desc, bg_checksum);
3232 __u16 crc = 0;
3233 __le32 le_group = cpu_to_le32(block_group);
3234 struct ext4_sb_info *sbi = EXT4_SB(sb);
3235
3236 if (ext4_has_metadata_csum(sbi->s_sb)) {
3237 /* Use new metadata_csum algorithm */
3238 __u32 csum32;
3239 __u16 dummy_csum = 0;
3240
3241 csum32 = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&le_group,
3242 sizeof(le_group));
3243 csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp, offset);
3244 csum32 = ext4_chksum(sbi, csum32, (__u8 *)&dummy_csum,
3245 sizeof(dummy_csum));
3246 offset += sizeof(dummy_csum);
3247 if (offset < sbi->s_desc_size)
3248 csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp + offset,
3249 sbi->s_desc_size - offset);
3250
3251 crc = csum32 & 0xFFFF;
3252 goto out;
3253 }
3254
3255 /* old crc16 code */
3256 if (!ext4_has_feature_gdt_csum(sb))
3257 return 0;
3258
3259 crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
3260 crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
3261 crc = crc16(crc, (__u8 *)gdp, offset);
3262 offset += sizeof(gdp->bg_checksum); /* skip checksum */
3263 /* for checksum of struct ext4_group_desc do the rest...*/
3264 if (ext4_has_feature_64bit(sb) && offset < sbi->s_desc_size)
3265 crc = crc16(crc, (__u8 *)gdp + offset,
3266 sbi->s_desc_size - offset);
3267
3268 out:
3269 return cpu_to_le16(crc);
3270 }
3271
ext4_group_desc_csum_verify(struct super_block * sb,__u32 block_group,struct ext4_group_desc * gdp)3272 int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
3273 struct ext4_group_desc *gdp)
3274 {
3275 if (ext4_has_group_desc_csum(sb) &&
3276 (gdp->bg_checksum != ext4_group_desc_csum(sb, block_group, gdp)))
3277 return 0;
3278
3279 return 1;
3280 }
3281
ext4_group_desc_csum_set(struct super_block * sb,__u32 block_group,struct ext4_group_desc * gdp)3282 void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
3283 struct ext4_group_desc *gdp)
3284 {
3285 if (!ext4_has_group_desc_csum(sb))
3286 return;
3287 gdp->bg_checksum = ext4_group_desc_csum(sb, block_group, gdp);
3288 }
3289
3290 /* Called at mount-time, super-block is locked */
ext4_check_descriptors(struct super_block * sb,ext4_fsblk_t sb_block,ext4_group_t * first_not_zeroed)3291 static int ext4_check_descriptors(struct super_block *sb,
3292 ext4_fsblk_t sb_block,
3293 ext4_group_t *first_not_zeroed)
3294 {
3295 struct ext4_sb_info *sbi = EXT4_SB(sb);
3296 ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
3297 ext4_fsblk_t last_block;
3298 ext4_fsblk_t last_bg_block = sb_block + ext4_bg_num_gdb(sb, 0);
3299 ext4_fsblk_t block_bitmap;
3300 ext4_fsblk_t inode_bitmap;
3301 ext4_fsblk_t inode_table;
3302 int flexbg_flag = 0;
3303 ext4_group_t i, grp = sbi->s_groups_count;
3304
3305 if (ext4_has_feature_flex_bg(sb))
3306 flexbg_flag = 1;
3307
3308 ext4_debug("Checking group descriptors");
3309
3310 for (i = 0; i < sbi->s_groups_count; i++) {
3311 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
3312
3313 if (i == sbi->s_groups_count - 1 || flexbg_flag)
3314 last_block = ext4_blocks_count(sbi->s_es) - 1;
3315 else
3316 last_block = first_block +
3317 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
3318
3319 if ((grp == sbi->s_groups_count) &&
3320 !(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3321 grp = i;
3322
3323 block_bitmap = ext4_block_bitmap(sb, gdp);
3324 if (block_bitmap == sb_block) {
3325 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3326 "Block bitmap for group %u overlaps "
3327 "superblock", i);
3328 if (!sb_rdonly(sb))
3329 return 0;
3330 }
3331 if (block_bitmap >= sb_block + 1 &&
3332 block_bitmap <= last_bg_block) {
3333 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3334 "Block bitmap for group %u overlaps "
3335 "block group descriptors", i);
3336 if (!sb_rdonly(sb))
3337 return 0;
3338 }
3339 if (block_bitmap < first_block || block_bitmap > last_block) {
3340 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3341 "Block bitmap for group %u not in group "
3342 "(block %llu)!", i, block_bitmap);
3343 return 0;
3344 }
3345 inode_bitmap = ext4_inode_bitmap(sb, gdp);
3346 if (inode_bitmap == sb_block) {
3347 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3348 "Inode bitmap for group %u overlaps "
3349 "superblock", i);
3350 if (!sb_rdonly(sb))
3351 return 0;
3352 }
3353 if (inode_bitmap >= sb_block + 1 &&
3354 inode_bitmap <= last_bg_block) {
3355 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3356 "Inode bitmap for group %u overlaps "
3357 "block group descriptors", i);
3358 if (!sb_rdonly(sb))
3359 return 0;
3360 }
3361 if (inode_bitmap < first_block || inode_bitmap > last_block) {
3362 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3363 "Inode bitmap for group %u not in group "
3364 "(block %llu)!", i, inode_bitmap);
3365 return 0;
3366 }
3367 inode_table = ext4_inode_table(sb, gdp);
3368 if (inode_table == sb_block) {
3369 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3370 "Inode table for group %u overlaps "
3371 "superblock", i);
3372 if (!sb_rdonly(sb))
3373 return 0;
3374 }
3375 if (inode_table >= sb_block + 1 &&
3376 inode_table <= last_bg_block) {
3377 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3378 "Inode table for group %u overlaps "
3379 "block group descriptors", i);
3380 if (!sb_rdonly(sb))
3381 return 0;
3382 }
3383 if (inode_table < first_block ||
3384 inode_table + sbi->s_itb_per_group - 1 > last_block) {
3385 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3386 "Inode table for group %u not in group "
3387 "(block %llu)!", i, inode_table);
3388 return 0;
3389 }
3390 ext4_lock_group(sb, i);
3391 if (!ext4_group_desc_csum_verify(sb, i, gdp)) {
3392 ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
3393 "Checksum for group %u failed (%u!=%u)",
3394 i, le16_to_cpu(ext4_group_desc_csum(sb, i,
3395 gdp)), le16_to_cpu(gdp->bg_checksum));
3396 if (!sb_rdonly(sb)) {
3397 ext4_unlock_group(sb, i);
3398 return 0;
3399 }
3400 }
3401 ext4_unlock_group(sb, i);
3402 if (!flexbg_flag)
3403 first_block += EXT4_BLOCKS_PER_GROUP(sb);
3404 }
3405 if (NULL != first_not_zeroed)
3406 *first_not_zeroed = grp;
3407 return 1;
3408 }
3409
3410 /*
3411 * Maximal extent format file size.
3412 * Resulting logical blkno at s_maxbytes must fit in our on-disk
3413 * extent format containers, within a sector_t, and within i_blocks
3414 * in the vfs. ext4 inode has 48 bits of i_block in fsblock units,
3415 * so that won't be a limiting factor.
3416 *
3417 * However there is other limiting factor. We do store extents in the form
3418 * of starting block and length, hence the resulting length of the extent
3419 * covering maximum file size must fit into on-disk format containers as
3420 * well. Given that length is always by 1 unit bigger than max unit (because
3421 * we count 0 as well) we have to lower the s_maxbytes by one fs block.
3422 *
3423 * Note, this does *not* consider any metadata overhead for vfs i_blocks.
3424 */
ext4_max_size(int blkbits,int has_huge_files)3425 static loff_t ext4_max_size(int blkbits, int has_huge_files)
3426 {
3427 loff_t res;
3428 loff_t upper_limit = MAX_LFS_FILESIZE;
3429
3430 BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
3431
3432 if (!has_huge_files) {
3433 upper_limit = (1LL << 32) - 1;
3434
3435 /* total blocks in file system block size */
3436 upper_limit >>= (blkbits - 9);
3437 upper_limit <<= blkbits;
3438 }
3439
3440 /*
3441 * 32-bit extent-start container, ee_block. We lower the maxbytes
3442 * by one fs block, so ee_len can cover the extent of maximum file
3443 * size
3444 */
3445 res = (1LL << 32) - 1;
3446 res <<= blkbits;
3447
3448 /* Sanity check against vm- & vfs- imposed limits */
3449 if (res > upper_limit)
3450 res = upper_limit;
3451
3452 return res;
3453 }
3454
3455 /*
3456 * Maximal bitmap file size. There is a direct, and {,double-,triple-}indirect
3457 * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
3458 * We need to be 1 filesystem block less than the 2^48 sector limit.
3459 */
ext4_max_bitmap_size(int bits,int has_huge_files)3460 static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
3461 {
3462 loff_t upper_limit, res = EXT4_NDIR_BLOCKS;
3463 int meta_blocks;
3464 unsigned int ppb = 1 << (bits - 2);
3465
3466 /*
3467 * This is calculated to be the largest file size for a dense, block
3468 * mapped file such that the file's total number of 512-byte sectors,
3469 * including data and all indirect blocks, does not exceed (2^48 - 1).
3470 *
3471 * __u32 i_blocks_lo and _u16 i_blocks_high represent the total
3472 * number of 512-byte sectors of the file.
3473 */
3474 if (!has_huge_files) {
3475 /*
3476 * !has_huge_files or implies that the inode i_block field
3477 * represents total file blocks in 2^32 512-byte sectors ==
3478 * size of vfs inode i_blocks * 8
3479 */
3480 upper_limit = (1LL << 32) - 1;
3481
3482 /* total blocks in file system block size */
3483 upper_limit >>= (bits - 9);
3484
3485 } else {
3486 /*
3487 * We use 48 bit ext4_inode i_blocks
3488 * With EXT4_HUGE_FILE_FL set the i_blocks
3489 * represent total number of blocks in
3490 * file system block size
3491 */
3492 upper_limit = (1LL << 48) - 1;
3493
3494 }
3495
3496 /* Compute how many blocks we can address by block tree */
3497 res += ppb;
3498 res += ppb * ppb;
3499 res += ((loff_t)ppb) * ppb * ppb;
3500 /* Compute how many metadata blocks are needed */
3501 meta_blocks = 1;
3502 meta_blocks += 1 + ppb;
3503 meta_blocks += 1 + ppb + ppb * ppb;
3504 /* Does block tree limit file size? */
3505 if (res + meta_blocks <= upper_limit)
3506 goto check_lfs;
3507
3508 res = upper_limit;
3509 /* How many metadata blocks are needed for addressing upper_limit? */
3510 upper_limit -= EXT4_NDIR_BLOCKS;
3511 /* indirect blocks */
3512 meta_blocks = 1;
3513 upper_limit -= ppb;
3514 /* double indirect blocks */
3515 if (upper_limit < ppb * ppb) {
3516 meta_blocks += 1 + DIV_ROUND_UP_ULL(upper_limit, ppb);
3517 res -= meta_blocks;
3518 goto check_lfs;
3519 }
3520 meta_blocks += 1 + ppb;
3521 upper_limit -= ppb * ppb;
3522 /* tripple indirect blocks for the rest */
3523 meta_blocks += 1 + DIV_ROUND_UP_ULL(upper_limit, ppb) +
3524 DIV_ROUND_UP_ULL(upper_limit, ppb*ppb);
3525 res -= meta_blocks;
3526 check_lfs:
3527 res <<= bits;
3528 if (res > MAX_LFS_FILESIZE)
3529 res = MAX_LFS_FILESIZE;
3530
3531 return res;
3532 }
3533
descriptor_loc(struct super_block * sb,ext4_fsblk_t logical_sb_block,int nr)3534 static ext4_fsblk_t descriptor_loc(struct super_block *sb,
3535 ext4_fsblk_t logical_sb_block, int nr)
3536 {
3537 struct ext4_sb_info *sbi = EXT4_SB(sb);
3538 ext4_group_t bg, first_meta_bg;
3539 int has_super = 0;
3540
3541 first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
3542
3543 if (!ext4_has_feature_meta_bg(sb) || nr < first_meta_bg)
3544 return logical_sb_block + nr + 1;
3545 bg = sbi->s_desc_per_block * nr;
3546 if (ext4_bg_has_super(sb, bg))
3547 has_super = 1;
3548
3549 /*
3550 * If we have a meta_bg fs with 1k blocks, group 0's GDT is at
3551 * block 2, not 1. If s_first_data_block == 0 (bigalloc is enabled
3552 * on modern mke2fs or blksize > 1k on older mke2fs) then we must
3553 * compensate.
3554 */
3555 if (sb->s_blocksize == 1024 && nr == 0 &&
3556 le32_to_cpu(sbi->s_es->s_first_data_block) == 0)
3557 has_super++;
3558
3559 return (has_super + ext4_group_first_block_no(sb, bg));
3560 }
3561
3562 /**
3563 * ext4_get_stripe_size: Get the stripe size.
3564 * @sbi: In memory super block info
3565 *
3566 * If we have specified it via mount option, then
3567 * use the mount option value. If the value specified at mount time is
3568 * greater than the blocks per group use the super block value.
3569 * If the super block value is greater than blocks per group return 0.
3570 * Allocator needs it be less than blocks per group.
3571 *
3572 */
ext4_get_stripe_size(struct ext4_sb_info * sbi)3573 static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
3574 {
3575 unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
3576 unsigned long stripe_width =
3577 le32_to_cpu(sbi->s_es->s_raid_stripe_width);
3578 int ret;
3579
3580 if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
3581 ret = sbi->s_stripe;
3582 else if (stripe_width && stripe_width <= sbi->s_blocks_per_group)
3583 ret = stripe_width;
3584 else if (stride && stride <= sbi->s_blocks_per_group)
3585 ret = stride;
3586 else
3587 ret = 0;
3588
3589 /*
3590 * If the stripe width is 1, this makes no sense and
3591 * we set it to 0 to turn off stripe handling code.
3592 */
3593 if (ret <= 1)
3594 ret = 0;
3595
3596 return ret;
3597 }
3598
3599 /*
3600 * Check whether this filesystem can be mounted based on
3601 * the features present and the RDONLY/RDWR mount requested.
3602 * Returns 1 if this filesystem can be mounted as requested,
3603 * 0 if it cannot be.
3604 */
ext4_feature_set_ok(struct super_block * sb,int readonly)3605 int ext4_feature_set_ok(struct super_block *sb, int readonly)
3606 {
3607 if (ext4_has_unknown_ext4_incompat_features(sb)) {
3608 ext4_msg(sb, KERN_ERR,
3609 "Couldn't mount because of "
3610 "unsupported optional features (%x)",
3611 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
3612 ~EXT4_FEATURE_INCOMPAT_SUPP));
3613 return 0;
3614 }
3615
3616 #if !IS_ENABLED(CONFIG_UNICODE)
3617 if (ext4_has_feature_casefold(sb)) {
3618 ext4_msg(sb, KERN_ERR,
3619 "Filesystem with casefold feature cannot be "
3620 "mounted without CONFIG_UNICODE");
3621 return 0;
3622 }
3623 #endif
3624
3625 if (readonly)
3626 return 1;
3627
3628 if (ext4_has_feature_readonly(sb)) {
3629 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
3630 sb->s_flags |= SB_RDONLY;
3631 return 1;
3632 }
3633
3634 /* Check that feature set is OK for a read-write mount */
3635 if (ext4_has_unknown_ext4_ro_compat_features(sb)) {
3636 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
3637 "unsupported optional features (%x)",
3638 (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
3639 ~EXT4_FEATURE_RO_COMPAT_SUPP));
3640 return 0;
3641 }
3642 if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3643 ext4_msg(sb, KERN_ERR,
3644 "Can't support bigalloc feature without "
3645 "extents feature\n");
3646 return 0;
3647 }
3648
3649 #if !IS_ENABLED(CONFIG_QUOTA) || !IS_ENABLED(CONFIG_QFMT_V2)
3650 if (!readonly && (ext4_has_feature_quota(sb) ||
3651 ext4_has_feature_project(sb))) {
3652 ext4_msg(sb, KERN_ERR,
3653 "The kernel was not built with CONFIG_QUOTA and CONFIG_QFMT_V2");
3654 return 0;
3655 }
3656 #endif /* CONFIG_QUOTA */
3657 return 1;
3658 }
3659
3660 /*
3661 * This function is called once a day if we have errors logged
3662 * on the file system
3663 */
print_daily_error_info(struct timer_list * t)3664 static void print_daily_error_info(struct timer_list *t)
3665 {
3666 struct ext4_sb_info *sbi = from_timer(sbi, t, s_err_report);
3667 struct super_block *sb = sbi->s_sb;
3668 struct ext4_super_block *es = sbi->s_es;
3669
3670 if (es->s_error_count)
3671 /* fsck newer than v1.41.13 is needed to clean this condition. */
3672 ext4_msg(sb, KERN_NOTICE, "error count since last fsck: %u",
3673 le32_to_cpu(es->s_error_count));
3674 if (es->s_first_error_time) {
3675 printk(KERN_NOTICE "EXT4-fs (%s): initial error at time %llu: %.*s:%d",
3676 sb->s_id,
3677 ext4_get_tstamp(es, s_first_error_time),
3678 (int) sizeof(es->s_first_error_func),
3679 es->s_first_error_func,
3680 le32_to_cpu(es->s_first_error_line));
3681 if (es->s_first_error_ino)
3682 printk(KERN_CONT ": inode %u",
3683 le32_to_cpu(es->s_first_error_ino));
3684 if (es->s_first_error_block)
3685 printk(KERN_CONT ": block %llu", (unsigned long long)
3686 le64_to_cpu(es->s_first_error_block));
3687 printk(KERN_CONT "\n");
3688 }
3689 if (es->s_last_error_time) {
3690 printk(KERN_NOTICE "EXT4-fs (%s): last error at time %llu: %.*s:%d",
3691 sb->s_id,
3692 ext4_get_tstamp(es, s_last_error_time),
3693 (int) sizeof(es->s_last_error_func),
3694 es->s_last_error_func,
3695 le32_to_cpu(es->s_last_error_line));
3696 if (es->s_last_error_ino)
3697 printk(KERN_CONT ": inode %u",
3698 le32_to_cpu(es->s_last_error_ino));
3699 if (es->s_last_error_block)
3700 printk(KERN_CONT ": block %llu", (unsigned long long)
3701 le64_to_cpu(es->s_last_error_block));
3702 printk(KERN_CONT "\n");
3703 }
3704 mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ); /* Once a day */
3705 }
3706
3707 /* Find next suitable group and run ext4_init_inode_table */
ext4_run_li_request(struct ext4_li_request * elr)3708 static int ext4_run_li_request(struct ext4_li_request *elr)
3709 {
3710 struct ext4_group_desc *gdp = NULL;
3711 struct super_block *sb = elr->lr_super;
3712 ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
3713 ext4_group_t group = elr->lr_next_group;
3714 unsigned int prefetch_ios = 0;
3715 int ret = 0;
3716 int nr = EXT4_SB(sb)->s_mb_prefetch;
3717 u64 start_time;
3718
3719 if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
3720 elr->lr_next_group = ext4_mb_prefetch(sb, group, nr, &prefetch_ios);
3721 ext4_mb_prefetch_fini(sb, elr->lr_next_group, nr);
3722 trace_ext4_prefetch_bitmaps(sb, group, elr->lr_next_group, nr);
3723 if (group >= elr->lr_next_group) {
3724 ret = 1;
3725 if (elr->lr_first_not_zeroed != ngroups &&
3726 !sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
3727 elr->lr_next_group = elr->lr_first_not_zeroed;
3728 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3729 ret = 0;
3730 }
3731 }
3732 return ret;
3733 }
3734
3735 for (; group < ngroups; group++) {
3736 gdp = ext4_get_group_desc(sb, group, NULL);
3737 if (!gdp) {
3738 ret = 1;
3739 break;
3740 }
3741
3742 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3743 break;
3744 }
3745
3746 if (group >= ngroups)
3747 ret = 1;
3748
3749 if (!ret) {
3750 start_time = ktime_get_real_ns();
3751 ret = ext4_init_inode_table(sb, group,
3752 elr->lr_timeout ? 0 : 1);
3753 trace_ext4_lazy_itable_init(sb, group);
3754 if (elr->lr_timeout == 0) {
3755 elr->lr_timeout = nsecs_to_jiffies((ktime_get_real_ns() - start_time) *
3756 EXT4_SB(elr->lr_super)->s_li_wait_mult);
3757 }
3758 elr->lr_next_sched = jiffies + elr->lr_timeout;
3759 elr->lr_next_group = group + 1;
3760 }
3761 return ret;
3762 }
3763
3764 /*
3765 * Remove lr_request from the list_request and free the
3766 * request structure. Should be called with li_list_mtx held
3767 */
ext4_remove_li_request(struct ext4_li_request * elr)3768 static void ext4_remove_li_request(struct ext4_li_request *elr)
3769 {
3770 if (!elr)
3771 return;
3772
3773 list_del(&elr->lr_request);
3774 EXT4_SB(elr->lr_super)->s_li_request = NULL;
3775 kfree(elr);
3776 }
3777
ext4_unregister_li_request(struct super_block * sb)3778 static void ext4_unregister_li_request(struct super_block *sb)
3779 {
3780 mutex_lock(&ext4_li_mtx);
3781 if (!ext4_li_info) {
3782 mutex_unlock(&ext4_li_mtx);
3783 return;
3784 }
3785
3786 mutex_lock(&ext4_li_info->li_list_mtx);
3787 ext4_remove_li_request(EXT4_SB(sb)->s_li_request);
3788 mutex_unlock(&ext4_li_info->li_list_mtx);
3789 mutex_unlock(&ext4_li_mtx);
3790 }
3791
3792 static struct task_struct *ext4_lazyinit_task;
3793
3794 /*
3795 * This is the function where ext4lazyinit thread lives. It walks
3796 * through the request list searching for next scheduled filesystem.
3797 * When such a fs is found, run the lazy initialization request
3798 * (ext4_rn_li_request) and keep track of the time spend in this
3799 * function. Based on that time we compute next schedule time of
3800 * the request. When walking through the list is complete, compute
3801 * next waking time and put itself into sleep.
3802 */
ext4_lazyinit_thread(void * arg)3803 static int ext4_lazyinit_thread(void *arg)
3804 {
3805 struct ext4_lazy_init *eli = arg;
3806 struct list_head *pos, *n;
3807 struct ext4_li_request *elr;
3808 unsigned long next_wakeup, cur;
3809
3810 BUG_ON(NULL == eli);
3811 set_freezable();
3812
3813 cont_thread:
3814 while (true) {
3815 next_wakeup = MAX_JIFFY_OFFSET;
3816
3817 mutex_lock(&eli->li_list_mtx);
3818 if (list_empty(&eli->li_request_list)) {
3819 mutex_unlock(&eli->li_list_mtx);
3820 goto exit_thread;
3821 }
3822 list_for_each_safe(pos, n, &eli->li_request_list) {
3823 int err = 0;
3824 int progress = 0;
3825 elr = list_entry(pos, struct ext4_li_request,
3826 lr_request);
3827
3828 if (time_before(jiffies, elr->lr_next_sched)) {
3829 if (time_before(elr->lr_next_sched, next_wakeup))
3830 next_wakeup = elr->lr_next_sched;
3831 continue;
3832 }
3833 if (down_read_trylock(&elr->lr_super->s_umount)) {
3834 if (sb_start_write_trylock(elr->lr_super)) {
3835 progress = 1;
3836 /*
3837 * We hold sb->s_umount, sb can not
3838 * be removed from the list, it is
3839 * now safe to drop li_list_mtx
3840 */
3841 mutex_unlock(&eli->li_list_mtx);
3842 err = ext4_run_li_request(elr);
3843 sb_end_write(elr->lr_super);
3844 mutex_lock(&eli->li_list_mtx);
3845 n = pos->next;
3846 }
3847 up_read((&elr->lr_super->s_umount));
3848 }
3849 /* error, remove the lazy_init job */
3850 if (err) {
3851 ext4_remove_li_request(elr);
3852 continue;
3853 }
3854 if (!progress) {
3855 elr->lr_next_sched = jiffies +
3856 get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3857 }
3858 if (time_before(elr->lr_next_sched, next_wakeup))
3859 next_wakeup = elr->lr_next_sched;
3860 }
3861 mutex_unlock(&eli->li_list_mtx);
3862
3863 try_to_freeze();
3864
3865 cur = jiffies;
3866 if ((time_after_eq(cur, next_wakeup)) ||
3867 (MAX_JIFFY_OFFSET == next_wakeup)) {
3868 cond_resched();
3869 continue;
3870 }
3871
3872 schedule_timeout_interruptible(next_wakeup - cur);
3873
3874 if (kthread_should_stop()) {
3875 ext4_clear_request_list();
3876 goto exit_thread;
3877 }
3878 }
3879
3880 exit_thread:
3881 /*
3882 * It looks like the request list is empty, but we need
3883 * to check it under the li_list_mtx lock, to prevent any
3884 * additions into it, and of course we should lock ext4_li_mtx
3885 * to atomically free the list and ext4_li_info, because at
3886 * this point another ext4 filesystem could be registering
3887 * new one.
3888 */
3889 mutex_lock(&ext4_li_mtx);
3890 mutex_lock(&eli->li_list_mtx);
3891 if (!list_empty(&eli->li_request_list)) {
3892 mutex_unlock(&eli->li_list_mtx);
3893 mutex_unlock(&ext4_li_mtx);
3894 goto cont_thread;
3895 }
3896 mutex_unlock(&eli->li_list_mtx);
3897 kfree(ext4_li_info);
3898 ext4_li_info = NULL;
3899 mutex_unlock(&ext4_li_mtx);
3900
3901 return 0;
3902 }
3903
ext4_clear_request_list(void)3904 static void ext4_clear_request_list(void)
3905 {
3906 struct list_head *pos, *n;
3907 struct ext4_li_request *elr;
3908
3909 mutex_lock(&ext4_li_info->li_list_mtx);
3910 list_for_each_safe(pos, n, &ext4_li_info->li_request_list) {
3911 elr = list_entry(pos, struct ext4_li_request,
3912 lr_request);
3913 ext4_remove_li_request(elr);
3914 }
3915 mutex_unlock(&ext4_li_info->li_list_mtx);
3916 }
3917
ext4_run_lazyinit_thread(void)3918 static int ext4_run_lazyinit_thread(void)
3919 {
3920 ext4_lazyinit_task = kthread_run(ext4_lazyinit_thread,
3921 ext4_li_info, "ext4lazyinit");
3922 if (IS_ERR(ext4_lazyinit_task)) {
3923 int err = PTR_ERR(ext4_lazyinit_task);
3924 ext4_clear_request_list();
3925 kfree(ext4_li_info);
3926 ext4_li_info = NULL;
3927 printk(KERN_CRIT "EXT4-fs: error %d creating inode table "
3928 "initialization thread\n",
3929 err);
3930 return err;
3931 }
3932 ext4_li_info->li_state |= EXT4_LAZYINIT_RUNNING;
3933 return 0;
3934 }
3935
3936 /*
3937 * Check whether it make sense to run itable init. thread or not.
3938 * If there is at least one uninitialized inode table, return
3939 * corresponding group number, else the loop goes through all
3940 * groups and return total number of groups.
3941 */
ext4_has_uninit_itable(struct super_block * sb)3942 static ext4_group_t ext4_has_uninit_itable(struct super_block *sb)
3943 {
3944 ext4_group_t group, ngroups = EXT4_SB(sb)->s_groups_count;
3945 struct ext4_group_desc *gdp = NULL;
3946
3947 if (!ext4_has_group_desc_csum(sb))
3948 return ngroups;
3949
3950 for (group = 0; group < ngroups; group++) {
3951 gdp = ext4_get_group_desc(sb, group, NULL);
3952 if (!gdp)
3953 continue;
3954
3955 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3956 break;
3957 }
3958
3959 return group;
3960 }
3961
ext4_li_info_new(void)3962 static int ext4_li_info_new(void)
3963 {
3964 struct ext4_lazy_init *eli = NULL;
3965
3966 eli = kzalloc(sizeof(*eli), GFP_KERNEL);
3967 if (!eli)
3968 return -ENOMEM;
3969
3970 INIT_LIST_HEAD(&eli->li_request_list);
3971 mutex_init(&eli->li_list_mtx);
3972
3973 eli->li_state |= EXT4_LAZYINIT_QUIT;
3974
3975 ext4_li_info = eli;
3976
3977 return 0;
3978 }
3979
ext4_li_request_new(struct super_block * sb,ext4_group_t start)3980 static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
3981 ext4_group_t start)
3982 {
3983 struct ext4_li_request *elr;
3984
3985 elr = kzalloc(sizeof(*elr), GFP_KERNEL);
3986 if (!elr)
3987 return NULL;
3988
3989 elr->lr_super = sb;
3990 elr->lr_first_not_zeroed = start;
3991 if (test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS)) {
3992 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3993 elr->lr_next_group = start;
3994 } else {
3995 elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
3996 }
3997
3998 /*
3999 * Randomize first schedule time of the request to
4000 * spread the inode table initialization requests
4001 * better.
4002 */
4003 elr->lr_next_sched = jiffies + get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
4004 return elr;
4005 }
4006
ext4_register_li_request(struct super_block * sb,ext4_group_t first_not_zeroed)4007 int ext4_register_li_request(struct super_block *sb,
4008 ext4_group_t first_not_zeroed)
4009 {
4010 struct ext4_sb_info *sbi = EXT4_SB(sb);
4011 struct ext4_li_request *elr = NULL;
4012 ext4_group_t ngroups = sbi->s_groups_count;
4013 int ret = 0;
4014
4015 mutex_lock(&ext4_li_mtx);
4016 if (sbi->s_li_request != NULL) {
4017 /*
4018 * Reset timeout so it can be computed again, because
4019 * s_li_wait_mult might have changed.
4020 */
4021 sbi->s_li_request->lr_timeout = 0;
4022 goto out;
4023 }
4024
4025 if (sb_rdonly(sb) ||
4026 (test_opt(sb, NO_PREFETCH_BLOCK_BITMAPS) &&
4027 (first_not_zeroed == ngroups || !test_opt(sb, INIT_INODE_TABLE))))
4028 goto out;
4029
4030 elr = ext4_li_request_new(sb, first_not_zeroed);
4031 if (!elr) {
4032 ret = -ENOMEM;
4033 goto out;
4034 }
4035
4036 if (NULL == ext4_li_info) {
4037 ret = ext4_li_info_new();
4038 if (ret)
4039 goto out;
4040 }
4041
4042 mutex_lock(&ext4_li_info->li_list_mtx);
4043 list_add(&elr->lr_request, &ext4_li_info->li_request_list);
4044 mutex_unlock(&ext4_li_info->li_list_mtx);
4045
4046 sbi->s_li_request = elr;
4047 /*
4048 * set elr to NULL here since it has been inserted to
4049 * the request_list and the removal and free of it is
4050 * handled by ext4_clear_request_list from now on.
4051 */
4052 elr = NULL;
4053
4054 if (!(ext4_li_info->li_state & EXT4_LAZYINIT_RUNNING)) {
4055 ret = ext4_run_lazyinit_thread();
4056 if (ret)
4057 goto out;
4058 }
4059 out:
4060 mutex_unlock(&ext4_li_mtx);
4061 if (ret)
4062 kfree(elr);
4063 return ret;
4064 }
4065
4066 /*
4067 * We do not need to lock anything since this is called on
4068 * module unload.
4069 */
ext4_destroy_lazyinit_thread(void)4070 static void ext4_destroy_lazyinit_thread(void)
4071 {
4072 /*
4073 * If thread exited earlier
4074 * there's nothing to be done.
4075 */
4076 if (!ext4_li_info || !ext4_lazyinit_task)
4077 return;
4078
4079 kthread_stop(ext4_lazyinit_task);
4080 }
4081
set_journal_csum_feature_set(struct super_block * sb)4082 static int set_journal_csum_feature_set(struct super_block *sb)
4083 {
4084 int ret = 1;
4085 int compat, incompat;
4086 struct ext4_sb_info *sbi = EXT4_SB(sb);
4087
4088 if (ext4_has_metadata_csum(sb)) {
4089 /* journal checksum v3 */
4090 compat = 0;
4091 incompat = JBD2_FEATURE_INCOMPAT_CSUM_V3;
4092 } else {
4093 /* journal checksum v1 */
4094 compat = JBD2_FEATURE_COMPAT_CHECKSUM;
4095 incompat = 0;
4096 }
4097
4098 jbd2_journal_clear_features(sbi->s_journal,
4099 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
4100 JBD2_FEATURE_INCOMPAT_CSUM_V3 |
4101 JBD2_FEATURE_INCOMPAT_CSUM_V2);
4102 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4103 ret = jbd2_journal_set_features(sbi->s_journal,
4104 compat, 0,
4105 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
4106 incompat);
4107 } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
4108 ret = jbd2_journal_set_features(sbi->s_journal,
4109 compat, 0,
4110 incompat);
4111 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
4112 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
4113 } else {
4114 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
4115 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
4116 }
4117
4118 return ret;
4119 }
4120
4121 /*
4122 * Note: calculating the overhead so we can be compatible with
4123 * historical BSD practice is quite difficult in the face of
4124 * clusters/bigalloc. This is because multiple metadata blocks from
4125 * different block group can end up in the same allocation cluster.
4126 * Calculating the exact overhead in the face of clustered allocation
4127 * requires either O(all block bitmaps) in memory or O(number of block
4128 * groups**2) in time. We will still calculate the superblock for
4129 * older file systems --- and if we come across with a bigalloc file
4130 * system with zero in s_overhead_clusters the estimate will be close to
4131 * correct especially for very large cluster sizes --- but for newer
4132 * file systems, it's better to calculate this figure once at mkfs
4133 * time, and store it in the superblock. If the superblock value is
4134 * present (even for non-bigalloc file systems), we will use it.
4135 */
count_overhead(struct super_block * sb,ext4_group_t grp,char * buf)4136 static int count_overhead(struct super_block *sb, ext4_group_t grp,
4137 char *buf)
4138 {
4139 struct ext4_sb_info *sbi = EXT4_SB(sb);
4140 struct ext4_group_desc *gdp;
4141 ext4_fsblk_t first_block, last_block, b;
4142 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
4143 int s, j, count = 0;
4144 int has_super = ext4_bg_has_super(sb, grp);
4145
4146 if (!ext4_has_feature_bigalloc(sb))
4147 return (has_super + ext4_bg_num_gdb(sb, grp) +
4148 (has_super ? le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0) +
4149 sbi->s_itb_per_group + 2);
4150
4151 first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
4152 (grp * EXT4_BLOCKS_PER_GROUP(sb));
4153 last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1;
4154 for (i = 0; i < ngroups; i++) {
4155 gdp = ext4_get_group_desc(sb, i, NULL);
4156 b = ext4_block_bitmap(sb, gdp);
4157 if (b >= first_block && b <= last_block) {
4158 ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
4159 count++;
4160 }
4161 b = ext4_inode_bitmap(sb, gdp);
4162 if (b >= first_block && b <= last_block) {
4163 ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
4164 count++;
4165 }
4166 b = ext4_inode_table(sb, gdp);
4167 if (b >= first_block && b + sbi->s_itb_per_group <= last_block)
4168 for (j = 0; j < sbi->s_itb_per_group; j++, b++) {
4169 int c = EXT4_B2C(sbi, b - first_block);
4170 ext4_set_bit(c, buf);
4171 count++;
4172 }
4173 if (i != grp)
4174 continue;
4175 s = 0;
4176 if (ext4_bg_has_super(sb, grp)) {
4177 ext4_set_bit(s++, buf);
4178 count++;
4179 }
4180 j = ext4_bg_num_gdb(sb, grp);
4181 if (s + j > EXT4_BLOCKS_PER_GROUP(sb)) {
4182 ext4_error(sb, "Invalid number of block group "
4183 "descriptor blocks: %d", j);
4184 j = EXT4_BLOCKS_PER_GROUP(sb) - s;
4185 }
4186 count += j;
4187 for (; j > 0; j--)
4188 ext4_set_bit(EXT4_B2C(sbi, s++), buf);
4189 }
4190 if (!count)
4191 return 0;
4192 return EXT4_CLUSTERS_PER_GROUP(sb) -
4193 ext4_count_free(buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8);
4194 }
4195
4196 /*
4197 * Compute the overhead and stash it in sbi->s_overhead
4198 */
ext4_calculate_overhead(struct super_block * sb)4199 int ext4_calculate_overhead(struct super_block *sb)
4200 {
4201 struct ext4_sb_info *sbi = EXT4_SB(sb);
4202 struct ext4_super_block *es = sbi->s_es;
4203 struct inode *j_inode;
4204 unsigned int j_blocks, j_inum = le32_to_cpu(es->s_journal_inum);
4205 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
4206 ext4_fsblk_t overhead = 0;
4207 char *buf = (char *) get_zeroed_page(GFP_NOFS);
4208
4209 if (!buf)
4210 return -ENOMEM;
4211
4212 /*
4213 * Compute the overhead (FS structures). This is constant
4214 * for a given filesystem unless the number of block groups
4215 * changes so we cache the previous value until it does.
4216 */
4217
4218 /*
4219 * All of the blocks before first_data_block are overhead
4220 */
4221 overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
4222
4223 /*
4224 * Add the overhead found in each block group
4225 */
4226 for (i = 0; i < ngroups; i++) {
4227 int blks;
4228
4229 blks = count_overhead(sb, i, buf);
4230 overhead += blks;
4231 if (blks)
4232 memset(buf, 0, PAGE_SIZE);
4233 cond_resched();
4234 }
4235
4236 /*
4237 * Add the internal journal blocks whether the journal has been
4238 * loaded or not
4239 */
4240 if (sbi->s_journal && !sbi->s_journal_bdev)
4241 overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
4242 else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
4243 /* j_inum for internal journal is non-zero */
4244 j_inode = ext4_get_journal_inode(sb, j_inum);
4245 if (!IS_ERR(j_inode)) {
4246 j_blocks = j_inode->i_size >> sb->s_blocksize_bits;
4247 overhead += EXT4_NUM_B2C(sbi, j_blocks);
4248 iput(j_inode);
4249 } else {
4250 ext4_msg(sb, KERN_ERR, "can't get journal size");
4251 }
4252 }
4253 sbi->s_overhead = overhead;
4254 smp_wmb();
4255 free_page((unsigned long) buf);
4256 return 0;
4257 }
4258
ext4_set_resv_clusters(struct super_block * sb)4259 static void ext4_set_resv_clusters(struct super_block *sb)
4260 {
4261 ext4_fsblk_t resv_clusters;
4262 struct ext4_sb_info *sbi = EXT4_SB(sb);
4263
4264 /*
4265 * There's no need to reserve anything when we aren't using extents.
4266 * The space estimates are exact, there are no unwritten extents,
4267 * hole punching doesn't need new metadata... This is needed especially
4268 * to keep ext2/3 backward compatibility.
4269 */
4270 if (!ext4_has_feature_extents(sb))
4271 return;
4272 /*
4273 * By default we reserve 2% or 4096 clusters, whichever is smaller.
4274 * This should cover the situations where we can not afford to run
4275 * out of space like for example punch hole, or converting
4276 * unwritten extents in delalloc path. In most cases such
4277 * allocation would require 1, or 2 blocks, higher numbers are
4278 * very rare.
4279 */
4280 resv_clusters = (ext4_blocks_count(sbi->s_es) >>
4281 sbi->s_cluster_bits);
4282
4283 do_div(resv_clusters, 50);
4284 resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
4285
4286 atomic64_set(&sbi->s_resv_clusters, resv_clusters);
4287 }
4288
ext4_quota_mode(struct super_block * sb)4289 static const char *ext4_quota_mode(struct super_block *sb)
4290 {
4291 #ifdef CONFIG_QUOTA
4292 if (!ext4_quota_capable(sb))
4293 return "none";
4294
4295 if (EXT4_SB(sb)->s_journal && ext4_is_quota_journalled(sb))
4296 return "journalled";
4297 else
4298 return "writeback";
4299 #else
4300 return "disabled";
4301 #endif
4302 }
4303
ext4_setup_csum_trigger(struct super_block * sb,enum ext4_journal_trigger_type type,void (* trigger)(struct jbd2_buffer_trigger_type * type,struct buffer_head * bh,void * mapped_data,size_t size))4304 static void ext4_setup_csum_trigger(struct super_block *sb,
4305 enum ext4_journal_trigger_type type,
4306 void (*trigger)(
4307 struct jbd2_buffer_trigger_type *type,
4308 struct buffer_head *bh,
4309 void *mapped_data,
4310 size_t size))
4311 {
4312 struct ext4_sb_info *sbi = EXT4_SB(sb);
4313
4314 sbi->s_journal_triggers[type].sb = sb;
4315 sbi->s_journal_triggers[type].tr_triggers.t_frozen = trigger;
4316 }
4317
ext4_free_sbi(struct ext4_sb_info * sbi)4318 static void ext4_free_sbi(struct ext4_sb_info *sbi)
4319 {
4320 if (!sbi)
4321 return;
4322
4323 kfree(sbi->s_blockgroup_lock);
4324 fs_put_dax(sbi->s_daxdev, NULL);
4325 kfree(sbi);
4326 }
4327
ext4_alloc_sbi(struct super_block * sb)4328 static struct ext4_sb_info *ext4_alloc_sbi(struct super_block *sb)
4329 {
4330 struct ext4_sb_info *sbi;
4331
4332 sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
4333 if (!sbi)
4334 return NULL;
4335
4336 sbi->s_daxdev = fs_dax_get_by_bdev(sb->s_bdev, &sbi->s_dax_part_off,
4337 NULL, NULL);
4338
4339 sbi->s_blockgroup_lock =
4340 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
4341
4342 if (!sbi->s_blockgroup_lock)
4343 goto err_out;
4344
4345 sb->s_fs_info = sbi;
4346 sbi->s_sb = sb;
4347 return sbi;
4348 err_out:
4349 fs_put_dax(sbi->s_daxdev, NULL);
4350 kfree(sbi);
4351 return NULL;
4352 }
4353
ext4_set_def_opts(struct super_block * sb,struct ext4_super_block * es)4354 static void ext4_set_def_opts(struct super_block *sb,
4355 struct ext4_super_block *es)
4356 {
4357 unsigned long def_mount_opts;
4358
4359 /* Set defaults before we parse the mount options */
4360 def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
4361 set_opt(sb, INIT_INODE_TABLE);
4362 if (def_mount_opts & EXT4_DEFM_DEBUG)
4363 set_opt(sb, DEBUG);
4364 if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
4365 set_opt(sb, GRPID);
4366 if (def_mount_opts & EXT4_DEFM_UID16)
4367 set_opt(sb, NO_UID32);
4368 /* xattr user namespace & acls are now defaulted on */
4369 set_opt(sb, XATTR_USER);
4370 #ifdef CONFIG_EXT4_FS_POSIX_ACL
4371 set_opt(sb, POSIX_ACL);
4372 #endif
4373 if (ext4_has_feature_fast_commit(sb))
4374 set_opt2(sb, JOURNAL_FAST_COMMIT);
4375 /* don't forget to enable journal_csum when metadata_csum is enabled. */
4376 if (ext4_has_metadata_csum(sb))
4377 set_opt(sb, JOURNAL_CHECKSUM);
4378
4379 if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
4380 set_opt(sb, JOURNAL_DATA);
4381 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
4382 set_opt(sb, ORDERED_DATA);
4383 else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
4384 set_opt(sb, WRITEBACK_DATA);
4385
4386 if (le16_to_cpu(es->s_errors) == EXT4_ERRORS_PANIC)
4387 set_opt(sb, ERRORS_PANIC);
4388 else if (le16_to_cpu(es->s_errors) == EXT4_ERRORS_CONTINUE)
4389 set_opt(sb, ERRORS_CONT);
4390 else
4391 set_opt(sb, ERRORS_RO);
4392 /* block_validity enabled by default; disable with noblock_validity */
4393 set_opt(sb, BLOCK_VALIDITY);
4394 if (def_mount_opts & EXT4_DEFM_DISCARD)
4395 set_opt(sb, DISCARD);
4396
4397 if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
4398 set_opt(sb, BARRIER);
4399
4400 /*
4401 * enable delayed allocation by default
4402 * Use -o nodelalloc to turn it off
4403 */
4404 if (!IS_EXT3_SB(sb) && !IS_EXT2_SB(sb) &&
4405 ((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
4406 set_opt(sb, DELALLOC);
4407
4408 if (sb->s_blocksize == PAGE_SIZE)
4409 set_opt(sb, DIOREAD_NOLOCK);
4410 }
4411
ext4_handle_clustersize(struct super_block * sb)4412 static int ext4_handle_clustersize(struct super_block *sb)
4413 {
4414 struct ext4_sb_info *sbi = EXT4_SB(sb);
4415 struct ext4_super_block *es = sbi->s_es;
4416 int clustersize;
4417
4418 /* Handle clustersize */
4419 clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4420 if (ext4_has_feature_bigalloc(sb)) {
4421 if (clustersize < sb->s_blocksize) {
4422 ext4_msg(sb, KERN_ERR,
4423 "cluster size (%d) smaller than "
4424 "block size (%lu)", clustersize, sb->s_blocksize);
4425 return -EINVAL;
4426 }
4427 sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
4428 le32_to_cpu(es->s_log_block_size);
4429 sbi->s_clusters_per_group =
4430 le32_to_cpu(es->s_clusters_per_group);
4431 if (sbi->s_clusters_per_group > sb->s_blocksize * 8) {
4432 ext4_msg(sb, KERN_ERR,
4433 "#clusters per group too big: %lu",
4434 sbi->s_clusters_per_group);
4435 return -EINVAL;
4436 }
4437 if (sbi->s_blocks_per_group !=
4438 (sbi->s_clusters_per_group * (clustersize / sb->s_blocksize))) {
4439 ext4_msg(sb, KERN_ERR, "blocks per group (%lu) and "
4440 "clusters per group (%lu) inconsistent",
4441 sbi->s_blocks_per_group,
4442 sbi->s_clusters_per_group);
4443 return -EINVAL;
4444 }
4445 } else {
4446 if (clustersize != sb->s_blocksize) {
4447 ext4_msg(sb, KERN_ERR,
4448 "fragment/cluster size (%d) != "
4449 "block size (%lu)", clustersize, sb->s_blocksize);
4450 return -EINVAL;
4451 }
4452 if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
4453 ext4_msg(sb, KERN_ERR,
4454 "#blocks per group too big: %lu",
4455 sbi->s_blocks_per_group);
4456 return -EINVAL;
4457 }
4458 sbi->s_clusters_per_group = sbi->s_blocks_per_group;
4459 sbi->s_cluster_bits = 0;
4460 }
4461 sbi->s_cluster_ratio = clustersize / sb->s_blocksize;
4462
4463 /* Do we have standard group size of clustersize * 8 blocks ? */
4464 if (sbi->s_blocks_per_group == clustersize << 3)
4465 set_opt2(sb, STD_GROUP_SIZE);
4466
4467 return 0;
4468 }
4469
ext4_fast_commit_init(struct super_block * sb)4470 static void ext4_fast_commit_init(struct super_block *sb)
4471 {
4472 struct ext4_sb_info *sbi = EXT4_SB(sb);
4473
4474 /* Initialize fast commit stuff */
4475 atomic_set(&sbi->s_fc_subtid, 0);
4476 INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_MAIN]);
4477 INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_STAGING]);
4478 INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_MAIN]);
4479 INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
4480 sbi->s_fc_bytes = 0;
4481 ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
4482 sbi->s_fc_ineligible_tid = 0;
4483 spin_lock_init(&sbi->s_fc_lock);
4484 memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
4485 sbi->s_fc_replay_state.fc_regions = NULL;
4486 sbi->s_fc_replay_state.fc_regions_size = 0;
4487 sbi->s_fc_replay_state.fc_regions_used = 0;
4488 sbi->s_fc_replay_state.fc_regions_valid = 0;
4489 sbi->s_fc_replay_state.fc_modified_inodes = NULL;
4490 sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
4491 sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
4492 }
4493
ext4_inode_info_init(struct super_block * sb,struct ext4_super_block * es)4494 static int ext4_inode_info_init(struct super_block *sb,
4495 struct ext4_super_block *es)
4496 {
4497 struct ext4_sb_info *sbi = EXT4_SB(sb);
4498
4499 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
4500 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
4501 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
4502 } else {
4503 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
4504 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
4505 if (sbi->s_first_ino < EXT4_GOOD_OLD_FIRST_INO) {
4506 ext4_msg(sb, KERN_ERR, "invalid first ino: %u",
4507 sbi->s_first_ino);
4508 return -EINVAL;
4509 }
4510 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
4511 (!is_power_of_2(sbi->s_inode_size)) ||
4512 (sbi->s_inode_size > sb->s_blocksize)) {
4513 ext4_msg(sb, KERN_ERR,
4514 "unsupported inode size: %d",
4515 sbi->s_inode_size);
4516 ext4_msg(sb, KERN_ERR, "blocksize: %lu", sb->s_blocksize);
4517 return -EINVAL;
4518 }
4519 /*
4520 * i_atime_extra is the last extra field available for
4521 * [acm]times in struct ext4_inode. Checking for that
4522 * field should suffice to ensure we have extra space
4523 * for all three.
4524 */
4525 if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
4526 sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
4527 sb->s_time_gran = 1;
4528 sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
4529 } else {
4530 sb->s_time_gran = NSEC_PER_SEC;
4531 sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
4532 }
4533 sb->s_time_min = EXT4_TIMESTAMP_MIN;
4534 }
4535
4536 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
4537 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
4538 EXT4_GOOD_OLD_INODE_SIZE;
4539 if (ext4_has_feature_extra_isize(sb)) {
4540 unsigned v, max = (sbi->s_inode_size -
4541 EXT4_GOOD_OLD_INODE_SIZE);
4542
4543 v = le16_to_cpu(es->s_want_extra_isize);
4544 if (v > max) {
4545 ext4_msg(sb, KERN_ERR,
4546 "bad s_want_extra_isize: %d", v);
4547 return -EINVAL;
4548 }
4549 if (sbi->s_want_extra_isize < v)
4550 sbi->s_want_extra_isize = v;
4551
4552 v = le16_to_cpu(es->s_min_extra_isize);
4553 if (v > max) {
4554 ext4_msg(sb, KERN_ERR,
4555 "bad s_min_extra_isize: %d", v);
4556 return -EINVAL;
4557 }
4558 if (sbi->s_want_extra_isize < v)
4559 sbi->s_want_extra_isize = v;
4560 }
4561 }
4562
4563 return 0;
4564 }
4565
4566 #if IS_ENABLED(CONFIG_UNICODE)
ext4_encoding_init(struct super_block * sb,struct ext4_super_block * es)4567 static int ext4_encoding_init(struct super_block *sb, struct ext4_super_block *es)
4568 {
4569 const struct ext4_sb_encodings *encoding_info;
4570 struct unicode_map *encoding;
4571 __u16 encoding_flags = le16_to_cpu(es->s_encoding_flags);
4572
4573 if (!ext4_has_feature_casefold(sb) || sb->s_encoding)
4574 return 0;
4575
4576 encoding_info = ext4_sb_read_encoding(es);
4577 if (!encoding_info) {
4578 ext4_msg(sb, KERN_ERR,
4579 "Encoding requested by superblock is unknown");
4580 return -EINVAL;
4581 }
4582
4583 encoding = utf8_load(encoding_info->version);
4584 if (IS_ERR(encoding)) {
4585 ext4_msg(sb, KERN_ERR,
4586 "can't mount with superblock charset: %s-%u.%u.%u "
4587 "not supported by the kernel. flags: 0x%x.",
4588 encoding_info->name,
4589 unicode_major(encoding_info->version),
4590 unicode_minor(encoding_info->version),
4591 unicode_rev(encoding_info->version),
4592 encoding_flags);
4593 return -EINVAL;
4594 }
4595 ext4_msg(sb, KERN_INFO,"Using encoding defined by superblock: "
4596 "%s-%u.%u.%u with flags 0x%hx", encoding_info->name,
4597 unicode_major(encoding_info->version),
4598 unicode_minor(encoding_info->version),
4599 unicode_rev(encoding_info->version),
4600 encoding_flags);
4601
4602 sb->s_encoding = encoding;
4603 sb->s_encoding_flags = encoding_flags;
4604
4605 return 0;
4606 }
4607 #else
ext4_encoding_init(struct super_block * sb,struct ext4_super_block * es)4608 static inline int ext4_encoding_init(struct super_block *sb, struct ext4_super_block *es)
4609 {
4610 return 0;
4611 }
4612 #endif
4613
ext4_init_metadata_csum(struct super_block * sb,struct ext4_super_block * es)4614 static int ext4_init_metadata_csum(struct super_block *sb, struct ext4_super_block *es)
4615 {
4616 struct ext4_sb_info *sbi = EXT4_SB(sb);
4617
4618 /* Warn if metadata_csum and gdt_csum are both set. */
4619 if (ext4_has_feature_metadata_csum(sb) &&
4620 ext4_has_feature_gdt_csum(sb))
4621 ext4_warning(sb, "metadata_csum and uninit_bg are "
4622 "redundant flags; please run fsck.");
4623
4624 /* Check for a known checksum algorithm */
4625 if (!ext4_verify_csum_type(sb, es)) {
4626 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4627 "unknown checksum algorithm.");
4628 return -EINVAL;
4629 }
4630 ext4_setup_csum_trigger(sb, EXT4_JTR_ORPHAN_FILE,
4631 ext4_orphan_file_block_trigger);
4632
4633 /* Load the checksum driver */
4634 sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
4635 if (IS_ERR(sbi->s_chksum_driver)) {
4636 int ret = PTR_ERR(sbi->s_chksum_driver);
4637 ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
4638 sbi->s_chksum_driver = NULL;
4639 return ret;
4640 }
4641
4642 /* Check superblock checksum */
4643 if (!ext4_superblock_csum_verify(sb, es)) {
4644 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4645 "invalid superblock checksum. Run e2fsck?");
4646 return -EFSBADCRC;
4647 }
4648
4649 /* Precompute checksum seed for all metadata */
4650 if (ext4_has_feature_csum_seed(sb))
4651 sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
4652 else if (ext4_has_metadata_csum(sb) || ext4_has_feature_ea_inode(sb))
4653 sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
4654 sizeof(es->s_uuid));
4655 return 0;
4656 }
4657
ext4_check_feature_compatibility(struct super_block * sb,struct ext4_super_block * es,int silent)4658 static int ext4_check_feature_compatibility(struct super_block *sb,
4659 struct ext4_super_block *es,
4660 int silent)
4661 {
4662 struct ext4_sb_info *sbi = EXT4_SB(sb);
4663
4664 if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
4665 (ext4_has_compat_features(sb) ||
4666 ext4_has_ro_compat_features(sb) ||
4667 ext4_has_incompat_features(sb)))
4668 ext4_msg(sb, KERN_WARNING,
4669 "feature flags set on rev 0 fs, "
4670 "running e2fsck is recommended");
4671
4672 if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
4673 set_opt2(sb, HURD_COMPAT);
4674 if (ext4_has_feature_64bit(sb)) {
4675 ext4_msg(sb, KERN_ERR,
4676 "The Hurd can't support 64-bit file systems");
4677 return -EINVAL;
4678 }
4679
4680 /*
4681 * ea_inode feature uses l_i_version field which is not
4682 * available in HURD_COMPAT mode.
4683 */
4684 if (ext4_has_feature_ea_inode(sb)) {
4685 ext4_msg(sb, KERN_ERR,
4686 "ea_inode feature is not supported for Hurd");
4687 return -EINVAL;
4688 }
4689 }
4690
4691 if (IS_EXT2_SB(sb)) {
4692 if (ext2_feature_set_ok(sb))
4693 ext4_msg(sb, KERN_INFO, "mounting ext2 file system "
4694 "using the ext4 subsystem");
4695 else {
4696 /*
4697 * If we're probing be silent, if this looks like
4698 * it's actually an ext[34] filesystem.
4699 */
4700 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4701 return -EINVAL;
4702 ext4_msg(sb, KERN_ERR, "couldn't mount as ext2 due "
4703 "to feature incompatibilities");
4704 return -EINVAL;
4705 }
4706 }
4707
4708 if (IS_EXT3_SB(sb)) {
4709 if (ext3_feature_set_ok(sb))
4710 ext4_msg(sb, KERN_INFO, "mounting ext3 file system "
4711 "using the ext4 subsystem");
4712 else {
4713 /*
4714 * If we're probing be silent, if this looks like
4715 * it's actually an ext4 filesystem.
4716 */
4717 if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4718 return -EINVAL;
4719 ext4_msg(sb, KERN_ERR, "couldn't mount as ext3 due "
4720 "to feature incompatibilities");
4721 return -EINVAL;
4722 }
4723 }
4724
4725 /*
4726 * Check feature flags regardless of the revision level, since we
4727 * previously didn't change the revision level when setting the flags,
4728 * so there is a chance incompat flags are set on a rev 0 filesystem.
4729 */
4730 if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
4731 return -EINVAL;
4732
4733 if (sbi->s_daxdev) {
4734 if (sb->s_blocksize == PAGE_SIZE)
4735 set_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags);
4736 else
4737 ext4_msg(sb, KERN_ERR, "unsupported blocksize for DAX\n");
4738 }
4739
4740 if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4741 if (ext4_has_feature_inline_data(sb)) {
4742 ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4743 " that may contain inline data");
4744 return -EINVAL;
4745 }
4746 if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4747 ext4_msg(sb, KERN_ERR,
4748 "DAX unsupported by block device.");
4749 return -EINVAL;
4750 }
4751 }
4752
4753 if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
4754 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
4755 es->s_encryption_level);
4756 return -EINVAL;
4757 }
4758
4759 return 0;
4760 }
4761
ext4_check_geometry(struct super_block * sb,struct ext4_super_block * es)4762 static int ext4_check_geometry(struct super_block *sb,
4763 struct ext4_super_block *es)
4764 {
4765 struct ext4_sb_info *sbi = EXT4_SB(sb);
4766 __u64 blocks_count;
4767 int err;
4768
4769 if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (sb->s_blocksize / 4)) {
4770 ext4_msg(sb, KERN_ERR,
4771 "Number of reserved GDT blocks insanely large: %d",
4772 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks));
4773 return -EINVAL;
4774 }
4775 /*
4776 * Test whether we have more sectors than will fit in sector_t,
4777 * and whether the max offset is addressable by the page cache.
4778 */
4779 err = generic_check_addressable(sb->s_blocksize_bits,
4780 ext4_blocks_count(es));
4781 if (err) {
4782 ext4_msg(sb, KERN_ERR, "filesystem"
4783 " too large to mount safely on this system");
4784 return err;
4785 }
4786
4787 /* check blocks count against device size */
4788 blocks_count = sb_bdev_nr_blocks(sb);
4789 if (blocks_count && ext4_blocks_count(es) > blocks_count) {
4790 ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
4791 "exceeds size of device (%llu blocks)",
4792 ext4_blocks_count(es), blocks_count);
4793 return -EINVAL;
4794 }
4795
4796 /*
4797 * It makes no sense for the first data block to be beyond the end
4798 * of the filesystem.
4799 */
4800 if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
4801 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4802 "block %u is beyond end of filesystem (%llu)",
4803 le32_to_cpu(es->s_first_data_block),
4804 ext4_blocks_count(es));
4805 return -EINVAL;
4806 }
4807 if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
4808 (sbi->s_cluster_ratio == 1)) {
4809 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4810 "block is 0 with a 1k block and cluster size");
4811 return -EINVAL;
4812 }
4813
4814 blocks_count = (ext4_blocks_count(es) -
4815 le32_to_cpu(es->s_first_data_block) +
4816 EXT4_BLOCKS_PER_GROUP(sb) - 1);
4817 do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
4818 if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
4819 ext4_msg(sb, KERN_WARNING, "groups count too large: %llu "
4820 "(block count %llu, first data block %u, "
4821 "blocks per group %lu)", blocks_count,
4822 ext4_blocks_count(es),
4823 le32_to_cpu(es->s_first_data_block),
4824 EXT4_BLOCKS_PER_GROUP(sb));
4825 return -EINVAL;
4826 }
4827 sbi->s_groups_count = blocks_count;
4828 sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
4829 (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
4830 if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
4831 le32_to_cpu(es->s_inodes_count)) {
4832 ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
4833 le32_to_cpu(es->s_inodes_count),
4834 ((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
4835 return -EINVAL;
4836 }
4837
4838 return 0;
4839 }
4840
ext4_group_desc_init(struct super_block * sb,struct ext4_super_block * es,ext4_fsblk_t logical_sb_block,ext4_group_t * first_not_zeroed)4841 static int ext4_group_desc_init(struct super_block *sb,
4842 struct ext4_super_block *es,
4843 ext4_fsblk_t logical_sb_block,
4844 ext4_group_t *first_not_zeroed)
4845 {
4846 struct ext4_sb_info *sbi = EXT4_SB(sb);
4847 unsigned int db_count;
4848 ext4_fsblk_t block;
4849 int i;
4850
4851 db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
4852 EXT4_DESC_PER_BLOCK(sb);
4853 if (ext4_has_feature_meta_bg(sb)) {
4854 if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
4855 ext4_msg(sb, KERN_WARNING,
4856 "first meta block group too large: %u "
4857 "(group descriptor block count %u)",
4858 le32_to_cpu(es->s_first_meta_bg), db_count);
4859 return -EINVAL;
4860 }
4861 }
4862 rcu_assign_pointer(sbi->s_group_desc,
4863 kvmalloc_array(db_count,
4864 sizeof(struct buffer_head *),
4865 GFP_KERNEL));
4866 if (sbi->s_group_desc == NULL) {
4867 ext4_msg(sb, KERN_ERR, "not enough memory");
4868 return -ENOMEM;
4869 }
4870
4871 bgl_lock_init(sbi->s_blockgroup_lock);
4872
4873 /* Pre-read the descriptors into the buffer cache */
4874 for (i = 0; i < db_count; i++) {
4875 block = descriptor_loc(sb, logical_sb_block, i);
4876 ext4_sb_breadahead_unmovable(sb, block);
4877 }
4878
4879 for (i = 0; i < db_count; i++) {
4880 struct buffer_head *bh;
4881
4882 block = descriptor_loc(sb, logical_sb_block, i);
4883 bh = ext4_sb_bread_unmovable(sb, block);
4884 if (IS_ERR(bh)) {
4885 ext4_msg(sb, KERN_ERR,
4886 "can't read group descriptor %d", i);
4887 sbi->s_gdb_count = i;
4888 return PTR_ERR(bh);
4889 }
4890 rcu_read_lock();
4891 rcu_dereference(sbi->s_group_desc)[i] = bh;
4892 rcu_read_unlock();
4893 }
4894 sbi->s_gdb_count = db_count;
4895 if (!ext4_check_descriptors(sb, logical_sb_block, first_not_zeroed)) {
4896 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
4897 return -EFSCORRUPTED;
4898 }
4899
4900 return 0;
4901 }
4902
ext4_load_and_init_journal(struct super_block * sb,struct ext4_super_block * es,struct ext4_fs_context * ctx)4903 static int ext4_load_and_init_journal(struct super_block *sb,
4904 struct ext4_super_block *es,
4905 struct ext4_fs_context *ctx)
4906 {
4907 struct ext4_sb_info *sbi = EXT4_SB(sb);
4908 int err;
4909
4910 err = ext4_load_journal(sb, es, ctx->journal_devnum);
4911 if (err)
4912 return err;
4913
4914 if (ext4_has_feature_64bit(sb) &&
4915 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4916 JBD2_FEATURE_INCOMPAT_64BIT)) {
4917 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
4918 goto out;
4919 }
4920
4921 if (!set_journal_csum_feature_set(sb)) {
4922 ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4923 "feature set");
4924 goto out;
4925 }
4926
4927 if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
4928 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4929 JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
4930 ext4_msg(sb, KERN_ERR,
4931 "Failed to set fast commit journal feature");
4932 goto out;
4933 }
4934
4935 /* We have now updated the journal if required, so we can
4936 * validate the data journaling mode. */
4937 switch (test_opt(sb, DATA_FLAGS)) {
4938 case 0:
4939 /* No mode set, assume a default based on the journal
4940 * capabilities: ORDERED_DATA if the journal can
4941 * cope, else JOURNAL_DATA
4942 */
4943 if (jbd2_journal_check_available_features
4944 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4945 set_opt(sb, ORDERED_DATA);
4946 sbi->s_def_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
4947 } else {
4948 set_opt(sb, JOURNAL_DATA);
4949 sbi->s_def_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
4950 }
4951 break;
4952
4953 case EXT4_MOUNT_ORDERED_DATA:
4954 case EXT4_MOUNT_WRITEBACK_DATA:
4955 if (!jbd2_journal_check_available_features
4956 (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4957 ext4_msg(sb, KERN_ERR, "Journal does not support "
4958 "requested data journaling mode");
4959 goto out;
4960 }
4961 break;
4962 default:
4963 break;
4964 }
4965
4966 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA &&
4967 test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4968 ext4_msg(sb, KERN_ERR, "can't mount with "
4969 "journal_async_commit in data=ordered mode");
4970 goto out;
4971 }
4972
4973 set_task_ioprio(sbi->s_journal->j_task, ctx->journal_ioprio);
4974
4975 sbi->s_journal->j_submit_inode_data_buffers =
4976 ext4_journal_submit_inode_data_buffers;
4977 sbi->s_journal->j_finish_inode_data_buffers =
4978 ext4_journal_finish_inode_data_buffers;
4979
4980 return 0;
4981
4982 out:
4983 /* flush s_sb_upd_work before destroying the journal. */
4984 flush_work(&sbi->s_sb_upd_work);
4985 jbd2_journal_destroy(sbi->s_journal);
4986 sbi->s_journal = NULL;
4987 return -EINVAL;
4988 }
4989
ext4_check_journal_data_mode(struct super_block * sb)4990 static int ext4_check_journal_data_mode(struct super_block *sb)
4991 {
4992 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
4993 printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with "
4994 "data=journal disables delayed allocation, "
4995 "dioread_nolock, O_DIRECT and fast_commit support!\n");
4996 /* can't mount with both data=journal and dioread_nolock. */
4997 clear_opt(sb, DIOREAD_NOLOCK);
4998 clear_opt2(sb, JOURNAL_FAST_COMMIT);
4999 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
5000 ext4_msg(sb, KERN_ERR, "can't mount with "
5001 "both data=journal and delalloc");
5002 return -EINVAL;
5003 }
5004 if (test_opt(sb, DAX_ALWAYS)) {
5005 ext4_msg(sb, KERN_ERR, "can't mount with "
5006 "both data=journal and dax");
5007 return -EINVAL;
5008 }
5009 if (ext4_has_feature_encrypt(sb)) {
5010 ext4_msg(sb, KERN_WARNING,
5011 "encrypted files will use data=ordered "
5012 "instead of data journaling mode");
5013 }
5014 if (test_opt(sb, DELALLOC))
5015 clear_opt(sb, DELALLOC);
5016 } else {
5017 sb->s_iflags |= SB_I_CGROUPWB;
5018 }
5019
5020 return 0;
5021 }
5022
ext4_load_super(struct super_block * sb,ext4_fsblk_t * lsb,int silent)5023 static int ext4_load_super(struct super_block *sb, ext4_fsblk_t *lsb,
5024 int silent)
5025 {
5026 struct ext4_sb_info *sbi = EXT4_SB(sb);
5027 struct ext4_super_block *es;
5028 ext4_fsblk_t logical_sb_block;
5029 unsigned long offset = 0;
5030 struct buffer_head *bh;
5031 int ret = -EINVAL;
5032 int blocksize;
5033
5034 blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
5035 if (!blocksize) {
5036 ext4_msg(sb, KERN_ERR, "unable to set blocksize");
5037 return -EINVAL;
5038 }
5039
5040 /*
5041 * The ext4 superblock will not be buffer aligned for other than 1kB
5042 * block sizes. We need to calculate the offset from buffer start.
5043 */
5044 if (blocksize != EXT4_MIN_BLOCK_SIZE) {
5045 logical_sb_block = sbi->s_sb_block * EXT4_MIN_BLOCK_SIZE;
5046 offset = do_div(logical_sb_block, blocksize);
5047 } else {
5048 logical_sb_block = sbi->s_sb_block;
5049 }
5050
5051 bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
5052 if (IS_ERR(bh)) {
5053 ext4_msg(sb, KERN_ERR, "unable to read superblock");
5054 return PTR_ERR(bh);
5055 }
5056 /*
5057 * Note: s_es must be initialized as soon as possible because
5058 * some ext4 macro-instructions depend on its value
5059 */
5060 es = (struct ext4_super_block *) (bh->b_data + offset);
5061 sbi->s_es = es;
5062 sb->s_magic = le16_to_cpu(es->s_magic);
5063 if (sb->s_magic != EXT4_SUPER_MAGIC) {
5064 if (!silent)
5065 ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5066 goto out;
5067 }
5068
5069 if (le32_to_cpu(es->s_log_block_size) >
5070 (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
5071 ext4_msg(sb, KERN_ERR,
5072 "Invalid log block size: %u",
5073 le32_to_cpu(es->s_log_block_size));
5074 goto out;
5075 }
5076 if (le32_to_cpu(es->s_log_cluster_size) >
5077 (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
5078 ext4_msg(sb, KERN_ERR,
5079 "Invalid log cluster size: %u",
5080 le32_to_cpu(es->s_log_cluster_size));
5081 goto out;
5082 }
5083
5084 blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
5085
5086 /*
5087 * If the default block size is not the same as the real block size,
5088 * we need to reload it.
5089 */
5090 if (sb->s_blocksize == blocksize) {
5091 *lsb = logical_sb_block;
5092 sbi->s_sbh = bh;
5093 return 0;
5094 }
5095
5096 /*
5097 * bh must be released before kill_bdev(), otherwise
5098 * it won't be freed and its page also. kill_bdev()
5099 * is called by sb_set_blocksize().
5100 */
5101 brelse(bh);
5102 /* Validate the filesystem blocksize */
5103 if (!sb_set_blocksize(sb, blocksize)) {
5104 ext4_msg(sb, KERN_ERR, "bad block size %d",
5105 blocksize);
5106 bh = NULL;
5107 goto out;
5108 }
5109
5110 logical_sb_block = sbi->s_sb_block * EXT4_MIN_BLOCK_SIZE;
5111 offset = do_div(logical_sb_block, blocksize);
5112 bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
5113 if (IS_ERR(bh)) {
5114 ext4_msg(sb, KERN_ERR, "Can't read superblock on 2nd try");
5115 ret = PTR_ERR(bh);
5116 bh = NULL;
5117 goto out;
5118 }
5119 es = (struct ext4_super_block *)(bh->b_data + offset);
5120 sbi->s_es = es;
5121 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
5122 ext4_msg(sb, KERN_ERR, "Magic mismatch, very weird!");
5123 goto out;
5124 }
5125 *lsb = logical_sb_block;
5126 sbi->s_sbh = bh;
5127 return 0;
5128 out:
5129 brelse(bh);
5130 return ret;
5131 }
5132
ext4_hash_info_init(struct super_block * sb)5133 static void ext4_hash_info_init(struct super_block *sb)
5134 {
5135 struct ext4_sb_info *sbi = EXT4_SB(sb);
5136 struct ext4_super_block *es = sbi->s_es;
5137 unsigned int i;
5138
5139 for (i = 0; i < 4; i++)
5140 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
5141
5142 sbi->s_def_hash_version = es->s_def_hash_version;
5143 if (ext4_has_feature_dir_index(sb)) {
5144 i = le32_to_cpu(es->s_flags);
5145 if (i & EXT2_FLAGS_UNSIGNED_HASH)
5146 sbi->s_hash_unsigned = 3;
5147 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
5148 #ifdef __CHAR_UNSIGNED__
5149 if (!sb_rdonly(sb))
5150 es->s_flags |=
5151 cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
5152 sbi->s_hash_unsigned = 3;
5153 #else
5154 if (!sb_rdonly(sb))
5155 es->s_flags |=
5156 cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
5157 #endif
5158 }
5159 }
5160 }
5161
ext4_block_group_meta_init(struct super_block * sb,int silent)5162 static int ext4_block_group_meta_init(struct super_block *sb, int silent)
5163 {
5164 struct ext4_sb_info *sbi = EXT4_SB(sb);
5165 struct ext4_super_block *es = sbi->s_es;
5166 int has_huge_files;
5167
5168 has_huge_files = ext4_has_feature_huge_file(sb);
5169 sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
5170 has_huge_files);
5171 sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
5172
5173 sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
5174 if (ext4_has_feature_64bit(sb)) {
5175 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
5176 sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
5177 !is_power_of_2(sbi->s_desc_size)) {
5178 ext4_msg(sb, KERN_ERR,
5179 "unsupported descriptor size %lu",
5180 sbi->s_desc_size);
5181 return -EINVAL;
5182 }
5183 } else
5184 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
5185
5186 sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
5187 sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
5188
5189 sbi->s_inodes_per_block = sb->s_blocksize / EXT4_INODE_SIZE(sb);
5190 if (sbi->s_inodes_per_block == 0 || sbi->s_blocks_per_group == 0) {
5191 if (!silent)
5192 ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5193 return -EINVAL;
5194 }
5195 if (sbi->s_inodes_per_group < sbi->s_inodes_per_block ||
5196 sbi->s_inodes_per_group > sb->s_blocksize * 8) {
5197 ext4_msg(sb, KERN_ERR, "invalid inodes per group: %lu\n",
5198 sbi->s_inodes_per_group);
5199 return -EINVAL;
5200 }
5201 sbi->s_itb_per_group = sbi->s_inodes_per_group /
5202 sbi->s_inodes_per_block;
5203 sbi->s_desc_per_block = sb->s_blocksize / EXT4_DESC_SIZE(sb);
5204 sbi->s_mount_state = le16_to_cpu(es->s_state) & ~EXT4_FC_REPLAY;
5205 sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
5206 sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
5207
5208 return 0;
5209 }
5210
__ext4_fill_super(struct fs_context * fc,struct super_block * sb)5211 static int __ext4_fill_super(struct fs_context *fc, struct super_block *sb)
5212 {
5213 struct ext4_super_block *es = NULL;
5214 struct ext4_sb_info *sbi = EXT4_SB(sb);
5215 ext4_fsblk_t logical_sb_block;
5216 struct inode *root;
5217 int needs_recovery;
5218 int err;
5219 ext4_group_t first_not_zeroed;
5220 struct ext4_fs_context *ctx = fc->fs_private;
5221 int silent = fc->sb_flags & SB_SILENT;
5222
5223 /* Set defaults for the variables that will be set during parsing */
5224 if (!(ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO))
5225 ctx->journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
5226
5227 sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
5228 sbi->s_sectors_written_start =
5229 part_stat_read(sb->s_bdev, sectors[STAT_WRITE]);
5230
5231 err = ext4_load_super(sb, &logical_sb_block, silent);
5232 if (err)
5233 goto out_fail;
5234
5235 es = sbi->s_es;
5236 sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
5237
5238 err = ext4_init_metadata_csum(sb, es);
5239 if (err)
5240 goto failed_mount;
5241
5242 ext4_set_def_opts(sb, es);
5243
5244 sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
5245 sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
5246 sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
5247 sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
5248 sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
5249
5250 /*
5251 * set default s_li_wait_mult for lazyinit, for the case there is
5252 * no mount option specified.
5253 */
5254 sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
5255
5256 err = ext4_inode_info_init(sb, es);
5257 if (err)
5258 goto failed_mount;
5259
5260 err = parse_apply_sb_mount_options(sb, ctx);
5261 if (err < 0)
5262 goto failed_mount;
5263
5264 sbi->s_def_mount_opt = sbi->s_mount_opt;
5265 sbi->s_def_mount_opt2 = sbi->s_mount_opt2;
5266
5267 err = ext4_check_opt_consistency(fc, sb);
5268 if (err < 0)
5269 goto failed_mount;
5270
5271 ext4_apply_options(fc, sb);
5272
5273 err = ext4_encoding_init(sb, es);
5274 if (err)
5275 goto failed_mount;
5276
5277 err = ext4_check_journal_data_mode(sb);
5278 if (err)
5279 goto failed_mount;
5280
5281 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5282 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
5283
5284 /* i_version is always enabled now */
5285 sb->s_flags |= SB_I_VERSION;
5286
5287 err = ext4_check_feature_compatibility(sb, es, silent);
5288 if (err)
5289 goto failed_mount;
5290
5291 err = ext4_block_group_meta_init(sb, silent);
5292 if (err)
5293 goto failed_mount;
5294
5295 ext4_hash_info_init(sb);
5296
5297 err = ext4_handle_clustersize(sb);
5298 if (err)
5299 goto failed_mount;
5300
5301 err = ext4_check_geometry(sb, es);
5302 if (err)
5303 goto failed_mount;
5304
5305 timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
5306 spin_lock_init(&sbi->s_error_lock);
5307 INIT_WORK(&sbi->s_sb_upd_work, update_super_work);
5308
5309 err = ext4_group_desc_init(sb, es, logical_sb_block, &first_not_zeroed);
5310 if (err)
5311 goto failed_mount3;
5312
5313 err = ext4_es_register_shrinker(sbi);
5314 if (err)
5315 goto failed_mount3;
5316
5317 sbi->s_stripe = ext4_get_stripe_size(sbi);
5318 /*
5319 * It's hard to get stripe aligned blocks if stripe is not aligned with
5320 * cluster, just disable stripe and alert user to simpfy code and avoid
5321 * stripe aligned allocation which will rarely successes.
5322 */
5323 if (sbi->s_stripe > 0 && sbi->s_cluster_ratio > 1 &&
5324 sbi->s_stripe % sbi->s_cluster_ratio != 0) {
5325 ext4_msg(sb, KERN_WARNING,
5326 "stripe (%lu) is not aligned with cluster size (%u), "
5327 "stripe is disabled",
5328 sbi->s_stripe, sbi->s_cluster_ratio);
5329 sbi->s_stripe = 0;
5330 }
5331 sbi->s_extent_max_zeroout_kb = 32;
5332
5333 /*
5334 * set up enough so that it can read an inode
5335 */
5336 sb->s_op = &ext4_sops;
5337 sb->s_export_op = &ext4_export_ops;
5338 sb->s_xattr = ext4_xattr_handlers;
5339 #ifdef CONFIG_FS_ENCRYPTION
5340 sb->s_cop = &ext4_cryptops;
5341 #endif
5342 #ifdef CONFIG_FS_VERITY
5343 sb->s_vop = &ext4_verityops;
5344 #endif
5345 #ifdef CONFIG_QUOTA
5346 sb->dq_op = &ext4_quota_operations;
5347 if (ext4_has_feature_quota(sb))
5348 sb->s_qcop = &dquot_quotactl_sysfile_ops;
5349 else
5350 sb->s_qcop = &ext4_qctl_operations;
5351 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
5352 #endif
5353 memcpy(&sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
5354
5355 INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
5356 mutex_init(&sbi->s_orphan_lock);
5357
5358 ext4_fast_commit_init(sb);
5359
5360 sb->s_root = NULL;
5361
5362 needs_recovery = (es->s_last_orphan != 0 ||
5363 ext4_has_feature_orphan_present(sb) ||
5364 ext4_has_feature_journal_needs_recovery(sb));
5365
5366 if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb)) {
5367 err = ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block));
5368 if (err)
5369 goto failed_mount3a;
5370 }
5371
5372 err = -EINVAL;
5373 /*
5374 * The first inode we look at is the journal inode. Don't try
5375 * root first: it may be modified in the journal!
5376 */
5377 if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
5378 err = ext4_load_and_init_journal(sb, es, ctx);
5379 if (err)
5380 goto failed_mount3a;
5381 } else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
5382 ext4_has_feature_journal_needs_recovery(sb)) {
5383 ext4_msg(sb, KERN_ERR, "required journal recovery "
5384 "suppressed and not mounted read-only");
5385 goto failed_mount3a;
5386 } else {
5387 /* Nojournal mode, all journal mount options are illegal */
5388 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
5389 ext4_msg(sb, KERN_ERR, "can't mount with "
5390 "journal_async_commit, fs mounted w/o journal");
5391 goto failed_mount3a;
5392 }
5393
5394 if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
5395 ext4_msg(sb, KERN_ERR, "can't mount with "
5396 "journal_checksum, fs mounted w/o journal");
5397 goto failed_mount3a;
5398 }
5399 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
5400 ext4_msg(sb, KERN_ERR, "can't mount with "
5401 "commit=%lu, fs mounted w/o journal",
5402 sbi->s_commit_interval / HZ);
5403 goto failed_mount3a;
5404 }
5405 if (EXT4_MOUNT_DATA_FLAGS &
5406 (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
5407 ext4_msg(sb, KERN_ERR, "can't mount with "
5408 "data=, fs mounted w/o journal");
5409 goto failed_mount3a;
5410 }
5411 sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
5412 clear_opt(sb, JOURNAL_CHECKSUM);
5413 clear_opt(sb, DATA_FLAGS);
5414 clear_opt2(sb, JOURNAL_FAST_COMMIT);
5415 sbi->s_journal = NULL;
5416 needs_recovery = 0;
5417 }
5418
5419 if (!test_opt(sb, NO_MBCACHE)) {
5420 sbi->s_ea_block_cache = ext4_xattr_create_cache();
5421 if (!sbi->s_ea_block_cache) {
5422 ext4_msg(sb, KERN_ERR,
5423 "Failed to create ea_block_cache");
5424 err = -EINVAL;
5425 goto failed_mount_wq;
5426 }
5427
5428 if (ext4_has_feature_ea_inode(sb)) {
5429 sbi->s_ea_inode_cache = ext4_xattr_create_cache();
5430 if (!sbi->s_ea_inode_cache) {
5431 ext4_msg(sb, KERN_ERR,
5432 "Failed to create ea_inode_cache");
5433 err = -EINVAL;
5434 goto failed_mount_wq;
5435 }
5436 }
5437 }
5438
5439 /*
5440 * Get the # of file system overhead blocks from the
5441 * superblock if present.
5442 */
5443 sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
5444 /* ignore the precalculated value if it is ridiculous */
5445 if (sbi->s_overhead > ext4_blocks_count(es))
5446 sbi->s_overhead = 0;
5447 /*
5448 * If the bigalloc feature is not enabled recalculating the
5449 * overhead doesn't take long, so we might as well just redo
5450 * it to make sure we are using the correct value.
5451 */
5452 if (!ext4_has_feature_bigalloc(sb))
5453 sbi->s_overhead = 0;
5454 if (sbi->s_overhead == 0) {
5455 err = ext4_calculate_overhead(sb);
5456 if (err)
5457 goto failed_mount_wq;
5458 }
5459
5460 /*
5461 * The maximum number of concurrent works can be high and
5462 * concurrency isn't really necessary. Limit it to 1.
5463 */
5464 EXT4_SB(sb)->rsv_conversion_wq =
5465 alloc_workqueue("ext4-rsv-conversion", WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
5466 if (!EXT4_SB(sb)->rsv_conversion_wq) {
5467 printk(KERN_ERR "EXT4-fs: failed to create workqueue\n");
5468 err = -ENOMEM;
5469 goto failed_mount4;
5470 }
5471
5472 /*
5473 * The jbd2_journal_load will have done any necessary log recovery,
5474 * so we can safely mount the rest of the filesystem now.
5475 */
5476
5477 root = ext4_iget(sb, EXT4_ROOT_INO, EXT4_IGET_SPECIAL);
5478 if (IS_ERR(root)) {
5479 ext4_msg(sb, KERN_ERR, "get root inode failed");
5480 err = PTR_ERR(root);
5481 root = NULL;
5482 goto failed_mount4;
5483 }
5484 if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
5485 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
5486 iput(root);
5487 err = -EFSCORRUPTED;
5488 goto failed_mount4;
5489 }
5490
5491 sb->s_root = d_make_root(root);
5492 if (!sb->s_root) {
5493 ext4_msg(sb, KERN_ERR, "get root dentry failed");
5494 err = -ENOMEM;
5495 goto failed_mount4;
5496 }
5497
5498 err = ext4_setup_super(sb, es, sb_rdonly(sb));
5499 if (err == -EROFS) {
5500 sb->s_flags |= SB_RDONLY;
5501 } else if (err)
5502 goto failed_mount4a;
5503
5504 ext4_set_resv_clusters(sb);
5505
5506 if (test_opt(sb, BLOCK_VALIDITY)) {
5507 err = ext4_setup_system_zone(sb);
5508 if (err) {
5509 ext4_msg(sb, KERN_ERR, "failed to initialize system "
5510 "zone (%d)", err);
5511 goto failed_mount4a;
5512 }
5513 }
5514 ext4_fc_replay_cleanup(sb);
5515
5516 ext4_ext_init(sb);
5517
5518 /*
5519 * Enable optimize_scan if number of groups is > threshold. This can be
5520 * turned off by passing "mb_optimize_scan=0". This can also be
5521 * turned on forcefully by passing "mb_optimize_scan=1".
5522 */
5523 if (!(ctx->spec & EXT4_SPEC_mb_optimize_scan)) {
5524 if (sbi->s_groups_count >= MB_DEFAULT_LINEAR_SCAN_THRESHOLD)
5525 set_opt2(sb, MB_OPTIMIZE_SCAN);
5526 else
5527 clear_opt2(sb, MB_OPTIMIZE_SCAN);
5528 }
5529
5530 err = ext4_mb_init(sb);
5531 if (err) {
5532 ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
5533 err);
5534 goto failed_mount5;
5535 }
5536
5537 /*
5538 * We can only set up the journal commit callback once
5539 * mballoc is initialized
5540 */
5541 if (sbi->s_journal)
5542 sbi->s_journal->j_commit_callback =
5543 ext4_journal_commit_callback;
5544
5545 err = ext4_percpu_param_init(sbi);
5546 if (err)
5547 goto failed_mount6;
5548
5549 if (ext4_has_feature_flex_bg(sb))
5550 if (!ext4_fill_flex_info(sb)) {
5551 ext4_msg(sb, KERN_ERR,
5552 "unable to initialize "
5553 "flex_bg meta info!");
5554 err = -ENOMEM;
5555 goto failed_mount6;
5556 }
5557
5558 err = ext4_register_li_request(sb, first_not_zeroed);
5559 if (err)
5560 goto failed_mount6;
5561
5562 err = ext4_init_orphan_info(sb);
5563 if (err)
5564 goto failed_mount7;
5565 #ifdef CONFIG_QUOTA
5566 /* Enable quota usage during mount. */
5567 if (ext4_has_feature_quota(sb) && !sb_rdonly(sb)) {
5568 err = ext4_enable_quotas(sb);
5569 if (err)
5570 goto failed_mount8;
5571 }
5572 #endif /* CONFIG_QUOTA */
5573
5574 /*
5575 * Save the original bdev mapping's wb_err value which could be
5576 * used to detect the metadata async write error.
5577 */
5578 spin_lock_init(&sbi->s_bdev_wb_lock);
5579 errseq_check_and_advance(&sb->s_bdev->bd_inode->i_mapping->wb_err,
5580 &sbi->s_bdev_wb_err);
5581 EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
5582 ext4_orphan_cleanup(sb, es);
5583 EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
5584 /*
5585 * Update the checksum after updating free space/inode counters and
5586 * ext4_orphan_cleanup. Otherwise the superblock can have an incorrect
5587 * checksum in the buffer cache until it is written out and
5588 * e2fsprogs programs trying to open a file system immediately
5589 * after it is mounted can fail.
5590 */
5591 ext4_superblock_csum_set(sb);
5592 if (needs_recovery) {
5593 ext4_msg(sb, KERN_INFO, "recovery complete");
5594 err = ext4_mark_recovery_complete(sb, es);
5595 if (err)
5596 goto failed_mount9;
5597 }
5598
5599 if (test_opt(sb, DISCARD) && !bdev_max_discard_sectors(sb->s_bdev))
5600 ext4_msg(sb, KERN_WARNING,
5601 "mounting with \"discard\" option, but the device does not support discard");
5602
5603 if (es->s_error_count)
5604 mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */
5605
5606 /* Enable message ratelimiting. Default is 10 messages per 5 secs. */
5607 ratelimit_state_init(&sbi->s_err_ratelimit_state, 5 * HZ, 10);
5608 ratelimit_state_init(&sbi->s_warning_ratelimit_state, 5 * HZ, 10);
5609 ratelimit_state_init(&sbi->s_msg_ratelimit_state, 5 * HZ, 10);
5610 atomic_set(&sbi->s_warning_count, 0);
5611 atomic_set(&sbi->s_msg_count, 0);
5612
5613 /* Register sysfs after all initializations are complete. */
5614 err = ext4_register_sysfs(sb);
5615 if (err)
5616 goto failed_mount9;
5617
5618 return 0;
5619
5620 failed_mount9:
5621 ext4_quotas_off(sb, EXT4_MAXQUOTAS);
5622 failed_mount8: __maybe_unused
5623 ext4_release_orphan_info(sb);
5624 failed_mount7:
5625 ext4_unregister_li_request(sb);
5626 failed_mount6:
5627 ext4_mb_release(sb);
5628 ext4_flex_groups_free(sbi);
5629 ext4_percpu_param_destroy(sbi);
5630 failed_mount5:
5631 ext4_ext_release(sb);
5632 ext4_release_system_zone(sb);
5633 failed_mount4a:
5634 dput(sb->s_root);
5635 sb->s_root = NULL;
5636 failed_mount4:
5637 ext4_msg(sb, KERN_ERR, "mount failed");
5638 if (EXT4_SB(sb)->rsv_conversion_wq)
5639 destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
5640 failed_mount_wq:
5641 ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
5642 sbi->s_ea_inode_cache = NULL;
5643
5644 ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
5645 sbi->s_ea_block_cache = NULL;
5646
5647 if (sbi->s_journal) {
5648 /* flush s_sb_upd_work before journal destroy. */
5649 flush_work(&sbi->s_sb_upd_work);
5650 jbd2_journal_destroy(sbi->s_journal);
5651 sbi->s_journal = NULL;
5652 }
5653 failed_mount3a:
5654 ext4_es_unregister_shrinker(sbi);
5655 failed_mount3:
5656 /* flush s_sb_upd_work before sbi destroy */
5657 flush_work(&sbi->s_sb_upd_work);
5658 del_timer_sync(&sbi->s_err_report);
5659 ext4_stop_mmpd(sbi);
5660 ext4_group_desc_free(sbi);
5661 failed_mount:
5662 if (sbi->s_chksum_driver)
5663 crypto_free_shash(sbi->s_chksum_driver);
5664
5665 #if IS_ENABLED(CONFIG_UNICODE)
5666 utf8_unload(sb->s_encoding);
5667 #endif
5668
5669 #ifdef CONFIG_QUOTA
5670 for (unsigned int i = 0; i < EXT4_MAXQUOTAS; i++)
5671 kfree(get_qf_name(sb, sbi, i));
5672 #endif
5673 fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
5674 brelse(sbi->s_sbh);
5675 if (sbi->s_journal_bdev) {
5676 invalidate_bdev(sbi->s_journal_bdev);
5677 blkdev_put(sbi->s_journal_bdev, sb);
5678 }
5679 out_fail:
5680 invalidate_bdev(sb->s_bdev);
5681 sb->s_fs_info = NULL;
5682 return err;
5683 }
5684
ext4_fill_super(struct super_block * sb,struct fs_context * fc)5685 static int ext4_fill_super(struct super_block *sb, struct fs_context *fc)
5686 {
5687 struct ext4_fs_context *ctx = fc->fs_private;
5688 struct ext4_sb_info *sbi;
5689 const char *descr;
5690 int ret;
5691
5692 sbi = ext4_alloc_sbi(sb);
5693 if (!sbi)
5694 return -ENOMEM;
5695
5696 fc->s_fs_info = sbi;
5697
5698 /* Cleanup superblock name */
5699 strreplace(sb->s_id, '/', '!');
5700
5701 sbi->s_sb_block = 1; /* Default super block location */
5702 if (ctx->spec & EXT4_SPEC_s_sb_block)
5703 sbi->s_sb_block = ctx->s_sb_block;
5704
5705 ret = __ext4_fill_super(fc, sb);
5706 if (ret < 0)
5707 goto free_sbi;
5708
5709 if (sbi->s_journal) {
5710 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
5711 descr = " journalled data mode";
5712 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
5713 descr = " ordered data mode";
5714 else
5715 descr = " writeback data mode";
5716 } else
5717 descr = "out journal";
5718
5719 if (___ratelimit(&ext4_mount_msg_ratelimit, "EXT4-fs mount"))
5720 ext4_msg(sb, KERN_INFO, "mounted filesystem %pU %s with%s. "
5721 "Quota mode: %s.", &sb->s_uuid,
5722 sb_rdonly(sb) ? "ro" : "r/w", descr,
5723 ext4_quota_mode(sb));
5724
5725 /* Update the s_overhead_clusters if necessary */
5726 ext4_update_overhead(sb, false);
5727 return 0;
5728
5729 free_sbi:
5730 ext4_free_sbi(sbi);
5731 fc->s_fs_info = NULL;
5732 return ret;
5733 }
5734
ext4_get_tree(struct fs_context * fc)5735 static int ext4_get_tree(struct fs_context *fc)
5736 {
5737 return get_tree_bdev(fc, ext4_fill_super);
5738 }
5739
5740 /*
5741 * Setup any per-fs journal parameters now. We'll do this both on
5742 * initial mount, once the journal has been initialised but before we've
5743 * done any recovery; and again on any subsequent remount.
5744 */
ext4_init_journal_params(struct super_block * sb,journal_t * journal)5745 static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
5746 {
5747 struct ext4_sb_info *sbi = EXT4_SB(sb);
5748
5749 journal->j_commit_interval = sbi->s_commit_interval;
5750 journal->j_min_batch_time = sbi->s_min_batch_time;
5751 journal->j_max_batch_time = sbi->s_max_batch_time;
5752 ext4_fc_init(sb, journal);
5753
5754 write_lock(&journal->j_state_lock);
5755 if (test_opt(sb, BARRIER))
5756 journal->j_flags |= JBD2_BARRIER;
5757 else
5758 journal->j_flags &= ~JBD2_BARRIER;
5759 if (test_opt(sb, DATA_ERR_ABORT))
5760 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
5761 else
5762 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
5763 /*
5764 * Always enable journal cycle record option, letting the journal
5765 * records log transactions continuously between each mount.
5766 */
5767 journal->j_flags |= JBD2_CYCLE_RECORD;
5768 write_unlock(&journal->j_state_lock);
5769 }
5770
ext4_get_journal_inode(struct super_block * sb,unsigned int journal_inum)5771 static struct inode *ext4_get_journal_inode(struct super_block *sb,
5772 unsigned int journal_inum)
5773 {
5774 struct inode *journal_inode;
5775
5776 /*
5777 * Test for the existence of a valid inode on disk. Bad things
5778 * happen if we iget() an unused inode, as the subsequent iput()
5779 * will try to delete it.
5780 */
5781 journal_inode = ext4_iget(sb, journal_inum, EXT4_IGET_SPECIAL);
5782 if (IS_ERR(journal_inode)) {
5783 ext4_msg(sb, KERN_ERR, "no journal found");
5784 return ERR_CAST(journal_inode);
5785 }
5786 if (!journal_inode->i_nlink) {
5787 make_bad_inode(journal_inode);
5788 iput(journal_inode);
5789 ext4_msg(sb, KERN_ERR, "journal inode is deleted");
5790 return ERR_PTR(-EFSCORRUPTED);
5791 }
5792 if (!S_ISREG(journal_inode->i_mode) || IS_ENCRYPTED(journal_inode)) {
5793 ext4_msg(sb, KERN_ERR, "invalid journal inode");
5794 iput(journal_inode);
5795 return ERR_PTR(-EFSCORRUPTED);
5796 }
5797
5798 ext4_debug("Journal inode found at %p: %lld bytes\n",
5799 journal_inode, journal_inode->i_size);
5800 return journal_inode;
5801 }
5802
ext4_journal_bmap(journal_t * journal,sector_t * block)5803 static int ext4_journal_bmap(journal_t *journal, sector_t *block)
5804 {
5805 struct ext4_map_blocks map;
5806 int ret;
5807
5808 if (journal->j_inode == NULL)
5809 return 0;
5810
5811 map.m_lblk = *block;
5812 map.m_len = 1;
5813 ret = ext4_map_blocks(NULL, journal->j_inode, &map, 0);
5814 if (ret <= 0) {
5815 ext4_msg(journal->j_inode->i_sb, KERN_CRIT,
5816 "journal bmap failed: block %llu ret %d\n",
5817 *block, ret);
5818 jbd2_journal_abort(journal, ret ? ret : -EIO);
5819 return ret;
5820 }
5821 *block = map.m_pblk;
5822 return 0;
5823 }
5824
ext4_open_inode_journal(struct super_block * sb,unsigned int journal_inum)5825 static journal_t *ext4_open_inode_journal(struct super_block *sb,
5826 unsigned int journal_inum)
5827 {
5828 struct inode *journal_inode;
5829 journal_t *journal;
5830
5831 journal_inode = ext4_get_journal_inode(sb, journal_inum);
5832 if (IS_ERR(journal_inode))
5833 return ERR_CAST(journal_inode);
5834
5835 journal = jbd2_journal_init_inode(journal_inode);
5836 if (IS_ERR(journal)) {
5837 ext4_msg(sb, KERN_ERR, "Could not load journal inode");
5838 iput(journal_inode);
5839 return ERR_CAST(journal);
5840 }
5841 journal->j_private = sb;
5842 journal->j_bmap = ext4_journal_bmap;
5843 ext4_init_journal_params(sb, journal);
5844 return journal;
5845 }
5846
ext4_get_journal_blkdev(struct super_block * sb,dev_t j_dev,ext4_fsblk_t * j_start,ext4_fsblk_t * j_len)5847 static struct block_device *ext4_get_journal_blkdev(struct super_block *sb,
5848 dev_t j_dev, ext4_fsblk_t *j_start,
5849 ext4_fsblk_t *j_len)
5850 {
5851 struct buffer_head *bh;
5852 struct block_device *bdev;
5853 int hblock, blocksize;
5854 ext4_fsblk_t sb_block;
5855 unsigned long offset;
5856 struct ext4_super_block *es;
5857 int errno;
5858
5859 /* see get_tree_bdev why this is needed and safe */
5860 up_write(&sb->s_umount);
5861 bdev = blkdev_get_by_dev(j_dev, BLK_OPEN_READ | BLK_OPEN_WRITE, sb,
5862 &fs_holder_ops);
5863 down_write(&sb->s_umount);
5864 if (IS_ERR(bdev)) {
5865 ext4_msg(sb, KERN_ERR,
5866 "failed to open journal device unknown-block(%u,%u) %ld",
5867 MAJOR(j_dev), MINOR(j_dev), PTR_ERR(bdev));
5868 return ERR_CAST(bdev);
5869 }
5870
5871 blocksize = sb->s_blocksize;
5872 hblock = bdev_logical_block_size(bdev);
5873 if (blocksize < hblock) {
5874 ext4_msg(sb, KERN_ERR,
5875 "blocksize too small for journal device");
5876 errno = -EINVAL;
5877 goto out_bdev;
5878 }
5879
5880 sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
5881 offset = EXT4_MIN_BLOCK_SIZE % blocksize;
5882 set_blocksize(bdev, blocksize);
5883 bh = __bread(bdev, sb_block, blocksize);
5884 if (!bh) {
5885 ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
5886 "external journal");
5887 errno = -EINVAL;
5888 goto out_bdev;
5889 }
5890
5891 es = (struct ext4_super_block *) (bh->b_data + offset);
5892 if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
5893 !(le32_to_cpu(es->s_feature_incompat) &
5894 EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
5895 ext4_msg(sb, KERN_ERR, "external journal has bad superblock");
5896 errno = -EFSCORRUPTED;
5897 goto out_bh;
5898 }
5899
5900 if ((le32_to_cpu(es->s_feature_ro_compat) &
5901 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
5902 es->s_checksum != ext4_superblock_csum(sb, es)) {
5903 ext4_msg(sb, KERN_ERR, "external journal has corrupt superblock");
5904 errno = -EFSCORRUPTED;
5905 goto out_bh;
5906 }
5907
5908 if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
5909 ext4_msg(sb, KERN_ERR, "journal UUID does not match");
5910 errno = -EFSCORRUPTED;
5911 goto out_bh;
5912 }
5913
5914 *j_start = sb_block + 1;
5915 *j_len = ext4_blocks_count(es);
5916 brelse(bh);
5917 return bdev;
5918
5919 out_bh:
5920 brelse(bh);
5921 out_bdev:
5922 blkdev_put(bdev, sb);
5923 return ERR_PTR(errno);
5924 }
5925
ext4_open_dev_journal(struct super_block * sb,dev_t j_dev)5926 static journal_t *ext4_open_dev_journal(struct super_block *sb,
5927 dev_t j_dev)
5928 {
5929 journal_t *journal;
5930 ext4_fsblk_t j_start;
5931 ext4_fsblk_t j_len;
5932 struct block_device *journal_bdev;
5933 int errno = 0;
5934
5935 journal_bdev = ext4_get_journal_blkdev(sb, j_dev, &j_start, &j_len);
5936 if (IS_ERR(journal_bdev))
5937 return ERR_CAST(journal_bdev);
5938
5939 journal = jbd2_journal_init_dev(journal_bdev, sb->s_bdev, j_start,
5940 j_len, sb->s_blocksize);
5941 if (IS_ERR(journal)) {
5942 ext4_msg(sb, KERN_ERR, "failed to create device journal");
5943 errno = PTR_ERR(journal);
5944 goto out_bdev;
5945 }
5946 if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
5947 ext4_msg(sb, KERN_ERR, "External journal has more than one "
5948 "user (unsupported) - %d",
5949 be32_to_cpu(journal->j_superblock->s_nr_users));
5950 errno = -EINVAL;
5951 goto out_journal;
5952 }
5953 journal->j_private = sb;
5954 EXT4_SB(sb)->s_journal_bdev = journal_bdev;
5955 ext4_init_journal_params(sb, journal);
5956 return journal;
5957
5958 out_journal:
5959 jbd2_journal_destroy(journal);
5960 out_bdev:
5961 blkdev_put(journal_bdev, sb);
5962 return ERR_PTR(errno);
5963 }
5964
ext4_load_journal(struct super_block * sb,struct ext4_super_block * es,unsigned long journal_devnum)5965 static int ext4_load_journal(struct super_block *sb,
5966 struct ext4_super_block *es,
5967 unsigned long journal_devnum)
5968 {
5969 journal_t *journal;
5970 unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
5971 dev_t journal_dev;
5972 int err = 0;
5973 int really_read_only;
5974 int journal_dev_ro;
5975
5976 if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5977 return -EFSCORRUPTED;
5978
5979 if (journal_devnum &&
5980 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5981 ext4_msg(sb, KERN_INFO, "external journal device major/minor "
5982 "numbers have changed");
5983 journal_dev = new_decode_dev(journal_devnum);
5984 } else
5985 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
5986
5987 if (journal_inum && journal_dev) {
5988 ext4_msg(sb, KERN_ERR,
5989 "filesystem has both journal inode and journal device!");
5990 return -EINVAL;
5991 }
5992
5993 if (journal_inum) {
5994 journal = ext4_open_inode_journal(sb, journal_inum);
5995 if (IS_ERR(journal))
5996 return PTR_ERR(journal);
5997 } else {
5998 journal = ext4_open_dev_journal(sb, journal_dev);
5999 if (IS_ERR(journal))
6000 return PTR_ERR(journal);
6001 }
6002
6003 journal_dev_ro = bdev_read_only(journal->j_dev);
6004 really_read_only = bdev_read_only(sb->s_bdev) | journal_dev_ro;
6005
6006 if (journal_dev_ro && !sb_rdonly(sb)) {
6007 ext4_msg(sb, KERN_ERR,
6008 "journal device read-only, try mounting with '-o ro'");
6009 err = -EROFS;
6010 goto err_out;
6011 }
6012
6013 /*
6014 * Are we loading a blank journal or performing recovery after a
6015 * crash? For recovery, we need to check in advance whether we
6016 * can get read-write access to the device.
6017 */
6018 if (ext4_has_feature_journal_needs_recovery(sb)) {
6019 if (sb_rdonly(sb)) {
6020 ext4_msg(sb, KERN_INFO, "INFO: recovery "
6021 "required on readonly filesystem");
6022 if (really_read_only) {
6023 ext4_msg(sb, KERN_ERR, "write access "
6024 "unavailable, cannot proceed "
6025 "(try mounting with noload)");
6026 err = -EROFS;
6027 goto err_out;
6028 }
6029 ext4_msg(sb, KERN_INFO, "write access will "
6030 "be enabled during recovery");
6031 }
6032 }
6033
6034 if (!(journal->j_flags & JBD2_BARRIER))
6035 ext4_msg(sb, KERN_INFO, "barriers disabled");
6036
6037 if (!ext4_has_feature_journal_needs_recovery(sb))
6038 err = jbd2_journal_wipe(journal, !really_read_only);
6039 if (!err) {
6040 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
6041 __le16 orig_state;
6042 bool changed = false;
6043
6044 if (save)
6045 memcpy(save, ((char *) es) +
6046 EXT4_S_ERR_START, EXT4_S_ERR_LEN);
6047 err = jbd2_journal_load(journal);
6048 if (save && memcmp(((char *) es) + EXT4_S_ERR_START,
6049 save, EXT4_S_ERR_LEN)) {
6050 memcpy(((char *) es) + EXT4_S_ERR_START,
6051 save, EXT4_S_ERR_LEN);
6052 changed = true;
6053 }
6054 kfree(save);
6055 orig_state = es->s_state;
6056 es->s_state |= cpu_to_le16(EXT4_SB(sb)->s_mount_state &
6057 EXT4_ERROR_FS);
6058 if (orig_state != es->s_state)
6059 changed = true;
6060 /* Write out restored error information to the superblock */
6061 if (changed && !really_read_only) {
6062 int err2;
6063 err2 = ext4_commit_super(sb);
6064 err = err ? : err2;
6065 }
6066 }
6067
6068 if (err) {
6069 ext4_msg(sb, KERN_ERR, "error loading journal");
6070 goto err_out;
6071 }
6072
6073 EXT4_SB(sb)->s_journal = journal;
6074 err = ext4_clear_journal_err(sb, es);
6075 if (err) {
6076 EXT4_SB(sb)->s_journal = NULL;
6077 jbd2_journal_destroy(journal);
6078 return err;
6079 }
6080
6081 if (!really_read_only && journal_devnum &&
6082 journal_devnum != le32_to_cpu(es->s_journal_dev)) {
6083 es->s_journal_dev = cpu_to_le32(journal_devnum);
6084 ext4_commit_super(sb);
6085 }
6086 if (!really_read_only && journal_inum &&
6087 journal_inum != le32_to_cpu(es->s_journal_inum)) {
6088 es->s_journal_inum = cpu_to_le32(journal_inum);
6089 ext4_commit_super(sb);
6090 }
6091
6092 return 0;
6093
6094 err_out:
6095 jbd2_journal_destroy(journal);
6096 return err;
6097 }
6098
6099 /* Copy state of EXT4_SB(sb) into buffer for on-disk superblock */
ext4_update_super(struct super_block * sb)6100 static void ext4_update_super(struct super_block *sb)
6101 {
6102 struct ext4_sb_info *sbi = EXT4_SB(sb);
6103 struct ext4_super_block *es = sbi->s_es;
6104 struct buffer_head *sbh = sbi->s_sbh;
6105
6106 lock_buffer(sbh);
6107 /*
6108 * If the file system is mounted read-only, don't update the
6109 * superblock write time. This avoids updating the superblock
6110 * write time when we are mounting the root file system
6111 * read/only but we need to replay the journal; at that point,
6112 * for people who are east of GMT and who make their clock
6113 * tick in localtime for Windows bug-for-bug compatibility,
6114 * the clock is set in the future, and this will cause e2fsck
6115 * to complain and force a full file system check.
6116 */
6117 if (!sb_rdonly(sb))
6118 ext4_update_tstamp(es, s_wtime);
6119 es->s_kbytes_written =
6120 cpu_to_le64(sbi->s_kbytes_written +
6121 ((part_stat_read(sb->s_bdev, sectors[STAT_WRITE]) -
6122 sbi->s_sectors_written_start) >> 1));
6123 if (percpu_counter_initialized(&sbi->s_freeclusters_counter))
6124 ext4_free_blocks_count_set(es,
6125 EXT4_C2B(sbi, percpu_counter_sum_positive(
6126 &sbi->s_freeclusters_counter)));
6127 if (percpu_counter_initialized(&sbi->s_freeinodes_counter))
6128 es->s_free_inodes_count =
6129 cpu_to_le32(percpu_counter_sum_positive(
6130 &sbi->s_freeinodes_counter));
6131 /* Copy error information to the on-disk superblock */
6132 spin_lock(&sbi->s_error_lock);
6133 if (sbi->s_add_error_count > 0) {
6134 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
6135 if (!es->s_first_error_time && !es->s_first_error_time_hi) {
6136 __ext4_update_tstamp(&es->s_first_error_time,
6137 &es->s_first_error_time_hi,
6138 sbi->s_first_error_time);
6139 strncpy(es->s_first_error_func, sbi->s_first_error_func,
6140 sizeof(es->s_first_error_func));
6141 es->s_first_error_line =
6142 cpu_to_le32(sbi->s_first_error_line);
6143 es->s_first_error_ino =
6144 cpu_to_le32(sbi->s_first_error_ino);
6145 es->s_first_error_block =
6146 cpu_to_le64(sbi->s_first_error_block);
6147 es->s_first_error_errcode =
6148 ext4_errno_to_code(sbi->s_first_error_code);
6149 }
6150 __ext4_update_tstamp(&es->s_last_error_time,
6151 &es->s_last_error_time_hi,
6152 sbi->s_last_error_time);
6153 strncpy(es->s_last_error_func, sbi->s_last_error_func,
6154 sizeof(es->s_last_error_func));
6155 es->s_last_error_line = cpu_to_le32(sbi->s_last_error_line);
6156 es->s_last_error_ino = cpu_to_le32(sbi->s_last_error_ino);
6157 es->s_last_error_block = cpu_to_le64(sbi->s_last_error_block);
6158 es->s_last_error_errcode =
6159 ext4_errno_to_code(sbi->s_last_error_code);
6160 /*
6161 * Start the daily error reporting function if it hasn't been
6162 * started already
6163 */
6164 if (!es->s_error_count)
6165 mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);
6166 le32_add_cpu(&es->s_error_count, sbi->s_add_error_count);
6167 sbi->s_add_error_count = 0;
6168 }
6169 spin_unlock(&sbi->s_error_lock);
6170
6171 ext4_superblock_csum_set(sb);
6172 unlock_buffer(sbh);
6173 }
6174
ext4_commit_super(struct super_block * sb)6175 static int ext4_commit_super(struct super_block *sb)
6176 {
6177 struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
6178
6179 if (!sbh)
6180 return -EINVAL;
6181 if (block_device_ejected(sb))
6182 return -ENODEV;
6183
6184 ext4_update_super(sb);
6185
6186 lock_buffer(sbh);
6187 /* Buffer got discarded which means block device got invalidated */
6188 if (!buffer_mapped(sbh)) {
6189 unlock_buffer(sbh);
6190 return -EIO;
6191 }
6192
6193 if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
6194 /*
6195 * Oh, dear. A previous attempt to write the
6196 * superblock failed. This could happen because the
6197 * USB device was yanked out. Or it could happen to
6198 * be a transient write error and maybe the block will
6199 * be remapped. Nothing we can do but to retry the
6200 * write and hope for the best.
6201 */
6202 ext4_msg(sb, KERN_ERR, "previous I/O error to "
6203 "superblock detected");
6204 clear_buffer_write_io_error(sbh);
6205 set_buffer_uptodate(sbh);
6206 }
6207 get_bh(sbh);
6208 /* Clear potential dirty bit if it was journalled update */
6209 clear_buffer_dirty(sbh);
6210 sbh->b_end_io = end_buffer_write_sync;
6211 submit_bh(REQ_OP_WRITE | REQ_SYNC |
6212 (test_opt(sb, BARRIER) ? REQ_FUA : 0), sbh);
6213 wait_on_buffer(sbh);
6214 if (buffer_write_io_error(sbh)) {
6215 ext4_msg(sb, KERN_ERR, "I/O error while writing "
6216 "superblock");
6217 clear_buffer_write_io_error(sbh);
6218 set_buffer_uptodate(sbh);
6219 return -EIO;
6220 }
6221 return 0;
6222 }
6223
6224 /*
6225 * Have we just finished recovery? If so, and if we are mounting (or
6226 * remounting) the filesystem readonly, then we will end up with a
6227 * consistent fs on disk. Record that fact.
6228 */
ext4_mark_recovery_complete(struct super_block * sb,struct ext4_super_block * es)6229 static int ext4_mark_recovery_complete(struct super_block *sb,
6230 struct ext4_super_block *es)
6231 {
6232 int err;
6233 journal_t *journal = EXT4_SB(sb)->s_journal;
6234
6235 if (!ext4_has_feature_journal(sb)) {
6236 if (journal != NULL) {
6237 ext4_error(sb, "Journal got removed while the fs was "
6238 "mounted!");
6239 return -EFSCORRUPTED;
6240 }
6241 return 0;
6242 }
6243 jbd2_journal_lock_updates(journal);
6244 err = jbd2_journal_flush(journal, 0);
6245 if (err < 0)
6246 goto out;
6247
6248 if (sb_rdonly(sb) && (ext4_has_feature_journal_needs_recovery(sb) ||
6249 ext4_has_feature_orphan_present(sb))) {
6250 if (!ext4_orphan_file_empty(sb)) {
6251 ext4_error(sb, "Orphan file not empty on read-only fs.");
6252 err = -EFSCORRUPTED;
6253 goto out;
6254 }
6255 ext4_clear_feature_journal_needs_recovery(sb);
6256 ext4_clear_feature_orphan_present(sb);
6257 ext4_commit_super(sb);
6258 }
6259 out:
6260 jbd2_journal_unlock_updates(journal);
6261 return err;
6262 }
6263
6264 /*
6265 * If we are mounting (or read-write remounting) a filesystem whose journal
6266 * has recorded an error from a previous lifetime, move that error to the
6267 * main filesystem now.
6268 */
ext4_clear_journal_err(struct super_block * sb,struct ext4_super_block * es)6269 static int ext4_clear_journal_err(struct super_block *sb,
6270 struct ext4_super_block *es)
6271 {
6272 journal_t *journal;
6273 int j_errno;
6274 const char *errstr;
6275
6276 if (!ext4_has_feature_journal(sb)) {
6277 ext4_error(sb, "Journal got removed while the fs was mounted!");
6278 return -EFSCORRUPTED;
6279 }
6280
6281 journal = EXT4_SB(sb)->s_journal;
6282
6283 /*
6284 * Now check for any error status which may have been recorded in the
6285 * journal by a prior ext4_error() or ext4_abort()
6286 */
6287
6288 j_errno = jbd2_journal_errno(journal);
6289 if (j_errno) {
6290 char nbuf[16];
6291
6292 errstr = ext4_decode_error(sb, j_errno, nbuf);
6293 ext4_warning(sb, "Filesystem error recorded "
6294 "from previous mount: %s", errstr);
6295
6296 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
6297 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
6298 j_errno = ext4_commit_super(sb);
6299 if (j_errno)
6300 return j_errno;
6301 ext4_warning(sb, "Marked fs in need of filesystem check.");
6302
6303 jbd2_journal_clear_err(journal);
6304 jbd2_journal_update_sb_errno(journal);
6305 }
6306 return 0;
6307 }
6308
6309 /*
6310 * Force the running and committing transactions to commit,
6311 * and wait on the commit.
6312 */
ext4_force_commit(struct super_block * sb)6313 int ext4_force_commit(struct super_block *sb)
6314 {
6315 return ext4_journal_force_commit(EXT4_SB(sb)->s_journal);
6316 }
6317
ext4_sync_fs(struct super_block * sb,int wait)6318 static int ext4_sync_fs(struct super_block *sb, int wait)
6319 {
6320 int ret = 0;
6321 tid_t target;
6322 bool needs_barrier = false;
6323 struct ext4_sb_info *sbi = EXT4_SB(sb);
6324
6325 if (unlikely(ext4_forced_shutdown(sb)))
6326 return 0;
6327
6328 trace_ext4_sync_fs(sb, wait);
6329 flush_workqueue(sbi->rsv_conversion_wq);
6330 /*
6331 * Writeback quota in non-journalled quota case - journalled quota has
6332 * no dirty dquots
6333 */
6334 dquot_writeback_dquots(sb, -1);
6335 /*
6336 * Data writeback is possible w/o journal transaction, so barrier must
6337 * being sent at the end of the function. But we can skip it if
6338 * transaction_commit will do it for us.
6339 */
6340 if (sbi->s_journal) {
6341 target = jbd2_get_latest_transaction(sbi->s_journal);
6342 if (wait && sbi->s_journal->j_flags & JBD2_BARRIER &&
6343 !jbd2_trans_will_send_data_barrier(sbi->s_journal, target))
6344 needs_barrier = true;
6345
6346 if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
6347 if (wait)
6348 ret = jbd2_log_wait_commit(sbi->s_journal,
6349 target);
6350 }
6351 } else if (wait && test_opt(sb, BARRIER))
6352 needs_barrier = true;
6353 if (needs_barrier) {
6354 int err;
6355 err = blkdev_issue_flush(sb->s_bdev);
6356 if (!ret)
6357 ret = err;
6358 }
6359
6360 return ret;
6361 }
6362
6363 /*
6364 * LVM calls this function before a (read-only) snapshot is created. This
6365 * gives us a chance to flush the journal completely and mark the fs clean.
6366 *
6367 * Note that only this function cannot bring a filesystem to be in a clean
6368 * state independently. It relies on upper layer to stop all data & metadata
6369 * modifications.
6370 */
ext4_freeze(struct super_block * sb)6371 static int ext4_freeze(struct super_block *sb)
6372 {
6373 int error = 0;
6374 journal_t *journal = EXT4_SB(sb)->s_journal;
6375
6376 if (journal) {
6377 /* Now we set up the journal barrier. */
6378 jbd2_journal_lock_updates(journal);
6379
6380 /*
6381 * Don't clear the needs_recovery flag if we failed to
6382 * flush the journal.
6383 */
6384 error = jbd2_journal_flush(journal, 0);
6385 if (error < 0)
6386 goto out;
6387
6388 /* Journal blocked and flushed, clear needs_recovery flag. */
6389 ext4_clear_feature_journal_needs_recovery(sb);
6390 if (ext4_orphan_file_empty(sb))
6391 ext4_clear_feature_orphan_present(sb);
6392 }
6393
6394 error = ext4_commit_super(sb);
6395 out:
6396 if (journal)
6397 /* we rely on upper layer to stop further updates */
6398 jbd2_journal_unlock_updates(journal);
6399 return error;
6400 }
6401
6402 /*
6403 * Called by LVM after the snapshot is done. We need to reset the RECOVER
6404 * flag here, even though the filesystem is not technically dirty yet.
6405 */
ext4_unfreeze(struct super_block * sb)6406 static int ext4_unfreeze(struct super_block *sb)
6407 {
6408 if (ext4_forced_shutdown(sb))
6409 return 0;
6410
6411 if (EXT4_SB(sb)->s_journal) {
6412 /* Reset the needs_recovery flag before the fs is unlocked. */
6413 ext4_set_feature_journal_needs_recovery(sb);
6414 if (ext4_has_feature_orphan_file(sb))
6415 ext4_set_feature_orphan_present(sb);
6416 }
6417
6418 ext4_commit_super(sb);
6419 return 0;
6420 }
6421
6422 /*
6423 * Structure to save mount options for ext4_remount's benefit
6424 */
6425 struct ext4_mount_options {
6426 unsigned long s_mount_opt;
6427 unsigned long s_mount_opt2;
6428 kuid_t s_resuid;
6429 kgid_t s_resgid;
6430 unsigned long s_commit_interval;
6431 u32 s_min_batch_time, s_max_batch_time;
6432 #ifdef CONFIG_QUOTA
6433 int s_jquota_fmt;
6434 char *s_qf_names[EXT4_MAXQUOTAS];
6435 #endif
6436 };
6437
__ext4_remount(struct fs_context * fc,struct super_block * sb)6438 static int __ext4_remount(struct fs_context *fc, struct super_block *sb)
6439 {
6440 struct ext4_fs_context *ctx = fc->fs_private;
6441 struct ext4_super_block *es;
6442 struct ext4_sb_info *sbi = EXT4_SB(sb);
6443 unsigned long old_sb_flags;
6444 struct ext4_mount_options old_opts;
6445 ext4_group_t g;
6446 int err = 0;
6447 int alloc_ctx;
6448 #ifdef CONFIG_QUOTA
6449 int enable_quota = 0;
6450 int i, j;
6451 char *to_free[EXT4_MAXQUOTAS];
6452 #endif
6453
6454
6455 /* Store the original options */
6456 old_sb_flags = sb->s_flags;
6457 old_opts.s_mount_opt = sbi->s_mount_opt;
6458 old_opts.s_mount_opt2 = sbi->s_mount_opt2;
6459 old_opts.s_resuid = sbi->s_resuid;
6460 old_opts.s_resgid = sbi->s_resgid;
6461 old_opts.s_commit_interval = sbi->s_commit_interval;
6462 old_opts.s_min_batch_time = sbi->s_min_batch_time;
6463 old_opts.s_max_batch_time = sbi->s_max_batch_time;
6464 #ifdef CONFIG_QUOTA
6465 old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
6466 for (i = 0; i < EXT4_MAXQUOTAS; i++)
6467 if (sbi->s_qf_names[i]) {
6468 char *qf_name = get_qf_name(sb, sbi, i);
6469
6470 old_opts.s_qf_names[i] = kstrdup(qf_name, GFP_KERNEL);
6471 if (!old_opts.s_qf_names[i]) {
6472 for (j = 0; j < i; j++)
6473 kfree(old_opts.s_qf_names[j]);
6474 return -ENOMEM;
6475 }
6476 } else
6477 old_opts.s_qf_names[i] = NULL;
6478 #endif
6479 if (!(ctx->spec & EXT4_SPEC_JOURNAL_IOPRIO)) {
6480 if (sbi->s_journal && sbi->s_journal->j_task->io_context)
6481 ctx->journal_ioprio =
6482 sbi->s_journal->j_task->io_context->ioprio;
6483 else
6484 ctx->journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
6485
6486 }
6487
6488 /*
6489 * Changing the DIOREAD_NOLOCK or DELALLOC mount options may cause
6490 * two calls to ext4_should_dioread_nolock() to return inconsistent
6491 * values, triggering WARN_ON in ext4_add_complete_io(). we grab
6492 * here s_writepages_rwsem to avoid race between writepages ops and
6493 * remount.
6494 */
6495 alloc_ctx = ext4_writepages_down_write(sb);
6496 ext4_apply_options(fc, sb);
6497 ext4_writepages_up_write(sb, alloc_ctx);
6498
6499 if ((old_opts.s_mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) ^
6500 test_opt(sb, JOURNAL_CHECKSUM)) {
6501 ext4_msg(sb, KERN_ERR, "changing journal_checksum "
6502 "during remount not supported; ignoring");
6503 sbi->s_mount_opt ^= EXT4_MOUNT_JOURNAL_CHECKSUM;
6504 }
6505
6506 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
6507 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
6508 ext4_msg(sb, KERN_ERR, "can't mount with "
6509 "both data=journal and delalloc");
6510 err = -EINVAL;
6511 goto restore_opts;
6512 }
6513 if (test_opt(sb, DIOREAD_NOLOCK)) {
6514 ext4_msg(sb, KERN_ERR, "can't mount with "
6515 "both data=journal and dioread_nolock");
6516 err = -EINVAL;
6517 goto restore_opts;
6518 }
6519 } else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) {
6520 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
6521 ext4_msg(sb, KERN_ERR, "can't mount with "
6522 "journal_async_commit in data=ordered mode");
6523 err = -EINVAL;
6524 goto restore_opts;
6525 }
6526 }
6527
6528 if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT4_MOUNT_NO_MBCACHE) {
6529 ext4_msg(sb, KERN_ERR, "can't enable nombcache during remount");
6530 err = -EINVAL;
6531 goto restore_opts;
6532 }
6533
6534 if (test_opt2(sb, ABORT))
6535 ext4_abort(sb, ESHUTDOWN, "Abort forced by user");
6536
6537 sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
6538 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
6539
6540 es = sbi->s_es;
6541
6542 if (sbi->s_journal) {
6543 ext4_init_journal_params(sb, sbi->s_journal);
6544 set_task_ioprio(sbi->s_journal->j_task, ctx->journal_ioprio);
6545 }
6546
6547 /* Flush outstanding errors before changing fs state */
6548 flush_work(&sbi->s_sb_upd_work);
6549
6550 if ((bool)(fc->sb_flags & SB_RDONLY) != sb_rdonly(sb)) {
6551 if (ext4_forced_shutdown(sb)) {
6552 err = -EROFS;
6553 goto restore_opts;
6554 }
6555
6556 if (fc->sb_flags & SB_RDONLY) {
6557 err = sync_filesystem(sb);
6558 if (err < 0)
6559 goto restore_opts;
6560 err = dquot_suspend(sb, -1);
6561 if (err < 0)
6562 goto restore_opts;
6563
6564 /*
6565 * First of all, the unconditional stuff we have to do
6566 * to disable replay of the journal when we next remount
6567 */
6568 sb->s_flags |= SB_RDONLY;
6569
6570 /*
6571 * OK, test if we are remounting a valid rw partition
6572 * readonly, and if so set the rdonly flag and then
6573 * mark the partition as valid again.
6574 */
6575 if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
6576 (sbi->s_mount_state & EXT4_VALID_FS))
6577 es->s_state = cpu_to_le16(sbi->s_mount_state);
6578
6579 if (sbi->s_journal) {
6580 /*
6581 * We let remount-ro finish even if marking fs
6582 * as clean failed...
6583 */
6584 ext4_mark_recovery_complete(sb, es);
6585 }
6586 } else {
6587 /* Make sure we can mount this feature set readwrite */
6588 if (ext4_has_feature_readonly(sb) ||
6589 !ext4_feature_set_ok(sb, 0)) {
6590 err = -EROFS;
6591 goto restore_opts;
6592 }
6593 /*
6594 * Make sure the group descriptor checksums
6595 * are sane. If they aren't, refuse to remount r/w.
6596 */
6597 for (g = 0; g < sbi->s_groups_count; g++) {
6598 struct ext4_group_desc *gdp =
6599 ext4_get_group_desc(sb, g, NULL);
6600
6601 if (!ext4_group_desc_csum_verify(sb, g, gdp)) {
6602 ext4_msg(sb, KERN_ERR,
6603 "ext4_remount: Checksum for group %u failed (%u!=%u)",
6604 g, le16_to_cpu(ext4_group_desc_csum(sb, g, gdp)),
6605 le16_to_cpu(gdp->bg_checksum));
6606 err = -EFSBADCRC;
6607 goto restore_opts;
6608 }
6609 }
6610
6611 /*
6612 * If we have an unprocessed orphan list hanging
6613 * around from a previously readonly bdev mount,
6614 * require a full umount/remount for now.
6615 */
6616 if (es->s_last_orphan || !ext4_orphan_file_empty(sb)) {
6617 ext4_msg(sb, KERN_WARNING, "Couldn't "
6618 "remount RDWR because of unprocessed "
6619 "orphan inode list. Please "
6620 "umount/remount instead");
6621 err = -EINVAL;
6622 goto restore_opts;
6623 }
6624
6625 /*
6626 * Mounting a RDONLY partition read-write, so reread
6627 * and store the current valid flag. (It may have
6628 * been changed by e2fsck since we originally mounted
6629 * the partition.)
6630 */
6631 if (sbi->s_journal) {
6632 err = ext4_clear_journal_err(sb, es);
6633 if (err)
6634 goto restore_opts;
6635 }
6636 sbi->s_mount_state = (le16_to_cpu(es->s_state) &
6637 ~EXT4_FC_REPLAY);
6638
6639 err = ext4_setup_super(sb, es, 0);
6640 if (err)
6641 goto restore_opts;
6642
6643 sb->s_flags &= ~SB_RDONLY;
6644 if (ext4_has_feature_mmp(sb)) {
6645 err = ext4_multi_mount_protect(sb,
6646 le64_to_cpu(es->s_mmp_block));
6647 if (err)
6648 goto restore_opts;
6649 }
6650 #ifdef CONFIG_QUOTA
6651 enable_quota = 1;
6652 #endif
6653 }
6654 }
6655
6656 /*
6657 * Handle creation of system zone data early because it can fail.
6658 * Releasing of existing data is done when we are sure remount will
6659 * succeed.
6660 */
6661 if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
6662 err = ext4_setup_system_zone(sb);
6663 if (err)
6664 goto restore_opts;
6665 }
6666
6667 if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
6668 err = ext4_commit_super(sb);
6669 if (err)
6670 goto restore_opts;
6671 }
6672
6673 #ifdef CONFIG_QUOTA
6674 if (enable_quota) {
6675 if (sb_any_quota_suspended(sb))
6676 dquot_resume(sb, -1);
6677 else if (ext4_has_feature_quota(sb)) {
6678 err = ext4_enable_quotas(sb);
6679 if (err)
6680 goto restore_opts;
6681 }
6682 }
6683 /* Release old quota file names */
6684 for (i = 0; i < EXT4_MAXQUOTAS; i++)
6685 kfree(old_opts.s_qf_names[i]);
6686 #endif
6687 if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6688 ext4_release_system_zone(sb);
6689
6690 /*
6691 * Reinitialize lazy itable initialization thread based on
6692 * current settings
6693 */
6694 if (sb_rdonly(sb) || !test_opt(sb, INIT_INODE_TABLE))
6695 ext4_unregister_li_request(sb);
6696 else {
6697 ext4_group_t first_not_zeroed;
6698 first_not_zeroed = ext4_has_uninit_itable(sb);
6699 ext4_register_li_request(sb, first_not_zeroed);
6700 }
6701
6702 if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
6703 ext4_stop_mmpd(sbi);
6704
6705 return 0;
6706
6707 restore_opts:
6708 /*
6709 * If there was a failing r/w to ro transition, we may need to
6710 * re-enable quota
6711 */
6712 if (sb_rdonly(sb) && !(old_sb_flags & SB_RDONLY) &&
6713 sb_any_quota_suspended(sb))
6714 dquot_resume(sb, -1);
6715
6716 alloc_ctx = ext4_writepages_down_write(sb);
6717 sb->s_flags = old_sb_flags;
6718 sbi->s_mount_opt = old_opts.s_mount_opt;
6719 sbi->s_mount_opt2 = old_opts.s_mount_opt2;
6720 sbi->s_resuid = old_opts.s_resuid;
6721 sbi->s_resgid = old_opts.s_resgid;
6722 sbi->s_commit_interval = old_opts.s_commit_interval;
6723 sbi->s_min_batch_time = old_opts.s_min_batch_time;
6724 sbi->s_max_batch_time = old_opts.s_max_batch_time;
6725 ext4_writepages_up_write(sb, alloc_ctx);
6726
6727 if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6728 ext4_release_system_zone(sb);
6729 #ifdef CONFIG_QUOTA
6730 sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
6731 for (i = 0; i < EXT4_MAXQUOTAS; i++) {
6732 to_free[i] = get_qf_name(sb, sbi, i);
6733 rcu_assign_pointer(sbi->s_qf_names[i], old_opts.s_qf_names[i]);
6734 }
6735 synchronize_rcu();
6736 for (i = 0; i < EXT4_MAXQUOTAS; i++)
6737 kfree(to_free[i]);
6738 #endif
6739 if (!ext4_has_feature_mmp(sb) || sb_rdonly(sb))
6740 ext4_stop_mmpd(sbi);
6741 return err;
6742 }
6743
ext4_reconfigure(struct fs_context * fc)6744 static int ext4_reconfigure(struct fs_context *fc)
6745 {
6746 struct super_block *sb = fc->root->d_sb;
6747 int ret;
6748
6749 fc->s_fs_info = EXT4_SB(sb);
6750
6751 ret = ext4_check_opt_consistency(fc, sb);
6752 if (ret < 0)
6753 return ret;
6754
6755 ret = __ext4_remount(fc, sb);
6756 if (ret < 0)
6757 return ret;
6758
6759 ext4_msg(sb, KERN_INFO, "re-mounted %pU %s. Quota mode: %s.",
6760 &sb->s_uuid, sb_rdonly(sb) ? "ro" : "r/w",
6761 ext4_quota_mode(sb));
6762
6763 return 0;
6764 }
6765
6766 #ifdef CONFIG_QUOTA
ext4_statfs_project(struct super_block * sb,kprojid_t projid,struct kstatfs * buf)6767 static int ext4_statfs_project(struct super_block *sb,
6768 kprojid_t projid, struct kstatfs *buf)
6769 {
6770 struct kqid qid;
6771 struct dquot *dquot;
6772 u64 limit;
6773 u64 curblock;
6774
6775 qid = make_kqid_projid(projid);
6776 dquot = dqget(sb, qid);
6777 if (IS_ERR(dquot))
6778 return PTR_ERR(dquot);
6779 spin_lock(&dquot->dq_dqb_lock);
6780
6781 limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
6782 dquot->dq_dqb.dqb_bhardlimit);
6783 limit >>= sb->s_blocksize_bits;
6784
6785 if (limit && buf->f_blocks > limit) {
6786 curblock = (dquot->dq_dqb.dqb_curspace +
6787 dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
6788 buf->f_blocks = limit;
6789 buf->f_bfree = buf->f_bavail =
6790 (buf->f_blocks > curblock) ?
6791 (buf->f_blocks - curblock) : 0;
6792 }
6793
6794 limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
6795 dquot->dq_dqb.dqb_ihardlimit);
6796 if (limit && buf->f_files > limit) {
6797 buf->f_files = limit;
6798 buf->f_ffree =
6799 (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
6800 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
6801 }
6802
6803 spin_unlock(&dquot->dq_dqb_lock);
6804 dqput(dquot);
6805 return 0;
6806 }
6807 #endif
6808
ext4_statfs(struct dentry * dentry,struct kstatfs * buf)6809 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
6810 {
6811 struct super_block *sb = dentry->d_sb;
6812 struct ext4_sb_info *sbi = EXT4_SB(sb);
6813 struct ext4_super_block *es = sbi->s_es;
6814 ext4_fsblk_t overhead = 0, resv_blocks;
6815 s64 bfree;
6816 resv_blocks = EXT4_C2B(sbi, atomic64_read(&sbi->s_resv_clusters));
6817
6818 if (!test_opt(sb, MINIX_DF))
6819 overhead = sbi->s_overhead;
6820
6821 buf->f_type = EXT4_SUPER_MAGIC;
6822 buf->f_bsize = sb->s_blocksize;
6823 buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, overhead);
6824 bfree = percpu_counter_sum_positive(&sbi->s_freeclusters_counter) -
6825 percpu_counter_sum_positive(&sbi->s_dirtyclusters_counter);
6826 /* prevent underflow in case that few free space is available */
6827 buf->f_bfree = EXT4_C2B(sbi, max_t(s64, bfree, 0));
6828 buf->f_bavail = buf->f_bfree -
6829 (ext4_r_blocks_count(es) + resv_blocks);
6830 if (buf->f_bfree < (ext4_r_blocks_count(es) + resv_blocks))
6831 buf->f_bavail = 0;
6832 buf->f_files = le32_to_cpu(es->s_inodes_count);
6833 buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
6834 buf->f_namelen = EXT4_NAME_LEN;
6835 buf->f_fsid = uuid_to_fsid(es->s_uuid);
6836
6837 #ifdef CONFIG_QUOTA
6838 if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
6839 sb_has_quota_limits_enabled(sb, PRJQUOTA))
6840 ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);
6841 #endif
6842 return 0;
6843 }
6844
6845
6846 #ifdef CONFIG_QUOTA
6847
6848 /*
6849 * Helper functions so that transaction is started before we acquire dqio_sem
6850 * to keep correct lock ordering of transaction > dqio_sem
6851 */
dquot_to_inode(struct dquot * dquot)6852 static inline struct inode *dquot_to_inode(struct dquot *dquot)
6853 {
6854 return sb_dqopt(dquot->dq_sb)->files[dquot->dq_id.type];
6855 }
6856
ext4_write_dquot(struct dquot * dquot)6857 static int ext4_write_dquot(struct dquot *dquot)
6858 {
6859 int ret, err;
6860 handle_t *handle;
6861 struct inode *inode;
6862
6863 inode = dquot_to_inode(dquot);
6864 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
6865 EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
6866 if (IS_ERR(handle))
6867 return PTR_ERR(handle);
6868 ret = dquot_commit(dquot);
6869 if (ret < 0)
6870 ext4_error_err(dquot->dq_sb, -ret,
6871 "Failed to commit dquot type %d",
6872 dquot->dq_id.type);
6873 err = ext4_journal_stop(handle);
6874 if (!ret)
6875 ret = err;
6876 return ret;
6877 }
6878
ext4_acquire_dquot(struct dquot * dquot)6879 static int ext4_acquire_dquot(struct dquot *dquot)
6880 {
6881 int ret, err;
6882 handle_t *handle;
6883
6884 handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6885 EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
6886 if (IS_ERR(handle))
6887 return PTR_ERR(handle);
6888 ret = dquot_acquire(dquot);
6889 if (ret < 0)
6890 ext4_error_err(dquot->dq_sb, -ret,
6891 "Failed to acquire dquot type %d",
6892 dquot->dq_id.type);
6893 err = ext4_journal_stop(handle);
6894 if (!ret)
6895 ret = err;
6896 return ret;
6897 }
6898
ext4_release_dquot(struct dquot * dquot)6899 static int ext4_release_dquot(struct dquot *dquot)
6900 {
6901 int ret, err;
6902 handle_t *handle;
6903
6904 handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6905 EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
6906 if (IS_ERR(handle)) {
6907 /* Release dquot anyway to avoid endless cycle in dqput() */
6908 dquot_release(dquot);
6909 return PTR_ERR(handle);
6910 }
6911 ret = dquot_release(dquot);
6912 if (ret < 0)
6913 ext4_error_err(dquot->dq_sb, -ret,
6914 "Failed to release dquot type %d",
6915 dquot->dq_id.type);
6916 err = ext4_journal_stop(handle);
6917 if (!ret)
6918 ret = err;
6919 return ret;
6920 }
6921
ext4_mark_dquot_dirty(struct dquot * dquot)6922 static int ext4_mark_dquot_dirty(struct dquot *dquot)
6923 {
6924 struct super_block *sb = dquot->dq_sb;
6925
6926 if (ext4_is_quota_journalled(sb)) {
6927 dquot_mark_dquot_dirty(dquot);
6928 return ext4_write_dquot(dquot);
6929 } else {
6930 return dquot_mark_dquot_dirty(dquot);
6931 }
6932 }
6933
ext4_write_info(struct super_block * sb,int type)6934 static int ext4_write_info(struct super_block *sb, int type)
6935 {
6936 int ret, err;
6937 handle_t *handle;
6938
6939 /* Data block + inode block */
6940 handle = ext4_journal_start_sb(sb, EXT4_HT_QUOTA, 2);
6941 if (IS_ERR(handle))
6942 return PTR_ERR(handle);
6943 ret = dquot_commit_info(sb, type);
6944 err = ext4_journal_stop(handle);
6945 if (!ret)
6946 ret = err;
6947 return ret;
6948 }
6949
lockdep_set_quota_inode(struct inode * inode,int subclass)6950 static void lockdep_set_quota_inode(struct inode *inode, int subclass)
6951 {
6952 struct ext4_inode_info *ei = EXT4_I(inode);
6953
6954 /* The first argument of lockdep_set_subclass has to be
6955 * *exactly* the same as the argument to init_rwsem() --- in
6956 * this case, in init_once() --- or lockdep gets unhappy
6957 * because the name of the lock is set using the
6958 * stringification of the argument to init_rwsem().
6959 */
6960 (void) ei; /* shut up clang warning if !CONFIG_LOCKDEP */
6961 lockdep_set_subclass(&ei->i_data_sem, subclass);
6962 }
6963
6964 /*
6965 * Standard function to be called on quota_on
6966 */
ext4_quota_on(struct super_block * sb,int type,int format_id,const struct path * path)6967 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
6968 const struct path *path)
6969 {
6970 int err;
6971
6972 if (!test_opt(sb, QUOTA))
6973 return -EINVAL;
6974
6975 /* Quotafile not on the same filesystem? */
6976 if (path->dentry->d_sb != sb)
6977 return -EXDEV;
6978
6979 /* Quota already enabled for this file? */
6980 if (IS_NOQUOTA(d_inode(path->dentry)))
6981 return -EBUSY;
6982
6983 /* Journaling quota? */
6984 if (EXT4_SB(sb)->s_qf_names[type]) {
6985 /* Quotafile not in fs root? */
6986 if (path->dentry->d_parent != sb->s_root)
6987 ext4_msg(sb, KERN_WARNING,
6988 "Quota file not on filesystem root. "
6989 "Journaled quota will not work");
6990 sb_dqopt(sb)->flags |= DQUOT_NOLIST_DIRTY;
6991 } else {
6992 /*
6993 * Clear the flag just in case mount options changed since
6994 * last time.
6995 */
6996 sb_dqopt(sb)->flags &= ~DQUOT_NOLIST_DIRTY;
6997 }
6998
6999 lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA);
7000 err = dquot_quota_on(sb, type, format_id, path);
7001 if (!err) {
7002 struct inode *inode = d_inode(path->dentry);
7003 handle_t *handle;
7004
7005 /*
7006 * Set inode flags to prevent userspace from messing with quota
7007 * files. If this fails, we return success anyway since quotas
7008 * are already enabled and this is not a hard failure.
7009 */
7010 inode_lock(inode);
7011 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
7012 if (IS_ERR(handle))
7013 goto unlock_inode;
7014 EXT4_I(inode)->i_flags |= EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL;
7015 inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
7016 S_NOATIME | S_IMMUTABLE);
7017 err = ext4_mark_inode_dirty(handle, inode);
7018 ext4_journal_stop(handle);
7019 unlock_inode:
7020 inode_unlock(inode);
7021 if (err)
7022 dquot_quota_off(sb, type);
7023 }
7024 if (err)
7025 lockdep_set_quota_inode(path->dentry->d_inode,
7026 I_DATA_SEM_NORMAL);
7027 return err;
7028 }
7029
ext4_check_quota_inum(int type,unsigned long qf_inum)7030 static inline bool ext4_check_quota_inum(int type, unsigned long qf_inum)
7031 {
7032 switch (type) {
7033 case USRQUOTA:
7034 return qf_inum == EXT4_USR_QUOTA_INO;
7035 case GRPQUOTA:
7036 return qf_inum == EXT4_GRP_QUOTA_INO;
7037 case PRJQUOTA:
7038 return qf_inum >= EXT4_GOOD_OLD_FIRST_INO;
7039 default:
7040 BUG();
7041 }
7042 }
7043
ext4_quota_enable(struct super_block * sb,int type,int format_id,unsigned int flags)7044 static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
7045 unsigned int flags)
7046 {
7047 int err;
7048 struct inode *qf_inode;
7049 unsigned long qf_inums[EXT4_MAXQUOTAS] = {
7050 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
7051 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
7052 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
7053 };
7054
7055 BUG_ON(!ext4_has_feature_quota(sb));
7056
7057 if (!qf_inums[type])
7058 return -EPERM;
7059
7060 if (!ext4_check_quota_inum(type, qf_inums[type])) {
7061 ext4_error(sb, "Bad quota inum: %lu, type: %d",
7062 qf_inums[type], type);
7063 return -EUCLEAN;
7064 }
7065
7066 qf_inode = ext4_iget(sb, qf_inums[type], EXT4_IGET_SPECIAL);
7067 if (IS_ERR(qf_inode)) {
7068 ext4_error(sb, "Bad quota inode: %lu, type: %d",
7069 qf_inums[type], type);
7070 return PTR_ERR(qf_inode);
7071 }
7072
7073 /* Don't account quota for quota files to avoid recursion */
7074 qf_inode->i_flags |= S_NOQUOTA;
7075 lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA);
7076 err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
7077 if (err)
7078 lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL);
7079 iput(qf_inode);
7080
7081 return err;
7082 }
7083
7084 /* Enable usage tracking for all quota types. */
ext4_enable_quotas(struct super_block * sb)7085 int ext4_enable_quotas(struct super_block *sb)
7086 {
7087 int type, err = 0;
7088 unsigned long qf_inums[EXT4_MAXQUOTAS] = {
7089 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
7090 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
7091 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
7092 };
7093 bool quota_mopt[EXT4_MAXQUOTAS] = {
7094 test_opt(sb, USRQUOTA),
7095 test_opt(sb, GRPQUOTA),
7096 test_opt(sb, PRJQUOTA),
7097 };
7098
7099 sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;
7100 for (type = 0; type < EXT4_MAXQUOTAS; type++) {
7101 if (qf_inums[type]) {
7102 err = ext4_quota_enable(sb, type, QFMT_VFS_V1,
7103 DQUOT_USAGE_ENABLED |
7104 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
7105 if (err) {
7106 ext4_warning(sb,
7107 "Failed to enable quota tracking "
7108 "(type=%d, err=%d, ino=%lu). "
7109 "Please run e2fsck to fix.", type,
7110 err, qf_inums[type]);
7111
7112 ext4_quotas_off(sb, type);
7113 return err;
7114 }
7115 }
7116 }
7117 return 0;
7118 }
7119
ext4_quota_off(struct super_block * sb,int type)7120 static int ext4_quota_off(struct super_block *sb, int type)
7121 {
7122 struct inode *inode = sb_dqopt(sb)->files[type];
7123 handle_t *handle;
7124 int err;
7125
7126 /* Force all delayed allocation blocks to be allocated.
7127 * Caller already holds s_umount sem */
7128 if (test_opt(sb, DELALLOC))
7129 sync_filesystem(sb);
7130
7131 if (!inode || !igrab(inode))
7132 goto out;
7133
7134 err = dquot_quota_off(sb, type);
7135 if (err || ext4_has_feature_quota(sb))
7136 goto out_put;
7137 /*
7138 * When the filesystem was remounted read-only first, we cannot cleanup
7139 * inode flags here. Bad luck but people should be using QUOTA feature
7140 * these days anyway.
7141 */
7142 if (sb_rdonly(sb))
7143 goto out_put;
7144
7145 inode_lock(inode);
7146 /*
7147 * Update modification times of quota files when userspace can
7148 * start looking at them. If we fail, we return success anyway since
7149 * this is not a hard failure and quotas are already disabled.
7150 */
7151 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
7152 if (IS_ERR(handle)) {
7153 err = PTR_ERR(handle);
7154 goto out_unlock;
7155 }
7156 EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
7157 inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
7158 inode->i_mtime = inode_set_ctime_current(inode);
7159 err = ext4_mark_inode_dirty(handle, inode);
7160 ext4_journal_stop(handle);
7161 out_unlock:
7162 inode_unlock(inode);
7163 out_put:
7164 lockdep_set_quota_inode(inode, I_DATA_SEM_NORMAL);
7165 iput(inode);
7166 return err;
7167 out:
7168 return dquot_quota_off(sb, type);
7169 }
7170
7171 /* Read data from quotafile - avoid pagecache and such because we cannot afford
7172 * acquiring the locks... As quota files are never truncated and quota code
7173 * itself serializes the operations (and no one else should touch the files)
7174 * we don't have to be afraid of races */
ext4_quota_read(struct super_block * sb,int type,char * data,size_t len,loff_t off)7175 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
7176 size_t len, loff_t off)
7177 {
7178 struct inode *inode = sb_dqopt(sb)->files[type];
7179 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
7180 int offset = off & (sb->s_blocksize - 1);
7181 int tocopy;
7182 size_t toread;
7183 struct buffer_head *bh;
7184 loff_t i_size = i_size_read(inode);
7185
7186 if (off > i_size)
7187 return 0;
7188 if (off+len > i_size)
7189 len = i_size-off;
7190 toread = len;
7191 while (toread > 0) {
7192 tocopy = min_t(unsigned long, sb->s_blocksize - offset, toread);
7193 bh = ext4_bread(NULL, inode, blk, 0);
7194 if (IS_ERR(bh))
7195 return PTR_ERR(bh);
7196 if (!bh) /* A hole? */
7197 memset(data, 0, tocopy);
7198 else
7199 memcpy(data, bh->b_data+offset, tocopy);
7200 brelse(bh);
7201 offset = 0;
7202 toread -= tocopy;
7203 data += tocopy;
7204 blk++;
7205 }
7206 return len;
7207 }
7208
7209 /* Write to quotafile (we know the transaction is already started and has
7210 * enough credits) */
ext4_quota_write(struct super_block * sb,int type,const char * data,size_t len,loff_t off)7211 static ssize_t ext4_quota_write(struct super_block *sb, int type,
7212 const char *data, size_t len, loff_t off)
7213 {
7214 struct inode *inode = sb_dqopt(sb)->files[type];
7215 ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
7216 int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
7217 int retries = 0;
7218 struct buffer_head *bh;
7219 handle_t *handle = journal_current_handle();
7220
7221 if (!handle) {
7222 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
7223 " cancelled because transaction is not started",
7224 (unsigned long long)off, (unsigned long long)len);
7225 return -EIO;
7226 }
7227 /*
7228 * Since we account only one data block in transaction credits,
7229 * then it is impossible to cross a block boundary.
7230 */
7231 if (sb->s_blocksize - offset < len) {
7232 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
7233 " cancelled because not block aligned",
7234 (unsigned long long)off, (unsigned long long)len);
7235 return -EIO;
7236 }
7237
7238 do {
7239 bh = ext4_bread(handle, inode, blk,
7240 EXT4_GET_BLOCKS_CREATE |
7241 EXT4_GET_BLOCKS_METADATA_NOFAIL);
7242 } while (PTR_ERR(bh) == -ENOSPC &&
7243 ext4_should_retry_alloc(inode->i_sb, &retries));
7244 if (IS_ERR(bh))
7245 return PTR_ERR(bh);
7246 if (!bh)
7247 goto out;
7248 BUFFER_TRACE(bh, "get write access");
7249 err = ext4_journal_get_write_access(handle, sb, bh, EXT4_JTR_NONE);
7250 if (err) {
7251 brelse(bh);
7252 return err;
7253 }
7254 lock_buffer(bh);
7255 memcpy(bh->b_data+offset, data, len);
7256 flush_dcache_page(bh->b_page);
7257 unlock_buffer(bh);
7258 err = ext4_handle_dirty_metadata(handle, NULL, bh);
7259 brelse(bh);
7260 out:
7261 if (inode->i_size < off + len) {
7262 i_size_write(inode, off + len);
7263 EXT4_I(inode)->i_disksize = inode->i_size;
7264 err2 = ext4_mark_inode_dirty(handle, inode);
7265 if (unlikely(err2 && !err))
7266 err = err2;
7267 }
7268 return err ? err : len;
7269 }
7270 #endif
7271
7272 #if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
register_as_ext2(void)7273 static inline void register_as_ext2(void)
7274 {
7275 int err = register_filesystem(&ext2_fs_type);
7276 if (err)
7277 printk(KERN_WARNING
7278 "EXT4-fs: Unable to register as ext2 (%d)\n", err);
7279 }
7280
unregister_as_ext2(void)7281 static inline void unregister_as_ext2(void)
7282 {
7283 unregister_filesystem(&ext2_fs_type);
7284 }
7285
ext2_feature_set_ok(struct super_block * sb)7286 static inline int ext2_feature_set_ok(struct super_block *sb)
7287 {
7288 if (ext4_has_unknown_ext2_incompat_features(sb))
7289 return 0;
7290 if (sb_rdonly(sb))
7291 return 1;
7292 if (ext4_has_unknown_ext2_ro_compat_features(sb))
7293 return 0;
7294 return 1;
7295 }
7296 #else
register_as_ext2(void)7297 static inline void register_as_ext2(void) { }
unregister_as_ext2(void)7298 static inline void unregister_as_ext2(void) { }
ext2_feature_set_ok(struct super_block * sb)7299 static inline int ext2_feature_set_ok(struct super_block *sb) { return 0; }
7300 #endif
7301
register_as_ext3(void)7302 static inline void register_as_ext3(void)
7303 {
7304 int err = register_filesystem(&ext3_fs_type);
7305 if (err)
7306 printk(KERN_WARNING
7307 "EXT4-fs: Unable to register as ext3 (%d)\n", err);
7308 }
7309
unregister_as_ext3(void)7310 static inline void unregister_as_ext3(void)
7311 {
7312 unregister_filesystem(&ext3_fs_type);
7313 }
7314
ext3_feature_set_ok(struct super_block * sb)7315 static inline int ext3_feature_set_ok(struct super_block *sb)
7316 {
7317 if (ext4_has_unknown_ext3_incompat_features(sb))
7318 return 0;
7319 if (!ext4_has_feature_journal(sb))
7320 return 0;
7321 if (sb_rdonly(sb))
7322 return 1;
7323 if (ext4_has_unknown_ext3_ro_compat_features(sb))
7324 return 0;
7325 return 1;
7326 }
7327
ext4_kill_sb(struct super_block * sb)7328 static void ext4_kill_sb(struct super_block *sb)
7329 {
7330 struct ext4_sb_info *sbi = EXT4_SB(sb);
7331 struct block_device *journal_bdev = sbi ? sbi->s_journal_bdev : NULL;
7332
7333 kill_block_super(sb);
7334
7335 if (journal_bdev)
7336 blkdev_put(journal_bdev, sb);
7337 }
7338
7339 static struct file_system_type ext4_fs_type = {
7340 .owner = THIS_MODULE,
7341 .name = "ext4",
7342 .init_fs_context = ext4_init_fs_context,
7343 .parameters = ext4_param_specs,
7344 .kill_sb = ext4_kill_sb,
7345 .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP,
7346 };
7347 MODULE_ALIAS_FS("ext4");
7348
7349 /* Shared across all ext4 file systems */
7350 wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
7351
ext4_init_fs(void)7352 static int __init ext4_init_fs(void)
7353 {
7354 int i, err;
7355
7356 ratelimit_state_init(&ext4_mount_msg_ratelimit, 30 * HZ, 64);
7357 ext4_li_info = NULL;
7358
7359 /* Build-time check for flags consistency */
7360 ext4_check_flag_values();
7361
7362 for (i = 0; i < EXT4_WQ_HASH_SZ; i++)
7363 init_waitqueue_head(&ext4__ioend_wq[i]);
7364
7365 err = ext4_init_es();
7366 if (err)
7367 return err;
7368
7369 err = ext4_init_pending();
7370 if (err)
7371 goto out7;
7372
7373 err = ext4_init_post_read_processing();
7374 if (err)
7375 goto out6;
7376
7377 err = ext4_init_pageio();
7378 if (err)
7379 goto out5;
7380
7381 err = ext4_init_system_zone();
7382 if (err)
7383 goto out4;
7384
7385 err = ext4_init_sysfs();
7386 if (err)
7387 goto out3;
7388
7389 err = ext4_init_mballoc();
7390 if (err)
7391 goto out2;
7392 err = init_inodecache();
7393 if (err)
7394 goto out1;
7395
7396 err = ext4_fc_init_dentry_cache();
7397 if (err)
7398 goto out05;
7399
7400 register_as_ext3();
7401 register_as_ext2();
7402 err = register_filesystem(&ext4_fs_type);
7403 if (err)
7404 goto out;
7405
7406 return 0;
7407 out:
7408 unregister_as_ext2();
7409 unregister_as_ext3();
7410 ext4_fc_destroy_dentry_cache();
7411 out05:
7412 destroy_inodecache();
7413 out1:
7414 ext4_exit_mballoc();
7415 out2:
7416 ext4_exit_sysfs();
7417 out3:
7418 ext4_exit_system_zone();
7419 out4:
7420 ext4_exit_pageio();
7421 out5:
7422 ext4_exit_post_read_processing();
7423 out6:
7424 ext4_exit_pending();
7425 out7:
7426 ext4_exit_es();
7427
7428 return err;
7429 }
7430
ext4_exit_fs(void)7431 static void __exit ext4_exit_fs(void)
7432 {
7433 ext4_destroy_lazyinit_thread();
7434 unregister_as_ext2();
7435 unregister_as_ext3();
7436 unregister_filesystem(&ext4_fs_type);
7437 ext4_fc_destroy_dentry_cache();
7438 destroy_inodecache();
7439 ext4_exit_mballoc();
7440 ext4_exit_sysfs();
7441 ext4_exit_system_zone();
7442 ext4_exit_pageio();
7443 ext4_exit_post_read_processing();
7444 ext4_exit_es();
7445 ext4_exit_pending();
7446 }
7447
7448 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
7449 MODULE_DESCRIPTION("Fourth Extended Filesystem");
7450 MODULE_LICENSE("GPL");
7451 MODULE_IMPORT_NS(ANDROID_GKI_VFS_EXPORT_ONLY);
7452 MODULE_SOFTDEP("pre: crc32c");
7453 module_init(ext4_init_fs)
7454 module_exit(ext4_exit_fs)
7455