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