Merge tag 'f2fs-for-6.0' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk...
[sfrench/cifs-2.6.git] / fs / f2fs / f2fs.h
index 85921a1f2db8bf90c7fe6c979bb91aebf14c2e9b..3c7cdb70fe2efc841379cee0e4968c6b60b6f706 100644 (file)
@@ -159,6 +159,7 @@ struct f2fs_mount_info {
        int fsync_mode;                 /* fsync policy */
        int fs_mode;                    /* fs mode: LFS or ADAPTIVE */
        int bggc_mode;                  /* bggc mode: off, on or sync */
+       int memory_mode;                /* memory mode */
        int discard_unit;               /*
                                         * discard command's offset/size should
                                         * be aligned to this unit: block,
@@ -229,7 +230,6 @@ enum {
 #define CP_PAUSE       0x00000040
 #define CP_RESIZE      0x00000080
 
-#define MAX_DISCARD_BLOCKS(sbi)                BLKS_PER_SEC(sbi)
 #define DEF_MAX_DISCARD_REQUEST                8       /* issue 8 discards per round */
 #define DEF_MIN_DISCARD_ISSUE_TIME     50      /* 50 ms, if exists */
 #define DEF_MID_DISCARD_ISSUE_TIME     500     /* 500 ms, if device busy */
@@ -598,6 +598,8 @@ enum {
 #define RECOVERY_MAX_RA_BLOCKS         BIO_MAX_VECS
 #define RECOVERY_MIN_RA_BLOCKS         1
 
+#define F2FS_ONSTACK_PAGES     16      /* nr of onstack pages */
+
 struct rb_entry {
        struct rb_node rb_node;         /* rb node located in rb-tree */
        union {
@@ -757,6 +759,7 @@ enum {
        FI_ENABLE_COMPRESS,     /* enable compression in "user" compression mode */
        FI_COMPRESS_RELEASED,   /* compressed blocks were released */
        FI_ALIGNED_WRITE,       /* enable aligned write */
+       FI_COW_FILE,            /* indicate COW file */
        FI_MAX,                 /* max flag, never be used */
 };
 
@@ -812,6 +815,8 @@ struct f2fs_inode_info {
        unsigned char i_compress_level;         /* compress level (lz4hc,zstd) */
        unsigned short i_compress_flag;         /* compress flag */
        unsigned int i_cluster_size;            /* cluster size */
+
+       unsigned int atomic_write_cnt;
 };
 
 static inline void get_extent_info(struct extent_info *ext,
@@ -1198,6 +1203,7 @@ struct f2fs_io_info {
        bool retry;             /* need to reallocate block address */
        int compr_blocks;       /* # of compressed block addresses */
        bool encrypted;         /* indicate file is encrypted */
+       bool post_read;         /* require post read */
        enum iostat_type io_type;       /* io type */
        struct writeback_control *io_wbc; /* writeback control */
        struct bio **bio;               /* bio for ipu */
@@ -1234,7 +1240,6 @@ struct f2fs_dev_info {
 #ifdef CONFIG_BLK_DEV_ZONED
        unsigned int nr_blkz;           /* Total number of zones */
        unsigned long *blkz_seq;        /* Bitmap indicating sequential zones */
-       block_t *zone_capacity_blocks;  /* Array of zone capacity in blks */
 #endif
 };
 
@@ -1360,6 +1365,13 @@ enum {
        DISCARD_UNIT_SECTION,   /* basic discard unit is section */
 };
 
+enum {
+       MEMORY_MODE_NORMAL,     /* memory mode for normal devices */
+       MEMORY_MODE_LOW,        /* memory mode for low memry devices */
+};
+
+
+
 static inline int f2fs_test_bit(unsigned int nr, char *addr);
 static inline void f2fs_set_bit(unsigned int nr, char *addr);
 static inline void f2fs_clear_bit(unsigned int nr, char *addr);
@@ -1580,6 +1592,7 @@ struct decompress_io_ctx {
        void *private;                  /* payload buffer for specified decompression algorithm */
        void *private2;                 /* extra payload buffer */
        struct work_struct verity_work; /* work to verify the decompressed pages */
+       struct work_struct free_work;   /* work for late free this structure itself */
 };
 
 #define NULL_CLUSTER                   ((unsigned int)(~0))
@@ -1664,6 +1677,7 @@ struct f2fs_sb_info {
        unsigned int meta_ino_num;              /* meta inode number*/
        unsigned int log_blocks_per_seg;        /* log2 blocks per segment */
        unsigned int blocks_per_seg;            /* blocks per segment */
+       unsigned int unusable_blocks_per_sec;   /* unusable blocks per section */
        unsigned int segs_per_sec;              /* segments per section */
        unsigned int secs_per_zone;             /* sections per zone */
        unsigned int total_sections;            /* total section count */
@@ -1804,6 +1818,12 @@ struct f2fs_sb_info {
        int max_fragment_chunk;                 /* max chunk size for block fragmentation mode */
        int max_fragment_hole;                  /* max hole size for block fragmentation mode */
 
+       /* For atomic write statistics */
+       atomic64_t current_atomic_write;
+       s64 peak_atomic_write;
+       u64 committed_atomic_block;
+       u64 revoked_atomic_block;
+
 #ifdef CONFIG_F2FS_FS_COMPRESSION
        struct kmem_cache *page_array_slab;     /* page array entry */
        unsigned int page_array_slab_size;      /* default page array slab size */
@@ -2418,6 +2438,28 @@ static inline void inode_dec_dirty_pages(struct inode *inode)
                dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_QDATA);
 }
 
+static inline void inc_atomic_write_cnt(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       u64 current_write;
+
+       fi->atomic_write_cnt++;
+       atomic64_inc(&sbi->current_atomic_write);
+       current_write = atomic64_read(&sbi->current_atomic_write);
+       if (current_write > sbi->peak_atomic_write)
+               sbi->peak_atomic_write = current_write;
+}
+
+static inline void release_atomic_write_cnt(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+
+       atomic64_sub(fi->atomic_write_cnt, &sbi->current_atomic_write);
+       fi->atomic_write_cnt = 0;
+}
+
 static inline s64 get_pages(struct f2fs_sb_info *sbi, int count_type)
 {
        return atomic_read(&sbi->nr_pages[count_type]);
@@ -2696,16 +2738,6 @@ static inline struct page *f2fs_pagecache_get_page(
        return pagecache_get_page(mapping, index, fgp_flags, gfp_mask);
 }
 
-static inline void f2fs_copy_page(struct page *src, struct page *dst)
-{
-       char *src_kaddr = kmap(src);
-       char *dst_kaddr = kmap(dst);
-
-       memcpy(dst_kaddr, src_kaddr, PAGE_SIZE);
-       kunmap(dst);
-       kunmap(src);
-}
-
 static inline void f2fs_put_page(struct page *page, int unlock)
 {
        if (!page)
@@ -3208,6 +3240,11 @@ static inline bool f2fs_is_atomic_file(struct inode *inode)
        return is_inode_flag_set(inode, FI_ATOMIC_FILE);
 }
 
+static inline bool f2fs_is_cow_file(struct inode *inode)
+{
+       return is_inode_flag_set(inode, FI_COW_FILE);
+}
+
 static inline bool f2fs_is_first_block_written(struct inode *inode)
 {
        return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
@@ -4154,13 +4191,13 @@ void f2fs_compress_write_end_io(struct bio *bio, struct page *page);
 bool f2fs_is_compress_backend_ready(struct inode *inode);
 int f2fs_init_compress_mempool(void);
 void f2fs_destroy_compress_mempool(void);
-void f2fs_decompress_cluster(struct decompress_io_ctx *dic);
+void f2fs_decompress_cluster(struct decompress_io_ctx *dic, bool in_task);
 void f2fs_end_read_compressed_page(struct page *page, bool failed,
-                                                       block_t blkaddr);
+                               block_t blkaddr, bool in_task);
 bool f2fs_cluster_is_empty(struct compress_ctx *cc);
 bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index);
-bool f2fs_all_cluster_page_loaded(struct compress_ctx *cc, struct pagevec *pvec,
-                               int index, int nr_pages);
+bool f2fs_all_cluster_page_ready(struct compress_ctx *cc, struct page **pages,
+                               int index, int nr_pages, bool uptodate);
 bool f2fs_sanity_check_cluster(struct dnode_of_data *dn);
 void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page);
 int f2fs_write_multi_pages(struct compress_ctx *cc,
@@ -4175,8 +4212,9 @@ int f2fs_read_multi_pages(struct compress_ctx *cc, struct bio **bio_ret,
                                unsigned nr_pages, sector_t *last_block_in_bio,
                                bool is_readahead, bool for_write);
 struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc);
-void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed);
-void f2fs_put_page_dic(struct page *page);
+void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed,
+                               bool in_task);
+void f2fs_put_page_dic(struct page *page, bool in_task);
 unsigned int f2fs_cluster_blocks_are_contiguous(struct dnode_of_data *dn);
 int f2fs_init_compress_ctx(struct compress_ctx *cc);
 void f2fs_destroy_compress_ctx(struct compress_ctx *cc, bool reuse);
@@ -4222,13 +4260,14 @@ static inline struct page *f2fs_compress_control_page(struct page *page)
 }
 static inline int f2fs_init_compress_mempool(void) { return 0; }
 static inline void f2fs_destroy_compress_mempool(void) { }
-static inline void f2fs_decompress_cluster(struct decompress_io_ctx *dic) { }
+static inline void f2fs_decompress_cluster(struct decompress_io_ctx *dic,
+                               bool in_task) { }
 static inline void f2fs_end_read_compressed_page(struct page *page,
-                                               bool failed, block_t blkaddr)
+                               bool failed, block_t blkaddr, bool in_task)
 {
        WARN_ON_ONCE(1);
 }
-static inline void f2fs_put_page_dic(struct page *page)
+static inline void f2fs_put_page_dic(struct page *page, bool in_task)
 {
        WARN_ON_ONCE(1);
 }
@@ -4254,8 +4293,9 @@ static inline void f2fs_update_extent_tree_range_compressed(struct inode *inode,
                                unsigned int c_len) { }
 #endif
 
-static inline void set_compress_context(struct inode *inode)
+static inline int set_compress_context(struct inode *inode)
 {
+#ifdef CONFIG_F2FS_FS_COMPRESSION
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 
        F2FS_I(inode)->i_compress_algorithm =
@@ -4278,6 +4318,10 @@ static inline void set_compress_context(struct inode *inode)
        stat_inc_compr_inode(inode);
        inc_compr_inode_stat(inode);
        f2fs_mark_inode_dirty_sync(inode, true);
+       return 0;
+#else
+       return -EOPNOTSUPP;
+#endif
 }
 
 static inline bool f2fs_disable_compressed_file(struct inode *inode)
@@ -4394,10 +4438,15 @@ static inline bool f2fs_lfs_mode(struct f2fs_sb_info *sbi)
        return F2FS_OPTION(sbi).fs_mode == FS_MODE_LFS;
 }
 
+static inline bool f2fs_low_mem_mode(struct f2fs_sb_info *sbi)
+{
+       return F2FS_OPTION(sbi).memory_mode == MEMORY_MODE_LOW;
+}
+
 static inline bool f2fs_may_compress(struct inode *inode)
 {
        if (IS_SWAPFILE(inode) || f2fs_is_pinned_file(inode) ||
-                               f2fs_is_atomic_file(inode))
+               f2fs_is_atomic_file(inode) || f2fs_has_inline_data(inode))
                return false;
        return S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode);
 }
@@ -4459,12 +4508,7 @@ static inline bool f2fs_force_buffered_io(struct inode *inode,
        /* disallow direct IO if any of devices has unaligned blksize */
        if (f2fs_is_multi_device(sbi) && !sbi->aligned_blksize)
                return true;
-       /*
-        * for blkzoned device, fallback direct IO to buffered IO, so
-        * all IOs can be serialized by log-structured write.
-        */
-       if (f2fs_sb_has_blkzoned(sbi))
-               return true;
+
        if (f2fs_lfs_mode(sbi) && (rw == WRITE)) {
                if (block_unaligned_IO(inode, iocb, iter))
                        return true;