f2fs: add reserved blocks for root user

This patch allows root to reserve some blocks via mount option.

"-o reserve_root=N" means N x 4KB-sized blocks for root only.

Reviewed-by: Chao Yu <yuchao0@huawei.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index e9ee7ae8da10ba8111b17f9be9d099d4dc10eaec..0f25ae7ff20cd0e0b2824324eca6d9b1ae8cae7d 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -95,6 +95,7 @@ extern char *fault_name[FAULT_MAX];
 #define F2FS_MOUNT_PRJQUOTA            0x00200000
 #define F2FS_MOUNT_QUOTA               0x00400000
 #define F2FS_MOUNT_INLINE_XATTR_SIZE   0x00800000
+#define F2FS_MOUNT_RESERVE_ROOT                0x01000000
 
 #define clear_opt(sbi, option) ((sbi)->mount_opt.opt &= ~F2FS_MOUNT_##option)
 #define set_opt(sbi, option)   ((sbi)->mount_opt.opt |= F2FS_MOUNT_##option)
@@ -1105,6 +1106,7 @@ struct f2fs_sb_info {
        block_t last_valid_block_count;         /* for recovery */
        block_t reserved_blocks;                /* configurable reserved blocks */
        block_t current_reserved_blocks;        /* current reserved blocks */
+       block_t root_reserved_blocks;           /* root reserved blocks */
 
        unsigned int nquota_files;              /* # of quota sysfile */
 
@@ -1583,11 +1585,17 @@ static inline int inc_valid_block_count(struct f2fs_sb_info *sbi,
        sbi->total_valid_block_count += (block_t)(*count);
        avail_user_block_count = sbi->user_block_count -
                                        sbi->current_reserved_blocks;
+
+       if (!(test_opt(sbi, RESERVE_ROOT) && capable(CAP_SYS_RESOURCE)))
+               avail_user_block_count -= sbi->root_reserved_blocks;
+
        if (unlikely(sbi->total_valid_block_count > avail_user_block_count)) {
                diff = sbi->total_valid_block_count - avail_user_block_count;
+               if (diff > *count)
+                       diff = *count;
                *count -= diff;
                release = diff;
-               sbi->total_valid_block_count = avail_user_block_count;
+               sbi->total_valid_block_count -= diff;
                if (!*count) {
                        spin_unlock(&sbi->stat_lock);
                        percpu_counter_sub(&sbi->alloc_valid_block_count, diff);
@@ -1776,9 +1784,13 @@ static inline int inc_valid_node_count(struct f2fs_sb_info *sbi,
 
        spin_lock(&sbi->stat_lock);
 
-       valid_block_count = sbi->total_valid_block_count + 1;
-       if (unlikely(valid_block_count + sbi->current_reserved_blocks >
-                                               sbi->user_block_count)) {
+       valid_block_count = sbi->total_valid_block_count +
+                                       sbi->current_reserved_blocks + 1;
+
+       if (!(test_opt(sbi, RESERVE_ROOT) && capable(CAP_SYS_RESOURCE)))
+               valid_block_count += sbi->root_reserved_blocks;
+
+       if (unlikely(valid_block_count > sbi->user_block_count)) {
                spin_unlock(&sbi->stat_lock);
                goto enospc;
        }

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e7bd7cf04f355b8a8c264e00e68dff0b3a8eef70..2b63e04c07c51c02a378b2854d447318482cb1a3 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -107,6 +107,7 @@ enum {
        Opt_noextent_cache,
        Opt_noinline_data,
        Opt_data_flush,
+       Opt_reserve_root,
        Opt_mode,
        Opt_io_size_bits,
        Opt_fault_injection,
@@ -157,6 +158,7 @@ static match_table_t f2fs_tokens = {
        {Opt_noextent_cache, "noextent_cache"},
        {Opt_noinline_data, "noinline_data"},
        {Opt_data_flush, "data_flush"},
+       {Opt_reserve_root, "reserve_root=%u"},
        {Opt_mode, "mode=%s"},
        {Opt_io_size_bits, "io_bits=%u"},
        {Opt_fault_injection, "fault_injection=%u"},
@@ -191,6 +193,19 @@ void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
        va_end(args);
 }
 
+static inline void limit_reserve_root(struct f2fs_sb_info *sbi)
+{
+       block_t limit = (sbi->user_block_count << 1) / 1000;
+
+       /* limit is 0.2% */
+       if (test_opt(sbi, RESERVE_ROOT) && sbi->root_reserved_blocks > limit) {
+               sbi->root_reserved_blocks = limit;
+               f2fs_msg(sbi->sb, KERN_INFO,
+                       "Reduce reserved blocks for root = %u",
+                               sbi->root_reserved_blocks);
+       }
+}
+
 static void init_once(void *foo)
 {
        struct f2fs_inode_info *fi = (struct f2fs_inode_info *) foo;
@@ -488,6 +503,18 @@ static int parse_options(struct super_block *sb, char *options)
                case Opt_data_flush:
                        set_opt(sbi, DATA_FLUSH);
                        break;
+               case Opt_reserve_root:
+                       if (args->from && match_int(args, &arg))
+                               return -EINVAL;
+                       if (test_opt(sbi, RESERVE_ROOT)) {
+                               f2fs_msg(sb, KERN_INFO,
+                                       "Preserve previous reserve_root=%u",
+                                       sbi->root_reserved_blocks);
+                       } else {
+                               sbi->root_reserved_blocks = arg;
+                               set_opt(sbi, RESERVE_ROOT);
+                       }
+                       break;
                case Opt_mode:
                        name = match_strdup(&args[0]);
 
@@ -1006,7 +1033,10 @@ static int f2fs_statfs(struct dentry *dentry, struct kstatfs *buf)
        buf->f_blocks = total_count - start_count;
        buf->f_bfree = user_block_count - valid_user_blocks(sbi) -
                                                sbi->current_reserved_blocks;
-       buf->f_bavail = buf->f_bfree;
+       if (buf->f_bfree > sbi->root_reserved_blocks)
+               buf->f_bavail = buf->f_bfree - sbi->root_reserved_blocks;
+       else
+               buf->f_bavail = 0;
 
        avail_node_count = sbi->total_node_count - sbi->nquota_files -
                                                F2FS_RESERVED_NODE_NUM;
@@ -1135,6 +1165,9 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
        else if (test_opt(sbi, LFS))
                seq_puts(seq, "lfs");
        seq_printf(seq, ",active_logs=%u", sbi->active_logs);
+       if (test_opt(sbi, RESERVE_ROOT))
+               seq_printf(seq, ",reserve_root=%u",
+                               sbi->root_reserved_blocks);
        if (F2FS_IO_SIZE_BITS(sbi))
                seq_printf(seq, ",io_size=%uKB", F2FS_IO_SIZE_KB(sbi));
 #ifdef CONFIG_F2FS_FAULT_INJECTION
@@ -1333,6 +1366,7 @@ skip:
        sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
                (test_opt(sbi, POSIX_ACL) ? MS_POSIXACL : 0);
 
+       limit_reserve_root(sbi);
        return 0;
 restore_gc:
        if (need_restart_gc) {
@@ -2569,6 +2603,7 @@ try_onemore:
        sbi->last_valid_block_count = sbi->total_valid_block_count;
        sbi->reserved_blocks = 0;
        sbi->current_reserved_blocks = 0;
+       limit_reserve_root(sbi);
 
        for (i = 0; i < NR_INODE_TYPE; i++) {
                INIT_LIST_HEAD(&sbi->inode_list[i]);

diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index 93c3364250dd05e1774a1188380eee7c1787dd6b..ab6028c332aa566d803782b6d1c062713872cf64 100644 (file)
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -162,7 +162,8 @@ static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
 #endif
        if (a->struct_type == RESERVED_BLOCKS) {
                spin_lock(&sbi->stat_lock);
-               if (t > (unsigned long)sbi->user_block_count) {
+               if (t > (unsigned long)(sbi->user_block_count -
+                                       sbi->root_reserved_blocks)) {
                        spin_unlock(&sbi->stat_lock);
                        return -EINVAL;
                }