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