f2fs: allow address pointer number of dnode aligning to specified size

This patch expands scalability of dnode layout, it allows address pointer
number of dnode aligning to specified size (now, the size is one byte by
default), and later the number can align to compress cluster size
(1 << n bytes, n=[2,..)), it can avoid cluster acrossing two dnode, making
design of compress meta layout simple.

Signed-off-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 4c6fe137962d9c3b15ac8e1aa12060c7be5f7787..9a9dc20e295b6dba0b6c040653ab7c2a9af24eb9 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2574,7 +2574,14 @@ static inline int f2fs_has_inline_xattr(struct inode *inode)
 
 static inline unsigned int addrs_per_inode(struct inode *inode)
 {
-       return CUR_ADDRS_PER_INODE(inode) - get_inline_xattr_addrs(inode);
+       unsigned int addrs = CUR_ADDRS_PER_INODE(inode) -
+                               get_inline_xattr_addrs(inode);
+       return ALIGN_DOWN(addrs, 1);
+}
+
+static inline unsigned int addrs_per_block(struct inode *inode)
+{
+       return ALIGN_DOWN(DEF_ADDRS_PER_BLOCK, 1);
 }
 
 static inline void *inline_xattr_addr(struct inode *inode, struct page *page)

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index f34c6820c44e8b36f6de974cbd31ea97ff286c94..920d66fc2c89fbc51bec6a4b76a26e632910b054 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -552,7 +552,7 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
 
 void f2fs_truncate_data_blocks(struct dnode_of_data *dn)
 {
-       f2fs_truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
+       f2fs_truncate_data_blocks_range(dn, ADDRS_PER_BLOCK(dn->inode));
 }
 
 static int truncate_partial_data_page(struct inode *inode, u64 from,
@@ -1006,7 +1006,8 @@ next_dnode:
        } else if (ret == -ENOENT) {
                if (dn.max_level == 0)
                        return -ENOENT;
-               done = min((pgoff_t)ADDRS_PER_BLOCK - dn.ofs_in_node, len);
+               done = min((pgoff_t)ADDRS_PER_BLOCK(inode) - dn.ofs_in_node,
+                                                                       len);
                blkaddr += done;
                do_replace += done;
                goto next;
@@ -1157,7 +1158,7 @@ static int __exchange_data_block(struct inode *src_inode,
        int ret;
 
        while (len) {
-               olen = min((pgoff_t)4 * ADDRS_PER_BLOCK, len);
+               olen = min((pgoff_t)4 * ADDRS_PER_BLOCK(src_inode), len);
 
                src_blkaddr = f2fs_kvzalloc(F2FS_I_SB(src_inode),
                                        array_size(olen, sizeof(block_t)),

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index a66a8752e5f6527d809ff3c7bab06bb9ea0cb74d..ba30ec90952fd7b21050b63940e99bed9e47b9f2 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -591,7 +591,7 @@ block_t f2fs_start_bidx_of_node(unsigned int node_ofs, struct inode *inode)
                int dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1);
                bidx = node_ofs - 5 - dec;
        }
-       return bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE(inode);
+       return bidx * ADDRS_PER_BLOCK(inode) + ADDRS_PER_INODE(inode);
 }
 
 static bool is_alive(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index e29d5f6735ae9143d70d9d7c75ba1ebee2b011c5..057362a821a091e52c4ed07f281b1ebbccb9c639 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -600,9 +600,9 @@ static void f2fs_ra_node_pages(struct page *parent, int start, int n)
 pgoff_t f2fs_get_next_page_offset(struct dnode_of_data *dn, pgoff_t pgofs)
 {
        const long direct_index = ADDRS_PER_INODE(dn->inode);
-       const long direct_blks = ADDRS_PER_BLOCK;
-       const long indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
-       unsigned int skipped_unit = ADDRS_PER_BLOCK;
+       const long direct_blks = ADDRS_PER_BLOCK(dn->inode);
+       const long indirect_blks = ADDRS_PER_BLOCK(dn->inode) * NIDS_PER_BLOCK;
+       unsigned int skipped_unit = ADDRS_PER_BLOCK(dn->inode);
        int cur_level = dn->cur_level;
        int max_level = dn->max_level;
        pgoff_t base = 0;
@@ -636,9 +636,9 @@ static int get_node_path(struct inode *inode, long block,
                                int offset[4], unsigned int noffset[4])
 {
        const long direct_index = ADDRS_PER_INODE(inode);
-       const long direct_blks = ADDRS_PER_BLOCK;
+       const long direct_blks = ADDRS_PER_BLOCK(inode);
        const long dptrs_per_blk = NIDS_PER_BLOCK;
-       const long indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
+       const long indirect_blks = ADDRS_PER_BLOCK(inode) * NIDS_PER_BLOCK;
        const long dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
        int n = 0;
        int level = 0;

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index cbbb1e35070d0fa3a2f1223b07fb3471e46433ec..fefc8cc6e756d462c8e909dcb1cd60d79afe39f4 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2276,7 +2276,7 @@ static const struct export_operations f2fs_export_ops = {
 static loff_t max_file_blocks(void)
 {
        loff_t result = 0;
-       loff_t leaf_count = ADDRS_PER_BLOCK;
+       loff_t leaf_count = DEF_ADDRS_PER_BLOCK;
 
        /*
         * note: previously, result is equal to (DEF_ADDRS_PER_INODE -

diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index f5740423b0023e9abf5c5023a5f146a5da59012a..55da9abed0232d6a3e207112d0bd556207c9fc30 100644 (file)
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -198,11 +198,12 @@ struct f2fs_extent {
                                        get_extra_isize(inode))
 #define DEF_NIDS_PER_INODE     5       /* Node IDs in an Inode */
 #define ADDRS_PER_INODE(inode) addrs_per_inode(inode)
-#define ADDRS_PER_BLOCK                1018    /* Address Pointers in a Direct Block */
+#define DEF_ADDRS_PER_BLOCK    1018    /* Address Pointers in a Direct Block */
+#define ADDRS_PER_BLOCK(inode) addrs_per_block(inode)
 #define NIDS_PER_BLOCK         1018    /* Node IDs in an Indirect Block */
 
 #define ADDRS_PER_PAGE(page, inode)    \
-       (IS_INODE(page) ? ADDRS_PER_INODE(inode) : ADDRS_PER_BLOCK)
+       (IS_INODE(page) ? ADDRS_PER_INODE(inode) : ADDRS_PER_BLOCK(inode))
 
 #define        NODE_DIR1_BLOCK         (DEF_ADDRS_PER_INODE + 1)
 #define        NODE_DIR2_BLOCK         (DEF_ADDRS_PER_INODE + 2)
@@ -267,7 +268,7 @@ struct f2fs_inode {
 } __packed;
 
 struct direct_node {
-       __le32 addr[ADDRS_PER_BLOCK];   /* array of data block address */
+       __le32 addr[DEF_ADDRS_PER_BLOCK];       /* array of data block address */
 } __packed;
 
 struct indirect_node {