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