xref: /openbmc/linux/fs/ext4/super.c (revision a1e58bbd)
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/jbd2.h>
24 #include <linux/ext4_fs.h>
25 #include <linux/ext4_jbd2.h>
26 #include <linux/slab.h>
27 #include <linux/init.h>
28 #include <linux/blkdev.h>
29 #include <linux/parser.h>
30 #include <linux/smp_lock.h>
31 #include <linux/buffer_head.h>
32 #include <linux/exportfs.h>
33 #include <linux/vfs.h>
34 #include <linux/random.h>
35 #include <linux/mount.h>
36 #include <linux/namei.h>
37 #include <linux/quotaops.h>
38 #include <linux/seq_file.h>
39 #include <linux/log2.h>
40 #include <linux/crc16.h>
41 
42 #include <asm/uaccess.h>
43 
44 #include "xattr.h"
45 #include "acl.h"
46 #include "namei.h"
47 #include "group.h"
48 
49 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
50 			     unsigned long journal_devnum);
51 static int ext4_create_journal(struct super_block *, struct ext4_super_block *,
52 			       unsigned int);
53 static void ext4_commit_super (struct super_block * sb,
54 			       struct ext4_super_block * es,
55 			       int sync);
56 static void ext4_mark_recovery_complete(struct super_block * sb,
57 					struct ext4_super_block * es);
58 static void ext4_clear_journal_err(struct super_block * sb,
59 				   struct ext4_super_block * es);
60 static int ext4_sync_fs(struct super_block *sb, int wait);
61 static const char *ext4_decode_error(struct super_block * sb, int errno,
62 				     char nbuf[16]);
63 static int ext4_remount (struct super_block * sb, int * flags, char * data);
64 static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf);
65 static void ext4_unlockfs(struct super_block *sb);
66 static void ext4_write_super (struct super_block * sb);
67 static void ext4_write_super_lockfs(struct super_block *sb);
68 
69 
70 ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
71 			       struct ext4_group_desc *bg)
72 {
73 	return le32_to_cpu(bg->bg_block_bitmap_lo) |
74 		(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
75 		(ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
76 }
77 
78 ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
79 			       struct ext4_group_desc *bg)
80 {
81 	return le32_to_cpu(bg->bg_inode_bitmap_lo) |
82 		(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
83 		(ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
84 }
85 
86 ext4_fsblk_t ext4_inode_table(struct super_block *sb,
87 			      struct ext4_group_desc *bg)
88 {
89 	return le32_to_cpu(bg->bg_inode_table_lo) |
90 		(EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
91 		(ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
92 }
93 
94 void ext4_block_bitmap_set(struct super_block *sb,
95 			   struct ext4_group_desc *bg, ext4_fsblk_t blk)
96 {
97 	bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
98 	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
99 		bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
100 }
101 
102 void ext4_inode_bitmap_set(struct super_block *sb,
103 			   struct ext4_group_desc *bg, ext4_fsblk_t blk)
104 {
105 	bg->bg_inode_bitmap_lo  = cpu_to_le32((u32)blk);
106 	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
107 		bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
108 }
109 
110 void ext4_inode_table_set(struct super_block *sb,
111 			  struct ext4_group_desc *bg, ext4_fsblk_t blk)
112 {
113 	bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
114 	if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
115 		bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
116 }
117 
118 /*
119  * Wrappers for jbd2_journal_start/end.
120  *
121  * The only special thing we need to do here is to make sure that all
122  * journal_end calls result in the superblock being marked dirty, so
123  * that sync() will call the filesystem's write_super callback if
124  * appropriate.
125  */
126 handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
127 {
128 	journal_t *journal;
129 
130 	if (sb->s_flags & MS_RDONLY)
131 		return ERR_PTR(-EROFS);
132 
133 	/* Special case here: if the journal has aborted behind our
134 	 * backs (eg. EIO in the commit thread), then we still need to
135 	 * take the FS itself readonly cleanly. */
136 	journal = EXT4_SB(sb)->s_journal;
137 	if (is_journal_aborted(journal)) {
138 		ext4_abort(sb, __FUNCTION__,
139 			   "Detected aborted journal");
140 		return ERR_PTR(-EROFS);
141 	}
142 
143 	return jbd2_journal_start(journal, nblocks);
144 }
145 
146 /*
147  * The only special thing we need to do here is to make sure that all
148  * jbd2_journal_stop calls result in the superblock being marked dirty, so
149  * that sync() will call the filesystem's write_super callback if
150  * appropriate.
151  */
152 int __ext4_journal_stop(const char *where, handle_t *handle)
153 {
154 	struct super_block *sb;
155 	int err;
156 	int rc;
157 
158 	sb = handle->h_transaction->t_journal->j_private;
159 	err = handle->h_err;
160 	rc = jbd2_journal_stop(handle);
161 
162 	if (!err)
163 		err = rc;
164 	if (err)
165 		__ext4_std_error(sb, where, err);
166 	return err;
167 }
168 
169 void ext4_journal_abort_handle(const char *caller, const char *err_fn,
170 		struct buffer_head *bh, handle_t *handle, int err)
171 {
172 	char nbuf[16];
173 	const char *errstr = ext4_decode_error(NULL, err, nbuf);
174 
175 	if (bh)
176 		BUFFER_TRACE(bh, "abort");
177 
178 	if (!handle->h_err)
179 		handle->h_err = err;
180 
181 	if (is_handle_aborted(handle))
182 		return;
183 
184 	printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
185 	       caller, errstr, err_fn);
186 
187 	jbd2_journal_abort_handle(handle);
188 }
189 
190 /* Deal with the reporting of failure conditions on a filesystem such as
191  * inconsistencies detected or read IO failures.
192  *
193  * On ext2, we can store the error state of the filesystem in the
194  * superblock.  That is not possible on ext4, because we may have other
195  * write ordering constraints on the superblock which prevent us from
196  * writing it out straight away; and given that the journal is about to
197  * be aborted, we can't rely on the current, or future, transactions to
198  * write out the superblock safely.
199  *
200  * We'll just use the jbd2_journal_abort() error code to record an error in
201  * the journal instead.  On recovery, the journal will compain about
202  * that error until we've noted it down and cleared it.
203  */
204 
205 static void ext4_handle_error(struct super_block *sb)
206 {
207 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
208 
209 	EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
210 	es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
211 
212 	if (sb->s_flags & MS_RDONLY)
213 		return;
214 
215 	if (!test_opt (sb, ERRORS_CONT)) {
216 		journal_t *journal = EXT4_SB(sb)->s_journal;
217 
218 		EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
219 		if (journal)
220 			jbd2_journal_abort(journal, -EIO);
221 	}
222 	if (test_opt (sb, ERRORS_RO)) {
223 		printk (KERN_CRIT "Remounting filesystem read-only\n");
224 		sb->s_flags |= MS_RDONLY;
225 	}
226 	ext4_commit_super(sb, es, 1);
227 	if (test_opt(sb, ERRORS_PANIC))
228 		panic("EXT4-fs (device %s): panic forced after error\n",
229 			sb->s_id);
230 }
231 
232 void ext4_error (struct super_block * sb, const char * function,
233 		 const char * fmt, ...)
234 {
235 	va_list args;
236 
237 	va_start(args, fmt);
238 	printk(KERN_CRIT "EXT4-fs error (device %s): %s: ",sb->s_id, function);
239 	vprintk(fmt, args);
240 	printk("\n");
241 	va_end(args);
242 
243 	ext4_handle_error(sb);
244 }
245 
246 static const char *ext4_decode_error(struct super_block * sb, int errno,
247 				     char nbuf[16])
248 {
249 	char *errstr = NULL;
250 
251 	switch (errno) {
252 	case -EIO:
253 		errstr = "IO failure";
254 		break;
255 	case -ENOMEM:
256 		errstr = "Out of memory";
257 		break;
258 	case -EROFS:
259 		if (!sb || EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT)
260 			errstr = "Journal has aborted";
261 		else
262 			errstr = "Readonly filesystem";
263 		break;
264 	default:
265 		/* If the caller passed in an extra buffer for unknown
266 		 * errors, textualise them now.  Else we just return
267 		 * NULL. */
268 		if (nbuf) {
269 			/* Check for truncated error codes... */
270 			if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
271 				errstr = nbuf;
272 		}
273 		break;
274 	}
275 
276 	return errstr;
277 }
278 
279 /* __ext4_std_error decodes expected errors from journaling functions
280  * automatically and invokes the appropriate error response.  */
281 
282 void __ext4_std_error (struct super_block * sb, const char * function,
283 		       int errno)
284 {
285 	char nbuf[16];
286 	const char *errstr;
287 
288 	/* Special case: if the error is EROFS, and we're not already
289 	 * inside a transaction, then there's really no point in logging
290 	 * an error. */
291 	if (errno == -EROFS && journal_current_handle() == NULL &&
292 	    (sb->s_flags & MS_RDONLY))
293 		return;
294 
295 	errstr = ext4_decode_error(sb, errno, nbuf);
296 	printk (KERN_CRIT "EXT4-fs error (device %s) in %s: %s\n",
297 		sb->s_id, function, errstr);
298 
299 	ext4_handle_error(sb);
300 }
301 
302 /*
303  * ext4_abort is a much stronger failure handler than ext4_error.  The
304  * abort function may be used to deal with unrecoverable failures such
305  * as journal IO errors or ENOMEM at a critical moment in log management.
306  *
307  * We unconditionally force the filesystem into an ABORT|READONLY state,
308  * unless the error response on the fs has been set to panic in which
309  * case we take the easy way out and panic immediately.
310  */
311 
312 void ext4_abort (struct super_block * sb, const char * function,
313 		 const char * fmt, ...)
314 {
315 	va_list args;
316 
317 	printk (KERN_CRIT "ext4_abort called.\n");
318 
319 	va_start(args, fmt);
320 	printk(KERN_CRIT "EXT4-fs error (device %s): %s: ",sb->s_id, function);
321 	vprintk(fmt, args);
322 	printk("\n");
323 	va_end(args);
324 
325 	if (test_opt(sb, ERRORS_PANIC))
326 		panic("EXT4-fs panic from previous error\n");
327 
328 	if (sb->s_flags & MS_RDONLY)
329 		return;
330 
331 	printk(KERN_CRIT "Remounting filesystem read-only\n");
332 	EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
333 	sb->s_flags |= MS_RDONLY;
334 	EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
335 	jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
336 }
337 
338 void ext4_warning (struct super_block * sb, const char * function,
339 		   const char * fmt, ...)
340 {
341 	va_list args;
342 
343 	va_start(args, fmt);
344 	printk(KERN_WARNING "EXT4-fs warning (device %s): %s: ",
345 	       sb->s_id, function);
346 	vprintk(fmt, args);
347 	printk("\n");
348 	va_end(args);
349 }
350 
351 void ext4_update_dynamic_rev(struct super_block *sb)
352 {
353 	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
354 
355 	if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
356 		return;
357 
358 	ext4_warning(sb, __FUNCTION__,
359 		     "updating to rev %d because of new feature flag, "
360 		     "running e2fsck is recommended",
361 		     EXT4_DYNAMIC_REV);
362 
363 	es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
364 	es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
365 	es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
366 	/* leave es->s_feature_*compat flags alone */
367 	/* es->s_uuid will be set by e2fsck if empty */
368 
369 	/*
370 	 * The rest of the superblock fields should be zero, and if not it
371 	 * means they are likely already in use, so leave them alone.  We
372 	 * can leave it up to e2fsck to clean up any inconsistencies there.
373 	 */
374 }
375 
376 int ext4_update_compat_feature(handle_t *handle,
377 					struct super_block *sb, __u32 compat)
378 {
379 	int err = 0;
380 	if (!EXT4_HAS_COMPAT_FEATURE(sb, compat)) {
381 		err = ext4_journal_get_write_access(handle,
382 				EXT4_SB(sb)->s_sbh);
383 		if (err)
384 			return err;
385 		EXT4_SET_COMPAT_FEATURE(sb, compat);
386 		sb->s_dirt = 1;
387 		handle->h_sync = 1;
388 		BUFFER_TRACE(EXT4_SB(sb)->s_sbh,
389 					"call ext4_journal_dirty_met adata");
390 		err = ext4_journal_dirty_metadata(handle,
391 				EXT4_SB(sb)->s_sbh);
392 	}
393 	return err;
394 }
395 
396 int ext4_update_rocompat_feature(handle_t *handle,
397 					struct super_block *sb, __u32 rocompat)
398 {
399 	int err = 0;
400 	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, rocompat)) {
401 		err = ext4_journal_get_write_access(handle,
402 				EXT4_SB(sb)->s_sbh);
403 		if (err)
404 			return err;
405 		EXT4_SET_RO_COMPAT_FEATURE(sb, rocompat);
406 		sb->s_dirt = 1;
407 		handle->h_sync = 1;
408 		BUFFER_TRACE(EXT4_SB(sb)->s_sbh,
409 					"call ext4_journal_dirty_met adata");
410 		err = ext4_journal_dirty_metadata(handle,
411 				EXT4_SB(sb)->s_sbh);
412 	}
413 	return err;
414 }
415 
416 int ext4_update_incompat_feature(handle_t *handle,
417 					struct super_block *sb, __u32 incompat)
418 {
419 	int err = 0;
420 	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, incompat)) {
421 		err = ext4_journal_get_write_access(handle,
422 				EXT4_SB(sb)->s_sbh);
423 		if (err)
424 			return err;
425 		EXT4_SET_INCOMPAT_FEATURE(sb, incompat);
426 		sb->s_dirt = 1;
427 		handle->h_sync = 1;
428 		BUFFER_TRACE(EXT4_SB(sb)->s_sbh,
429 					"call ext4_journal_dirty_met adata");
430 		err = ext4_journal_dirty_metadata(handle,
431 				EXT4_SB(sb)->s_sbh);
432 	}
433 	return err;
434 }
435 
436 /*
437  * Open the external journal device
438  */
439 static struct block_device *ext4_blkdev_get(dev_t dev)
440 {
441 	struct block_device *bdev;
442 	char b[BDEVNAME_SIZE];
443 
444 	bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
445 	if (IS_ERR(bdev))
446 		goto fail;
447 	return bdev;
448 
449 fail:
450 	printk(KERN_ERR "EXT4: failed to open journal device %s: %ld\n",
451 			__bdevname(dev, b), PTR_ERR(bdev));
452 	return NULL;
453 }
454 
455 /*
456  * Release the journal device
457  */
458 static int ext4_blkdev_put(struct block_device *bdev)
459 {
460 	bd_release(bdev);
461 	return blkdev_put(bdev);
462 }
463 
464 static int ext4_blkdev_remove(struct ext4_sb_info *sbi)
465 {
466 	struct block_device *bdev;
467 	int ret = -ENODEV;
468 
469 	bdev = sbi->journal_bdev;
470 	if (bdev) {
471 		ret = ext4_blkdev_put(bdev);
472 		sbi->journal_bdev = NULL;
473 	}
474 	return ret;
475 }
476 
477 static inline struct inode *orphan_list_entry(struct list_head *l)
478 {
479 	return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
480 }
481 
482 static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
483 {
484 	struct list_head *l;
485 
486 	printk(KERN_ERR "sb orphan head is %d\n",
487 	       le32_to_cpu(sbi->s_es->s_last_orphan));
488 
489 	printk(KERN_ERR "sb_info orphan list:\n");
490 	list_for_each(l, &sbi->s_orphan) {
491 		struct inode *inode = orphan_list_entry(l);
492 		printk(KERN_ERR "  "
493 		       "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
494 		       inode->i_sb->s_id, inode->i_ino, inode,
495 		       inode->i_mode, inode->i_nlink,
496 		       NEXT_ORPHAN(inode));
497 	}
498 }
499 
500 static void ext4_put_super (struct super_block * sb)
501 {
502 	struct ext4_sb_info *sbi = EXT4_SB(sb);
503 	struct ext4_super_block *es = sbi->s_es;
504 	int i;
505 
506 	ext4_mb_release(sb);
507 	ext4_ext_release(sb);
508 	ext4_xattr_put_super(sb);
509 	jbd2_journal_destroy(sbi->s_journal);
510 	if (!(sb->s_flags & MS_RDONLY)) {
511 		EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
512 		es->s_state = cpu_to_le16(sbi->s_mount_state);
513 		BUFFER_TRACE(sbi->s_sbh, "marking dirty");
514 		mark_buffer_dirty(sbi->s_sbh);
515 		ext4_commit_super(sb, es, 1);
516 	}
517 
518 	for (i = 0; i < sbi->s_gdb_count; i++)
519 		brelse(sbi->s_group_desc[i]);
520 	kfree(sbi->s_group_desc);
521 	percpu_counter_destroy(&sbi->s_freeblocks_counter);
522 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
523 	percpu_counter_destroy(&sbi->s_dirs_counter);
524 	brelse(sbi->s_sbh);
525 #ifdef CONFIG_QUOTA
526 	for (i = 0; i < MAXQUOTAS; i++)
527 		kfree(sbi->s_qf_names[i]);
528 #endif
529 
530 	/* Debugging code just in case the in-memory inode orphan list
531 	 * isn't empty.  The on-disk one can be non-empty if we've
532 	 * detected an error and taken the fs readonly, but the
533 	 * in-memory list had better be clean by this point. */
534 	if (!list_empty(&sbi->s_orphan))
535 		dump_orphan_list(sb, sbi);
536 	J_ASSERT(list_empty(&sbi->s_orphan));
537 
538 	invalidate_bdev(sb->s_bdev);
539 	if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
540 		/*
541 		 * Invalidate the journal device's buffers.  We don't want them
542 		 * floating about in memory - the physical journal device may
543 		 * hotswapped, and it breaks the `ro-after' testing code.
544 		 */
545 		sync_blockdev(sbi->journal_bdev);
546 		invalidate_bdev(sbi->journal_bdev);
547 		ext4_blkdev_remove(sbi);
548 	}
549 	sb->s_fs_info = NULL;
550 	kfree(sbi);
551 	return;
552 }
553 
554 static struct kmem_cache *ext4_inode_cachep;
555 
556 /*
557  * Called inside transaction, so use GFP_NOFS
558  */
559 static struct inode *ext4_alloc_inode(struct super_block *sb)
560 {
561 	struct ext4_inode_info *ei;
562 
563 	ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
564 	if (!ei)
565 		return NULL;
566 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
567 	ei->i_acl = EXT4_ACL_NOT_CACHED;
568 	ei->i_default_acl = EXT4_ACL_NOT_CACHED;
569 #endif
570 	ei->i_block_alloc_info = NULL;
571 	ei->vfs_inode.i_version = 1;
572 	memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
573 	INIT_LIST_HEAD(&ei->i_prealloc_list);
574 	spin_lock_init(&ei->i_prealloc_lock);
575 	return &ei->vfs_inode;
576 }
577 
578 static void ext4_destroy_inode(struct inode *inode)
579 {
580 	if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
581 		printk("EXT4 Inode %p: orphan list check failed!\n",
582 			EXT4_I(inode));
583 		print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
584 				EXT4_I(inode), sizeof(struct ext4_inode_info),
585 				true);
586 		dump_stack();
587 	}
588 	kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
589 }
590 
591 static void init_once(struct kmem_cache *cachep, void *foo)
592 {
593 	struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
594 
595 	INIT_LIST_HEAD(&ei->i_orphan);
596 #ifdef CONFIG_EXT4DEV_FS_XATTR
597 	init_rwsem(&ei->xattr_sem);
598 #endif
599 	init_rwsem(&ei->i_data_sem);
600 	inode_init_once(&ei->vfs_inode);
601 }
602 
603 static int init_inodecache(void)
604 {
605 	ext4_inode_cachep = kmem_cache_create("ext4_inode_cache",
606 					     sizeof(struct ext4_inode_info),
607 					     0, (SLAB_RECLAIM_ACCOUNT|
608 						SLAB_MEM_SPREAD),
609 					     init_once);
610 	if (ext4_inode_cachep == NULL)
611 		return -ENOMEM;
612 	return 0;
613 }
614 
615 static void destroy_inodecache(void)
616 {
617 	kmem_cache_destroy(ext4_inode_cachep);
618 }
619 
620 static void ext4_clear_inode(struct inode *inode)
621 {
622 	struct ext4_block_alloc_info *rsv = EXT4_I(inode)->i_block_alloc_info;
623 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
624 	if (EXT4_I(inode)->i_acl &&
625 			EXT4_I(inode)->i_acl != EXT4_ACL_NOT_CACHED) {
626 		posix_acl_release(EXT4_I(inode)->i_acl);
627 		EXT4_I(inode)->i_acl = EXT4_ACL_NOT_CACHED;
628 	}
629 	if (EXT4_I(inode)->i_default_acl &&
630 			EXT4_I(inode)->i_default_acl != EXT4_ACL_NOT_CACHED) {
631 		posix_acl_release(EXT4_I(inode)->i_default_acl);
632 		EXT4_I(inode)->i_default_acl = EXT4_ACL_NOT_CACHED;
633 	}
634 #endif
635 	ext4_discard_reservation(inode);
636 	EXT4_I(inode)->i_block_alloc_info = NULL;
637 	if (unlikely(rsv))
638 		kfree(rsv);
639 }
640 
641 static inline void ext4_show_quota_options(struct seq_file *seq, struct super_block *sb)
642 {
643 #if defined(CONFIG_QUOTA)
644 	struct ext4_sb_info *sbi = EXT4_SB(sb);
645 
646 	if (sbi->s_jquota_fmt)
647 		seq_printf(seq, ",jqfmt=%s",
648 		(sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
649 
650 	if (sbi->s_qf_names[USRQUOTA])
651 		seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
652 
653 	if (sbi->s_qf_names[GRPQUOTA])
654 		seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
655 
656 	if (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA)
657 		seq_puts(seq, ",usrquota");
658 
659 	if (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)
660 		seq_puts(seq, ",grpquota");
661 #endif
662 }
663 
664 /*
665  * Show an option if
666  *  - it's set to a non-default value OR
667  *  - if the per-sb default is different from the global default
668  */
669 static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
670 {
671 	int def_errors;
672 	unsigned long def_mount_opts;
673 	struct super_block *sb = vfs->mnt_sb;
674 	struct ext4_sb_info *sbi = EXT4_SB(sb);
675 	struct ext4_super_block *es = sbi->s_es;
676 
677 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
678 	def_errors     = le16_to_cpu(es->s_errors);
679 
680 	if (sbi->s_sb_block != 1)
681 		seq_printf(seq, ",sb=%llu", sbi->s_sb_block);
682 	if (test_opt(sb, MINIX_DF))
683 		seq_puts(seq, ",minixdf");
684 	if (test_opt(sb, GRPID) && !(def_mount_opts & EXT4_DEFM_BSDGROUPS))
685 		seq_puts(seq, ",grpid");
686 	if (!test_opt(sb, GRPID) && (def_mount_opts & EXT4_DEFM_BSDGROUPS))
687 		seq_puts(seq, ",nogrpid");
688 	if (sbi->s_resuid != EXT4_DEF_RESUID ||
689 	    le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID) {
690 		seq_printf(seq, ",resuid=%u", sbi->s_resuid);
691 	}
692 	if (sbi->s_resgid != EXT4_DEF_RESGID ||
693 	    le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID) {
694 		seq_printf(seq, ",resgid=%u", sbi->s_resgid);
695 	}
696 	if (test_opt(sb, ERRORS_RO)) {
697 		if (def_errors == EXT4_ERRORS_PANIC ||
698 		    def_errors == EXT4_ERRORS_CONTINUE) {
699 			seq_puts(seq, ",errors=remount-ro");
700 		}
701 	}
702 	if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
703 		seq_puts(seq, ",errors=continue");
704 	if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
705 		seq_puts(seq, ",errors=panic");
706 	if (test_opt(sb, NO_UID32) && !(def_mount_opts & EXT4_DEFM_UID16))
707 		seq_puts(seq, ",nouid32");
708 	if (test_opt(sb, DEBUG) && !(def_mount_opts & EXT4_DEFM_DEBUG))
709 		seq_puts(seq, ",debug");
710 	if (test_opt(sb, OLDALLOC))
711 		seq_puts(seq, ",oldalloc");
712 #ifdef CONFIG_EXT4DEV_FS_XATTR
713 	if (test_opt(sb, XATTR_USER) &&
714 		!(def_mount_opts & EXT4_DEFM_XATTR_USER))
715 		seq_puts(seq, ",user_xattr");
716 	if (!test_opt(sb, XATTR_USER) &&
717 	    (def_mount_opts & EXT4_DEFM_XATTR_USER)) {
718 		seq_puts(seq, ",nouser_xattr");
719 	}
720 #endif
721 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
722 	if (test_opt(sb, POSIX_ACL) && !(def_mount_opts & EXT4_DEFM_ACL))
723 		seq_puts(seq, ",acl");
724 	if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT4_DEFM_ACL))
725 		seq_puts(seq, ",noacl");
726 #endif
727 	if (!test_opt(sb, RESERVATION))
728 		seq_puts(seq, ",noreservation");
729 	if (sbi->s_commit_interval) {
730 		seq_printf(seq, ",commit=%u",
731 			   (unsigned) (sbi->s_commit_interval / HZ));
732 	}
733 	if (test_opt(sb, BARRIER))
734 		seq_puts(seq, ",barrier=1");
735 	if (test_opt(sb, NOBH))
736 		seq_puts(seq, ",nobh");
737 	if (!test_opt(sb, EXTENTS))
738 		seq_puts(seq, ",noextents");
739 	if (!test_opt(sb, MBALLOC))
740 		seq_puts(seq, ",nomballoc");
741 	if (test_opt(sb, I_VERSION))
742 		seq_puts(seq, ",i_version");
743 
744 	if (sbi->s_stripe)
745 		seq_printf(seq, ",stripe=%lu", sbi->s_stripe);
746 	/*
747 	 * journal mode get enabled in different ways
748 	 * So just print the value even if we didn't specify it
749 	 */
750 	if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
751 		seq_puts(seq, ",data=journal");
752 	else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
753 		seq_puts(seq, ",data=ordered");
754 	else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
755 		seq_puts(seq, ",data=writeback");
756 
757 	ext4_show_quota_options(seq, sb);
758 	return 0;
759 }
760 
761 
762 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
763 		u64 ino, u32 generation)
764 {
765 	struct inode *inode;
766 
767 	if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
768 		return ERR_PTR(-ESTALE);
769 	if (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
770 		return ERR_PTR(-ESTALE);
771 
772 	/* iget isn't really right if the inode is currently unallocated!!
773 	 *
774 	 * ext4_read_inode will return a bad_inode if the inode had been
775 	 * deleted, so we should be safe.
776 	 *
777 	 * Currently we don't know the generation for parent directory, so
778 	 * a generation of 0 means "accept any"
779 	 */
780 	inode = ext4_iget(sb, ino);
781 	if (IS_ERR(inode))
782 		return ERR_CAST(inode);
783 	if (generation && inode->i_generation != generation) {
784 		iput(inode);
785 		return ERR_PTR(-ESTALE);
786 	}
787 
788 	return inode;
789 }
790 
791 static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
792 		int fh_len, int fh_type)
793 {
794 	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
795 				    ext4_nfs_get_inode);
796 }
797 
798 static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
799 		int fh_len, int fh_type)
800 {
801 	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
802 				    ext4_nfs_get_inode);
803 }
804 
805 #ifdef CONFIG_QUOTA
806 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
807 #define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
808 
809 static int ext4_dquot_initialize(struct inode *inode, int type);
810 static int ext4_dquot_drop(struct inode *inode);
811 static int ext4_write_dquot(struct dquot *dquot);
812 static int ext4_acquire_dquot(struct dquot *dquot);
813 static int ext4_release_dquot(struct dquot *dquot);
814 static int ext4_mark_dquot_dirty(struct dquot *dquot);
815 static int ext4_write_info(struct super_block *sb, int type);
816 static int ext4_quota_on(struct super_block *sb, int type, int format_id, char *path);
817 static int ext4_quota_on_mount(struct super_block *sb, int type);
818 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
819 			       size_t len, loff_t off);
820 static ssize_t ext4_quota_write(struct super_block *sb, int type,
821 				const char *data, size_t len, loff_t off);
822 
823 static struct dquot_operations ext4_quota_operations = {
824 	.initialize	= ext4_dquot_initialize,
825 	.drop		= ext4_dquot_drop,
826 	.alloc_space	= dquot_alloc_space,
827 	.alloc_inode	= dquot_alloc_inode,
828 	.free_space	= dquot_free_space,
829 	.free_inode	= dquot_free_inode,
830 	.transfer	= dquot_transfer,
831 	.write_dquot	= ext4_write_dquot,
832 	.acquire_dquot	= ext4_acquire_dquot,
833 	.release_dquot	= ext4_release_dquot,
834 	.mark_dirty	= ext4_mark_dquot_dirty,
835 	.write_info	= ext4_write_info
836 };
837 
838 static struct quotactl_ops ext4_qctl_operations = {
839 	.quota_on	= ext4_quota_on,
840 	.quota_off	= vfs_quota_off,
841 	.quota_sync	= vfs_quota_sync,
842 	.get_info	= vfs_get_dqinfo,
843 	.set_info	= vfs_set_dqinfo,
844 	.get_dqblk	= vfs_get_dqblk,
845 	.set_dqblk	= vfs_set_dqblk
846 };
847 #endif
848 
849 static const struct super_operations ext4_sops = {
850 	.alloc_inode	= ext4_alloc_inode,
851 	.destroy_inode	= ext4_destroy_inode,
852 	.write_inode	= ext4_write_inode,
853 	.dirty_inode	= ext4_dirty_inode,
854 	.delete_inode	= ext4_delete_inode,
855 	.put_super	= ext4_put_super,
856 	.write_super	= ext4_write_super,
857 	.sync_fs	= ext4_sync_fs,
858 	.write_super_lockfs = ext4_write_super_lockfs,
859 	.unlockfs	= ext4_unlockfs,
860 	.statfs		= ext4_statfs,
861 	.remount_fs	= ext4_remount,
862 	.clear_inode	= ext4_clear_inode,
863 	.show_options	= ext4_show_options,
864 #ifdef CONFIG_QUOTA
865 	.quota_read	= ext4_quota_read,
866 	.quota_write	= ext4_quota_write,
867 #endif
868 };
869 
870 static const struct export_operations ext4_export_ops = {
871 	.fh_to_dentry = ext4_fh_to_dentry,
872 	.fh_to_parent = ext4_fh_to_parent,
873 	.get_parent = ext4_get_parent,
874 };
875 
876 enum {
877 	Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
878 	Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
879 	Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
880 	Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
881 	Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh, Opt_bh,
882 	Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
883 	Opt_journal_checksum, Opt_journal_async_commit,
884 	Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
885 	Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
886 	Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
887 	Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
888 	Opt_grpquota, Opt_extents, Opt_noextents, Opt_i_version,
889 	Opt_mballoc, Opt_nomballoc, Opt_stripe,
890 };
891 
892 static match_table_t tokens = {
893 	{Opt_bsd_df, "bsddf"},
894 	{Opt_minix_df, "minixdf"},
895 	{Opt_grpid, "grpid"},
896 	{Opt_grpid, "bsdgroups"},
897 	{Opt_nogrpid, "nogrpid"},
898 	{Opt_nogrpid, "sysvgroups"},
899 	{Opt_resgid, "resgid=%u"},
900 	{Opt_resuid, "resuid=%u"},
901 	{Opt_sb, "sb=%u"},
902 	{Opt_err_cont, "errors=continue"},
903 	{Opt_err_panic, "errors=panic"},
904 	{Opt_err_ro, "errors=remount-ro"},
905 	{Opt_nouid32, "nouid32"},
906 	{Opt_nocheck, "nocheck"},
907 	{Opt_nocheck, "check=none"},
908 	{Opt_debug, "debug"},
909 	{Opt_oldalloc, "oldalloc"},
910 	{Opt_orlov, "orlov"},
911 	{Opt_user_xattr, "user_xattr"},
912 	{Opt_nouser_xattr, "nouser_xattr"},
913 	{Opt_acl, "acl"},
914 	{Opt_noacl, "noacl"},
915 	{Opt_reservation, "reservation"},
916 	{Opt_noreservation, "noreservation"},
917 	{Opt_noload, "noload"},
918 	{Opt_nobh, "nobh"},
919 	{Opt_bh, "bh"},
920 	{Opt_commit, "commit=%u"},
921 	{Opt_journal_update, "journal=update"},
922 	{Opt_journal_inum, "journal=%u"},
923 	{Opt_journal_dev, "journal_dev=%u"},
924 	{Opt_journal_checksum, "journal_checksum"},
925 	{Opt_journal_async_commit, "journal_async_commit"},
926 	{Opt_abort, "abort"},
927 	{Opt_data_journal, "data=journal"},
928 	{Opt_data_ordered, "data=ordered"},
929 	{Opt_data_writeback, "data=writeback"},
930 	{Opt_offusrjquota, "usrjquota="},
931 	{Opt_usrjquota, "usrjquota=%s"},
932 	{Opt_offgrpjquota, "grpjquota="},
933 	{Opt_grpjquota, "grpjquota=%s"},
934 	{Opt_jqfmt_vfsold, "jqfmt=vfsold"},
935 	{Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
936 	{Opt_grpquota, "grpquota"},
937 	{Opt_noquota, "noquota"},
938 	{Opt_quota, "quota"},
939 	{Opt_usrquota, "usrquota"},
940 	{Opt_barrier, "barrier=%u"},
941 	{Opt_extents, "extents"},
942 	{Opt_noextents, "noextents"},
943 	{Opt_i_version, "i_version"},
944 	{Opt_mballoc, "mballoc"},
945 	{Opt_nomballoc, "nomballoc"},
946 	{Opt_stripe, "stripe=%u"},
947 	{Opt_err, NULL},
948 	{Opt_resize, "resize"},
949 };
950 
951 static ext4_fsblk_t get_sb_block(void **data)
952 {
953 	ext4_fsblk_t	sb_block;
954 	char		*options = (char *) *data;
955 
956 	if (!options || strncmp(options, "sb=", 3) != 0)
957 		return 1;	/* Default location */
958 	options += 3;
959 	/*todo: use simple_strtoll with >32bit ext4 */
960 	sb_block = simple_strtoul(options, &options, 0);
961 	if (*options && *options != ',') {
962 		printk("EXT4-fs: Invalid sb specification: %s\n",
963 		       (char *) *data);
964 		return 1;
965 	}
966 	if (*options == ',')
967 		options++;
968 	*data = (void *) options;
969 	return sb_block;
970 }
971 
972 static int parse_options (char *options, struct super_block *sb,
973 			  unsigned int *inum, unsigned long *journal_devnum,
974 			  ext4_fsblk_t *n_blocks_count, int is_remount)
975 {
976 	struct ext4_sb_info *sbi = EXT4_SB(sb);
977 	char * p;
978 	substring_t args[MAX_OPT_ARGS];
979 	int data_opt = 0;
980 	int option;
981 #ifdef CONFIG_QUOTA
982 	int qtype;
983 	char *qname;
984 #endif
985 
986 	if (!options)
987 		return 1;
988 
989 	while ((p = strsep (&options, ",")) != NULL) {
990 		int token;
991 		if (!*p)
992 			continue;
993 
994 		token = match_token(p, tokens, args);
995 		switch (token) {
996 		case Opt_bsd_df:
997 			clear_opt (sbi->s_mount_opt, MINIX_DF);
998 			break;
999 		case Opt_minix_df:
1000 			set_opt (sbi->s_mount_opt, MINIX_DF);
1001 			break;
1002 		case Opt_grpid:
1003 			set_opt (sbi->s_mount_opt, GRPID);
1004 			break;
1005 		case Opt_nogrpid:
1006 			clear_opt (sbi->s_mount_opt, GRPID);
1007 			break;
1008 		case Opt_resuid:
1009 			if (match_int(&args[0], &option))
1010 				return 0;
1011 			sbi->s_resuid = option;
1012 			break;
1013 		case Opt_resgid:
1014 			if (match_int(&args[0], &option))
1015 				return 0;
1016 			sbi->s_resgid = option;
1017 			break;
1018 		case Opt_sb:
1019 			/* handled by get_sb_block() instead of here */
1020 			/* *sb_block = match_int(&args[0]); */
1021 			break;
1022 		case Opt_err_panic:
1023 			clear_opt (sbi->s_mount_opt, ERRORS_CONT);
1024 			clear_opt (sbi->s_mount_opt, ERRORS_RO);
1025 			set_opt (sbi->s_mount_opt, ERRORS_PANIC);
1026 			break;
1027 		case Opt_err_ro:
1028 			clear_opt (sbi->s_mount_opt, ERRORS_CONT);
1029 			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
1030 			set_opt (sbi->s_mount_opt, ERRORS_RO);
1031 			break;
1032 		case Opt_err_cont:
1033 			clear_opt (sbi->s_mount_opt, ERRORS_RO);
1034 			clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
1035 			set_opt (sbi->s_mount_opt, ERRORS_CONT);
1036 			break;
1037 		case Opt_nouid32:
1038 			set_opt (sbi->s_mount_opt, NO_UID32);
1039 			break;
1040 		case Opt_nocheck:
1041 			clear_opt (sbi->s_mount_opt, CHECK);
1042 			break;
1043 		case Opt_debug:
1044 			set_opt (sbi->s_mount_opt, DEBUG);
1045 			break;
1046 		case Opt_oldalloc:
1047 			set_opt (sbi->s_mount_opt, OLDALLOC);
1048 			break;
1049 		case Opt_orlov:
1050 			clear_opt (sbi->s_mount_opt, OLDALLOC);
1051 			break;
1052 #ifdef CONFIG_EXT4DEV_FS_XATTR
1053 		case Opt_user_xattr:
1054 			set_opt (sbi->s_mount_opt, XATTR_USER);
1055 			break;
1056 		case Opt_nouser_xattr:
1057 			clear_opt (sbi->s_mount_opt, XATTR_USER);
1058 			break;
1059 #else
1060 		case Opt_user_xattr:
1061 		case Opt_nouser_xattr:
1062 			printk("EXT4 (no)user_xattr options not supported\n");
1063 			break;
1064 #endif
1065 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
1066 		case Opt_acl:
1067 			set_opt(sbi->s_mount_opt, POSIX_ACL);
1068 			break;
1069 		case Opt_noacl:
1070 			clear_opt(sbi->s_mount_opt, POSIX_ACL);
1071 			break;
1072 #else
1073 		case Opt_acl:
1074 		case Opt_noacl:
1075 			printk("EXT4 (no)acl options not supported\n");
1076 			break;
1077 #endif
1078 		case Opt_reservation:
1079 			set_opt(sbi->s_mount_opt, RESERVATION);
1080 			break;
1081 		case Opt_noreservation:
1082 			clear_opt(sbi->s_mount_opt, RESERVATION);
1083 			break;
1084 		case Opt_journal_update:
1085 			/* @@@ FIXME */
1086 			/* Eventually we will want to be able to create
1087 			   a journal file here.  For now, only allow the
1088 			   user to specify an existing inode to be the
1089 			   journal file. */
1090 			if (is_remount) {
1091 				printk(KERN_ERR "EXT4-fs: cannot specify "
1092 				       "journal on remount\n");
1093 				return 0;
1094 			}
1095 			set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
1096 			break;
1097 		case Opt_journal_inum:
1098 			if (is_remount) {
1099 				printk(KERN_ERR "EXT4-fs: cannot specify "
1100 				       "journal on remount\n");
1101 				return 0;
1102 			}
1103 			if (match_int(&args[0], &option))
1104 				return 0;
1105 			*inum = option;
1106 			break;
1107 		case Opt_journal_dev:
1108 			if (is_remount) {
1109 				printk(KERN_ERR "EXT4-fs: cannot specify "
1110 				       "journal on remount\n");
1111 				return 0;
1112 			}
1113 			if (match_int(&args[0], &option))
1114 				return 0;
1115 			*journal_devnum = option;
1116 			break;
1117 		case Opt_journal_checksum:
1118 			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1119 			break;
1120 		case Opt_journal_async_commit:
1121 			set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
1122 			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1123 			break;
1124 		case Opt_noload:
1125 			set_opt (sbi->s_mount_opt, NOLOAD);
1126 			break;
1127 		case Opt_commit:
1128 			if (match_int(&args[0], &option))
1129 				return 0;
1130 			if (option < 0)
1131 				return 0;
1132 			if (option == 0)
1133 				option = JBD2_DEFAULT_MAX_COMMIT_AGE;
1134 			sbi->s_commit_interval = HZ * option;
1135 			break;
1136 		case Opt_data_journal:
1137 			data_opt = EXT4_MOUNT_JOURNAL_DATA;
1138 			goto datacheck;
1139 		case Opt_data_ordered:
1140 			data_opt = EXT4_MOUNT_ORDERED_DATA;
1141 			goto datacheck;
1142 		case Opt_data_writeback:
1143 			data_opt = EXT4_MOUNT_WRITEBACK_DATA;
1144 		datacheck:
1145 			if (is_remount) {
1146 				if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS)
1147 						!= data_opt) {
1148 					printk(KERN_ERR
1149 						"EXT4-fs: cannot change data "
1150 						"mode on remount\n");
1151 					return 0;
1152 				}
1153 			} else {
1154 				sbi->s_mount_opt &= ~EXT4_MOUNT_DATA_FLAGS;
1155 				sbi->s_mount_opt |= data_opt;
1156 			}
1157 			break;
1158 #ifdef CONFIG_QUOTA
1159 		case Opt_usrjquota:
1160 			qtype = USRQUOTA;
1161 			goto set_qf_name;
1162 		case Opt_grpjquota:
1163 			qtype = GRPQUOTA;
1164 set_qf_name:
1165 			if (sb_any_quota_enabled(sb)) {
1166 				printk(KERN_ERR
1167 					"EXT4-fs: Cannot change journalled "
1168 					"quota options when quota turned on.\n");
1169 				return 0;
1170 			}
1171 			qname = match_strdup(&args[0]);
1172 			if (!qname) {
1173 				printk(KERN_ERR
1174 					"EXT4-fs: not enough memory for "
1175 					"storing quotafile name.\n");
1176 				return 0;
1177 			}
1178 			if (sbi->s_qf_names[qtype] &&
1179 			    strcmp(sbi->s_qf_names[qtype], qname)) {
1180 				printk(KERN_ERR
1181 					"EXT4-fs: %s quota file already "
1182 					"specified.\n", QTYPE2NAME(qtype));
1183 				kfree(qname);
1184 				return 0;
1185 			}
1186 			sbi->s_qf_names[qtype] = qname;
1187 			if (strchr(sbi->s_qf_names[qtype], '/')) {
1188 				printk(KERN_ERR
1189 					"EXT4-fs: quotafile must be on "
1190 					"filesystem root.\n");
1191 				kfree(sbi->s_qf_names[qtype]);
1192 				sbi->s_qf_names[qtype] = NULL;
1193 				return 0;
1194 			}
1195 			set_opt(sbi->s_mount_opt, QUOTA);
1196 			break;
1197 		case Opt_offusrjquota:
1198 			qtype = USRQUOTA;
1199 			goto clear_qf_name;
1200 		case Opt_offgrpjquota:
1201 			qtype = GRPQUOTA;
1202 clear_qf_name:
1203 			if (sb_any_quota_enabled(sb)) {
1204 				printk(KERN_ERR "EXT4-fs: Cannot change "
1205 					"journalled quota options when "
1206 					"quota turned on.\n");
1207 				return 0;
1208 			}
1209 			/*
1210 			 * The space will be released later when all options
1211 			 * are confirmed to be correct
1212 			 */
1213 			sbi->s_qf_names[qtype] = NULL;
1214 			break;
1215 		case Opt_jqfmt_vfsold:
1216 			sbi->s_jquota_fmt = QFMT_VFS_OLD;
1217 			break;
1218 		case Opt_jqfmt_vfsv0:
1219 			sbi->s_jquota_fmt = QFMT_VFS_V0;
1220 			break;
1221 		case Opt_quota:
1222 		case Opt_usrquota:
1223 			set_opt(sbi->s_mount_opt, QUOTA);
1224 			set_opt(sbi->s_mount_opt, USRQUOTA);
1225 			break;
1226 		case Opt_grpquota:
1227 			set_opt(sbi->s_mount_opt, QUOTA);
1228 			set_opt(sbi->s_mount_opt, GRPQUOTA);
1229 			break;
1230 		case Opt_noquota:
1231 			if (sb_any_quota_enabled(sb)) {
1232 				printk(KERN_ERR "EXT4-fs: Cannot change quota "
1233 					"options when quota turned on.\n");
1234 				return 0;
1235 			}
1236 			clear_opt(sbi->s_mount_opt, QUOTA);
1237 			clear_opt(sbi->s_mount_opt, USRQUOTA);
1238 			clear_opt(sbi->s_mount_opt, GRPQUOTA);
1239 			break;
1240 #else
1241 		case Opt_quota:
1242 		case Opt_usrquota:
1243 		case Opt_grpquota:
1244 		case Opt_usrjquota:
1245 		case Opt_grpjquota:
1246 		case Opt_offusrjquota:
1247 		case Opt_offgrpjquota:
1248 		case Opt_jqfmt_vfsold:
1249 		case Opt_jqfmt_vfsv0:
1250 			printk(KERN_ERR
1251 				"EXT4-fs: journalled quota options not "
1252 				"supported.\n");
1253 			break;
1254 		case Opt_noquota:
1255 			break;
1256 #endif
1257 		case Opt_abort:
1258 			set_opt(sbi->s_mount_opt, ABORT);
1259 			break;
1260 		case Opt_barrier:
1261 			if (match_int(&args[0], &option))
1262 				return 0;
1263 			if (option)
1264 				set_opt(sbi->s_mount_opt, BARRIER);
1265 			else
1266 				clear_opt(sbi->s_mount_opt, BARRIER);
1267 			break;
1268 		case Opt_ignore:
1269 			break;
1270 		case Opt_resize:
1271 			if (!is_remount) {
1272 				printk("EXT4-fs: resize option only available "
1273 					"for remount\n");
1274 				return 0;
1275 			}
1276 			if (match_int(&args[0], &option) != 0)
1277 				return 0;
1278 			*n_blocks_count = option;
1279 			break;
1280 		case Opt_nobh:
1281 			set_opt(sbi->s_mount_opt, NOBH);
1282 			break;
1283 		case Opt_bh:
1284 			clear_opt(sbi->s_mount_opt, NOBH);
1285 			break;
1286 		case Opt_extents:
1287 			set_opt (sbi->s_mount_opt, EXTENTS);
1288 			break;
1289 		case Opt_noextents:
1290 			clear_opt (sbi->s_mount_opt, EXTENTS);
1291 			break;
1292 		case Opt_i_version:
1293 			set_opt(sbi->s_mount_opt, I_VERSION);
1294 			sb->s_flags |= MS_I_VERSION;
1295 			break;
1296 		case Opt_mballoc:
1297 			set_opt(sbi->s_mount_opt, MBALLOC);
1298 			break;
1299 		case Opt_nomballoc:
1300 			clear_opt(sbi->s_mount_opt, MBALLOC);
1301 			break;
1302 		case Opt_stripe:
1303 			if (match_int(&args[0], &option))
1304 				return 0;
1305 			if (option < 0)
1306 				return 0;
1307 			sbi->s_stripe = option;
1308 			break;
1309 		default:
1310 			printk (KERN_ERR
1311 				"EXT4-fs: Unrecognized mount option \"%s\" "
1312 				"or missing value\n", p);
1313 			return 0;
1314 		}
1315 	}
1316 #ifdef CONFIG_QUOTA
1317 	if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
1318 		if ((sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA) &&
1319 		     sbi->s_qf_names[USRQUOTA])
1320 			clear_opt(sbi->s_mount_opt, USRQUOTA);
1321 
1322 		if ((sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA) &&
1323 		     sbi->s_qf_names[GRPQUOTA])
1324 			clear_opt(sbi->s_mount_opt, GRPQUOTA);
1325 
1326 		if ((sbi->s_qf_names[USRQUOTA] &&
1327 				(sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) ||
1328 		    (sbi->s_qf_names[GRPQUOTA] &&
1329 				(sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) {
1330 			printk(KERN_ERR "EXT4-fs: old and new quota "
1331 					"format mixing.\n");
1332 			return 0;
1333 		}
1334 
1335 		if (!sbi->s_jquota_fmt) {
1336 			printk(KERN_ERR "EXT4-fs: journalled quota format "
1337 					"not specified.\n");
1338 			return 0;
1339 		}
1340 	} else {
1341 		if (sbi->s_jquota_fmt) {
1342 			printk(KERN_ERR "EXT4-fs: journalled quota format "
1343 					"specified with no journalling "
1344 					"enabled.\n");
1345 			return 0;
1346 		}
1347 	}
1348 #endif
1349 	return 1;
1350 }
1351 
1352 static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
1353 			    int read_only)
1354 {
1355 	struct ext4_sb_info *sbi = EXT4_SB(sb);
1356 	int res = 0;
1357 
1358 	if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
1359 		printk (KERN_ERR "EXT4-fs warning: revision level too high, "
1360 			"forcing read-only mode\n");
1361 		res = MS_RDONLY;
1362 	}
1363 	if (read_only)
1364 		return res;
1365 	if (!(sbi->s_mount_state & EXT4_VALID_FS))
1366 		printk (KERN_WARNING "EXT4-fs warning: mounting unchecked fs, "
1367 			"running e2fsck is recommended\n");
1368 	else if ((sbi->s_mount_state & EXT4_ERROR_FS))
1369 		printk (KERN_WARNING
1370 			"EXT4-fs warning: mounting fs with errors, "
1371 			"running e2fsck is recommended\n");
1372 	else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1373 		 le16_to_cpu(es->s_mnt_count) >=
1374 		 (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
1375 		printk (KERN_WARNING
1376 			"EXT4-fs warning: maximal mount count reached, "
1377 			"running e2fsck is recommended\n");
1378 	else if (le32_to_cpu(es->s_checkinterval) &&
1379 		(le32_to_cpu(es->s_lastcheck) +
1380 			le32_to_cpu(es->s_checkinterval) <= get_seconds()))
1381 		printk (KERN_WARNING
1382 			"EXT4-fs warning: checktime reached, "
1383 			"running e2fsck is recommended\n");
1384 #if 0
1385 		/* @@@ We _will_ want to clear the valid bit if we find
1386 		 * inconsistencies, to force a fsck at reboot.  But for
1387 		 * a plain journaled filesystem we can keep it set as
1388 		 * valid forever! :)
1389 		 */
1390 	es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) & ~EXT4_VALID_FS);
1391 #endif
1392 	if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
1393 		es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
1394 	es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
1395 	es->s_mtime = cpu_to_le32(get_seconds());
1396 	ext4_update_dynamic_rev(sb);
1397 	EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
1398 
1399 	ext4_commit_super(sb, es, 1);
1400 	if (test_opt(sb, DEBUG))
1401 		printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%lu, "
1402 				"bpg=%lu, ipg=%lu, mo=%04lx]\n",
1403 			sb->s_blocksize,
1404 			sbi->s_groups_count,
1405 			EXT4_BLOCKS_PER_GROUP(sb),
1406 			EXT4_INODES_PER_GROUP(sb),
1407 			sbi->s_mount_opt);
1408 
1409 	printk(KERN_INFO "EXT4 FS on %s, ", sb->s_id);
1410 	if (EXT4_SB(sb)->s_journal->j_inode == NULL) {
1411 		char b[BDEVNAME_SIZE];
1412 
1413 		printk("external journal on %s\n",
1414 			bdevname(EXT4_SB(sb)->s_journal->j_dev, b));
1415 	} else {
1416 		printk("internal journal\n");
1417 	}
1418 	return res;
1419 }
1420 
1421 __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
1422 			    struct ext4_group_desc *gdp)
1423 {
1424 	__u16 crc = 0;
1425 
1426 	if (sbi->s_es->s_feature_ro_compat &
1427 	    cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1428 		int offset = offsetof(struct ext4_group_desc, bg_checksum);
1429 		__le32 le_group = cpu_to_le32(block_group);
1430 
1431 		crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
1432 		crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
1433 		crc = crc16(crc, (__u8 *)gdp, offset);
1434 		offset += sizeof(gdp->bg_checksum); /* skip checksum */
1435 		/* for checksum of struct ext4_group_desc do the rest...*/
1436 		if ((sbi->s_es->s_feature_incompat &
1437 		     cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
1438 		    offset < le16_to_cpu(sbi->s_es->s_desc_size))
1439 			crc = crc16(crc, (__u8 *)gdp + offset,
1440 				    le16_to_cpu(sbi->s_es->s_desc_size) -
1441 					offset);
1442 	}
1443 
1444 	return cpu_to_le16(crc);
1445 }
1446 
1447 int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 block_group,
1448 				struct ext4_group_desc *gdp)
1449 {
1450 	if ((sbi->s_es->s_feature_ro_compat &
1451 	     cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
1452 	    (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
1453 		return 0;
1454 
1455 	return 1;
1456 }
1457 
1458 /* Called at mount-time, super-block is locked */
1459 static int ext4_check_descriptors(struct super_block *sb)
1460 {
1461 	struct ext4_sb_info *sbi = EXT4_SB(sb);
1462 	ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1463 	ext4_fsblk_t last_block;
1464 	ext4_fsblk_t block_bitmap;
1465 	ext4_fsblk_t inode_bitmap;
1466 	ext4_fsblk_t inode_table;
1467 	int flexbg_flag = 0;
1468 	ext4_group_t i;
1469 
1470 	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
1471 		flexbg_flag = 1;
1472 
1473 	ext4_debug ("Checking group descriptors");
1474 
1475 	for (i = 0; i < sbi->s_groups_count; i++) {
1476 		struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1477 
1478 		if (i == sbi->s_groups_count - 1 || flexbg_flag)
1479 			last_block = ext4_blocks_count(sbi->s_es) - 1;
1480 		else
1481 			last_block = first_block +
1482 				(EXT4_BLOCKS_PER_GROUP(sb) - 1);
1483 
1484 		block_bitmap = ext4_block_bitmap(sb, gdp);
1485 		if (block_bitmap < first_block || block_bitmap > last_block)
1486 		{
1487 			ext4_error (sb, "ext4_check_descriptors",
1488 				    "Block bitmap for group %lu"
1489 				    " not in group (block %llu)!",
1490 				    i, block_bitmap);
1491 			return 0;
1492 		}
1493 		inode_bitmap = ext4_inode_bitmap(sb, gdp);
1494 		if (inode_bitmap < first_block || inode_bitmap > last_block)
1495 		{
1496 			ext4_error (sb, "ext4_check_descriptors",
1497 				    "Inode bitmap for group %lu"
1498 				    " not in group (block %llu)!",
1499 				    i, inode_bitmap);
1500 			return 0;
1501 		}
1502 		inode_table = ext4_inode_table(sb, gdp);
1503 		if (inode_table < first_block ||
1504 		    inode_table + sbi->s_itb_per_group - 1 > last_block)
1505 		{
1506 			ext4_error (sb, "ext4_check_descriptors",
1507 				    "Inode table for group %lu"
1508 				    " not in group (block %llu)!",
1509 				    i, inode_table);
1510 			return 0;
1511 		}
1512 		if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
1513 			ext4_error(sb, __FUNCTION__,
1514 				   "Checksum for group %lu failed (%u!=%u)\n",
1515 				    i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
1516 				    gdp)), le16_to_cpu(gdp->bg_checksum));
1517 			return 0;
1518 		}
1519 		if (!flexbg_flag)
1520 			first_block += EXT4_BLOCKS_PER_GROUP(sb);
1521 	}
1522 
1523 	ext4_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
1524 	sbi->s_es->s_free_inodes_count=cpu_to_le32(ext4_count_free_inodes(sb));
1525 	return 1;
1526 }
1527 
1528 /* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
1529  * the superblock) which were deleted from all directories, but held open by
1530  * a process at the time of a crash.  We walk the list and try to delete these
1531  * inodes at recovery time (only with a read-write filesystem).
1532  *
1533  * In order to keep the orphan inode chain consistent during traversal (in
1534  * case of crash during recovery), we link each inode into the superblock
1535  * orphan list_head and handle it the same way as an inode deletion during
1536  * normal operation (which journals the operations for us).
1537  *
1538  * We only do an iget() and an iput() on each inode, which is very safe if we
1539  * accidentally point at an in-use or already deleted inode.  The worst that
1540  * can happen in this case is that we get a "bit already cleared" message from
1541  * ext4_free_inode().  The only reason we would point at a wrong inode is if
1542  * e2fsck was run on this filesystem, and it must have already done the orphan
1543  * inode cleanup for us, so we can safely abort without any further action.
1544  */
1545 static void ext4_orphan_cleanup (struct super_block * sb,
1546 				 struct ext4_super_block * es)
1547 {
1548 	unsigned int s_flags = sb->s_flags;
1549 	int nr_orphans = 0, nr_truncates = 0;
1550 #ifdef CONFIG_QUOTA
1551 	int i;
1552 #endif
1553 	if (!es->s_last_orphan) {
1554 		jbd_debug(4, "no orphan inodes to clean up\n");
1555 		return;
1556 	}
1557 
1558 	if (bdev_read_only(sb->s_bdev)) {
1559 		printk(KERN_ERR "EXT4-fs: write access "
1560 			"unavailable, skipping orphan cleanup.\n");
1561 		return;
1562 	}
1563 
1564 	if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
1565 		if (es->s_last_orphan)
1566 			jbd_debug(1, "Errors on filesystem, "
1567 				  "clearing orphan list.\n");
1568 		es->s_last_orphan = 0;
1569 		jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1570 		return;
1571 	}
1572 
1573 	if (s_flags & MS_RDONLY) {
1574 		printk(KERN_INFO "EXT4-fs: %s: orphan cleanup on readonly fs\n",
1575 		       sb->s_id);
1576 		sb->s_flags &= ~MS_RDONLY;
1577 	}
1578 #ifdef CONFIG_QUOTA
1579 	/* Needed for iput() to work correctly and not trash data */
1580 	sb->s_flags |= MS_ACTIVE;
1581 	/* Turn on quotas so that they are updated correctly */
1582 	for (i = 0; i < MAXQUOTAS; i++) {
1583 		if (EXT4_SB(sb)->s_qf_names[i]) {
1584 			int ret = ext4_quota_on_mount(sb, i);
1585 			if (ret < 0)
1586 				printk(KERN_ERR
1587 					"EXT4-fs: Cannot turn on journalled "
1588 					"quota: error %d\n", ret);
1589 		}
1590 	}
1591 #endif
1592 
1593 	while (es->s_last_orphan) {
1594 		struct inode *inode;
1595 
1596 		if (!(inode =
1597 		      ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
1598 			es->s_last_orphan = 0;
1599 			break;
1600 		}
1601 
1602 		list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
1603 		DQUOT_INIT(inode);
1604 		if (inode->i_nlink) {
1605 			printk(KERN_DEBUG
1606 				"%s: truncating inode %lu to %Ld bytes\n",
1607 				__FUNCTION__, inode->i_ino, inode->i_size);
1608 			jbd_debug(2, "truncating inode %lu to %Ld bytes\n",
1609 				  inode->i_ino, inode->i_size);
1610 			ext4_truncate(inode);
1611 			nr_truncates++;
1612 		} else {
1613 			printk(KERN_DEBUG
1614 				"%s: deleting unreferenced inode %lu\n",
1615 				__FUNCTION__, inode->i_ino);
1616 			jbd_debug(2, "deleting unreferenced inode %lu\n",
1617 				  inode->i_ino);
1618 			nr_orphans++;
1619 		}
1620 		iput(inode);  /* The delete magic happens here! */
1621 	}
1622 
1623 #define PLURAL(x) (x), ((x)==1) ? "" : "s"
1624 
1625 	if (nr_orphans)
1626 		printk(KERN_INFO "EXT4-fs: %s: %d orphan inode%s deleted\n",
1627 		       sb->s_id, PLURAL(nr_orphans));
1628 	if (nr_truncates)
1629 		printk(KERN_INFO "EXT4-fs: %s: %d truncate%s cleaned up\n",
1630 		       sb->s_id, PLURAL(nr_truncates));
1631 #ifdef CONFIG_QUOTA
1632 	/* Turn quotas off */
1633 	for (i = 0; i < MAXQUOTAS; i++) {
1634 		if (sb_dqopt(sb)->files[i])
1635 			vfs_quota_off(sb, i);
1636 	}
1637 #endif
1638 	sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1639 }
1640 /*
1641  * Maximal extent format file size.
1642  * Resulting logical blkno at s_maxbytes must fit in our on-disk
1643  * extent format containers, within a sector_t, and within i_blocks
1644  * in the vfs.  ext4 inode has 48 bits of i_block in fsblock units,
1645  * so that won't be a limiting factor.
1646  *
1647  * Note, this does *not* consider any metadata overhead for vfs i_blocks.
1648  */
1649 static loff_t ext4_max_size(int blkbits)
1650 {
1651 	loff_t res;
1652 	loff_t upper_limit = MAX_LFS_FILESIZE;
1653 
1654 	/* small i_blocks in vfs inode? */
1655 	if (sizeof(blkcnt_t) < sizeof(u64)) {
1656 		/*
1657 		 * CONFIG_LSF is not enabled implies the inode
1658 		 * i_block represent total blocks in 512 bytes
1659 		 * 32 == size of vfs inode i_blocks * 8
1660 		 */
1661 		upper_limit = (1LL << 32) - 1;
1662 
1663 		/* total blocks in file system block size */
1664 		upper_limit >>= (blkbits - 9);
1665 		upper_limit <<= blkbits;
1666 	}
1667 
1668 	/* 32-bit extent-start container, ee_block */
1669 	res = 1LL << 32;
1670 	res <<= blkbits;
1671 	res -= 1;
1672 
1673 	/* Sanity check against vm- & vfs- imposed limits */
1674 	if (res > upper_limit)
1675 		res = upper_limit;
1676 
1677 	return res;
1678 }
1679 
1680 /*
1681  * Maximal bitmap file size.  There is a direct, and {,double-,triple-}indirect
1682  * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
1683  * We need to be 1 filesystem block less than the 2^48 sector limit.
1684  */
1685 static loff_t ext4_max_bitmap_size(int bits)
1686 {
1687 	loff_t res = EXT4_NDIR_BLOCKS;
1688 	int meta_blocks;
1689 	loff_t upper_limit;
1690 	/* This is calculated to be the largest file size for a
1691 	 * dense, bitmapped file such that the total number of
1692 	 * sectors in the file, including data and all indirect blocks,
1693 	 * does not exceed 2^48 -1
1694 	 * __u32 i_blocks_lo and _u16 i_blocks_high representing the
1695 	 * total number of  512 bytes blocks of the file
1696 	 */
1697 
1698 	if (sizeof(blkcnt_t) < sizeof(u64)) {
1699 		/*
1700 		 * CONFIG_LSF is not enabled implies the inode
1701 		 * i_block represent total blocks in 512 bytes
1702 		 * 32 == size of vfs inode i_blocks * 8
1703 		 */
1704 		upper_limit = (1LL << 32) - 1;
1705 
1706 		/* total blocks in file system block size */
1707 		upper_limit >>= (bits - 9);
1708 
1709 	} else {
1710 		/*
1711 		 * We use 48 bit ext4_inode i_blocks
1712 		 * With EXT4_HUGE_FILE_FL set the i_blocks
1713 		 * represent total number of blocks in
1714 		 * file system block size
1715 		 */
1716 		upper_limit = (1LL << 48) - 1;
1717 
1718 	}
1719 
1720 	/* indirect blocks */
1721 	meta_blocks = 1;
1722 	/* double indirect blocks */
1723 	meta_blocks += 1 + (1LL << (bits-2));
1724 	/* tripple indirect blocks */
1725 	meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
1726 
1727 	upper_limit -= meta_blocks;
1728 	upper_limit <<= bits;
1729 
1730 	res += 1LL << (bits-2);
1731 	res += 1LL << (2*(bits-2));
1732 	res += 1LL << (3*(bits-2));
1733 	res <<= bits;
1734 	if (res > upper_limit)
1735 		res = upper_limit;
1736 
1737 	if (res > MAX_LFS_FILESIZE)
1738 		res = MAX_LFS_FILESIZE;
1739 
1740 	return res;
1741 }
1742 
1743 static ext4_fsblk_t descriptor_loc(struct super_block *sb,
1744 				ext4_fsblk_t logical_sb_block, int nr)
1745 {
1746 	struct ext4_sb_info *sbi = EXT4_SB(sb);
1747 	ext4_group_t bg, first_meta_bg;
1748 	int has_super = 0;
1749 
1750 	first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
1751 
1752 	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
1753 	    nr < first_meta_bg)
1754 		return logical_sb_block + nr + 1;
1755 	bg = sbi->s_desc_per_block * nr;
1756 	if (ext4_bg_has_super(sb, bg))
1757 		has_super = 1;
1758 	return (has_super + ext4_group_first_block_no(sb, bg));
1759 }
1760 
1761 /**
1762  * ext4_get_stripe_size: Get the stripe size.
1763  * @sbi: In memory super block info
1764  *
1765  * If we have specified it via mount option, then
1766  * use the mount option value. If the value specified at mount time is
1767  * greater than the blocks per group use the super block value.
1768  * If the super block value is greater than blocks per group return 0.
1769  * Allocator needs it be less than blocks per group.
1770  *
1771  */
1772 static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
1773 {
1774 	unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
1775 	unsigned long stripe_width =
1776 			le32_to_cpu(sbi->s_es->s_raid_stripe_width);
1777 
1778 	if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
1779 		return sbi->s_stripe;
1780 
1781 	if (stripe_width <= sbi->s_blocks_per_group)
1782 		return stripe_width;
1783 
1784 	if (stride <= sbi->s_blocks_per_group)
1785 		return stride;
1786 
1787 	return 0;
1788 }
1789 
1790 static int ext4_fill_super (struct super_block *sb, void *data, int silent)
1791 				__releases(kernel_sem)
1792 				__acquires(kernel_sem)
1793 
1794 {
1795 	struct buffer_head * bh;
1796 	struct ext4_super_block *es = NULL;
1797 	struct ext4_sb_info *sbi;
1798 	ext4_fsblk_t block;
1799 	ext4_fsblk_t sb_block = get_sb_block(&data);
1800 	ext4_fsblk_t logical_sb_block;
1801 	unsigned long offset = 0;
1802 	unsigned int journal_inum = 0;
1803 	unsigned long journal_devnum = 0;
1804 	unsigned long def_mount_opts;
1805 	struct inode *root;
1806 	int ret = -EINVAL;
1807 	int blocksize;
1808 	int db_count;
1809 	int i;
1810 	int needs_recovery;
1811 	__le32 features;
1812 	__u64 blocks_count;
1813 	int err;
1814 
1815 	sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
1816 	if (!sbi)
1817 		return -ENOMEM;
1818 	sb->s_fs_info = sbi;
1819 	sbi->s_mount_opt = 0;
1820 	sbi->s_resuid = EXT4_DEF_RESUID;
1821 	sbi->s_resgid = EXT4_DEF_RESGID;
1822 	sbi->s_sb_block = sb_block;
1823 
1824 	unlock_kernel();
1825 
1826 	blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
1827 	if (!blocksize) {
1828 		printk(KERN_ERR "EXT4-fs: unable to set blocksize\n");
1829 		goto out_fail;
1830 	}
1831 
1832 	if (!sb_set_blocksize(sb, blocksize)) {
1833 		printk(KERN_ERR "EXT4-fs: bad blocksize %d.\n", blocksize);
1834 		goto out_fail;
1835 	}
1836 
1837 	/*
1838 	 * The ext4 superblock will not be buffer aligned for other than 1kB
1839 	 * block sizes.  We need to calculate the offset from buffer start.
1840 	 */
1841 	if (blocksize != EXT4_MIN_BLOCK_SIZE) {
1842 		logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
1843 		offset = do_div(logical_sb_block, blocksize);
1844 	} else {
1845 		logical_sb_block = sb_block;
1846 	}
1847 
1848 	if (!(bh = sb_bread(sb, logical_sb_block))) {
1849 		printk (KERN_ERR "EXT4-fs: unable to read superblock\n");
1850 		goto out_fail;
1851 	}
1852 	/*
1853 	 * Note: s_es must be initialized as soon as possible because
1854 	 *       some ext4 macro-instructions depend on its value
1855 	 */
1856 	es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
1857 	sbi->s_es = es;
1858 	sb->s_magic = le16_to_cpu(es->s_magic);
1859 	if (sb->s_magic != EXT4_SUPER_MAGIC)
1860 		goto cantfind_ext4;
1861 
1862 	/* Set defaults before we parse the mount options */
1863 	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
1864 	if (def_mount_opts & EXT4_DEFM_DEBUG)
1865 		set_opt(sbi->s_mount_opt, DEBUG);
1866 	if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
1867 		set_opt(sbi->s_mount_opt, GRPID);
1868 	if (def_mount_opts & EXT4_DEFM_UID16)
1869 		set_opt(sbi->s_mount_opt, NO_UID32);
1870 #ifdef CONFIG_EXT4DEV_FS_XATTR
1871 	if (def_mount_opts & EXT4_DEFM_XATTR_USER)
1872 		set_opt(sbi->s_mount_opt, XATTR_USER);
1873 #endif
1874 #ifdef CONFIG_EXT4DEV_FS_POSIX_ACL
1875 	if (def_mount_opts & EXT4_DEFM_ACL)
1876 		set_opt(sbi->s_mount_opt, POSIX_ACL);
1877 #endif
1878 	if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
1879 		sbi->s_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
1880 	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
1881 		sbi->s_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
1882 	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
1883 		sbi->s_mount_opt |= EXT4_MOUNT_WRITEBACK_DATA;
1884 
1885 	if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
1886 		set_opt(sbi->s_mount_opt, ERRORS_PANIC);
1887 	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
1888 		set_opt(sbi->s_mount_opt, ERRORS_CONT);
1889 	else
1890 		set_opt(sbi->s_mount_opt, ERRORS_RO);
1891 
1892 	sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
1893 	sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
1894 
1895 	set_opt(sbi->s_mount_opt, RESERVATION);
1896 
1897 	/*
1898 	 * turn on extents feature by default in ext4 filesystem
1899 	 * User -o noextents to turn it off
1900 	 */
1901 	set_opt(sbi->s_mount_opt, EXTENTS);
1902 	/*
1903 	 * turn on mballoc feature by default in ext4 filesystem
1904 	 * User -o nomballoc to turn it off
1905 	 */
1906 	set_opt(sbi->s_mount_opt, MBALLOC);
1907 
1908 	if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
1909 			    NULL, 0))
1910 		goto failed_mount;
1911 
1912 	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1913 		((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1914 
1915 	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
1916 	    (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
1917 	     EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
1918 	     EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
1919 		printk(KERN_WARNING
1920 		       "EXT4-fs warning: feature flags set on rev 0 fs, "
1921 		       "running e2fsck is recommended\n");
1922 
1923 	/*
1924 	 * Since ext4 is still considered development code, we require
1925 	 * that the TEST_FILESYS flag in s->flags be set.
1926 	 */
1927 	if (!(le32_to_cpu(es->s_flags) & EXT2_FLAGS_TEST_FILESYS)) {
1928 		printk(KERN_WARNING "EXT4-fs: %s: not marked "
1929 		       "OK to use with test code.\n", sb->s_id);
1930 		goto failed_mount;
1931 	}
1932 
1933 	/*
1934 	 * Check feature flags regardless of the revision level, since we
1935 	 * previously didn't change the revision level when setting the flags,
1936 	 * so there is a chance incompat flags are set on a rev 0 filesystem.
1937 	 */
1938 	features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP);
1939 	if (features) {
1940 		printk(KERN_ERR "EXT4-fs: %s: couldn't mount because of "
1941 		       "unsupported optional features (%x).\n",
1942 		       sb->s_id, le32_to_cpu(features));
1943 		goto failed_mount;
1944 	}
1945 	features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP);
1946 	if (!(sb->s_flags & MS_RDONLY) && features) {
1947 		printk(KERN_ERR "EXT4-fs: %s: couldn't mount RDWR because of "
1948 		       "unsupported optional features (%x).\n",
1949 		       sb->s_id, le32_to_cpu(features));
1950 		goto failed_mount;
1951 	}
1952 	if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
1953 		/*
1954 		 * Large file size enabled file system can only be
1955 		 * mount if kernel is build with CONFIG_LSF
1956 		 */
1957 		if (sizeof(root->i_blocks) < sizeof(u64) &&
1958 				!(sb->s_flags & MS_RDONLY)) {
1959 			printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge "
1960 					"files cannot be mounted read-write "
1961 					"without CONFIG_LSF.\n", sb->s_id);
1962 			goto failed_mount;
1963 		}
1964 	}
1965 	blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
1966 
1967 	if (blocksize < EXT4_MIN_BLOCK_SIZE ||
1968 	    blocksize > EXT4_MAX_BLOCK_SIZE) {
1969 		printk(KERN_ERR
1970 		       "EXT4-fs: Unsupported filesystem blocksize %d on %s.\n",
1971 		       blocksize, sb->s_id);
1972 		goto failed_mount;
1973 	}
1974 
1975 	if (sb->s_blocksize != blocksize) {
1976 
1977 		/* Validate the filesystem blocksize */
1978 		if (!sb_set_blocksize(sb, blocksize)) {
1979 			printk(KERN_ERR "EXT4-fs: bad block size %d.\n",
1980 					blocksize);
1981 			goto failed_mount;
1982 		}
1983 
1984 		brelse (bh);
1985 		logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
1986 		offset = do_div(logical_sb_block, blocksize);
1987 		bh = sb_bread(sb, logical_sb_block);
1988 		if (!bh) {
1989 			printk(KERN_ERR
1990 			       "EXT4-fs: Can't read superblock on 2nd try.\n");
1991 			goto failed_mount;
1992 		}
1993 		es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
1994 		sbi->s_es = es;
1995 		if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
1996 			printk (KERN_ERR
1997 				"EXT4-fs: Magic mismatch, very weird !\n");
1998 			goto failed_mount;
1999 		}
2000 	}
2001 
2002 	sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits);
2003 	sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits);
2004 
2005 	if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
2006 		sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
2007 		sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
2008 	} else {
2009 		sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
2010 		sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
2011 		if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
2012 		    (!is_power_of_2(sbi->s_inode_size)) ||
2013 		    (sbi->s_inode_size > blocksize)) {
2014 			printk (KERN_ERR
2015 				"EXT4-fs: unsupported inode size: %d\n",
2016 				sbi->s_inode_size);
2017 			goto failed_mount;
2018 		}
2019 		if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
2020 			sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
2021 	}
2022 	sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
2023 	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) {
2024 		if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
2025 		    sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
2026 		    !is_power_of_2(sbi->s_desc_size)) {
2027 			printk(KERN_ERR
2028 			       "EXT4-fs: unsupported descriptor size %lu\n",
2029 			       sbi->s_desc_size);
2030 			goto failed_mount;
2031 		}
2032 	} else
2033 		sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
2034 	sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
2035 	sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
2036 	if (EXT4_INODE_SIZE(sb) == 0 || EXT4_INODES_PER_GROUP(sb) == 0)
2037 		goto cantfind_ext4;
2038 	sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
2039 	if (sbi->s_inodes_per_block == 0)
2040 		goto cantfind_ext4;
2041 	sbi->s_itb_per_group = sbi->s_inodes_per_group /
2042 					sbi->s_inodes_per_block;
2043 	sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
2044 	sbi->s_sbh = bh;
2045 	sbi->s_mount_state = le16_to_cpu(es->s_state);
2046 	sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
2047 	sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
2048 	for (i=0; i < 4; i++)
2049 		sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2050 	sbi->s_def_hash_version = es->s_def_hash_version;
2051 
2052 	if (sbi->s_blocks_per_group > blocksize * 8) {
2053 		printk (KERN_ERR
2054 			"EXT4-fs: #blocks per group too big: %lu\n",
2055 			sbi->s_blocks_per_group);
2056 		goto failed_mount;
2057 	}
2058 	if (sbi->s_inodes_per_group > blocksize * 8) {
2059 		printk (KERN_ERR
2060 			"EXT4-fs: #inodes per group too big: %lu\n",
2061 			sbi->s_inodes_per_group);
2062 		goto failed_mount;
2063 	}
2064 
2065 	if (ext4_blocks_count(es) >
2066 		    (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
2067 		printk(KERN_ERR "EXT4-fs: filesystem on %s:"
2068 			" too large to mount safely\n", sb->s_id);
2069 		if (sizeof(sector_t) < 8)
2070 			printk(KERN_WARNING "EXT4-fs: CONFIG_LBD not "
2071 					"enabled\n");
2072 		goto failed_mount;
2073 	}
2074 
2075 	if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2076 		goto cantfind_ext4;
2077 
2078 	/* ensure blocks_count calculation below doesn't sign-extend */
2079 	if (ext4_blocks_count(es) + EXT4_BLOCKS_PER_GROUP(sb) <
2080 	    le32_to_cpu(es->s_first_data_block) + 1) {
2081 		printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu, "
2082 		       "first data block %u, blocks per group %lu\n",
2083 			ext4_blocks_count(es),
2084 			le32_to_cpu(es->s_first_data_block),
2085 			EXT4_BLOCKS_PER_GROUP(sb));
2086 		goto failed_mount;
2087 	}
2088 	blocks_count = (ext4_blocks_count(es) -
2089 			le32_to_cpu(es->s_first_data_block) +
2090 			EXT4_BLOCKS_PER_GROUP(sb) - 1);
2091 	do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
2092 	sbi->s_groups_count = blocks_count;
2093 	db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2094 		   EXT4_DESC_PER_BLOCK(sb);
2095 	sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
2096 				    GFP_KERNEL);
2097 	if (sbi->s_group_desc == NULL) {
2098 		printk (KERN_ERR "EXT4-fs: not enough memory\n");
2099 		goto failed_mount;
2100 	}
2101 
2102 	bgl_lock_init(&sbi->s_blockgroup_lock);
2103 
2104 	for (i = 0; i < db_count; i++) {
2105 		block = descriptor_loc(sb, logical_sb_block, i);
2106 		sbi->s_group_desc[i] = sb_bread(sb, block);
2107 		if (!sbi->s_group_desc[i]) {
2108 			printk (KERN_ERR "EXT4-fs: "
2109 				"can't read group descriptor %d\n", i);
2110 			db_count = i;
2111 			goto failed_mount2;
2112 		}
2113 	}
2114 	if (!ext4_check_descriptors (sb)) {
2115 		printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n");
2116 		goto failed_mount2;
2117 	}
2118 	sbi->s_gdb_count = db_count;
2119 	get_random_bytes(&sbi->s_next_generation, sizeof(u32));
2120 	spin_lock_init(&sbi->s_next_gen_lock);
2121 
2122 	err = percpu_counter_init(&sbi->s_freeblocks_counter,
2123 			ext4_count_free_blocks(sb));
2124 	if (!err) {
2125 		err = percpu_counter_init(&sbi->s_freeinodes_counter,
2126 				ext4_count_free_inodes(sb));
2127 	}
2128 	if (!err) {
2129 		err = percpu_counter_init(&sbi->s_dirs_counter,
2130 				ext4_count_dirs(sb));
2131 	}
2132 	if (err) {
2133 		printk(KERN_ERR "EXT4-fs: insufficient memory\n");
2134 		goto failed_mount3;
2135 	}
2136 
2137 	/* per fileystem reservation list head & lock */
2138 	spin_lock_init(&sbi->s_rsv_window_lock);
2139 	sbi->s_rsv_window_root = RB_ROOT;
2140 	/* Add a single, static dummy reservation to the start of the
2141 	 * reservation window list --- it gives us a placeholder for
2142 	 * append-at-start-of-list which makes the allocation logic
2143 	 * _much_ simpler. */
2144 	sbi->s_rsv_window_head.rsv_start = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
2145 	sbi->s_rsv_window_head.rsv_end = EXT4_RESERVE_WINDOW_NOT_ALLOCATED;
2146 	sbi->s_rsv_window_head.rsv_alloc_hit = 0;
2147 	sbi->s_rsv_window_head.rsv_goal_size = 0;
2148 	ext4_rsv_window_add(sb, &sbi->s_rsv_window_head);
2149 
2150 	sbi->s_stripe = ext4_get_stripe_size(sbi);
2151 
2152 	/*
2153 	 * set up enough so that it can read an inode
2154 	 */
2155 	sb->s_op = &ext4_sops;
2156 	sb->s_export_op = &ext4_export_ops;
2157 	sb->s_xattr = ext4_xattr_handlers;
2158 #ifdef CONFIG_QUOTA
2159 	sb->s_qcop = &ext4_qctl_operations;
2160 	sb->dq_op = &ext4_quota_operations;
2161 #endif
2162 	INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
2163 
2164 	sb->s_root = NULL;
2165 
2166 	needs_recovery = (es->s_last_orphan != 0 ||
2167 			  EXT4_HAS_INCOMPAT_FEATURE(sb,
2168 				    EXT4_FEATURE_INCOMPAT_RECOVER));
2169 
2170 	/*
2171 	 * The first inode we look at is the journal inode.  Don't try
2172 	 * root first: it may be modified in the journal!
2173 	 */
2174 	if (!test_opt(sb, NOLOAD) &&
2175 	    EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
2176 		if (ext4_load_journal(sb, es, journal_devnum))
2177 			goto failed_mount3;
2178 	} else if (journal_inum) {
2179 		if (ext4_create_journal(sb, es, journal_inum))
2180 			goto failed_mount3;
2181 	} else {
2182 		if (!silent)
2183 			printk (KERN_ERR
2184 				"ext4: No journal on filesystem on %s\n",
2185 				sb->s_id);
2186 		goto failed_mount3;
2187 	}
2188 
2189 	if (ext4_blocks_count(es) > 0xffffffffULL &&
2190 	    !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
2191 				       JBD2_FEATURE_INCOMPAT_64BIT)) {
2192 		printk(KERN_ERR "ext4: Failed to set 64-bit journal feature\n");
2193 		goto failed_mount4;
2194 	}
2195 
2196 	if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2197 		jbd2_journal_set_features(sbi->s_journal,
2198 				JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2199 				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2200 	} else if (test_opt(sb, JOURNAL_CHECKSUM)) {
2201 		jbd2_journal_set_features(sbi->s_journal,
2202 				JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);
2203 		jbd2_journal_clear_features(sbi->s_journal, 0, 0,
2204 				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2205 	} else {
2206 		jbd2_journal_clear_features(sbi->s_journal,
2207 				JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2208 				JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2209 	}
2210 
2211 	/* We have now updated the journal if required, so we can
2212 	 * validate the data journaling mode. */
2213 	switch (test_opt(sb, DATA_FLAGS)) {
2214 	case 0:
2215 		/* No mode set, assume a default based on the journal
2216 		 * capabilities: ORDERED_DATA if the journal can
2217 		 * cope, else JOURNAL_DATA
2218 		 */
2219 		if (jbd2_journal_check_available_features
2220 		    (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
2221 			set_opt(sbi->s_mount_opt, ORDERED_DATA);
2222 		else
2223 			set_opt(sbi->s_mount_opt, JOURNAL_DATA);
2224 		break;
2225 
2226 	case EXT4_MOUNT_ORDERED_DATA:
2227 	case EXT4_MOUNT_WRITEBACK_DATA:
2228 		if (!jbd2_journal_check_available_features
2229 		    (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
2230 			printk(KERN_ERR "EXT4-fs: Journal does not support "
2231 			       "requested data journaling mode\n");
2232 			goto failed_mount4;
2233 		}
2234 	default:
2235 		break;
2236 	}
2237 
2238 	if (test_opt(sb, NOBH)) {
2239 		if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
2240 			printk(KERN_WARNING "EXT4-fs: Ignoring nobh option - "
2241 				"its supported only with writeback mode\n");
2242 			clear_opt(sbi->s_mount_opt, NOBH);
2243 		}
2244 	}
2245 	/*
2246 	 * The jbd2_journal_load will have done any necessary log recovery,
2247 	 * so we can safely mount the rest of the filesystem now.
2248 	 */
2249 
2250 	root = ext4_iget(sb, EXT4_ROOT_INO);
2251 	if (IS_ERR(root)) {
2252 		printk(KERN_ERR "EXT4-fs: get root inode failed\n");
2253 		ret = PTR_ERR(root);
2254 		goto failed_mount4;
2255 	}
2256 	if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
2257 		iput(root);
2258 		printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
2259 		goto failed_mount4;
2260 	}
2261 	sb->s_root = d_alloc_root(root);
2262 	if (!sb->s_root) {
2263 		printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
2264 		iput(root);
2265 		ret = -ENOMEM;
2266 		goto failed_mount4;
2267 	}
2268 
2269 	ext4_setup_super (sb, es, sb->s_flags & MS_RDONLY);
2270 
2271 	/* determine the minimum size of new large inodes, if present */
2272 	if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
2273 		sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2274 						     EXT4_GOOD_OLD_INODE_SIZE;
2275 		if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
2276 				       EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
2277 			if (sbi->s_want_extra_isize <
2278 			    le16_to_cpu(es->s_want_extra_isize))
2279 				sbi->s_want_extra_isize =
2280 					le16_to_cpu(es->s_want_extra_isize);
2281 			if (sbi->s_want_extra_isize <
2282 			    le16_to_cpu(es->s_min_extra_isize))
2283 				sbi->s_want_extra_isize =
2284 					le16_to_cpu(es->s_min_extra_isize);
2285 		}
2286 	}
2287 	/* Check if enough inode space is available */
2288 	if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
2289 							sbi->s_inode_size) {
2290 		sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2291 						       EXT4_GOOD_OLD_INODE_SIZE;
2292 		printk(KERN_INFO "EXT4-fs: required extra inode space not"
2293 			"available.\n");
2294 	}
2295 
2296 	/*
2297 	 * akpm: core read_super() calls in here with the superblock locked.
2298 	 * That deadlocks, because orphan cleanup needs to lock the superblock
2299 	 * in numerous places.  Here we just pop the lock - it's relatively
2300 	 * harmless, because we are now ready to accept write_super() requests,
2301 	 * and aviro says that's the only reason for hanging onto the
2302 	 * superblock lock.
2303 	 */
2304 	EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
2305 	ext4_orphan_cleanup(sb, es);
2306 	EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
2307 	if (needs_recovery)
2308 		printk (KERN_INFO "EXT4-fs: recovery complete.\n");
2309 	ext4_mark_recovery_complete(sb, es);
2310 	printk (KERN_INFO "EXT4-fs: mounted filesystem with %s data mode.\n",
2311 		test_opt(sb,DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA ? "journal":
2312 		test_opt(sb,DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA ? "ordered":
2313 		"writeback");
2314 
2315 	ext4_ext_init(sb);
2316 	ext4_mb_init(sb, needs_recovery);
2317 
2318 	lock_kernel();
2319 	return 0;
2320 
2321 cantfind_ext4:
2322 	if (!silent)
2323 		printk(KERN_ERR "VFS: Can't find ext4 filesystem on dev %s.\n",
2324 		       sb->s_id);
2325 	goto failed_mount;
2326 
2327 failed_mount4:
2328 	jbd2_journal_destroy(sbi->s_journal);
2329 failed_mount3:
2330 	percpu_counter_destroy(&sbi->s_freeblocks_counter);
2331 	percpu_counter_destroy(&sbi->s_freeinodes_counter);
2332 	percpu_counter_destroy(&sbi->s_dirs_counter);
2333 failed_mount2:
2334 	for (i = 0; i < db_count; i++)
2335 		brelse(sbi->s_group_desc[i]);
2336 	kfree(sbi->s_group_desc);
2337 failed_mount:
2338 #ifdef CONFIG_QUOTA
2339 	for (i = 0; i < MAXQUOTAS; i++)
2340 		kfree(sbi->s_qf_names[i]);
2341 #endif
2342 	ext4_blkdev_remove(sbi);
2343 	brelse(bh);
2344 out_fail:
2345 	sb->s_fs_info = NULL;
2346 	kfree(sbi);
2347 	lock_kernel();
2348 	return ret;
2349 }
2350 
2351 /*
2352  * Setup any per-fs journal parameters now.  We'll do this both on
2353  * initial mount, once the journal has been initialised but before we've
2354  * done any recovery; and again on any subsequent remount.
2355  */
2356 static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
2357 {
2358 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2359 
2360 	if (sbi->s_commit_interval)
2361 		journal->j_commit_interval = sbi->s_commit_interval;
2362 	/* We could also set up an ext4-specific default for the commit
2363 	 * interval here, but for now we'll just fall back to the jbd
2364 	 * default. */
2365 
2366 	spin_lock(&journal->j_state_lock);
2367 	if (test_opt(sb, BARRIER))
2368 		journal->j_flags |= JBD2_BARRIER;
2369 	else
2370 		journal->j_flags &= ~JBD2_BARRIER;
2371 	spin_unlock(&journal->j_state_lock);
2372 }
2373 
2374 static journal_t *ext4_get_journal(struct super_block *sb,
2375 				   unsigned int journal_inum)
2376 {
2377 	struct inode *journal_inode;
2378 	journal_t *journal;
2379 
2380 	/* First, test for the existence of a valid inode on disk.  Bad
2381 	 * things happen if we iget() an unused inode, as the subsequent
2382 	 * iput() will try to delete it. */
2383 
2384 	journal_inode = ext4_iget(sb, journal_inum);
2385 	if (IS_ERR(journal_inode)) {
2386 		printk(KERN_ERR "EXT4-fs: no journal found.\n");
2387 		return NULL;
2388 	}
2389 	if (!journal_inode->i_nlink) {
2390 		make_bad_inode(journal_inode);
2391 		iput(journal_inode);
2392 		printk(KERN_ERR "EXT4-fs: journal inode is deleted.\n");
2393 		return NULL;
2394 	}
2395 
2396 	jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
2397 		  journal_inode, journal_inode->i_size);
2398 	if (!S_ISREG(journal_inode->i_mode)) {
2399 		printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
2400 		iput(journal_inode);
2401 		return NULL;
2402 	}
2403 
2404 	journal = jbd2_journal_init_inode(journal_inode);
2405 	if (!journal) {
2406 		printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
2407 		iput(journal_inode);
2408 		return NULL;
2409 	}
2410 	journal->j_private = sb;
2411 	ext4_init_journal_params(sb, journal);
2412 	return journal;
2413 }
2414 
2415 static journal_t *ext4_get_dev_journal(struct super_block *sb,
2416 				       dev_t j_dev)
2417 {
2418 	struct buffer_head * bh;
2419 	journal_t *journal;
2420 	ext4_fsblk_t start;
2421 	ext4_fsblk_t len;
2422 	int hblock, blocksize;
2423 	ext4_fsblk_t sb_block;
2424 	unsigned long offset;
2425 	struct ext4_super_block * es;
2426 	struct block_device *bdev;
2427 
2428 	bdev = ext4_blkdev_get(j_dev);
2429 	if (bdev == NULL)
2430 		return NULL;
2431 
2432 	if (bd_claim(bdev, sb)) {
2433 		printk(KERN_ERR
2434 			"EXT4: failed to claim external journal device.\n");
2435 		blkdev_put(bdev);
2436 		return NULL;
2437 	}
2438 
2439 	blocksize = sb->s_blocksize;
2440 	hblock = bdev_hardsect_size(bdev);
2441 	if (blocksize < hblock) {
2442 		printk(KERN_ERR
2443 			"EXT4-fs: blocksize too small for journal device.\n");
2444 		goto out_bdev;
2445 	}
2446 
2447 	sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
2448 	offset = EXT4_MIN_BLOCK_SIZE % blocksize;
2449 	set_blocksize(bdev, blocksize);
2450 	if (!(bh = __bread(bdev, sb_block, blocksize))) {
2451 		printk(KERN_ERR "EXT4-fs: couldn't read superblock of "
2452 		       "external journal\n");
2453 		goto out_bdev;
2454 	}
2455 
2456 	es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
2457 	if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
2458 	    !(le32_to_cpu(es->s_feature_incompat) &
2459 	      EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
2460 		printk(KERN_ERR "EXT4-fs: external journal has "
2461 					"bad superblock\n");
2462 		brelse(bh);
2463 		goto out_bdev;
2464 	}
2465 
2466 	if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
2467 		printk(KERN_ERR "EXT4-fs: journal UUID does not match\n");
2468 		brelse(bh);
2469 		goto out_bdev;
2470 	}
2471 
2472 	len = ext4_blocks_count(es);
2473 	start = sb_block + 1;
2474 	brelse(bh);	/* we're done with the superblock */
2475 
2476 	journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
2477 					start, len, blocksize);
2478 	if (!journal) {
2479 		printk(KERN_ERR "EXT4-fs: failed to create device journal\n");
2480 		goto out_bdev;
2481 	}
2482 	journal->j_private = sb;
2483 	ll_rw_block(READ, 1, &journal->j_sb_buffer);
2484 	wait_on_buffer(journal->j_sb_buffer);
2485 	if (!buffer_uptodate(journal->j_sb_buffer)) {
2486 		printk(KERN_ERR "EXT4-fs: I/O error on journal device\n");
2487 		goto out_journal;
2488 	}
2489 	if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
2490 		printk(KERN_ERR "EXT4-fs: External journal has more than one "
2491 					"user (unsupported) - %d\n",
2492 			be32_to_cpu(journal->j_superblock->s_nr_users));
2493 		goto out_journal;
2494 	}
2495 	EXT4_SB(sb)->journal_bdev = bdev;
2496 	ext4_init_journal_params(sb, journal);
2497 	return journal;
2498 out_journal:
2499 	jbd2_journal_destroy(journal);
2500 out_bdev:
2501 	ext4_blkdev_put(bdev);
2502 	return NULL;
2503 }
2504 
2505 static int ext4_load_journal(struct super_block *sb,
2506 			     struct ext4_super_block *es,
2507 			     unsigned long journal_devnum)
2508 {
2509 	journal_t *journal;
2510 	unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
2511 	dev_t journal_dev;
2512 	int err = 0;
2513 	int really_read_only;
2514 
2515 	if (journal_devnum &&
2516 	    journal_devnum != le32_to_cpu(es->s_journal_dev)) {
2517 		printk(KERN_INFO "EXT4-fs: external journal device major/minor "
2518 			"numbers have changed\n");
2519 		journal_dev = new_decode_dev(journal_devnum);
2520 	} else
2521 		journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
2522 
2523 	really_read_only = bdev_read_only(sb->s_bdev);
2524 
2525 	/*
2526 	 * Are we loading a blank journal or performing recovery after a
2527 	 * crash?  For recovery, we need to check in advance whether we
2528 	 * can get read-write access to the device.
2529 	 */
2530 
2531 	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
2532 		if (sb->s_flags & MS_RDONLY) {
2533 			printk(KERN_INFO "EXT4-fs: INFO: recovery "
2534 					"required on readonly filesystem.\n");
2535 			if (really_read_only) {
2536 				printk(KERN_ERR "EXT4-fs: write access "
2537 					"unavailable, cannot proceed.\n");
2538 				return -EROFS;
2539 			}
2540 			printk (KERN_INFO "EXT4-fs: write access will "
2541 					"be enabled during recovery.\n");
2542 		}
2543 	}
2544 
2545 	if (journal_inum && journal_dev) {
2546 		printk(KERN_ERR "EXT4-fs: filesystem has both journal "
2547 		       "and inode journals!\n");
2548 		return -EINVAL;
2549 	}
2550 
2551 	if (journal_inum) {
2552 		if (!(journal = ext4_get_journal(sb, journal_inum)))
2553 			return -EINVAL;
2554 	} else {
2555 		if (!(journal = ext4_get_dev_journal(sb, journal_dev)))
2556 			return -EINVAL;
2557 	}
2558 
2559 	if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
2560 		err = jbd2_journal_update_format(journal);
2561 		if (err)  {
2562 			printk(KERN_ERR "EXT4-fs: error updating journal.\n");
2563 			jbd2_journal_destroy(journal);
2564 			return err;
2565 		}
2566 	}
2567 
2568 	if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER))
2569 		err = jbd2_journal_wipe(journal, !really_read_only);
2570 	if (!err)
2571 		err = jbd2_journal_load(journal);
2572 
2573 	if (err) {
2574 		printk(KERN_ERR "EXT4-fs: error loading journal.\n");
2575 		jbd2_journal_destroy(journal);
2576 		return err;
2577 	}
2578 
2579 	EXT4_SB(sb)->s_journal = journal;
2580 	ext4_clear_journal_err(sb, es);
2581 
2582 	if (journal_devnum &&
2583 	    journal_devnum != le32_to_cpu(es->s_journal_dev)) {
2584 		es->s_journal_dev = cpu_to_le32(journal_devnum);
2585 		sb->s_dirt = 1;
2586 
2587 		/* Make sure we flush the recovery flag to disk. */
2588 		ext4_commit_super(sb, es, 1);
2589 	}
2590 
2591 	return 0;
2592 }
2593 
2594 static int ext4_create_journal(struct super_block * sb,
2595 			       struct ext4_super_block * es,
2596 			       unsigned int journal_inum)
2597 {
2598 	journal_t *journal;
2599 	int err;
2600 
2601 	if (sb->s_flags & MS_RDONLY) {
2602 		printk(KERN_ERR "EXT4-fs: readonly filesystem when trying to "
2603 				"create journal.\n");
2604 		return -EROFS;
2605 	}
2606 
2607 	journal = ext4_get_journal(sb, journal_inum);
2608 	if (!journal)
2609 		return -EINVAL;
2610 
2611 	printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
2612 	       journal_inum);
2613 
2614 	err = jbd2_journal_create(journal);
2615 	if (err) {
2616 		printk(KERN_ERR "EXT4-fs: error creating journal.\n");
2617 		jbd2_journal_destroy(journal);
2618 		return -EIO;
2619 	}
2620 
2621 	EXT4_SB(sb)->s_journal = journal;
2622 
2623 	ext4_update_dynamic_rev(sb);
2624 	EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2625 	EXT4_SET_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL);
2626 
2627 	es->s_journal_inum = cpu_to_le32(journal_inum);
2628 	sb->s_dirt = 1;
2629 
2630 	/* Make sure we flush the recovery flag to disk. */
2631 	ext4_commit_super(sb, es, 1);
2632 
2633 	return 0;
2634 }
2635 
2636 static void ext4_commit_super (struct super_block * sb,
2637 			       struct ext4_super_block * es,
2638 			       int sync)
2639 {
2640 	struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
2641 
2642 	if (!sbh)
2643 		return;
2644 	es->s_wtime = cpu_to_le32(get_seconds());
2645 	ext4_free_blocks_count_set(es, ext4_count_free_blocks(sb));
2646 	es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
2647 	BUFFER_TRACE(sbh, "marking dirty");
2648 	mark_buffer_dirty(sbh);
2649 	if (sync)
2650 		sync_dirty_buffer(sbh);
2651 }
2652 
2653 
2654 /*
2655  * Have we just finished recovery?  If so, and if we are mounting (or
2656  * remounting) the filesystem readonly, then we will end up with a
2657  * consistent fs on disk.  Record that fact.
2658  */
2659 static void ext4_mark_recovery_complete(struct super_block * sb,
2660 					struct ext4_super_block * es)
2661 {
2662 	journal_t *journal = EXT4_SB(sb)->s_journal;
2663 
2664 	jbd2_journal_lock_updates(journal);
2665 	jbd2_journal_flush(journal);
2666 	lock_super(sb);
2667 	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
2668 	    sb->s_flags & MS_RDONLY) {
2669 		EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2670 		sb->s_dirt = 0;
2671 		ext4_commit_super(sb, es, 1);
2672 	}
2673 	unlock_super(sb);
2674 	jbd2_journal_unlock_updates(journal);
2675 }
2676 
2677 /*
2678  * If we are mounting (or read-write remounting) a filesystem whose journal
2679  * has recorded an error from a previous lifetime, move that error to the
2680  * main filesystem now.
2681  */
2682 static void ext4_clear_journal_err(struct super_block * sb,
2683 				   struct ext4_super_block * es)
2684 {
2685 	journal_t *journal;
2686 	int j_errno;
2687 	const char *errstr;
2688 
2689 	journal = EXT4_SB(sb)->s_journal;
2690 
2691 	/*
2692 	 * Now check for any error status which may have been recorded in the
2693 	 * journal by a prior ext4_error() or ext4_abort()
2694 	 */
2695 
2696 	j_errno = jbd2_journal_errno(journal);
2697 	if (j_errno) {
2698 		char nbuf[16];
2699 
2700 		errstr = ext4_decode_error(sb, j_errno, nbuf);
2701 		ext4_warning(sb, __FUNCTION__, "Filesystem error recorded "
2702 			     "from previous mount: %s", errstr);
2703 		ext4_warning(sb, __FUNCTION__, "Marking fs in need of "
2704 			     "filesystem check.");
2705 
2706 		EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2707 		es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
2708 		ext4_commit_super (sb, es, 1);
2709 
2710 		jbd2_journal_clear_err(journal);
2711 	}
2712 }
2713 
2714 /*
2715  * Force the running and committing transactions to commit,
2716  * and wait on the commit.
2717  */
2718 int ext4_force_commit(struct super_block *sb)
2719 {
2720 	journal_t *journal;
2721 	int ret;
2722 
2723 	if (sb->s_flags & MS_RDONLY)
2724 		return 0;
2725 
2726 	journal = EXT4_SB(sb)->s_journal;
2727 	sb->s_dirt = 0;
2728 	ret = ext4_journal_force_commit(journal);
2729 	return ret;
2730 }
2731 
2732 /*
2733  * Ext4 always journals updates to the superblock itself, so we don't
2734  * have to propagate any other updates to the superblock on disk at this
2735  * point.  Just start an async writeback to get the buffers on their way
2736  * to the disk.
2737  *
2738  * This implicitly triggers the writebehind on sync().
2739  */
2740 
2741 static void ext4_write_super (struct super_block * sb)
2742 {
2743 	if (mutex_trylock(&sb->s_lock) != 0)
2744 		BUG();
2745 	sb->s_dirt = 0;
2746 }
2747 
2748 static int ext4_sync_fs(struct super_block *sb, int wait)
2749 {
2750 	tid_t target;
2751 
2752 	sb->s_dirt = 0;
2753 	if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
2754 		if (wait)
2755 			jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
2756 	}
2757 	return 0;
2758 }
2759 
2760 /*
2761  * LVM calls this function before a (read-only) snapshot is created.  This
2762  * gives us a chance to flush the journal completely and mark the fs clean.
2763  */
2764 static void ext4_write_super_lockfs(struct super_block *sb)
2765 {
2766 	sb->s_dirt = 0;
2767 
2768 	if (!(sb->s_flags & MS_RDONLY)) {
2769 		journal_t *journal = EXT4_SB(sb)->s_journal;
2770 
2771 		/* Now we set up the journal barrier. */
2772 		jbd2_journal_lock_updates(journal);
2773 		jbd2_journal_flush(journal);
2774 
2775 		/* Journal blocked and flushed, clear needs_recovery flag. */
2776 		EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2777 		ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
2778 	}
2779 }
2780 
2781 /*
2782  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
2783  * flag here, even though the filesystem is not technically dirty yet.
2784  */
2785 static void ext4_unlockfs(struct super_block *sb)
2786 {
2787 	if (!(sb->s_flags & MS_RDONLY)) {
2788 		lock_super(sb);
2789 		/* Reser the needs_recovery flag before the fs is unlocked. */
2790 		EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
2791 		ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
2792 		unlock_super(sb);
2793 		jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
2794 	}
2795 }
2796 
2797 static int ext4_remount (struct super_block * sb, int * flags, char * data)
2798 {
2799 	struct ext4_super_block * es;
2800 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2801 	ext4_fsblk_t n_blocks_count = 0;
2802 	unsigned long old_sb_flags;
2803 	struct ext4_mount_options old_opts;
2804 	int err;
2805 #ifdef CONFIG_QUOTA
2806 	int i;
2807 #endif
2808 
2809 	/* Store the original options */
2810 	old_sb_flags = sb->s_flags;
2811 	old_opts.s_mount_opt = sbi->s_mount_opt;
2812 	old_opts.s_resuid = sbi->s_resuid;
2813 	old_opts.s_resgid = sbi->s_resgid;
2814 	old_opts.s_commit_interval = sbi->s_commit_interval;
2815 #ifdef CONFIG_QUOTA
2816 	old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
2817 	for (i = 0; i < MAXQUOTAS; i++)
2818 		old_opts.s_qf_names[i] = sbi->s_qf_names[i];
2819 #endif
2820 
2821 	/*
2822 	 * Allow the "check" option to be passed as a remount option.
2823 	 */
2824 	if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
2825 		err = -EINVAL;
2826 		goto restore_opts;
2827 	}
2828 
2829 	if (sbi->s_mount_opt & EXT4_MOUNT_ABORT)
2830 		ext4_abort(sb, __FUNCTION__, "Abort forced by user");
2831 
2832 	sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2833 		((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
2834 
2835 	es = sbi->s_es;
2836 
2837 	ext4_init_journal_params(sb, sbi->s_journal);
2838 
2839 	if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
2840 		n_blocks_count > ext4_blocks_count(es)) {
2841 		if (sbi->s_mount_opt & EXT4_MOUNT_ABORT) {
2842 			err = -EROFS;
2843 			goto restore_opts;
2844 		}
2845 
2846 		if (*flags & MS_RDONLY) {
2847 			/*
2848 			 * First of all, the unconditional stuff we have to do
2849 			 * to disable replay of the journal when we next remount
2850 			 */
2851 			sb->s_flags |= MS_RDONLY;
2852 
2853 			/*
2854 			 * OK, test if we are remounting a valid rw partition
2855 			 * readonly, and if so set the rdonly flag and then
2856 			 * mark the partition as valid again.
2857 			 */
2858 			if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
2859 			    (sbi->s_mount_state & EXT4_VALID_FS))
2860 				es->s_state = cpu_to_le16(sbi->s_mount_state);
2861 
2862 			/*
2863 			 * We have to unlock super so that we can wait for
2864 			 * transactions.
2865 			 */
2866 			unlock_super(sb);
2867 			ext4_mark_recovery_complete(sb, es);
2868 			lock_super(sb);
2869 		} else {
2870 			__le32 ret;
2871 			if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
2872 					~EXT4_FEATURE_RO_COMPAT_SUPP))) {
2873 				printk(KERN_WARNING "EXT4-fs: %s: couldn't "
2874 				       "remount RDWR because of unsupported "
2875 				       "optional features (%x).\n",
2876 				       sb->s_id, le32_to_cpu(ret));
2877 				err = -EROFS;
2878 				goto restore_opts;
2879 			}
2880 
2881 			/*
2882 			 * If we have an unprocessed orphan list hanging
2883 			 * around from a previously readonly bdev mount,
2884 			 * require a full umount/remount for now.
2885 			 */
2886 			if (es->s_last_orphan) {
2887 				printk(KERN_WARNING "EXT4-fs: %s: couldn't "
2888 				       "remount RDWR because of unprocessed "
2889 				       "orphan inode list.  Please "
2890 				       "umount/remount instead.\n",
2891 				       sb->s_id);
2892 				err = -EINVAL;
2893 				goto restore_opts;
2894 			}
2895 
2896 			/*
2897 			 * Mounting a RDONLY partition read-write, so reread
2898 			 * and store the current valid flag.  (It may have
2899 			 * been changed by e2fsck since we originally mounted
2900 			 * the partition.)
2901 			 */
2902 			ext4_clear_journal_err(sb, es);
2903 			sbi->s_mount_state = le16_to_cpu(es->s_state);
2904 			if ((err = ext4_group_extend(sb, es, n_blocks_count)))
2905 				goto restore_opts;
2906 			if (!ext4_setup_super (sb, es, 0))
2907 				sb->s_flags &= ~MS_RDONLY;
2908 		}
2909 	}
2910 #ifdef CONFIG_QUOTA
2911 	/* Release old quota file names */
2912 	for (i = 0; i < MAXQUOTAS; i++)
2913 		if (old_opts.s_qf_names[i] &&
2914 		    old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2915 			kfree(old_opts.s_qf_names[i]);
2916 #endif
2917 	return 0;
2918 restore_opts:
2919 	sb->s_flags = old_sb_flags;
2920 	sbi->s_mount_opt = old_opts.s_mount_opt;
2921 	sbi->s_resuid = old_opts.s_resuid;
2922 	sbi->s_resgid = old_opts.s_resgid;
2923 	sbi->s_commit_interval = old_opts.s_commit_interval;
2924 #ifdef CONFIG_QUOTA
2925 	sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
2926 	for (i = 0; i < MAXQUOTAS; i++) {
2927 		if (sbi->s_qf_names[i] &&
2928 		    old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2929 			kfree(sbi->s_qf_names[i]);
2930 		sbi->s_qf_names[i] = old_opts.s_qf_names[i];
2931 	}
2932 #endif
2933 	return err;
2934 }
2935 
2936 static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
2937 {
2938 	struct super_block *sb = dentry->d_sb;
2939 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2940 	struct ext4_super_block *es = sbi->s_es;
2941 	u64 fsid;
2942 
2943 	if (test_opt(sb, MINIX_DF)) {
2944 		sbi->s_overhead_last = 0;
2945 	} else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
2946 		ext4_group_t ngroups = sbi->s_groups_count, i;
2947 		ext4_fsblk_t overhead = 0;
2948 		smp_rmb();
2949 
2950 		/*
2951 		 * Compute the overhead (FS structures).  This is constant
2952 		 * for a given filesystem unless the number of block groups
2953 		 * changes so we cache the previous value until it does.
2954 		 */
2955 
2956 		/*
2957 		 * All of the blocks before first_data_block are
2958 		 * overhead
2959 		 */
2960 		overhead = le32_to_cpu(es->s_first_data_block);
2961 
2962 		/*
2963 		 * Add the overhead attributed to the superblock and
2964 		 * block group descriptors.  If the sparse superblocks
2965 		 * feature is turned on, then not all groups have this.
2966 		 */
2967 		for (i = 0; i < ngroups; i++) {
2968 			overhead += ext4_bg_has_super(sb, i) +
2969 				ext4_bg_num_gdb(sb, i);
2970 			cond_resched();
2971 		}
2972 
2973 		/*
2974 		 * Every block group has an inode bitmap, a block
2975 		 * bitmap, and an inode table.
2976 		 */
2977 		overhead += ngroups * (2 + sbi->s_itb_per_group);
2978 		sbi->s_overhead_last = overhead;
2979 		smp_wmb();
2980 		sbi->s_blocks_last = ext4_blocks_count(es);
2981 	}
2982 
2983 	buf->f_type = EXT4_SUPER_MAGIC;
2984 	buf->f_bsize = sb->s_blocksize;
2985 	buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
2986 	buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter);
2987 	ext4_free_blocks_count_set(es, buf->f_bfree);
2988 	buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
2989 	if (buf->f_bfree < ext4_r_blocks_count(es))
2990 		buf->f_bavail = 0;
2991 	buf->f_files = le32_to_cpu(es->s_inodes_count);
2992 	buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
2993 	es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
2994 	buf->f_namelen = EXT4_NAME_LEN;
2995 	fsid = le64_to_cpup((void *)es->s_uuid) ^
2996 	       le64_to_cpup((void *)es->s_uuid + sizeof(u64));
2997 	buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
2998 	buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
2999 	return 0;
3000 }
3001 
3002 /* Helper function for writing quotas on sync - we need to start transaction before quota file
3003  * is locked for write. Otherwise the are possible deadlocks:
3004  * Process 1                         Process 2
3005  * ext4_create()                     quota_sync()
3006  *   jbd2_journal_start()                   write_dquot()
3007  *   DQUOT_INIT()                        down(dqio_mutex)
3008  *     down(dqio_mutex)                    jbd2_journal_start()
3009  *
3010  */
3011 
3012 #ifdef CONFIG_QUOTA
3013 
3014 static inline struct inode *dquot_to_inode(struct dquot *dquot)
3015 {
3016 	return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
3017 }
3018 
3019 static int ext4_dquot_initialize(struct inode *inode, int type)
3020 {
3021 	handle_t *handle;
3022 	int ret, err;
3023 
3024 	/* We may create quota structure so we need to reserve enough blocks */
3025 	handle = ext4_journal_start(inode, 2*EXT4_QUOTA_INIT_BLOCKS(inode->i_sb));
3026 	if (IS_ERR(handle))
3027 		return PTR_ERR(handle);
3028 	ret = dquot_initialize(inode, type);
3029 	err = ext4_journal_stop(handle);
3030 	if (!ret)
3031 		ret = err;
3032 	return ret;
3033 }
3034 
3035 static int ext4_dquot_drop(struct inode *inode)
3036 {
3037 	handle_t *handle;
3038 	int ret, err;
3039 
3040 	/* We may delete quota structure so we need to reserve enough blocks */
3041 	handle = ext4_journal_start(inode, 2*EXT4_QUOTA_DEL_BLOCKS(inode->i_sb));
3042 	if (IS_ERR(handle))
3043 		return PTR_ERR(handle);
3044 	ret = dquot_drop(inode);
3045 	err = ext4_journal_stop(handle);
3046 	if (!ret)
3047 		ret = err;
3048 	return ret;
3049 }
3050 
3051 static int ext4_write_dquot(struct dquot *dquot)
3052 {
3053 	int ret, err;
3054 	handle_t *handle;
3055 	struct inode *inode;
3056 
3057 	inode = dquot_to_inode(dquot);
3058 	handle = ext4_journal_start(inode,
3059 					EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
3060 	if (IS_ERR(handle))
3061 		return PTR_ERR(handle);
3062 	ret = dquot_commit(dquot);
3063 	err = ext4_journal_stop(handle);
3064 	if (!ret)
3065 		ret = err;
3066 	return ret;
3067 }
3068 
3069 static int ext4_acquire_dquot(struct dquot *dquot)
3070 {
3071 	int ret, err;
3072 	handle_t *handle;
3073 
3074 	handle = ext4_journal_start(dquot_to_inode(dquot),
3075 					EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
3076 	if (IS_ERR(handle))
3077 		return PTR_ERR(handle);
3078 	ret = dquot_acquire(dquot);
3079 	err = ext4_journal_stop(handle);
3080 	if (!ret)
3081 		ret = err;
3082 	return ret;
3083 }
3084 
3085 static int ext4_release_dquot(struct dquot *dquot)
3086 {
3087 	int ret, err;
3088 	handle_t *handle;
3089 
3090 	handle = ext4_journal_start(dquot_to_inode(dquot),
3091 					EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
3092 	if (IS_ERR(handle)) {
3093 		/* Release dquot anyway to avoid endless cycle in dqput() */
3094 		dquot_release(dquot);
3095 		return PTR_ERR(handle);
3096 	}
3097 	ret = dquot_release(dquot);
3098 	err = ext4_journal_stop(handle);
3099 	if (!ret)
3100 		ret = err;
3101 	return ret;
3102 }
3103 
3104 static int ext4_mark_dquot_dirty(struct dquot *dquot)
3105 {
3106 	/* Are we journalling quotas? */
3107 	if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
3108 	    EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
3109 		dquot_mark_dquot_dirty(dquot);
3110 		return ext4_write_dquot(dquot);
3111 	} else {
3112 		return dquot_mark_dquot_dirty(dquot);
3113 	}
3114 }
3115 
3116 static int ext4_write_info(struct super_block *sb, int type)
3117 {
3118 	int ret, err;
3119 	handle_t *handle;
3120 
3121 	/* Data block + inode block */
3122 	handle = ext4_journal_start(sb->s_root->d_inode, 2);
3123 	if (IS_ERR(handle))
3124 		return PTR_ERR(handle);
3125 	ret = dquot_commit_info(sb, type);
3126 	err = ext4_journal_stop(handle);
3127 	if (!ret)
3128 		ret = err;
3129 	return ret;
3130 }
3131 
3132 /*
3133  * Turn on quotas during mount time - we need to find
3134  * the quota file and such...
3135  */
3136 static int ext4_quota_on_mount(struct super_block *sb, int type)
3137 {
3138 	return vfs_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type],
3139 			EXT4_SB(sb)->s_jquota_fmt, type);
3140 }
3141 
3142 /*
3143  * Standard function to be called on quota_on
3144  */
3145 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
3146 			 char *path)
3147 {
3148 	int err;
3149 	struct nameidata nd;
3150 
3151 	if (!test_opt(sb, QUOTA))
3152 		return -EINVAL;
3153 	/* Not journalling quota? */
3154 	if (!EXT4_SB(sb)->s_qf_names[USRQUOTA] &&
3155 	    !EXT4_SB(sb)->s_qf_names[GRPQUOTA])
3156 		return vfs_quota_on(sb, type, format_id, path);
3157 	err = path_lookup(path, LOOKUP_FOLLOW, &nd);
3158 	if (err)
3159 		return err;
3160 	/* Quotafile not on the same filesystem? */
3161 	if (nd.path.mnt->mnt_sb != sb) {
3162 		path_put(&nd.path);
3163 		return -EXDEV;
3164 	}
3165 	/* Quotafile not of fs root? */
3166 	if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)
3167 		printk(KERN_WARNING
3168 			"EXT4-fs: Quota file not on filesystem root. "
3169 			"Journalled quota will not work.\n");
3170 	path_put(&nd.path);
3171 	return vfs_quota_on(sb, type, format_id, path);
3172 }
3173 
3174 /* Read data from quotafile - avoid pagecache and such because we cannot afford
3175  * acquiring the locks... As quota files are never truncated and quota code
3176  * itself serializes the operations (and noone else should touch the files)
3177  * we don't have to be afraid of races */
3178 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
3179 			       size_t len, loff_t off)
3180 {
3181 	struct inode *inode = sb_dqopt(sb)->files[type];
3182 	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
3183 	int err = 0;
3184 	int offset = off & (sb->s_blocksize - 1);
3185 	int tocopy;
3186 	size_t toread;
3187 	struct buffer_head *bh;
3188 	loff_t i_size = i_size_read(inode);
3189 
3190 	if (off > i_size)
3191 		return 0;
3192 	if (off+len > i_size)
3193 		len = i_size-off;
3194 	toread = len;
3195 	while (toread > 0) {
3196 		tocopy = sb->s_blocksize - offset < toread ?
3197 				sb->s_blocksize - offset : toread;
3198 		bh = ext4_bread(NULL, inode, blk, 0, &err);
3199 		if (err)
3200 			return err;
3201 		if (!bh)	/* A hole? */
3202 			memset(data, 0, tocopy);
3203 		else
3204 			memcpy(data, bh->b_data+offset, tocopy);
3205 		brelse(bh);
3206 		offset = 0;
3207 		toread -= tocopy;
3208 		data += tocopy;
3209 		blk++;
3210 	}
3211 	return len;
3212 }
3213 
3214 /* Write to quotafile (we know the transaction is already started and has
3215  * enough credits) */
3216 static ssize_t ext4_quota_write(struct super_block *sb, int type,
3217 				const char *data, size_t len, loff_t off)
3218 {
3219 	struct inode *inode = sb_dqopt(sb)->files[type];
3220 	ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
3221 	int err = 0;
3222 	int offset = off & (sb->s_blocksize - 1);
3223 	int tocopy;
3224 	int journal_quota = EXT4_SB(sb)->s_qf_names[type] != NULL;
3225 	size_t towrite = len;
3226 	struct buffer_head *bh;
3227 	handle_t *handle = journal_current_handle();
3228 
3229 	if (!handle) {
3230 		printk(KERN_WARNING "EXT4-fs: Quota write (off=%Lu, len=%Lu)"
3231 			" cancelled because transaction is not started.\n",
3232 			(unsigned long long)off, (unsigned long long)len);
3233 		return -EIO;
3234 	}
3235 	mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
3236 	while (towrite > 0) {
3237 		tocopy = sb->s_blocksize - offset < towrite ?
3238 				sb->s_blocksize - offset : towrite;
3239 		bh = ext4_bread(handle, inode, blk, 1, &err);
3240 		if (!bh)
3241 			goto out;
3242 		if (journal_quota) {
3243 			err = ext4_journal_get_write_access(handle, bh);
3244 			if (err) {
3245 				brelse(bh);
3246 				goto out;
3247 			}
3248 		}
3249 		lock_buffer(bh);
3250 		memcpy(bh->b_data+offset, data, tocopy);
3251 		flush_dcache_page(bh->b_page);
3252 		unlock_buffer(bh);
3253 		if (journal_quota)
3254 			err = ext4_journal_dirty_metadata(handle, bh);
3255 		else {
3256 			/* Always do at least ordered writes for quotas */
3257 			err = ext4_journal_dirty_data(handle, bh);
3258 			mark_buffer_dirty(bh);
3259 		}
3260 		brelse(bh);
3261 		if (err)
3262 			goto out;
3263 		offset = 0;
3264 		towrite -= tocopy;
3265 		data += tocopy;
3266 		blk++;
3267 	}
3268 out:
3269 	if (len == towrite)
3270 		return err;
3271 	if (inode->i_size < off+len-towrite) {
3272 		i_size_write(inode, off+len-towrite);
3273 		EXT4_I(inode)->i_disksize = inode->i_size;
3274 	}
3275 	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
3276 	ext4_mark_inode_dirty(handle, inode);
3277 	mutex_unlock(&inode->i_mutex);
3278 	return len - towrite;
3279 }
3280 
3281 #endif
3282 
3283 static int ext4_get_sb(struct file_system_type *fs_type,
3284 	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
3285 {
3286 	return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
3287 }
3288 
3289 static struct file_system_type ext4dev_fs_type = {
3290 	.owner		= THIS_MODULE,
3291 	.name		= "ext4dev",
3292 	.get_sb		= ext4_get_sb,
3293 	.kill_sb	= kill_block_super,
3294 	.fs_flags	= FS_REQUIRES_DEV,
3295 };
3296 
3297 static int __init init_ext4_fs(void)
3298 {
3299 	int err;
3300 
3301 	err = init_ext4_mballoc();
3302 	if (err)
3303 		return err;
3304 
3305 	err = init_ext4_xattr();
3306 	if (err)
3307 		goto out2;
3308 	err = init_inodecache();
3309 	if (err)
3310 		goto out1;
3311 	err = register_filesystem(&ext4dev_fs_type);
3312 	if (err)
3313 		goto out;
3314 	return 0;
3315 out:
3316 	destroy_inodecache();
3317 out1:
3318 	exit_ext4_xattr();
3319 out2:
3320 	exit_ext4_mballoc();
3321 	return err;
3322 }
3323 
3324 static void __exit exit_ext4_fs(void)
3325 {
3326 	unregister_filesystem(&ext4dev_fs_type);
3327 	destroy_inodecache();
3328 	exit_ext4_xattr();
3329 	exit_ext4_mballoc();
3330 }
3331 
3332 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
3333 MODULE_DESCRIPTION("Fourth Extended Filesystem with extents");
3334 MODULE_LICENSE("GPL");
3335 module_init(init_ext4_fs)
3336 module_exit(exit_ext4_fs)
3337