"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "fs/ext4/super.c" between
linux-3.16.62.tar.xz and linux-3.16.63.tar.xz

About: The full source of the Linux kernel 3.16.x (longterm stable)

super.c  (linux-3.16.62.tar.xz):super.c  (linux-3.16.63.tar.xz)
skipping to change at line 781 skipping to change at line 781
list_for_each(l, &sbi->s_orphan) { list_for_each(l, &sbi->s_orphan) {
struct inode *inode = orphan_list_entry(l); struct inode *inode = orphan_list_entry(l);
printk(KERN_ERR " " printk(KERN_ERR " "
"inode %s:%lu at %p: mode %o, nlink %d, next %d\n", "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
inode->i_sb->s_id, inode->i_ino, inode, inode->i_sb->s_id, inode->i_ino, inode,
inode->i_mode, inode->i_nlink, inode->i_mode, inode->i_nlink,
NEXT_ORPHAN(inode)); NEXT_ORPHAN(inode));
} }
} }
#ifdef CONFIG_QUOTA
/*
* This is a helper function which is used in the mount/remount
* codepaths (which holds s_umount) to fetch the quota file name.
*/
static inline char *get_qf_name(struct super_block *sb,
struct ext4_sb_info *sbi,
int type)
{
return rcu_dereference_protected(sbi->s_qf_names[type],
lockdep_is_held(&sb->s_umount));
}
#endif
static void ext4_put_super(struct super_block *sb) static void ext4_put_super(struct super_block *sb)
{ {
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
struct ext4_super_block *es = sbi->s_es; struct ext4_super_block *es = sbi->s_es;
int aborted = 0; int aborted = 0;
int i, err; int i, err;
ext4_unregister_li_request(sb); ext4_unregister_li_request(sb);
dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); dquot_disable(sb, -1, DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
skipping to change at line 834 skipping to change at line 848
ext4_kvfree(sbi->s_group_desc); ext4_kvfree(sbi->s_group_desc);
ext4_kvfree(sbi->s_flex_groups); ext4_kvfree(sbi->s_flex_groups);
percpu_counter_destroy(&sbi->s_freeclusters_counter); percpu_counter_destroy(&sbi->s_freeclusters_counter);
percpu_counter_destroy(&sbi->s_freeinodes_counter); percpu_counter_destroy(&sbi->s_freeinodes_counter);
percpu_counter_destroy(&sbi->s_dirs_counter); percpu_counter_destroy(&sbi->s_dirs_counter);
percpu_counter_destroy(&sbi->s_dirtyclusters_counter); percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
percpu_counter_destroy(&sbi->s_extent_cache_cnt); percpu_counter_destroy(&sbi->s_extent_cache_cnt);
brelse(sbi->s_sbh); brelse(sbi->s_sbh);
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
for (i = 0; i < MAXQUOTAS; i++) for (i = 0; i < MAXQUOTAS; i++)
kfree(sbi->s_qf_names[i]); kfree(get_qf_name(sb, sbi, i));
#endif #endif
/* Debugging code just in case the in-memory inode orphan list /* Debugging code just in case the in-memory inode orphan list
* isn't empty. The on-disk one can be non-empty if we've * isn't empty. The on-disk one can be non-empty if we've
* detected an error and taken the fs readonly, but the * detected an error and taken the fs readonly, but the
* in-memory list had better be clean by this point. */ * in-memory list had better be clean by this point. */
if (!list_empty(&sbi->s_orphan)) if (!list_empty(&sbi->s_orphan))
dump_orphan_list(sb, sbi); dump_orphan_list(sb, sbi);
J_ASSERT(list_empty(&sbi->s_orphan)); J_ASSERT(list_empty(&sbi->s_orphan));
skipping to change at line 1294 skipping to change at line 1308
} }
#define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3)) #define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
static char deprecated_msg[] = "Mount option \"%s\" will be removed by %s\n" static char deprecated_msg[] = "Mount option \"%s\" will be removed by %s\n"
"Contact linux-ext4@vger.kernel.org if you think we should keep it.\n"; "Contact linux-ext4@vger.kernel.org if you think we should keep it.\n";
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
static int set_qf_name(struct super_block *sb, int qtype, substring_t *args) static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
{ {
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
char *qname; char *qname, *old_qname = get_qf_name(sb, sbi, qtype);
int ret = -1; int ret = -1;
if (sb_any_quota_loaded(sb) && if (sb_any_quota_loaded(sb) && !old_qname) {
!sbi->s_qf_names[qtype]) {
ext4_msg(sb, KERN_ERR, ext4_msg(sb, KERN_ERR,
"Cannot change journaled " "Cannot change journaled "
"quota options when quota turned on"); "quota options when quota turned on");
return -1; return -1;
} }
if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) { if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) {
ext4_msg(sb, KERN_ERR, "Cannot set journaled quota options " ext4_msg(sb, KERN_ERR, "Cannot set journaled quota options "
"when QUOTA feature is enabled"); "when QUOTA feature is enabled");
return -1; return -1;
} }
qname = match_strdup(args); qname = match_strdup(args);
if (!qname) { if (!qname) {
ext4_msg(sb, KERN_ERR, ext4_msg(sb, KERN_ERR,
"Not enough memory for storing quotafile name"); "Not enough memory for storing quotafile name");
return -1; return -1;
} }
if (sbi->s_qf_names[qtype]) { if (old_qname) {
if (strcmp(sbi->s_qf_names[qtype], qname) == 0) if (strcmp(old_qname, qname) == 0)
ret = 1; ret = 1;
else else
ext4_msg(sb, KERN_ERR, ext4_msg(sb, KERN_ERR,
"%s quota file already specified", "%s quota file already specified",
QTYPE2NAME(qtype)); QTYPE2NAME(qtype));
goto errout; goto errout;
} }
if (strchr(qname, '/')) { if (strchr(qname, '/')) {
ext4_msg(sb, KERN_ERR, ext4_msg(sb, KERN_ERR,
"quotafile must be on filesystem root"); "quotafile must be on filesystem root");
goto errout; goto errout;
} }
sbi->s_qf_names[qtype] = qname; rcu_assign_pointer(sbi->s_qf_names[qtype], qname);
set_opt(sb, QUOTA); set_opt(sb, QUOTA);
return 1; return 1;
errout: errout:
kfree(qname); kfree(qname);
return ret; return ret;
} }
static int clear_qf_name(struct super_block *sb, int qtype) static int clear_qf_name(struct super_block *sb, int qtype)
{ {
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
char *old_qname = get_qf_name(sb, sbi, qtype);
if (sb_any_quota_loaded(sb) && if (sb_any_quota_loaded(sb) && old_qname) {
sbi->s_qf_names[qtype]) {
ext4_msg(sb, KERN_ERR, "Cannot change journaled quota options" ext4_msg(sb, KERN_ERR, "Cannot change journaled quota options"
" when quota turned on"); " when quota turned on");
return -1; return -1;
} }
kfree(sbi->s_qf_names[qtype]); rcu_assign_pointer(sbi->s_qf_names[qtype], NULL);
sbi->s_qf_names[qtype] = NULL; synchronize_rcu();
kfree(old_qname);
return 1; return 1;
} }
#endif #endif
#define MOPT_SET 0x0001 #define MOPT_SET 0x0001
#define MOPT_CLEAR 0x0002 #define MOPT_CLEAR 0x0002
#define MOPT_NOSUPPORT 0x0004 #define MOPT_NOSUPPORT 0x0004
#define MOPT_EXPLICIT 0x0008 #define MOPT_EXPLICIT 0x0008
#define MOPT_CLEAR_ERR 0x0010 #define MOPT_CLEAR_ERR 0x0010
#define MOPT_GTE0 0x0020 #define MOPT_GTE0 0x0020
skipping to change at line 1678 skipping to change at line 1692
} }
return 1; return 1;
} }
static int parse_options(char *options, struct super_block *sb, static int parse_options(char *options, struct super_block *sb,
unsigned long *journal_devnum, unsigned long *journal_devnum,
unsigned int *journal_ioprio, unsigned int *journal_ioprio,
int is_remount) int is_remount)
{ {
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
char *p; char *p, __maybe_unused *usr_qf_name, __maybe_unused *grp_qf_name;
substring_t args[MAX_OPT_ARGS]; substring_t args[MAX_OPT_ARGS];
int token; int token;
if (!options) if (!options)
return 1; return 1;
while ((p = strsep(&options, ",")) != NULL) { while ((p = strsep(&options, ",")) != NULL) {
if (!*p) if (!*p)
continue; continue;
/* /*
skipping to change at line 1705 skipping to change at line 1719
journal_ioprio, is_remount) < 0) journal_ioprio, is_remount) < 0)
return 0; return 0;
} }
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) && if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) &&
(test_opt(sb, USRQUOTA) || test_opt(sb, GRPQUOTA))) { (test_opt(sb, USRQUOTA) || test_opt(sb, GRPQUOTA))) {
ext4_msg(sb, KERN_ERR, "Cannot set quota options when QUOTA " ext4_msg(sb, KERN_ERR, "Cannot set quota options when QUOTA "
"feature is enabled"); "feature is enabled");
return 0; return 0;
} }
if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) { usr_qf_name = get_qf_name(sb, sbi, USRQUOTA);
if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA]) grp_qf_name = get_qf_name(sb, sbi, GRPQUOTA);
if (usr_qf_name || grp_qf_name) {
if (test_opt(sb, USRQUOTA) && usr_qf_name)
clear_opt(sb, USRQUOTA); clear_opt(sb, USRQUOTA);
if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA]) if (test_opt(sb, GRPQUOTA) && grp_qf_name)
clear_opt(sb, GRPQUOTA); clear_opt(sb, GRPQUOTA);
if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) { if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
ext4_msg(sb, KERN_ERR, "old and new quota " ext4_msg(sb, KERN_ERR, "old and new quota "
"format mixing"); "format mixing");
return 0; return 0;
} }
if (!sbi->s_jquota_fmt) { if (!sbi->s_jquota_fmt) {
ext4_msg(sb, KERN_ERR, "journaled quota format " ext4_msg(sb, KERN_ERR, "journaled quota format "
skipping to change at line 1743 skipping to change at line 1759
} }
} }
return 1; return 1;
} }
static inline void ext4_show_quota_options(struct seq_file *seq, static inline void ext4_show_quota_options(struct seq_file *seq,
struct super_block *sb) struct super_block *sb)
{ {
#if defined(CONFIG_QUOTA) #if defined(CONFIG_QUOTA)
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
char *usr_qf_name, *grp_qf_name;
if (sbi->s_jquota_fmt) { if (sbi->s_jquota_fmt) {
char *fmtname = ""; char *fmtname = "";
switch (sbi->s_jquota_fmt) { switch (sbi->s_jquota_fmt) {
case QFMT_VFS_OLD: case QFMT_VFS_OLD:
fmtname = "vfsold"; fmtname = "vfsold";
break; break;
case QFMT_VFS_V0: case QFMT_VFS_V0:
fmtname = "vfsv0"; fmtname = "vfsv0";
break; break;
case QFMT_VFS_V1: case QFMT_VFS_V1:
fmtname = "vfsv1"; fmtname = "vfsv1";
break; break;
} }
seq_printf(seq, ",jqfmt=%s", fmtname); seq_printf(seq, ",jqfmt=%s", fmtname);
} }
if (sbi->s_qf_names[USRQUOTA]) rcu_read_lock();
seq_show_option(seq, "usrjquota", sbi->s_qf_names[USRQUOTA]); usr_qf_name = rcu_dereference(sbi->s_qf_names[USRQUOTA]);
grp_qf_name = rcu_dereference(sbi->s_qf_names[GRPQUOTA]);
if (sbi->s_qf_names[GRPQUOTA]) if (usr_qf_name)
seq_show_option(seq, "grpjquota", sbi->s_qf_names[GRPQUOTA]); seq_show_option(seq, "usrjquota", usr_qf_name);
if (grp_qf_name)
seq_show_option(seq, "grpjquota", grp_qf_name);
rcu_read_unlock();
#endif #endif
} }
static const char *token2str(int token) static const char *token2str(int token)
{ {
const struct match_token *t; const struct match_token *t;
for (t = tokens; t->token != Opt_err; t++) for (t = tokens; t->token != Opt_err; t++)
if (t->token == token && !strchr(t->pattern, '=')) if (t->token == token && !strchr(t->pattern, '='))
break; break;
skipping to change at line 3959 skipping to change at line 3979
"(block count %llu, first data block %u, " "(block count %llu, first data block %u, "
"blocks per group %lu)", sbi->s_groups_count, "blocks per group %lu)", sbi->s_groups_count,
ext4_blocks_count(es), ext4_blocks_count(es),
le32_to_cpu(es->s_first_data_block), le32_to_cpu(es->s_first_data_block),
EXT4_BLOCKS_PER_GROUP(sb)); EXT4_BLOCKS_PER_GROUP(sb));
goto failed_mount; goto failed_mount;
} }
sbi->s_groups_count = blocks_count; sbi->s_groups_count = blocks_count;
sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count, sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
(EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb))); (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
le32_to_cpu(es->s_inodes_count)) {
ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
le32_to_cpu(es->s_inodes_count),
((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
ret = -EINVAL;
goto failed_mount;
}
db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) / db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
EXT4_DESC_PER_BLOCK(sb); EXT4_DESC_PER_BLOCK(sb);
if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG)) { if (EXT4_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG)) {
if (le32_to_cpu(es->s_first_meta_bg) > db_count) { if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
ext4_msg(sb, KERN_WARNING, ext4_msg(sb, KERN_WARNING,
"first meta block group too large: %u " "first meta block group too large: %u "
"(group descriptor block count %u)", "(group descriptor block count %u)",
le32_to_cpu(es->s_first_meta_bg), db_count); le32_to_cpu(es->s_first_meta_bg), db_count);
goto failed_mount; goto failed_mount;
} }
} }
sbi->s_group_desc = ext4_kvmalloc(db_count * sbi->s_group_desc = ext4_kvmalloc(db_count *
sizeof(struct buffer_head *), sizeof(struct buffer_head *),
GFP_KERNEL); GFP_KERNEL);
if (sbi->s_group_desc == NULL) { if (sbi->s_group_desc == NULL) {
ext4_msg(sb, KERN_ERR, "not enough memory"); ext4_msg(sb, KERN_ERR, "not enough memory");
ret = -ENOMEM; ret = -ENOMEM;
goto failed_mount; goto failed_mount;
} }
if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
le32_to_cpu(es->s_inodes_count)) {
ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
le32_to_cpu(es->s_inodes_count),
((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
ret = -EINVAL;
goto failed_mount;
}
if (ext4_proc_root) if (ext4_proc_root)
sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root); sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
if (sbi->s_proc) if (sbi->s_proc)
proc_create_data("options", S_IRUGO, sbi->s_proc, proc_create_data("options", S_IRUGO, sbi->s_proc,
&ext4_seq_options_fops, sb); &ext4_seq_options_fops, sb);
bgl_lock_init(sbi->s_blockgroup_lock); bgl_lock_init(sbi->s_blockgroup_lock);
skipping to change at line 4935 skipping to change at line 4955
struct ext4_super_block *es; struct ext4_super_block *es;
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
unsigned long old_sb_flags; unsigned long old_sb_flags;
struct ext4_mount_options old_opts; struct ext4_mount_options old_opts;
int enable_quota = 0; int enable_quota = 0;
ext4_group_t g; ext4_group_t g;
unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO; unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
int err = 0; int err = 0;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
int i, j; int i, j;
char *to_free[MAXQUOTAS];
#endif #endif
char *orig_data = kstrdup(data, GFP_KERNEL); char *orig_data = kstrdup(data, GFP_KERNEL);
/* Store the original options */ /* Store the original options */
old_sb_flags = sb->s_flags; old_sb_flags = sb->s_flags;
old_opts.s_mount_opt = sbi->s_mount_opt; old_opts.s_mount_opt = sbi->s_mount_opt;
old_opts.s_mount_opt2 = sbi->s_mount_opt2; old_opts.s_mount_opt2 = sbi->s_mount_opt2;
old_opts.s_resuid = sbi->s_resuid; old_opts.s_resuid = sbi->s_resuid;
old_opts.s_resgid = sbi->s_resgid; old_opts.s_resgid = sbi->s_resgid;
old_opts.s_commit_interval = sbi->s_commit_interval; old_opts.s_commit_interval = sbi->s_commit_interval;
old_opts.s_min_batch_time = sbi->s_min_batch_time; old_opts.s_min_batch_time = sbi->s_min_batch_time;
old_opts.s_max_batch_time = sbi->s_max_batch_time; old_opts.s_max_batch_time = sbi->s_max_batch_time;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
old_opts.s_jquota_fmt = sbi->s_jquota_fmt; old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
for (i = 0; i < MAXQUOTAS; i++) for (i = 0; i < MAXQUOTAS; i++)
if (sbi->s_qf_names[i]) { if (sbi->s_qf_names[i]) {
old_opts.s_qf_names[i] = kstrdup(sbi->s_qf_names[i], char *qf_name = get_qf_name(sb, sbi, i);
GFP_KERNEL);
old_opts.s_qf_names[i] = kstrdup(qf_name, GFP_KERNEL);
if (!old_opts.s_qf_names[i]) { if (!old_opts.s_qf_names[i]) {
for (j = 0; j < i; j++) for (j = 0; j < i; j++)
kfree(old_opts.s_qf_names[j]); kfree(old_opts.s_qf_names[j]);
kfree(orig_data); kfree(orig_data);
return -ENOMEM; return -ENOMEM;
} }
} else } else
old_opts.s_qf_names[i] = NULL; old_opts.s_qf_names[i] = NULL;
#endif #endif
if (sbi->s_journal && sbi->s_journal->j_task->io_context) if (sbi->s_journal && sbi->s_journal->j_task->io_context)
skipping to change at line 5140 skipping to change at line 5162
sbi->s_mount_opt = old_opts.s_mount_opt; sbi->s_mount_opt = old_opts.s_mount_opt;
sbi->s_mount_opt2 = old_opts.s_mount_opt2; sbi->s_mount_opt2 = old_opts.s_mount_opt2;
sbi->s_resuid = old_opts.s_resuid; sbi->s_resuid = old_opts.s_resuid;
sbi->s_resgid = old_opts.s_resgid; sbi->s_resgid = old_opts.s_resgid;
sbi->s_commit_interval = old_opts.s_commit_interval; sbi->s_commit_interval = old_opts.s_commit_interval;
sbi->s_min_batch_time = old_opts.s_min_batch_time; sbi->s_min_batch_time = old_opts.s_min_batch_time;
sbi->s_max_batch_time = old_opts.s_max_batch_time; sbi->s_max_batch_time = old_opts.s_max_batch_time;
#ifdef CONFIG_QUOTA #ifdef CONFIG_QUOTA
sbi->s_jquota_fmt = old_opts.s_jquota_fmt; sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
for (i = 0; i < MAXQUOTAS; i++) { for (i = 0; i < MAXQUOTAS; i++) {
kfree(sbi->s_qf_names[i]); to_free[i] = get_qf_name(sb, sbi, i);
sbi->s_qf_names[i] = old_opts.s_qf_names[i]; rcu_assign_pointer(sbi->s_qf_names[i], old_opts.s_qf_names[i]);
} }
synchronize_rcu();
for (i = 0; i < MAXQUOTAS; i++)
kfree(to_free[i]);
#endif #endif
kfree(orig_data); kfree(orig_data);
return err; return err;
} }
static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf) static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
struct super_block *sb = dentry->d_sb; struct super_block *sb = dentry->d_sb;
struct ext4_sb_info *sbi = EXT4_SB(sb); struct ext4_sb_info *sbi = EXT4_SB(sb);
struct ext4_super_block *es = sbi->s_es; struct ext4_super_block *es = sbi->s_es;
skipping to change at line 5290 skipping to change at line 5315
ret = err; ret = err;
return ret; return ret;
} }
/* /*
* Turn on quotas during mount time - we need to find * Turn on quotas during mount time - we need to find
* the quota file and such... * the quota file and such...
*/ */
static int ext4_quota_on_mount(struct super_block *sb, int type) static int ext4_quota_on_mount(struct super_block *sb, int type)
{ {
return dquot_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type], return dquot_quota_on_mount(sb, get_qf_name(sb, EXT4_SB(sb), type),
EXT4_SB(sb)->s_jquota_fmt, type); EXT4_SB(sb)->s_jquota_fmt, type);
} }
static void lockdep_set_quota_inode(struct inode *inode, int subclass) static void lockdep_set_quota_inode(struct inode *inode, int subclass)
{ {
struct ext4_inode_info *ei = EXT4_I(inode); struct ext4_inode_info *ei = EXT4_I(inode);
/* The first argument of lockdep_set_subclass has to be /* The first argument of lockdep_set_subclass has to be
* *exactly* the same as the argument to init_rwsem() --- in * *exactly* the same as the argument to init_rwsem() --- in
* this case, in init_once() --- or lockdep gets unhappy * this case, in init_once() --- or lockdep gets unhappy
 End of changes. 21 change blocks. 
33 lines changed or deleted 58 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)