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