#define F2FS_SUPER_OFFSET              1024    /* byte-size offset */
 #define F2FS_MIN_LOG_SECTOR_SIZE       9       /* 9 bits for 512 bytes */
-#define F2FS_MAX_LOG_SECTOR_SIZE       12      /* 12 bits for 4096 bytes */
-#define F2FS_LOG_SECTORS_PER_BLOCK     3       /* log number for sector/blk */
-#define F2FS_BLKSIZE                   4096    /* support only 4KB block */
-#define F2FS_BLKSIZE_BITS              12      /* bits for F2FS_BLKSIZE */
+#define F2FS_MAX_LOG_SECTOR_SIZE       PAGE_SHIFT      /* Max is Block Size */
+#define F2FS_LOG_SECTORS_PER_BLOCK     (PAGE_SHIFT - 9) /* log number for sector/blk */
+#define F2FS_BLKSIZE                   PAGE_SIZE /* support only block == page */
+#define F2FS_BLKSIZE_BITS              PAGE_SHIFT /* bits for F2FS_BLKSIZE */
 #define F2FS_MAX_EXTENSION             64      /* # of extension entries */
 #define F2FS_EXTENSION_LEN             8       /* max size of extension */
 #define F2FS_BLK_ALIGN(x)      (((x) + F2FS_BLKSIZE - 1) >> F2FS_BLKSIZE_BITS)
        unsigned char sit_nat_version_bitmap[];
 } __packed;
 
-#define CP_CHKSUM_OFFSET       4092    /* default chksum offset in checkpoint */
+#define CP_CHKSUM_OFFSET       (F2FS_BLKSIZE - sizeof(__le32)) /* default chksum offset in checkpoint */
 #define CP_MIN_CHKSUM_OFFSET                                           \
        (offsetof(struct f2fs_checkpoint, sit_nat_version_bitmap))
 
 /*
  * For orphan inode management
  */
-#define F2FS_ORPHANS_PER_BLOCK 1020
+#define F2FS_ORPHANS_PER_BLOCK ((F2FS_BLKSIZE - 4 * sizeof(__le32)) / sizeof(__le32))
 
 #define GET_ORPHAN_BLOCKS(n)   (((n) + F2FS_ORPHANS_PER_BLOCK - 1) / \
                                        F2FS_ORPHANS_PER_BLOCK)
 #define F2FS_NAME_LEN          255
 /* 200 bytes for inline xattrs by default */
 #define DEFAULT_INLINE_XATTR_ADDRS     50
-#define DEF_ADDRS_PER_INODE    923     /* Address Pointers in an Inode */
+
+#define OFFSET_OF_END_OF_I_EXT         360
+#define SIZE_OF_I_NID                  20
+
+struct node_footer {
+       __le32 nid;             /* node id */
+       __le32 ino;             /* inode number */
+       __le32 flag;            /* include cold/fsync/dentry marks and offset */
+       __le64 cp_ver;          /* checkpoint version */
+       __le32 next_blkaddr;    /* next node page block address */
+} __packed;
+
+/* Address Pointers in an Inode */
+#define DEF_ADDRS_PER_INODE    ((F2FS_BLKSIZE - OFFSET_OF_END_OF_I_EXT \
+                                       - SIZE_OF_I_NID \
+                                       - sizeof(struct node_footer)) / sizeof(__le32))
 #define CUR_ADDRS_PER_INODE(inode)     (DEF_ADDRS_PER_INODE - \
                                        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 DEF_ADDRS_PER_BLOCK    1018    /* Address Pointers in a Direct Block */
+/* Address Pointers in a Direct Block */
+#define DEF_ADDRS_PER_BLOCK    ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))
 #define ADDRS_PER_BLOCK(inode) addrs_per_block(inode)
-#define NIDS_PER_BLOCK         1018    /* Node IDs in an Indirect Block */
+/* Node IDs in an Indirect Block */
+#define NIDS_PER_BLOCK         ((F2FS_BLKSIZE - sizeof(struct node_footer)) / sizeof(__le32))
 
 #define ADDRS_PER_PAGE(page, inode)    \
        (IS_INODE(page) ? ADDRS_PER_INODE(inode) : ADDRS_PER_BLOCK(inode))
 
 #define OFFSET_BIT_MASK                GENMASK(OFFSET_BIT_SHIFT - 1, 0)
 
