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