LCOV - code coverage report
Current view: top level - lkbce/fs/ext2 - super.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 423 748 56.6 %
Date: 2017-01-25 Functions: 24 31 77.4 %

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

Generated by: LCOV version 1.10