• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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