On 08/11, Chao Yu wrote:
> 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?

mkfs -O extra_attr -O project_quota -O inode_checksum

loop of:
 # mount -o usrquota,grpquota,prjquota,discard
 # quotacheck -u -g /dir
 # quotaon -u -g /dir
 # echo 511 > /sys/fs/f2fs/dev/inject_type
 # echo (random 3000~5000) > /sys/fs/f2fs/dev/inject_rate
 # ltp/fsstress -x "echo 3 > /proc/sys/vm/drop_caches" -X 10 -r -f fsync=0 -f 
sync=0 -f write=1 -f dwrite=1 -f truncate=6 -f allocsp=0 -f bulkstat=0 -f 
bulkstat1=0 -f freesp=0 -f zero=1 -f collapse=1 -f insert=1 -f resvsp=0 -f 
unresvsp=0 -S t -p 20 -n 200000 -d /dir/test &
 # sleep 10
 # src/gowodn
 # umount

[  886.628389] BUG: unable to handle kernel paging request at ffffffffd9c01f9d
[  886.655169] IP: check_idq+0x5/0x180
[  886.665391] PGD 21e0c067
[  886.665393] P4D 21e0c067
[  886.671572] PUD 21e0e067
[  886.675062] PMD 0
[  886.685069]
[  886.753302] Oops: 0000 [#1] SMP
[  886.851212] Modules linked in: quota_v2 quota_tree f2fs(O) ppdev 
snd_intel8x0 sb_edac snd_ac97_codec ac97_bus snd_pcm joydev input_leds 
snd_timer snd parport_pc parport i2c_piix4 mac_hid serio_raw soundcore ib_iser 
rdma_cm iw_cm ib_cm ib_core configfs iscsi_tcp libiscsi_tcp libiscsi 
scsi_transport_iscsi autofs4 btrfs raid10 raid456 async_raid6_recov 
async_memcpy async_pq async_xor async_tx xor raid6_pq libcrc32c raid1 raid0 
multipath linear hid_generic crct10dif_pclmul crc32_pclmul usbhid 
ghash_clmulni_intel pcbc hid aesni_intel aes_x86_64 crypto_simd glue_helper 
cryptd ahci libahci psmouse pata_acpi e1000 video
[  888.738972] CPU: 3 PID: 2678 Comm: fsstress Tainted: G           O    
4.13.0-rc2+ #9
[  888.776776] Hardware name: innotek GmbH VirtualBox/VirtualBox, BIOS 
VirtualBox 12/01/2006
[  888.785881] task: ffff9597390d5a00 task.stack: ffffbb6401208000
[  888.793283] RIP: 0010:check_idq+0x5/0x180
[  888.801156] RSP: 0018:ffffbb640120bc20 EFLAGS: 00010246
[  888.878306] RAX: ffff9596fd8a3d00 RBX: ffffbb640120bd88 RCX: 0000000000000000
[  888.990955] RDX: ffffbb640120bc68 RSI: 0000000000000001 RDI: ffffffffd9c01f11
[  889.011385] RBP: ffffbb640120bd78 R08: 0000000000000001 R09: 0000000000000000
[  889.018383] R10: 0000000000000000 R11: 0000000000000000 R12: 0000000000000000
[  889.060570] R13: 0000000000000000 R14: ffff9596fd89b4f0 R15: ffffbb640120bc68
[  889.541140] FS:  00007fe4706c4700(0000) GS:ffff95973fd80000(0000) 
knlGS:0000000000000000
[  890.021093] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[  890.411148] CR2: ffffffffd9c01f9d CR3: 000000005d1c8000 CR4: 00000000000406e0
[  890.841158] DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
[  891.305554] DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
[  891.638985] Call Trace:
[  891.666669]  ? __dquot_transfer+0x1d6/0x490
[  891.945967]  ? __mutex_unlock_slowpath.isra.11+0xcb/0x130
[  892.091555]  ? mutex_unlock+0x26/0x30
[  892.112444]  ? dquot_acquire+0x74/0x120
[  892.351151]  ? dqget+0x345/0x4a0
[  892.591885]  dquot_transfer+0xce/0x130
[  892.751686]  f2fs_setattr+0x8b/0x3c0 [f2fs]
[  892.773699]  notify_change+0x2db/0x410
[  892.791540]  chown_common+0x18b/0x1e0
[  892.800299]  SyS_lchown+0x98/0xe0
[  892.933985]  entry_SYSCALL_64_fastpath+0x1e/0xa9
[  893.059419] RIP: 0033:0x7fe46fdb9327


> 
> 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
> > 
> > .
> > 

Reply via email to