Push BKL down into ->remount_fs()
[linux-2.6.git] / fs / ext2 / super.c
1 /*
2  *  linux/fs/ext2/super.c
3  *
4  * Copyright (C) 1992, 1993, 1994, 1995
5  * Remy Card (card@masi.ibp.fr)
6  * Laboratoire MASI - Institut Blaise Pascal
7  * Universite Pierre et Marie Curie (Paris VI)
8  *
9  *  from
10  *
11  *  linux/fs/minix/inode.c
12  *
13  *  Copyright (C) 1991, 1992  Linus Torvalds
14  *
15  *  Big-endian to little-endian byte-swapping/bitmaps by
16  *        David S. Miller (davem@caip.rutgers.edu), 1995
17  */
18
19 #include <linux/module.h>
20 #include <linux/string.h>
21 #include <linux/fs.h>
22 #include <linux/slab.h>
23 #include <linux/init.h>
24 #include <linux/blkdev.h>
25 #include <linux/parser.h>
26 #include <linux/random.h>
27 #include <linux/buffer_head.h>
28 #include <linux/exportfs.h>
29 #include <linux/smp_lock.h>
30 #include <linux/vfs.h>
31 #include <linux/seq_file.h>
32 #include <linux/mount.h>
33 #include <linux/log2.h>
34 #include <linux/quotaops.h>
35 #include <asm/uaccess.h>
36 #include "ext2.h"
37 #include "xattr.h"
38 #include "acl.h"
39 #include "xip.h"
40
41 static void ext2_sync_super(struct super_block *sb,
42                             struct ext2_super_block *es);
43 static int ext2_remount (struct super_block * sb, int * flags, char * data);
44 static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf);
45
46 void ext2_error (struct super_block * sb, const char * function,
47                  const char * fmt, ...)
48 {
49         va_list args;
50         struct ext2_sb_info *sbi = EXT2_SB(sb);
51         struct ext2_super_block *es = sbi->s_es;
52
53         if (!(sb->s_flags & MS_RDONLY)) {
54                 sbi->s_mount_state |= EXT2_ERROR_FS;
55                 es->s_state |= cpu_to_le16(EXT2_ERROR_FS);
56                 ext2_sync_super(sb, es);
57         }
58
59         va_start(args, fmt);
60         printk(KERN_CRIT "EXT2-fs error (device %s): %s: ",sb->s_id, function);
61         vprintk(fmt, args);
62         printk("\n");
63         va_end(args);
64
65         if (test_opt(sb, ERRORS_PANIC))
66                 panic("EXT2-fs panic from previous error\n");
67         if (test_opt(sb, ERRORS_RO)) {
68                 printk("Remounting filesystem read-only\n");
69                 sb->s_flags |= MS_RDONLY;
70         }
71 }
72
73 void ext2_warning (struct super_block * sb, const char * function,
74                    const char * fmt, ...)
75 {
76         va_list args;
77
78         va_start(args, fmt);
79         printk(KERN_WARNING "EXT2-fs warning (device %s): %s: ",
80                sb->s_id, function);
81         vprintk(fmt, args);
82         printk("\n");
83         va_end(args);
84 }
85
86 void ext2_update_dynamic_rev(struct super_block *sb)
87 {
88         struct ext2_super_block *es = EXT2_SB(sb)->s_es;
89
90         if (le32_to_cpu(es->s_rev_level) > EXT2_GOOD_OLD_REV)
91                 return;
92
93         ext2_warning(sb, __func__,
94                      "updating to rev %d because of new feature flag, "
95                      "running e2fsck is recommended",
96                      EXT2_DYNAMIC_REV);
97
98         es->s_first_ino = cpu_to_le32(EXT2_GOOD_OLD_FIRST_INO);
99         es->s_inode_size = cpu_to_le16(EXT2_GOOD_OLD_INODE_SIZE);
100         es->s_rev_level = cpu_to_le32(EXT2_DYNAMIC_REV);
101         /* leave es->s_feature_*compat flags alone */
102         /* es->s_uuid will be set by e2fsck if empty */
103
104         /*
105          * The rest of the superblock fields should be zero, and if not it
106          * means they are likely already in use, so leave them alone.  We
107          * can leave it up to e2fsck to clean up any inconsistencies there.
108          */
109 }
110
111 static void ext2_put_super (struct super_block * sb)
112 {
113         int db_count;
114         int i;
115         struct ext2_sb_info *sbi = EXT2_SB(sb);
116
117         lock_kernel();
118
119         if (sb->s_dirt)
120                 ext2_write_super(sb);
121
122         ext2_xattr_put_super(sb);
123         if (!(sb->s_flags & MS_RDONLY)) {
124                 struct ext2_super_block *es = sbi->s_es;
125
126                 es->s_state = cpu_to_le16(sbi->s_mount_state);
127                 ext2_sync_super(sb, es);
128         }
129         db_count = sbi->s_gdb_count;
130         for (i = 0; i < db_count; i++)
131                 if (sbi->s_group_desc[i])
132                         brelse (sbi->s_group_desc[i]);
133         kfree(sbi->s_group_desc);
134         kfree(sbi->s_debts);
135         percpu_counter_destroy(&sbi->s_freeblocks_counter);
136         percpu_counter_destroy(&sbi->s_freeinodes_counter);
137         percpu_counter_destroy(&sbi->s_dirs_counter);
138         brelse (sbi->s_sbh);
139         sb->s_fs_info = NULL;
140         kfree(sbi->s_blockgroup_lock);
141         kfree(sbi);
142
143         unlock_kernel();
144 }
145
146 static struct kmem_cache * ext2_inode_cachep;
147
148 static struct inode *ext2_alloc_inode(struct super_block *sb)
149 {
150         struct ext2_inode_info *ei;
151         ei = (struct ext2_inode_info *)kmem_cache_alloc(ext2_inode_cachep, GFP_KERNEL);
152         if (!ei)
153                 return NULL;
154 #ifdef CONFIG_EXT2_FS_POSIX_ACL
155         ei->i_acl = EXT2_ACL_NOT_CACHED;
156         ei->i_default_acl = EXT2_ACL_NOT_CACHED;
157 #endif
158         ei->i_block_alloc_info = NULL;
159         ei->vfs_inode.i_version = 1;
160         return &ei->vfs_inode;
161 }
162
163 static void ext2_destroy_inode(struct inode *inode)
164 {
165         kmem_cache_free(ext2_inode_cachep, EXT2_I(inode));
166 }
167
168 static void init_once(void *foo)
169 {
170         struct ext2_inode_info *ei = (struct ext2_inode_info *) foo;
171
172         rwlock_init(&ei->i_meta_lock);
173 #ifdef CONFIG_EXT2_FS_XATTR
174         init_rwsem(&ei->xattr_sem);
175 #endif
176         mutex_init(&ei->truncate_mutex);
177         inode_init_once(&ei->vfs_inode);
178 }
179
180 static int init_inodecache(void)
181 {
182         ext2_inode_cachep = kmem_cache_create("ext2_inode_cache",
183                                              sizeof(struct ext2_inode_info),
184                                              0, (SLAB_RECLAIM_ACCOUNT|
185                                                 SLAB_MEM_SPREAD),
186                                              init_once);
187         if (ext2_inode_cachep == NULL)
188                 return -ENOMEM;
189         return 0;
190 }
191
192 static void destroy_inodecache(void)
193 {
194         kmem_cache_destroy(ext2_inode_cachep);
195 }
196
197 static void ext2_clear_inode(struct inode *inode)
198 {
199         struct ext2_block_alloc_info *rsv = EXT2_I(inode)->i_block_alloc_info;
200 #ifdef CONFIG_EXT2_FS_POSIX_ACL
201         struct ext2_inode_info *ei = EXT2_I(inode);
202
203         if (ei->i_acl && ei->i_acl != EXT2_ACL_NOT_CACHED) {
204                 posix_acl_release(ei->i_acl);
205                 ei->i_acl = EXT2_ACL_NOT_CACHED;
206         }
207         if (ei->i_default_acl && ei->i_default_acl != EXT2_ACL_NOT_CACHED) {
208                 posix_acl_release(ei->i_default_acl);
209                 ei->i_default_acl = EXT2_ACL_NOT_CACHED;
210         }
211 #endif
212         ext2_discard_reservation(inode);
213         EXT2_I(inode)->i_block_alloc_info = NULL;
214         if (unlikely(rsv))
215                 kfree(rsv);
216 }
217
218 static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
219 {
220         struct super_block *sb = vfs->mnt_sb;
221         struct ext2_sb_info *sbi = EXT2_SB(sb);
222         struct ext2_super_block *es = sbi->s_es;
223         unsigned long def_mount_opts;
224
225         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
226
227         if (sbi->s_sb_block != 1)
228                 seq_printf(seq, ",sb=%lu", sbi->s_sb_block);
229         if (test_opt(sb, MINIX_DF))
230                 seq_puts(seq, ",minixdf");
231         if (test_opt(sb, GRPID))
232                 seq_puts(seq, ",grpid");
233         if (!test_opt(sb, GRPID) && (def_mount_opts & EXT2_DEFM_BSDGROUPS))
234                 seq_puts(seq, ",nogrpid");
235         if (sbi->s_resuid != EXT2_DEF_RESUID ||
236             le16_to_cpu(es->s_def_resuid) != EXT2_DEF_RESUID) {
237                 seq_printf(seq, ",resuid=%u", sbi->s_resuid);
238         }
239         if (sbi->s_resgid != EXT2_DEF_RESGID ||
240             le16_to_cpu(es->s_def_resgid) != EXT2_DEF_RESGID) {
241                 seq_printf(seq, ",resgid=%u", sbi->s_resgid);
242         }
243         if (test_opt(sb, ERRORS_RO)) {
244                 int def_errors = le16_to_cpu(es->s_errors);
245
246                 if (def_errors == EXT2_ERRORS_PANIC ||
247                     def_errors == EXT2_ERRORS_CONTINUE) {
248                         seq_puts(seq, ",errors=remount-ro");
249                 }
250         }
251         if (test_opt(sb, ERRORS_CONT))
252                 seq_puts(seq, ",errors=continue");
253         if (test_opt(sb, ERRORS_PANIC))
254                 seq_puts(seq, ",errors=panic");
255         if (test_opt(sb, NO_UID32))
256                 seq_puts(seq, ",nouid32");
257         if (test_opt(sb, DEBUG))
258                 seq_puts(seq, ",debug");
259         if (test_opt(sb, OLDALLOC))
260                 seq_puts(seq, ",oldalloc");
261
262 #ifdef CONFIG_EXT2_FS_XATTR
263         if (test_opt(sb, XATTR_USER))
264                 seq_puts(seq, ",user_xattr");
265         if (!test_opt(sb, XATTR_USER) &&
266             (def_mount_opts & EXT2_DEFM_XATTR_USER)) {
267                 seq_puts(seq, ",nouser_xattr");
268         }
269 #endif
270
271 #ifdef CONFIG_EXT2_FS_POSIX_ACL
272         if (test_opt(sb, POSIX_ACL))
273                 seq_puts(seq, ",acl");
274         if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT2_DEFM_ACL))
275                 seq_puts(seq, ",noacl");
276 #endif
277
278         if (test_opt(sb, NOBH))
279                 seq_puts(seq, ",nobh");
280
281 #if defined(CONFIG_QUOTA)
282         if (sbi->s_mount_opt & EXT2_MOUNT_USRQUOTA)
283                 seq_puts(seq, ",usrquota");
284
285         if (sbi->s_mount_opt & EXT2_MOUNT_GRPQUOTA)
286                 seq_puts(seq, ",grpquota");
287 #endif
288
289 #if defined(CONFIG_EXT2_FS_XIP)
290         if (sbi->s_mount_opt & EXT2_MOUNT_XIP)
291                 seq_puts(seq, ",xip");
292 #endif
293
294         if (!test_opt(sb, RESERVATION))
295                 seq_puts(seq, ",noreservation");
296
297         return 0;
298 }
299
300 #ifdef CONFIG_QUOTA
301 static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data, size_t len, loff_t off);
302 static ssize_t ext2_quota_write(struct super_block *sb, int type, const char *data, size_t len, loff_t off);
303 #endif
304
305 static const struct super_operations ext2_sops = {
306         .alloc_inode    = ext2_alloc_inode,
307         .destroy_inode  = ext2_destroy_inode,
308         .write_inode    = ext2_write_inode,
309         .delete_inode   = ext2_delete_inode,
310         .put_super      = ext2_put_super,
311         .write_super    = ext2_write_super,
312         .statfs         = ext2_statfs,
313         .remount_fs     = ext2_remount,
314         .clear_inode    = ext2_clear_inode,
315         .show_options   = ext2_show_options,
316 #ifdef CONFIG_QUOTA
317         .quota_read     = ext2_quota_read,
318         .quota_write    = ext2_quota_write,
319 #endif
320 };
321
322 static struct inode *ext2_nfs_get_inode(struct super_block *sb,
323                 u64 ino, u32 generation)
324 {
325         struct inode *inode;
326
327         if (ino < EXT2_FIRST_INO(sb) && ino != EXT2_ROOT_INO)
328                 return ERR_PTR(-ESTALE);
329         if (ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
330                 return ERR_PTR(-ESTALE);
331
332         /* iget isn't really right if the inode is currently unallocated!!
333          * ext2_read_inode currently does appropriate checks, but
334          * it might be "neater" to call ext2_get_inode first and check
335          * if the inode is valid.....
336          */
337         inode = ext2_iget(sb, ino);
338         if (IS_ERR(inode))
339                 return ERR_CAST(inode);
340         if (generation && inode->i_generation != generation) {
341                 /* we didn't find the right inode.. */
342                 iput(inode);
343                 return ERR_PTR(-ESTALE);
344         }
345         return inode;
346 }
347
348 static struct dentry *ext2_fh_to_dentry(struct super_block *sb, struct fid *fid,
349                 int fh_len, int fh_type)
350 {
351         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
352                                     ext2_nfs_get_inode);
353 }
354
355 static struct dentry *ext2_fh_to_parent(struct super_block *sb, struct fid *fid,
356                 int fh_len, int fh_type)
357 {
358         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
359                                     ext2_nfs_get_inode);
360 }
361
362 /* Yes, most of these are left as NULL!!
363  * A NULL value implies the default, which works with ext2-like file
364  * systems, but can be improved upon.
365  * Currently only get_parent is required.
366  */
367 static const struct export_operations ext2_export_ops = {
368         .fh_to_dentry = ext2_fh_to_dentry,
369         .fh_to_parent = ext2_fh_to_parent,
370         .get_parent = ext2_get_parent,
371 };
372
373 static unsigned long get_sb_block(void **data)
374 {
375         unsigned long   sb_block;
376         char            *options = (char *) *data;
377
378         if (!options || strncmp(options, "sb=", 3) != 0)
379                 return 1;       /* Default location */
380         options += 3;
381         sb_block = simple_strtoul(options, &options, 0);
382         if (*options && *options != ',') {
383                 printk("EXT2-fs: Invalid sb specification: %s\n",
384                        (char *) *data);
385                 return 1;
386         }
387         if (*options == ',')
388                 options++;
389         *data = (void *) options;
390         return sb_block;
391 }
392
393 enum {
394         Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
395         Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic,
396         Opt_err_ro, Opt_nouid32, Opt_nocheck, Opt_debug,
397         Opt_oldalloc, Opt_orlov, Opt_nobh, Opt_user_xattr, Opt_nouser_xattr,
398         Opt_acl, Opt_noacl, Opt_xip, Opt_ignore, Opt_err, Opt_quota,
399         Opt_usrquota, Opt_grpquota, Opt_reservation, Opt_noreservation
400 };
401
402 static const match_table_t tokens = {
403         {Opt_bsd_df, "bsddf"},
404         {Opt_minix_df, "minixdf"},
405         {Opt_grpid, "grpid"},
406         {Opt_grpid, "bsdgroups"},
407         {Opt_nogrpid, "nogrpid"},
408         {Opt_nogrpid, "sysvgroups"},
409         {Opt_resgid, "resgid=%u"},
410         {Opt_resuid, "resuid=%u"},
411         {Opt_sb, "sb=%u"},
412         {Opt_err_cont, "errors=continue"},
413         {Opt_err_panic, "errors=panic"},
414         {Opt_err_ro, "errors=remount-ro"},
415         {Opt_nouid32, "nouid32"},
416         {Opt_nocheck, "check=none"},
417         {Opt_nocheck, "nocheck"},
418         {Opt_debug, "debug"},
419         {Opt_oldalloc, "oldalloc"},
420         {Opt_orlov, "orlov"},
421         {Opt_nobh, "nobh"},
422         {Opt_user_xattr, "user_xattr"},
423         {Opt_nouser_xattr, "nouser_xattr"},
424         {Opt_acl, "acl"},
425         {Opt_noacl, "noacl"},
426         {Opt_xip, "xip"},
427         {Opt_grpquota, "grpquota"},
428         {Opt_ignore, "noquota"},
429         {Opt_quota, "quota"},
430         {Opt_usrquota, "usrquota"},
431         {Opt_reservation, "reservation"},
432         {Opt_noreservation, "noreservation"},
433         {Opt_err, NULL}
434 };
435
436 static int parse_options (char * options,
437                           struct ext2_sb_info *sbi)
438 {
439         char * p;
440         substring_t args[MAX_OPT_ARGS];
441         int option;
442
443         if (!options)
444                 return 1;
445
446         while ((p = strsep (&options, ",")) != NULL) {
447                 int token;
448                 if (!*p)
449                         continue;
450
451                 token = match_token(p, tokens, args);
452                 switch (token) {
453                 case Opt_bsd_df:
454                         clear_opt (sbi->s_mount_opt, MINIX_DF);
455                         break;
456                 case Opt_minix_df:
457                         set_opt (sbi->s_mount_opt, MINIX_DF);
458                         break;
459                 case Opt_grpid:
460                         set_opt (sbi->s_mount_opt, GRPID);
461                         break;
462                 case Opt_nogrpid:
463                         clear_opt (sbi->s_mount_opt, GRPID);
464                         break;
465                 case Opt_resuid:
466                         if (match_int(&args[0], &option))
467                                 return 0;
468                         sbi->s_resuid = option;
469                         break;
470                 case Opt_resgid:
471                         if (match_int(&args[0], &option))
472                                 return 0;
473                         sbi->s_resgid = option;
474                         break;
475                 case Opt_sb:
476                         /* handled by get_sb_block() instead of here */
477                         /* *sb_block = match_int(&args[0]); */
478                         break;
479                 case Opt_err_panic:
480                         clear_opt (sbi->s_mount_opt, ERRORS_CONT);
481                         clear_opt (sbi->s_mount_opt, ERRORS_RO);
482                         set_opt (sbi->s_mount_opt, ERRORS_PANIC);
483                         break;
484                 case Opt_err_ro:
485                         clear_opt (sbi->s_mount_opt, ERRORS_CONT);
486                         clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
487                         set_opt (sbi->s_mount_opt, ERRORS_RO);
488                         break;
489                 case Opt_err_cont:
490                         clear_opt (sbi->s_mount_opt, ERRORS_RO);
491                         clear_opt (sbi->s_mount_opt, ERRORS_PANIC);
492                         set_opt (sbi->s_mount_opt, ERRORS_CONT);
493                         break;
494                 case Opt_nouid32:
495                         set_opt (sbi->s_mount_opt, NO_UID32);
496                         break;
497                 case Opt_nocheck:
498                         clear_opt (sbi->s_mount_opt, CHECK);
499                         break;
500                 case Opt_debug:
501                         set_opt (sbi->s_mount_opt, DEBUG);
502                         break;
503                 case Opt_oldalloc:
504                         set_opt (sbi->s_mount_opt, OLDALLOC);
505                         break;
506                 case Opt_orlov:
507                         clear_opt (sbi->s_mount_opt, OLDALLOC);
508                         break;
509                 case Opt_nobh:
510                         set_opt (sbi->s_mount_opt, NOBH);
511                         break;
512 #ifdef CONFIG_EXT2_FS_XATTR
513                 case Opt_user_xattr:
514                         set_opt (sbi->s_mount_opt, XATTR_USER);
515                         break;
516                 case Opt_nouser_xattr:
517                         clear_opt (sbi->s_mount_opt, XATTR_USER);
518                         break;
519 #else
520                 case Opt_user_xattr:
521                 case Opt_nouser_xattr:
522                         printk("EXT2 (no)user_xattr options not supported\n");
523                         break;
524 #endif
525 #ifdef CONFIG_EXT2_FS_POSIX_ACL
526                 case Opt_acl:
527                         set_opt(sbi->s_mount_opt, POSIX_ACL);
528                         break;
529                 case Opt_noacl:
530                         clear_opt(sbi->s_mount_opt, POSIX_ACL);
531                         break;
532 #else
533                 case Opt_acl:
534                 case Opt_noacl:
535                         printk("EXT2 (no)acl options not supported\n");
536                         break;
537 #endif
538                 case Opt_xip:
539 #ifdef CONFIG_EXT2_FS_XIP
540                         set_opt (sbi->s_mount_opt, XIP);
541 #else
542                         printk("EXT2 xip option not supported\n");
543 #endif
544                         break;
545
546 #if defined(CONFIG_QUOTA)
547                 case Opt_quota:
548                 case Opt_usrquota:
549                         set_opt(sbi->s_mount_opt, USRQUOTA);
550                         break;
551
552                 case Opt_grpquota:
553                         set_opt(sbi->s_mount_opt, GRPQUOTA);
554                         break;
555 #else
556                 case Opt_quota:
557                 case Opt_usrquota:
558                 case Opt_grpquota:
559                         printk(KERN_ERR
560                                 "EXT2-fs: quota operations not supported.\n");
561
562                         break;
563 #endif
564
565                 case Opt_reservation:
566                         set_opt(sbi->s_mount_opt, RESERVATION);
567                         printk("reservations ON\n");
568                         break;
569                 case Opt_noreservation:
570                         clear_opt(sbi->s_mount_opt, RESERVATION);
571                         printk("reservations OFF\n");
572                         break;
573                 case Opt_ignore:
574                         break;
575                 default:
576                         return 0;
577                 }
578         }
579         return 1;
580 }
581
582 static int ext2_setup_super (struct super_block * sb,
583                               struct ext2_super_block * es,
584                               int read_only)
585 {
586         int res = 0;
587         struct ext2_sb_info *sbi = EXT2_SB(sb);
588
589         if (le32_to_cpu(es->s_rev_level) > EXT2_MAX_SUPP_REV) {
590                 printk ("EXT2-fs warning: revision level too high, "
591                         "forcing read-only mode\n");
592                 res = MS_RDONLY;
593         }
594         if (read_only)
595                 return res;
596         if (!(sbi->s_mount_state & EXT2_VALID_FS))
597                 printk ("EXT2-fs warning: mounting unchecked fs, "
598                         "running e2fsck is recommended\n");
599         else if ((sbi->s_mount_state & EXT2_ERROR_FS))
600                 printk ("EXT2-fs warning: mounting fs with errors, "
601                         "running e2fsck is recommended\n");
602         else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
603                  le16_to_cpu(es->s_mnt_count) >=
604                  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
605                 printk ("EXT2-fs warning: maximal mount count reached, "
606                         "running e2fsck is recommended\n");
607         else if (le32_to_cpu(es->s_checkinterval) &&
608                 (le32_to_cpu(es->s_lastcheck) + le32_to_cpu(es->s_checkinterval) <= get_seconds()))
609                 printk ("EXT2-fs warning: checktime reached, "
610                         "running e2fsck is recommended\n");
611         if (!le16_to_cpu(es->s_max_mnt_count))
612                 es->s_max_mnt_count = cpu_to_le16(EXT2_DFL_MAX_MNT_COUNT);
613         le16_add_cpu(&es->s_mnt_count, 1);
614         ext2_write_super(sb);
615         if (test_opt (sb, DEBUG))
616                 printk ("[EXT II FS %s, %s, bs=%lu, fs=%lu, gc=%lu, "
617                         "bpg=%lu, ipg=%lu, mo=%04lx]\n",
618                         EXT2FS_VERSION, EXT2FS_DATE, sb->s_blocksize,
619                         sbi->s_frag_size,
620                         sbi->s_groups_count,
621                         EXT2_BLOCKS_PER_GROUP(sb),
622                         EXT2_INODES_PER_GROUP(sb),
623                         sbi->s_mount_opt);
624         return res;
625 }
626
627 static int ext2_check_descriptors(struct super_block *sb)
628 {
629         int i;
630         struct ext2_sb_info *sbi = EXT2_SB(sb);
631
632         ext2_debug ("Checking group descriptors");
633
634         for (i = 0; i < sbi->s_groups_count; i++) {
635                 struct ext2_group_desc *gdp = ext2_get_group_desc(sb, i, NULL);
636                 ext2_fsblk_t first_block = ext2_group_first_block_no(sb, i);
637                 ext2_fsblk_t last_block;
638
639                 if (i == sbi->s_groups_count - 1)
640                         last_block = le32_to_cpu(sbi->s_es->s_blocks_count) - 1;
641                 else
642                         last_block = first_block +
643                                 (EXT2_BLOCKS_PER_GROUP(sb) - 1);
644
645                 if (le32_to_cpu(gdp->bg_block_bitmap) < first_block ||
646                     le32_to_cpu(gdp->bg_block_bitmap) > last_block)
647                 {
648                         ext2_error (sb, "ext2_check_descriptors",
649                                     "Block bitmap for group %d"
650                                     " not in group (block %lu)!",
651                                     i, (unsigned long) le32_to_cpu(gdp->bg_block_bitmap));
652                         return 0;
653                 }
654                 if (le32_to_cpu(gdp->bg_inode_bitmap) < first_block ||
655                     le32_to_cpu(gdp->bg_inode_bitmap) > last_block)
656                 {
657                         ext2_error (sb, "ext2_check_descriptors",
658                                     "Inode bitmap for group %d"
659                                     " not in group (block %lu)!",
660                                     i, (unsigned long) le32_to_cpu(gdp->bg_inode_bitmap));
661                         return 0;
662                 }
663                 if (le32_to_cpu(gdp->bg_inode_table) < first_block ||
664                     le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group - 1 >
665                     last_block)
666                 {
667                         ext2_error (sb, "ext2_check_descriptors",
668                                     "Inode table for group %d"
669                                     " not in group (block %lu)!",
670                                     i, (unsigned long) le32_to_cpu(gdp->bg_inode_table));
671                         return 0;
672                 }
673         }
674         return 1;
675 }
676
677 /*
678  * Maximal file size.  There is a direct, and {,double-,triple-}indirect
679  * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
680  * We need to be 1 filesystem block less than the 2^32 sector limit.
681  */
682 static loff_t ext2_max_size(int bits)
683 {
684         loff_t res = EXT2_NDIR_BLOCKS;
685         int meta_blocks;
686         loff_t upper_limit;
687
688         /* This is calculated to be the largest file size for a
689          * dense, file such that the total number of
690          * sectors in the file, including data and all indirect blocks,
691          * does not exceed 2^32 -1
692          * __u32 i_blocks representing the total number of
693          * 512 bytes blocks of the file
694          */
695         upper_limit = (1LL << 32) - 1;
696
697         /* total blocks in file system block size */
698         upper_limit >>= (bits - 9);
699
700
701         /* indirect blocks */
702         meta_blocks = 1;
703         /* double indirect blocks */
704         meta_blocks += 1 + (1LL << (bits-2));
705         /* tripple indirect blocks */
706         meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
707
708         upper_limit -= meta_blocks;
709         upper_limit <<= bits;
710
711         res += 1LL << (bits-2);
712         res += 1LL << (2*(bits-2));
713         res += 1LL << (3*(bits-2));
714         res <<= bits;
715         if (res > upper_limit)
716                 res = upper_limit;
717
718         if (res > MAX_LFS_FILESIZE)
719                 res = MAX_LFS_FILESIZE;
720
721         return res;
722 }
723
724 static unsigned long descriptor_loc(struct super_block *sb,
725                                     unsigned long logic_sb_block,
726                                     int nr)
727 {
728         struct ext2_sb_info *sbi = EXT2_SB(sb);
729         unsigned long bg, first_meta_bg;
730         int has_super = 0;
731         
732         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
733
734         if (!EXT2_HAS_INCOMPAT_FEATURE(sb, EXT2_FEATURE_INCOMPAT_META_BG) ||
735             nr < first_meta_bg)
736                 return (logic_sb_block + nr + 1);
737         bg = sbi->s_desc_per_block * nr;
738         if (ext2_bg_has_super(sb, bg))
739                 has_super = 1;
740
741         return ext2_group_first_block_no(sb, bg) + has_super;
742 }
743
744 static int ext2_fill_super(struct super_block *sb, void *data, int silent)
745 {
746         struct buffer_head * bh;
747         struct ext2_sb_info * sbi;
748         struct ext2_super_block * es;
749         struct inode *root;
750         unsigned long block;
751         unsigned long sb_block = get_sb_block(&data);
752         unsigned long logic_sb_block;
753         unsigned long offset = 0;
754         unsigned long def_mount_opts;
755         long ret = -EINVAL;
756         int blocksize = BLOCK_SIZE;
757         int db_count;
758         int i, j;
759         __le32 features;
760         int err;
761
762         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
763         if (!sbi)
764                 return -ENOMEM;
765
766         sbi->s_blockgroup_lock =
767                 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
768         if (!sbi->s_blockgroup_lock) {
769                 kfree(sbi);
770                 return -ENOMEM;
771         }
772         sb->s_fs_info = sbi;
773         sbi->s_sb_block = sb_block;
774
775         /*
776          * See what the current blocksize for the device is, and
777          * use that as the blocksize.  Otherwise (or if the blocksize
778          * is smaller than the default) use the default.
779          * This is important for devices that have a hardware
780          * sectorsize that is larger than the default.
781          */
782         blocksize = sb_min_blocksize(sb, BLOCK_SIZE);
783         if (!blocksize) {
784                 printk ("EXT2-fs: unable to set blocksize\n");
785                 goto failed_sbi;
786         }
787
788         /*
789          * If the superblock doesn't start on a hardware sector boundary,
790          * calculate the offset.  
791          */
792         if (blocksize != BLOCK_SIZE) {
793                 logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
794                 offset = (sb_block*BLOCK_SIZE) % blocksize;
795         } else {
796                 logic_sb_block = sb_block;
797         }
798
799         if (!(bh = sb_bread(sb, logic_sb_block))) {
800                 printk ("EXT2-fs: unable to read superblock\n");
801                 goto failed_sbi;
802         }
803         /*
804          * Note: s_es must be initialized as soon as possible because
805          *       some ext2 macro-instructions depend on its value
806          */
807         es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
808         sbi->s_es = es;
809         sb->s_magic = le16_to_cpu(es->s_magic);
810
811         if (sb->s_magic != EXT2_SUPER_MAGIC)
812                 goto cantfind_ext2;
813
814         /* Set defaults before we parse the mount options */
815         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
816         if (def_mount_opts & EXT2_DEFM_DEBUG)
817                 set_opt(sbi->s_mount_opt, DEBUG);
818         if (def_mount_opts & EXT2_DEFM_BSDGROUPS)
819                 set_opt(sbi->s_mount_opt, GRPID);
820         if (def_mount_opts & EXT2_DEFM_UID16)
821                 set_opt(sbi->s_mount_opt, NO_UID32);
822 #ifdef CONFIG_EXT2_FS_XATTR
823         if (def_mount_opts & EXT2_DEFM_XATTR_USER)
824                 set_opt(sbi->s_mount_opt, XATTR_USER);
825 #endif
826 #ifdef CONFIG_EXT2_FS_POSIX_ACL
827         if (def_mount_opts & EXT2_DEFM_ACL)
828                 set_opt(sbi->s_mount_opt, POSIX_ACL);
829 #endif
830         
831         if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_PANIC)
832                 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
833         else if (le16_to_cpu(sbi->s_es->s_errors) == EXT2_ERRORS_CONTINUE)
834                 set_opt(sbi->s_mount_opt, ERRORS_CONT);
835         else
836                 set_opt(sbi->s_mount_opt, ERRORS_RO);
837
838         sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
839         sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
840         
841         set_opt(sbi->s_mount_opt, RESERVATION);
842
843         if (!parse_options ((char *) data, sbi))
844                 goto failed_mount;
845
846         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
847                 ((EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ?
848                  MS_POSIXACL : 0);
849
850         ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
851                                     EXT2_MOUNT_XIP if not */
852
853         if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV &&
854             (EXT2_HAS_COMPAT_FEATURE(sb, ~0U) ||
855              EXT2_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
856              EXT2_HAS_INCOMPAT_FEATURE(sb, ~0U)))
857                 printk("EXT2-fs warning: feature flags set on rev 0 fs, "
858                        "running e2fsck is recommended\n");
859         /*
860          * Check feature flags regardless of the revision level, since we
861          * previously didn't change the revision level when setting the flags,
862          * so there is a chance incompat flags are set on a rev 0 filesystem.
863          */
864         features = EXT2_HAS_INCOMPAT_FEATURE(sb, ~EXT2_FEATURE_INCOMPAT_SUPP);
865         if (features) {
866                 printk("EXT2-fs: %s: couldn't mount because of "
867                        "unsupported optional features (%x).\n",
868                        sb->s_id, le32_to_cpu(features));
869                 goto failed_mount;
870         }
871         if (!(sb->s_flags & MS_RDONLY) &&
872             (features = EXT2_HAS_RO_COMPAT_FEATURE(sb, ~EXT2_FEATURE_RO_COMPAT_SUPP))){
873                 printk("EXT2-fs: %s: couldn't mount RDWR because of "
874                        "unsupported optional features (%x).\n",
875                        sb->s_id, le32_to_cpu(features));
876                 goto failed_mount;
877         }
878
879         blocksize = BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
880
881         if (ext2_use_xip(sb) && blocksize != PAGE_SIZE) {
882                 if (!silent)
883                         printk("XIP: Unsupported blocksize\n");
884                 goto failed_mount;
885         }
886
887         /* If the blocksize doesn't match, re-read the thing.. */
888         if (sb->s_blocksize != blocksize) {
889                 brelse(bh);
890
891                 if (!sb_set_blocksize(sb, blocksize)) {
892                         printk(KERN_ERR "EXT2-fs: blocksize too small for device.\n");
893                         goto failed_sbi;
894                 }
895
896                 logic_sb_block = (sb_block*BLOCK_SIZE) / blocksize;
897                 offset = (sb_block*BLOCK_SIZE) % blocksize;
898                 bh = sb_bread(sb, logic_sb_block);
899                 if(!bh) {
900                         printk("EXT2-fs: Couldn't read superblock on "
901                                "2nd try.\n");
902                         goto failed_sbi;
903                 }
904                 es = (struct ext2_super_block *) (((char *)bh->b_data) + offset);
905                 sbi->s_es = es;
906                 if (es->s_magic != cpu_to_le16(EXT2_SUPER_MAGIC)) {
907                         printk ("EXT2-fs: Magic mismatch, very weird !\n");
908                         goto failed_mount;
909                 }
910         }
911
912         sb->s_maxbytes = ext2_max_size(sb->s_blocksize_bits);
913
914         if (le32_to_cpu(es->s_rev_level) == EXT2_GOOD_OLD_REV) {
915                 sbi->s_inode_size = EXT2_GOOD_OLD_INODE_SIZE;
916                 sbi->s_first_ino = EXT2_GOOD_OLD_FIRST_INO;
917         } else {
918                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
919                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
920                 if ((sbi->s_inode_size < EXT2_GOOD_OLD_INODE_SIZE) ||
921                     !is_power_of_2(sbi->s_inode_size) ||
922                     (sbi->s_inode_size > blocksize)) {
923                         printk ("EXT2-fs: unsupported inode size: %d\n",
924                                 sbi->s_inode_size);
925                         goto failed_mount;
926                 }
927         }
928
929         sbi->s_frag_size = EXT2_MIN_FRAG_SIZE <<
930                                    le32_to_cpu(es->s_log_frag_size);
931         if (sbi->s_frag_size == 0)
932                 goto cantfind_ext2;
933         sbi->s_frags_per_block = sb->s_blocksize / sbi->s_frag_size;
934
935         sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
936         sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
937         sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
938
939         if (EXT2_INODE_SIZE(sb) == 0)
940                 goto cantfind_ext2;
941         sbi->s_inodes_per_block = sb->s_blocksize / EXT2_INODE_SIZE(sb);
942         if (sbi->s_inodes_per_block == 0 || sbi->s_inodes_per_group == 0)
943                 goto cantfind_ext2;
944         sbi->s_itb_per_group = sbi->s_inodes_per_group /
945                                         sbi->s_inodes_per_block;
946         sbi->s_desc_per_block = sb->s_blocksize /
947                                         sizeof (struct ext2_group_desc);
948         sbi->s_sbh = bh;
949         sbi->s_mount_state = le16_to_cpu(es->s_state);
950         sbi->s_addr_per_block_bits =
951                 ilog2 (EXT2_ADDR_PER_BLOCK(sb));
952         sbi->s_desc_per_block_bits =
953                 ilog2 (EXT2_DESC_PER_BLOCK(sb));
954
955         if (sb->s_magic != EXT2_SUPER_MAGIC)
956                 goto cantfind_ext2;
957
958         if (sb->s_blocksize != bh->b_size) {
959                 if (!silent)
960                         printk ("VFS: Unsupported blocksize on dev "
961                                 "%s.\n", sb->s_id);
962                 goto failed_mount;
963         }
964
965         if (sb->s_blocksize != sbi->s_frag_size) {
966                 printk ("EXT2-fs: fragsize %lu != blocksize %lu (not supported yet)\n",
967                         sbi->s_frag_size, sb->s_blocksize);
968                 goto failed_mount;
969         }
970
971         if (sbi->s_blocks_per_group > sb->s_blocksize * 8) {
972                 printk ("EXT2-fs: #blocks per group too big: %lu\n",
973                         sbi->s_blocks_per_group);
974                 goto failed_mount;
975         }
976         if (sbi->s_frags_per_group > sb->s_blocksize * 8) {
977                 printk ("EXT2-fs: #fragments per group too big: %lu\n",
978                         sbi->s_frags_per_group);
979                 goto failed_mount;
980         }
981         if (sbi->s_inodes_per_group > sb->s_blocksize * 8) {
982                 printk ("EXT2-fs: #inodes per group too big: %lu\n",
983                         sbi->s_inodes_per_group);
984                 goto failed_mount;
985         }
986
987         if (EXT2_BLOCKS_PER_GROUP(sb) == 0)
988                 goto cantfind_ext2;
989         sbi->s_groups_count = ((le32_to_cpu(es->s_blocks_count) -
990                                 le32_to_cpu(es->s_first_data_block) - 1)
991                                         / EXT2_BLOCKS_PER_GROUP(sb)) + 1;
992         db_count = (sbi->s_groups_count + EXT2_DESC_PER_BLOCK(sb) - 1) /
993                    EXT2_DESC_PER_BLOCK(sb);
994         sbi->s_group_desc = kmalloc (db_count * sizeof (struct buffer_head *), GFP_KERNEL);
995         if (sbi->s_group_desc == NULL) {
996                 printk ("EXT2-fs: not enough memory\n");
997                 goto failed_mount;
998         }
999         bgl_lock_init(sbi->s_blockgroup_lock);
1000         sbi->s_debts = kcalloc(sbi->s_groups_count, sizeof(*sbi->s_debts), GFP_KERNEL);
1001         if (!sbi->s_debts) {
1002                 printk ("EXT2-fs: not enough memory\n");
1003                 goto failed_mount_group_desc;
1004         }
1005         for (i = 0; i < db_count; i++) {
1006                 block = descriptor_loc(sb, logic_sb_block, i);
1007                 sbi->s_group_desc[i] = sb_bread(sb, block);
1008                 if (!sbi->s_group_desc[i]) {
1009                         for (j = 0; j < i; j++)
1010                                 brelse (sbi->s_group_desc[j]);
1011                         printk ("EXT2-fs: unable to read group descriptors\n");
1012                         goto failed_mount_group_desc;
1013                 }
1014         }
1015         if (!ext2_check_descriptors (sb)) {
1016                 printk ("EXT2-fs: group descriptors corrupted!\n");
1017                 goto failed_mount2;
1018         }
1019         sbi->s_gdb_count = db_count;
1020         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
1021         spin_lock_init(&sbi->s_next_gen_lock);
1022
1023         /* per fileystem reservation list head & lock */
1024         spin_lock_init(&sbi->s_rsv_window_lock);
1025         sbi->s_rsv_window_root = RB_ROOT;
1026         /*
1027          * Add a single, static dummy reservation to the start of the
1028          * reservation window list --- it gives us a placeholder for
1029          * append-at-start-of-list which makes the allocation logic
1030          * _much_ simpler.
1031          */
1032         sbi->s_rsv_window_head.rsv_start = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
1033         sbi->s_rsv_window_head.rsv_end = EXT2_RESERVE_WINDOW_NOT_ALLOCATED;
1034         sbi->s_rsv_window_head.rsv_alloc_hit = 0;
1035         sbi->s_rsv_window_head.rsv_goal_size = 0;
1036         ext2_rsv_window_add(sb, &sbi->s_rsv_window_head);
1037
1038         err = percpu_counter_init(&sbi->s_freeblocks_counter,
1039                                 ext2_count_free_blocks(sb));
1040         if (!err) {
1041                 err = percpu_counter_init(&sbi->s_freeinodes_counter,
1042                                 ext2_count_free_inodes(sb));
1043         }
1044         if (!err) {
1045                 err = percpu_counter_init(&sbi->s_dirs_counter,
1046                                 ext2_count_dirs(sb));
1047         }
1048         if (err) {
1049                 printk(KERN_ERR "EXT2-fs: insufficient memory\n");
1050                 goto failed_mount3;
1051         }
1052         /*
1053          * set up enough so that it can read an inode
1054          */
1055         sb->s_op = &ext2_sops;
1056         sb->s_export_op = &ext2_export_ops;
1057         sb->s_xattr = ext2_xattr_handlers;
1058         root = ext2_iget(sb, EXT2_ROOT_INO);
1059         if (IS_ERR(root)) {
1060                 ret = PTR_ERR(root);
1061                 goto failed_mount3;
1062         }
1063         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
1064                 iput(root);
1065                 printk(KERN_ERR "EXT2-fs: corrupt root inode, run e2fsck\n");
1066                 goto failed_mount3;
1067         }
1068
1069         sb->s_root = d_alloc_root(root);
1070         if (!sb->s_root) {
1071                 iput(root);
1072                 printk(KERN_ERR "EXT2-fs: get root inode failed\n");
1073                 ret = -ENOMEM;
1074                 goto failed_mount3;
1075         }
1076         if (EXT2_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL))
1077                 ext2_warning(sb, __func__,
1078                         "mounting ext3 filesystem as ext2");
1079         ext2_setup_super (sb, es, sb->s_flags & MS_RDONLY);
1080         return 0;
1081
1082 cantfind_ext2:
1083         if (!silent)
1084                 printk("VFS: Can't find an ext2 filesystem on dev %s.\n",
1085                        sb->s_id);
1086         goto failed_mount;
1087 failed_mount3:
1088         percpu_counter_destroy(&sbi->s_freeblocks_counter);
1089         percpu_counter_destroy(&sbi->s_freeinodes_counter);
1090         percpu_counter_destroy(&sbi->s_dirs_counter);
1091 failed_mount2:
1092         for (i = 0; i < db_count; i++)
1093                 brelse(sbi->s_group_desc[i]);
1094 failed_mount_group_desc:
1095         kfree(sbi->s_group_desc);
1096         kfree(sbi->s_debts);
1097 failed_mount:
1098         brelse(bh);
1099 failed_sbi:
1100         sb->s_fs_info = NULL;
1101         kfree(sbi->s_blockgroup_lock);
1102         kfree(sbi);
1103         return ret;
1104 }
1105
1106 static void ext2_commit_super (struct super_block * sb,
1107                                struct ext2_super_block * es)
1108 {
1109         es->s_wtime = cpu_to_le32(get_seconds());
1110         mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
1111         sb->s_dirt = 0;
1112 }
1113
1114 static void ext2_sync_super(struct super_block *sb, struct ext2_super_block *es)
1115 {
1116         es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
1117         es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
1118         es->s_wtime = cpu_to_le32(get_seconds());
1119         mark_buffer_dirty(EXT2_SB(sb)->s_sbh);
1120         sync_dirty_buffer(EXT2_SB(sb)->s_sbh);
1121         sb->s_dirt = 0;
1122 }
1123
1124 /*
1125  * In the second extended file system, it is not necessary to
1126  * write the super block since we use a mapping of the
1127  * disk super block in a buffer.
1128  *
1129  * However, this function is still used to set the fs valid
1130  * flags to 0.  We need to set this flag to 0 since the fs
1131  * may have been checked while mounted and e2fsck may have
1132  * set s_state to EXT2_VALID_FS after some corrections.
1133  */
1134
1135 void ext2_write_super (struct super_block * sb)
1136 {
1137         struct ext2_super_block * es;
1138         lock_kernel();
1139         if (!(sb->s_flags & MS_RDONLY)) {
1140                 es = EXT2_SB(sb)->s_es;
1141
1142                 if (es->s_state & cpu_to_le16(EXT2_VALID_FS)) {
1143                         ext2_debug ("setting valid to 0\n");
1144                         es->s_state &= cpu_to_le16(~EXT2_VALID_FS);
1145                         es->s_free_blocks_count = cpu_to_le32(ext2_count_free_blocks(sb));
1146                         es->s_free_inodes_count = cpu_to_le32(ext2_count_free_inodes(sb));
1147                         es->s_mtime = cpu_to_le32(get_seconds());
1148                         ext2_sync_super(sb, es);
1149                 } else
1150                         ext2_commit_super (sb, es);
1151         }
1152         sb->s_dirt = 0;
1153         unlock_kernel();
1154 }
1155
1156 static int ext2_remount (struct super_block * sb, int * flags, char * data)
1157 {
1158         struct ext2_sb_info * sbi = EXT2_SB(sb);
1159         struct ext2_super_block * es;
1160         unsigned long old_mount_opt = sbi->s_mount_opt;
1161         struct ext2_mount_options old_opts;
1162         unsigned long old_sb_flags;
1163         int err;
1164
1165         lock_kernel();
1166
1167         /* Store the old options */
1168         old_sb_flags = sb->s_flags;
1169         old_opts.s_mount_opt = sbi->s_mount_opt;
1170         old_opts.s_resuid = sbi->s_resuid;
1171         old_opts.s_resgid = sbi->s_resgid;
1172
1173         /*
1174          * Allow the "check" option to be passed as a remount option.
1175          */
1176         if (!parse_options (data, sbi)) {
1177                 err = -EINVAL;
1178                 goto restore_opts;
1179         }
1180
1181         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
1182                 ((sbi->s_mount_opt & EXT2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
1183
1184         ext2_xip_verify_sb(sb); /* see if bdev supports xip, unset
1185                                     EXT2_MOUNT_XIP if not */
1186
1187         if ((ext2_use_xip(sb)) && (sb->s_blocksize != PAGE_SIZE)) {
1188                 printk("XIP: Unsupported blocksize\n");
1189                 err = -EINVAL;
1190                 goto restore_opts;
1191         }
1192
1193         es = sbi->s_es;
1194         if (((sbi->s_mount_opt & EXT2_MOUNT_XIP) !=
1195             (old_mount_opt & EXT2_MOUNT_XIP)) &&
1196             invalidate_inodes(sb)) {
1197                 ext2_warning(sb, __func__, "refusing change of xip flag "
1198                              "with busy inodes while remounting");
1199                 sbi->s_mount_opt &= ~EXT2_MOUNT_XIP;
1200                 sbi->s_mount_opt |= old_mount_opt & EXT2_MOUNT_XIP;
1201         }
1202         if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) {
1203                 unlock_kernel();
1204                 return 0;
1205         }
1206         if (*flags & MS_RDONLY) {
1207                 if (le16_to_cpu(es->s_state) & EXT2_VALID_FS ||
1208                     !(sbi->s_mount_state & EXT2_VALID_FS)) {
1209                         unlock_kernel();
1210                         return 0;
1211                 }
1212                 /*
1213                  * OK, we are remounting a valid rw partition rdonly, so set
1214                  * the rdonly flag and then mark the partition as valid again.
1215                  */
1216                 es->s_state = cpu_to_le16(sbi->s_mount_state);
1217                 es->s_mtime = cpu_to_le32(get_seconds());
1218         } else {
1219                 __le32 ret = EXT2_HAS_RO_COMPAT_FEATURE(sb,
1220                                                ~EXT2_FEATURE_RO_COMPAT_SUPP);
1221                 if (ret) {
1222                         printk("EXT2-fs: %s: couldn't remount RDWR because of "
1223                                "unsupported optional features (%x).\n",
1224                                sb->s_id, le32_to_cpu(ret));
1225                         err = -EROFS;
1226                         goto restore_opts;
1227                 }
1228                 /*
1229                  * Mounting a RDONLY partition read-write, so reread and
1230                  * store the current valid flag.  (It may have been changed
1231                  * by e2fsck since we originally mounted the partition.)
1232                  */
1233                 sbi->s_mount_state = le16_to_cpu(es->s_state);
1234                 if (!ext2_setup_super (sb, es, 0))
1235                         sb->s_flags &= ~MS_RDONLY;
1236         }
1237         ext2_sync_super(sb, es);
1238         unlock_kernel();
1239         return 0;
1240 restore_opts:
1241         sbi->s_mount_opt = old_opts.s_mount_opt;
1242         sbi->s_resuid = old_opts.s_resuid;
1243         sbi->s_resgid = old_opts.s_resgid;
1244         sb->s_flags = old_sb_flags;
1245         unlock_kernel();
1246         return err;
1247 }
1248
1249 static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
1250 {
1251         struct super_block *sb = dentry->d_sb;
1252         struct ext2_sb_info *sbi = EXT2_SB(sb);
1253         struct ext2_super_block *es = sbi->s_es;
1254         u64 fsid;
1255
1256         if (test_opt (sb, MINIX_DF))
1257                 sbi->s_overhead_last = 0;
1258         else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
1259                 unsigned long i, overhead = 0;
1260                 smp_rmb();
1261
1262                 /*
1263                  * Compute the overhead (FS structures). This is constant
1264                  * for a given filesystem unless the number of block groups
1265                  * changes so we cache the previous value until it does.
1266                  */
1267
1268                 /*
1269                  * All of the blocks before first_data_block are
1270                  * overhead
1271                  */
1272                 overhead = le32_to_cpu(es->s_first_data_block);
1273
1274                 /*
1275                  * Add the overhead attributed to the superblock and
1276                  * block group descriptors.  If the sparse superblocks
1277                  * feature is turned on, then not all groups have this.
1278                  */
1279                 for (i = 0; i < sbi->s_groups_count; i++)
1280                         overhead += ext2_bg_has_super(sb, i) +
1281                                 ext2_bg_num_gdb(sb, i);
1282
1283                 /*
1284                  * Every block group has an inode bitmap, a block
1285                  * bitmap, and an inode table.
1286                  */
1287                 overhead += (sbi->s_groups_count *
1288                              (2 + sbi->s_itb_per_group));
1289                 sbi->s_overhead_last = overhead;
1290                 smp_wmb();
1291                 sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
1292         }
1293
1294         buf->f_type = EXT2_SUPER_MAGIC;
1295         buf->f_bsize = sb->s_blocksize;
1296         buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
1297         buf->f_bfree = ext2_count_free_blocks(sb);
1298         es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
1299         buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
1300         if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
1301                 buf->f_bavail = 0;
1302         buf->f_files = le32_to_cpu(es->s_inodes_count);
1303         buf->f_ffree = ext2_count_free_inodes(sb);
1304         es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
1305         buf->f_namelen = EXT2_NAME_LEN;
1306         fsid = le64_to_cpup((void *)es->s_uuid) ^
1307                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
1308         buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
1309         buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
1310         return 0;
1311 }
1312
1313 static int ext2_get_sb(struct file_system_type *fs_type,
1314         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
1315 {
1316         return get_sb_bdev(fs_type, flags, dev_name, data, ext2_fill_super, mnt);
1317 }
1318
1319 #ifdef CONFIG_QUOTA
1320
1321 /* Read data from quotafile - avoid pagecache and such because we cannot afford
1322  * acquiring the locks... As quota files are never truncated and quota code
1323  * itself serializes the operations (and noone else should touch the files)
1324  * we don't have to be afraid of races */
1325 static ssize_t ext2_quota_read(struct super_block *sb, int type, char *data,
1326                                size_t len, loff_t off)
1327 {
1328         struct inode *inode = sb_dqopt(sb)->files[type];
1329         sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1330         int err = 0;
1331         int offset = off & (sb->s_blocksize - 1);
1332         int tocopy;
1333         size_t toread;
1334         struct buffer_head tmp_bh;
1335         struct buffer_head *bh;
1336         loff_t i_size = i_size_read(inode);
1337
1338         if (off > i_size)
1339                 return 0;
1340         if (off+len > i_size)
1341                 len = i_size-off;
1342         toread = len;
1343         while (toread > 0) {
1344                 tocopy = sb->s_blocksize - offset < toread ?
1345                                 sb->s_blocksize - offset : toread;
1346
1347                 tmp_bh.b_state = 0;
1348                 tmp_bh.b_size = sb->s_blocksize;
1349                 err = ext2_get_block(inode, blk, &tmp_bh, 0);
1350                 if (err < 0)
1351                         return err;
1352                 if (!buffer_mapped(&tmp_bh))    /* A hole? */
1353                         memset(data, 0, tocopy);
1354                 else {
1355                         bh = sb_bread(sb, tmp_bh.b_blocknr);
1356                         if (!bh)
1357                                 return -EIO;
1358                         memcpy(data, bh->b_data+offset, tocopy);
1359                         brelse(bh);
1360                 }
1361                 offset = 0;
1362                 toread -= tocopy;
1363                 data += tocopy;
1364                 blk++;
1365         }
1366         return len;
1367 }
1368
1369 /* Write to quotafile */
1370 static ssize_t ext2_quota_write(struct super_block *sb, int type,
1371                                 const char *data, size_t len, loff_t off)
1372 {
1373         struct inode *inode = sb_dqopt(sb)->files[type];
1374         sector_t blk = off >> EXT2_BLOCK_SIZE_BITS(sb);
1375         int err = 0;
1376         int offset = off & (sb->s_blocksize - 1);
1377         int tocopy;
1378         size_t towrite = len;
1379         struct buffer_head tmp_bh;
1380         struct buffer_head *bh;
1381
1382         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
1383         while (towrite > 0) {
1384                 tocopy = sb->s_blocksize - offset < towrite ?
1385                                 sb->s_blocksize - offset : towrite;
1386
1387                 tmp_bh.b_state = 0;
1388                 err = ext2_get_block(inode, blk, &tmp_bh, 1);
1389                 if (err < 0)
1390                         goto out;
1391                 if (offset || tocopy != EXT2_BLOCK_SIZE(sb))
1392                         bh = sb_bread(sb, tmp_bh.b_blocknr);
1393                 else
1394                         bh = sb_getblk(sb, tmp_bh.b_blocknr);
1395                 if (!bh) {
1396                         err = -EIO;
1397                         goto out;
1398                 }
1399                 lock_buffer(bh);
1400                 memcpy(bh->b_data+offset, data, tocopy);
1401                 flush_dcache_page(bh->b_page);
1402                 set_buffer_uptodate(bh);
1403                 mark_buffer_dirty(bh);
1404                 unlock_buffer(bh);
1405                 brelse(bh);
1406                 offset = 0;
1407                 towrite -= tocopy;
1408                 data += tocopy;
1409                 blk++;
1410         }
1411 out:
1412         if (len == towrite) {
1413                 mutex_unlock(&inode->i_mutex);
1414                 return err;
1415         }
1416         if (inode->i_size < off+len-towrite)
1417                 i_size_write(inode, off+len-towrite);
1418         inode->i_version++;
1419         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1420         mark_inode_dirty(inode);
1421         mutex_unlock(&inode->i_mutex);
1422         return len - towrite;
1423 }
1424
1425 #endif
1426
1427 static struct file_system_type ext2_fs_type = {
1428         .owner          = THIS_MODULE,
1429         .name           = "ext2",
1430         .get_sb         = ext2_get_sb,
1431         .kill_sb        = kill_block_super,
1432         .fs_flags       = FS_REQUIRES_DEV,
1433 };
1434
1435 static int __init init_ext2_fs(void)
1436 {
1437         int err = init_ext2_xattr();
1438         if (err)
1439                 return err;
1440         err = init_inodecache();
1441         if (err)
1442                 goto out1;
1443         err = register_filesystem(&ext2_fs_type);
1444         if (err)
1445                 goto out;
1446         return 0;
1447 out:
1448         destroy_inodecache();
1449 out1:
1450         exit_ext2_xattr();
1451         return err;
1452 }
1453
1454 static void __exit exit_ext2_fs(void)
1455 {
1456         unregister_filesystem(&ext2_fs_type);
1457         destroy_inodecache();
1458         exit_ext2_xattr();
1459 }
1460
1461 module_init(init_ext2_fs)
1462 module_exit(exit_ext2_fs)