[PATCH] VFS: Permit filesystem to override root dentry on mount
[linux-2.6.git] / fs / ext3 / super.c
1 /*
2  *  linux/fs/ext3/super.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  *  from
10  *
11  *  linux/fs/minix/inode.c
12  *
13  *  Copyright (C) 1991, 1992  Linus Torvalds
14  *
15  *  Big-endian to little-endian byte-swapping/bitmaps by
16  *        David S. Miller (davem@caip.rutgers.edu), 1995
17  */
18
19 #include <linux/config.h>
20 #include <linux/module.h>
21 #include <linux/string.h>
22 #include <linux/fs.h>
23 #include <linux/time.h>
24 #include <linux/jbd.h>
25 #include <linux/ext3_fs.h>
26 #include <linux/ext3_jbd.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/blkdev.h>
30 #include <linux/parser.h>
31 #include <linux/smp_lock.h>
32 #include <linux/buffer_head.h>
33 #include <linux/vfs.h>
34 #include <linux/random.h>
35 #include <linux/mount.h>
36 #include <linux/namei.h>
37 #include <linux/quotaops.h>
38 #include <linux/seq_file.h>
39
40 #include <asm/uaccess.h>
41
42 #include "xattr.h"
43 #include "acl.h"
44 #include "namei.h"
45
46 static int ext3_load_journal(struct super_block *, struct ext3_super_block *,
47                              unsigned long journal_devnum);
48 static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
49                                int);
50 static void ext3_commit_super (struct super_block * sb,
51                                struct ext3_super_block * es,
52                                int sync);
53 static void ext3_mark_recovery_complete(struct super_block * sb,
54                                         struct ext3_super_block * es);
55 static void ext3_clear_journal_err(struct super_block * sb,
56                                    struct ext3_super_block * es);
57 static int ext3_sync_fs(struct super_block *sb, int wait);
58 static const char *ext3_decode_error(struct super_block * sb, int errno,
59                                      char nbuf[16]);
60 static int ext3_remount (struct super_block * sb, int * flags, char * data);
61 static int ext3_statfs (struct super_block * sb, struct kstatfs * buf);
62 static void ext3_unlockfs(struct super_block *sb);
63 static void ext3_write_super (struct super_block * sb);
64 static void ext3_write_super_lockfs(struct super_block *sb);
65
66 /* 
67  * Wrappers for journal_start/end.
68  *
69  * The only special thing we need to do here is to make sure that all
70  * journal_end calls result in the superblock being marked dirty, so
71  * that sync() will call the filesystem's write_super callback if
72  * appropriate. 
73  */
74 handle_t *ext3_journal_start_sb(struct super_block *sb, int nblocks)
75 {
76         journal_t *journal;
77
78         if (sb->s_flags & MS_RDONLY)
79                 return ERR_PTR(-EROFS);
80
81         /* Special case here: if the journal has aborted behind our
82          * backs (eg. EIO in the commit thread), then we still need to
83          * take the FS itself readonly cleanly. */
84         journal = EXT3_SB(sb)->s_journal;
85         if (is_journal_aborted(journal)) {
86                 ext3_abort(sb, __FUNCTION__,
87                            "Detected aborted journal");
88                 return ERR_PTR(-EROFS);
89         }
90
91         return journal_start(journal, nblocks);
92 }
93
94 /* 
95  * The only special thing we need to do here is to make sure that all
96  * journal_stop calls result in the superblock being marked dirty, so
97  * that sync() will call the filesystem's write_super callback if
98  * appropriate. 
99  */
100 int __ext3_journal_stop(const char *where, handle_t *handle)
101 {
102         struct super_block *sb;
103         int err;
104         int rc;
105
106         sb = handle->h_transaction->t_journal->j_private;
107         err = handle->h_err;
108         rc = journal_stop(handle);
109
110         if (!err)
111                 err = rc;
112         if (err)
113                 __ext3_std_error(sb, where, err);
114         return err;
115 }
116
117 void ext3_journal_abort_handle(const char *caller, const char *err_fn,
118                 struct buffer_head *bh, handle_t *handle, int err)
119 {
120         char nbuf[16];
121         const char *errstr = ext3_decode_error(NULL, err, nbuf);
122
123         if (bh)
124                 BUFFER_TRACE(bh, "abort");
125
126         if (!handle->h_err)
127                 handle->h_err = err;
128
129         if (is_handle_aborted(handle))
130                 return;
131
132         printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
133                caller, errstr, err_fn);
134
135         journal_abort_handle(handle);
136 }
137
138 /* Deal with the reporting of failure conditions on a filesystem such as
139  * inconsistencies detected or read IO failures.
140  *
141  * On ext2, we can store the error state of the filesystem in the
142  * superblock.  That is not possible on ext3, because we may have other
143  * write ordering constraints on the superblock which prevent us from
144  * writing it out straight away; and given that the journal is about to
145  * be aborted, we can't rely on the current, or future, transactions to
146  * write out the superblock safely.
147  *
148  * We'll just use the journal_abort() error code to record an error in
149  * the journal instead.  On recovery, the journal will compain about
150  * that error until we've noted it down and cleared it.
151  */
152
153 static void ext3_handle_error(struct super_block *sb)
154 {
155         struct ext3_super_block *es = EXT3_SB(sb)->s_es;
156
157         EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
158         es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
159
160         if (sb->s_flags & MS_RDONLY)
161                 return;
162
163         if (test_opt (sb, ERRORS_RO)) {
164                 printk (KERN_CRIT "Remounting filesystem read-only\n");
165                 sb->s_flags |= MS_RDONLY;
166         } else {
167                 journal_t *journal = EXT3_SB(sb)->s_journal;
168
169                 EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
170                 if (journal)
171                         journal_abort(journal, -EIO);
172         }
173         if (test_opt(sb, ERRORS_PANIC))
174                 panic("EXT3-fs (device %s): panic forced after error\n",
175                         sb->s_id);
176         ext3_commit_super(sb, es, 1);
177 }
178
179 void ext3_error (struct super_block * sb, const char * function,
180                  const char * fmt, ...)
181 {
182         va_list args;
183
184         va_start(args, fmt);
185         printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
186         vprintk(fmt, args);
187         printk("\n");
188         va_end(args);
189
190         ext3_handle_error(sb);
191 }
192
193 static const char *ext3_decode_error(struct super_block * sb, int errno,
194                                      char nbuf[16])
195 {
196         char *errstr = NULL;
197
198         switch (errno) {
199         case -EIO:
200                 errstr = "IO failure";
201                 break;
202         case -ENOMEM:
203                 errstr = "Out of memory";
204                 break;
205         case -EROFS:
206                 if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
207                         errstr = "Journal has aborted";
208                 else
209                         errstr = "Readonly filesystem";
210                 break;
211         default:
212                 /* If the caller passed in an extra buffer for unknown
213                  * errors, textualise them now.  Else we just return
214                  * NULL. */
215                 if (nbuf) {
216                         /* Check for truncated error codes... */
217                         if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
218                                 errstr = nbuf;
219                 }
220                 break;
221         }
222
223         return errstr;
224 }
225
226 /* __ext3_std_error decodes expected errors from journaling functions
227  * automatically and invokes the appropriate error response.  */
228
229 void __ext3_std_error (struct super_block * sb, const char * function,
230                        int errno)
231 {
232         char nbuf[16];
233         const char *errstr;
234
235         /* Special case: if the error is EROFS, and we're not already
236          * inside a transaction, then there's really no point in logging
237          * an error. */
238         if (errno == -EROFS && journal_current_handle() == NULL &&
239             (sb->s_flags & MS_RDONLY))
240                 return;
241
242         errstr = ext3_decode_error(sb, errno, nbuf);
243         printk (KERN_CRIT "EXT3-fs error (device %s) in %s: %s\n",
244                 sb->s_id, function, errstr);
245
246         ext3_handle_error(sb);
247 }
248
249 /*
250  * ext3_abort is a much stronger failure handler than ext3_error.  The
251  * abort function may be used to deal with unrecoverable failures such
252  * as journal IO errors or ENOMEM at a critical moment in log management.
253  *
254  * We unconditionally force the filesystem into an ABORT|READONLY state,
255  * unless the error response on the fs has been set to panic in which
256  * case we take the easy way out and panic immediately.
257  */
258
259 void ext3_abort (struct super_block * sb, const char * function,
260                  const char * fmt, ...)
261 {
262         va_list args;
263
264         printk (KERN_CRIT "ext3_abort called.\n");
265
266         va_start(args, fmt);
267         printk(KERN_CRIT "EXT3-fs error (device %s): %s: ",sb->s_id, function);
268         vprintk(fmt, args);
269         printk("\n");
270         va_end(args);
271
272         if (test_opt(sb, ERRORS_PANIC))
273                 panic("EXT3-fs panic from previous error\n");
274
275         if (sb->s_flags & MS_RDONLY)
276                 return;
277
278         printk(KERN_CRIT "Remounting filesystem read-only\n");
279         EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
280         sb->s_flags |= MS_RDONLY;
281         EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
282         journal_abort(EXT3_SB(sb)->s_journal, -EIO);
283 }
284
285 void ext3_warning (struct super_block * sb, const char * function,
286                    const char * fmt, ...)
287 {
288         va_list args;
289
290         va_start(args, fmt);
291         printk(KERN_WARNING "EXT3-fs warning (device %s): %s: ",
292                sb->s_id, function);
293         vprintk(fmt, args);
294         printk("\n");
295         va_end(args);
296 }
297
298 void ext3_update_dynamic_rev(struct super_block *sb)
299 {
300         struct ext3_super_block *es = EXT3_SB(sb)->s_es;
301
302         if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
303                 return;
304
305         ext3_warning(sb, __FUNCTION__,
306                      "updating to rev %d because of new feature flag, "
307                      "running e2fsck is recommended",
308                      EXT3_DYNAMIC_REV);
309
310         es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
311         es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
312         es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
313         /* leave es->s_feature_*compat flags alone */
314         /* es->s_uuid will be set by e2fsck if empty */
315
316         /*
317          * The rest of the superblock fields should be zero, and if not it
318          * means they are likely already in use, so leave them alone.  We
319          * can leave it up to e2fsck to clean up any inconsistencies there.
320          */
321 }
322
323 /*
324  * Open the external journal device
325  */
326 static struct block_device *ext3_blkdev_get(dev_t dev)
327 {
328         struct block_device *bdev;
329         char b[BDEVNAME_SIZE];
330
331         bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
332         if (IS_ERR(bdev))
333                 goto fail;
334         return bdev;
335
336 fail:
337         printk(KERN_ERR "EXT3: failed to open journal device %s: %ld\n",
338                         __bdevname(dev, b), PTR_ERR(bdev));
339         return NULL;
340 }
341
342 /*
343  * Release the journal device
344  */
345 static int ext3_blkdev_put(struct block_device *bdev)
346 {
347         bd_release(bdev);
348         return blkdev_put(bdev);
349 }
350
351 static int ext3_blkdev_remove(struct ext3_sb_info *sbi)
352 {
353         struct block_device *bdev;
354         int ret = -ENODEV;
355
356         bdev = sbi->journal_bdev;
357         if (bdev) {
358                 ret = ext3_blkdev_put(bdev);
359                 sbi->journal_bdev = NULL;
360         }
361         return ret;
362 }
363
364 static inline struct inode *orphan_list_entry(struct list_head *l)
365 {
366         return &list_entry(l, struct ext3_inode_info, i_orphan)->vfs_inode;
367 }
368
369 static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
370 {
371         struct list_head *l;
372
373         printk(KERN_ERR "sb orphan head is %d\n", 
374                le32_to_cpu(sbi->s_es->s_last_orphan));
375
376         printk(KERN_ERR "sb_info orphan list:\n");
377         list_for_each(l, &sbi->s_orphan) {
378                 struct inode *inode = orphan_list_entry(l);
379                 printk(KERN_ERR "  "
380                        "inode %s:%ld at %p: mode %o, nlink %d, next %d\n",
381                        inode->i_sb->s_id, inode->i_ino, inode,
382                        inode->i_mode, inode->i_nlink, 
383                        NEXT_ORPHAN(inode));
384         }
385 }
386
387 static void ext3_put_super (struct super_block * sb)
388 {
389         struct ext3_sb_info *sbi = EXT3_SB(sb);
390         struct ext3_super_block *es = sbi->s_es;
391         int i;
392
393         ext3_xattr_put_super(sb);
394         journal_destroy(sbi->s_journal);
395         if (!(sb->s_flags & MS_RDONLY)) {
396                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
397                 es->s_state = cpu_to_le16(sbi->s_mount_state);
398                 BUFFER_TRACE(sbi->s_sbh, "marking dirty");
399                 mark_buffer_dirty(sbi->s_sbh);
400                 ext3_commit_super(sb, es, 1);
401         }
402
403         for (i = 0; i < sbi->s_gdb_count; i++)
404                 brelse(sbi->s_group_desc[i]);
405         kfree(sbi->s_group_desc);
406         percpu_counter_destroy(&sbi->s_freeblocks_counter);
407         percpu_counter_destroy(&sbi->s_freeinodes_counter);
408         percpu_counter_destroy(&sbi->s_dirs_counter);
409         brelse(sbi->s_sbh);
410 #ifdef CONFIG_QUOTA
411         for (i = 0; i < MAXQUOTAS; i++)
412                 kfree(sbi->s_qf_names[i]);
413 #endif
414
415         /* Debugging code just in case the in-memory inode orphan list
416          * isn't empty.  The on-disk one can be non-empty if we've
417          * detected an error and taken the fs readonly, but the
418          * in-memory list had better be clean by this point. */
419         if (!list_empty(&sbi->s_orphan))
420                 dump_orphan_list(sb, sbi);
421         J_ASSERT(list_empty(&sbi->s_orphan));
422
423         invalidate_bdev(sb->s_bdev, 0);
424         if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
425                 /*
426                  * Invalidate the journal device's buffers.  We don't want them
427                  * floating about in memory - the physical journal device may
428                  * hotswapped, and it breaks the `ro-after' testing code.
429                  */
430                 sync_blockdev(sbi->journal_bdev);
431                 invalidate_bdev(sbi->journal_bdev, 0);
432                 ext3_blkdev_remove(sbi);
433         }
434         sb->s_fs_info = NULL;
435         kfree(sbi);
436         return;
437 }
438
439 static kmem_cache_t *ext3_inode_cachep;
440
441 /*
442  * Called inside transaction, so use GFP_NOFS
443  */
444 static struct inode *ext3_alloc_inode(struct super_block *sb)
445 {
446         struct ext3_inode_info *ei;
447
448         ei = kmem_cache_alloc(ext3_inode_cachep, SLAB_NOFS);
449         if (!ei)
450                 return NULL;
451 #ifdef CONFIG_EXT3_FS_POSIX_ACL
452         ei->i_acl = EXT3_ACL_NOT_CACHED;
453         ei->i_default_acl = EXT3_ACL_NOT_CACHED;
454 #endif
455         ei->i_block_alloc_info = NULL;
456         ei->vfs_inode.i_version = 1;
457         return &ei->vfs_inode;
458 }
459
460 static void ext3_destroy_inode(struct inode *inode)
461 {
462         kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
463 }
464
465 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
466 {
467         struct ext3_inode_info *ei = (struct ext3_inode_info *) foo;
468
469         if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
470             SLAB_CTOR_CONSTRUCTOR) {
471                 INIT_LIST_HEAD(&ei->i_orphan);
472 #ifdef CONFIG_EXT3_FS_XATTR
473                 init_rwsem(&ei->xattr_sem);
474 #endif
475                 mutex_init(&ei->truncate_mutex);
476                 inode_init_once(&ei->vfs_inode);
477         }
478 }
479  
480 static int init_inodecache(void)
481 {
482         ext3_inode_cachep = kmem_cache_create("ext3_inode_cache",
483                                              sizeof(struct ext3_inode_info),
484                                              0, (SLAB_RECLAIM_ACCOUNT|
485                                                 SLAB_MEM_SPREAD),
486                                              init_once, NULL);
487         if (ext3_inode_cachep == NULL)
488                 return -ENOMEM;
489         return 0;
490 }
491
492 static void destroy_inodecache(void)
493 {
494         if (kmem_cache_destroy(ext3_inode_cachep))
495                 printk(KERN_INFO "ext3_inode_cache: not all structures were freed\n");
496 }
497
498 static void ext3_clear_inode(struct inode *inode)
499 {
500         struct ext3_block_alloc_info *rsv = EXT3_I(inode)->i_block_alloc_info;
501 #ifdef CONFIG_EXT3_FS_POSIX_ACL
502        if (EXT3_I(inode)->i_acl &&
503            EXT3_I(inode)->i_acl != EXT3_ACL_NOT_CACHED) {
504                posix_acl_release(EXT3_I(inode)->i_acl);
505                EXT3_I(inode)->i_acl = EXT3_ACL_NOT_CACHED;
506        }
507        if (EXT3_I(inode)->i_default_acl &&
508            EXT3_I(inode)->i_default_acl != EXT3_ACL_NOT_CACHED) {
509                posix_acl_release(EXT3_I(inode)->i_default_acl);
510                EXT3_I(inode)->i_default_acl = EXT3_ACL_NOT_CACHED;
511        }
512 #endif
513         ext3_discard_reservation(inode);
514         EXT3_I(inode)->i_block_alloc_info = NULL;
515         kfree(rsv);
516 }
517
518 static inline void ext3_show_quota_options(struct seq_file *seq, struct super_block *sb)
519 {
520 #if defined(CONFIG_QUOTA)
521         struct ext3_sb_info *sbi = EXT3_SB(sb);
522
523         if (sbi->s_jquota_fmt)
524                 seq_printf(seq, ",jqfmt=%s",
525                 (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold": "vfsv0");
526
527         if (sbi->s_qf_names[USRQUOTA])
528                 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
529
530         if (sbi->s_qf_names[GRPQUOTA])
531                 seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
532
533         if (sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA)
534                 seq_puts(seq, ",usrquota");
535
536         if (sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA)
537                 seq_puts(seq, ",grpquota");
538 #endif
539 }
540
541 static int ext3_show_options(struct seq_file *seq, struct vfsmount *vfs)
542 {
543         struct super_block *sb = vfs->mnt_sb;
544
545         if (test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA)
546                 seq_puts(seq, ",data=journal");
547         else if (test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA)
548                 seq_puts(seq, ",data=ordered");
549         else if (test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)
550                 seq_puts(seq, ",data=writeback");
551
552         ext3_show_quota_options(seq, sb);
553
554         return 0;
555 }
556
557 #ifdef CONFIG_QUOTA
558 #define QTYPE2NAME(t) ((t)==USRQUOTA?"user":"group")
559 #define QTYPE2MOPT(on, t) ((t)==USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
560
561 static int ext3_dquot_initialize(struct inode *inode, int type);
562 static int ext3_dquot_drop(struct inode *inode);
563 static int ext3_write_dquot(struct dquot *dquot);
564 static int ext3_acquire_dquot(struct dquot *dquot);
565 static int ext3_release_dquot(struct dquot *dquot);
566 static int ext3_mark_dquot_dirty(struct dquot *dquot);
567 static int ext3_write_info(struct super_block *sb, int type);
568 static int ext3_quota_on(struct super_block *sb, int type, int format_id, char *path);
569 static int ext3_quota_on_mount(struct super_block *sb, int type);
570 static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
571                                size_t len, loff_t off);
572 static ssize_t ext3_quota_write(struct super_block *sb, int type,
573                                 const char *data, size_t len, loff_t off);
574
575 static struct dquot_operations ext3_quota_operations = {
576         .initialize     = ext3_dquot_initialize,
577         .drop           = ext3_dquot_drop,
578         .alloc_space    = dquot_alloc_space,
579         .alloc_inode    = dquot_alloc_inode,
580         .free_space     = dquot_free_space,
581         .free_inode     = dquot_free_inode,
582         .transfer       = dquot_transfer,
583         .write_dquot    = ext3_write_dquot,
584         .acquire_dquot  = ext3_acquire_dquot,
585         .release_dquot  = ext3_release_dquot,
586         .mark_dirty     = ext3_mark_dquot_dirty,
587         .write_info     = ext3_write_info
588 };
589
590 static struct quotactl_ops ext3_qctl_operations = {
591         .quota_on       = ext3_quota_on,
592         .quota_off      = vfs_quota_off,
593         .quota_sync     = vfs_quota_sync,
594         .get_info       = vfs_get_dqinfo,
595         .set_info       = vfs_set_dqinfo,
596         .get_dqblk      = vfs_get_dqblk,
597         .set_dqblk      = vfs_set_dqblk
598 };
599 #endif
600
601 static struct super_operations ext3_sops = {
602         .alloc_inode    = ext3_alloc_inode,
603         .destroy_inode  = ext3_destroy_inode,
604         .read_inode     = ext3_read_inode,
605         .write_inode    = ext3_write_inode,
606         .dirty_inode    = ext3_dirty_inode,
607         .delete_inode   = ext3_delete_inode,
608         .put_super      = ext3_put_super,
609         .write_super    = ext3_write_super,
610         .sync_fs        = ext3_sync_fs,
611         .write_super_lockfs = ext3_write_super_lockfs,
612         .unlockfs       = ext3_unlockfs,
613         .statfs         = ext3_statfs,
614         .remount_fs     = ext3_remount,
615         .clear_inode    = ext3_clear_inode,
616         .show_options   = ext3_show_options,
617 #ifdef CONFIG_QUOTA
618         .quota_read     = ext3_quota_read,
619         .quota_write    = ext3_quota_write,
620 #endif
621 };
622
623 static struct export_operations ext3_export_ops = {
624         .get_parent = ext3_get_parent,
625 };
626
627 enum {
628         Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
629         Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
630         Opt_nouid32, Opt_nocheck, Opt_debug, Opt_oldalloc, Opt_orlov,
631         Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
632         Opt_reservation, Opt_noreservation, Opt_noload, Opt_nobh,
633         Opt_commit, Opt_journal_update, Opt_journal_inum, Opt_journal_dev,
634         Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
635         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
636         Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
637         Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
638         Opt_grpquota
639 };
640
641 static match_table_t tokens = {
642         {Opt_bsd_df, "bsddf"},
643         {Opt_minix_df, "minixdf"},
644         {Opt_grpid, "grpid"},
645         {Opt_grpid, "bsdgroups"},
646         {Opt_nogrpid, "nogrpid"},
647         {Opt_nogrpid, "sysvgroups"},
648         {Opt_resgid, "resgid=%u"},
649         {Opt_resuid, "resuid=%u"},
650         {Opt_sb, "sb=%u"},
651         {Opt_err_cont, "errors=continue"},
652         {Opt_err_panic, "errors=panic"},
653         {Opt_err_ro, "errors=remount-ro"},
654         {Opt_nouid32, "nouid32"},
655         {Opt_nocheck, "nocheck"},
656         {Opt_nocheck, "check=none"},
657         {Opt_debug, "debug"},
658         {Opt_oldalloc, "oldalloc"},
659         {Opt_orlov, "orlov"},
660         {Opt_user_xattr, "user_xattr"},
661         {Opt_nouser_xattr, "nouser_xattr"},
662         {Opt_acl, "acl"},
663         {Opt_noacl, "noacl"},
664         {Opt_reservation, "reservation"},
665         {Opt_noreservation, "noreservation"},
666         {Opt_noload, "noload"},
667         {Opt_nobh, "nobh"},
668         {Opt_commit, "commit=%u"},
669         {Opt_journal_update, "journal=update"},
670         {Opt_journal_inum, "journal=%u"},
671         {Opt_journal_dev, "journal_dev=%u"},
672         {Opt_abort, "abort"},
673         {Opt_data_journal, "data=journal"},
674         {Opt_data_ordered, "data=ordered"},
675         {Opt_data_writeback, "data=writeback"},
676         {Opt_offusrjquota, "usrjquota="},
677         {Opt_usrjquota, "usrjquota=%s"},
678         {Opt_offgrpjquota, "grpjquota="},
679         {Opt_grpjquota, "grpjquota=%s"},
680         {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
681         {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
682         {Opt_grpquota, "grpquota"},
683         {Opt_noquota, "noquota"},
684         {Opt_quota, "quota"},
685         {Opt_usrquota, "usrquota"},
686         {Opt_barrier, "barrier=%u"},
687         {Opt_err, NULL},
688         {Opt_resize, "resize"},
689 };
690
691 static unsigned long get_sb_block(void **data)
692 {
693         unsigned long   sb_block;
694         char            *options = (char *) *data;
695
696         if (!options || strncmp(options, "sb=", 3) != 0)
697                 return 1;       /* Default location */
698         options += 3;
699         sb_block = simple_strtoul(options, &options, 0);
700         if (*options && *options != ',') {
701                 printk("EXT3-fs: Invalid sb specification: %s\n",
702                        (char *) *data);
703                 return 1;
704         }
705         if (*options == ',')
706                 options++;
707         *data = (void *) options;
708         return sb_block;
709 }
710
711 static int parse_options (char *options, struct super_block *sb,
712                           unsigned long *inum, unsigned long *journal_devnum,
713                           unsigned long *n_blocks_count, int is_remount)
714 {
715         struct ext3_sb_info *sbi = EXT3_SB(sb);
716         char * p;
717         substring_t args[MAX_OPT_ARGS];
718         int data_opt = 0;
719         int option;
720 #ifdef CONFIG_QUOTA
721         int qtype;
722         char *qname;
723 #endif
724
725         if (!options)
726                 return 1;
727
728         while ((p = strsep (&options, ",")) != NULL) {
729                 int token;
730                 if (!*p)
731                         continue;
732
733                 token = match_token(p, tokens, args);
734                 switch (token) {
735                 case Opt_bsd_df:
736                         clear_opt (sbi->s_mount_opt, MINIX_DF);
737                         break;
738                 case Opt_minix_df:
739                         set_opt (sbi->s_mount_opt, MINIX_DF);
740                         break;
741                 case Opt_grpid:
742                         set_opt (sbi->s_mount_opt, GRPID);
743                         break;
744                 case Opt_nogrpid:
745                         clear_opt (sbi->s_mount_opt, GRPID);
746                         break;
747                 case Opt_resuid:
748                         if (match_int(&args[0], &option))
749                                 return 0;
750                         sbi->s_resuid = option;
751                         break;
752                 case Opt_resgid:
753                         if (match_int(&args[0], &option))
754                                 return 0;
755                         sbi->s_resgid = option;
756                         break;
757                 case Opt_sb:
758                         /* handled by get_sb_block() instead of here */
759                         /* *sb_block = match_int(&args[0]); */
760                         break;
761                 case Opt_err_panic:
762                         clear_opt (sbi->s_mount_opt, ERRORS_CONT);
763                         clear_opt (sbi->s_mount_opt, ERRORS_RO);
764                         set_opt (sbi->s_mount_opt, ERRORS_PANIC);
765                         break;
766                 case Opt_err_ro:
767                         clear_opt (sbi->s_mount_opt, ERRORS_CONT);
768                         clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
769                         set_opt (sbi->s_mount_opt, ERRORS_RO);
770                         break;
771                 case Opt_err_cont:
772                         clear_opt (sbi->s_mount_opt, ERRORS_RO);
773                         clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
774                         set_opt (sbi->s_mount_opt, ERRORS_CONT);
775                         break;
776                 case Opt_nouid32:
777                         set_opt (sbi->s_mount_opt, NO_UID32);
778                         break;
779                 case Opt_nocheck:
780                         clear_opt (sbi->s_mount_opt, CHECK);
781                         break;
782                 case Opt_debug:
783                         set_opt (sbi->s_mount_opt, DEBUG);
784                         break;
785                 case Opt_oldalloc:
786                         set_opt (sbi->s_mount_opt, OLDALLOC);
787                         break;
788                 case Opt_orlov:
789                         clear_opt (sbi->s_mount_opt, OLDALLOC);
790                         break;
791 #ifdef CONFIG_EXT3_FS_XATTR
792                 case Opt_user_xattr:
793                         set_opt (sbi->s_mount_opt, XATTR_USER);
794                         break;
795                 case Opt_nouser_xattr:
796                         clear_opt (sbi->s_mount_opt, XATTR_USER);
797                         break;
798 #else
799                 case Opt_user_xattr:
800                 case Opt_nouser_xattr:
801                         printk("EXT3 (no)user_xattr options not supported\n");
802                         break;
803 #endif
804 #ifdef CONFIG_EXT3_FS_POSIX_ACL
805                 case Opt_acl:
806                         set_opt(sbi->s_mount_opt, POSIX_ACL);
807                         break;
808                 case Opt_noacl:
809                         clear_opt(sbi->s_mount_opt, POSIX_ACL);
810                         break;
811 #else
812                 case Opt_acl:
813                 case Opt_noacl:
814                         printk("EXT3 (no)acl options not supported\n");
815                         break;
816 #endif
817                 case Opt_reservation:
818                         set_opt(sbi->s_mount_opt, RESERVATION);
819                         break;
820                 case Opt_noreservation:
821                         clear_opt(sbi->s_mount_opt, RESERVATION);
822                         break;
823                 case Opt_journal_update:
824                         /* @@@ FIXME */
825                         /* Eventually we will want to be able to create
826                            a journal file here.  For now, only allow the
827                            user to specify an existing inode to be the
828                            journal file. */
829                         if (is_remount) {
830                                 printk(KERN_ERR "EXT3-fs: cannot specify "
831                                        "journal on remount\n");
832                                 return 0;
833                         }
834                         set_opt (sbi->s_mount_opt, UPDATE_JOURNAL);
835                         break;
836                 case Opt_journal_inum:
837                         if (is_remount) {
838                                 printk(KERN_ERR "EXT3-fs: cannot specify "
839                                        "journal on remount\n");
840                                 return 0;
841                         }
842                         if (match_int(&args[0], &option))
843                                 return 0;
844                         *inum = option;
845                         break;
846                 case Opt_journal_dev:
847                         if (is_remount) {
848                                 printk(KERN_ERR "EXT3-fs: cannot specify "
849                                        "journal on remount\n");
850                                 return 0;
851                         }
852                         if (match_int(&args[0], &option))
853                                 return 0;
854                         *journal_devnum = option;
855                         break;
856                 case Opt_noload:
857                         set_opt (sbi->s_mount_opt, NOLOAD);
858                         break;
859                 case Opt_commit:
860                         if (match_int(&args[0], &option))
861                                 return 0;
862                         if (option < 0)
863                                 return 0;
864                         if (option == 0)
865                                 option = JBD_DEFAULT_MAX_COMMIT_AGE;
866                         sbi->s_commit_interval = HZ * option;
867                         break;
868                 case Opt_data_journal:
869                         data_opt = EXT3_MOUNT_JOURNAL_DATA;
870                         goto datacheck;
871                 case Opt_data_ordered:
872                         data_opt = EXT3_MOUNT_ORDERED_DATA;
873                         goto datacheck;
874                 case Opt_data_writeback:
875                         data_opt = EXT3_MOUNT_WRITEBACK_DATA;
876                 datacheck:
877                         if (is_remount) {
878                                 if ((sbi->s_mount_opt & EXT3_MOUNT_DATA_FLAGS)
879                                                 != data_opt) {
880                                         printk(KERN_ERR
881                                                 "EXT3-fs: cannot change data "
882                                                 "mode on remount\n");
883                                         return 0;
884                                 }
885                         } else {
886                                 sbi->s_mount_opt &= ~EXT3_MOUNT_DATA_FLAGS;
887                                 sbi->s_mount_opt |= data_opt;
888                         }
889                         break;
890 #ifdef CONFIG_QUOTA
891                 case Opt_usrjquota:
892                         qtype = USRQUOTA;
893                         goto set_qf_name;
894                 case Opt_grpjquota:
895                         qtype = GRPQUOTA;
896 set_qf_name:
897                         if (sb_any_quota_enabled(sb)) {
898                                 printk(KERN_ERR
899                                         "EXT3-fs: Cannot change journalled "
900                                         "quota options when quota turned on.\n");
901                                 return 0;
902                         }
903                         qname = match_strdup(&args[0]);
904                         if (!qname) {
905                                 printk(KERN_ERR
906                                         "EXT3-fs: not enough memory for "
907                                         "storing quotafile name.\n");
908                                 return 0;
909                         }
910                         if (sbi->s_qf_names[qtype] &&
911                             strcmp(sbi->s_qf_names[qtype], qname)) {
912                                 printk(KERN_ERR
913                                         "EXT3-fs: %s quota file already "
914                                         "specified.\n", QTYPE2NAME(qtype));
915                                 kfree(qname);
916                                 return 0;
917                         }
918                         sbi->s_qf_names[qtype] = qname;
919                         if (strchr(sbi->s_qf_names[qtype], '/')) {
920                                 printk(KERN_ERR
921                                         "EXT3-fs: quotafile must be on "
922                                         "filesystem root.\n");
923                                 kfree(sbi->s_qf_names[qtype]);
924                                 sbi->s_qf_names[qtype] = NULL;
925                                 return 0;
926                         }
927                         set_opt(sbi->s_mount_opt, QUOTA);
928                         break;
929                 case Opt_offusrjquota:
930                         qtype = USRQUOTA;
931                         goto clear_qf_name;
932                 case Opt_offgrpjquota:
933                         qtype = GRPQUOTA;
934 clear_qf_name:
935                         if (sb_any_quota_enabled(sb)) {
936                                 printk(KERN_ERR "EXT3-fs: Cannot change "
937                                         "journalled quota options when "
938                                         "quota turned on.\n");
939                                 return 0;
940                         }
941                         /*
942                          * The space will be released later when all options
943                          * are confirmed to be correct
944                          */
945                         sbi->s_qf_names[qtype] = NULL;
946                         break;
947                 case Opt_jqfmt_vfsold:
948                         sbi->s_jquota_fmt = QFMT_VFS_OLD;
949                         break;
950                 case Opt_jqfmt_vfsv0:
951                         sbi->s_jquota_fmt = QFMT_VFS_V0;
952                         break;
953                 case Opt_quota:
954                 case Opt_usrquota:
955                         set_opt(sbi->s_mount_opt, QUOTA);
956                         set_opt(sbi->s_mount_opt, USRQUOTA);
957                         break;
958                 case Opt_grpquota:
959                         set_opt(sbi->s_mount_opt, QUOTA);
960                         set_opt(sbi->s_mount_opt, GRPQUOTA);
961                         break;
962                 case Opt_noquota:
963                         if (sb_any_quota_enabled(sb)) {
964                                 printk(KERN_ERR "EXT3-fs: Cannot change quota "
965                                         "options when quota turned on.\n");
966                                 return 0;
967                         }
968                         clear_opt(sbi->s_mount_opt, QUOTA);
969                         clear_opt(sbi->s_mount_opt, USRQUOTA);
970                         clear_opt(sbi->s_mount_opt, GRPQUOTA);
971                         break;
972 #else
973                 case Opt_quota:
974                 case Opt_usrquota:
975                 case Opt_grpquota:
976                 case Opt_usrjquota:
977                 case Opt_grpjquota:
978                 case Opt_offusrjquota:
979                 case Opt_offgrpjquota:
980                 case Opt_jqfmt_vfsold:
981                 case Opt_jqfmt_vfsv0:
982                         printk(KERN_ERR
983                                 "EXT3-fs: journalled quota options not "
984                                 "supported.\n");
985                         break;
986                 case Opt_noquota:
987                         break;
988 #endif
989                 case Opt_abort:
990                         set_opt(sbi->s_mount_opt, ABORT);
991                         break;
992                 case Opt_barrier:
993                         if (match_int(&args[0], &option))
994                                 return 0;
995                         if (option)
996                                 set_opt(sbi->s_mount_opt, BARRIER);
997                         else
998                                 clear_opt(sbi->s_mount_opt, BARRIER);
999                         break;
1000                 case Opt_ignore:
1001                         break;
1002                 case Opt_resize:
1003                         if (!is_remount) {
1004                                 printk("EXT3-fs: resize option only available "
1005                                         "for remount\n");
1006                                 return 0;
1007                         }
1008                         if (match_int(&args[0], &option) != 0)
1009                                 return 0;
1010                         *n_blocks_count = option;
1011                         break;
1012                 case Opt_nobh:
1013                         set_opt(sbi->s_mount_opt, NOBH);
1014                         break;
1015                 default:
1016                         printk (KERN_ERR
1017                                 "EXT3-fs: Unrecognized mount option \"%s\" "
1018                                 "or missing value\n", p);
1019                         return 0;
1020                 }
1021         }
1022 #ifdef CONFIG_QUOTA
1023         if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
1024                 if ((sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA) &&
1025                      sbi->s_qf_names[USRQUOTA])
1026                         clear_opt(sbi->s_mount_opt, USRQUOTA);
1027
1028                 if ((sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA) &&
1029                      sbi->s_qf_names[GRPQUOTA])
1030                         clear_opt(sbi->s_mount_opt, GRPQUOTA);
1031
1032                 if ((sbi->s_qf_names[USRQUOTA] &&
1033                                 (sbi->s_mount_opt & EXT3_MOUNT_GRPQUOTA)) ||
1034                     (sbi->s_qf_names[GRPQUOTA] &&
1035                                 (sbi->s_mount_opt & EXT3_MOUNT_USRQUOTA))) {
1036                         printk(KERN_ERR "EXT3-fs: old and new quota "
1037                                         "format mixing.\n");
1038                         return 0;
1039                 }
1040
1041                 if (!sbi->s_jquota_fmt) {
1042                         printk(KERN_ERR "EXT3-fs: journalled quota format "
1043                                         "not specified.\n");
1044                         return 0;
1045                 }
1046         } else {
1047                 if (sbi->s_jquota_fmt) {
1048                         printk(KERN_ERR "EXT3-fs: journalled quota format "
1049                                         "specified with no journalling "
1050                                         "enabled.\n");
1051                         return 0;
1052                 }
1053         }
1054 #endif
1055         return 1;
1056 }
1057
1058 static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
1059                             int read_only)
1060 {
1061         struct ext3_sb_info *sbi = EXT3_SB(sb);
1062         int res = 0;
1063
1064         if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
1065                 printk (KERN_ERR "EXT3-fs warning: revision level too high, "
1066                         "forcing read-only mode\n");
1067                 res = MS_RDONLY;
1068         }
1069         if (read_only)
1070                 return res;
1071         if (!(sbi->s_mount_state & EXT3_VALID_FS))
1072                 printk (KERN_WARNING "EXT3-fs warning: mounting unchecked fs, "
1073                         "running e2fsck is recommended\n");
1074         else if ((sbi->s_mount_state & EXT3_ERROR_FS))
1075                 printk (KERN_WARNING
1076                         "EXT3-fs warning: mounting fs with errors, "
1077                         "running e2fsck is recommended\n");
1078         else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1079                  le16_to_cpu(es->s_mnt_count) >=
1080                  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
1081                 printk (KERN_WARNING
1082                         "EXT3-fs warning: maximal mount count reached, "
1083                         "running e2fsck is recommended\n");
1084         else if (le32_to_cpu(es->s_checkinterval) &&
1085                 (le32_to_cpu(es->s_lastcheck) +
1086                         le32_to_cpu(es->s_checkinterval) <= get_seconds()))
1087                 printk (KERN_WARNING
1088                         "EXT3-fs warning: checktime reached, "
1089                         "running e2fsck is recommended\n");
1090 #if 0
1091                 /* @@@ We _will_ want to clear the valid bit if we find
1092                    inconsistencies, to force a fsck at reboot.  But for
1093                    a plain journaled filesystem we can keep it set as
1094                    valid forever! :) */
1095         es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) & ~EXT3_VALID_FS);
1096 #endif
1097         if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
1098                 es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
1099         es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
1100         es->s_mtime = cpu_to_le32(get_seconds());
1101         ext3_update_dynamic_rev(sb);
1102         EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
1103
1104         ext3_commit_super(sb, es, 1);
1105         if (test_opt(sb, DEBUG))
1106                 printk(KERN_INFO "[EXT3 FS bs=%lu, gc=%lu, "
1107                                 "bpg=%lu, ipg=%lu, mo=%04lx]\n",
1108                         sb->s_blocksize,
1109                         sbi->s_groups_count,
1110                         EXT3_BLOCKS_PER_GROUP(sb),
1111                         EXT3_INODES_PER_GROUP(sb),
1112                         sbi->s_mount_opt);
1113
1114         printk(KERN_INFO "EXT3 FS on %s, ", sb->s_id);
1115         if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
1116                 char b[BDEVNAME_SIZE];
1117
1118                 printk("external journal on %s\n",
1119                         bdevname(EXT3_SB(sb)->s_journal->j_dev, b));
1120         } else {
1121                 printk("internal journal\n");
1122         }
1123         return res;
1124 }
1125
1126 /* Called at mount-time, super-block is locked */
1127 static int ext3_check_descriptors (struct super_block * sb)
1128 {
1129         struct ext3_sb_info *sbi = EXT3_SB(sb);
1130         unsigned long block = le32_to_cpu(sbi->s_es->s_first_data_block);
1131         struct ext3_group_desc * gdp = NULL;
1132         int desc_block = 0;
1133         int i;
1134
1135         ext3_debug ("Checking group descriptors");
1136
1137         for (i = 0; i < sbi->s_groups_count; i++)
1138         {
1139                 if ((i % EXT3_DESC_PER_BLOCK(sb)) == 0)
1140                         gdp = (struct ext3_group_desc *)
1141                                         sbi->s_group_desc[desc_block++]->b_data;
1142                 if (le32_to_cpu(gdp->bg_block_bitmap) < block ||
1143                     le32_to_cpu(gdp->bg_block_bitmap) >=
1144                                 block + EXT3_BLOCKS_PER_GROUP(sb))
1145                 {
1146                         ext3_error (sb, "ext3_check_descriptors",
1147                                     "Block bitmap for group %d"
1148                                     " not in group (block %lu)!",
1149                                     i, (unsigned long)
1150                                         le32_to_cpu(gdp->bg_block_bitmap));
1151                         return 0;
1152                 }
1153                 if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||
1154                     le32_to_cpu(gdp->bg_inode_bitmap) >=
1155                                 block + EXT3_BLOCKS_PER_GROUP(sb))
1156                 {
1157                         ext3_error (sb, "ext3_check_descriptors",
1158                                     "Inode bitmap for group %d"
1159                                     " not in group (block %lu)!",
1160                                     i, (unsigned long)
1161                                         le32_to_cpu(gdp->bg_inode_bitmap));
1162                         return 0;
1163                 }
1164                 if (le32_to_cpu(gdp->bg_inode_table) < block ||
1165                     le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >=
1166                     block + EXT3_BLOCKS_PER_GROUP(sb))
1167                 {
1168                         ext3_error (sb, "ext3_check_descriptors",
1169                                     "Inode table for group %d"
1170                                     " not in group (block %lu)!",
1171                                     i, (unsigned long)
1172                                         le32_to_cpu(gdp->bg_inode_table));
1173                         return 0;
1174                 }
1175                 block += EXT3_BLOCKS_PER_GROUP(sb);
1176                 gdp++;
1177         }
1178
1179         sbi->s_es->s_free_blocks_count=cpu_to_le32(ext3_count_free_blocks(sb));
1180         sbi->s_es->s_free_inodes_count=cpu_to_le32(ext3_count_free_inodes(sb));
1181         return 1;
1182 }
1183
1184
1185 /* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
1186  * the superblock) which were deleted from all directories, but held open by
1187  * a process at the time of a crash.  We walk the list and try to delete these
1188  * inodes at recovery time (only with a read-write filesystem).
1189  *
1190  * In order to keep the orphan inode chain consistent during traversal (in
1191  * case of crash during recovery), we link each inode into the superblock
1192  * orphan list_head and handle it the same way as an inode deletion during
1193  * normal operation (which journals the operations for us).
1194  *
1195  * We only do an iget() and an iput() on each inode, which is very safe if we
1196  * accidentally point at an in-use or already deleted inode.  The worst that
1197  * can happen in this case is that we get a "bit already cleared" message from
1198  * ext3_free_inode().  The only reason we would point at a wrong inode is if
1199  * e2fsck was run on this filesystem, and it must have already done the orphan
1200  * inode cleanup for us, so we can safely abort without any further action.
1201  */
1202 static void ext3_orphan_cleanup (struct super_block * sb,
1203                                  struct ext3_super_block * es)
1204 {
1205         unsigned int s_flags = sb->s_flags;
1206         int nr_orphans = 0, nr_truncates = 0;
1207 #ifdef CONFIG_QUOTA
1208         int i;
1209 #endif
1210         if (!es->s_last_orphan) {
1211                 jbd_debug(4, "no orphan inodes to clean up\n");
1212                 return;
1213         }
1214
1215         if (EXT3_SB(sb)->s_mount_state & EXT3_ERROR_FS) {
1216                 if (es->s_last_orphan)
1217                         jbd_debug(1, "Errors on filesystem, "
1218                                   "clearing orphan list.\n");
1219                 es->s_last_orphan = 0;
1220                 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1221                 return;
1222         }
1223
1224         if (s_flags & MS_RDONLY) {
1225                 printk(KERN_INFO "EXT3-fs: %s: orphan cleanup on readonly fs\n",
1226                        sb->s_id);
1227                 sb->s_flags &= ~MS_RDONLY;
1228         }
1229 #ifdef CONFIG_QUOTA
1230         /* Needed for iput() to work correctly and not trash data */
1231         sb->s_flags |= MS_ACTIVE;
1232         /* Turn on quotas so that they are updated correctly */
1233         for (i = 0; i < MAXQUOTAS; i++) {
1234                 if (EXT3_SB(sb)->s_qf_names[i]) {
1235                         int ret = ext3_quota_on_mount(sb, i);
1236                         if (ret < 0)
1237                                 printk(KERN_ERR
1238                                         "EXT3-fs: Cannot turn on journalled "
1239                                         "quota: error %d\n", ret);
1240                 }
1241         }
1242 #endif
1243
1244         while (es->s_last_orphan) {
1245                 struct inode *inode;
1246
1247                 if (!(inode =
1248                       ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
1249                         es->s_last_orphan = 0;
1250                         break;
1251                 }
1252
1253                 list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
1254                 DQUOT_INIT(inode);
1255                 if (inode->i_nlink) {
1256                         printk(KERN_DEBUG
1257                                 "%s: truncating inode %ld to %Ld bytes\n",
1258                                 __FUNCTION__, inode->i_ino, inode->i_size);
1259                         jbd_debug(2, "truncating inode %ld to %Ld bytes\n",
1260                                   inode->i_ino, inode->i_size);
1261                         ext3_truncate(inode);
1262                         nr_truncates++;
1263                 } else {
1264                         printk(KERN_DEBUG
1265                                 "%s: deleting unreferenced inode %ld\n",
1266                                 __FUNCTION__, inode->i_ino);
1267                         jbd_debug(2, "deleting unreferenced inode %ld\n",
1268                                   inode->i_ino);
1269                         nr_orphans++;
1270                 }
1271                 iput(inode);  /* The delete magic happens here! */
1272         }
1273
1274 #define PLURAL(x) (x), ((x)==1) ? "" : "s"
1275
1276         if (nr_orphans)
1277                 printk(KERN_INFO "EXT3-fs: %s: %d orphan inode%s deleted\n",
1278                        sb->s_id, PLURAL(nr_orphans));
1279         if (nr_truncates)
1280                 printk(KERN_INFO "EXT3-fs: %s: %d truncate%s cleaned up\n",
1281                        sb->s_id, PLURAL(nr_truncates));
1282 #ifdef CONFIG_QUOTA
1283         /* Turn quotas off */
1284         for (i = 0; i < MAXQUOTAS; i++) {
1285                 if (sb_dqopt(sb)->files[i])
1286                         vfs_quota_off(sb, i);
1287         }
1288 #endif
1289         sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1290 }
1291
1292 #define log2(n) ffz(~(n))
1293
1294 /*
1295  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
1296  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
1297  * We need to be 1 filesystem block less than the 2^32 sector limit.
1298  */
1299 static loff_t ext3_max_size(int bits)
1300 {
1301         loff_t res = EXT3_NDIR_BLOCKS;
1302         /* This constant is calculated to be the largest file size for a
1303          * dense, 4k-blocksize file such that the total number of
1304          * sectors in the file, including data and all indirect blocks,
1305          * does not exceed 2^32. */
1306         const loff_t upper_limit = 0x1ff7fffd000LL;
1307
1308         res += 1LL << (bits-2);
1309         res += 1LL << (2*(bits-2));
1310         res += 1LL << (3*(bits-2));
1311         res <<= bits;
1312         if (res > upper_limit)
1313                 res = upper_limit;
1314         return res;
1315 }
1316
1317 static unsigned long descriptor_loc(struct super_block *sb,
1318                                     unsigned long logic_sb_block,
1319                                     int nr)
1320 {
1321         struct ext3_sb_info *sbi = EXT3_SB(sb);
1322         unsigned long bg, first_data_block, first_meta_bg;
1323         int has_super = 0;
1324
1325         first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1326         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
1327
1328         if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
1329             nr < first_meta_bg)
1330                 return (logic_sb_block + nr + 1);
1331         bg = sbi->s_desc_per_block * nr;
1332         if (ext3_bg_has_super(sb, bg))
1333                 has_super = 1;
1334         return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
1335 }
1336
1337
1338 static int ext3_fill_super (struct super_block *sb, void *data, int silent)
1339 {
1340         struct buffer_head * bh;
1341         struct ext3_super_block *es = NULL;
1342         struct ext3_sb_info *sbi;
1343         unsigned long block;
1344         unsigned long sb_block = get_sb_block(&data);
1345         unsigned long logic_sb_block;
1346         unsigned long offset = 0;
1347         unsigned long journal_inum = 0;
1348         unsigned long journal_devnum = 0;
1349         unsigned long def_mount_opts;
1350         struct inode *root;
1351         int blocksize;
1352         int hblock;
1353         int db_count;
1354         int i;
1355         int needs_recovery;
1356         __le32 features;
1357
1358         sbi = kmalloc(sizeof(*sbi), GFP_KERNEL);
1359         if (!sbi)
1360                 return -ENOMEM;
1361         sb->s_fs_info = sbi;
1362         memset(sbi, 0, sizeof(*sbi));
1363         sbi->s_mount_opt = 0;
1364         sbi->s_resuid = EXT3_DEF_RESUID;
1365         sbi->s_resgid = EXT3_DEF_RESGID;
1366
1367         unlock_kernel();
1368
1369         blocksize = sb_min_blocksize(sb, EXT3_MIN_BLOCK_SIZE);
1370         if (!blocksize) {
1371                 printk(KERN_ERR "EXT3-fs: unable to set blocksize\n");
1372                 goto out_fail;
1373         }
1374
1375         /*
1376          * The ext3 superblock will not be buffer aligned for other than 1kB
1377          * block sizes.  We need to calculate the offset from buffer start.
1378          */
1379         if (blocksize != EXT3_MIN_BLOCK_SIZE) {
1380                 logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1381                 offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1382         } else {
1383                 logic_sb_block = sb_block;
1384         }
1385
1386         if (!(bh = sb_bread(sb, logic_sb_block))) {
1387                 printk (KERN_ERR "EXT3-fs: unable to read superblock\n");
1388                 goto out_fail;
1389         }
1390         /*
1391          * Note: s_es must be initialized as soon as possible because
1392          *       some ext3 macro-instructions depend on its value
1393          */
1394         es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
1395         sbi->s_es = es;
1396         sb->s_magic = le16_to_cpu(es->s_magic);
1397         if (sb->s_magic != EXT3_SUPER_MAGIC)
1398                 goto cantfind_ext3;
1399
1400         /* Set defaults before we parse the mount options */
1401         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
1402         if (def_mount_opts & EXT3_DEFM_DEBUG)
1403                 set_opt(sbi->s_mount_opt, DEBUG);
1404         if (def_mount_opts & EXT3_DEFM_BSDGROUPS)
1405                 set_opt(sbi->s_mount_opt, GRPID);
1406         if (def_mount_opts & EXT3_DEFM_UID16)
1407                 set_opt(sbi->s_mount_opt, NO_UID32);
1408         if (def_mount_opts & EXT3_DEFM_XATTR_USER)
1409                 set_opt(sbi->s_mount_opt, XATTR_USER);
1410         if (def_mount_opts & EXT3_DEFM_ACL)
1411                 set_opt(sbi->s_mount_opt, POSIX_ACL);
1412         if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_DATA)
1413                 sbi->s_mount_opt |= EXT3_MOUNT_JOURNAL_DATA;
1414         else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_ORDERED)
1415                 sbi->s_mount_opt |= EXT3_MOUNT_ORDERED_DATA;
1416         else if ((def_mount_opts & EXT3_DEFM_JMODE) == EXT3_DEFM_JMODE_WBACK)
1417                 sbi->s_mount_opt |= EXT3_MOUNT_WRITEBACK_DATA;
1418
1419         if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_PANIC)
1420                 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
1421         else if (le16_to_cpu(sbi->s_es->s_errors) == EXT3_ERRORS_RO)
1422                 set_opt(sbi->s_mount_opt, ERRORS_RO);
1423
1424         sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
1425         sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
1426
1427         set_opt(sbi->s_mount_opt, RESERVATION);
1428
1429         if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
1430                             NULL, 0))
1431                 goto failed_mount;
1432
1433         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1434                 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1435
1436         if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
1437             (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
1438              EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
1439              EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
1440                 printk(KERN_WARNING 
1441                        "EXT3-fs warning: feature flags set on rev 0 fs, "
1442                        "running e2fsck is recommended\n");
1443         /*
1444          * Check feature flags regardless of the revision level, since we
1445          * previously didn't change the revision level when setting the flags,
1446          * so there is a chance incompat flags are set on a rev 0 filesystem.
1447          */
1448         features = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP);
1449         if (features) {
1450                 printk(KERN_ERR "EXT3-fs: %s: couldn't mount because of "
1451                        "unsupported optional features (%x).\n",
1452                        sb->s_id, le32_to_cpu(features));
1453                 goto failed_mount;
1454         }
1455         features = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP);
1456         if (!(sb->s_flags & MS_RDONLY) && features) {
1457                 printk(KERN_ERR "EXT3-fs: %s: couldn't mount RDWR because of "
1458                        "unsupported optional features (%x).\n",
1459                        sb->s_id, le32_to_cpu(features));
1460                 goto failed_mount;
1461         }
1462         blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
1463
1464         if (blocksize < EXT3_MIN_BLOCK_SIZE ||
1465             blocksize > EXT3_MAX_BLOCK_SIZE) {
1466                 printk(KERN_ERR 
1467                        "EXT3-fs: Unsupported filesystem blocksize %d on %s.\n",
1468                        blocksize, sb->s_id);
1469                 goto failed_mount;
1470         }
1471
1472         hblock = bdev_hardsect_size(sb->s_bdev);
1473         if (sb->s_blocksize != blocksize) {
1474                 /*
1475                  * Make sure the blocksize for the filesystem is larger
1476                  * than the hardware sectorsize for the machine.
1477                  */
1478                 if (blocksize < hblock) {
1479                         printk(KERN_ERR "EXT3-fs: blocksize %d too small for "
1480                                "device blocksize %d.\n", blocksize, hblock);
1481                         goto failed_mount;
1482                 }
1483
1484                 brelse (bh);
1485                 sb_set_blocksize(sb, blocksize);
1486                 logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
1487                 offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
1488                 bh = sb_bread(sb, logic_sb_block);
1489                 if (!bh) {
1490                         printk(KERN_ERR 
1491                                "EXT3-fs: Can't read superblock on 2nd try.\n");
1492                         goto failed_mount;
1493                 }
1494                 es = (struct ext3_super_block *)(((char *)bh->b_data) + offset);
1495                 sbi->s_es = es;
1496                 if (es->s_magic != cpu_to_le16(EXT3_SUPER_MAGIC)) {
1497                         printk (KERN_ERR 
1498                                 "EXT3-fs: Magic mismatch, very weird !\n");
1499                         goto failed_mount;
1500                 }
1501         }
1502
1503         sb->s_maxbytes = ext3_max_size(sb->s_blocksize_bits);
1504
1505         if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV) {
1506                 sbi->s_inode_size = EXT3_GOOD_OLD_INODE_SIZE;
1507                 sbi->s_first_ino = EXT3_GOOD_OLD_FIRST_INO;
1508         } else {
1509                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
1510                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
1511                 if ((sbi->s_inode_size < EXT3_GOOD_OLD_INODE_SIZE) ||
1512                     (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
1513                     (sbi->s_inode_size > blocksize)) {
1514                         printk (KERN_ERR
1515                                 "EXT3-fs: unsupported inode size: %d\n",
1516                                 sbi->s_inode_size);
1517                         goto failed_mount;
1518                 }
1519         }
1520         sbi->s_frag_size = EXT3_MIN_FRAG_SIZE <<
1521                                    le32_to_cpu(es->s_log_frag_size);
1522         if (blocksize != sbi->s_frag_size) {
1523                 printk(KERN_ERR
1524                        "EXT3-fs: fragsize %lu != blocksize %u (unsupported)\n",
1525                        sbi->s_frag_size, blocksize);
1526                 goto failed_mount;
1527         }
1528         sbi->s_frags_per_block = 1;
1529         sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
1530         sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
1531         sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
1532         if (EXT3_INODE_SIZE(sb) == 0)
1533                 goto cantfind_ext3;
1534         sbi->s_inodes_per_block = blocksize / EXT3_INODE_SIZE(sb);
1535         if (sbi->s_inodes_per_block == 0)
1536                 goto cantfind_ext3;
1537         sbi->s_itb_per_group = sbi->s_inodes_per_group /
1538                                         sbi->s_inodes_per_block;
1539         sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
1540         sbi->s_sbh = bh;
1541         sbi->s_mount_state = le16_to_cpu(es->s_state);
1542         sbi->s_addr_per_block_bits = log2(EXT3_ADDR_PER_BLOCK(sb));
1543         sbi->s_desc_per_block_bits = log2(EXT3_DESC_PER_BLOCK(sb));
1544         for (i=0; i < 4; i++)
1545                 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
1546         sbi->s_def_hash_version = es->s_def_hash_version;
1547
1548         if (sbi->s_blocks_per_group > blocksize * 8) {
1549                 printk (KERN_ERR
1550                         "EXT3-fs: #blocks per group too big: %lu\n",
1551                         sbi->s_blocks_per_group);
1552                 goto failed_mount;
1553         }
1554         if (sbi->s_frags_per_group > blocksize * 8) {
1555                 printk (KERN_ERR
1556                         "EXT3-fs: #fragments per group too big: %lu\n",
1557                         sbi->s_frags_per_group);
1558                 goto failed_mount;
1559         }
1560         if (sbi->s_inodes_per_group > blocksize * 8) {
1561                 printk (KERN_ERR
1562                         "EXT3-fs: #inodes per group too big: %lu\n",
1563                         sbi->s_inodes_per_group);
1564                 goto failed_mount;
1565         }
1566
1567         if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
1568                 goto cantfind_ext3;
1569         sbi->s_groups_count = (le32_to_cpu(es->s_blocks_count) -
1570                                le32_to_cpu(es->s_first_data_block) +
1571                                EXT3_BLOCKS_PER_GROUP(sb) - 1) /
1572                               EXT3_BLOCKS_PER_GROUP(sb);
1573         db_count = (sbi->s_groups_count + EXT3_DESC_PER_BLOCK(sb) - 1) /
1574                    EXT3_DESC_PER_BLOCK(sb);
1575         sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
1576                                     GFP_KERNEL);
1577         if (sbi->s_group_desc == NULL) {
1578                 printk (KERN_ERR "EXT3-fs: not enough memory\n");
1579                 goto failed_mount;
1580         }
1581
1582         percpu_counter_init(&sbi->s_freeblocks_counter);
1583         percpu_counter_init(&sbi->s_freeinodes_counter);
1584         percpu_counter_init(&sbi->s_dirs_counter);
1585         bgl_lock_init(&sbi->s_blockgroup_lock);
1586
1587         for (i = 0; i < db_count; i++) {
1588                 block = descriptor_loc(sb, logic_sb_block, i);
1589                 sbi->s_group_desc[i] = sb_bread(sb, block);
1590                 if (!sbi->s_group_desc[i]) {
1591                         printk (KERN_ERR "EXT3-fs: "
1592                                 "can't read group descriptor %d\n", i);
1593                         db_count = i;
1594                         goto failed_mount2;
1595                 }
1596         }
1597         if (!ext3_check_descriptors (sb)) {
1598                 printk (KERN_ERR "EXT3-fs: group descriptors corrupted !\n");
1599                 goto failed_mount2;
1600         }
1601         sbi->s_gdb_count = db_count;
1602         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1603         spin_lock_init(&sbi->s_next_gen_lock);
1604         /* per fileystem reservation list head & lock */
1605         spin_lock_init(&sbi->s_rsv_window_lock);
1606         sbi->s_rsv_window_root = RB_ROOT;
1607         /* Add a single, static dummy reservation to the start of the
1608          * reservation window list --- it gives us a placeholder for
1609          * append-at-start-of-list which makes the allocation logic
1610          * _much_ simpler. */
1611         sbi->s_rsv_window_head.rsv_start = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1612         sbi->s_rsv_window_head.rsv_end = EXT3_RESERVE_WINDOW_NOT_ALLOCATED;
1613         sbi->s_rsv_window_head.rsv_alloc_hit = 0;
1614         sbi->s_rsv_window_head.rsv_goal_size = 0;
1615         ext3_rsv_window_add(sb, &sbi->s_rsv_window_head);
1616
1617         /*
1618          * set up enough so that it can read an inode
1619          */
1620         sb->s_op = &ext3_sops;
1621         sb->s_export_op = &ext3_export_ops;
1622         sb->s_xattr = ext3_xattr_handlers;
1623 #ifdef CONFIG_QUOTA
1624         sb->s_qcop = &ext3_qctl_operations;
1625         sb->dq_op = &ext3_quota_operations;
1626 #endif
1627         INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
1628
1629         sb->s_root = NULL;
1630
1631         needs_recovery = (es->s_last_orphan != 0 ||
1632                           EXT3_HAS_INCOMPAT_FEATURE(sb,
1633                                     EXT3_FEATURE_INCOMPAT_RECOVER));
1634
1635         /*
1636          * The first inode we look at is the journal inode.  Don't try
1637          * root first: it may be modified in the journal!
1638          */
1639         if (!test_opt(sb, NOLOAD) &&
1640             EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
1641                 if (ext3_load_journal(sb, es, journal_devnum))
1642                         goto failed_mount2;
1643         } else if (journal_inum) {
1644                 if (ext3_create_journal(sb, es, journal_inum))
1645                         goto failed_mount2;
1646         } else {
1647                 if (!silent)
1648                         printk (KERN_ERR
1649                                 "ext3: No journal on filesystem on %s\n",
1650                                 sb->s_id);
1651                 goto failed_mount2;
1652         }
1653
1654         /* We have now updated the journal if required, so we can
1655          * validate the data journaling mode. */
1656         switch (test_opt(sb, DATA_FLAGS)) {
1657         case 0:
1658                 /* No mode set, assume a default based on the journal
1659                    capabilities: ORDERED_DATA if the journal can
1660                    cope, else JOURNAL_DATA */
1661                 if (journal_check_available_features
1662                     (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
1663                         set_opt(sbi->s_mount_opt, ORDERED_DATA);
1664                 else
1665                         set_opt(sbi->s_mount_opt, JOURNAL_DATA);
1666                 break;
1667
1668         case EXT3_MOUNT_ORDERED_DATA:
1669         case EXT3_MOUNT_WRITEBACK_DATA:
1670                 if (!journal_check_available_features
1671                     (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
1672                         printk(KERN_ERR "EXT3-fs: Journal does not support "
1673                                "requested data journaling mode\n");
1674                         goto failed_mount3;
1675                 }
1676         default:
1677                 break;
1678         }
1679
1680         if (test_opt(sb, NOBH)) {
1681                 if (!(test_opt(sb, DATA_FLAGS) == EXT3_MOUNT_WRITEBACK_DATA)) {
1682                         printk(KERN_WARNING "EXT3-fs: Ignoring nobh option - "
1683                                 "its supported only with writeback mode\n");
1684                         clear_opt(sbi->s_mount_opt, NOBH);
1685                 }
1686         }
1687         /*
1688          * The journal_load will have done any necessary log recovery,
1689          * so we can safely mount the rest of the filesystem now.
1690          */
1691
1692         root = iget(sb, EXT3_ROOT_INO);
1693         sb->s_root = d_alloc_root(root);
1694         if (!sb->s_root) {
1695                 printk(KERN_ERR "EXT3-fs: get root inode failed\n");
1696                 iput(root);
1697                 goto failed_mount3;
1698         }
1699         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1700                 dput(sb->s_root);
1701                 sb->s_root = NULL;
1702                 printk(KERN_ERR "EXT3-fs: corrupt root inode, run e2fsck\n");
1703                 goto failed_mount3;
1704         }
1705
1706         ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
1707         /*
1708          * akpm: core read_super() calls in here with the superblock locked.
1709          * That deadlocks, because orphan cleanup needs to lock the superblock
1710          * in numerous places.  Here we just pop the lock - it's relatively
1711          * harmless, because we are now ready to accept write_super() requests,
1712          * and aviro says that's the only reason for hanging onto the
1713          * superblock lock.
1714          */
1715         EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
1716         ext3_orphan_cleanup(sb, es);
1717         EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
1718         if (needs_recovery)
1719                 printk (KERN_INFO "EXT3-fs: recovery complete.\n");
1720         ext3_mark_recovery_complete(sb, es);
1721         printk (KERN_INFO "EXT3-fs: mounted filesystem with %s data mode.\n",
1722                 test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ? "journal":
1723                 test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
1724                 "writeback");
1725
1726         percpu_counter_mod(&sbi->s_freeblocks_counter,
1727                 ext3_count_free_blocks(sb));
1728         percpu_counter_mod(&sbi->s_freeinodes_counter,
1729                 ext3_count_free_inodes(sb));
1730         percpu_counter_mod(&sbi->s_dirs_counter,
1731                 ext3_count_dirs(sb));
1732
1733         lock_kernel();
1734         return 0;
1735
1736 cantfind_ext3:
1737         if (!silent)
1738                 printk(KERN_ERR "VFS: Can't find ext3 filesystem on dev %s.\n",
1739                        sb->s_id);
1740         goto failed_mount;
1741
1742 failed_mount3:
1743         journal_destroy(sbi->s_journal);
1744 failed_mount2:
1745         for (i = 0; i < db_count; i++)
1746                 brelse(sbi->s_group_desc[i]);
1747         kfree(sbi->s_group_desc);
1748 failed_mount:
1749 #ifdef CONFIG_QUOTA
1750         for (i = 0; i < MAXQUOTAS; i++)
1751                 kfree(sbi->s_qf_names[i]);
1752 #endif
1753         ext3_blkdev_remove(sbi);
1754         brelse(bh);
1755 out_fail:
1756         sb->s_fs_info = NULL;
1757         kfree(sbi);
1758         lock_kernel();
1759         return -EINVAL;
1760 }
1761
1762 /*
1763  * Setup any per-fs journal parameters now.  We'll do this both on
1764  * initial mount, once the journal has been initialised but before we've
1765  * done any recovery; and again on any subsequent remount. 
1766  */
1767 static void ext3_init_journal_params(struct super_block *sb, journal_t *journal)
1768 {
1769         struct ext3_sb_info *sbi = EXT3_SB(sb);
1770
1771         if (sbi->s_commit_interval)
1772                 journal->j_commit_interval = sbi->s_commit_interval;
1773         /* We could also set up an ext3-specific default for the commit
1774          * interval here, but for now we'll just fall back to the jbd
1775          * default. */
1776
1777         spin_lock(&journal->j_state_lock);
1778         if (test_opt(sb, BARRIER))
1779                 journal->j_flags |= JFS_BARRIER;
1780         else
1781                 journal->j_flags &= ~JFS_BARRIER;
1782         spin_unlock(&journal->j_state_lock);
1783 }
1784
1785 static journal_t *ext3_get_journal(struct super_block *sb, int journal_inum)
1786 {
1787         struct inode *journal_inode;
1788         journal_t *journal;
1789
1790         /* First, test for the existence of a valid inode on disk.  Bad
1791          * things happen if we iget() an unused inode, as the subsequent
1792          * iput() will try to delete it. */
1793
1794         journal_inode = iget(sb, journal_inum);
1795         if (!journal_inode) {
1796                 printk(KERN_ERR "EXT3-fs: no journal found.\n");
1797                 return NULL;
1798         }
1799         if (!journal_inode->i_nlink) {
1800                 make_bad_inode(journal_inode);
1801                 iput(journal_inode);
1802                 printk(KERN_ERR "EXT3-fs: journal inode is deleted.\n");
1803                 return NULL;
1804         }
1805
1806         jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
1807                   journal_inode, journal_inode->i_size);
1808         if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
1809                 printk(KERN_ERR "EXT3-fs: invalid journal inode.\n");
1810                 iput(journal_inode);
1811                 return NULL;
1812         }
1813
1814         journal = journal_init_inode(journal_inode);
1815         if (!journal) {
1816                 printk(KERN_ERR "EXT3-fs: Could not load journal inode\n");
1817                 iput(journal_inode);
1818                 return NULL;
1819         }
1820         journal->j_private = sb;
1821         ext3_init_journal_params(sb, journal);
1822         return journal;
1823 }
1824
1825 static journal_t *ext3_get_dev_journal(struct super_block *sb,
1826                                        dev_t j_dev)
1827 {
1828         struct buffer_head * bh;
1829         journal_t *journal;
1830         int start;
1831         int len;
1832         int hblock, blocksize;
1833         unsigned long sb_block;
1834         unsigned long offset;
1835         struct ext3_super_block * es;
1836         struct block_device *bdev;
1837
1838         bdev = ext3_blkdev_get(j_dev);
1839         if (bdev == NULL)
1840                 return NULL;
1841
1842         if (bd_claim(bdev, sb)) {
1843                 printk(KERN_ERR
1844                         "EXT3: failed to claim external journal device.\n");
1845                 blkdev_put(bdev);
1846                 return NULL;
1847         }
1848
1849         blocksize = sb->s_blocksize;
1850         hblock = bdev_hardsect_size(bdev);
1851         if (blocksize < hblock) {
1852                 printk(KERN_ERR
1853                         "EXT3-fs: blocksize too small for journal device.\n");
1854                 goto out_bdev;
1855         }
1856
1857         sb_block = EXT3_MIN_BLOCK_SIZE / blocksize;
1858         offset = EXT3_MIN_BLOCK_SIZE % blocksize;
1859         set_blocksize(bdev, blocksize);
1860         if (!(bh = __bread(bdev, sb_block, blocksize))) {
1861                 printk(KERN_ERR "EXT3-fs: couldn't read superblock of "
1862                        "external journal\n");
1863                 goto out_bdev;
1864         }
1865
1866         es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
1867         if ((le16_to_cpu(es->s_magic) != EXT3_SUPER_MAGIC) ||
1868             !(le32_to_cpu(es->s_feature_incompat) &
1869               EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
1870                 printk(KERN_ERR "EXT3-fs: external journal has "
1871                                         "bad superblock\n");
1872                 brelse(bh);
1873                 goto out_bdev;
1874         }
1875
1876         if (memcmp(EXT3_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
1877                 printk(KERN_ERR "EXT3-fs: journal UUID does not match\n");
1878                 brelse(bh);
1879                 goto out_bdev;
1880         }
1881
1882         len = le32_to_cpu(es->s_blocks_count);
1883         start = sb_block + 1;
1884         brelse(bh);     /* we're done with the superblock */
1885
1886         journal = journal_init_dev(bdev, sb->s_bdev,
1887                                         start, len, blocksize);
1888         if (!journal) {
1889                 printk(KERN_ERR "EXT3-fs: failed to create device journal\n");
1890                 goto out_bdev;
1891         }
1892         journal->j_private = sb;
1893         ll_rw_block(READ, 1, &journal->j_sb_buffer);
1894         wait_on_buffer(journal->j_sb_buffer);
1895         if (!buffer_uptodate(journal->j_sb_buffer)) {
1896                 printk(KERN_ERR "EXT3-fs: I/O error on journal device\n");
1897                 goto out_journal;
1898         }
1899         if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
1900                 printk(KERN_ERR "EXT3-fs: External journal has more than one "
1901                                         "user (unsupported) - %d\n",
1902                         be32_to_cpu(journal->j_superblock->s_nr_users));
1903                 goto out_journal;
1904         }
1905         EXT3_SB(sb)->journal_bdev = bdev;
1906         ext3_init_journal_params(sb, journal);
1907         return journal;
1908 out_journal:
1909         journal_destroy(journal);
1910 out_bdev:
1911         ext3_blkdev_put(bdev);
1912         return NULL;
1913 }
1914
1915 static int ext3_load_journal(struct super_block *sb,
1916                              struct ext3_super_block *es,
1917                              unsigned long journal_devnum)
1918 {
1919         journal_t *journal;
1920         int journal_inum = le32_to_cpu(es->s_journal_inum);
1921         dev_t journal_dev;
1922         int err = 0;
1923         int really_read_only;
1924
1925         if (journal_devnum &&
1926             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
1927                 printk(KERN_INFO "EXT3-fs: external journal device major/minor "
1928                         "numbers have changed\n");
1929                 journal_dev = new_decode_dev(journal_devnum);
1930         } else
1931                 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
1932
1933         really_read_only = bdev_read_only(sb->s_bdev);
1934
1935         /*
1936          * Are we loading a blank journal or performing recovery after a
1937          * crash?  For recovery, we need to check in advance whether we
1938          * can get read-write access to the device.
1939          */
1940
1941         if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER)) {
1942                 if (sb->s_flags & MS_RDONLY) {
1943                         printk(KERN_INFO "EXT3-fs: INFO: recovery "
1944                                         "required on readonly filesystem.\n");
1945                         if (really_read_only) {
1946                                 printk(KERN_ERR "EXT3-fs: write access "
1947                                         "unavailable, cannot proceed.\n");
1948                                 return -EROFS;
1949                         }
1950                         printk (KERN_INFO "EXT3-fs: write access will "
1951                                         "be enabled during recovery.\n");
1952                 }
1953         }
1954
1955         if (journal_inum && journal_dev) {
1956                 printk(KERN_ERR "EXT3-fs: filesystem has both journal "
1957                        "and inode journals!\n");
1958                 return -EINVAL;
1959         }
1960
1961         if (journal_inum) {
1962                 if (!(journal = ext3_get_journal(sb, journal_inum)))
1963                         return -EINVAL;
1964         } else {
1965                 if (!(journal = ext3_get_dev_journal(sb, journal_dev)))
1966                         return -EINVAL;
1967         }
1968
1969         if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
1970                 err = journal_update_format(journal);
1971                 if (err)  {
1972                         printk(KERN_ERR "EXT3-fs: error updating journal.\n");
1973                         journal_destroy(journal);
1974                         return err;
1975                 }
1976         }
1977
1978         if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER))
1979                 err = journal_wipe(journal, !really_read_only);
1980         if (!err)
1981                 err = journal_load(journal);
1982
1983         if (err) {
1984                 printk(KERN_ERR "EXT3-fs: error loading journal.\n");
1985                 journal_destroy(journal);
1986                 return err;
1987         }
1988
1989         EXT3_SB(sb)->s_journal = journal;
1990         ext3_clear_journal_err(sb, es);
1991
1992         if (journal_devnum &&
1993             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
1994                 es->s_journal_dev = cpu_to_le32(journal_devnum);
1995                 sb->s_dirt = 1;
1996
1997                 /* Make sure we flush the recovery flag to disk. */
1998                 ext3_commit_super(sb, es, 1);
1999         }
2000
2001         return 0;
2002 }
2003
2004 static int ext3_create_journal(struct super_block * sb,
2005                                struct ext3_super_block * es,
2006                                int journal_inum)
2007 {
2008         journal_t *journal;
2009
2010         if (sb->s_flags & MS_RDONLY) {
2011                 printk(KERN_ERR "EXT3-fs: readonly filesystem when trying to "
2012                                 "create journal.\n");
2013                 return -EROFS;
2014         }
2015
2016         if (!(journal = ext3_get_journal(sb, journal_inum)))
2017                 return -EINVAL;
2018
2019         printk(KERN_INFO "EXT3-fs: creating new journal on inode %d\n",
2020                journal_inum);
2021
2022         if (journal_create(journal)) {
2023                 printk(KERN_ERR "EXT3-fs: error creating journal.\n");
2024                 journal_destroy(journal);
2025                 return -EIO;
2026         }
2027
2028         EXT3_SB(sb)->s_journal = journal;
2029
2030         ext3_update_dynamic_rev(sb);
2031         EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2032         EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL);
2033
2034         es->s_journal_inum = cpu_to_le32(journal_inum);
2035         sb->s_dirt = 1;
2036
2037         /* Make sure we flush the recovery flag to disk. */
2038         ext3_commit_super(sb, es, 1);
2039
2040         return 0;
2041 }
2042
2043 static void ext3_commit_super (struct super_block * sb,
2044                                struct ext3_super_block * es,
2045                                int sync)
2046 {
2047         struct buffer_head *sbh = EXT3_SB(sb)->s_sbh;
2048
2049         if (!sbh)
2050                 return;
2051         es->s_wtime = cpu_to_le32(get_seconds());
2052         es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
2053         es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
2054         BUFFER_TRACE(sbh, "marking dirty");
2055         mark_buffer_dirty(sbh);
2056         if (sync)
2057                 sync_dirty_buffer(sbh);
2058 }
2059
2060
2061 /*
2062  * Have we just finished recovery?  If so, and if we are mounting (or
2063  * remounting) the filesystem readonly, then we will end up with a
2064  * consistent fs on disk.  Record that fact.
2065  */
2066 static void ext3_mark_recovery_complete(struct super_block * sb,
2067                                         struct ext3_super_block * es)
2068 {
2069         journal_t *journal = EXT3_SB(sb)->s_journal;
2070
2071         journal_lock_updates(journal);
2072         journal_flush(journal);
2073         if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
2074             sb->s_flags & MS_RDONLY) {
2075                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2076                 sb->s_dirt = 0;
2077                 ext3_commit_super(sb, es, 1);
2078         }
2079         journal_unlock_updates(journal);
2080 }
2081
2082 /*
2083  * If we are mounting (or read-write remounting) a filesystem whose journal
2084  * has recorded an error from a previous lifetime, move that error to the
2085  * main filesystem now.
2086  */
2087 static void ext3_clear_journal_err(struct super_block * sb,
2088                                    struct ext3_super_block * es)
2089 {
2090         journal_t *journal;
2091         int j_errno;
2092         const char *errstr;
2093
2094         journal = EXT3_SB(sb)->s_journal;
2095
2096         /*
2097          * Now check for any error status which may have been recorded in the
2098          * journal by a prior ext3_error() or ext3_abort()
2099          */
2100
2101         j_errno = journal_errno(journal);
2102         if (j_errno) {
2103                 char nbuf[16];
2104
2105                 errstr = ext3_decode_error(sb, j_errno, nbuf);
2106                 ext3_warning(sb, __FUNCTION__, "Filesystem error recorded "
2107                              "from previous mount: %s", errstr);
2108                 ext3_warning(sb, __FUNCTION__, "Marking fs in need of "
2109                              "filesystem check.");
2110
2111                 EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
2112                 es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
2113                 ext3_commit_super (sb, es, 1);
2114
2115                 journal_clear_err(journal);
2116         }
2117 }
2118
2119 /*
2120  * Force the running and committing transactions to commit,
2121  * and wait on the commit.
2122  */
2123 int ext3_force_commit(struct super_block *sb)
2124 {
2125         journal_t *journal;
2126         int ret;
2127
2128         if (sb->s_flags & MS_RDONLY)
2129                 return 0;
2130
2131         journal = EXT3_SB(sb)->s_journal;
2132         sb->s_dirt = 0;
2133         ret = ext3_journal_force_commit(journal);
2134         return ret;
2135 }
2136
2137 /*
2138  * Ext3 always journals updates to the superblock itself, so we don't
2139  * have to propagate any other updates to the superblock on disk at this
2140  * point.  Just start an async writeback to get the buffers on their way
2141  * to the disk.
2142  *
2143  * This implicitly triggers the writebehind on sync().
2144  */
2145
2146 static void ext3_write_super (struct super_block * sb)
2147 {
2148         if (mutex_trylock(&sb->s_lock) != 0)
2149                 BUG();
2150         sb->s_dirt = 0;
2151 }
2152
2153 static int ext3_sync_fs(struct super_block *sb, int wait)
2154 {
2155         tid_t target;
2156
2157         sb->s_dirt = 0;
2158         if (journal_start_commit(EXT3_SB(sb)->s_journal, &target)) {
2159                 if (wait)
2160                         log_wait_commit(EXT3_SB(sb)->s_journal, target);
2161         }
2162         return 0;
2163 }
2164
2165 /*
2166  * LVM calls this function before a (read-only) snapshot is created.  This
2167  * gives us a chance to flush the journal completely and mark the fs clean.
2168  */
2169 static void ext3_write_super_lockfs(struct super_block *sb)
2170 {
2171         sb->s_dirt = 0;
2172
2173         if (!(sb->s_flags & MS_RDONLY)) {
2174                 journal_t *journal = EXT3_SB(sb)->s_journal;
2175
2176                 /* Now we set up the journal barrier. */
2177                 journal_lock_updates(journal);
2178                 journal_flush(journal);
2179
2180                 /* Journal blocked and flushed, clear needs_recovery flag. */
2181                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2182                 ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2183         }
2184 }
2185
2186 /*
2187  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
2188  * flag here, even though the filesystem is not technically dirty yet.
2189  */
2190 static void ext3_unlockfs(struct super_block *sb)
2191 {
2192         if (!(sb->s_flags & MS_RDONLY)) {
2193                 lock_super(sb);
2194                 /* Reser the needs_recovery flag before the fs is unlocked. */
2195                 EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
2196                 ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
2197                 unlock_super(sb);
2198                 journal_unlock_updates(EXT3_SB(sb)->s_journal);
2199         }
2200 }
2201
2202 static int ext3_remount (struct super_block * sb, int * flags, char * data)
2203 {
2204         struct ext3_super_block * es;
2205         struct ext3_sb_info *sbi = EXT3_SB(sb);
2206         unsigned long n_blocks_count = 0;
2207         unsigned long old_sb_flags;
2208         struct ext3_mount_options old_opts;
2209         int err;
2210 #ifdef CONFIG_QUOTA
2211         int i;
2212 #endif
2213
2214         /* Store the original options */
2215         old_sb_flags = sb->s_flags;
2216         old_opts.s_mount_opt = sbi->s_mount_opt;
2217         old_opts.s_resuid = sbi->s_resuid;
2218         old_opts.s_resgid = sbi->s_resgid;
2219         old_opts.s_commit_interval = sbi->s_commit_interval;
2220 #ifdef CONFIG_QUOTA
2221         old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
2222         for (i = 0; i < MAXQUOTAS; i++)
2223                 old_opts.s_qf_names[i] = sbi->s_qf_names[i];
2224 #endif
2225
2226         /*
2227          * Allow the "check" option to be passed as a remount option.
2228          */
2229         if (!parse_options(data, sb, NULL, NULL, &n_blocks_count, 1)) {
2230                 err = -EINVAL;
2231                 goto restore_opts;
2232         }
2233
2234         if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
2235                 ext3_abort(sb, __FUNCTION__, "Abort forced by user");
2236
2237         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2238                 ((sbi->s_mount_opt & EXT3_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
2239
2240         es = sbi->s_es;
2241
2242         ext3_init_journal_params(sb, sbi->s_journal);
2243
2244         if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
2245                 n_blocks_count > le32_to_cpu(es->s_blocks_count)) {
2246                 if (sbi->s_mount_opt & EXT3_MOUNT_ABORT) {
2247                         err = -EROFS;
2248                         goto restore_opts;
2249                 }
2250
2251                 if (*flags & MS_RDONLY) {
2252                         /*
2253                          * First of all, the unconditional stuff we have to do
2254                          * to disable replay of the journal when we next remount
2255                          */
2256                         sb->s_flags |= MS_RDONLY;
2257
2258                         /*
2259                          * OK, test if we are remounting a valid rw partition
2260                          * readonly, and if so set the rdonly flag and then
2261                          * mark the partition as valid again.
2262                          */
2263                         if (!(es->s_state & cpu_to_le16(EXT3_VALID_FS)) &&
2264                             (sbi->s_mount_state & EXT3_VALID_FS))
2265                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
2266
2267                         ext3_mark_recovery_complete(sb, es);
2268                 } else {
2269                         __le32 ret;
2270                         if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
2271                                         ~EXT3_FEATURE_RO_COMPAT_SUPP))) {
2272                                 printk(KERN_WARNING "EXT3-fs: %s: couldn't "
2273                                        "remount RDWR because of unsupported "
2274                                        "optional features (%x).\n",
2275                                        sb->s_id, le32_to_cpu(ret));
2276                                 err = -EROFS;
2277                                 goto restore_opts;
2278                         }
2279                         /*
2280                          * Mounting a RDONLY partition read-write, so reread
2281                          * and store the current valid flag.  (It may have
2282                          * been changed by e2fsck since we originally mounted
2283                          * the partition.)
2284                          */
2285                         ext3_clear_journal_err(sb, es);
2286                         sbi->s_mount_state = le16_to_cpu(es->s_state);
2287                         if ((ret = ext3_group_extend(sb, es, n_blocks_count))) {
2288                                 err = ret;
2289                                 goto restore_opts;
2290                         }
2291                         if (!ext3_setup_super (sb, es, 0))
2292                                 sb->s_flags &= ~MS_RDONLY;
2293                 }
2294         }
2295 #ifdef CONFIG_QUOTA
2296         /* Release old quota file names */
2297         for (i = 0; i < MAXQUOTAS; i++)
2298                 if (old_opts.s_qf_names[i] &&
2299                     old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2300                         kfree(old_opts.s_qf_names[i]);
2301 #endif
2302         return 0;
2303 restore_opts:
2304         sb->s_flags = old_sb_flags;
2305         sbi->s_mount_opt = old_opts.s_mount_opt;
2306         sbi->s_resuid = old_opts.s_resuid;
2307         sbi->s_resgid = old_opts.s_resgid;
2308         sbi->s_commit_interval = old_opts.s_commit_interval;
2309 #ifdef CONFIG_QUOTA
2310         sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
2311         for (i = 0; i < MAXQUOTAS; i++) {
2312                 if (sbi->s_qf_names[i] &&
2313                     old_opts.s_qf_names[i] != sbi->s_qf_names[i])
2314                         kfree(sbi->s_qf_names[i]);
2315                 sbi->s_qf_names[i] = old_opts.s_qf_names[i];
2316         }
2317 #endif
2318         return err;
2319 }
2320
2321 static int ext3_statfs (struct super_block * sb, struct kstatfs * buf)
2322 {
2323         struct ext3_sb_info *sbi = EXT3_SB(sb);
2324         struct ext3_super_block *es = sbi->s_es;
2325         unsigned long overhead;
2326         int i;
2327
2328         if (test_opt (sb, MINIX_DF))
2329                 overhead = 0;
2330         else {
2331                 unsigned long ngroups;
2332                 ngroups = EXT3_SB(sb)->s_groups_count;
2333                 smp_rmb();
2334
2335                 /*
2336                  * Compute the overhead (FS structures)
2337                  */
2338
2339                 /*
2340                  * All of the blocks before first_data_block are
2341                  * overhead
2342                  */
2343                 overhead = le32_to_cpu(es->s_first_data_block);
2344
2345                 /*
2346                  * Add the overhead attributed to the superblock and
2347                  * block group descriptors.  If the sparse superblocks
2348                  * feature is turned on, then not all groups have this.
2349                  */
2350                 for (i = 0; i < ngroups; i++) {
2351                         overhead += ext3_bg_has_super(sb, i) +
2352                                 ext3_bg_num_gdb(sb, i);
2353                         cond_resched();
2354                 }
2355
2356                 /*
2357                  * Every block group has an inode bitmap, a block
2358                  * bitmap, and an inode table.
2359                  */
2360                 overhead += (ngroups * (2 + EXT3_SB(sb)->s_itb_per_group));
2361         }
2362
2363         buf->f_type = EXT3_SUPER_MAGIC;
2364         buf->f_bsize = sb->s_blocksize;
2365         buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
2366         buf->f_bfree = percpu_counter_sum(&sbi->s_freeblocks_counter);
2367         buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
2368         if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
2369                 buf->f_bavail = 0;
2370         buf->f_files = le32_to_cpu(es->s_inodes_count);
2371         buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
2372         buf->f_namelen = EXT3_NAME_LEN;
2373         return 0;
2374 }
2375
2376 /* Helper function for writing quotas on sync - we need to start transaction before quota file
2377  * is locked for write. Otherwise the are possible deadlocks:
2378  * Process 1                         Process 2
2379  * ext3_create()                     quota_sync()
2380  *   journal_start()                   write_dquot()
2381  *   DQUOT_INIT()                        down(dqio_mutex)
2382  *     down(dqio_mutex)                    journal_start()
2383  *
2384  */
2385
2386 #ifdef CONFIG_QUOTA
2387
2388 static inline struct inode *dquot_to_inode(struct dquot *dquot)
2389 {
2390         return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
2391 }
2392
2393 static int ext3_dquot_initialize(struct inode *inode, int type)
2394 {
2395         handle_t *handle;
2396         int ret, err;
2397
2398         /* We may create quota structure so we need to reserve enough blocks */
2399         handle = ext3_journal_start(inode, 2*EXT3_QUOTA_INIT_BLOCKS(inode->i_sb));
2400         if (IS_ERR(handle))
2401                 return PTR_ERR(handle);
2402         ret = dquot_initialize(inode, type);
2403         err = ext3_journal_stop(handle);
2404         if (!ret)
2405                 ret = err;
2406         return ret;
2407 }
2408
2409 static int ext3_dquot_drop(struct inode *inode)
2410 {
2411         handle_t *handle;
2412         int ret, err;
2413
2414         /* We may delete quota structure so we need to reserve enough blocks */
2415         handle = ext3_journal_start(inode, 2*EXT3_QUOTA_DEL_BLOCKS(inode->i_sb));
2416         if (IS_ERR(handle))
2417                 return PTR_ERR(handle);
2418         ret = dquot_drop(inode);
2419         err = ext3_journal_stop(handle);
2420         if (!ret)
2421                 ret = err;
2422         return ret;
2423 }
2424
2425 static int ext3_write_dquot(struct dquot *dquot)
2426 {
2427         int ret, err;
2428         handle_t *handle;
2429         struct inode *inode;
2430
2431         inode = dquot_to_inode(dquot);
2432         handle = ext3_journal_start(inode,
2433                                         EXT3_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
2434         if (IS_ERR(handle))
2435                 return PTR_ERR(handle);
2436         ret = dquot_commit(dquot);
2437         err = ext3_journal_stop(handle);
2438         if (!ret)
2439                 ret = err;
2440         return ret;
2441 }
2442
2443 static int ext3_acquire_dquot(struct dquot *dquot)
2444 {
2445         int ret, err;
2446         handle_t *handle;
2447
2448         handle = ext3_journal_start(dquot_to_inode(dquot),
2449                                         EXT3_QUOTA_INIT_BLOCKS(dquot->dq_sb));
2450         if (IS_ERR(handle))
2451                 return PTR_ERR(handle);
2452         ret = dquot_acquire(dquot);
2453         err = ext3_journal_stop(handle);
2454         if (!ret)
2455                 ret = err;
2456         return ret;
2457 }
2458
2459 static int ext3_release_dquot(struct dquot *dquot)
2460 {
2461         int ret, err;
2462         handle_t *handle;
2463
2464         handle = ext3_journal_start(dquot_to_inode(dquot),
2465                                         EXT3_QUOTA_DEL_BLOCKS(dquot->dq_sb));
2466         if (IS_ERR(handle))
2467                 return PTR_ERR(handle);
2468         ret = dquot_release(dquot);
2469         err = ext3_journal_stop(handle);
2470         if (!ret)
2471                 ret = err;
2472         return ret;
2473 }
2474
2475 static int ext3_mark_dquot_dirty(struct dquot *dquot)
2476 {
2477         /* Are we journalling quotas? */
2478         if (EXT3_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
2479             EXT3_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
2480                 dquot_mark_dquot_dirty(dquot);
2481                 return ext3_write_dquot(dquot);
2482         } else {
2483                 return dquot_mark_dquot_dirty(dquot);
2484         }
2485 }
2486
2487 static int ext3_write_info(struct super_block *sb, int type)
2488 {
2489         int ret, err;
2490         handle_t *handle;
2491
2492         /* Data block + inode block */
2493         handle = ext3_journal_start(sb->s_root->d_inode, 2);
2494         if (IS_ERR(handle))
2495                 return PTR_ERR(handle);
2496         ret = dquot_commit_info(sb, type);
2497         err = ext3_journal_stop(handle);
2498         if (!ret)
2499                 ret = err;
2500         return ret;
2501 }
2502
2503 /*
2504  * Turn on quotas during mount time - we need to find
2505  * the quota file and such...
2506  */
2507 static int ext3_quota_on_mount(struct super_block *sb, int type)
2508 {
2509         return vfs_quota_on_mount(sb, EXT3_SB(sb)->s_qf_names[type],
2510                         EXT3_SB(sb)->s_jquota_fmt, type);
2511 }
2512
2513 /*
2514  * Standard function to be called on quota_on
2515  */
2516 static int ext3_quota_on(struct super_block *sb, int type, int format_id,
2517                          char *path)
2518 {
2519         int err;
2520         struct nameidata nd;
2521
2522         if (!test_opt(sb, QUOTA))
2523                 return -EINVAL;
2524         /* Not journalling quota? */
2525         if (!EXT3_SB(sb)->s_qf_names[USRQUOTA] &&
2526             !EXT3_SB(sb)->s_qf_names[GRPQUOTA])
2527                 return vfs_quota_on(sb, type, format_id, path);
2528         err = path_lookup(path, LOOKUP_FOLLOW, &nd);
2529         if (err)
2530                 return err;
2531         /* Quotafile not on the same filesystem? */
2532         if (nd.mnt->mnt_sb != sb) {
2533                 path_release(&nd);
2534                 return -EXDEV;
2535         }
2536         /* Quotafile not of fs root? */
2537         if (nd.dentry->d_parent->d_inode != sb->s_root->d_inode)
2538                 printk(KERN_WARNING
2539                         "EXT3-fs: Quota file not on filesystem root. "
2540                         "Journalled quota will not work.\n");
2541         path_release(&nd);
2542         return vfs_quota_on(sb, type, format_id, path);
2543 }
2544
2545 /* Read data from quotafile - avoid pagecache and such because we cannot afford
2546  * acquiring the locks... As quota files are never truncated and quota code
2547  * itself serializes the operations (and noone else should touch the files)
2548  * we don't have to be afraid of races */
2549 static ssize_t ext3_quota_read(struct super_block *sb, int type, char *data,
2550                                size_t len, loff_t off)
2551 {
2552         struct inode *inode = sb_dqopt(sb)->files[type];
2553         sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
2554         int err = 0;
2555         int offset = off & (sb->s_blocksize - 1);
2556         int tocopy;
2557         size_t toread;
2558         struct buffer_head *bh;
2559         loff_t i_size = i_size_read(inode);
2560
2561         if (off > i_size)
2562                 return 0;
2563         if (off+len > i_size)
2564                 len = i_size-off;
2565         toread = len;
2566         while (toread > 0) {
2567                 tocopy = sb->s_blocksize - offset < toread ?
2568                                 sb->s_blocksize - offset : toread;
2569                 bh = ext3_bread(NULL, inode, blk, 0, &err);
2570                 if (err)
2571                         return err;
2572                 if (!bh)        /* A hole? */
2573                         memset(data, 0, tocopy);
2574                 else
2575                         memcpy(data, bh->b_data+offset, tocopy);
2576                 brelse(bh);
2577                 offset = 0;
2578                 toread -= tocopy;
2579                 data += tocopy;
2580                 blk++;
2581         }
2582         return len;
2583 }
2584
2585 /* Write to quotafile (we know the transaction is already started and has
2586  * enough credits) */
2587 static ssize_t ext3_quota_write(struct super_block *sb, int type,
2588                                 const char *data, size_t len, loff_t off)
2589 {
2590         struct inode *inode = sb_dqopt(sb)->files[type];
2591         sector_t blk = off >> EXT3_BLOCK_SIZE_BITS(sb);
2592         int err = 0;
2593         int offset = off & (sb->s_blocksize - 1);
2594         int tocopy;
2595         int journal_quota = EXT3_SB(sb)->s_qf_names[type] != NULL;
2596         size_t towrite = len;
2597         struct buffer_head *bh;
2598         handle_t *handle = journal_current_handle();
2599
2600         mutex_lock(&inode->i_mutex);
2601         while (towrite > 0) {
2602                 tocopy = sb->s_blocksize - offset < towrite ?
2603                                 sb->s_blocksize - offset : towrite;
2604                 bh = ext3_bread(handle, inode, blk, 1, &err);
2605                 if (!bh)
2606                         goto out;
2607                 if (journal_quota) {
2608                         err = ext3_journal_get_write_access(handle, bh);
2609                         if (err) {
2610                                 brelse(bh);
2611                                 goto out;
2612                         }
2613                 }
2614                 lock_buffer(bh);
2615                 memcpy(bh->b_data+offset, data, tocopy);
2616                 flush_dcache_page(bh->b_page);
2617                 unlock_buffer(bh);
2618                 if (journal_quota)
2619                         err = ext3_journal_dirty_metadata(handle, bh);
2620                 else {
2621                         /* Always do at least ordered writes for quotas */
2622                         err = ext3_journal_dirty_data(handle, bh);
2623                         mark_buffer_dirty(bh);
2624                 }
2625                 brelse(bh);
2626                 if (err)
2627                         goto out;
2628                 offset = 0;
2629                 towrite -= tocopy;
2630                 data += tocopy;
2631                 blk++;
2632         }
2633 out:
2634         if (len == towrite)
2635                 return err;
2636         if (inode->i_size < off+len-towrite) {
2637                 i_size_write(inode, off+len-towrite);
2638                 EXT3_I(inode)->i_disksize = inode->i_size;
2639         }
2640         inode->i_version++;
2641         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
2642         ext3_mark_inode_dirty(handle, inode);
2643         mutex_unlock(&inode->i_mutex);
2644         return len - towrite;
2645 }
2646
2647 #endif
2648
2649 static int ext3_get_sb(struct file_system_type *fs_type,
2650         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
2651 {
2652         return get_sb_bdev(fs_type, flags, dev_name, data, ext3_fill_super, mnt);
2653 }
2654
2655 static struct file_system_type ext3_fs_type = {
2656         .owner          = THIS_MODULE,
2657         .name           = "ext3",
2658         .get_sb         = ext3_get_sb,
2659         .kill_sb        = kill_block_super,
2660         .fs_flags       = FS_REQUIRES_DEV,
2661 };
2662
2663 static int __init init_ext3_fs(void)
2664 {
2665         int err = init_ext3_xattr();
2666         if (err)
2667                 return err;
2668         err = init_inodecache();
2669         if (err)
2670                 goto out1;
2671         err = register_filesystem(&ext3_fs_type);
2672         if (err)
2673                 goto out;
2674         return 0;
2675 out:
2676         destroy_inodecache();
2677 out1:
2678         exit_ext3_xattr();
2679         return err;
2680 }
2681
2682 static void __exit exit_ext3_fs(void)
2683 {
2684         unregister_filesystem(&ext3_fs_type);
2685         destroy_inodecache();
2686         exit_ext3_xattr();
2687 }
2688
2689 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
2690 MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
2691 MODULE_LICENSE("GPL");
2692 module_init(init_ext3_fs)
2693 module_exit(exit_ext3_fs)