-struct node_footer {
-       __le32 nid;             /* node id */
-       __le32 ino;             /* inode number */
-       __le32 flag;            /* include cold/fsync/dentry marks and offset */
-       __le64 cp_ver;          /* checkpoint version */
-       __le32 next_blkaddr;    /* next node page block address */
-} __packed;
-
 struct f2fs_node {
        /* can be one of three types: inode, direct, and indirect types */
        union {
 /*
  * For NAT entries
  */
-#define NAT_ENTRY_PER_BLOCK (PAGE_SIZE / sizeof(struct f2fs_nat_entry))
+#define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_nat_entry))
 
 struct f2fs_nat_entry {
        __u8 version;           /* latest version of cached nat entry */
 /*
  * For SIT entries
  *
- * Each segment is 2MB in size by default so that a bitmap for validity of
- * there-in blocks should occupy 64 bytes, 512 bits.
+ * A validity bitmap of 64 bytes covers 512 blocks of area. For a 4K page size,
+ * this results in a segment size of 2MB. For 16k pages, the default segment size
+ * is 8MB.
  * Not allow to change this.
  */
 #define SIT_VBLOCK_MAP_SIZE 64
-#define SIT_ENTRY_PER_BLOCK (PAGE_SIZE / sizeof(struct f2fs_sit_entry))
+#define SIT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / sizeof(struct f2fs_sit_entry))
 
 /*
  * F2FS uses 4 bytes to represent block address. As a result, supported size of
  * For segment summary
  *
  * One summary block contains exactly 512 summary entries, which represents
- * exactly 2MB segment by default. Not allow to change the basic units.
+ * exactly one segment by default. Not allow to change the basic units.
  *
  * NOTE: For initializing fields, you must use set_summary
  *
  * from node's page's beginning to get a data block address.
  * ex) data_blkaddr = (block_t)(nodepage_start_address + ofs_in_node)
  */
-#define ENTRIES_IN_SUM         512
+#define ENTRIES_IN_SUM         (F2FS_BLKSIZE / 8)
 #define        SUMMARY_SIZE            (7)     /* sizeof(struct summary) */
 #define        SUM_FOOTER_SIZE         (5)     /* sizeof(struct summary_footer) */
 #define SUM_ENTRY_SIZE         (SUMMARY_SIZE * ENTRIES_IN_SUM)
 
-/* a summary entry for a 4KB-sized block in a segment */
+/* a summary entry for a block in a segment */
 struct f2fs_summary {
        __le32 nid;             /* parent node id */
        union {
        };
 } __packed;
 
-/* 4KB-sized summary block structure */
+/* Block-sized summary block structure */
 struct f2fs_summary_block {
        struct f2fs_summary entries[ENTRIES_IN_SUM];
        struct f2fs_journal journal;
  * Note: there are more reserved space in inline dentry than in regular
  * dentry, when converting inline dentry we should handle this carefully.
  */
-#define NR_DENTRY_IN_BLOCK     214     /* the number of dentry in a block */
+
+/* the number of dentry in a block */
+#define NR_DENTRY_IN_BLOCK     ((BITS_PER_BYTE * F2FS_BLKSIZE) / \
+                                       ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * BITS_PER_BYTE + 1))
 #define SIZE_OF_DIR_ENTRY      11      /* by byte */
 #define SIZE_OF_DENTRY_BITMAP  ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
                                        BITS_PER_BYTE)
-#define SIZE_OF_RESERVED       (PAGE_SIZE - ((SIZE_OF_DIR_ENTRY + \
+#define SIZE_OF_RESERVED       (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \
                                F2FS_SLOT_LEN) * \
                                NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
 #define MIN_INLINE_DENTRY_SIZE         40      /* just include '.' and '..' entries */
        __u8 file_type;         /* file type */
 } __packed;
 
-/* 4KB-sized directory entry block */
+/* Block-sized directory entry block */
 struct f2fs_dentry_block {
        /* validity bitmap for directory entries in each block */
        __u8 dentry_bitmap[SIZE_OF_DENTRY_BITMAP];