f2fs: support large sector size

Block size in f2fs is 4096 bytes, so theoretically, f2fs can support 4096 bytes
sector device at maximum. But now f2fs only support 512 bytes size sector, so
block device such as zRAM which uses page cache as its block storage space will
not be mounted successfully as mismatch between sector size of zRAM and sector
size of f2fs supported.

In this patch we support large sector size in f2fs, so block device with sector
size of 512/1024/2048/4096 bytes can be supported in f2fs.

Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index aaf22a9120441291b2772ad78a21c82568b1c9b0..13ab72084913016da8e012ce0cf7e3c7ac58527e 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -85,7 +85,7 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr,
        bio = bio_alloc(GFP_NOIO, npages);
 
        bio->bi_bdev = sbi->sb->s_bdev;
-       bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
+       bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);
        bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;
        bio->bi_private = sbi;
 

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 4ea53aab786d984da2a9fd4e8bdd2ea283394c4c..24b768ae39c4c34f929757be3041619103531c84 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -370,8 +370,8 @@ static void locate_dirty_segment(struct f2fs_sb_info *sbi, unsigned int segno)
 static int f2fs_issue_discard(struct f2fs_sb_info *sbi,
                                block_t blkstart, block_t blklen)
 {
-       sector_t start = SECTOR_FROM_BLOCK(sbi, blkstart);
-       sector_t len = SECTOR_FROM_BLOCK(sbi, blklen);
+       sector_t start = SECTOR_FROM_BLOCK(blkstart);
+       sector_t len = SECTOR_FROM_BLOCK(blklen);
        trace_f2fs_issue_discard(sbi->sb, blkstart, blklen);
        return blkdev_issue_discard(sbi->sb->s_bdev, start, len, GFP_NOFS, 0);
 }

diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 848ac519958fa97d9d0440b59d305cdff8da2d4b..032c0905a12bfae7f54194125525b9a87ec68fd4 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -89,10 +89,10 @@
 #define TOTAL_SECS(sbi)        (sbi->total_sections)
 #define TOTAL_BLKS(sbi)        (SM_I(sbi)->segment_count << sbi->log_blocks_per_seg)
 
-#define SECTOR_FROM_BLOCK(sbi, blk_addr)                               \
-       (((sector_t)blk_addr) << (sbi)->log_sectors_per_block)
-#define SECTOR_TO_BLOCK(sbi, sectors)                                  \
-       (sectors >> (sbi)->log_sectors_per_block)
+#define SECTOR_FROM_BLOCK(blk_addr)                                    \
+       (((sector_t)blk_addr) << F2FS_LOG_SECTORS_PER_BLOCK)
+#define SECTOR_TO_BLOCK(sectors)                                       \
+       (sectors >> F2FS_LOG_SECTORS_PER_BLOCK)
 #define MAX_BIO_BLOCKS(sbi)                                            \
        ((int)min((int)max_hw_blocks(sbi), BIO_MAX_PAGES))
 
@@ -711,7 +711,7 @@ static inline unsigned int max_hw_blocks(struct f2fs_sb_info *sbi)
 {
        struct block_device *bdev = sbi->sb->s_bdev;
        struct request_queue *q = bdev_get_queue(bdev);
-       return SECTOR_TO_BLOCK(sbi, queue_max_sectors(q));
+       return SECTOR_TO_BLOCK(queue_max_sectors(q));
 }
 
 /*

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index ed4095e5e8a7405c7b49a489466dcee9e3fca643..3dfa1b5eae2f04d44791ac4d17056f6beedbc8f7 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -788,14 +788,22 @@ static int sanity_check_raw_super(struct super_block *sb,
                return 1;
        }
 
-       if (le32_to_cpu(raw_super->log_sectorsize) !=
-                                       F2FS_LOG_SECTOR_SIZE) {
-               f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize");
+       /* Currently, support 512/1024/2048/4096 bytes sector size */
+       if (le32_to_cpu(raw_super->log_sectorsize) >
+                               F2FS_MAX_LOG_SECTOR_SIZE ||
+               le32_to_cpu(raw_super->log_sectorsize) <
+                               F2FS_MIN_LOG_SECTOR_SIZE) {
+               f2fs_msg(sb, KERN_INFO, "Invalid log sectorsize (%u)",
+                       le32_to_cpu(raw_super->log_sectorsize));
                return 1;
        }
-       if (le32_to_cpu(raw_super->log_sectors_per_block) !=
-                                       F2FS_LOG_SECTORS_PER_BLOCK) {
-               f2fs_msg(sb, KERN_INFO, "Invalid log sectors per block");
+       if (le32_to_cpu(raw_super->log_sectors_per_block) +
+               le32_to_cpu(raw_super->log_sectorsize) !=
+                       F2FS_MAX_LOG_SECTOR_SIZE) {
+               f2fs_msg(sb, KERN_INFO,
+                       "Invalid log sectors per block(%u) log sectorsize(%u)",
+                       le32_to_cpu(raw_super->log_sectors_per_block),
+                       le32_to_cpu(raw_super->log_sectorsize));
                return 1;
        }
        return 0;

diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 9ca1ff3d46623e0e8499ea97863886e8272a61e9..860313a33a43882a67dabc55bb65badd82f1776f 100644 (file)
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -15,8 +15,9 @@
 #include <linux/types.h>
 
 #define F2FS_SUPER_OFFSET              1024    /* byte-size offset */
-#define F2FS_LOG_SECTOR_SIZE           9       /* 9 bits for 512 byte */
-#define F2FS_LOG_SECTORS_PER_BLOCK     3       /* 4KB: F2FS_BLKSIZE */
+#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_MAX_EXTENSION             64      /* # of extension entries */
 #define F2FS_BLK_ALIGN(x)      (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)