Hi Jaegeuk, On 2017/8/11 9:51, Jaegeuk Kim wrote: > Hi Chao, > > Do we have to add .get_inode_usage ? > > I hit a kernel panic on __dquot_transfer() -> check_idq() saying > "BUG: unable to handle kernel paging request at 0xfff..."
Could you provider whole kernel dump info, mount option, test method? Thanks, > > Thanks, > > On 08/08, Chao Yu wrote: >> This patch supports to enable f2fs to accept quota information through >> mount option: >> - {usr,grp,prj}jquota=<quota file path> >> - jqfmt=<quota type> >> >> Then, in ->mount flow, we can recover quota file during log replaying, >> by this, journelled quota can be supported. >> >> Signed-off-by: Chao Yu <yuch...@huawei.com> >> Signed-off-by: Jaegeuk Kim <jaeg...@kernel.org> >> --- >> Documentation/filesystems/f2fs.txt | 9 + >> fs/f2fs/checkpoint.c | 26 ++- >> fs/f2fs/f2fs.h | 9 + >> fs/f2fs/recovery.c | 72 +++++++- >> fs/f2fs/super.c | 327 >> ++++++++++++++++++++++++++++++++++--- >> 5 files changed, 413 insertions(+), 30 deletions(-) >> >> diff --git a/Documentation/filesystems/f2fs.txt >> b/Documentation/filesystems/f2fs.txt >> index b8f495a8b67d..deafeff7795b 100644 >> --- a/Documentation/filesystems/f2fs.txt >> +++ b/Documentation/filesystems/f2fs.txt >> @@ -165,6 +165,15 @@ io_bits=%u Set the bit size of write IO >> requests. It should be set >> usrquota Enable plain user disk quota accounting. >> grpquota Enable plain group disk quota accounting. >> prjquota Enable plain project quota accounting. >> +usrjquota=<file> Appoint specified file and type during mount, so >> that quota >> +grpjquota=<file> information can be properly updated during recovery >> flow, >> +prjjquota=<file> <quota file>: must be in root directory; >> +jqfmt=<quota type> <quota type>: [vfsold,vfsv0,vfsv1]. >> +offusrjquota Turn off user journelled quota. >> +offgrpjquota Turn off group journelled quota. >> +offprjjquota Turn off project journelled quota. >> +quota Enable plain user disk quota accounting. >> +noquota Disable all plain disk quota option. >> >> >> ================================================================================ >> DEBUGFS ENTRIES >> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c >> index da5b49183e09..04fe1df052b2 100644 >> --- a/fs/f2fs/checkpoint.c >> +++ b/fs/f2fs/checkpoint.c >> @@ -588,11 +588,24 @@ static int recover_orphan_inode(struct f2fs_sb_info >> *sbi, nid_t ino) >> int recover_orphan_inodes(struct f2fs_sb_info *sbi) >> { >> block_t start_blk, orphan_blocks, i, j; >> - int err; >> + unsigned int s_flags = sbi->sb->s_flags; >> + int err = 0; >> >> if (!is_set_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG)) >> return 0; >> >> + if (s_flags & MS_RDONLY) { >> + f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs"); >> + sbi->sb->s_flags &= ~MS_RDONLY; >> + } >> + >> +#ifdef CONFIG_QUOTA >> + /* Needed for iput() to work correctly and not trash data */ >> + sbi->sb->s_flags |= MS_ACTIVE; >> + /* Turn on quotas so that they are updated correctly */ >> + f2fs_enable_quota_files(sbi); >> +#endif >> + >> start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi); >> orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi); >> >> @@ -608,14 +621,21 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) >> err = recover_orphan_inode(sbi, ino); >> if (err) { >> f2fs_put_page(page, 1); >> - return err; >> + goto out; >> } >> } >> f2fs_put_page(page, 1); >> } >> /* clear Orphan Flag */ >> clear_ckpt_flags(sbi, CP_ORPHAN_PRESENT_FLAG); >> - return 0; >> +out: >> +#ifdef CONFIG_QUOTA >> + /* Turn quotas off */ >> + f2fs_quota_off_umount(sbi->sb); >> +#endif >> + sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */ >> + >> + return err; >> } >> >> static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) >> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h >> index 1bcaa93bfed7..cea329f75068 100644 >> --- a/fs/f2fs/f2fs.h >> +++ b/fs/f2fs/f2fs.h >> @@ -92,6 +92,7 @@ extern char *fault_name[FAULT_MAX]; >> #define F2FS_MOUNT_USRQUOTA 0x00080000 >> #define F2FS_MOUNT_GRPQUOTA 0x00100000 >> #define F2FS_MOUNT_PRJQUOTA 0x00200000 >> +#define F2FS_MOUNT_QUOTA 0x00400000 >> >> #define clear_opt(sbi, option) ((sbi)->mount_opt.opt &= >> ~F2FS_MOUNT_##option) >> #define set_opt(sbi, option) ((sbi)->mount_opt.opt |= >> F2FS_MOUNT_##option) >> @@ -1121,6 +1122,12 @@ struct f2fs_sb_info { >> #ifdef CONFIG_F2FS_FAULT_INJECTION >> struct f2fs_fault_info fault_info; >> #endif >> + >> +#ifdef CONFIG_QUOTA >> + /* Names of quota files with journalled quota */ >> + char *s_qf_names[MAXQUOTAS]; >> + int s_jquota_fmt; /* Format of quota to use */ >> +#endif >> }; >> >> #ifdef CONFIG_F2FS_FAULT_INJECTION >> @@ -2433,6 +2440,8 @@ static inline int f2fs_add_link(struct dentry *dentry, >> struct inode *inode) >> */ >> int f2fs_inode_dirtied(struct inode *inode, bool sync); >> void f2fs_inode_synced(struct inode *inode); >> +void f2fs_enable_quota_files(struct f2fs_sb_info *sbi); >> +void f2fs_quota_off_umount(struct super_block *sb); >> int f2fs_commit_super(struct f2fs_sb_info *sbi, bool recover); >> int f2fs_sync_fs(struct super_block *sb, int sync); >> extern __printf(3, 4) >> diff --git a/fs/f2fs/recovery.c b/fs/f2fs/recovery.c >> index 2d9b8182691f..a3d02613934a 100644 >> --- a/fs/f2fs/recovery.c >> +++ b/fs/f2fs/recovery.c >> @@ -69,20 +69,34 @@ static struct fsync_inode_entry *get_fsync_inode(struct >> list_head *head, >> } >> >> static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi, >> - struct list_head *head, nid_t ino) >> + struct list_head *head, nid_t ino, bool quota_inode) >> { >> struct inode *inode; >> struct fsync_inode_entry *entry; >> + int err; >> >> inode = f2fs_iget_retry(sbi->sb, ino); >> if (IS_ERR(inode)) >> return ERR_CAST(inode); >> >> + err = dquot_initialize(inode); >> + if (err) >> + goto err_out; >> + >> + if (quota_inode) { >> + err = dquot_alloc_inode(inode); >> + if (err) >> + goto err_out; >> + } >> + >> entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO); >> entry->inode = inode; >> list_add_tail(&entry->list, head); >> >> return entry; >> +err_out: >> + iput(inode); >> + return ERR_PTR(err); >> } >> >> static void del_fsync_inode(struct fsync_inode_entry *entry) >> @@ -107,7 +121,8 @@ static int recover_dentry(struct inode *inode, struct >> page *ipage, >> >> entry = get_fsync_inode(dir_list, pino); >> if (!entry) { >> - entry = add_fsync_inode(F2FS_I_SB(inode), dir_list, pino); >> + entry = add_fsync_inode(F2FS_I_SB(inode), dir_list, >> + pino, false); >> if (IS_ERR(entry)) { >> dir = ERR_CAST(entry); >> err = PTR_ERR(entry); >> @@ -140,6 +155,13 @@ static int recover_dentry(struct inode *inode, struct >> page *ipage, >> err = -EEXIST; >> goto out_unmap_put; >> } >> + >> + err = dquot_initialize(einode); >> + if (err) { >> + iput(einode); >> + goto out_unmap_put; >> + } >> + >> err = acquire_orphan_inode(F2FS_I_SB(inode)); >> if (err) { >> iput(einode); >> @@ -226,18 +248,22 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, >> struct list_head *head, >> >> entry = get_fsync_inode(head, ino_of_node(page)); >> if (!entry) { >> + bool quota_inode = false; >> + >> if (!check_only && >> IS_INODE(page) && is_dent_dnode(page)) { >> err = recover_inode_page(sbi, page); >> if (err) >> break; >> + quota_inode = true; >> } >> >> /* >> * CP | dnode(F) | inode(DF) >> * For this case, we should not give up now. >> */ >> - entry = add_fsync_inode(sbi, head, ino_of_node(page)); >> + entry = add_fsync_inode(sbi, head, ino_of_node(page), >> + quota_inode); >> if (IS_ERR(entry)) { >> err = PTR_ERR(entry); >> if (err == -ENOENT) { >> @@ -328,10 +354,18 @@ static int check_index_in_prev_nodes(struct >> f2fs_sb_info *sbi, >> f2fs_put_page(node_page, 1); >> >> if (ino != dn->inode->i_ino) { >> + int ret; >> + >> /* Deallocate previous index in the node page */ >> inode = f2fs_iget_retry(sbi->sb, ino); >> if (IS_ERR(inode)) >> return PTR_ERR(inode); >> + >> + ret = dquot_initialize(inode); >> + if (ret) { >> + iput(inode); >> + return ret; >> + } >> } else { >> inode = dn->inode; >> } >> @@ -558,12 +592,27 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool >> check_only) >> struct list_head dir_list; >> int err; >> int ret = 0; >> + unsigned long s_flags = sbi->sb->s_flags; >> bool need_writecp = false; >> >> + if (s_flags & MS_RDONLY) { >> + f2fs_msg(sbi->sb, KERN_INFO, "orphan cleanup on readonly fs"); >> + sbi->sb->s_flags &= ~MS_RDONLY; >> + } >> + >> +#ifdef CONFIG_QUOTA >> + /* Needed for iput() to work correctly and not trash data */ >> + sbi->sb->s_flags |= MS_ACTIVE; >> + /* Turn on quotas so that they are updated correctly */ >> + f2fs_enable_quota_files(sbi); >> +#endif >> + >> fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry", >> sizeof(struct fsync_inode_entry)); >> - if (!fsync_entry_slab) >> - return -ENOMEM; >> + if (!fsync_entry_slab) { >> + err = -ENOMEM; >> + goto out; >> + } >> >> INIT_LIST_HEAD(&inode_list); >> INIT_LIST_HEAD(&dir_list); >> @@ -574,11 +623,11 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool >> check_only) >> /* step #1: find fsynced inode numbers */ >> err = find_fsync_dnodes(sbi, &inode_list, check_only); >> if (err || list_empty(&inode_list)) >> - goto out; >> + goto skip; >> >> if (check_only) { >> ret = 1; >> - goto out; >> + goto skip; >> } >> >> need_writecp = true; >> @@ -587,7 +636,7 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool >> check_only) >> err = recover_data(sbi, &inode_list, &dir_list); >> if (!err) >> f2fs_bug_on(sbi, !list_empty(&inode_list)); >> -out: >> +skip: >> destroy_fsync_dnodes(&inode_list); >> >> /* truncate meta pages to be used by the recovery */ >> @@ -615,5 +664,12 @@ int recover_fsync_data(struct f2fs_sb_info *sbi, bool >> check_only) >> } >> >> kmem_cache_destroy(fsync_entry_slab); >> +out: >> +#ifdef CONFIG_QUOTA >> + /* Turn quotas off */ >> + f2fs_quota_off_umount(sbi->sb); >> +#endif >> + sbi->sb->s_flags = s_flags; /* Restore MS_RDONLY status */ >> + >> return ret ? ret: err; >> } >> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c >> index 54b8ff4c6fc9..4c1bdcb94133 100644 >> --- a/fs/f2fs/super.c >> +++ b/fs/f2fs/super.c >> @@ -25,6 +25,7 @@ >> #include <linux/quotaops.h> >> #include <linux/f2fs_fs.h> >> #include <linux/sysfs.h> >> +#include <linux/quota.h> >> >> #include "f2fs.h" >> #include "node.h" >> @@ -107,9 +108,20 @@ enum { >> Opt_fault_injection, >> Opt_lazytime, >> Opt_nolazytime, >> + Opt_quota, >> + Opt_noquota, >> Opt_usrquota, >> Opt_grpquota, >> Opt_prjquota, >> + Opt_usrjquota, >> + Opt_grpjquota, >> + Opt_prjjquota, >> + Opt_offusrjquota, >> + Opt_offgrpjquota, >> + Opt_offprjjquota, >> + Opt_jqfmt_vfsold, >> + Opt_jqfmt_vfsv0, >> + Opt_jqfmt_vfsv1, >> Opt_err, >> }; >> >> @@ -145,9 +157,20 @@ static match_table_t f2fs_tokens = { >> {Opt_fault_injection, "fault_injection=%u"}, >> {Opt_lazytime, "lazytime"}, >> {Opt_nolazytime, "nolazytime"}, >> + {Opt_quota, "quota"}, >> + {Opt_noquota, "noquota"}, >> {Opt_usrquota, "usrquota"}, >> {Opt_grpquota, "grpquota"}, >> {Opt_prjquota, "prjquota"}, >> + {Opt_usrjquota, "usrjquota=%s"}, >> + {Opt_grpjquota, "grpjquota=%s"}, >> + {Opt_prjjquota, "prjjquota=%s"}, >> + {Opt_offusrjquota, "usrjquota="}, >> + {Opt_offgrpjquota, "grpjquota="}, >> + {Opt_offprjjquota, "prjjquota="}, >> + {Opt_jqfmt_vfsold, "jqfmt=vfsold"}, >> + {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"}, >> + {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"}, >> {Opt_err, NULL}, >> }; >> >> @@ -170,6 +193,105 @@ static void init_once(void *foo) >> inode_init_once(&fi->vfs_inode); >> } >> >> +#ifdef CONFIG_QUOTA >> +static const char * const quotatypes[] = INITQFNAMES; >> +#define QTYPE2NAME(t) (quotatypes[t]) >> +static int f2fs_set_qf_name(struct super_block *sb, int qtype, >> + substring_t *args) >> +{ >> + struct f2fs_sb_info *sbi = F2FS_SB(sb); >> + char *qname; >> + int ret = -1; >> + >> + if (sb_any_quota_loaded(sb) && !sbi->s_qf_names[qtype]) { >> + f2fs_msg(sb, KERN_ERR, >> + "Cannot change journaled " >> + "quota options when quota turned on"); >> + return -1; >> + } >> + qname = match_strdup(args); >> + if (!qname) { >> + f2fs_msg(sb, KERN_ERR, >> + "Not enough memory for storing quotafile name"); >> + return -1; >> + } >> + if (sbi->s_qf_names[qtype]) { >> + if (strcmp(sbi->s_qf_names[qtype], qname) == 0) >> + ret = 1; >> + else >> + f2fs_msg(sb, KERN_ERR, >> + "%s quota file already specified", >> + QTYPE2NAME(qtype)); >> + goto errout; >> + } >> + if (strchr(qname, '/')) { >> + f2fs_msg(sb, KERN_ERR, >> + "quotafile must be on filesystem root"); >> + goto errout; >> + } >> + sbi->s_qf_names[qtype] = qname; >> + set_opt(sbi, QUOTA); >> + return 0; >> +errout: >> + kfree(qname); >> + return ret; >> +} >> + >> +static int f2fs_clear_qf_name(struct super_block *sb, int qtype) >> +{ >> + >> + struct f2fs_sb_info *sbi = F2FS_SB(sb); >> + >> + if (sb_any_quota_loaded(sb) && sbi->s_qf_names[qtype]) { >> + f2fs_msg(sb, KERN_ERR, "Cannot change journaled quota options" >> + " when quota turned on"); >> + return -1; >> + } >> + kfree(sbi->s_qf_names[qtype]); >> + sbi->s_qf_names[qtype] = NULL; >> + return 1; >> +} >> + >> +static int f2fs_check_quota_options(struct f2fs_sb_info *sbi) >> +{ >> + /* >> + * We do the test below only for project quotas. 'usrquota' and >> + * 'grpquota' mount options are allowed even without quota feature >> + * to support legacy quotas in quota files. >> + */ >> + if (test_opt(sbi, PRJQUOTA) && !f2fs_sb_has_project_quota(sbi->sb)) { >> + f2fs_msg(sbi->sb, KERN_ERR, "Project quota feature not enabled. >> " >> + "Cannot enable project quota enforcement."); >> + return -1; >> + } >> + if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA] || >> + sbi->s_qf_names[PRJQUOTA]) { >> + if (test_opt(sbi, USRQUOTA) && sbi->s_qf_names[USRQUOTA]) >> + clear_opt(sbi, USRQUOTA); >> + >> + if (test_opt(sbi, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA]) >> + clear_opt(sbi, GRPQUOTA); >> + >> + if (test_opt(sbi, PRJQUOTA) && sbi->s_qf_names[PRJQUOTA]) >> + clear_opt(sbi, PRJQUOTA); >> + >> + if (test_opt(sbi, GRPQUOTA) || test_opt(sbi, USRQUOTA) || >> + test_opt(sbi, PRJQUOTA)) { >> + f2fs_msg(sbi->sb, KERN_ERR, "old and new quota " >> + "format mixing"); >> + return -1; >> + } >> + >> + if (!sbi->s_jquota_fmt) { >> + f2fs_msg(sbi->sb, KERN_ERR, "journaled quota format " >> + "not specified"); >> + return -1; >> + } >> + } >> + return 0; >> +} >> +#endif >> + >> static int parse_options(struct super_block *sb, char *options) >> { >> struct f2fs_sb_info *sbi = F2FS_SB(sb); >> @@ -177,6 +299,9 @@ static int parse_options(struct super_block *sb, char >> *options) >> substring_t args[MAX_OPT_ARGS]; >> char *p, *name; >> int arg = 0; >> +#ifdef CONFIG_QUOTA >> + int ret; >> +#endif >> >> if (!options) >> return 0; >> @@ -388,6 +513,7 @@ static int parse_options(struct super_block *sb, char >> *options) >> sb->s_flags &= ~MS_LAZYTIME; >> break; >> #ifdef CONFIG_QUOTA >> + case Opt_quota: >> case Opt_usrquota: >> set_opt(sbi, USRQUOTA); >> break; >> @@ -397,10 +523,66 @@ static int parse_options(struct super_block *sb, char >> *options) >> case Opt_prjquota: >> set_opt(sbi, PRJQUOTA); >> break; >> + case Opt_usrjquota: >> + ret = f2fs_set_qf_name(sb, USRQUOTA, &args[0]); >> + if (ret) >> + return ret; >> + break; >> + case Opt_grpjquota: >> + ret = f2fs_set_qf_name(sb, GRPQUOTA, &args[0]); >> + if (ret) >> + return ret; >> + break; >> + case Opt_prjjquota: >> + ret = f2fs_set_qf_name(sb, PRJQUOTA, &args[0]); >> + if (ret) >> + return ret; >> + break; >> + case Opt_offusrjquota: >> + ret = f2fs_clear_qf_name(sb, USRQUOTA); >> + if (ret) >> + return ret; >> + break; >> + case Opt_offgrpjquota: >> + ret = f2fs_clear_qf_name(sb, GRPQUOTA); >> + if (ret) >> + return ret; >> + break; >> + case Opt_offprjjquota: >> + ret = f2fs_clear_qf_name(sb, PRJQUOTA); >> + if (ret) >> + return ret; >> + break; >> + case Opt_jqfmt_vfsold: >> + sbi->s_jquota_fmt = QFMT_VFS_OLD; >> + break; >> + case Opt_jqfmt_vfsv0: >> + sbi->s_jquota_fmt = QFMT_VFS_V0; >> + break; >> + case Opt_jqfmt_vfsv1: >> + sbi->s_jquota_fmt = QFMT_VFS_V1; >> + break; >> + case Opt_noquota: >> + clear_opt(sbi, QUOTA); >> + clear_opt(sbi, USRQUOTA); >> + clear_opt(sbi, GRPQUOTA); >> + clear_opt(sbi, PRJQUOTA); >> + break; >> #else >> + case Opt_quota: >> case Opt_usrquota: >> case Opt_grpquota: >> case Opt_prjquota: >> + case Opt_usrjquota: >> + case Opt_grpjquota: >> + case Opt_prjjquota: >> + case Opt_offusrjquota: >> + case Opt_offgrpjquota: >> + case Opt_offprjjquota: >> + case Opt_jqfmt_vfsold: >> + case Opt_jqfmt_vfsv0: >> + case Opt_jqfmt_vfsv1: >> + case Opt_noquota: >> f2fs_msg(sb, KERN_INFO, >> "quota operations not supported"); >> break; >> @@ -412,6 +594,10 @@ static int parse_options(struct super_block *sb, char >> *options) >> return -EINVAL; >> } >> } >> +#ifdef CONFIG_QUOTA >> + if (f2fs_check_quota_options(sbi)) >> + return -EINVAL; >> +#endif >> >> if (F2FS_IO_SIZE_BITS(sbi) && !test_opt(sbi, LFS)) { >> f2fs_msg(sb, KERN_ERR, >> @@ -591,7 +777,6 @@ static void destroy_device_list(struct f2fs_sb_info *sbi) >> kfree(sbi->devs); >> } >> >> -static void f2fs_quota_off_umount(struct super_block *sb); >> static void f2fs_put_super(struct super_block *sb) >> { >> struct f2fs_sb_info *sbi = F2FS_SB(sb); >> @@ -658,6 +843,10 @@ static void f2fs_put_super(struct super_block *sb) >> >> destroy_device_list(sbi); >> mempool_destroy(sbi->write_io_dummy); >> +#ifdef CONFIG_QUOTA >> + for (i = 0; i < MAXQUOTAS; i++) >> + kfree(sbi->s_qf_names[i]); >> +#endif >> destroy_percpu_info(sbi); >> for (i = 0; i < NR_PAGE_TYPE; i++) >> kfree(sbi->write_io[i]); >> @@ -671,6 +860,9 @@ int f2fs_sync_fs(struct super_block *sb, int sync) >> >> trace_f2fs_sync_fs(sb, sync); >> >> + if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) >> + return -EAGAIN; >> + >> if (sync) { >> struct cp_control cpc; >> >> @@ -791,6 +983,40 @@ static int f2fs_statfs(struct dentry *dentry, struct >> kstatfs *buf) >> return 0; >> } >> >> +static inline void f2fs_show_quota_options(struct seq_file *seq, >> + struct super_block *sb) >> +{ >> +#ifdef CONFIG_QUOTA >> + struct f2fs_sb_info *sbi = F2FS_SB(sb); >> + >> + if (sbi->s_jquota_fmt) { >> + char *fmtname = ""; >> + >> + switch (sbi->s_jquota_fmt) { >> + case QFMT_VFS_OLD: >> + fmtname = "vfsold"; >> + break; >> + case QFMT_VFS_V0: >> + fmtname = "vfsv0"; >> + break; >> + case QFMT_VFS_V1: >> + fmtname = "vfsv1"; >> + break; >> + } >> + seq_printf(seq, ",jqfmt=%s", fmtname); >> + } >> + >> + if (sbi->s_qf_names[USRQUOTA]) >> + seq_show_option(seq, "usrjquota", sbi->s_qf_names[USRQUOTA]); >> + >> + if (sbi->s_qf_names[GRPQUOTA]) >> + seq_show_option(seq, "grpjquota", sbi->s_qf_names[GRPQUOTA]); >> + >> + if (sbi->s_qf_names[PRJQUOTA]) >> + seq_show_option(seq, "prjjquota", sbi->s_qf_names[PRJQUOTA]); >> +#endif >> +} >> + >> static int f2fs_show_options(struct seq_file *seq, struct dentry *root) >> { >> struct f2fs_sb_info *sbi = F2FS_SB(root->d_sb); >> @@ -864,6 +1090,8 @@ static int f2fs_show_options(struct seq_file *seq, >> struct dentry *root) >> sbi->fault_info.inject_rate); >> #endif >> #ifdef CONFIG_QUOTA >> + if (test_opt(sbi, QUOTA)) >> + seq_puts(seq, ",quota"); >> if (test_opt(sbi, USRQUOTA)) >> seq_puts(seq, ",usrquota"); >> if (test_opt(sbi, GRPQUOTA)) >> @@ -871,6 +1099,7 @@ static int f2fs_show_options(struct seq_file *seq, >> struct dentry *root) >> if (test_opt(sbi, PRJQUOTA)) >> seq_puts(seq, ",prjquota"); >> #endif >> + f2fs_show_quota_options(seq, sbi->sb); >> >> return 0; >> } >> @@ -919,6 +1148,11 @@ static int f2fs_remount(struct super_block *sb, int >> *flags, char *data) >> #ifdef CONFIG_F2FS_FAULT_INJECTION >> struct f2fs_fault_info ffi = sbi->fault_info; >> #endif >> +#ifdef CONFIG_QUOTA >> + int s_jquota_fmt; >> + char *s_qf_names[MAXQUOTAS]; >> + int i, j; >> +#endif >> >> /* >> * Save the old mount options in case we >> @@ -928,6 +1162,23 @@ static int f2fs_remount(struct super_block *sb, int >> *flags, char *data) >> old_sb_flags = sb->s_flags; >> active_logs = sbi->active_logs; >> >> +#ifdef CONFIG_QUOTA >> + s_jquota_fmt = sbi->s_jquota_fmt; >> + for (i = 0; i < MAXQUOTAS; i++) { >> + if (sbi->s_qf_names[i]) { >> + s_qf_names[i] = kstrdup(sbi->s_qf_names[i], >> + GFP_KERNEL); >> + if (!s_qf_names[i]) { >> + for (j = 0; j < i; j++) >> + kfree(s_qf_names[j]); >> + return -ENOMEM; >> + } >> + } else { >> + s_qf_names[i] = NULL; >> + } >> + } >> +#endif >> + >> /* recover superblocks we couldn't write due to previous RO mount */ >> if (!(*flags & MS_RDONLY) && is_sbi_flag_set(sbi, SBI_NEED_SB_WRITE)) { >> err = f2fs_commit_super(sbi, false); >> @@ -1009,6 +1260,11 @@ static int f2fs_remount(struct super_block *sb, int >> *flags, char *data) >> goto restore_gc; >> } >> skip: >> +#ifdef CONFIG_QUOTA >> + /* Release old quota file names */ >> + for (i = 0; i < MAXQUOTAS; i++) >> + kfree(s_qf_names[i]); >> +#endif >> /* Update the POSIXACL Flag */ >> sb->s_flags = (sb->s_flags & ~MS_POSIXACL) | >> (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0); >> @@ -1023,6 +1279,13 @@ static int f2fs_remount(struct super_block *sb, int >> *flags, char *data) >> stop_gc_thread(sbi); >> } >> restore_opts: >> +#ifdef CONFIG_QUOTA >> + sbi->s_jquota_fmt = s_jquota_fmt; >> + for (i = 0; i < MAXQUOTAS; i++) { >> + kfree(sbi->s_qf_names[i]); >> + sbi->s_qf_names[i] = s_qf_names[i]; >> + } >> +#endif >> sbi->mount_opt = org_mount_opt; >> sbi->active_logs = active_logs; >> sb->s_flags = old_sb_flags; >> @@ -1139,6 +1402,27 @@ static qsize_t *f2fs_get_reserved_space(struct inode >> *inode) >> return &F2FS_I(inode)->i_reserved_quota; >> } >> >> +static int f2fs_quota_on_mount(struct f2fs_sb_info *sbi, int type) >> +{ >> + return dquot_quota_on_mount(sbi->sb, sbi->s_qf_names[type], >> + sbi->s_jquota_fmt, type); >> +} >> + >> +void f2fs_enable_quota_files(struct f2fs_sb_info *sbi) >> +{ >> + int i, ret; >> + >> + for (i = 0; i < MAXQUOTAS; i++) { >> + if (sbi->s_qf_names[i]) { >> + ret = f2fs_quota_on_mount(sbi, i); >> + if (ret < 0) >> + f2fs_msg(sbi->sb, KERN_ERR, >> + "Cannot turn on journaled " >> + "quota: error %d", ret); >> + } >> + } >> +} >> + >> static int f2fs_quota_sync(struct super_block *sb, int type) >> { >> struct quota_info *dqopt = sb_dqopt(sb); >> @@ -1220,7 +1504,7 @@ static int f2fs_quota_off(struct super_block *sb, int >> type) >> return err; >> } >> >> -static void f2fs_quota_off_umount(struct super_block *sb) >> +void f2fs_quota_off_umount(struct super_block *sb) >> { >> int type; >> >> @@ -1258,7 +1542,7 @@ static const struct quotactl_ops f2fs_quotactl_ops = { >> .get_nextdqblk = dquot_get_next_dqblk, >> }; >> #else >> -static inline void f2fs_quota_off_umount(struct super_block *sb) >> +void f2fs_quota_off_umount(struct super_block *sb) >> { >> } >> #endif >> @@ -2178,11 +2462,6 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> if (err) >> goto free_nm; >> >> - /* if there are nt orphan nodes free them */ >> - err = recover_orphan_inodes(sbi); >> - if (err) >> - goto free_node_inode; >> - >> /* read root inode and dentry */ >> root = f2fs_iget(sb, F2FS_ROOT_INO(sbi)); >> if (IS_ERR(root)) { >> @@ -2206,6 +2485,11 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> if (err) >> goto free_root_inode; >> >> + /* if there are nt orphan nodes free them */ >> + err = recover_orphan_inodes(sbi); >> + if (err) >> + goto free_sysfs; >> + >> /* recover fsynced data */ >> if (!test_opt(sbi, DISABLE_ROLL_FORWARD)) { >> /* >> @@ -2215,7 +2499,7 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> if (bdev_read_only(sb->s_bdev) && >> !is_set_ckpt_flags(sbi, CP_UMOUNT_FLAG)) { >> err = -EROFS; >> - goto free_sysfs; >> + goto free_meta; >> } >> >> if (need_fsck) >> @@ -2229,7 +2513,7 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> need_fsck = true; >> f2fs_msg(sb, KERN_ERR, >> "Cannot recover all fsync data errno=%d", err); >> - goto free_sysfs; >> + goto free_meta; >> } >> } else { >> err = recover_fsync_data(sbi, true); >> @@ -2253,7 +2537,7 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> /* After POR, we can run background GC thread.*/ >> err = start_gc_thread(sbi); >> if (err) >> - goto free_sysfs; >> + goto free_meta; >> } >> kfree(options); >> >> @@ -2271,8 +2555,16 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> f2fs_update_time(sbi, REQ_TIME); >> return 0; >> >> -free_sysfs: >> +free_meta: >> f2fs_sync_inode_meta(sbi); >> + /* >> + * Some dirty meta pages can be produced by recover_orphan_inodes() >> + * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg() >> + * followed by write_checkpoint() through f2fs_write_node_pages(), which >> + * falls into an infinite loop in sync_meta_pages(). >> + */ >> + truncate_inode_pages_final(META_MAPPING(sbi)); >> +free_sysfs: >> f2fs_unregister_sysfs(sbi); >> free_root_inode: >> dput(sb->s_root); >> @@ -2282,13 +2574,6 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> mutex_lock(&sbi->umount_mutex); >> release_ino_entry(sbi, true); >> f2fs_leave_shrinker(sbi); >> - /* >> - * Some dirty meta pages can be produced by recover_orphan_inodes() >> - * failed by EIO. Then, iput(node_inode) can trigger balance_fs_bg() >> - * followed by write_checkpoint() through f2fs_write_node_pages(), which >> - * falls into an infinite loop in sync_meta_pages(). >> - */ >> - truncate_inode_pages_final(META_MAPPING(sbi)); >> iput(sbi->node_inode); >> mutex_unlock(&sbi->umount_mutex); >> f2fs_destroy_stats(sbi); >> @@ -2308,6 +2593,10 @@ static int f2fs_fill_super(struct super_block *sb, >> void *data, int silent) >> for (i = 0; i < NR_PAGE_TYPE; i++) >> kfree(sbi->write_io[i]); >> destroy_percpu_info(sbi); >> +#ifdef CONFIG_QUOTA >> + for (i = 0; i < MAXQUOTAS; i++) >> + kfree(sbi->s_qf_names[i]); >> +#endif >> kfree(options); >> free_sb_buf: >> kfree(raw_super); >> -- >> 2.13.1.388.g69e6b9b4f4a9 > > . >