14c8ff709SChao Yu // SPDX-License-Identifier: GPL-2.0 24c8ff709SChao Yu /* 34c8ff709SChao Yu * f2fs compress support 44c8ff709SChao Yu * 54c8ff709SChao Yu * Copyright (c) 2019 Chao Yu <chao@kernel.org> 64c8ff709SChao Yu */ 74c8ff709SChao Yu 84c8ff709SChao Yu #include <linux/fs.h> 94c8ff709SChao Yu #include <linux/f2fs_fs.h> 10e41d12f5SChristoph Hellwig #include <linux/moduleparam.h> 114c8ff709SChao Yu #include <linux/writeback.h> 124c8ff709SChao Yu #include <linux/backing-dev.h> 134c8ff709SChao Yu #include <linux/lzo.h> 144c8ff709SChao Yu #include <linux/lz4.h> 1550cfa66fSChao Yu #include <linux/zstd.h> 166ce19affSChao Yu #include <linux/pagevec.h> 174c8ff709SChao Yu 184c8ff709SChao Yu #include "f2fs.h" 194c8ff709SChao Yu #include "node.h" 206ce19affSChao Yu #include "segment.h" 214c8ff709SChao Yu #include <trace/events/f2fs.h> 224c8ff709SChao Yu 23c68d6c88SChao Yu static struct kmem_cache *cic_entry_slab; 24c68d6c88SChao Yu static struct kmem_cache *dic_entry_slab; 25c68d6c88SChao Yu 2631083031SChao Yu static void *page_array_alloc(struct inode *inode, int nr) 2731083031SChao Yu { 2831083031SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2931083031SChao Yu unsigned int size = sizeof(struct page *) * nr; 3031083031SChao Yu 3131083031SChao Yu if (likely(size <= sbi->page_array_slab_size)) 3232410577SChao Yu return f2fs_kmem_cache_alloc(sbi->page_array_slab, 3332410577SChao Yu GFP_F2FS_ZERO, false, F2FS_I_SB(inode)); 3431083031SChao Yu return f2fs_kzalloc(sbi, size, GFP_NOFS); 3531083031SChao Yu } 3631083031SChao Yu 3731083031SChao Yu static void page_array_free(struct inode *inode, void *pages, int nr) 3831083031SChao Yu { 3931083031SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 4031083031SChao Yu unsigned int size = sizeof(struct page *) * nr; 4131083031SChao Yu 4231083031SChao Yu if (!pages) 4331083031SChao Yu return; 4431083031SChao Yu 4531083031SChao Yu if (likely(size <= sbi->page_array_slab_size)) 4631083031SChao Yu kmem_cache_free(sbi->page_array_slab, pages); 4731083031SChao Yu else 4831083031SChao Yu kfree(pages); 4931083031SChao Yu } 5031083031SChao Yu 514c8ff709SChao Yu struct f2fs_compress_ops { 524c8ff709SChao Yu int (*init_compress_ctx)(struct compress_ctx *cc); 534c8ff709SChao Yu void (*destroy_compress_ctx)(struct compress_ctx *cc); 544c8ff709SChao Yu int (*compress_pages)(struct compress_ctx *cc); 5523b1faaaSChao Yu int (*init_decompress_ctx)(struct decompress_io_ctx *dic); 5623b1faaaSChao Yu void (*destroy_decompress_ctx)(struct decompress_io_ctx *dic); 574c8ff709SChao Yu int (*decompress_pages)(struct decompress_io_ctx *dic); 58c571fbb5SSheng Yong bool (*is_level_valid)(int level); 594c8ff709SChao Yu }; 604c8ff709SChao Yu 614c8ff709SChao Yu static unsigned int offset_in_cluster(struct compress_ctx *cc, pgoff_t index) 624c8ff709SChao Yu { 634c8ff709SChao Yu return index & (cc->cluster_size - 1); 644c8ff709SChao Yu } 654c8ff709SChao Yu 664c8ff709SChao Yu static pgoff_t cluster_idx(struct compress_ctx *cc, pgoff_t index) 674c8ff709SChao Yu { 684c8ff709SChao Yu return index >> cc->log_cluster_size; 694c8ff709SChao Yu } 704c8ff709SChao Yu 714c8ff709SChao Yu static pgoff_t start_idx_of_cluster(struct compress_ctx *cc) 724c8ff709SChao Yu { 734c8ff709SChao Yu return cc->cluster_idx << cc->log_cluster_size; 744c8ff709SChao Yu } 754c8ff709SChao Yu 764c8ff709SChao Yu bool f2fs_is_compressed_page(struct page *page) 774c8ff709SChao Yu { 784c8ff709SChao Yu if (!PagePrivate(page)) 794c8ff709SChao Yu return false; 804c8ff709SChao Yu if (!page_private(page)) 814c8ff709SChao Yu return false; 82b763f3beSChao Yu if (page_private_nonpointer(page)) 834c8ff709SChao Yu return false; 8429b993c7SYu Changchun 854c8ff709SChao Yu f2fs_bug_on(F2FS_M_SB(page->mapping), 864c8ff709SChao Yu *((u32 *)page_private(page)) != F2FS_COMPRESSED_PAGE_MAGIC); 874c8ff709SChao Yu return true; 884c8ff709SChao Yu } 894c8ff709SChao Yu 904c8ff709SChao Yu static void f2fs_set_compressed_page(struct page *page, 91887347a0SChao Yu struct inode *inode, pgoff_t index, void *data) 924c8ff709SChao Yu { 93b763f3beSChao Yu attach_page_private(page, (void *)data); 944c8ff709SChao Yu 954c8ff709SChao Yu /* i_crypto_info and iv index */ 964c8ff709SChao Yu page->index = index; 974c8ff709SChao Yu page->mapping = inode->i_mapping; 984c8ff709SChao Yu } 994c8ff709SChao Yu 1004c8ff709SChao Yu static void f2fs_drop_rpages(struct compress_ctx *cc, int len, bool unlock) 1014c8ff709SChao Yu { 1024c8ff709SChao Yu int i; 1034c8ff709SChao Yu 1044c8ff709SChao Yu for (i = 0; i < len; i++) { 1054c8ff709SChao Yu if (!cc->rpages[i]) 1064c8ff709SChao Yu continue; 1074c8ff709SChao Yu if (unlock) 1084c8ff709SChao Yu unlock_page(cc->rpages[i]); 1094c8ff709SChao Yu else 1104c8ff709SChao Yu put_page(cc->rpages[i]); 1114c8ff709SChao Yu } 1124c8ff709SChao Yu } 1134c8ff709SChao Yu 1144c8ff709SChao Yu static void f2fs_put_rpages(struct compress_ctx *cc) 1154c8ff709SChao Yu { 1164c8ff709SChao Yu f2fs_drop_rpages(cc, cc->cluster_size, false); 1174c8ff709SChao Yu } 1184c8ff709SChao Yu 1194c8ff709SChao Yu static void f2fs_unlock_rpages(struct compress_ctx *cc, int len) 1204c8ff709SChao Yu { 1214c8ff709SChao Yu f2fs_drop_rpages(cc, len, true); 1224c8ff709SChao Yu } 1234c8ff709SChao Yu 1244c8ff709SChao Yu static void f2fs_put_rpages_wbc(struct compress_ctx *cc, 1254c8ff709SChao Yu struct writeback_control *wbc, bool redirty, int unlock) 1264c8ff709SChao Yu { 1274c8ff709SChao Yu unsigned int i; 1284c8ff709SChao Yu 1294c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1304c8ff709SChao Yu if (!cc->rpages[i]) 1314c8ff709SChao Yu continue; 1324c8ff709SChao Yu if (redirty) 1334c8ff709SChao Yu redirty_page_for_writepage(wbc, cc->rpages[i]); 1344c8ff709SChao Yu f2fs_put_page(cc->rpages[i], unlock); 1354c8ff709SChao Yu } 1364c8ff709SChao Yu } 1374c8ff709SChao Yu 1384c8ff709SChao Yu struct page *f2fs_compress_control_page(struct page *page) 1394c8ff709SChao Yu { 1404c8ff709SChao Yu return ((struct compress_io_ctx *)page_private(page))->rpages[0]; 1414c8ff709SChao Yu } 1424c8ff709SChao Yu 1434c8ff709SChao Yu int f2fs_init_compress_ctx(struct compress_ctx *cc) 1444c8ff709SChao Yu { 145adfc6943SJaegeuk Kim if (cc->rpages) 1464c8ff709SChao Yu return 0; 1474c8ff709SChao Yu 14831083031SChao Yu cc->rpages = page_array_alloc(cc->inode, cc->cluster_size); 1494c8ff709SChao Yu return cc->rpages ? 0 : -ENOMEM; 1504c8ff709SChao Yu } 1514c8ff709SChao Yu 1528bfbfb0dSChao Yu void f2fs_destroy_compress_ctx(struct compress_ctx *cc, bool reuse) 1534c8ff709SChao Yu { 15431083031SChao Yu page_array_free(cc->inode, cc->rpages, cc->cluster_size); 1554c8ff709SChao Yu cc->rpages = NULL; 1564c8ff709SChao Yu cc->nr_rpages = 0; 1574c8ff709SChao Yu cc->nr_cpages = 0; 1583271d7ebSFengnan Chang cc->valid_nr_cpages = 0; 1598bfbfb0dSChao Yu if (!reuse) 1604c8ff709SChao Yu cc->cluster_idx = NULL_CLUSTER; 1614c8ff709SChao Yu } 1624c8ff709SChao Yu 1634c8ff709SChao Yu void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page) 1644c8ff709SChao Yu { 1654c8ff709SChao Yu unsigned int cluster_ofs; 1664c8ff709SChao Yu 1674c8ff709SChao Yu if (!f2fs_cluster_can_merge_page(cc, page->index)) 1684c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), 1); 1694c8ff709SChao Yu 1704c8ff709SChao Yu cluster_ofs = offset_in_cluster(cc, page->index); 1714c8ff709SChao Yu cc->rpages[cluster_ofs] = page; 1724c8ff709SChao Yu cc->nr_rpages++; 1734c8ff709SChao Yu cc->cluster_idx = cluster_idx(cc, page->index); 1744c8ff709SChao Yu } 1754c8ff709SChao Yu 1764c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 1774c8ff709SChao Yu static int lzo_init_compress_ctx(struct compress_ctx *cc) 1784c8ff709SChao Yu { 1794c8ff709SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 1804c8ff709SChao Yu LZO1X_MEM_COMPRESS, GFP_NOFS); 1814c8ff709SChao Yu if (!cc->private) 1824c8ff709SChao Yu return -ENOMEM; 1834c8ff709SChao Yu 1844c8ff709SChao Yu cc->clen = lzo1x_worst_compress(PAGE_SIZE << cc->log_cluster_size); 1854c8ff709SChao Yu return 0; 1864c8ff709SChao Yu } 1874c8ff709SChao Yu 1884c8ff709SChao Yu static void lzo_destroy_compress_ctx(struct compress_ctx *cc) 1894c8ff709SChao Yu { 1904c8ff709SChao Yu kvfree(cc->private); 1914c8ff709SChao Yu cc->private = NULL; 1924c8ff709SChao Yu } 1934c8ff709SChao Yu 1944c8ff709SChao Yu static int lzo_compress_pages(struct compress_ctx *cc) 1954c8ff709SChao Yu { 1964c8ff709SChao Yu int ret; 1974c8ff709SChao Yu 1984c8ff709SChao Yu ret = lzo1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 1994c8ff709SChao Yu &cc->clen, cc->private); 2004c8ff709SChao Yu if (ret != LZO_E_OK) { 2014c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo compress failed, ret:%d\n", 2024c8ff709SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 2034c8ff709SChao Yu return -EIO; 2044c8ff709SChao Yu } 2054c8ff709SChao Yu return 0; 2064c8ff709SChao Yu } 2074c8ff709SChao Yu 2084c8ff709SChao Yu static int lzo_decompress_pages(struct decompress_io_ctx *dic) 2094c8ff709SChao Yu { 2104c8ff709SChao Yu int ret; 2114c8ff709SChao Yu 2124c8ff709SChao Yu ret = lzo1x_decompress_safe(dic->cbuf->cdata, dic->clen, 2134c8ff709SChao Yu dic->rbuf, &dic->rlen); 2144c8ff709SChao Yu if (ret != LZO_E_OK) { 2154c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo decompress failed, ret:%d\n", 2164c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 2174c8ff709SChao Yu return -EIO; 2184c8ff709SChao Yu } 2194c8ff709SChao Yu 2204c8ff709SChao Yu if (dic->rlen != PAGE_SIZE << dic->log_cluster_size) { 2214c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo invalid rlen:%zu, " 2224c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 2234c8ff709SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 2244c8ff709SChao Yu dic->rlen, 2254c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 2264c8ff709SChao Yu return -EIO; 2274c8ff709SChao Yu } 2284c8ff709SChao Yu return 0; 2294c8ff709SChao Yu } 2304c8ff709SChao Yu 2314c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lzo_ops = { 2324c8ff709SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 2334c8ff709SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 2344c8ff709SChao Yu .compress_pages = lzo_compress_pages, 2354c8ff709SChao Yu .decompress_pages = lzo_decompress_pages, 2364c8ff709SChao Yu }; 2374c8ff709SChao Yu #endif 2384c8ff709SChao Yu 2394c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 2404c8ff709SChao Yu static int lz4_init_compress_ctx(struct compress_ctx *cc) 2414c8ff709SChao Yu { 2423fde13f8SChao Yu unsigned int size = LZ4_MEM_COMPRESS; 2433fde13f8SChao Yu 2443fde13f8SChao Yu #ifdef CONFIG_F2FS_FS_LZ4HC 245b90e5086SChao Yu if (F2FS_I(cc->inode)->i_compress_level) 2463fde13f8SChao Yu size = LZ4HC_MEM_COMPRESS; 2473fde13f8SChao Yu #endif 2483fde13f8SChao Yu 2493fde13f8SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), size, GFP_NOFS); 2504c8ff709SChao Yu if (!cc->private) 2514c8ff709SChao Yu return -ENOMEM; 2524c8ff709SChao Yu 253f6644143SChao Yu /* 254f6644143SChao Yu * we do not change cc->clen to LZ4_compressBound(inputsize) to 255f6644143SChao Yu * adapt worst compress case, because lz4 compressor can handle 256f6644143SChao Yu * output budget properly. 257f6644143SChao Yu */ 258f6644143SChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 2594c8ff709SChao Yu return 0; 2604c8ff709SChao Yu } 2614c8ff709SChao Yu 2624c8ff709SChao Yu static void lz4_destroy_compress_ctx(struct compress_ctx *cc) 2634c8ff709SChao Yu { 2644c8ff709SChao Yu kvfree(cc->private); 2654c8ff709SChao Yu cc->private = NULL; 2664c8ff709SChao Yu } 2674c8ff709SChao Yu 2684c8ff709SChao Yu static int lz4_compress_pages(struct compress_ctx *cc) 2694c8ff709SChao Yu { 2703094e557SYangtao Li int len = -EINVAL; 2713094e557SYangtao Li unsigned char level = F2FS_I(cc->inode)->i_compress_level; 2724c8ff709SChao Yu 2733094e557SYangtao Li if (!level) 2744c8ff709SChao Yu len = LZ4_compress_default(cc->rbuf, cc->cbuf->cdata, cc->rlen, 2754c8ff709SChao Yu cc->clen, cc->private); 2763094e557SYangtao Li #ifdef CONFIG_F2FS_FS_LZ4HC 2773094e557SYangtao Li else 2783094e557SYangtao Li len = LZ4_compress_HC(cc->rbuf, cc->cbuf->cdata, cc->rlen, 2793094e557SYangtao Li cc->clen, level, cc->private); 2803094e557SYangtao Li #endif 2813094e557SYangtao Li if (len < 0) 2823094e557SYangtao Li return len; 283f6644143SChao Yu if (!len) 284f6644143SChao Yu return -EAGAIN; 285f6644143SChao Yu 2864c8ff709SChao Yu cc->clen = len; 2874c8ff709SChao Yu return 0; 2884c8ff709SChao Yu } 2894c8ff709SChao Yu 2904c8ff709SChao Yu static int lz4_decompress_pages(struct decompress_io_ctx *dic) 2914c8ff709SChao Yu { 2924c8ff709SChao Yu int ret; 2934c8ff709SChao Yu 2944c8ff709SChao Yu ret = LZ4_decompress_safe(dic->cbuf->cdata, dic->rbuf, 2954c8ff709SChao Yu dic->clen, dic->rlen); 2964c8ff709SChao Yu if (ret < 0) { 2974c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 decompress failed, ret:%d\n", 2984c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 2994c8ff709SChao Yu return -EIO; 3004c8ff709SChao Yu } 3014c8ff709SChao Yu 3024c8ff709SChao Yu if (ret != PAGE_SIZE << dic->log_cluster_size) { 303d284af43SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 invalid ret:%d, " 3044c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 305d284af43SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, ret, 3064c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 3074c8ff709SChao Yu return -EIO; 3084c8ff709SChao Yu } 3094c8ff709SChao Yu return 0; 3104c8ff709SChao Yu } 3114c8ff709SChao Yu 312c571fbb5SSheng Yong static bool lz4_is_level_valid(int lvl) 313c571fbb5SSheng Yong { 314c571fbb5SSheng Yong #ifdef CONFIG_F2FS_FS_LZ4HC 315c571fbb5SSheng Yong return !lvl || (lvl >= LZ4HC_MIN_CLEVEL && lvl <= LZ4HC_MAX_CLEVEL); 316c571fbb5SSheng Yong #else 317c571fbb5SSheng Yong return lvl == 0; 318c571fbb5SSheng Yong #endif 319c571fbb5SSheng Yong } 320c571fbb5SSheng Yong 3214c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lz4_ops = { 3224c8ff709SChao Yu .init_compress_ctx = lz4_init_compress_ctx, 3234c8ff709SChao Yu .destroy_compress_ctx = lz4_destroy_compress_ctx, 3244c8ff709SChao Yu .compress_pages = lz4_compress_pages, 3254c8ff709SChao Yu .decompress_pages = lz4_decompress_pages, 326c571fbb5SSheng Yong .is_level_valid = lz4_is_level_valid, 3274c8ff709SChao Yu }; 3284c8ff709SChao Yu #endif 3294c8ff709SChao Yu 33050cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 33150cfa66fSChao Yu static int zstd_init_compress_ctx(struct compress_ctx *cc) 33250cfa66fSChao Yu { 333cf30f6a5SNick Terrell zstd_parameters params; 334cf30f6a5SNick Terrell zstd_cstream *stream; 33550cfa66fSChao Yu void *workspace; 33650cfa66fSChao Yu unsigned int workspace_size; 337b90e5086SChao Yu unsigned char level = F2FS_I(cc->inode)->i_compress_level; 33850cfa66fSChao Yu 33900e120b5SJaegeuk Kim /* Need to remain this for backward compatibility */ 3403fde13f8SChao Yu if (!level) 3413fde13f8SChao Yu level = F2FS_ZSTD_DEFAULT_CLEVEL; 3423fde13f8SChao Yu 3434ff23a65SSheng Yong params = zstd_get_params(level, cc->rlen); 344cf30f6a5SNick Terrell workspace_size = zstd_cstream_workspace_bound(¶ms.cParams); 34550cfa66fSChao Yu 34650cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 34750cfa66fSChao Yu workspace_size, GFP_NOFS); 34850cfa66fSChao Yu if (!workspace) 34950cfa66fSChao Yu return -ENOMEM; 35050cfa66fSChao Yu 351cf30f6a5SNick Terrell stream = zstd_init_cstream(¶ms, 0, workspace, workspace_size); 35250cfa66fSChao Yu if (!stream) { 353cf30f6a5SNick Terrell printk_ratelimited("%sF2FS-fs (%s): %s zstd_init_cstream failed\n", 35450cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 35550cfa66fSChao Yu __func__); 35650cfa66fSChao Yu kvfree(workspace); 35750cfa66fSChao Yu return -EIO; 35850cfa66fSChao Yu } 35950cfa66fSChao Yu 36050cfa66fSChao Yu cc->private = workspace; 36150cfa66fSChao Yu cc->private2 = stream; 36250cfa66fSChao Yu 36350cfa66fSChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 36450cfa66fSChao Yu return 0; 36550cfa66fSChao Yu } 36650cfa66fSChao Yu 36750cfa66fSChao Yu static void zstd_destroy_compress_ctx(struct compress_ctx *cc) 36850cfa66fSChao Yu { 36950cfa66fSChao Yu kvfree(cc->private); 37050cfa66fSChao Yu cc->private = NULL; 37150cfa66fSChao Yu cc->private2 = NULL; 37250cfa66fSChao Yu } 37350cfa66fSChao Yu 37450cfa66fSChao Yu static int zstd_compress_pages(struct compress_ctx *cc) 37550cfa66fSChao Yu { 376cf30f6a5SNick Terrell zstd_cstream *stream = cc->private2; 377cf30f6a5SNick Terrell zstd_in_buffer inbuf; 378cf30f6a5SNick Terrell zstd_out_buffer outbuf; 37950cfa66fSChao Yu int src_size = cc->rlen; 38050cfa66fSChao Yu int dst_size = src_size - PAGE_SIZE - COMPRESS_HEADER_SIZE; 38150cfa66fSChao Yu int ret; 38250cfa66fSChao Yu 38350cfa66fSChao Yu inbuf.pos = 0; 38450cfa66fSChao Yu inbuf.src = cc->rbuf; 38550cfa66fSChao Yu inbuf.size = src_size; 38650cfa66fSChao Yu 38750cfa66fSChao Yu outbuf.pos = 0; 38850cfa66fSChao Yu outbuf.dst = cc->cbuf->cdata; 38950cfa66fSChao Yu outbuf.size = dst_size; 39050cfa66fSChao Yu 391cf30f6a5SNick Terrell ret = zstd_compress_stream(stream, &outbuf, &inbuf); 392cf30f6a5SNick Terrell if (zstd_is_error(ret)) { 393cf30f6a5SNick Terrell printk_ratelimited("%sF2FS-fs (%s): %s zstd_compress_stream failed, ret: %d\n", 39450cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 395cf30f6a5SNick Terrell __func__, zstd_get_error_code(ret)); 39650cfa66fSChao Yu return -EIO; 39750cfa66fSChao Yu } 39850cfa66fSChao Yu 399cf30f6a5SNick Terrell ret = zstd_end_stream(stream, &outbuf); 400cf30f6a5SNick Terrell if (zstd_is_error(ret)) { 401cf30f6a5SNick Terrell printk_ratelimited("%sF2FS-fs (%s): %s zstd_end_stream returned %d\n", 40250cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 403cf30f6a5SNick Terrell __func__, zstd_get_error_code(ret)); 40450cfa66fSChao Yu return -EIO; 40550cfa66fSChao Yu } 40650cfa66fSChao Yu 4071454c978SChao Yu /* 4081454c978SChao Yu * there is compressed data remained in intermediate buffer due to 4091454c978SChao Yu * no more space in cbuf.cdata 4101454c978SChao Yu */ 4111454c978SChao Yu if (ret) 4121454c978SChao Yu return -EAGAIN; 4131454c978SChao Yu 41450cfa66fSChao Yu cc->clen = outbuf.pos; 41550cfa66fSChao Yu return 0; 41650cfa66fSChao Yu } 41750cfa66fSChao Yu 41850cfa66fSChao Yu static int zstd_init_decompress_ctx(struct decompress_io_ctx *dic) 41950cfa66fSChao Yu { 420cf30f6a5SNick Terrell zstd_dstream *stream; 42150cfa66fSChao Yu void *workspace; 42250cfa66fSChao Yu unsigned int workspace_size; 4230e2b7385SChao Yu unsigned int max_window_size = 4240e2b7385SChao Yu MAX_COMPRESS_WINDOW_SIZE(dic->log_cluster_size); 42550cfa66fSChao Yu 426cf30f6a5SNick Terrell workspace_size = zstd_dstream_workspace_bound(max_window_size); 42750cfa66fSChao Yu 42850cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(dic->inode), 42950cfa66fSChao Yu workspace_size, GFP_NOFS); 43050cfa66fSChao Yu if (!workspace) 43150cfa66fSChao Yu return -ENOMEM; 43250cfa66fSChao Yu 433cf30f6a5SNick Terrell stream = zstd_init_dstream(max_window_size, workspace, workspace_size); 43450cfa66fSChao Yu if (!stream) { 435cf30f6a5SNick Terrell printk_ratelimited("%sF2FS-fs (%s): %s zstd_init_dstream failed\n", 43650cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 43750cfa66fSChao Yu __func__); 43850cfa66fSChao Yu kvfree(workspace); 43950cfa66fSChao Yu return -EIO; 44050cfa66fSChao Yu } 44150cfa66fSChao Yu 44250cfa66fSChao Yu dic->private = workspace; 44350cfa66fSChao Yu dic->private2 = stream; 44450cfa66fSChao Yu 44550cfa66fSChao Yu return 0; 44650cfa66fSChao Yu } 44750cfa66fSChao Yu 44850cfa66fSChao Yu static void zstd_destroy_decompress_ctx(struct decompress_io_ctx *dic) 44950cfa66fSChao Yu { 45050cfa66fSChao Yu kvfree(dic->private); 45150cfa66fSChao Yu dic->private = NULL; 45250cfa66fSChao Yu dic->private2 = NULL; 45350cfa66fSChao Yu } 45450cfa66fSChao Yu 45550cfa66fSChao Yu static int zstd_decompress_pages(struct decompress_io_ctx *dic) 45650cfa66fSChao Yu { 457cf30f6a5SNick Terrell zstd_dstream *stream = dic->private2; 458cf30f6a5SNick Terrell zstd_in_buffer inbuf; 459cf30f6a5SNick Terrell zstd_out_buffer outbuf; 46050cfa66fSChao Yu int ret; 46150cfa66fSChao Yu 46250cfa66fSChao Yu inbuf.pos = 0; 46350cfa66fSChao Yu inbuf.src = dic->cbuf->cdata; 46450cfa66fSChao Yu inbuf.size = dic->clen; 46550cfa66fSChao Yu 46650cfa66fSChao Yu outbuf.pos = 0; 46750cfa66fSChao Yu outbuf.dst = dic->rbuf; 46850cfa66fSChao Yu outbuf.size = dic->rlen; 46950cfa66fSChao Yu 470cf30f6a5SNick Terrell ret = zstd_decompress_stream(stream, &outbuf, &inbuf); 471cf30f6a5SNick Terrell if (zstd_is_error(ret)) { 472cf30f6a5SNick Terrell printk_ratelimited("%sF2FS-fs (%s): %s zstd_decompress_stream failed, ret: %d\n", 47350cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 474cf30f6a5SNick Terrell __func__, zstd_get_error_code(ret)); 47550cfa66fSChao Yu return -EIO; 47650cfa66fSChao Yu } 47750cfa66fSChao Yu 47850cfa66fSChao Yu if (dic->rlen != outbuf.pos) { 47950cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD invalid rlen:%zu, " 48050cfa66fSChao Yu "expected:%lu\n", KERN_ERR, 48150cfa66fSChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 48250cfa66fSChao Yu __func__, dic->rlen, 48350cfa66fSChao Yu PAGE_SIZE << dic->log_cluster_size); 48450cfa66fSChao Yu return -EIO; 48550cfa66fSChao Yu } 48650cfa66fSChao Yu 48750cfa66fSChao Yu return 0; 48850cfa66fSChao Yu } 48950cfa66fSChao Yu 490c571fbb5SSheng Yong static bool zstd_is_level_valid(int lvl) 491c571fbb5SSheng Yong { 492c571fbb5SSheng Yong return lvl >= zstd_min_clevel() && lvl <= zstd_max_clevel(); 493c571fbb5SSheng Yong } 494c571fbb5SSheng Yong 49550cfa66fSChao Yu static const struct f2fs_compress_ops f2fs_zstd_ops = { 49650cfa66fSChao Yu .init_compress_ctx = zstd_init_compress_ctx, 49750cfa66fSChao Yu .destroy_compress_ctx = zstd_destroy_compress_ctx, 49850cfa66fSChao Yu .compress_pages = zstd_compress_pages, 49950cfa66fSChao Yu .init_decompress_ctx = zstd_init_decompress_ctx, 50050cfa66fSChao Yu .destroy_decompress_ctx = zstd_destroy_decompress_ctx, 50150cfa66fSChao Yu .decompress_pages = zstd_decompress_pages, 502c571fbb5SSheng Yong .is_level_valid = zstd_is_level_valid, 50350cfa66fSChao Yu }; 50450cfa66fSChao Yu #endif 50550cfa66fSChao Yu 5066d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZO 5076d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZORLE 5086d92b201SChao Yu static int lzorle_compress_pages(struct compress_ctx *cc) 5096d92b201SChao Yu { 5106d92b201SChao Yu int ret; 5116d92b201SChao Yu 5126d92b201SChao Yu ret = lzorle1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 5136d92b201SChao Yu &cc->clen, cc->private); 5146d92b201SChao Yu if (ret != LZO_E_OK) { 5156d92b201SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo-rle compress failed, ret:%d\n", 5166d92b201SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 5176d92b201SChao Yu return -EIO; 5186d92b201SChao Yu } 5196d92b201SChao Yu return 0; 5206d92b201SChao Yu } 5216d92b201SChao Yu 5226d92b201SChao Yu static const struct f2fs_compress_ops f2fs_lzorle_ops = { 5236d92b201SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 5246d92b201SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 5256d92b201SChao Yu .compress_pages = lzorle_compress_pages, 5266d92b201SChao Yu .decompress_pages = lzo_decompress_pages, 5276d92b201SChao Yu }; 5286d92b201SChao Yu #endif 5296d92b201SChao Yu #endif 5306d92b201SChao Yu 5314c8ff709SChao Yu static const struct f2fs_compress_ops *f2fs_cops[COMPRESS_MAX] = { 5324c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 5334c8ff709SChao Yu &f2fs_lzo_ops, 5344c8ff709SChao Yu #else 5354c8ff709SChao Yu NULL, 5364c8ff709SChao Yu #endif 5374c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 5384c8ff709SChao Yu &f2fs_lz4_ops, 5394c8ff709SChao Yu #else 5404c8ff709SChao Yu NULL, 5414c8ff709SChao Yu #endif 54250cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 54350cfa66fSChao Yu &f2fs_zstd_ops, 54450cfa66fSChao Yu #else 54550cfa66fSChao Yu NULL, 54650cfa66fSChao Yu #endif 5476d92b201SChao Yu #if defined(CONFIG_F2FS_FS_LZO) && defined(CONFIG_F2FS_FS_LZORLE) 5486d92b201SChao Yu &f2fs_lzorle_ops, 5496d92b201SChao Yu #else 5506d92b201SChao Yu NULL, 5516d92b201SChao Yu #endif 5524c8ff709SChao Yu }; 5534c8ff709SChao Yu 5544c8ff709SChao Yu bool f2fs_is_compress_backend_ready(struct inode *inode) 5554c8ff709SChao Yu { 5564c8ff709SChao Yu if (!f2fs_compressed_file(inode)) 5574c8ff709SChao Yu return true; 5584c8ff709SChao Yu return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; 5594c8ff709SChao Yu } 5604c8ff709SChao Yu 561c571fbb5SSheng Yong bool f2fs_is_compress_level_valid(int alg, int lvl) 562c571fbb5SSheng Yong { 563c571fbb5SSheng Yong const struct f2fs_compress_ops *cops = f2fs_cops[alg]; 564c571fbb5SSheng Yong 565c571fbb5SSheng Yong if (cops->is_level_valid) 566c571fbb5SSheng Yong return cops->is_level_valid(lvl); 567c571fbb5SSheng Yong 568c571fbb5SSheng Yong return lvl == 0; 569c571fbb5SSheng Yong } 570c571fbb5SSheng Yong 57199bbe307SJaegeuk Kim static mempool_t *compress_page_pool; 5725e6bbde9SChao Yu static int num_compress_pages = 512; 5735e6bbde9SChao Yu module_param(num_compress_pages, uint, 0444); 5745e6bbde9SChao Yu MODULE_PARM_DESC(num_compress_pages, 5755e6bbde9SChao Yu "Number of intermediate compress pages to preallocate"); 5765e6bbde9SChao Yu 577a1357a91SYangtao Li int __init f2fs_init_compress_mempool(void) 5785e6bbde9SChao Yu { 5795e6bbde9SChao Yu compress_page_pool = mempool_create_page_pool(num_compress_pages, 0); 580870af777SYangtao Li return compress_page_pool ? 0 : -ENOMEM; 5815e6bbde9SChao Yu } 5825e6bbde9SChao Yu 5835e6bbde9SChao Yu void f2fs_destroy_compress_mempool(void) 5845e6bbde9SChao Yu { 5855e6bbde9SChao Yu mempool_destroy(compress_page_pool); 5865e6bbde9SChao Yu } 5875e6bbde9SChao Yu 5885e6bbde9SChao Yu static struct page *f2fs_compress_alloc_page(void) 5894c8ff709SChao Yu { 5904c8ff709SChao Yu struct page *page; 5914c8ff709SChao Yu 5925e6bbde9SChao Yu page = mempool_alloc(compress_page_pool, GFP_NOFS); 5934c8ff709SChao Yu lock_page(page); 5945e6bbde9SChao Yu 5954c8ff709SChao Yu return page; 5964c8ff709SChao Yu } 5974c8ff709SChao Yu 5985e6bbde9SChao Yu static void f2fs_compress_free_page(struct page *page) 5995e6bbde9SChao Yu { 6005e6bbde9SChao Yu if (!page) 6015e6bbde9SChao Yu return; 602b763f3beSChao Yu detach_page_private(page); 6035e6bbde9SChao Yu page->mapping = NULL; 6045e6bbde9SChao Yu unlock_page(page); 6055e6bbde9SChao Yu mempool_free(page, compress_page_pool); 6065e6bbde9SChao Yu } 6075e6bbde9SChao Yu 6086fcaebacSDaeho Jeong #define MAX_VMAP_RETRIES 3 6096fcaebacSDaeho Jeong 6106fcaebacSDaeho Jeong static void *f2fs_vmap(struct page **pages, unsigned int count) 6116fcaebacSDaeho Jeong { 6126fcaebacSDaeho Jeong int i; 6136fcaebacSDaeho Jeong void *buf = NULL; 6146fcaebacSDaeho Jeong 6156fcaebacSDaeho Jeong for (i = 0; i < MAX_VMAP_RETRIES; i++) { 6166fcaebacSDaeho Jeong buf = vm_map_ram(pages, count, -1); 6176fcaebacSDaeho Jeong if (buf) 6186fcaebacSDaeho Jeong break; 6196fcaebacSDaeho Jeong vm_unmap_aliases(); 6206fcaebacSDaeho Jeong } 6216fcaebacSDaeho Jeong return buf; 6226fcaebacSDaeho Jeong } 6236fcaebacSDaeho Jeong 6244c8ff709SChao Yu static int f2fs_compress_pages(struct compress_ctx *cc) 6254c8ff709SChao Yu { 6264c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(cc->inode); 6274c8ff709SChao Yu const struct f2fs_compress_ops *cops = 6284c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 62931083031SChao Yu unsigned int max_len, new_nr_cpages; 630b28f047bSChao Yu u32 chksum = 0; 6314c8ff709SChao Yu int i, ret; 6324c8ff709SChao Yu 6334c8ff709SChao Yu trace_f2fs_compress_pages_start(cc->inode, cc->cluster_idx, 6344c8ff709SChao Yu cc->cluster_size, fi->i_compress_algorithm); 6354c8ff709SChao Yu 63623b1faaaSChao Yu if (cops->init_compress_ctx) { 6374c8ff709SChao Yu ret = cops->init_compress_ctx(cc); 6384c8ff709SChao Yu if (ret) 6394c8ff709SChao Yu goto out; 64023b1faaaSChao Yu } 6414c8ff709SChao Yu 6424c8ff709SChao Yu max_len = COMPRESS_HEADER_SIZE + cc->clen; 6434c8ff709SChao Yu cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE); 6443271d7ebSFengnan Chang cc->valid_nr_cpages = cc->nr_cpages; 6454c8ff709SChao Yu 64631083031SChao Yu cc->cpages = page_array_alloc(cc->inode, cc->nr_cpages); 6474c8ff709SChao Yu if (!cc->cpages) { 6484c8ff709SChao Yu ret = -ENOMEM; 6494c8ff709SChao Yu goto destroy_compress_ctx; 6504c8ff709SChao Yu } 6514c8ff709SChao Yu 652863907a4SChao Yu for (i = 0; i < cc->nr_cpages; i++) 6535e6bbde9SChao Yu cc->cpages[i] = f2fs_compress_alloc_page(); 6544c8ff709SChao Yu 6556fcaebacSDaeho Jeong cc->rbuf = f2fs_vmap(cc->rpages, cc->cluster_size); 6564c8ff709SChao Yu if (!cc->rbuf) { 6574c8ff709SChao Yu ret = -ENOMEM; 6584c8ff709SChao Yu goto out_free_cpages; 6594c8ff709SChao Yu } 6604c8ff709SChao Yu 6616fcaebacSDaeho Jeong cc->cbuf = f2fs_vmap(cc->cpages, cc->nr_cpages); 6624c8ff709SChao Yu if (!cc->cbuf) { 6634c8ff709SChao Yu ret = -ENOMEM; 6644c8ff709SChao Yu goto out_vunmap_rbuf; 6654c8ff709SChao Yu } 6664c8ff709SChao Yu 6674c8ff709SChao Yu ret = cops->compress_pages(cc); 6684c8ff709SChao Yu if (ret) 6694c8ff709SChao Yu goto out_vunmap_cbuf; 6704c8ff709SChao Yu 6714c8ff709SChao Yu max_len = PAGE_SIZE * (cc->cluster_size - 1) - COMPRESS_HEADER_SIZE; 6724c8ff709SChao Yu 6734c8ff709SChao Yu if (cc->clen > max_len) { 6744c8ff709SChao Yu ret = -EAGAIN; 6754c8ff709SChao Yu goto out_vunmap_cbuf; 6764c8ff709SChao Yu } 6774c8ff709SChao Yu 6784c8ff709SChao Yu cc->cbuf->clen = cpu_to_le32(cc->clen); 6794c8ff709SChao Yu 680447286ebSYangtao Li if (fi->i_compress_flag & BIT(COMPRESS_CHKSUM)) 681b28f047bSChao Yu chksum = f2fs_crc32(F2FS_I_SB(cc->inode), 682b28f047bSChao Yu cc->cbuf->cdata, cc->clen); 683b28f047bSChao Yu cc->cbuf->chksum = cpu_to_le32(chksum); 684b28f047bSChao Yu 6854c8ff709SChao Yu for (i = 0; i < COMPRESS_DATA_RESERVED_SIZE; i++) 6864c8ff709SChao Yu cc->cbuf->reserved[i] = cpu_to_le32(0); 6874c8ff709SChao Yu 68831083031SChao Yu new_nr_cpages = DIV_ROUND_UP(cc->clen + COMPRESS_HEADER_SIZE, PAGE_SIZE); 68931083031SChao Yu 6907fa6d598SEric Biggers /* zero out any unused part of the last page */ 6917fa6d598SEric Biggers memset(&cc->cbuf->cdata[cc->clen], 0, 69231083031SChao Yu (new_nr_cpages * PAGE_SIZE) - 69331083031SChao Yu (cc->clen + COMPRESS_HEADER_SIZE)); 6947fa6d598SEric Biggers 6956fcaebacSDaeho Jeong vm_unmap_ram(cc->cbuf, cc->nr_cpages); 6966fcaebacSDaeho Jeong vm_unmap_ram(cc->rbuf, cc->cluster_size); 6974c8ff709SChao Yu 698ebaaec35SZhang Qilong for (i = new_nr_cpages; i < cc->nr_cpages; i++) { 6995e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 7004c8ff709SChao Yu cc->cpages[i] = NULL; 7014c8ff709SChao Yu } 7024c8ff709SChao Yu 70323b1faaaSChao Yu if (cops->destroy_compress_ctx) 70409ff4801SChao Yu cops->destroy_compress_ctx(cc); 70509ff4801SChao Yu 7063271d7ebSFengnan Chang cc->valid_nr_cpages = new_nr_cpages; 7074c8ff709SChao Yu 7084c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 7094c8ff709SChao Yu cc->clen, ret); 7104c8ff709SChao Yu return 0; 7114c8ff709SChao Yu 7124c8ff709SChao Yu out_vunmap_cbuf: 7136fcaebacSDaeho Jeong vm_unmap_ram(cc->cbuf, cc->nr_cpages); 7144c8ff709SChao Yu out_vunmap_rbuf: 7156fcaebacSDaeho Jeong vm_unmap_ram(cc->rbuf, cc->cluster_size); 7164c8ff709SChao Yu out_free_cpages: 7174c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 7184c8ff709SChao Yu if (cc->cpages[i]) 7195e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 7204c8ff709SChao Yu } 72131083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 7224c8ff709SChao Yu cc->cpages = NULL; 7234c8ff709SChao Yu destroy_compress_ctx: 72423b1faaaSChao Yu if (cops->destroy_compress_ctx) 7254c8ff709SChao Yu cops->destroy_compress_ctx(cc); 7264c8ff709SChao Yu out: 7274c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 7284c8ff709SChao Yu cc->clen, ret); 7294c8ff709SChao Yu return ret; 7304c8ff709SChao Yu } 7314c8ff709SChao Yu 732bff139b4SDaeho Jeong static int f2fs_prepare_decomp_mem(struct decompress_io_ctx *dic, 733bff139b4SDaeho Jeong bool pre_alloc); 734bff139b4SDaeho Jeong static void f2fs_release_decomp_mem(struct decompress_io_ctx *dic, 735bff139b4SDaeho Jeong bool bypass_destroy_callback, bool pre_alloc); 736bff139b4SDaeho Jeong 737bff139b4SDaeho Jeong void f2fs_decompress_cluster(struct decompress_io_ctx *dic, bool in_task) 7384c8ff709SChao Yu { 7394c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode); 7404c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(dic->inode); 7414c8ff709SChao Yu const struct f2fs_compress_ops *cops = 7424c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 743bff139b4SDaeho Jeong bool bypass_callback = false; 7444c8ff709SChao Yu int ret; 7454c8ff709SChao Yu 7464c8ff709SChao Yu trace_f2fs_decompress_pages_start(dic->inode, dic->cluster_idx, 7474c8ff709SChao Yu dic->cluster_size, fi->i_compress_algorithm); 7484c8ff709SChao Yu 7494c8ff709SChao Yu if (dic->failed) { 7504c8ff709SChao Yu ret = -EIO; 7517f59b277SEric Biggers goto out_end_io; 7524c8ff709SChao Yu } 7534c8ff709SChao Yu 754bff139b4SDaeho Jeong ret = f2fs_prepare_decomp_mem(dic, false); 755bff139b4SDaeho Jeong if (ret) { 756bff139b4SDaeho Jeong bypass_callback = true; 757bff139b4SDaeho Jeong goto out_release; 7584c8ff709SChao Yu } 7594c8ff709SChao Yu 7604c8ff709SChao Yu dic->clen = le32_to_cpu(dic->cbuf->clen); 7614c8ff709SChao Yu dic->rlen = PAGE_SIZE << dic->log_cluster_size; 7624c8ff709SChao Yu 7634c8ff709SChao Yu if (dic->clen > PAGE_SIZE * dic->nr_cpages - COMPRESS_HEADER_SIZE) { 7644c8ff709SChao Yu ret = -EFSCORRUPTED; 7651aa161e4SJaegeuk Kim 7661aa161e4SJaegeuk Kim /* Avoid f2fs_commit_super in irq context */ 767633c8b94SJaegeuk Kim if (!in_task) 768901c12d1SChao Yu f2fs_handle_error_async(sbi, ERROR_FAIL_DECOMPRESSION); 7691aa161e4SJaegeuk Kim else 77095fa90c9SChao Yu f2fs_handle_error(sbi, ERROR_FAIL_DECOMPRESSION); 771bff139b4SDaeho Jeong goto out_release; 7724c8ff709SChao Yu } 7734c8ff709SChao Yu 7744c8ff709SChao Yu ret = cops->decompress_pages(dic); 7754c8ff709SChao Yu 776447286ebSYangtao Li if (!ret && (fi->i_compress_flag & BIT(COMPRESS_CHKSUM))) { 777b28f047bSChao Yu u32 provided = le32_to_cpu(dic->cbuf->chksum); 778b28f047bSChao Yu u32 calculated = f2fs_crc32(sbi, dic->cbuf->cdata, dic->clen); 779b28f047bSChao Yu 780b28f047bSChao Yu if (provided != calculated) { 781b28f047bSChao Yu if (!is_inode_flag_set(dic->inode, FI_COMPRESS_CORRUPT)) { 782b28f047bSChao Yu set_inode_flag(dic->inode, FI_COMPRESS_CORRUPT); 783b28f047bSChao Yu printk_ratelimited( 784b28f047bSChao Yu "%sF2FS-fs (%s): checksum invalid, nid = %lu, %x vs %x", 785b28f047bSChao Yu KERN_INFO, sbi->sb->s_id, dic->inode->i_ino, 786b28f047bSChao Yu provided, calculated); 787b28f047bSChao Yu } 788b28f047bSChao Yu set_sbi_flag(sbi, SBI_NEED_FSCK); 789b28f047bSChao Yu } 790b28f047bSChao Yu } 791b28f047bSChao Yu 792bff139b4SDaeho Jeong out_release: 793bff139b4SDaeho Jeong f2fs_release_decomp_mem(dic, bypass_callback, false); 794bff139b4SDaeho Jeong 7957f59b277SEric Biggers out_end_io: 7964c8ff709SChao Yu trace_f2fs_decompress_pages_end(dic->inode, dic->cluster_idx, 7974c8ff709SChao Yu dic->clen, ret); 798bff139b4SDaeho Jeong f2fs_decompress_end_io(dic, ret, in_task); 7997f59b277SEric Biggers } 8007f59b277SEric Biggers 8017f59b277SEric Biggers /* 8027f59b277SEric Biggers * This is called when a page of a compressed cluster has been read from disk 8037f59b277SEric Biggers * (or failed to be read from disk). It checks whether this page was the last 8047f59b277SEric Biggers * page being waited on in the cluster, and if so, it decompresses the cluster 8057f59b277SEric Biggers * (or in the case of a failure, cleans up without actually decompressing). 8067f59b277SEric Biggers */ 8076ce19affSChao Yu void f2fs_end_read_compressed_page(struct page *page, bool failed, 808bff139b4SDaeho Jeong block_t blkaddr, bool in_task) 8097f59b277SEric Biggers { 8107f59b277SEric Biggers struct decompress_io_ctx *dic = 8117f59b277SEric Biggers (struct decompress_io_ctx *)page_private(page); 8127f59b277SEric Biggers struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode); 8137f59b277SEric Biggers 8147f59b277SEric Biggers dec_page_count(sbi, F2FS_RD_DATA); 8157f59b277SEric Biggers 8167f59b277SEric Biggers if (failed) 8177f59b277SEric Biggers WRITE_ONCE(dic->failed, true); 818bff139b4SDaeho Jeong else if (blkaddr && in_task) 8196ce19affSChao Yu f2fs_cache_compressed_page(sbi, page, 8206ce19affSChao Yu dic->inode->i_ino, blkaddr); 8217f59b277SEric Biggers 8227f59b277SEric Biggers if (atomic_dec_and_test(&dic->remaining_pages)) 823bff139b4SDaeho Jeong f2fs_decompress_cluster(dic, in_task); 8244c8ff709SChao Yu } 8254c8ff709SChao Yu 8264c8ff709SChao Yu static bool is_page_in_cluster(struct compress_ctx *cc, pgoff_t index) 8274c8ff709SChao Yu { 8284c8ff709SChao Yu if (cc->cluster_idx == NULL_CLUSTER) 8294c8ff709SChao Yu return true; 8304c8ff709SChao Yu return cc->cluster_idx == cluster_idx(cc, index); 8314c8ff709SChao Yu } 8324c8ff709SChao Yu 8334c8ff709SChao Yu bool f2fs_cluster_is_empty(struct compress_ctx *cc) 8344c8ff709SChao Yu { 8354c8ff709SChao Yu return cc->nr_rpages == 0; 8364c8ff709SChao Yu } 8374c8ff709SChao Yu 8384c8ff709SChao Yu static bool f2fs_cluster_is_full(struct compress_ctx *cc) 8394c8ff709SChao Yu { 8404c8ff709SChao Yu return cc->cluster_size == cc->nr_rpages; 8414c8ff709SChao Yu } 8424c8ff709SChao Yu 8434c8ff709SChao Yu bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index) 8444c8ff709SChao Yu { 8454c8ff709SChao Yu if (f2fs_cluster_is_empty(cc)) 8464c8ff709SChao Yu return true; 8474c8ff709SChao Yu return is_page_in_cluster(cc, index); 8484c8ff709SChao Yu } 8494c8ff709SChao Yu 85001fc4b9aSFengnan Chang bool f2fs_all_cluster_page_ready(struct compress_ctx *cc, struct page **pages, 8514f8219f8SFengnan Chang int index, int nr_pages, bool uptodate) 852b368cc5eSFengnan Chang { 85301fc4b9aSFengnan Chang unsigned long pgidx = pages[index]->index; 8544f8219f8SFengnan Chang int i = uptodate ? 0 : 1; 8554f8219f8SFengnan Chang 8564f8219f8SFengnan Chang /* 8574f8219f8SFengnan Chang * when uptodate set to true, try to check all pages in cluster is 8584f8219f8SFengnan Chang * uptodate or not. 8594f8219f8SFengnan Chang */ 8604f8219f8SFengnan Chang if (uptodate && (pgidx % cc->cluster_size)) 8614f8219f8SFengnan Chang return false; 862b368cc5eSFengnan Chang 863b368cc5eSFengnan Chang if (nr_pages - index < cc->cluster_size) 864b368cc5eSFengnan Chang return false; 865b368cc5eSFengnan Chang 8664f8219f8SFengnan Chang for (; i < cc->cluster_size; i++) { 86701fc4b9aSFengnan Chang if (pages[index + i]->index != pgidx + i) 868b368cc5eSFengnan Chang return false; 86901fc4b9aSFengnan Chang if (uptodate && !PageUptodate(pages[index + i])) 870b368cc5eSFengnan Chang return false; 871b368cc5eSFengnan Chang } 872b368cc5eSFengnan Chang 873b368cc5eSFengnan Chang return true; 874b368cc5eSFengnan Chang } 875b368cc5eSFengnan Chang 8765db479f0SChao Yu static bool cluster_has_invalid_data(struct compress_ctx *cc) 8774c8ff709SChao Yu { 8784c8ff709SChao Yu loff_t i_size = i_size_read(cc->inode); 8794c8ff709SChao Yu unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE); 8804c8ff709SChao Yu int i; 8814c8ff709SChao Yu 8824c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 8834c8ff709SChao Yu struct page *page = cc->rpages[i]; 8844c8ff709SChao Yu 8858af85f71SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), !page); 8864c8ff709SChao Yu 8874c8ff709SChao Yu /* beyond EOF */ 8884c8ff709SChao Yu if (page->index >= nr_pages) 8894c8ff709SChao Yu return true; 8904c8ff709SChao Yu } 8915db479f0SChao Yu return false; 8925db479f0SChao Yu } 8934c8ff709SChao Yu 894bbe1da7eSChao Yu bool f2fs_sanity_check_cluster(struct dnode_of_data *dn) 895bbe1da7eSChao Yu { 8962aaea533SChao Yu #ifdef CONFIG_F2FS_CHECK_FS 897bbe1da7eSChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode); 898bbe1da7eSChao Yu unsigned int cluster_size = F2FS_I(dn->inode)->i_cluster_size; 899bbe1da7eSChao Yu int cluster_end = 0; 9002aaea533SChao Yu unsigned int count; 901bbe1da7eSChao Yu int i; 902bbe1da7eSChao Yu char *reason = ""; 903bbe1da7eSChao Yu 9042aaea533SChao Yu if (dn->data_blkaddr != COMPRESS_ADDR) 905bbe1da7eSChao Yu return false; 906bbe1da7eSChao Yu 907bbe1da7eSChao Yu /* [..., COMPR_ADDR, ...] */ 908bbe1da7eSChao Yu if (dn->ofs_in_node % cluster_size) { 909bbe1da7eSChao Yu reason = "[*|C|*|*]"; 910bbe1da7eSChao Yu goto out; 911bbe1da7eSChao Yu } 912bbe1da7eSChao Yu 9132aaea533SChao Yu for (i = 1, count = 1; i < cluster_size; i++, count++) { 914bbe1da7eSChao Yu block_t blkaddr = data_blkaddr(dn->inode, dn->node_page, 915bbe1da7eSChao Yu dn->ofs_in_node + i); 916bbe1da7eSChao Yu 917bbe1da7eSChao Yu /* [COMPR_ADDR, ..., COMPR_ADDR] */ 918bbe1da7eSChao Yu if (blkaddr == COMPRESS_ADDR) { 919bbe1da7eSChao Yu reason = "[C|*|C|*]"; 920bbe1da7eSChao Yu goto out; 921bbe1da7eSChao Yu } 922bbe1da7eSChao Yu if (!__is_valid_data_blkaddr(blkaddr)) { 923bbe1da7eSChao Yu if (!cluster_end) 924bbe1da7eSChao Yu cluster_end = i; 925bbe1da7eSChao Yu continue; 926bbe1da7eSChao Yu } 927bbe1da7eSChao Yu /* [COMPR_ADDR, NULL_ADDR or NEW_ADDR, valid_blkaddr] */ 928bbe1da7eSChao Yu if (cluster_end) { 929bbe1da7eSChao Yu reason = "[C|N|N|V]"; 930bbe1da7eSChao Yu goto out; 931bbe1da7eSChao Yu } 932bbe1da7eSChao Yu } 9332aaea533SChao Yu 9342aaea533SChao Yu f2fs_bug_on(F2FS_I_SB(dn->inode), count != cluster_size && 9352aaea533SChao Yu !is_inode_flag_set(dn->inode, FI_COMPRESS_RELEASED)); 9362aaea533SChao Yu 937bbe1da7eSChao Yu return false; 938bbe1da7eSChao Yu out: 939bbe1da7eSChao Yu f2fs_warn(sbi, "access invalid cluster, ino:%lu, nid:%u, ofs_in_node:%u, reason:%s", 940bbe1da7eSChao Yu dn->inode->i_ino, dn->nid, dn->ofs_in_node, reason); 941bbe1da7eSChao Yu set_sbi_flag(sbi, SBI_NEED_FSCK); 942bbe1da7eSChao Yu return true; 9432aaea533SChao Yu #else 9442aaea533SChao Yu return false; 9452aaea533SChao Yu #endif 9462aaea533SChao Yu } 9472aaea533SChao Yu 9482aaea533SChao Yu static int __f2fs_get_cluster_blocks(struct inode *inode, 9492aaea533SChao Yu struct dnode_of_data *dn) 9502aaea533SChao Yu { 9512aaea533SChao Yu unsigned int cluster_size = F2FS_I(inode)->i_cluster_size; 9522aaea533SChao Yu int count, i; 9532aaea533SChao Yu 9542aaea533SChao Yu for (i = 1, count = 1; i < cluster_size; i++) { 9552aaea533SChao Yu block_t blkaddr = data_blkaddr(dn->inode, dn->node_page, 9562aaea533SChao Yu dn->ofs_in_node + i); 9572aaea533SChao Yu 9582aaea533SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 9592aaea533SChao Yu count++; 9602aaea533SChao Yu } 9612aaea533SChao Yu 9622aaea533SChao Yu return count; 963bbe1da7eSChao Yu } 964bbe1da7eSChao Yu 96591f0fb69SChao Yu static int __f2fs_cluster_blocks(struct inode *inode, 9662aaea533SChao Yu unsigned int cluster_idx, bool compr_blks) 9674c8ff709SChao Yu { 9684c8ff709SChao Yu struct dnode_of_data dn; 96991f0fb69SChao Yu unsigned int start_idx = cluster_idx << 97091f0fb69SChao Yu F2FS_I(inode)->i_log_cluster_size; 9714c8ff709SChao Yu int ret; 9724c8ff709SChao Yu 97391f0fb69SChao Yu set_new_dnode(&dn, inode, NULL, NULL, 0); 97491f0fb69SChao Yu ret = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE); 9754c8ff709SChao Yu if (ret) { 9764c8ff709SChao Yu if (ret == -ENOENT) 9774c8ff709SChao Yu ret = 0; 9784c8ff709SChao Yu goto fail; 9794c8ff709SChao Yu } 9804c8ff709SChao Yu 981bbe1da7eSChao Yu if (f2fs_sanity_check_cluster(&dn)) { 982bbe1da7eSChao Yu ret = -EFSCORRUPTED; 983bbe1da7eSChao Yu goto fail; 984bbe1da7eSChao Yu } 985bbe1da7eSChao Yu 9864c8ff709SChao Yu if (dn.data_blkaddr == COMPRESS_ADDR) { 9872aaea533SChao Yu if (compr_blks) 9882aaea533SChao Yu ret = __f2fs_get_cluster_blocks(inode, &dn); 9892aaea533SChao Yu else 9904c8ff709SChao Yu ret = 1; 9911a67cbe1SChao Yu } 9924c8ff709SChao Yu fail: 9934c8ff709SChao Yu f2fs_put_dnode(&dn); 9944c8ff709SChao Yu return ret; 9954c8ff709SChao Yu } 9964c8ff709SChao Yu 9971a67cbe1SChao Yu /* return # of compressed blocks in compressed cluster */ 9981a67cbe1SChao Yu static int f2fs_compressed_blocks(struct compress_ctx *cc) 9991a67cbe1SChao Yu { 100091f0fb69SChao Yu return __f2fs_cluster_blocks(cc->inode, cc->cluster_idx, true); 10011a67cbe1SChao Yu } 10021a67cbe1SChao Yu 10032aaea533SChao Yu /* return whether cluster is compressed one or not */ 10044c8ff709SChao Yu int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index) 10054c8ff709SChao Yu { 100691f0fb69SChao Yu return __f2fs_cluster_blocks(inode, 100791f0fb69SChao Yu index >> F2FS_I(inode)->i_log_cluster_size, 100891f0fb69SChao Yu false); 10094c8ff709SChao Yu } 10104c8ff709SChao Yu 10114c8ff709SChao Yu static bool cluster_may_compress(struct compress_ctx *cc) 10124c8ff709SChao Yu { 1013602a16d5SDaeho Jeong if (!f2fs_need_compress_data(cc->inode)) 10144c8ff709SChao Yu return false; 10154c8ff709SChao Yu if (f2fs_is_atomic_file(cc->inode)) 10164c8ff709SChao Yu return false; 10174c8ff709SChao Yu if (!f2fs_cluster_is_full(cc)) 10184c8ff709SChao Yu return false; 1019dc35d73aSChao Yu if (unlikely(f2fs_cp_error(F2FS_I_SB(cc->inode)))) 1020dc35d73aSChao Yu return false; 10215db479f0SChao Yu return !cluster_has_invalid_data(cc); 10224c8ff709SChao Yu } 10234c8ff709SChao Yu 10244c8ff709SChao Yu static void set_cluster_writeback(struct compress_ctx *cc) 10254c8ff709SChao Yu { 10264c8ff709SChao Yu int i; 10274c8ff709SChao Yu 10284c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 10294c8ff709SChao Yu if (cc->rpages[i]) 10304c8ff709SChao Yu set_page_writeback(cc->rpages[i]); 10314c8ff709SChao Yu } 10324c8ff709SChao Yu } 10334c8ff709SChao Yu 10344c8ff709SChao Yu static void set_cluster_dirty(struct compress_ctx *cc) 10354c8ff709SChao Yu { 10364c8ff709SChao Yu int i; 10374c8ff709SChao Yu 10384c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 10394961acddSChao Yu if (cc->rpages[i]) { 10404c8ff709SChao Yu set_page_dirty(cc->rpages[i]); 10414961acddSChao Yu set_page_private_gcing(cc->rpages[i]); 10424961acddSChao Yu } 10434c8ff709SChao Yu } 10444c8ff709SChao Yu 10454c8ff709SChao Yu static int prepare_compress_overwrite(struct compress_ctx *cc, 10464c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 10474c8ff709SChao Yu { 10484c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 10494c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 10504c8ff709SChao Yu struct page *page; 10514c8ff709SChao Yu sector_t last_block_in_bio; 1052ffc143dbSMatthew Wilcox (Oracle) fgf_t fgp_flag = FGP_LOCK | FGP_WRITE | FGP_CREAT; 10534c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 10544c8ff709SChao Yu int i, ret; 10554c8ff709SChao Yu 10564c8ff709SChao Yu retry: 105791f0fb69SChao Yu ret = f2fs_is_compressed_cluster(cc->inode, start_idx); 10584c8ff709SChao Yu if (ret <= 0) 10594c8ff709SChao Yu return ret; 10604c8ff709SChao Yu 10614c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 10624c8ff709SChao Yu if (ret) 10634c8ff709SChao Yu return ret; 10644c8ff709SChao Yu 10654c8ff709SChao Yu /* keep page reference to avoid page reclaim */ 10664c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 10674c8ff709SChao Yu page = f2fs_pagecache_get_page(mapping, start_idx + i, 10684c8ff709SChao Yu fgp_flag, GFP_NOFS); 10694c8ff709SChao Yu if (!page) { 10704c8ff709SChao Yu ret = -ENOMEM; 10714c8ff709SChao Yu goto unlock_pages; 10724c8ff709SChao Yu } 10734c8ff709SChao Yu 10744c8ff709SChao Yu if (PageUptodate(page)) 1075a949dc5fSChao Yu f2fs_put_page(page, 1); 10764c8ff709SChao Yu else 10774c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 10784c8ff709SChao Yu } 10794c8ff709SChao Yu 10804c8ff709SChao Yu if (!f2fs_cluster_is_empty(cc)) { 10814c8ff709SChao Yu struct bio *bio = NULL; 10824c8ff709SChao Yu 10834c8ff709SChao Yu ret = f2fs_read_multi_pages(cc, &bio, cc->cluster_size, 10840683728aSChao Yu &last_block_in_bio, false, true); 1085a949dc5fSChao Yu f2fs_put_rpages(cc); 10868bfbfb0dSChao Yu f2fs_destroy_compress_ctx(cc, true); 10874c8ff709SChao Yu if (ret) 1088a949dc5fSChao Yu goto out; 10894c8ff709SChao Yu if (bio) 1090bc29835aSChristoph Hellwig f2fs_submit_read_bio(sbi, bio, DATA); 10914c8ff709SChao Yu 10924c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 10934c8ff709SChao Yu if (ret) 1094a949dc5fSChao Yu goto out; 10954c8ff709SChao Yu } 10964c8ff709SChao Yu 10974c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 10984c8ff709SChao Yu f2fs_bug_on(sbi, cc->rpages[i]); 10994c8ff709SChao Yu 11004c8ff709SChao Yu page = find_lock_page(mapping, start_idx + i); 1101a949dc5fSChao Yu if (!page) { 1102a949dc5fSChao Yu /* page can be truncated */ 1103a949dc5fSChao Yu goto release_and_retry; 1104a949dc5fSChao Yu } 11054c8ff709SChao Yu 11064c8ff709SChao Yu f2fs_wait_on_page_writeback(page, DATA, true, true); 11074c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 11084c8ff709SChao Yu 11094c8ff709SChao Yu if (!PageUptodate(page)) { 1110a949dc5fSChao Yu release_and_retry: 1111a949dc5fSChao Yu f2fs_put_rpages(cc); 11124c8ff709SChao Yu f2fs_unlock_rpages(cc, i + 1); 11138bfbfb0dSChao Yu f2fs_destroy_compress_ctx(cc, true); 11144c8ff709SChao Yu goto retry; 11154c8ff709SChao Yu } 11164c8ff709SChao Yu } 11174c8ff709SChao Yu 11184c8ff709SChao Yu if (likely(!ret)) { 11194c8ff709SChao Yu *fsdata = cc->rpages; 11204c8ff709SChao Yu *pagep = cc->rpages[offset_in_cluster(cc, index)]; 11214c8ff709SChao Yu return cc->cluster_size; 11224c8ff709SChao Yu } 11234c8ff709SChao Yu 11244c8ff709SChao Yu unlock_pages: 1125a949dc5fSChao Yu f2fs_put_rpages(cc); 11264c8ff709SChao Yu f2fs_unlock_rpages(cc, i); 11278bfbfb0dSChao Yu f2fs_destroy_compress_ctx(cc, true); 1128a949dc5fSChao Yu out: 11294c8ff709SChao Yu return ret; 11304c8ff709SChao Yu } 11314c8ff709SChao Yu 11324c8ff709SChao Yu int f2fs_prepare_compress_overwrite(struct inode *inode, 11334c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 11344c8ff709SChao Yu { 11354c8ff709SChao Yu struct compress_ctx cc = { 11364c8ff709SChao Yu .inode = inode, 11374c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 11384c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 11394c8ff709SChao Yu .cluster_idx = index >> F2FS_I(inode)->i_log_cluster_size, 11404c8ff709SChao Yu .rpages = NULL, 11414c8ff709SChao Yu .nr_rpages = 0, 11424c8ff709SChao Yu }; 11434c8ff709SChao Yu 11444c8ff709SChao Yu return prepare_compress_overwrite(&cc, pagep, index, fsdata); 11454c8ff709SChao Yu } 11464c8ff709SChao Yu 11474c8ff709SChao Yu bool f2fs_compress_write_end(struct inode *inode, void *fsdata, 11484c8ff709SChao Yu pgoff_t index, unsigned copied) 11494c8ff709SChao Yu 11504c8ff709SChao Yu { 11514c8ff709SChao Yu struct compress_ctx cc = { 115231083031SChao Yu .inode = inode, 11534c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 11544c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 11554c8ff709SChao Yu .rpages = fsdata, 11564c8ff709SChao Yu }; 11574c8ff709SChao Yu bool first_index = (index == cc.rpages[0]->index); 11584c8ff709SChao Yu 11594c8ff709SChao Yu if (copied) 11604c8ff709SChao Yu set_cluster_dirty(&cc); 11614c8ff709SChao Yu 11624c8ff709SChao Yu f2fs_put_rpages_wbc(&cc, NULL, false, 1); 11638bfbfb0dSChao Yu f2fs_destroy_compress_ctx(&cc, false); 11644c8ff709SChao Yu 11654c8ff709SChao Yu return first_index; 11664c8ff709SChao Yu } 11674c8ff709SChao Yu 11683265d3dbSChao Yu int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock) 11693265d3dbSChao Yu { 11703265d3dbSChao Yu void *fsdata = NULL; 11713265d3dbSChao Yu struct page *pagep; 11723265d3dbSChao Yu int log_cluster_size = F2FS_I(inode)->i_log_cluster_size; 11733265d3dbSChao Yu pgoff_t start_idx = from >> (PAGE_SHIFT + log_cluster_size) << 11743265d3dbSChao Yu log_cluster_size; 11753265d3dbSChao Yu int err; 11763265d3dbSChao Yu 11773265d3dbSChao Yu err = f2fs_is_compressed_cluster(inode, start_idx); 11783265d3dbSChao Yu if (err < 0) 11793265d3dbSChao Yu return err; 11803265d3dbSChao Yu 11813265d3dbSChao Yu /* truncate normal cluster */ 11823265d3dbSChao Yu if (!err) 11833265d3dbSChao Yu return f2fs_do_truncate_blocks(inode, from, lock); 11843265d3dbSChao Yu 11853265d3dbSChao Yu /* truncate compressed cluster */ 11863265d3dbSChao Yu err = f2fs_prepare_compress_overwrite(inode, &pagep, 11873265d3dbSChao Yu start_idx, &fsdata); 11883265d3dbSChao Yu 11893265d3dbSChao Yu /* should not be a normal cluster */ 11903265d3dbSChao Yu f2fs_bug_on(F2FS_I_SB(inode), err == 0); 11913265d3dbSChao Yu 11923265d3dbSChao Yu if (err <= 0) 11933265d3dbSChao Yu return err; 11943265d3dbSChao Yu 11953265d3dbSChao Yu if (err > 0) { 11963265d3dbSChao Yu struct page **rpages = fsdata; 11973265d3dbSChao Yu int cluster_size = F2FS_I(inode)->i_cluster_size; 11983265d3dbSChao Yu int i; 11993265d3dbSChao Yu 12003265d3dbSChao Yu for (i = cluster_size - 1; i >= 0; i--) { 12013265d3dbSChao Yu loff_t start = rpages[i]->index << PAGE_SHIFT; 12023265d3dbSChao Yu 12033265d3dbSChao Yu if (from <= start) { 12043265d3dbSChao Yu zero_user_segment(rpages[i], 0, PAGE_SIZE); 12053265d3dbSChao Yu } else { 12063265d3dbSChao Yu zero_user_segment(rpages[i], from - start, 12073265d3dbSChao Yu PAGE_SIZE); 12083265d3dbSChao Yu break; 12093265d3dbSChao Yu } 12103265d3dbSChao Yu } 12113265d3dbSChao Yu 12123265d3dbSChao Yu f2fs_compress_write_end(inode, fsdata, start_idx, true); 12133265d3dbSChao Yu } 12143265d3dbSChao Yu return 0; 12153265d3dbSChao Yu } 12163265d3dbSChao Yu 12174c8ff709SChao Yu static int f2fs_write_compressed_pages(struct compress_ctx *cc, 12184c8ff709SChao Yu int *submitted, 12194c8ff709SChao Yu struct writeback_control *wbc, 12204c8ff709SChao Yu enum iostat_type io_type) 12214c8ff709SChao Yu { 12224c8ff709SChao Yu struct inode *inode = cc->inode; 12234c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 12244c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(inode); 12254c8ff709SChao Yu struct f2fs_io_info fio = { 12264c8ff709SChao Yu .sbi = sbi, 12274c8ff709SChao Yu .ino = cc->inode->i_ino, 12284c8ff709SChao Yu .type = DATA, 12294c8ff709SChao Yu .op = REQ_OP_WRITE, 12304c8ff709SChao Yu .op_flags = wbc_to_write_flags(wbc), 12314c8ff709SChao Yu .old_blkaddr = NEW_ADDR, 12324c8ff709SChao Yu .page = NULL, 12334c8ff709SChao Yu .encrypted_page = NULL, 12344c8ff709SChao Yu .compressed_page = NULL, 12352eae077eSChao Yu .submitted = 0, 12364c8ff709SChao Yu .io_type = io_type, 12374c8ff709SChao Yu .io_wbc = wbc, 12382eae077eSChao Yu .encrypted = fscrypt_inode_uses_fs_layer_crypto(cc->inode) ? 12392eae077eSChao Yu 1 : 0, 12404c8ff709SChao Yu }; 12414c8ff709SChao Yu struct dnode_of_data dn; 12424c8ff709SChao Yu struct node_info ni; 12434c8ff709SChao Yu struct compress_io_ctx *cic; 12444c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 12454c8ff709SChao Yu unsigned int last_index = cc->cluster_size - 1; 12464c8ff709SChao Yu loff_t psize; 12474c8ff709SChao Yu int i, err; 1248f082c6b2SChao Yu bool quota_inode = IS_NOQUOTA(inode); 12494c8ff709SChao Yu 1250146949deSJinyoung CHOI /* we should bypass data pages to proceed the kworker jobs */ 1251ee68d271SChao Yu if (unlikely(f2fs_cp_error(sbi))) { 1252ee68d271SChao Yu mapping_set_error(cc->rpages[0]->mapping, -EIO); 1253ee68d271SChao Yu goto out_free; 1254ee68d271SChao Yu } 1255ee68d271SChao Yu 1256f082c6b2SChao Yu if (quota_inode) { 125779963d96SChao Yu /* 125879963d96SChao Yu * We need to wait for node_write to avoid block allocation during 125979963d96SChao Yu * checkpoint. This can only happen to quota writes which can cause 126079963d96SChao Yu * the below discard race condition. 126179963d96SChao Yu */ 1262e4544b63STim Murray f2fs_down_read(&sbi->node_write); 126379963d96SChao Yu } else if (!f2fs_trylock_op(sbi)) { 126431083031SChao Yu goto out_free; 126579963d96SChao Yu } 12664c8ff709SChao Yu 1267df77fbd8SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 12684c8ff709SChao Yu 12694c8ff709SChao Yu err = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE); 12704c8ff709SChao Yu if (err) 12714c8ff709SChao Yu goto out_unlock_op; 12724c8ff709SChao Yu 12734c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1274a2ced1ceSChao Yu if (data_blkaddr(dn.inode, dn.node_page, 12754c8ff709SChao Yu dn.ofs_in_node + i) == NULL_ADDR) 12764c8ff709SChao Yu goto out_put_dnode; 12774c8ff709SChao Yu } 12784c8ff709SChao Yu 12794c8ff709SChao Yu psize = (loff_t)(cc->rpages[last_index]->index + 1) << PAGE_SHIFT; 12804c8ff709SChao Yu 1281a9419b63SJaegeuk Kim err = f2fs_get_node_info(fio.sbi, dn.nid, &ni, false); 12824c8ff709SChao Yu if (err) 12834c8ff709SChao Yu goto out_put_dnode; 12844c8ff709SChao Yu 12854c8ff709SChao Yu fio.version = ni.version; 12864c8ff709SChao Yu 128732410577SChao Yu cic = f2fs_kmem_cache_alloc(cic_entry_slab, GFP_F2FS_ZERO, false, sbi); 12884c8ff709SChao Yu if (!cic) 12894c8ff709SChao Yu goto out_put_dnode; 12904c8ff709SChao Yu 12914c8ff709SChao Yu cic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 12924c8ff709SChao Yu cic->inode = inode; 12933271d7ebSFengnan Chang atomic_set(&cic->pending_pages, cc->valid_nr_cpages); 129431083031SChao Yu cic->rpages = page_array_alloc(cc->inode, cc->cluster_size); 12954c8ff709SChao Yu if (!cic->rpages) 12964c8ff709SChao Yu goto out_put_cic; 12974c8ff709SChao Yu 12984c8ff709SChao Yu cic->nr_rpages = cc->cluster_size; 12994c8ff709SChao Yu 13003271d7ebSFengnan Chang for (i = 0; i < cc->valid_nr_cpages; i++) { 13014c8ff709SChao Yu f2fs_set_compressed_page(cc->cpages[i], inode, 1302887347a0SChao Yu cc->rpages[i + 1]->index, cic); 13034c8ff709SChao Yu fio.compressed_page = cc->cpages[i]; 1304f567adb0SChao Yu 1305f567adb0SChao Yu fio.old_blkaddr = data_blkaddr(dn.inode, dn.node_page, 1306f567adb0SChao Yu dn.ofs_in_node + i + 1); 1307f567adb0SChao Yu 1308f567adb0SChao Yu /* wait for GCed page writeback via META_MAPPING */ 1309f567adb0SChao Yu f2fs_wait_on_block_writeback(inode, fio.old_blkaddr); 1310f567adb0SChao Yu 13114c8ff709SChao Yu if (fio.encrypted) { 13124c8ff709SChao Yu fio.page = cc->rpages[i + 1]; 13134c8ff709SChao Yu err = f2fs_encrypt_one_page(&fio); 13144c8ff709SChao Yu if (err) 13154c8ff709SChao Yu goto out_destroy_crypt; 13164c8ff709SChao Yu cc->cpages[i] = fio.encrypted_page; 13174c8ff709SChao Yu } 13184c8ff709SChao Yu } 13194c8ff709SChao Yu 13204c8ff709SChao Yu set_cluster_writeback(cc); 13214c8ff709SChao Yu 13224c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 13234c8ff709SChao Yu cic->rpages[i] = cc->rpages[i]; 13244c8ff709SChao Yu 13254c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++, dn.ofs_in_node++) { 13264c8ff709SChao Yu block_t blkaddr; 13274c8ff709SChao Yu 1328a2ced1ceSChao Yu blkaddr = f2fs_data_blkaddr(&dn); 132995978caaSChao Yu fio.page = cc->rpages[i]; 13304c8ff709SChao Yu fio.old_blkaddr = blkaddr; 13314c8ff709SChao Yu 13324c8ff709SChao Yu /* cluster header */ 13334c8ff709SChao Yu if (i == 0) { 13344c8ff709SChao Yu if (blkaddr == COMPRESS_ADDR) 13354c8ff709SChao Yu fio.compr_blocks++; 13364c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 13374c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 13384c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR); 13394c8ff709SChao Yu goto unlock_continue; 13404c8ff709SChao Yu } 13414c8ff709SChao Yu 13424c8ff709SChao Yu if (fio.compr_blocks && __is_valid_data_blkaddr(blkaddr)) 13434c8ff709SChao Yu fio.compr_blocks++; 13444c8ff709SChao Yu 13453271d7ebSFengnan Chang if (i > cc->valid_nr_cpages) { 13464c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) { 13474c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 13484c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, NEW_ADDR); 13494c8ff709SChao Yu } 13504c8ff709SChao Yu goto unlock_continue; 13514c8ff709SChao Yu } 13524c8ff709SChao Yu 13534c8ff709SChao Yu f2fs_bug_on(fio.sbi, blkaddr == NULL_ADDR); 13544c8ff709SChao Yu 13554c8ff709SChao Yu if (fio.encrypted) 13564c8ff709SChao Yu fio.encrypted_page = cc->cpages[i - 1]; 13574c8ff709SChao Yu else 13584c8ff709SChao Yu fio.compressed_page = cc->cpages[i - 1]; 13594c8ff709SChao Yu 13604c8ff709SChao Yu cc->cpages[i - 1] = NULL; 13614c8ff709SChao Yu f2fs_outplace_write_data(&dn, &fio); 13624c8ff709SChao Yu (*submitted)++; 13634c8ff709SChao Yu unlock_continue: 13644c8ff709SChao Yu inode_dec_dirty_pages(cc->inode); 13654c8ff709SChao Yu unlock_page(fio.page); 13664c8ff709SChao Yu } 13674c8ff709SChao Yu 13684c8ff709SChao Yu if (fio.compr_blocks) 13694c8ff709SChao Yu f2fs_i_compr_blocks_update(inode, fio.compr_blocks - 1, false); 13703271d7ebSFengnan Chang f2fs_i_compr_blocks_update(inode, cc->valid_nr_cpages, true); 13713271d7ebSFengnan Chang add_compr_block_stat(inode, cc->valid_nr_cpages); 13724c8ff709SChao Yu 13734c8ff709SChao Yu set_inode_flag(cc->inode, FI_APPEND_WRITE); 13744c8ff709SChao Yu 13754c8ff709SChao Yu f2fs_put_dnode(&dn); 1376f082c6b2SChao Yu if (quota_inode) 1377e4544b63STim Murray f2fs_up_read(&sbi->node_write); 137879963d96SChao Yu else 13794c8ff709SChao Yu f2fs_unlock_op(sbi); 13804c8ff709SChao Yu 1381c10c9820SChao Yu spin_lock(&fi->i_size_lock); 13824c8ff709SChao Yu if (fi->last_disk_size < psize) 13834c8ff709SChao Yu fi->last_disk_size = psize; 1384c10c9820SChao Yu spin_unlock(&fi->i_size_lock); 13854c8ff709SChao Yu 13864c8ff709SChao Yu f2fs_put_rpages(cc); 138731083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 138831083031SChao Yu cc->cpages = NULL; 13898bfbfb0dSChao Yu f2fs_destroy_compress_ctx(cc, false); 13904c8ff709SChao Yu return 0; 13914c8ff709SChao Yu 13924c8ff709SChao Yu out_destroy_crypt: 139331083031SChao Yu page_array_free(cc->inode, cic->rpages, cc->cluster_size); 13944c8ff709SChao Yu 13954c8ff709SChao Yu for (--i; i >= 0; i--) 13964c8ff709SChao Yu fscrypt_finalize_bounce_page(&cc->cpages[i]); 13974c8ff709SChao Yu out_put_cic: 1398c68d6c88SChao Yu kmem_cache_free(cic_entry_slab, cic); 13994c8ff709SChao Yu out_put_dnode: 14004c8ff709SChao Yu f2fs_put_dnode(&dn); 14014c8ff709SChao Yu out_unlock_op: 1402f082c6b2SChao Yu if (quota_inode) 1403e4544b63STim Murray f2fs_up_read(&sbi->node_write); 140479963d96SChao Yu else 14054c8ff709SChao Yu f2fs_unlock_op(sbi); 140631083031SChao Yu out_free: 14073271d7ebSFengnan Chang for (i = 0; i < cc->valid_nr_cpages; i++) { 1408827f0284SJaegeuk Kim f2fs_compress_free_page(cc->cpages[i]); 1409827f0284SJaegeuk Kim cc->cpages[i] = NULL; 1410827f0284SJaegeuk Kim } 141131083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 141231083031SChao Yu cc->cpages = NULL; 14134c8ff709SChao Yu return -EAGAIN; 14144c8ff709SChao Yu } 14154c8ff709SChao Yu 14164c8ff709SChao Yu void f2fs_compress_write_end_io(struct bio *bio, struct page *page) 14174c8ff709SChao Yu { 14184c8ff709SChao Yu struct f2fs_sb_info *sbi = bio->bi_private; 14194c8ff709SChao Yu struct compress_io_ctx *cic = 14204c8ff709SChao Yu (struct compress_io_ctx *)page_private(page); 14218a430dd4SChao Yu enum count_type type = WB_DATA_TYPE(page, 14228a430dd4SChao Yu f2fs_is_compressed_page(page)); 14234c8ff709SChao Yu int i; 14244c8ff709SChao Yu 14254c8ff709SChao Yu if (unlikely(bio->bi_status)) 14264c8ff709SChao Yu mapping_set_error(cic->inode->i_mapping, -EIO); 14274c8ff709SChao Yu 14285e6bbde9SChao Yu f2fs_compress_free_page(page); 14294c8ff709SChao Yu 14308a430dd4SChao Yu dec_page_count(sbi, type); 14314c8ff709SChao Yu 1432e6c3948dSChao Yu if (atomic_dec_return(&cic->pending_pages)) 14334c8ff709SChao Yu return; 14344c8ff709SChao Yu 14354c8ff709SChao Yu for (i = 0; i < cic->nr_rpages; i++) { 14364c8ff709SChao Yu WARN_ON(!cic->rpages[i]); 1437b763f3beSChao Yu clear_page_private_gcing(cic->rpages[i]); 14384c8ff709SChao Yu end_page_writeback(cic->rpages[i]); 14394c8ff709SChao Yu } 14404c8ff709SChao Yu 144131083031SChao Yu page_array_free(cic->inode, cic->rpages, cic->nr_rpages); 1442c68d6c88SChao Yu kmem_cache_free(cic_entry_slab, cic); 14434c8ff709SChao Yu } 14444c8ff709SChao Yu 14454c8ff709SChao Yu static int f2fs_write_raw_pages(struct compress_ctx *cc, 1446*fd244524SChao Yu int *submitted_p, 14474c8ff709SChao Yu struct writeback_control *wbc, 14484c8ff709SChao Yu enum iostat_type io_type) 14494c8ff709SChao Yu { 14504c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 1451*fd244524SChao Yu struct f2fs_sb_info *sbi = F2FS_M_SB(mapping); 1452*fd244524SChao Yu int submitted, compr_blocks, i; 1453*fd244524SChao Yu int ret = 0; 14544c8ff709SChao Yu 14554c8ff709SChao Yu compr_blocks = f2fs_compressed_blocks(cc); 14567377e853SHyeong-Jun Kim 14577377e853SHyeong-Jun Kim for (i = 0; i < cc->cluster_size; i++) { 14587377e853SHyeong-Jun Kim if (!cc->rpages[i]) 14597377e853SHyeong-Jun Kim continue; 14607377e853SHyeong-Jun Kim 14617377e853SHyeong-Jun Kim redirty_page_for_writepage(wbc, cc->rpages[i]); 14627377e853SHyeong-Jun Kim unlock_page(cc->rpages[i]); 14634c8ff709SChao Yu } 14644c8ff709SChao Yu 14657377e853SHyeong-Jun Kim if (compr_blocks < 0) 14667377e853SHyeong-Jun Kim return compr_blocks; 14677377e853SHyeong-Jun Kim 1468*fd244524SChao Yu /* overwrite compressed cluster w/ normal cluster */ 1469*fd244524SChao Yu if (compr_blocks > 0) 1470*fd244524SChao Yu f2fs_lock_op(sbi); 1471*fd244524SChao Yu 14724c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 14734c8ff709SChao Yu if (!cc->rpages[i]) 14744c8ff709SChao Yu continue; 14754c8ff709SChao Yu retry_write: 14767377e853SHyeong-Jun Kim lock_page(cc->rpages[i]); 14777377e853SHyeong-Jun Kim 14784c8ff709SChao Yu if (cc->rpages[i]->mapping != mapping) { 14797377e853SHyeong-Jun Kim continue_unlock: 14804c8ff709SChao Yu unlock_page(cc->rpages[i]); 14814c8ff709SChao Yu continue; 14824c8ff709SChao Yu } 14834c8ff709SChao Yu 14847377e853SHyeong-Jun Kim if (!PageDirty(cc->rpages[i])) 14857377e853SHyeong-Jun Kim goto continue_unlock; 14867377e853SHyeong-Jun Kim 1487babedcbaSYangtao Li if (PageWriteback(cc->rpages[i])) { 1488babedcbaSYangtao Li if (wbc->sync_mode == WB_SYNC_NONE) 1489babedcbaSYangtao Li goto continue_unlock; 1490babedcbaSYangtao Li f2fs_wait_on_page_writeback(cc->rpages[i], DATA, true, true); 1491babedcbaSYangtao Li } 1492babedcbaSYangtao Li 14937377e853SHyeong-Jun Kim if (!clear_page_dirty_for_io(cc->rpages[i])) 14947377e853SHyeong-Jun Kim goto continue_unlock; 14954c8ff709SChao Yu 1496*fd244524SChao Yu ret = f2fs_write_single_data_page(cc->rpages[i], &submitted, 14974c8ff709SChao Yu NULL, NULL, wbc, io_type, 14983afae09fSChao Yu compr_blocks, false); 14994c8ff709SChao Yu if (ret) { 15004c8ff709SChao Yu if (ret == AOP_WRITEPAGE_ACTIVATE) { 15014c8ff709SChao Yu unlock_page(cc->rpages[i]); 15024c8ff709SChao Yu ret = 0; 15034c8ff709SChao Yu } else if (ret == -EAGAIN) { 1504*fd244524SChao Yu ret = 0; 1505466357dcSChao Yu /* 1506466357dcSChao Yu * for quota file, just redirty left pages to 1507466357dcSChao Yu * avoid deadlock caused by cluster update race 1508466357dcSChao Yu * from foreground operation. 1509466357dcSChao Yu */ 15107377e853SHyeong-Jun Kim if (IS_NOQUOTA(cc->inode)) 1511*fd244524SChao Yu goto out; 1512a64239d0SNeilBrown f2fs_io_schedule_timeout(DEFAULT_IO_TIMEOUT); 15134c8ff709SChao Yu goto retry_write; 15144c8ff709SChao Yu } 1515*fd244524SChao Yu goto out; 1516*fd244524SChao Yu } 1517*fd244524SChao Yu 1518*fd244524SChao Yu *submitted_p += submitted; 1519*fd244524SChao Yu } 1520*fd244524SChao Yu 1521*fd244524SChao Yu out: 1522*fd244524SChao Yu if (compr_blocks > 0) 1523*fd244524SChao Yu f2fs_unlock_op(sbi); 1524*fd244524SChao Yu 1525*fd244524SChao Yu f2fs_balance_fs(sbi, true); 15267377e853SHyeong-Jun Kim return ret; 15274c8ff709SChao Yu } 15284c8ff709SChao Yu 15294c8ff709SChao Yu int f2fs_write_multi_pages(struct compress_ctx *cc, 15304c8ff709SChao Yu int *submitted, 15314c8ff709SChao Yu struct writeback_control *wbc, 15324c8ff709SChao Yu enum iostat_type io_type) 15334c8ff709SChao Yu { 15344c8ff709SChao Yu int err; 15354c8ff709SChao Yu 15364c8ff709SChao Yu *submitted = 0; 15374c8ff709SChao Yu if (cluster_may_compress(cc)) { 15384c8ff709SChao Yu err = f2fs_compress_pages(cc); 15394c8ff709SChao Yu if (err == -EAGAIN) { 154009631cf3SDaeho Jeong add_compr_block_stat(cc->inode, cc->cluster_size); 15414c8ff709SChao Yu goto write; 15424c8ff709SChao Yu } else if (err) { 15434c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, true, 1); 15444c8ff709SChao Yu goto destroy_out; 15454c8ff709SChao Yu } 15464c8ff709SChao Yu 15474c8ff709SChao Yu err = f2fs_write_compressed_pages(cc, submitted, 15484c8ff709SChao Yu wbc, io_type); 15494c8ff709SChao Yu if (!err) 15504c8ff709SChao Yu return 0; 15514c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), err != -EAGAIN); 15524c8ff709SChao Yu } 15534c8ff709SChao Yu write: 15544c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), *submitted); 15554c8ff709SChao Yu 15564c8ff709SChao Yu err = f2fs_write_raw_pages(cc, submitted, wbc, io_type); 15574c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, false, 0); 15584c8ff709SChao Yu destroy_out: 15598bfbfb0dSChao Yu f2fs_destroy_compress_ctx(cc, false); 15604c8ff709SChao Yu return err; 15614c8ff709SChao Yu } 15624c8ff709SChao Yu 1563bff139b4SDaeho Jeong static inline bool allow_memalloc_for_decomp(struct f2fs_sb_info *sbi, 1564bff139b4SDaeho Jeong bool pre_alloc) 1565bff139b4SDaeho Jeong { 1566bff139b4SDaeho Jeong return pre_alloc ^ f2fs_low_mem_mode(sbi); 1567bff139b4SDaeho Jeong } 1568bff139b4SDaeho Jeong 1569bff139b4SDaeho Jeong static int f2fs_prepare_decomp_mem(struct decompress_io_ctx *dic, 1570bff139b4SDaeho Jeong bool pre_alloc) 1571bff139b4SDaeho Jeong { 1572bff139b4SDaeho Jeong const struct f2fs_compress_ops *cops = 1573bff139b4SDaeho Jeong f2fs_cops[F2FS_I(dic->inode)->i_compress_algorithm]; 1574bff139b4SDaeho Jeong int i; 1575bff139b4SDaeho Jeong 1576bff139b4SDaeho Jeong if (!allow_memalloc_for_decomp(F2FS_I_SB(dic->inode), pre_alloc)) 1577bff139b4SDaeho Jeong return 0; 1578bff139b4SDaeho Jeong 1579bff139b4SDaeho Jeong dic->tpages = page_array_alloc(dic->inode, dic->cluster_size); 1580bff139b4SDaeho Jeong if (!dic->tpages) 1581bff139b4SDaeho Jeong return -ENOMEM; 1582bff139b4SDaeho Jeong 1583bff139b4SDaeho Jeong for (i = 0; i < dic->cluster_size; i++) { 1584bff139b4SDaeho Jeong if (dic->rpages[i]) { 1585bff139b4SDaeho Jeong dic->tpages[i] = dic->rpages[i]; 1586bff139b4SDaeho Jeong continue; 1587bff139b4SDaeho Jeong } 1588bff139b4SDaeho Jeong 1589bff139b4SDaeho Jeong dic->tpages[i] = f2fs_compress_alloc_page(); 1590bff139b4SDaeho Jeong } 1591bff139b4SDaeho Jeong 1592bff139b4SDaeho Jeong dic->rbuf = f2fs_vmap(dic->tpages, dic->cluster_size); 1593bff139b4SDaeho Jeong if (!dic->rbuf) 1594bff139b4SDaeho Jeong return -ENOMEM; 1595bff139b4SDaeho Jeong 1596bff139b4SDaeho Jeong dic->cbuf = f2fs_vmap(dic->cpages, dic->nr_cpages); 1597bff139b4SDaeho Jeong if (!dic->cbuf) 1598bff139b4SDaeho Jeong return -ENOMEM; 1599bff139b4SDaeho Jeong 16008140654eSZhang Qilong if (cops->init_decompress_ctx) 16018140654eSZhang Qilong return cops->init_decompress_ctx(dic); 1602bff139b4SDaeho Jeong 1603bff139b4SDaeho Jeong return 0; 1604bff139b4SDaeho Jeong } 1605bff139b4SDaeho Jeong 1606bff139b4SDaeho Jeong static void f2fs_release_decomp_mem(struct decompress_io_ctx *dic, 1607bff139b4SDaeho Jeong bool bypass_destroy_callback, bool pre_alloc) 1608bff139b4SDaeho Jeong { 1609bff139b4SDaeho Jeong const struct f2fs_compress_ops *cops = 1610bff139b4SDaeho Jeong f2fs_cops[F2FS_I(dic->inode)->i_compress_algorithm]; 1611bff139b4SDaeho Jeong 1612bff139b4SDaeho Jeong if (!allow_memalloc_for_decomp(F2FS_I_SB(dic->inode), pre_alloc)) 1613bff139b4SDaeho Jeong return; 1614bff139b4SDaeho Jeong 1615bff139b4SDaeho Jeong if (!bypass_destroy_callback && cops->destroy_decompress_ctx) 1616bff139b4SDaeho Jeong cops->destroy_decompress_ctx(dic); 1617bff139b4SDaeho Jeong 1618bff139b4SDaeho Jeong if (dic->cbuf) 1619bff139b4SDaeho Jeong vm_unmap_ram(dic->cbuf, dic->nr_cpages); 1620bff139b4SDaeho Jeong 1621bff139b4SDaeho Jeong if (dic->rbuf) 1622bff139b4SDaeho Jeong vm_unmap_ram(dic->rbuf, dic->cluster_size); 1623bff139b4SDaeho Jeong } 1624bff139b4SDaeho Jeong 1625bff139b4SDaeho Jeong static void f2fs_free_dic(struct decompress_io_ctx *dic, 1626bff139b4SDaeho Jeong bool bypass_destroy_callback); 16277f59b277SEric Biggers 16284c8ff709SChao Yu struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc) 16294c8ff709SChao Yu { 16304c8ff709SChao Yu struct decompress_io_ctx *dic; 16314c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 1632bff139b4SDaeho Jeong struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 1633bff139b4SDaeho Jeong int i, ret; 16344c8ff709SChao Yu 1635bff139b4SDaeho Jeong dic = f2fs_kmem_cache_alloc(dic_entry_slab, GFP_F2FS_ZERO, false, sbi); 16364c8ff709SChao Yu if (!dic) 16374c8ff709SChao Yu return ERR_PTR(-ENOMEM); 16384c8ff709SChao Yu 163931083031SChao Yu dic->rpages = page_array_alloc(cc->inode, cc->cluster_size); 16404c8ff709SChao Yu if (!dic->rpages) { 1641c68d6c88SChao Yu kmem_cache_free(dic_entry_slab, dic); 16424c8ff709SChao Yu return ERR_PTR(-ENOMEM); 16434c8ff709SChao Yu } 16444c8ff709SChao Yu 16454c8ff709SChao Yu dic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 16464c8ff709SChao Yu dic->inode = cc->inode; 16477f59b277SEric Biggers atomic_set(&dic->remaining_pages, cc->nr_cpages); 16484c8ff709SChao Yu dic->cluster_idx = cc->cluster_idx; 16494c8ff709SChao Yu dic->cluster_size = cc->cluster_size; 16504c8ff709SChao Yu dic->log_cluster_size = cc->log_cluster_size; 16514c8ff709SChao Yu dic->nr_cpages = cc->nr_cpages; 16527f59b277SEric Biggers refcount_set(&dic->refcnt, 1); 16534c8ff709SChao Yu dic->failed = false; 16547f59b277SEric Biggers dic->need_verity = f2fs_need_verity(cc->inode, start_idx); 16554c8ff709SChao Yu 16564c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) 16574c8ff709SChao Yu dic->rpages[i] = cc->rpages[i]; 16584c8ff709SChao Yu dic->nr_rpages = cc->cluster_size; 16594c8ff709SChao Yu 166031083031SChao Yu dic->cpages = page_array_alloc(dic->inode, dic->nr_cpages); 1661bff139b4SDaeho Jeong if (!dic->cpages) { 1662bff139b4SDaeho Jeong ret = -ENOMEM; 16634c8ff709SChao Yu goto out_free; 1664bff139b4SDaeho Jeong } 16654c8ff709SChao Yu 16664c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 16674c8ff709SChao Yu struct page *page; 16684c8ff709SChao Yu 16695e6bbde9SChao Yu page = f2fs_compress_alloc_page(); 16704c8ff709SChao Yu f2fs_set_compressed_page(page, cc->inode, 1671887347a0SChao Yu start_idx + i + 1, dic); 16724c8ff709SChao Yu dic->cpages[i] = page; 16734c8ff709SChao Yu } 16744c8ff709SChao Yu 1675bff139b4SDaeho Jeong ret = f2fs_prepare_decomp_mem(dic, true); 1676bff139b4SDaeho Jeong if (ret) 1677bff139b4SDaeho Jeong goto out_free; 1678bff139b4SDaeho Jeong 16794c8ff709SChao Yu return dic; 16804c8ff709SChao Yu 16814c8ff709SChao Yu out_free: 1682bff139b4SDaeho Jeong f2fs_free_dic(dic, true); 1683bff139b4SDaeho Jeong return ERR_PTR(ret); 16844c8ff709SChao Yu } 16854c8ff709SChao Yu 1686bff139b4SDaeho Jeong static void f2fs_free_dic(struct decompress_io_ctx *dic, 1687bff139b4SDaeho Jeong bool bypass_destroy_callback) 16884c8ff709SChao Yu { 16894c8ff709SChao Yu int i; 16904c8ff709SChao Yu 1691bff139b4SDaeho Jeong f2fs_release_decomp_mem(dic, bypass_destroy_callback, true); 1692bff139b4SDaeho Jeong 16934c8ff709SChao Yu if (dic->tpages) { 16944c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) { 16954c8ff709SChao Yu if (dic->rpages[i]) 16964c8ff709SChao Yu continue; 16978908e753SChao Yu if (!dic->tpages[i]) 16988908e753SChao Yu continue; 16995e6bbde9SChao Yu f2fs_compress_free_page(dic->tpages[i]); 17004c8ff709SChao Yu } 170131083031SChao Yu page_array_free(dic->inode, dic->tpages, dic->cluster_size); 17024c8ff709SChao Yu } 17034c8ff709SChao Yu 17044c8ff709SChao Yu if (dic->cpages) { 17054c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 17064c8ff709SChao Yu if (!dic->cpages[i]) 17074c8ff709SChao Yu continue; 17085e6bbde9SChao Yu f2fs_compress_free_page(dic->cpages[i]); 17094c8ff709SChao Yu } 171031083031SChao Yu page_array_free(dic->inode, dic->cpages, dic->nr_cpages); 17114c8ff709SChao Yu } 17124c8ff709SChao Yu 171331083031SChao Yu page_array_free(dic->inode, dic->rpages, dic->nr_rpages); 1714c68d6c88SChao Yu kmem_cache_free(dic_entry_slab, dic); 17154c8ff709SChao Yu } 17164c8ff709SChao Yu 1717bff139b4SDaeho Jeong static void f2fs_late_free_dic(struct work_struct *work) 17187f59b277SEric Biggers { 1719bff139b4SDaeho Jeong struct decompress_io_ctx *dic = 1720bff139b4SDaeho Jeong container_of(work, struct decompress_io_ctx, free_work); 1721bff139b4SDaeho Jeong 1722bff139b4SDaeho Jeong f2fs_free_dic(dic, false); 1723bff139b4SDaeho Jeong } 1724bff139b4SDaeho Jeong 1725bff139b4SDaeho Jeong static void f2fs_put_dic(struct decompress_io_ctx *dic, bool in_task) 1726bff139b4SDaeho Jeong { 1727bff139b4SDaeho Jeong if (refcount_dec_and_test(&dic->refcnt)) { 1728bff139b4SDaeho Jeong if (in_task) { 1729bff139b4SDaeho Jeong f2fs_free_dic(dic, false); 1730bff139b4SDaeho Jeong } else { 1731bff139b4SDaeho Jeong INIT_WORK(&dic->free_work, f2fs_late_free_dic); 1732bff139b4SDaeho Jeong queue_work(F2FS_I_SB(dic->inode)->post_read_wq, 1733bff139b4SDaeho Jeong &dic->free_work); 1734bff139b4SDaeho Jeong } 1735bff139b4SDaeho Jeong } 17367f59b277SEric Biggers } 17377f59b277SEric Biggers 17387f59b277SEric Biggers static void f2fs_verify_cluster(struct work_struct *work) 17397f59b277SEric Biggers { 17407f59b277SEric Biggers struct decompress_io_ctx *dic = 17417f59b277SEric Biggers container_of(work, struct decompress_io_ctx, verity_work); 17427f59b277SEric Biggers int i; 17437f59b277SEric Biggers 174498dc08baSEric Biggers /* Verify, update, and unlock the decompressed pages. */ 17457f59b277SEric Biggers for (i = 0; i < dic->cluster_size; i++) { 17467f59b277SEric Biggers struct page *rpage = dic->rpages[i]; 17477f59b277SEric Biggers 174898dc08baSEric Biggers if (!rpage) 174998dc08baSEric Biggers continue; 175098dc08baSEric Biggers 175198dc08baSEric Biggers if (fsverity_verify_page(rpage)) 175298dc08baSEric Biggers SetPageUptodate(rpage); 175398dc08baSEric Biggers else 175498dc08baSEric Biggers ClearPageUptodate(rpage); 175598dc08baSEric Biggers unlock_page(rpage); 17567f59b277SEric Biggers } 17577f59b277SEric Biggers 175898dc08baSEric Biggers f2fs_put_dic(dic, true); 17597f59b277SEric Biggers } 17607f59b277SEric Biggers 17617f59b277SEric Biggers /* 17627f59b277SEric Biggers * This is called when a compressed cluster has been decompressed 17637f59b277SEric Biggers * (or failed to be read and/or decompressed). 17647f59b277SEric Biggers */ 1765bff139b4SDaeho Jeong void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed, 1766bff139b4SDaeho Jeong bool in_task) 17677f59b277SEric Biggers { 176898dc08baSEric Biggers int i; 176998dc08baSEric Biggers 17707f59b277SEric Biggers if (!failed && dic->need_verity) { 17717f59b277SEric Biggers /* 17727f59b277SEric Biggers * Note that to avoid deadlocks, the verity work can't be done 17737f59b277SEric Biggers * on the decompression workqueue. This is because verifying 17747f59b277SEric Biggers * the data pages can involve reading metadata pages from the 17757f59b277SEric Biggers * file, and these metadata pages may be compressed. 17767f59b277SEric Biggers */ 17777f59b277SEric Biggers INIT_WORK(&dic->verity_work, f2fs_verify_cluster); 17787f59b277SEric Biggers fsverity_enqueue_verify_work(&dic->verity_work); 177998dc08baSEric Biggers return; 17807f59b277SEric Biggers } 178198dc08baSEric Biggers 178298dc08baSEric Biggers /* Update and unlock the cluster's pagecache pages. */ 178398dc08baSEric Biggers for (i = 0; i < dic->cluster_size; i++) { 178498dc08baSEric Biggers struct page *rpage = dic->rpages[i]; 178598dc08baSEric Biggers 178698dc08baSEric Biggers if (!rpage) 178798dc08baSEric Biggers continue; 178898dc08baSEric Biggers 178998dc08baSEric Biggers if (failed) 179098dc08baSEric Biggers ClearPageUptodate(rpage); 179198dc08baSEric Biggers else 179298dc08baSEric Biggers SetPageUptodate(rpage); 179398dc08baSEric Biggers unlock_page(rpage); 179498dc08baSEric Biggers } 179598dc08baSEric Biggers 179698dc08baSEric Biggers /* 179798dc08baSEric Biggers * Release the reference to the decompress_io_ctx that was being held 179898dc08baSEric Biggers * for I/O completion. 179998dc08baSEric Biggers */ 180098dc08baSEric Biggers f2fs_put_dic(dic, in_task); 18017f59b277SEric Biggers } 18027f59b277SEric Biggers 18037f59b277SEric Biggers /* 18047f59b277SEric Biggers * Put a reference to a compressed page's decompress_io_ctx. 18057f59b277SEric Biggers * 18067f59b277SEric Biggers * This is called when the page is no longer needed and can be freed. 18077f59b277SEric Biggers */ 1808bff139b4SDaeho Jeong void f2fs_put_page_dic(struct page *page, bool in_task) 18097f59b277SEric Biggers { 18107f59b277SEric Biggers struct decompress_io_ctx *dic = 18117f59b277SEric Biggers (struct decompress_io_ctx *)page_private(page); 18127f59b277SEric Biggers 1813bff139b4SDaeho Jeong f2fs_put_dic(dic, in_task); 18144c8ff709SChao Yu } 181531083031SChao Yu 181694afd6d6SChao Yu /* 181794afd6d6SChao Yu * check whether cluster blocks are contiguous, and add extent cache entry 181894afd6d6SChao Yu * only if cluster blocks are logically and physically contiguous. 181994afd6d6SChao Yu */ 182094afd6d6SChao Yu unsigned int f2fs_cluster_blocks_are_contiguous(struct dnode_of_data *dn) 182194afd6d6SChao Yu { 182294afd6d6SChao Yu bool compressed = f2fs_data_blkaddr(dn) == COMPRESS_ADDR; 182394afd6d6SChao Yu int i = compressed ? 1 : 0; 182494afd6d6SChao Yu block_t first_blkaddr = data_blkaddr(dn->inode, dn->node_page, 182594afd6d6SChao Yu dn->ofs_in_node + i); 182694afd6d6SChao Yu 182794afd6d6SChao Yu for (i += 1; i < F2FS_I(dn->inode)->i_cluster_size; i++) { 182894afd6d6SChao Yu block_t blkaddr = data_blkaddr(dn->inode, dn->node_page, 182994afd6d6SChao Yu dn->ofs_in_node + i); 183094afd6d6SChao Yu 183194afd6d6SChao Yu if (!__is_valid_data_blkaddr(blkaddr)) 183294afd6d6SChao Yu break; 183394afd6d6SChao Yu if (first_blkaddr + i - (compressed ? 1 : 0) != blkaddr) 183494afd6d6SChao Yu return 0; 183594afd6d6SChao Yu } 183694afd6d6SChao Yu 183794afd6d6SChao Yu return compressed ? i - 1 : i; 183894afd6d6SChao Yu } 183994afd6d6SChao Yu 18406ce19affSChao Yu const struct address_space_operations f2fs_compress_aops = { 1841c26cd045SMatthew Wilcox (Oracle) .release_folio = f2fs_release_folio, 184291503996SMatthew Wilcox (Oracle) .invalidate_folio = f2fs_invalidate_folio, 1843f35474ecSChao Yu .migrate_folio = filemap_migrate_folio, 18446ce19affSChao Yu }; 18456ce19affSChao Yu 18466ce19affSChao Yu struct address_space *COMPRESS_MAPPING(struct f2fs_sb_info *sbi) 18476ce19affSChao Yu { 18486ce19affSChao Yu return sbi->compress_inode->i_mapping; 18496ce19affSChao Yu } 18506ce19affSChao Yu 18516ce19affSChao Yu void f2fs_invalidate_compress_page(struct f2fs_sb_info *sbi, block_t blkaddr) 18526ce19affSChao Yu { 18536ce19affSChao Yu if (!sbi->compress_inode) 18546ce19affSChao Yu return; 18556ce19affSChao Yu invalidate_mapping_pages(COMPRESS_MAPPING(sbi), blkaddr, blkaddr); 18566ce19affSChao Yu } 18576ce19affSChao Yu 18586ce19affSChao Yu void f2fs_cache_compressed_page(struct f2fs_sb_info *sbi, struct page *page, 18596ce19affSChao Yu nid_t ino, block_t blkaddr) 18606ce19affSChao Yu { 18616ce19affSChao Yu struct page *cpage; 18626ce19affSChao Yu int ret; 18636ce19affSChao Yu 18646ce19affSChao Yu if (!test_opt(sbi, COMPRESS_CACHE)) 18656ce19affSChao Yu return; 18666ce19affSChao Yu 18676ce19affSChao Yu if (!f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC_ENHANCE_READ)) 18686ce19affSChao Yu return; 18696ce19affSChao Yu 18706ce19affSChao Yu if (!f2fs_available_free_memory(sbi, COMPRESS_PAGE)) 18716ce19affSChao Yu return; 18726ce19affSChao Yu 18736ce19affSChao Yu cpage = find_get_page(COMPRESS_MAPPING(sbi), blkaddr); 18746ce19affSChao Yu if (cpage) { 18756ce19affSChao Yu f2fs_put_page(cpage, 0); 18766ce19affSChao Yu return; 18776ce19affSChao Yu } 18786ce19affSChao Yu 18796ce19affSChao Yu cpage = alloc_page(__GFP_NOWARN | __GFP_IO); 18806ce19affSChao Yu if (!cpage) 18816ce19affSChao Yu return; 18826ce19affSChao Yu 18836ce19affSChao Yu ret = add_to_page_cache_lru(cpage, COMPRESS_MAPPING(sbi), 18846ce19affSChao Yu blkaddr, GFP_NOFS); 18856ce19affSChao Yu if (ret) { 18866ce19affSChao Yu f2fs_put_page(cpage, 0); 18876ce19affSChao Yu return; 18886ce19affSChao Yu } 18896ce19affSChao Yu 18906ce19affSChao Yu set_page_private_data(cpage, ino); 18916ce19affSChao Yu 18926ce19affSChao Yu if (!f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC_ENHANCE_READ)) 18936ce19affSChao Yu goto out; 18946ce19affSChao Yu 18956ce19affSChao Yu memcpy(page_address(cpage), page_address(page), PAGE_SIZE); 18966ce19affSChao Yu SetPageUptodate(cpage); 18976ce19affSChao Yu out: 18986ce19affSChao Yu f2fs_put_page(cpage, 1); 18996ce19affSChao Yu } 19006ce19affSChao Yu 19016ce19affSChao Yu bool f2fs_load_compressed_page(struct f2fs_sb_info *sbi, struct page *page, 19026ce19affSChao Yu block_t blkaddr) 19036ce19affSChao Yu { 19046ce19affSChao Yu struct page *cpage; 19056ce19affSChao Yu bool hitted = false; 19066ce19affSChao Yu 19076ce19affSChao Yu if (!test_opt(sbi, COMPRESS_CACHE)) 19086ce19affSChao Yu return false; 19096ce19affSChao Yu 19106ce19affSChao Yu cpage = f2fs_pagecache_get_page(COMPRESS_MAPPING(sbi), 19116ce19affSChao Yu blkaddr, FGP_LOCK | FGP_NOWAIT, GFP_NOFS); 19126ce19affSChao Yu if (cpage) { 19136ce19affSChao Yu if (PageUptodate(cpage)) { 19146ce19affSChao Yu atomic_inc(&sbi->compress_page_hit); 19156ce19affSChao Yu memcpy(page_address(page), 19166ce19affSChao Yu page_address(cpage), PAGE_SIZE); 19176ce19affSChao Yu hitted = true; 19186ce19affSChao Yu } 19196ce19affSChao Yu f2fs_put_page(cpage, 1); 19206ce19affSChao Yu } 19216ce19affSChao Yu 19226ce19affSChao Yu return hitted; 19236ce19affSChao Yu } 19246ce19affSChao Yu 19256ce19affSChao Yu void f2fs_invalidate_compress_pages(struct f2fs_sb_info *sbi, nid_t ino) 19266ce19affSChao Yu { 1927173cdf2cSZhang Qilong struct address_space *mapping = COMPRESS_MAPPING(sbi); 1928bbfe4f66SMatthew Wilcox (Oracle) struct folio_batch fbatch; 19296ce19affSChao Yu pgoff_t index = 0; 19306ce19affSChao Yu pgoff_t end = MAX_BLKADDR(sbi); 19316ce19affSChao Yu 19326ce19affSChao Yu if (!mapping->nrpages) 19336ce19affSChao Yu return; 19346ce19affSChao Yu 1935bbfe4f66SMatthew Wilcox (Oracle) folio_batch_init(&fbatch); 19366ce19affSChao Yu 19376ce19affSChao Yu do { 1938bbfe4f66SMatthew Wilcox (Oracle) unsigned int nr, i; 19396ce19affSChao Yu 1940bbfe4f66SMatthew Wilcox (Oracle) nr = filemap_get_folios(mapping, &index, end - 1, &fbatch); 1941bbfe4f66SMatthew Wilcox (Oracle) if (!nr) 19426ce19affSChao Yu break; 19436ce19affSChao Yu 1944bbfe4f66SMatthew Wilcox (Oracle) for (i = 0; i < nr; i++) { 1945bbfe4f66SMatthew Wilcox (Oracle) struct folio *folio = fbatch.folios[i]; 19466ce19affSChao Yu 1947bbfe4f66SMatthew Wilcox (Oracle) folio_lock(folio); 1948bbfe4f66SMatthew Wilcox (Oracle) if (folio->mapping != mapping) { 1949bbfe4f66SMatthew Wilcox (Oracle) folio_unlock(folio); 19506ce19affSChao Yu continue; 19516ce19affSChao Yu } 19526ce19affSChao Yu 1953bbfe4f66SMatthew Wilcox (Oracle) if (ino != get_page_private_data(&folio->page)) { 1954bbfe4f66SMatthew Wilcox (Oracle) folio_unlock(folio); 19556ce19affSChao Yu continue; 19566ce19affSChao Yu } 19576ce19affSChao Yu 1958af7628d6SMatthew Wilcox (Oracle) generic_error_remove_folio(mapping, folio); 1959bbfe4f66SMatthew Wilcox (Oracle) folio_unlock(folio); 19606ce19affSChao Yu } 1961bbfe4f66SMatthew Wilcox (Oracle) folio_batch_release(&fbatch); 19626ce19affSChao Yu cond_resched(); 19636ce19affSChao Yu } while (index < end); 19646ce19affSChao Yu } 19656ce19affSChao Yu 19666ce19affSChao Yu int f2fs_init_compress_inode(struct f2fs_sb_info *sbi) 19676ce19affSChao Yu { 19686ce19affSChao Yu struct inode *inode; 19696ce19affSChao Yu 19706ce19affSChao Yu if (!test_opt(sbi, COMPRESS_CACHE)) 19716ce19affSChao Yu return 0; 19726ce19affSChao Yu 19736ce19affSChao Yu inode = f2fs_iget(sbi->sb, F2FS_COMPRESS_INO(sbi)); 19746ce19affSChao Yu if (IS_ERR(inode)) 19756ce19affSChao Yu return PTR_ERR(inode); 19766ce19affSChao Yu sbi->compress_inode = inode; 19776ce19affSChao Yu 19786ce19affSChao Yu sbi->compress_percent = COMPRESS_PERCENT; 19796ce19affSChao Yu sbi->compress_watermark = COMPRESS_WATERMARK; 19806ce19affSChao Yu 19816ce19affSChao Yu atomic_set(&sbi->compress_page_hit, 0); 19826ce19affSChao Yu 19836ce19affSChao Yu return 0; 19846ce19affSChao Yu } 19856ce19affSChao Yu 19866ce19affSChao Yu void f2fs_destroy_compress_inode(struct f2fs_sb_info *sbi) 19876ce19affSChao Yu { 19886ce19affSChao Yu if (!sbi->compress_inode) 19896ce19affSChao Yu return; 19906ce19affSChao Yu iput(sbi->compress_inode); 19916ce19affSChao Yu sbi->compress_inode = NULL; 19926ce19affSChao Yu } 19936ce19affSChao Yu 199431083031SChao Yu int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi) 199531083031SChao Yu { 199631083031SChao Yu dev_t dev = sbi->sb->s_bdev->bd_dev; 1997e0d4e8acSSu Hui char slab_name[35]; 199831083031SChao Yu 199929be7ec3SChao Yu if (!f2fs_sb_has_compression(sbi)) 200029be7ec3SChao Yu return 0; 200129be7ec3SChao Yu 200231083031SChao Yu sprintf(slab_name, "f2fs_page_array_entry-%u:%u", MAJOR(dev), MINOR(dev)); 200331083031SChao Yu 200431083031SChao Yu sbi->page_array_slab_size = sizeof(struct page *) << 200531083031SChao Yu F2FS_OPTION(sbi).compress_log_size; 200631083031SChao Yu 200731083031SChao Yu sbi->page_array_slab = f2fs_kmem_cache_create(slab_name, 200831083031SChao Yu sbi->page_array_slab_size); 2009870af777SYangtao Li return sbi->page_array_slab ? 0 : -ENOMEM; 201031083031SChao Yu } 201131083031SChao Yu 201231083031SChao Yu void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) 201331083031SChao Yu { 201431083031SChao Yu kmem_cache_destroy(sbi->page_array_slab); 201531083031SChao Yu } 2016c68d6c88SChao Yu 2017870af777SYangtao Li int __init f2fs_init_compress_cache(void) 2018c68d6c88SChao Yu { 2019c68d6c88SChao Yu cic_entry_slab = f2fs_kmem_cache_create("f2fs_cic_entry", 2020c68d6c88SChao Yu sizeof(struct compress_io_ctx)); 2021c68d6c88SChao Yu if (!cic_entry_slab) 2022c68d6c88SChao Yu return -ENOMEM; 2023c68d6c88SChao Yu dic_entry_slab = f2fs_kmem_cache_create("f2fs_dic_entry", 2024c68d6c88SChao Yu sizeof(struct decompress_io_ctx)); 2025c68d6c88SChao Yu if (!dic_entry_slab) 2026c68d6c88SChao Yu goto free_cic; 2027c68d6c88SChao Yu return 0; 2028c68d6c88SChao Yu free_cic: 2029870af777SYangtao Li kmem_cache_destroy(cic_entry_slab); 2030c68d6c88SChao Yu return -ENOMEM; 2031c68d6c88SChao Yu } 2032c68d6c88SChao Yu 2033c68d6c88SChao Yu void f2fs_destroy_compress_cache(void) 2034c68d6c88SChao Yu { 2035870af777SYangtao Li kmem_cache_destroy(dic_entry_slab); 2036870af777SYangtao Li kmem_cache_destroy(cic_entry_slab); 2037c68d6c88SChao Yu } 2038