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