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> 104c8ff709SChao Yu #include <linux/writeback.h> 114c8ff709SChao Yu #include <linux/backing-dev.h> 124c8ff709SChao Yu #include <linux/lzo.h> 134c8ff709SChao Yu #include <linux/lz4.h> 1450cfa66fSChao Yu #include <linux/zstd.h> 154c8ff709SChao Yu 164c8ff709SChao Yu #include "f2fs.h" 174c8ff709SChao Yu #include "node.h" 184c8ff709SChao Yu #include <trace/events/f2fs.h> 194c8ff709SChao Yu 20c68d6c88SChao Yu static struct kmem_cache *cic_entry_slab; 21c68d6c88SChao Yu static struct kmem_cache *dic_entry_slab; 22c68d6c88SChao Yu 2331083031SChao Yu static void *page_array_alloc(struct inode *inode, int nr) 2431083031SChao Yu { 2531083031SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2631083031SChao Yu unsigned int size = sizeof(struct page *) * nr; 2731083031SChao Yu 2831083031SChao Yu if (likely(size <= sbi->page_array_slab_size)) 2931083031SChao Yu return kmem_cache_zalloc(sbi->page_array_slab, GFP_NOFS); 3031083031SChao Yu return f2fs_kzalloc(sbi, size, GFP_NOFS); 3131083031SChao Yu } 3231083031SChao Yu 3331083031SChao Yu static void page_array_free(struct inode *inode, void *pages, int nr) 3431083031SChao Yu { 3531083031SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 3631083031SChao Yu unsigned int size = sizeof(struct page *) * nr; 3731083031SChao Yu 3831083031SChao Yu if (!pages) 3931083031SChao Yu return; 4031083031SChao Yu 4131083031SChao Yu if (likely(size <= sbi->page_array_slab_size)) 4231083031SChao Yu kmem_cache_free(sbi->page_array_slab, pages); 4331083031SChao Yu else 4431083031SChao Yu kfree(pages); 4531083031SChao Yu } 4631083031SChao Yu 474c8ff709SChao Yu struct f2fs_compress_ops { 484c8ff709SChao Yu int (*init_compress_ctx)(struct compress_ctx *cc); 494c8ff709SChao Yu void (*destroy_compress_ctx)(struct compress_ctx *cc); 504c8ff709SChao Yu int (*compress_pages)(struct compress_ctx *cc); 5123b1faaaSChao Yu int (*init_decompress_ctx)(struct decompress_io_ctx *dic); 5223b1faaaSChao Yu void (*destroy_decompress_ctx)(struct decompress_io_ctx *dic); 534c8ff709SChao Yu int (*decompress_pages)(struct decompress_io_ctx *dic); 544c8ff709SChao Yu }; 554c8ff709SChao Yu 564c8ff709SChao Yu static unsigned int offset_in_cluster(struct compress_ctx *cc, pgoff_t index) 574c8ff709SChao Yu { 584c8ff709SChao Yu return index & (cc->cluster_size - 1); 594c8ff709SChao Yu } 604c8ff709SChao Yu 614c8ff709SChao Yu static pgoff_t cluster_idx(struct compress_ctx *cc, pgoff_t index) 624c8ff709SChao Yu { 634c8ff709SChao Yu return index >> cc->log_cluster_size; 644c8ff709SChao Yu } 654c8ff709SChao Yu 664c8ff709SChao Yu static pgoff_t start_idx_of_cluster(struct compress_ctx *cc) 674c8ff709SChao Yu { 684c8ff709SChao Yu return cc->cluster_idx << cc->log_cluster_size; 694c8ff709SChao Yu } 704c8ff709SChao Yu 714c8ff709SChao Yu bool f2fs_is_compressed_page(struct page *page) 724c8ff709SChao Yu { 734c8ff709SChao Yu if (!PagePrivate(page)) 744c8ff709SChao Yu return false; 754c8ff709SChao Yu if (!page_private(page)) 764c8ff709SChao Yu return false; 774c8ff709SChao Yu if (IS_ATOMIC_WRITTEN_PAGE(page) || IS_DUMMY_WRITTEN_PAGE(page)) 784c8ff709SChao Yu return false; 7929b993c7SYu Changchun 804c8ff709SChao Yu f2fs_bug_on(F2FS_M_SB(page->mapping), 814c8ff709SChao Yu *((u32 *)page_private(page)) != F2FS_COMPRESSED_PAGE_MAGIC); 824c8ff709SChao Yu return true; 834c8ff709SChao Yu } 844c8ff709SChao Yu 854c8ff709SChao Yu static void f2fs_set_compressed_page(struct page *page, 86887347a0SChao Yu struct inode *inode, pgoff_t index, void *data) 874c8ff709SChao Yu { 884c8ff709SChao Yu SetPagePrivate(page); 894c8ff709SChao Yu set_page_private(page, (unsigned long)data); 904c8ff709SChao Yu 914c8ff709SChao Yu /* i_crypto_info and iv index */ 924c8ff709SChao Yu page->index = index; 934c8ff709SChao Yu page->mapping = inode->i_mapping; 944c8ff709SChao Yu } 954c8ff709SChao Yu 964c8ff709SChao Yu static void f2fs_drop_rpages(struct compress_ctx *cc, int len, bool unlock) 974c8ff709SChao Yu { 984c8ff709SChao Yu int i; 994c8ff709SChao Yu 1004c8ff709SChao Yu for (i = 0; i < len; i++) { 1014c8ff709SChao Yu if (!cc->rpages[i]) 1024c8ff709SChao Yu continue; 1034c8ff709SChao Yu if (unlock) 1044c8ff709SChao Yu unlock_page(cc->rpages[i]); 1054c8ff709SChao Yu else 1064c8ff709SChao Yu put_page(cc->rpages[i]); 1074c8ff709SChao Yu } 1084c8ff709SChao Yu } 1094c8ff709SChao Yu 1104c8ff709SChao Yu static void f2fs_put_rpages(struct compress_ctx *cc) 1114c8ff709SChao Yu { 1124c8ff709SChao Yu f2fs_drop_rpages(cc, cc->cluster_size, false); 1134c8ff709SChao Yu } 1144c8ff709SChao Yu 1154c8ff709SChao Yu static void f2fs_unlock_rpages(struct compress_ctx *cc, int len) 1164c8ff709SChao Yu { 1174c8ff709SChao Yu f2fs_drop_rpages(cc, len, true); 1184c8ff709SChao Yu } 1194c8ff709SChao Yu 120bc67c5d0SChao Yu static void f2fs_put_rpages_mapping(struct address_space *mapping, 1214c8ff709SChao Yu pgoff_t start, int len) 1224c8ff709SChao Yu { 1234c8ff709SChao Yu int i; 1244c8ff709SChao Yu 1254c8ff709SChao Yu for (i = 0; i < len; i++) { 1264c8ff709SChao Yu struct page *page = find_get_page(mapping, start + i); 1274c8ff709SChao Yu 1284c8ff709SChao Yu put_page(page); 1294c8ff709SChao Yu put_page(page); 1304c8ff709SChao Yu } 1314c8ff709SChao Yu } 1324c8ff709SChao Yu 1334c8ff709SChao Yu static void f2fs_put_rpages_wbc(struct compress_ctx *cc, 1344c8ff709SChao Yu struct writeback_control *wbc, bool redirty, int unlock) 1354c8ff709SChao Yu { 1364c8ff709SChao Yu unsigned int i; 1374c8ff709SChao Yu 1384c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1394c8ff709SChao Yu if (!cc->rpages[i]) 1404c8ff709SChao Yu continue; 1414c8ff709SChao Yu if (redirty) 1424c8ff709SChao Yu redirty_page_for_writepage(wbc, cc->rpages[i]); 1434c8ff709SChao Yu f2fs_put_page(cc->rpages[i], unlock); 1444c8ff709SChao Yu } 1454c8ff709SChao Yu } 1464c8ff709SChao Yu 1474c8ff709SChao Yu struct page *f2fs_compress_control_page(struct page *page) 1484c8ff709SChao Yu { 1494c8ff709SChao Yu return ((struct compress_io_ctx *)page_private(page))->rpages[0]; 1504c8ff709SChao Yu } 1514c8ff709SChao Yu 1524c8ff709SChao Yu int f2fs_init_compress_ctx(struct compress_ctx *cc) 1534c8ff709SChao Yu { 154adfc6943SJaegeuk Kim if (cc->rpages) 1554c8ff709SChao Yu return 0; 1564c8ff709SChao Yu 15731083031SChao Yu cc->rpages = page_array_alloc(cc->inode, cc->cluster_size); 1584c8ff709SChao Yu return cc->rpages ? 0 : -ENOMEM; 1594c8ff709SChao Yu } 1604c8ff709SChao Yu 1614c8ff709SChao Yu void f2fs_destroy_compress_ctx(struct compress_ctx *cc) 1624c8ff709SChao Yu { 16331083031SChao Yu page_array_free(cc->inode, cc->rpages, cc->cluster_size); 1644c8ff709SChao Yu cc->rpages = NULL; 1654c8ff709SChao Yu cc->nr_rpages = 0; 1664c8ff709SChao Yu cc->nr_cpages = 0; 1674c8ff709SChao Yu cc->cluster_idx = NULL_CLUSTER; 1684c8ff709SChao Yu } 1694c8ff709SChao Yu 1704c8ff709SChao Yu void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page) 1714c8ff709SChao Yu { 1724c8ff709SChao Yu unsigned int cluster_ofs; 1734c8ff709SChao Yu 1744c8ff709SChao Yu if (!f2fs_cluster_can_merge_page(cc, page->index)) 1754c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), 1); 1764c8ff709SChao Yu 1774c8ff709SChao Yu cluster_ofs = offset_in_cluster(cc, page->index); 1784c8ff709SChao Yu cc->rpages[cluster_ofs] = page; 1794c8ff709SChao Yu cc->nr_rpages++; 1804c8ff709SChao Yu cc->cluster_idx = cluster_idx(cc, page->index); 1814c8ff709SChao Yu } 1824c8ff709SChao Yu 1834c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 1844c8ff709SChao Yu static int lzo_init_compress_ctx(struct compress_ctx *cc) 1854c8ff709SChao Yu { 1864c8ff709SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 1874c8ff709SChao Yu LZO1X_MEM_COMPRESS, GFP_NOFS); 1884c8ff709SChao Yu if (!cc->private) 1894c8ff709SChao Yu return -ENOMEM; 1904c8ff709SChao Yu 1914c8ff709SChao Yu cc->clen = lzo1x_worst_compress(PAGE_SIZE << cc->log_cluster_size); 1924c8ff709SChao Yu return 0; 1934c8ff709SChao Yu } 1944c8ff709SChao Yu 1954c8ff709SChao Yu static void lzo_destroy_compress_ctx(struct compress_ctx *cc) 1964c8ff709SChao Yu { 1974c8ff709SChao Yu kvfree(cc->private); 1984c8ff709SChao Yu cc->private = NULL; 1994c8ff709SChao Yu } 2004c8ff709SChao Yu 2014c8ff709SChao Yu static int lzo_compress_pages(struct compress_ctx *cc) 2024c8ff709SChao Yu { 2034c8ff709SChao Yu int ret; 2044c8ff709SChao Yu 2054c8ff709SChao Yu ret = lzo1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 2064c8ff709SChao Yu &cc->clen, cc->private); 2074c8ff709SChao Yu if (ret != LZO_E_OK) { 2084c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo compress failed, ret:%d\n", 2094c8ff709SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 2104c8ff709SChao Yu return -EIO; 2114c8ff709SChao Yu } 2124c8ff709SChao Yu return 0; 2134c8ff709SChao Yu } 2144c8ff709SChao Yu 2154c8ff709SChao Yu static int lzo_decompress_pages(struct decompress_io_ctx *dic) 2164c8ff709SChao Yu { 2174c8ff709SChao Yu int ret; 2184c8ff709SChao Yu 2194c8ff709SChao Yu ret = lzo1x_decompress_safe(dic->cbuf->cdata, dic->clen, 2204c8ff709SChao Yu dic->rbuf, &dic->rlen); 2214c8ff709SChao Yu if (ret != LZO_E_OK) { 2224c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo decompress failed, ret:%d\n", 2234c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 2244c8ff709SChao Yu return -EIO; 2254c8ff709SChao Yu } 2264c8ff709SChao Yu 2274c8ff709SChao Yu if (dic->rlen != PAGE_SIZE << dic->log_cluster_size) { 2284c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo invalid rlen:%zu, " 2294c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 2304c8ff709SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 2314c8ff709SChao Yu dic->rlen, 2324c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 2334c8ff709SChao Yu return -EIO; 2344c8ff709SChao Yu } 2354c8ff709SChao Yu return 0; 2364c8ff709SChao Yu } 2374c8ff709SChao Yu 2384c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lzo_ops = { 2394c8ff709SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 2404c8ff709SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 2414c8ff709SChao Yu .compress_pages = lzo_compress_pages, 2424c8ff709SChao Yu .decompress_pages = lzo_decompress_pages, 2434c8ff709SChao Yu }; 2444c8ff709SChao Yu #endif 2454c8ff709SChao Yu 2464c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 2474c8ff709SChao Yu static int lz4_init_compress_ctx(struct compress_ctx *cc) 2484c8ff709SChao Yu { 2493fde13f8SChao Yu unsigned int size = LZ4_MEM_COMPRESS; 2503fde13f8SChao Yu 2513fde13f8SChao Yu #ifdef CONFIG_F2FS_FS_LZ4HC 2523fde13f8SChao Yu if (F2FS_I(cc->inode)->i_compress_flag >> COMPRESS_LEVEL_OFFSET) 2533fde13f8SChao Yu size = LZ4HC_MEM_COMPRESS; 2543fde13f8SChao Yu #endif 2553fde13f8SChao Yu 2563fde13f8SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), size, GFP_NOFS); 2574c8ff709SChao Yu if (!cc->private) 2584c8ff709SChao Yu return -ENOMEM; 2594c8ff709SChao Yu 260f6644143SChao Yu /* 261f6644143SChao Yu * we do not change cc->clen to LZ4_compressBound(inputsize) to 262f6644143SChao Yu * adapt worst compress case, because lz4 compressor can handle 263f6644143SChao Yu * output budget properly. 264f6644143SChao Yu */ 265f6644143SChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 2664c8ff709SChao Yu return 0; 2674c8ff709SChao Yu } 2684c8ff709SChao Yu 2694c8ff709SChao Yu static void lz4_destroy_compress_ctx(struct compress_ctx *cc) 2704c8ff709SChao Yu { 2714c8ff709SChao Yu kvfree(cc->private); 2724c8ff709SChao Yu cc->private = NULL; 2734c8ff709SChao Yu } 2744c8ff709SChao Yu 2753fde13f8SChao Yu #ifdef CONFIG_F2FS_FS_LZ4HC 2763fde13f8SChao Yu static int lz4hc_compress_pages(struct compress_ctx *cc) 2773fde13f8SChao Yu { 2783fde13f8SChao Yu unsigned char level = F2FS_I(cc->inode)->i_compress_flag >> 2793fde13f8SChao Yu COMPRESS_LEVEL_OFFSET; 2803fde13f8SChao Yu int len; 2813fde13f8SChao Yu 2823fde13f8SChao Yu if (level) 2833fde13f8SChao Yu len = LZ4_compress_HC(cc->rbuf, cc->cbuf->cdata, cc->rlen, 2843fde13f8SChao Yu cc->clen, level, cc->private); 2853fde13f8SChao Yu else 2863fde13f8SChao Yu len = LZ4_compress_default(cc->rbuf, cc->cbuf->cdata, cc->rlen, 2873fde13f8SChao Yu cc->clen, cc->private); 2883fde13f8SChao Yu if (!len) 2893fde13f8SChao Yu return -EAGAIN; 2903fde13f8SChao Yu 2913fde13f8SChao Yu cc->clen = len; 2923fde13f8SChao Yu return 0; 2933fde13f8SChao Yu } 2943fde13f8SChao Yu #endif 2953fde13f8SChao Yu 2964c8ff709SChao Yu static int lz4_compress_pages(struct compress_ctx *cc) 2974c8ff709SChao Yu { 2984c8ff709SChao Yu int len; 2994c8ff709SChao Yu 3003fde13f8SChao Yu #ifdef CONFIG_F2FS_FS_LZ4HC 3013fde13f8SChao Yu return lz4hc_compress_pages(cc); 3023fde13f8SChao Yu #endif 3034c8ff709SChao Yu len = LZ4_compress_default(cc->rbuf, cc->cbuf->cdata, cc->rlen, 3044c8ff709SChao Yu cc->clen, cc->private); 305f6644143SChao Yu if (!len) 306f6644143SChao Yu return -EAGAIN; 307f6644143SChao Yu 3084c8ff709SChao Yu cc->clen = len; 3094c8ff709SChao Yu return 0; 3104c8ff709SChao Yu } 3114c8ff709SChao Yu 3124c8ff709SChao Yu static int lz4_decompress_pages(struct decompress_io_ctx *dic) 3134c8ff709SChao Yu { 3144c8ff709SChao Yu int ret; 3154c8ff709SChao Yu 3164c8ff709SChao Yu ret = LZ4_decompress_safe(dic->cbuf->cdata, dic->rbuf, 3174c8ff709SChao Yu dic->clen, dic->rlen); 3184c8ff709SChao Yu if (ret < 0) { 3194c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 decompress failed, ret:%d\n", 3204c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 3214c8ff709SChao Yu return -EIO; 3224c8ff709SChao Yu } 3234c8ff709SChao Yu 3244c8ff709SChao Yu if (ret != PAGE_SIZE << dic->log_cluster_size) { 3254c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 invalid rlen:%zu, " 3264c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 3274c8ff709SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 3284c8ff709SChao Yu dic->rlen, 3294c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 3304c8ff709SChao Yu return -EIO; 3314c8ff709SChao Yu } 3324c8ff709SChao Yu return 0; 3334c8ff709SChao Yu } 3344c8ff709SChao Yu 3354c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lz4_ops = { 3364c8ff709SChao Yu .init_compress_ctx = lz4_init_compress_ctx, 3374c8ff709SChao Yu .destroy_compress_ctx = lz4_destroy_compress_ctx, 3384c8ff709SChao Yu .compress_pages = lz4_compress_pages, 3394c8ff709SChao Yu .decompress_pages = lz4_decompress_pages, 3404c8ff709SChao Yu }; 3414c8ff709SChao Yu #endif 3424c8ff709SChao Yu 34350cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 34450cfa66fSChao Yu #define F2FS_ZSTD_DEFAULT_CLEVEL 1 34550cfa66fSChao Yu 34650cfa66fSChao Yu static int zstd_init_compress_ctx(struct compress_ctx *cc) 34750cfa66fSChao Yu { 34850cfa66fSChao Yu ZSTD_parameters params; 34950cfa66fSChao Yu ZSTD_CStream *stream; 35050cfa66fSChao Yu void *workspace; 35150cfa66fSChao Yu unsigned int workspace_size; 3523fde13f8SChao Yu unsigned char level = F2FS_I(cc->inode)->i_compress_flag >> 3533fde13f8SChao Yu COMPRESS_LEVEL_OFFSET; 35450cfa66fSChao Yu 3553fde13f8SChao Yu if (!level) 3563fde13f8SChao Yu level = F2FS_ZSTD_DEFAULT_CLEVEL; 3573fde13f8SChao Yu 3583fde13f8SChao Yu params = ZSTD_getParams(level, cc->rlen, 0); 35950cfa66fSChao Yu workspace_size = ZSTD_CStreamWorkspaceBound(params.cParams); 36050cfa66fSChao Yu 36150cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 36250cfa66fSChao Yu workspace_size, GFP_NOFS); 36350cfa66fSChao Yu if (!workspace) 36450cfa66fSChao Yu return -ENOMEM; 36550cfa66fSChao Yu 36650cfa66fSChao Yu stream = ZSTD_initCStream(params, 0, workspace, workspace_size); 36750cfa66fSChao Yu if (!stream) { 36850cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_initCStream failed\n", 36950cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 37050cfa66fSChao Yu __func__); 37150cfa66fSChao Yu kvfree(workspace); 37250cfa66fSChao Yu return -EIO; 37350cfa66fSChao Yu } 37450cfa66fSChao Yu 37550cfa66fSChao Yu cc->private = workspace; 37650cfa66fSChao Yu cc->private2 = stream; 37750cfa66fSChao Yu 37850cfa66fSChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 37950cfa66fSChao Yu return 0; 38050cfa66fSChao Yu } 38150cfa66fSChao Yu 38250cfa66fSChao Yu static void zstd_destroy_compress_ctx(struct compress_ctx *cc) 38350cfa66fSChao Yu { 38450cfa66fSChao Yu kvfree(cc->private); 38550cfa66fSChao Yu cc->private = NULL; 38650cfa66fSChao Yu cc->private2 = NULL; 38750cfa66fSChao Yu } 38850cfa66fSChao Yu 38950cfa66fSChao Yu static int zstd_compress_pages(struct compress_ctx *cc) 39050cfa66fSChao Yu { 39150cfa66fSChao Yu ZSTD_CStream *stream = cc->private2; 39250cfa66fSChao Yu ZSTD_inBuffer inbuf; 39350cfa66fSChao Yu ZSTD_outBuffer outbuf; 39450cfa66fSChao Yu int src_size = cc->rlen; 39550cfa66fSChao Yu int dst_size = src_size - PAGE_SIZE - COMPRESS_HEADER_SIZE; 39650cfa66fSChao Yu int ret; 39750cfa66fSChao Yu 39850cfa66fSChao Yu inbuf.pos = 0; 39950cfa66fSChao Yu inbuf.src = cc->rbuf; 40050cfa66fSChao Yu inbuf.size = src_size; 40150cfa66fSChao Yu 40250cfa66fSChao Yu outbuf.pos = 0; 40350cfa66fSChao Yu outbuf.dst = cc->cbuf->cdata; 40450cfa66fSChao Yu outbuf.size = dst_size; 40550cfa66fSChao Yu 40650cfa66fSChao Yu ret = ZSTD_compressStream(stream, &outbuf, &inbuf); 40750cfa66fSChao Yu if (ZSTD_isError(ret)) { 40850cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_compressStream failed, ret: %d\n", 40950cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 41050cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 41150cfa66fSChao Yu return -EIO; 41250cfa66fSChao Yu } 41350cfa66fSChao Yu 41450cfa66fSChao Yu ret = ZSTD_endStream(stream, &outbuf); 41550cfa66fSChao Yu if (ZSTD_isError(ret)) { 41650cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_endStream returned %d\n", 41750cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 41850cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 41950cfa66fSChao Yu return -EIO; 42050cfa66fSChao Yu } 42150cfa66fSChao Yu 4221454c978SChao Yu /* 4231454c978SChao Yu * there is compressed data remained in intermediate buffer due to 4241454c978SChao Yu * no more space in cbuf.cdata 4251454c978SChao Yu */ 4261454c978SChao Yu if (ret) 4271454c978SChao Yu return -EAGAIN; 4281454c978SChao Yu 42950cfa66fSChao Yu cc->clen = outbuf.pos; 43050cfa66fSChao Yu return 0; 43150cfa66fSChao Yu } 43250cfa66fSChao Yu 43350cfa66fSChao Yu static int zstd_init_decompress_ctx(struct decompress_io_ctx *dic) 43450cfa66fSChao Yu { 43550cfa66fSChao Yu ZSTD_DStream *stream; 43650cfa66fSChao Yu void *workspace; 43750cfa66fSChao Yu unsigned int workspace_size; 4380e2b7385SChao Yu unsigned int max_window_size = 4390e2b7385SChao Yu MAX_COMPRESS_WINDOW_SIZE(dic->log_cluster_size); 44050cfa66fSChao Yu 4410e2b7385SChao Yu workspace_size = ZSTD_DStreamWorkspaceBound(max_window_size); 44250cfa66fSChao Yu 44350cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(dic->inode), 44450cfa66fSChao Yu workspace_size, GFP_NOFS); 44550cfa66fSChao Yu if (!workspace) 44650cfa66fSChao Yu return -ENOMEM; 44750cfa66fSChao Yu 4480e2b7385SChao Yu stream = ZSTD_initDStream(max_window_size, workspace, workspace_size); 44950cfa66fSChao Yu if (!stream) { 45050cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_initDStream failed\n", 45150cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 45250cfa66fSChao Yu __func__); 45350cfa66fSChao Yu kvfree(workspace); 45450cfa66fSChao Yu return -EIO; 45550cfa66fSChao Yu } 45650cfa66fSChao Yu 45750cfa66fSChao Yu dic->private = workspace; 45850cfa66fSChao Yu dic->private2 = stream; 45950cfa66fSChao Yu 46050cfa66fSChao Yu return 0; 46150cfa66fSChao Yu } 46250cfa66fSChao Yu 46350cfa66fSChao Yu static void zstd_destroy_decompress_ctx(struct decompress_io_ctx *dic) 46450cfa66fSChao Yu { 46550cfa66fSChao Yu kvfree(dic->private); 46650cfa66fSChao Yu dic->private = NULL; 46750cfa66fSChao Yu dic->private2 = NULL; 46850cfa66fSChao Yu } 46950cfa66fSChao Yu 47050cfa66fSChao Yu static int zstd_decompress_pages(struct decompress_io_ctx *dic) 47150cfa66fSChao Yu { 47250cfa66fSChao Yu ZSTD_DStream *stream = dic->private2; 47350cfa66fSChao Yu ZSTD_inBuffer inbuf; 47450cfa66fSChao Yu ZSTD_outBuffer outbuf; 47550cfa66fSChao Yu int ret; 47650cfa66fSChao Yu 47750cfa66fSChao Yu inbuf.pos = 0; 47850cfa66fSChao Yu inbuf.src = dic->cbuf->cdata; 47950cfa66fSChao Yu inbuf.size = dic->clen; 48050cfa66fSChao Yu 48150cfa66fSChao Yu outbuf.pos = 0; 48250cfa66fSChao Yu outbuf.dst = dic->rbuf; 48350cfa66fSChao Yu outbuf.size = dic->rlen; 48450cfa66fSChao Yu 48550cfa66fSChao Yu ret = ZSTD_decompressStream(stream, &outbuf, &inbuf); 48650cfa66fSChao Yu if (ZSTD_isError(ret)) { 48750cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_compressStream failed, ret: %d\n", 48850cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 48950cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 49050cfa66fSChao Yu return -EIO; 49150cfa66fSChao Yu } 49250cfa66fSChao Yu 49350cfa66fSChao Yu if (dic->rlen != outbuf.pos) { 49450cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD invalid rlen:%zu, " 49550cfa66fSChao Yu "expected:%lu\n", KERN_ERR, 49650cfa66fSChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 49750cfa66fSChao Yu __func__, dic->rlen, 49850cfa66fSChao Yu PAGE_SIZE << dic->log_cluster_size); 49950cfa66fSChao Yu return -EIO; 50050cfa66fSChao Yu } 50150cfa66fSChao Yu 50250cfa66fSChao Yu return 0; 50350cfa66fSChao Yu } 50450cfa66fSChao Yu 50550cfa66fSChao Yu static const struct f2fs_compress_ops f2fs_zstd_ops = { 50650cfa66fSChao Yu .init_compress_ctx = zstd_init_compress_ctx, 50750cfa66fSChao Yu .destroy_compress_ctx = zstd_destroy_compress_ctx, 50850cfa66fSChao Yu .compress_pages = zstd_compress_pages, 50950cfa66fSChao Yu .init_decompress_ctx = zstd_init_decompress_ctx, 51050cfa66fSChao Yu .destroy_decompress_ctx = zstd_destroy_decompress_ctx, 51150cfa66fSChao Yu .decompress_pages = zstd_decompress_pages, 51250cfa66fSChao Yu }; 51350cfa66fSChao Yu #endif 51450cfa66fSChao Yu 5156d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZO 5166d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZORLE 5176d92b201SChao Yu static int lzorle_compress_pages(struct compress_ctx *cc) 5186d92b201SChao Yu { 5196d92b201SChao Yu int ret; 5206d92b201SChao Yu 5216d92b201SChao Yu ret = lzorle1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 5226d92b201SChao Yu &cc->clen, cc->private); 5236d92b201SChao Yu if (ret != LZO_E_OK) { 5246d92b201SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo-rle compress failed, ret:%d\n", 5256d92b201SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 5266d92b201SChao Yu return -EIO; 5276d92b201SChao Yu } 5286d92b201SChao Yu return 0; 5296d92b201SChao Yu } 5306d92b201SChao Yu 5316d92b201SChao Yu static const struct f2fs_compress_ops f2fs_lzorle_ops = { 5326d92b201SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 5336d92b201SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 5346d92b201SChao Yu .compress_pages = lzorle_compress_pages, 5356d92b201SChao Yu .decompress_pages = lzo_decompress_pages, 5366d92b201SChao Yu }; 5376d92b201SChao Yu #endif 5386d92b201SChao Yu #endif 5396d92b201SChao Yu 5404c8ff709SChao Yu static const struct f2fs_compress_ops *f2fs_cops[COMPRESS_MAX] = { 5414c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 5424c8ff709SChao Yu &f2fs_lzo_ops, 5434c8ff709SChao Yu #else 5444c8ff709SChao Yu NULL, 5454c8ff709SChao Yu #endif 5464c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 5474c8ff709SChao Yu &f2fs_lz4_ops, 5484c8ff709SChao Yu #else 5494c8ff709SChao Yu NULL, 5504c8ff709SChao Yu #endif 55150cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 55250cfa66fSChao Yu &f2fs_zstd_ops, 55350cfa66fSChao Yu #else 55450cfa66fSChao Yu NULL, 55550cfa66fSChao Yu #endif 5566d92b201SChao Yu #if defined(CONFIG_F2FS_FS_LZO) && defined(CONFIG_F2FS_FS_LZORLE) 5576d92b201SChao Yu &f2fs_lzorle_ops, 5586d92b201SChao Yu #else 5596d92b201SChao Yu NULL, 5606d92b201SChao Yu #endif 5614c8ff709SChao Yu }; 5624c8ff709SChao Yu 5634c8ff709SChao Yu bool f2fs_is_compress_backend_ready(struct inode *inode) 5644c8ff709SChao Yu { 5654c8ff709SChao Yu if (!f2fs_compressed_file(inode)) 5664c8ff709SChao Yu return true; 5674c8ff709SChao Yu return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; 5684c8ff709SChao Yu } 5694c8ff709SChao Yu 57099bbe307SJaegeuk Kim static mempool_t *compress_page_pool; 5715e6bbde9SChao Yu static int num_compress_pages = 512; 5725e6bbde9SChao Yu module_param(num_compress_pages, uint, 0444); 5735e6bbde9SChao Yu MODULE_PARM_DESC(num_compress_pages, 5745e6bbde9SChao Yu "Number of intermediate compress pages to preallocate"); 5755e6bbde9SChao Yu 5765e6bbde9SChao Yu int f2fs_init_compress_mempool(void) 5775e6bbde9SChao Yu { 5785e6bbde9SChao Yu compress_page_pool = mempool_create_page_pool(num_compress_pages, 0); 5795e6bbde9SChao Yu if (!compress_page_pool) 5805e6bbde9SChao Yu return -ENOMEM; 5815e6bbde9SChao Yu 5825e6bbde9SChao Yu return 0; 5835e6bbde9SChao Yu } 5845e6bbde9SChao Yu 5855e6bbde9SChao Yu void f2fs_destroy_compress_mempool(void) 5865e6bbde9SChao Yu { 5875e6bbde9SChao Yu mempool_destroy(compress_page_pool); 5885e6bbde9SChao Yu } 5895e6bbde9SChao Yu 5905e6bbde9SChao Yu static struct page *f2fs_compress_alloc_page(void) 5914c8ff709SChao Yu { 5924c8ff709SChao Yu struct page *page; 5934c8ff709SChao Yu 5945e6bbde9SChao Yu page = mempool_alloc(compress_page_pool, GFP_NOFS); 5954c8ff709SChao Yu lock_page(page); 5965e6bbde9SChao Yu 5974c8ff709SChao Yu return page; 5984c8ff709SChao Yu } 5994c8ff709SChao Yu 6005e6bbde9SChao Yu static void f2fs_compress_free_page(struct page *page) 6015e6bbde9SChao Yu { 6025e6bbde9SChao Yu if (!page) 6035e6bbde9SChao Yu return; 6045e6bbde9SChao Yu set_page_private(page, (unsigned long)NULL); 6055e6bbde9SChao Yu ClearPagePrivate(page); 6065e6bbde9SChao Yu page->mapping = NULL; 6075e6bbde9SChao Yu unlock_page(page); 6085e6bbde9SChao Yu mempool_free(page, compress_page_pool); 6095e6bbde9SChao Yu } 6105e6bbde9SChao Yu 6116fcaebacSDaeho Jeong #define MAX_VMAP_RETRIES 3 6126fcaebacSDaeho Jeong 6136fcaebacSDaeho Jeong static void *f2fs_vmap(struct page **pages, unsigned int count) 6146fcaebacSDaeho Jeong { 6156fcaebacSDaeho Jeong int i; 6166fcaebacSDaeho Jeong void *buf = NULL; 6176fcaebacSDaeho Jeong 6186fcaebacSDaeho Jeong for (i = 0; i < MAX_VMAP_RETRIES; i++) { 6196fcaebacSDaeho Jeong buf = vm_map_ram(pages, count, -1); 6206fcaebacSDaeho Jeong if (buf) 6216fcaebacSDaeho Jeong break; 6226fcaebacSDaeho Jeong vm_unmap_aliases(); 6236fcaebacSDaeho Jeong } 6246fcaebacSDaeho Jeong return buf; 6256fcaebacSDaeho Jeong } 6266fcaebacSDaeho Jeong 6274c8ff709SChao Yu static int f2fs_compress_pages(struct compress_ctx *cc) 6284c8ff709SChao Yu { 6294c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(cc->inode); 6304c8ff709SChao Yu const struct f2fs_compress_ops *cops = 6314c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 63231083031SChao Yu unsigned int max_len, new_nr_cpages; 63331083031SChao Yu struct page **new_cpages; 634b28f047bSChao Yu u32 chksum = 0; 6354c8ff709SChao Yu int i, ret; 6364c8ff709SChao Yu 6374c8ff709SChao Yu trace_f2fs_compress_pages_start(cc->inode, cc->cluster_idx, 6384c8ff709SChao Yu cc->cluster_size, fi->i_compress_algorithm); 6394c8ff709SChao Yu 64023b1faaaSChao Yu if (cops->init_compress_ctx) { 6414c8ff709SChao Yu ret = cops->init_compress_ctx(cc); 6424c8ff709SChao Yu if (ret) 6434c8ff709SChao Yu goto out; 64423b1faaaSChao Yu } 6454c8ff709SChao Yu 6464c8ff709SChao Yu max_len = COMPRESS_HEADER_SIZE + cc->clen; 6474c8ff709SChao Yu cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE); 6484c8ff709SChao Yu 64931083031SChao Yu cc->cpages = page_array_alloc(cc->inode, cc->nr_cpages); 6504c8ff709SChao Yu if (!cc->cpages) { 6514c8ff709SChao Yu ret = -ENOMEM; 6524c8ff709SChao Yu goto destroy_compress_ctx; 6534c8ff709SChao Yu } 6544c8ff709SChao Yu 6554c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 6565e6bbde9SChao Yu cc->cpages[i] = f2fs_compress_alloc_page(); 6574c8ff709SChao Yu if (!cc->cpages[i]) { 6584c8ff709SChao Yu ret = -ENOMEM; 6594c8ff709SChao Yu goto out_free_cpages; 6604c8ff709SChao Yu } 6614c8ff709SChao Yu } 6624c8ff709SChao Yu 6636fcaebacSDaeho Jeong cc->rbuf = f2fs_vmap(cc->rpages, cc->cluster_size); 6644c8ff709SChao Yu if (!cc->rbuf) { 6654c8ff709SChao Yu ret = -ENOMEM; 6664c8ff709SChao Yu goto out_free_cpages; 6674c8ff709SChao Yu } 6684c8ff709SChao Yu 6696fcaebacSDaeho Jeong cc->cbuf = f2fs_vmap(cc->cpages, cc->nr_cpages); 6704c8ff709SChao Yu if (!cc->cbuf) { 6714c8ff709SChao Yu ret = -ENOMEM; 6724c8ff709SChao Yu goto out_vunmap_rbuf; 6734c8ff709SChao Yu } 6744c8ff709SChao Yu 6754c8ff709SChao Yu ret = cops->compress_pages(cc); 6764c8ff709SChao Yu if (ret) 6774c8ff709SChao Yu goto out_vunmap_cbuf; 6784c8ff709SChao Yu 6794c8ff709SChao Yu max_len = PAGE_SIZE * (cc->cluster_size - 1) - COMPRESS_HEADER_SIZE; 6804c8ff709SChao Yu 6814c8ff709SChao Yu if (cc->clen > max_len) { 6824c8ff709SChao Yu ret = -EAGAIN; 6834c8ff709SChao Yu goto out_vunmap_cbuf; 6844c8ff709SChao Yu } 6854c8ff709SChao Yu 6864c8ff709SChao Yu cc->cbuf->clen = cpu_to_le32(cc->clen); 6874c8ff709SChao Yu 688b28f047bSChao Yu if (fi->i_compress_flag & 1 << COMPRESS_CHKSUM) 689b28f047bSChao Yu chksum = f2fs_crc32(F2FS_I_SB(cc->inode), 690b28f047bSChao Yu cc->cbuf->cdata, cc->clen); 691b28f047bSChao Yu cc->cbuf->chksum = cpu_to_le32(chksum); 692b28f047bSChao Yu 6934c8ff709SChao Yu for (i = 0; i < COMPRESS_DATA_RESERVED_SIZE; i++) 6944c8ff709SChao Yu cc->cbuf->reserved[i] = cpu_to_le32(0); 6954c8ff709SChao Yu 69631083031SChao Yu new_nr_cpages = DIV_ROUND_UP(cc->clen + COMPRESS_HEADER_SIZE, PAGE_SIZE); 69731083031SChao Yu 69831083031SChao Yu /* Now we're going to cut unnecessary tail pages */ 69931083031SChao Yu new_cpages = page_array_alloc(cc->inode, new_nr_cpages); 70031083031SChao Yu if (!new_cpages) { 70131083031SChao Yu ret = -ENOMEM; 70231083031SChao Yu goto out_vunmap_cbuf; 70331083031SChao Yu } 7047fa6d598SEric Biggers 7057fa6d598SEric Biggers /* zero out any unused part of the last page */ 7067fa6d598SEric Biggers memset(&cc->cbuf->cdata[cc->clen], 0, 70731083031SChao Yu (new_nr_cpages * PAGE_SIZE) - 70831083031SChao Yu (cc->clen + COMPRESS_HEADER_SIZE)); 7097fa6d598SEric Biggers 7106fcaebacSDaeho Jeong vm_unmap_ram(cc->cbuf, cc->nr_cpages); 7116fcaebacSDaeho Jeong vm_unmap_ram(cc->rbuf, cc->cluster_size); 7124c8ff709SChao Yu 71331083031SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 71431083031SChao Yu if (i < new_nr_cpages) { 71531083031SChao Yu new_cpages[i] = cc->cpages[i]; 71631083031SChao Yu continue; 71731083031SChao Yu } 7185e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 7194c8ff709SChao Yu cc->cpages[i] = NULL; 7204c8ff709SChao Yu } 7214c8ff709SChao Yu 72223b1faaaSChao Yu if (cops->destroy_compress_ctx) 72309ff4801SChao Yu cops->destroy_compress_ctx(cc); 72409ff4801SChao Yu 72531083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 72631083031SChao Yu cc->cpages = new_cpages; 72731083031SChao Yu cc->nr_cpages = new_nr_cpages; 7284c8ff709SChao Yu 7294c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 7304c8ff709SChao Yu cc->clen, ret); 7314c8ff709SChao Yu return 0; 7324c8ff709SChao Yu 7334c8ff709SChao Yu out_vunmap_cbuf: 7346fcaebacSDaeho Jeong vm_unmap_ram(cc->cbuf, cc->nr_cpages); 7354c8ff709SChao Yu out_vunmap_rbuf: 7366fcaebacSDaeho Jeong vm_unmap_ram(cc->rbuf, cc->cluster_size); 7374c8ff709SChao Yu out_free_cpages: 7384c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 7394c8ff709SChao Yu if (cc->cpages[i]) 7405e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 7414c8ff709SChao Yu } 74231083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 7434c8ff709SChao Yu cc->cpages = NULL; 7444c8ff709SChao Yu destroy_compress_ctx: 74523b1faaaSChao Yu if (cops->destroy_compress_ctx) 7464c8ff709SChao Yu cops->destroy_compress_ctx(cc); 7474c8ff709SChao Yu out: 7484c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 7494c8ff709SChao Yu cc->clen, ret); 7504c8ff709SChao Yu return ret; 7514c8ff709SChao Yu } 7524c8ff709SChao Yu 7537f59b277SEric Biggers static void f2fs_decompress_cluster(struct decompress_io_ctx *dic) 7544c8ff709SChao Yu { 7554c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode); 7564c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(dic->inode); 7574c8ff709SChao Yu const struct f2fs_compress_ops *cops = 7584c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 7594c8ff709SChao Yu int ret; 760b2f57a8eSChao Yu int i; 7614c8ff709SChao Yu 7624c8ff709SChao Yu trace_f2fs_decompress_pages_start(dic->inode, dic->cluster_idx, 7634c8ff709SChao Yu dic->cluster_size, fi->i_compress_algorithm); 7644c8ff709SChao Yu 7654c8ff709SChao Yu if (dic->failed) { 7664c8ff709SChao Yu ret = -EIO; 7677f59b277SEric Biggers goto out_end_io; 7684c8ff709SChao Yu } 7694c8ff709SChao Yu 77031083031SChao Yu dic->tpages = page_array_alloc(dic->inode, dic->cluster_size); 771b2f57a8eSChao Yu if (!dic->tpages) { 772b2f57a8eSChao Yu ret = -ENOMEM; 7737f59b277SEric Biggers goto out_end_io; 774b2f57a8eSChao Yu } 775b2f57a8eSChao Yu 776b2f57a8eSChao Yu for (i = 0; i < dic->cluster_size; i++) { 777b2f57a8eSChao Yu if (dic->rpages[i]) { 778b2f57a8eSChao Yu dic->tpages[i] = dic->rpages[i]; 779b2f57a8eSChao Yu continue; 780b2f57a8eSChao Yu } 781b2f57a8eSChao Yu 782b2f57a8eSChao Yu dic->tpages[i] = f2fs_compress_alloc_page(); 783b2f57a8eSChao Yu if (!dic->tpages[i]) { 784b2f57a8eSChao Yu ret = -ENOMEM; 7857f59b277SEric Biggers goto out_end_io; 786b2f57a8eSChao Yu } 787b2f57a8eSChao Yu } 788b2f57a8eSChao Yu 78923b1faaaSChao Yu if (cops->init_decompress_ctx) { 79023b1faaaSChao Yu ret = cops->init_decompress_ctx(dic); 79123b1faaaSChao Yu if (ret) 7927f59b277SEric Biggers goto out_end_io; 79323b1faaaSChao Yu } 79423b1faaaSChao Yu 7956fcaebacSDaeho Jeong dic->rbuf = f2fs_vmap(dic->tpages, dic->cluster_size); 7964c8ff709SChao Yu if (!dic->rbuf) { 7974c8ff709SChao Yu ret = -ENOMEM; 7987f59b277SEric Biggers goto out_destroy_decompress_ctx; 7994c8ff709SChao Yu } 8004c8ff709SChao Yu 8016fcaebacSDaeho Jeong dic->cbuf = f2fs_vmap(dic->cpages, dic->nr_cpages); 8024c8ff709SChao Yu if (!dic->cbuf) { 8034c8ff709SChao Yu ret = -ENOMEM; 8044c8ff709SChao Yu goto out_vunmap_rbuf; 8054c8ff709SChao Yu } 8064c8ff709SChao Yu 8074c8ff709SChao Yu dic->clen = le32_to_cpu(dic->cbuf->clen); 8084c8ff709SChao Yu dic->rlen = PAGE_SIZE << dic->log_cluster_size; 8094c8ff709SChao Yu 8104c8ff709SChao Yu if (dic->clen > PAGE_SIZE * dic->nr_cpages - COMPRESS_HEADER_SIZE) { 8114c8ff709SChao Yu ret = -EFSCORRUPTED; 8124c8ff709SChao Yu goto out_vunmap_cbuf; 8134c8ff709SChao Yu } 8144c8ff709SChao Yu 8154c8ff709SChao Yu ret = cops->decompress_pages(dic); 8164c8ff709SChao Yu 81775e91c88SChao Yu if (!ret && (fi->i_compress_flag & 1 << COMPRESS_CHKSUM)) { 818b28f047bSChao Yu u32 provided = le32_to_cpu(dic->cbuf->chksum); 819b28f047bSChao Yu u32 calculated = f2fs_crc32(sbi, dic->cbuf->cdata, dic->clen); 820b28f047bSChao Yu 821b28f047bSChao Yu if (provided != calculated) { 822b28f047bSChao Yu if (!is_inode_flag_set(dic->inode, FI_COMPRESS_CORRUPT)) { 823b28f047bSChao Yu set_inode_flag(dic->inode, FI_COMPRESS_CORRUPT); 824b28f047bSChao Yu printk_ratelimited( 825b28f047bSChao Yu "%sF2FS-fs (%s): checksum invalid, nid = %lu, %x vs %x", 826b28f047bSChao Yu KERN_INFO, sbi->sb->s_id, dic->inode->i_ino, 827b28f047bSChao Yu provided, calculated); 828b28f047bSChao Yu } 829b28f047bSChao Yu set_sbi_flag(sbi, SBI_NEED_FSCK); 830b28f047bSChao Yu } 831b28f047bSChao Yu } 832b28f047bSChao Yu 8334c8ff709SChao Yu out_vunmap_cbuf: 8346fcaebacSDaeho Jeong vm_unmap_ram(dic->cbuf, dic->nr_cpages); 8354c8ff709SChao Yu out_vunmap_rbuf: 8366fcaebacSDaeho Jeong vm_unmap_ram(dic->rbuf, dic->cluster_size); 8377f59b277SEric Biggers out_destroy_decompress_ctx: 83823b1faaaSChao Yu if (cops->destroy_decompress_ctx) 83923b1faaaSChao Yu cops->destroy_decompress_ctx(dic); 8407f59b277SEric Biggers out_end_io: 8414c8ff709SChao Yu trace_f2fs_decompress_pages_end(dic->inode, dic->cluster_idx, 8424c8ff709SChao Yu dic->clen, ret); 8437f59b277SEric Biggers f2fs_decompress_end_io(dic, ret); 8447f59b277SEric Biggers } 8457f59b277SEric Biggers 8467f59b277SEric Biggers /* 8477f59b277SEric Biggers * This is called when a page of a compressed cluster has been read from disk 8487f59b277SEric Biggers * (or failed to be read from disk). It checks whether this page was the last 8497f59b277SEric Biggers * page being waited on in the cluster, and if so, it decompresses the cluster 8507f59b277SEric Biggers * (or in the case of a failure, cleans up without actually decompressing). 8517f59b277SEric Biggers */ 8527f59b277SEric Biggers void f2fs_end_read_compressed_page(struct page *page, bool failed) 8537f59b277SEric Biggers { 8547f59b277SEric Biggers struct decompress_io_ctx *dic = 8557f59b277SEric Biggers (struct decompress_io_ctx *)page_private(page); 8567f59b277SEric Biggers struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode); 8577f59b277SEric Biggers 8587f59b277SEric Biggers dec_page_count(sbi, F2FS_RD_DATA); 8597f59b277SEric Biggers 8607f59b277SEric Biggers if (failed) 8617f59b277SEric Biggers WRITE_ONCE(dic->failed, true); 8627f59b277SEric Biggers 8637f59b277SEric Biggers if (atomic_dec_and_test(&dic->remaining_pages)) 8647f59b277SEric Biggers f2fs_decompress_cluster(dic); 8654c8ff709SChao Yu } 8664c8ff709SChao Yu 8674c8ff709SChao Yu static bool is_page_in_cluster(struct compress_ctx *cc, pgoff_t index) 8684c8ff709SChao Yu { 8694c8ff709SChao Yu if (cc->cluster_idx == NULL_CLUSTER) 8704c8ff709SChao Yu return true; 8714c8ff709SChao Yu return cc->cluster_idx == cluster_idx(cc, index); 8724c8ff709SChao Yu } 8734c8ff709SChao Yu 8744c8ff709SChao Yu bool f2fs_cluster_is_empty(struct compress_ctx *cc) 8754c8ff709SChao Yu { 8764c8ff709SChao Yu return cc->nr_rpages == 0; 8774c8ff709SChao Yu } 8784c8ff709SChao Yu 8794c8ff709SChao Yu static bool f2fs_cluster_is_full(struct compress_ctx *cc) 8804c8ff709SChao Yu { 8814c8ff709SChao Yu return cc->cluster_size == cc->nr_rpages; 8824c8ff709SChao Yu } 8834c8ff709SChao Yu 8844c8ff709SChao Yu bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index) 8854c8ff709SChao Yu { 8864c8ff709SChao Yu if (f2fs_cluster_is_empty(cc)) 8874c8ff709SChao Yu return true; 8884c8ff709SChao Yu return is_page_in_cluster(cc, index); 8894c8ff709SChao Yu } 8904c8ff709SChao Yu 8914c8ff709SChao Yu static bool __cluster_may_compress(struct compress_ctx *cc) 8924c8ff709SChao Yu { 8934c8ff709SChao Yu loff_t i_size = i_size_read(cc->inode); 8944c8ff709SChao Yu unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE); 8954c8ff709SChao Yu int i; 8964c8ff709SChao Yu 8974c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 8984c8ff709SChao Yu struct page *page = cc->rpages[i]; 8994c8ff709SChao Yu 900*8af85f71SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), !page); 9014c8ff709SChao Yu 9024c8ff709SChao Yu /* beyond EOF */ 9034c8ff709SChao Yu if (page->index >= nr_pages) 9044c8ff709SChao Yu return false; 9054c8ff709SChao Yu } 9064c8ff709SChao Yu return true; 9074c8ff709SChao Yu } 9084c8ff709SChao Yu 9091a67cbe1SChao Yu static int __f2fs_cluster_blocks(struct compress_ctx *cc, bool compr) 9104c8ff709SChao Yu { 9114c8ff709SChao Yu struct dnode_of_data dn; 9124c8ff709SChao Yu int ret; 9134c8ff709SChao Yu 9144c8ff709SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 9154c8ff709SChao Yu ret = f2fs_get_dnode_of_data(&dn, start_idx_of_cluster(cc), 9164c8ff709SChao Yu LOOKUP_NODE); 9174c8ff709SChao Yu if (ret) { 9184c8ff709SChao Yu if (ret == -ENOENT) 9194c8ff709SChao Yu ret = 0; 9204c8ff709SChao Yu goto fail; 9214c8ff709SChao Yu } 9224c8ff709SChao Yu 9234c8ff709SChao Yu if (dn.data_blkaddr == COMPRESS_ADDR) { 9244c8ff709SChao Yu int i; 9254c8ff709SChao Yu 9264c8ff709SChao Yu ret = 1; 9274c8ff709SChao Yu for (i = 1; i < cc->cluster_size; i++) { 9284c8ff709SChao Yu block_t blkaddr; 9294c8ff709SChao Yu 930a2ced1ceSChao Yu blkaddr = data_blkaddr(dn.inode, 9314c8ff709SChao Yu dn.node_page, dn.ofs_in_node + i); 9321a67cbe1SChao Yu if (compr) { 9331a67cbe1SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 9341a67cbe1SChao Yu ret++; 9351a67cbe1SChao Yu } else { 9364c8ff709SChao Yu if (blkaddr != NULL_ADDR) 9374c8ff709SChao Yu ret++; 9384c8ff709SChao Yu } 9394c8ff709SChao Yu } 9401a67cbe1SChao Yu } 9414c8ff709SChao Yu fail: 9424c8ff709SChao Yu f2fs_put_dnode(&dn); 9434c8ff709SChao Yu return ret; 9444c8ff709SChao Yu } 9454c8ff709SChao Yu 9461a67cbe1SChao Yu /* return # of compressed blocks in compressed cluster */ 9471a67cbe1SChao Yu static int f2fs_compressed_blocks(struct compress_ctx *cc) 9481a67cbe1SChao Yu { 9491a67cbe1SChao Yu return __f2fs_cluster_blocks(cc, true); 9501a67cbe1SChao Yu } 9511a67cbe1SChao Yu 9521a67cbe1SChao Yu /* return # of valid blocks in compressed cluster */ 953d078319dSWang Xiaojun static int f2fs_cluster_blocks(struct compress_ctx *cc) 9541a67cbe1SChao Yu { 9551a67cbe1SChao Yu return __f2fs_cluster_blocks(cc, false); 9561a67cbe1SChao Yu } 9571a67cbe1SChao Yu 9584c8ff709SChao Yu int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index) 9594c8ff709SChao Yu { 9604c8ff709SChao Yu struct compress_ctx cc = { 9614c8ff709SChao Yu .inode = inode, 9624c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 9634c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 9644c8ff709SChao Yu .cluster_idx = index >> F2FS_I(inode)->i_log_cluster_size, 9654c8ff709SChao Yu }; 9664c8ff709SChao Yu 967d078319dSWang Xiaojun return f2fs_cluster_blocks(&cc); 9684c8ff709SChao Yu } 9694c8ff709SChao Yu 9704c8ff709SChao Yu static bool cluster_may_compress(struct compress_ctx *cc) 9714c8ff709SChao Yu { 972602a16d5SDaeho Jeong if (!f2fs_need_compress_data(cc->inode)) 9734c8ff709SChao Yu return false; 9744c8ff709SChao Yu if (f2fs_is_atomic_file(cc->inode)) 9754c8ff709SChao Yu return false; 9764c8ff709SChao Yu if (f2fs_is_mmap_file(cc->inode)) 9774c8ff709SChao Yu return false; 9784c8ff709SChao Yu if (!f2fs_cluster_is_full(cc)) 9794c8ff709SChao Yu return false; 980dc35d73aSChao Yu if (unlikely(f2fs_cp_error(F2FS_I_SB(cc->inode)))) 981dc35d73aSChao Yu return false; 9824c8ff709SChao Yu return __cluster_may_compress(cc); 9834c8ff709SChao Yu } 9844c8ff709SChao Yu 9854c8ff709SChao Yu static void set_cluster_writeback(struct compress_ctx *cc) 9864c8ff709SChao Yu { 9874c8ff709SChao Yu int i; 9884c8ff709SChao Yu 9894c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 9904c8ff709SChao Yu if (cc->rpages[i]) 9914c8ff709SChao Yu set_page_writeback(cc->rpages[i]); 9924c8ff709SChao Yu } 9934c8ff709SChao Yu } 9944c8ff709SChao Yu 9954c8ff709SChao Yu static void set_cluster_dirty(struct compress_ctx *cc) 9964c8ff709SChao Yu { 9974c8ff709SChao Yu int i; 9984c8ff709SChao Yu 9994c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 10004c8ff709SChao Yu if (cc->rpages[i]) 10014c8ff709SChao Yu set_page_dirty(cc->rpages[i]); 10024c8ff709SChao Yu } 10034c8ff709SChao Yu 10044c8ff709SChao Yu static int prepare_compress_overwrite(struct compress_ctx *cc, 10054c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 10064c8ff709SChao Yu { 10074c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 10084c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 10094c8ff709SChao Yu struct page *page; 10104c8ff709SChao Yu struct dnode_of_data dn; 10114c8ff709SChao Yu sector_t last_block_in_bio; 10124c8ff709SChao Yu unsigned fgp_flag = FGP_LOCK | FGP_WRITE | FGP_CREAT; 10134c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 10144c8ff709SChao Yu int i, ret; 10154c8ff709SChao Yu bool prealloc; 10164c8ff709SChao Yu 10174c8ff709SChao Yu retry: 1018d078319dSWang Xiaojun ret = f2fs_cluster_blocks(cc); 10194c8ff709SChao Yu if (ret <= 0) 10204c8ff709SChao Yu return ret; 10214c8ff709SChao Yu 10224c8ff709SChao Yu /* compressed case */ 10234c8ff709SChao Yu prealloc = (ret < cc->cluster_size); 10244c8ff709SChao Yu 10254c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 10264c8ff709SChao Yu if (ret) 10274c8ff709SChao Yu return ret; 10284c8ff709SChao Yu 10294c8ff709SChao Yu /* keep page reference to avoid page reclaim */ 10304c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 10314c8ff709SChao Yu page = f2fs_pagecache_get_page(mapping, start_idx + i, 10324c8ff709SChao Yu fgp_flag, GFP_NOFS); 10334c8ff709SChao Yu if (!page) { 10344c8ff709SChao Yu ret = -ENOMEM; 10354c8ff709SChao Yu goto unlock_pages; 10364c8ff709SChao Yu } 10374c8ff709SChao Yu 10384c8ff709SChao Yu if (PageUptodate(page)) 10394c8ff709SChao Yu unlock_page(page); 10404c8ff709SChao Yu else 10414c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 10424c8ff709SChao Yu } 10434c8ff709SChao Yu 10444c8ff709SChao Yu if (!f2fs_cluster_is_empty(cc)) { 10454c8ff709SChao Yu struct bio *bio = NULL; 10464c8ff709SChao Yu 10474c8ff709SChao Yu ret = f2fs_read_multi_pages(cc, &bio, cc->cluster_size, 10480683728aSChao Yu &last_block_in_bio, false, true); 10494c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 10504c8ff709SChao Yu if (ret) 10514c8ff709SChao Yu goto release_pages; 10524c8ff709SChao Yu if (bio) 10534c8ff709SChao Yu f2fs_submit_bio(sbi, bio, DATA); 10544c8ff709SChao Yu 10554c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 10564c8ff709SChao Yu if (ret) 10574c8ff709SChao Yu goto release_pages; 10584c8ff709SChao Yu } 10594c8ff709SChao Yu 10604c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 10614c8ff709SChao Yu f2fs_bug_on(sbi, cc->rpages[i]); 10624c8ff709SChao Yu 10634c8ff709SChao Yu page = find_lock_page(mapping, start_idx + i); 10644c8ff709SChao Yu f2fs_bug_on(sbi, !page); 10654c8ff709SChao Yu 10664c8ff709SChao Yu f2fs_wait_on_page_writeback(page, DATA, true, true); 10674c8ff709SChao Yu 10684c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 10694c8ff709SChao Yu f2fs_put_page(page, 0); 10704c8ff709SChao Yu 10714c8ff709SChao Yu if (!PageUptodate(page)) { 10724c8ff709SChao Yu f2fs_unlock_rpages(cc, i + 1); 1073bc67c5d0SChao Yu f2fs_put_rpages_mapping(mapping, start_idx, 10744c8ff709SChao Yu cc->cluster_size); 10754c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 10764c8ff709SChao Yu goto retry; 10774c8ff709SChao Yu } 10784c8ff709SChao Yu } 10794c8ff709SChao Yu 10804c8ff709SChao Yu if (prealloc) { 10810ef81833SChao Yu f2fs_do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true); 10824c8ff709SChao Yu 10834c8ff709SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 10844c8ff709SChao Yu 10854c8ff709SChao Yu for (i = cc->cluster_size - 1; i > 0; i--) { 10864c8ff709SChao Yu ret = f2fs_get_block(&dn, start_idx + i); 10874c8ff709SChao Yu if (ret) { 10884c8ff709SChao Yu i = cc->cluster_size; 10894c8ff709SChao Yu break; 10904c8ff709SChao Yu } 10914c8ff709SChao Yu 10924c8ff709SChao Yu if (dn.data_blkaddr != NEW_ADDR) 10934c8ff709SChao Yu break; 10944c8ff709SChao Yu } 10954c8ff709SChao Yu 10960ef81833SChao Yu f2fs_do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false); 10974c8ff709SChao Yu } 10984c8ff709SChao Yu 10994c8ff709SChao Yu if (likely(!ret)) { 11004c8ff709SChao Yu *fsdata = cc->rpages; 11014c8ff709SChao Yu *pagep = cc->rpages[offset_in_cluster(cc, index)]; 11024c8ff709SChao Yu return cc->cluster_size; 11034c8ff709SChao Yu } 11044c8ff709SChao Yu 11054c8ff709SChao Yu unlock_pages: 11064c8ff709SChao Yu f2fs_unlock_rpages(cc, i); 11074c8ff709SChao Yu release_pages: 1108bc67c5d0SChao Yu f2fs_put_rpages_mapping(mapping, start_idx, i); 11094c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 11104c8ff709SChao Yu return ret; 11114c8ff709SChao Yu } 11124c8ff709SChao Yu 11134c8ff709SChao Yu int f2fs_prepare_compress_overwrite(struct inode *inode, 11144c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 11154c8ff709SChao Yu { 11164c8ff709SChao Yu struct compress_ctx cc = { 11174c8ff709SChao Yu .inode = inode, 11184c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 11194c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 11204c8ff709SChao Yu .cluster_idx = index >> F2FS_I(inode)->i_log_cluster_size, 11214c8ff709SChao Yu .rpages = NULL, 11224c8ff709SChao Yu .nr_rpages = 0, 11234c8ff709SChao Yu }; 11244c8ff709SChao Yu 11254c8ff709SChao Yu return prepare_compress_overwrite(&cc, pagep, index, fsdata); 11264c8ff709SChao Yu } 11274c8ff709SChao Yu 11284c8ff709SChao Yu bool f2fs_compress_write_end(struct inode *inode, void *fsdata, 11294c8ff709SChao Yu pgoff_t index, unsigned copied) 11304c8ff709SChao Yu 11314c8ff709SChao Yu { 11324c8ff709SChao Yu struct compress_ctx cc = { 113331083031SChao Yu .inode = inode, 11344c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 11354c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 11364c8ff709SChao Yu .rpages = fsdata, 11374c8ff709SChao Yu }; 11384c8ff709SChao Yu bool first_index = (index == cc.rpages[0]->index); 11394c8ff709SChao Yu 11404c8ff709SChao Yu if (copied) 11414c8ff709SChao Yu set_cluster_dirty(&cc); 11424c8ff709SChao Yu 11434c8ff709SChao Yu f2fs_put_rpages_wbc(&cc, NULL, false, 1); 11444c8ff709SChao Yu f2fs_destroy_compress_ctx(&cc); 11454c8ff709SChao Yu 11464c8ff709SChao Yu return first_index; 11474c8ff709SChao Yu } 11484c8ff709SChao Yu 11493265d3dbSChao Yu int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock) 11503265d3dbSChao Yu { 11513265d3dbSChao Yu void *fsdata = NULL; 11523265d3dbSChao Yu struct page *pagep; 11533265d3dbSChao Yu int log_cluster_size = F2FS_I(inode)->i_log_cluster_size; 11543265d3dbSChao Yu pgoff_t start_idx = from >> (PAGE_SHIFT + log_cluster_size) << 11553265d3dbSChao Yu log_cluster_size; 11563265d3dbSChao Yu int err; 11573265d3dbSChao Yu 11583265d3dbSChao Yu err = f2fs_is_compressed_cluster(inode, start_idx); 11593265d3dbSChao Yu if (err < 0) 11603265d3dbSChao Yu return err; 11613265d3dbSChao Yu 11623265d3dbSChao Yu /* truncate normal cluster */ 11633265d3dbSChao Yu if (!err) 11643265d3dbSChao Yu return f2fs_do_truncate_blocks(inode, from, lock); 11653265d3dbSChao Yu 11663265d3dbSChao Yu /* truncate compressed cluster */ 11673265d3dbSChao Yu err = f2fs_prepare_compress_overwrite(inode, &pagep, 11683265d3dbSChao Yu start_idx, &fsdata); 11693265d3dbSChao Yu 11703265d3dbSChao Yu /* should not be a normal cluster */ 11713265d3dbSChao Yu f2fs_bug_on(F2FS_I_SB(inode), err == 0); 11723265d3dbSChao Yu 11733265d3dbSChao Yu if (err <= 0) 11743265d3dbSChao Yu return err; 11753265d3dbSChao Yu 11763265d3dbSChao Yu if (err > 0) { 11773265d3dbSChao Yu struct page **rpages = fsdata; 11783265d3dbSChao Yu int cluster_size = F2FS_I(inode)->i_cluster_size; 11793265d3dbSChao Yu int i; 11803265d3dbSChao Yu 11813265d3dbSChao Yu for (i = cluster_size - 1; i >= 0; i--) { 11823265d3dbSChao Yu loff_t start = rpages[i]->index << PAGE_SHIFT; 11833265d3dbSChao Yu 11843265d3dbSChao Yu if (from <= start) { 11853265d3dbSChao Yu zero_user_segment(rpages[i], 0, PAGE_SIZE); 11863265d3dbSChao Yu } else { 11873265d3dbSChao Yu zero_user_segment(rpages[i], from - start, 11883265d3dbSChao Yu PAGE_SIZE); 11893265d3dbSChao Yu break; 11903265d3dbSChao Yu } 11913265d3dbSChao Yu } 11923265d3dbSChao Yu 11933265d3dbSChao Yu f2fs_compress_write_end(inode, fsdata, start_idx, true); 11943265d3dbSChao Yu } 11953265d3dbSChao Yu return 0; 11963265d3dbSChao Yu } 11973265d3dbSChao Yu 11984c8ff709SChao Yu static int f2fs_write_compressed_pages(struct compress_ctx *cc, 11994c8ff709SChao Yu int *submitted, 12004c8ff709SChao Yu struct writeback_control *wbc, 12014c8ff709SChao Yu enum iostat_type io_type) 12024c8ff709SChao Yu { 12034c8ff709SChao Yu struct inode *inode = cc->inode; 12044c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 12054c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(inode); 12064c8ff709SChao Yu struct f2fs_io_info fio = { 12074c8ff709SChao Yu .sbi = sbi, 12084c8ff709SChao Yu .ino = cc->inode->i_ino, 12094c8ff709SChao Yu .type = DATA, 12104c8ff709SChao Yu .op = REQ_OP_WRITE, 12114c8ff709SChao Yu .op_flags = wbc_to_write_flags(wbc), 12124c8ff709SChao Yu .old_blkaddr = NEW_ADDR, 12134c8ff709SChao Yu .page = NULL, 12144c8ff709SChao Yu .encrypted_page = NULL, 12154c8ff709SChao Yu .compressed_page = NULL, 12164c8ff709SChao Yu .submitted = false, 12174c8ff709SChao Yu .io_type = io_type, 12184c8ff709SChao Yu .io_wbc = wbc, 121927aacd28SSatya Tangirala .encrypted = fscrypt_inode_uses_fs_layer_crypto(cc->inode), 12204c8ff709SChao Yu }; 12214c8ff709SChao Yu struct dnode_of_data dn; 12224c8ff709SChao Yu struct node_info ni; 12234c8ff709SChao Yu struct compress_io_ctx *cic; 12244c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 12254c8ff709SChao Yu unsigned int last_index = cc->cluster_size - 1; 12264c8ff709SChao Yu loff_t psize; 12274c8ff709SChao Yu int i, err; 12284c8ff709SChao Yu 122979963d96SChao Yu if (IS_NOQUOTA(inode)) { 123079963d96SChao Yu /* 123179963d96SChao Yu * We need to wait for node_write to avoid block allocation during 123279963d96SChao Yu * checkpoint. This can only happen to quota writes which can cause 123379963d96SChao Yu * the below discard race condition. 123479963d96SChao Yu */ 123579963d96SChao Yu down_read(&sbi->node_write); 123679963d96SChao Yu } else if (!f2fs_trylock_op(sbi)) { 123731083031SChao Yu goto out_free; 123879963d96SChao Yu } 12394c8ff709SChao Yu 1240df77fbd8SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 12414c8ff709SChao Yu 12424c8ff709SChao Yu err = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE); 12434c8ff709SChao Yu if (err) 12444c8ff709SChao Yu goto out_unlock_op; 12454c8ff709SChao Yu 12464c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1247a2ced1ceSChao Yu if (data_blkaddr(dn.inode, dn.node_page, 12484c8ff709SChao Yu dn.ofs_in_node + i) == NULL_ADDR) 12494c8ff709SChao Yu goto out_put_dnode; 12504c8ff709SChao Yu } 12514c8ff709SChao Yu 12524c8ff709SChao Yu psize = (loff_t)(cc->rpages[last_index]->index + 1) << PAGE_SHIFT; 12534c8ff709SChao Yu 12544c8ff709SChao Yu err = f2fs_get_node_info(fio.sbi, dn.nid, &ni); 12554c8ff709SChao Yu if (err) 12564c8ff709SChao Yu goto out_put_dnode; 12574c8ff709SChao Yu 12584c8ff709SChao Yu fio.version = ni.version; 12594c8ff709SChao Yu 1260c68d6c88SChao Yu cic = kmem_cache_zalloc(cic_entry_slab, GFP_NOFS); 12614c8ff709SChao Yu if (!cic) 12624c8ff709SChao Yu goto out_put_dnode; 12634c8ff709SChao Yu 12644c8ff709SChao Yu cic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 12654c8ff709SChao Yu cic->inode = inode; 1266e6c3948dSChao Yu atomic_set(&cic->pending_pages, cc->nr_cpages); 126731083031SChao Yu cic->rpages = page_array_alloc(cc->inode, cc->cluster_size); 12684c8ff709SChao Yu if (!cic->rpages) 12694c8ff709SChao Yu goto out_put_cic; 12704c8ff709SChao Yu 12714c8ff709SChao Yu cic->nr_rpages = cc->cluster_size; 12724c8ff709SChao Yu 12734c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 12744c8ff709SChao Yu f2fs_set_compressed_page(cc->cpages[i], inode, 1275887347a0SChao Yu cc->rpages[i + 1]->index, cic); 12764c8ff709SChao Yu fio.compressed_page = cc->cpages[i]; 1277f567adb0SChao Yu 1278f567adb0SChao Yu fio.old_blkaddr = data_blkaddr(dn.inode, dn.node_page, 1279f567adb0SChao Yu dn.ofs_in_node + i + 1); 1280f567adb0SChao Yu 1281f567adb0SChao Yu /* wait for GCed page writeback via META_MAPPING */ 1282f567adb0SChao Yu f2fs_wait_on_block_writeback(inode, fio.old_blkaddr); 1283f567adb0SChao Yu 12844c8ff709SChao Yu if (fio.encrypted) { 12854c8ff709SChao Yu fio.page = cc->rpages[i + 1]; 12864c8ff709SChao Yu err = f2fs_encrypt_one_page(&fio); 12874c8ff709SChao Yu if (err) 12884c8ff709SChao Yu goto out_destroy_crypt; 12894c8ff709SChao Yu cc->cpages[i] = fio.encrypted_page; 12904c8ff709SChao Yu } 12914c8ff709SChao Yu } 12924c8ff709SChao Yu 12934c8ff709SChao Yu set_cluster_writeback(cc); 12944c8ff709SChao Yu 12954c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 12964c8ff709SChao Yu cic->rpages[i] = cc->rpages[i]; 12974c8ff709SChao Yu 12984c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++, dn.ofs_in_node++) { 12994c8ff709SChao Yu block_t blkaddr; 13004c8ff709SChao Yu 1301a2ced1ceSChao Yu blkaddr = f2fs_data_blkaddr(&dn); 130295978caaSChao Yu fio.page = cc->rpages[i]; 13034c8ff709SChao Yu fio.old_blkaddr = blkaddr; 13044c8ff709SChao Yu 13054c8ff709SChao Yu /* cluster header */ 13064c8ff709SChao Yu if (i == 0) { 13074c8ff709SChao Yu if (blkaddr == COMPRESS_ADDR) 13084c8ff709SChao Yu fio.compr_blocks++; 13094c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 13104c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 13114c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR); 13124c8ff709SChao Yu goto unlock_continue; 13134c8ff709SChao Yu } 13144c8ff709SChao Yu 13154c8ff709SChao Yu if (fio.compr_blocks && __is_valid_data_blkaddr(blkaddr)) 13164c8ff709SChao Yu fio.compr_blocks++; 13174c8ff709SChao Yu 13184c8ff709SChao Yu if (i > cc->nr_cpages) { 13194c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) { 13204c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 13214c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, NEW_ADDR); 13224c8ff709SChao Yu } 13234c8ff709SChao Yu goto unlock_continue; 13244c8ff709SChao Yu } 13254c8ff709SChao Yu 13264c8ff709SChao Yu f2fs_bug_on(fio.sbi, blkaddr == NULL_ADDR); 13274c8ff709SChao Yu 13284c8ff709SChao Yu if (fio.encrypted) 13294c8ff709SChao Yu fio.encrypted_page = cc->cpages[i - 1]; 13304c8ff709SChao Yu else 13314c8ff709SChao Yu fio.compressed_page = cc->cpages[i - 1]; 13324c8ff709SChao Yu 13334c8ff709SChao Yu cc->cpages[i - 1] = NULL; 13344c8ff709SChao Yu f2fs_outplace_write_data(&dn, &fio); 13354c8ff709SChao Yu (*submitted)++; 13364c8ff709SChao Yu unlock_continue: 13374c8ff709SChao Yu inode_dec_dirty_pages(cc->inode); 13384c8ff709SChao Yu unlock_page(fio.page); 13394c8ff709SChao Yu } 13404c8ff709SChao Yu 13414c8ff709SChao Yu if (fio.compr_blocks) 13424c8ff709SChao Yu f2fs_i_compr_blocks_update(inode, fio.compr_blocks - 1, false); 13434c8ff709SChao Yu f2fs_i_compr_blocks_update(inode, cc->nr_cpages, true); 13445ac443e2SDaeho Jeong add_compr_block_stat(inode, cc->nr_cpages); 13454c8ff709SChao Yu 13464c8ff709SChao Yu set_inode_flag(cc->inode, FI_APPEND_WRITE); 13474c8ff709SChao Yu if (cc->cluster_idx == 0) 13484c8ff709SChao Yu set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN); 13494c8ff709SChao Yu 13504c8ff709SChao Yu f2fs_put_dnode(&dn); 135179963d96SChao Yu if (IS_NOQUOTA(inode)) 135279963d96SChao Yu up_read(&sbi->node_write); 135379963d96SChao Yu else 13544c8ff709SChao Yu f2fs_unlock_op(sbi); 13554c8ff709SChao Yu 1356c10c9820SChao Yu spin_lock(&fi->i_size_lock); 13574c8ff709SChao Yu if (fi->last_disk_size < psize) 13584c8ff709SChao Yu fi->last_disk_size = psize; 1359c10c9820SChao Yu spin_unlock(&fi->i_size_lock); 13604c8ff709SChao Yu 13614c8ff709SChao Yu f2fs_put_rpages(cc); 136231083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 136331083031SChao Yu cc->cpages = NULL; 13644c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 13654c8ff709SChao Yu return 0; 13664c8ff709SChao Yu 13674c8ff709SChao Yu out_destroy_crypt: 136831083031SChao Yu page_array_free(cc->inode, cic->rpages, cc->cluster_size); 13694c8ff709SChao Yu 13704c8ff709SChao Yu for (--i; i >= 0; i--) 13714c8ff709SChao Yu fscrypt_finalize_bounce_page(&cc->cpages[i]); 13724c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 13734c8ff709SChao Yu if (!cc->cpages[i]) 13744c8ff709SChao Yu continue; 13754c8ff709SChao Yu f2fs_put_page(cc->cpages[i], 1); 13764c8ff709SChao Yu } 13774c8ff709SChao Yu out_put_cic: 1378c68d6c88SChao Yu kmem_cache_free(cic_entry_slab, cic); 13794c8ff709SChao Yu out_put_dnode: 13804c8ff709SChao Yu f2fs_put_dnode(&dn); 13814c8ff709SChao Yu out_unlock_op: 138279963d96SChao Yu if (IS_NOQUOTA(inode)) 138379963d96SChao Yu up_read(&sbi->node_write); 138479963d96SChao Yu else 13854c8ff709SChao Yu f2fs_unlock_op(sbi); 138631083031SChao Yu out_free: 138731083031SChao Yu page_array_free(cc->inode, cc->cpages, cc->nr_cpages); 138831083031SChao Yu cc->cpages = NULL; 13894c8ff709SChao Yu return -EAGAIN; 13904c8ff709SChao Yu } 13914c8ff709SChao Yu 13924c8ff709SChao Yu void f2fs_compress_write_end_io(struct bio *bio, struct page *page) 13934c8ff709SChao Yu { 13944c8ff709SChao Yu struct f2fs_sb_info *sbi = bio->bi_private; 13954c8ff709SChao Yu struct compress_io_ctx *cic = 13964c8ff709SChao Yu (struct compress_io_ctx *)page_private(page); 13974c8ff709SChao Yu int i; 13984c8ff709SChao Yu 13994c8ff709SChao Yu if (unlikely(bio->bi_status)) 14004c8ff709SChao Yu mapping_set_error(cic->inode->i_mapping, -EIO); 14014c8ff709SChao Yu 14025e6bbde9SChao Yu f2fs_compress_free_page(page); 14034c8ff709SChao Yu 14044c8ff709SChao Yu dec_page_count(sbi, F2FS_WB_DATA); 14054c8ff709SChao Yu 1406e6c3948dSChao Yu if (atomic_dec_return(&cic->pending_pages)) 14074c8ff709SChao Yu return; 14084c8ff709SChao Yu 14094c8ff709SChao Yu for (i = 0; i < cic->nr_rpages; i++) { 14104c8ff709SChao Yu WARN_ON(!cic->rpages[i]); 14114c8ff709SChao Yu clear_cold_data(cic->rpages[i]); 14124c8ff709SChao Yu end_page_writeback(cic->rpages[i]); 14134c8ff709SChao Yu } 14144c8ff709SChao Yu 141531083031SChao Yu page_array_free(cic->inode, cic->rpages, cic->nr_rpages); 1416c68d6c88SChao Yu kmem_cache_free(cic_entry_slab, cic); 14174c8ff709SChao Yu } 14184c8ff709SChao Yu 14194c8ff709SChao Yu static int f2fs_write_raw_pages(struct compress_ctx *cc, 14204c8ff709SChao Yu int *submitted, 14214c8ff709SChao Yu struct writeback_control *wbc, 14224c8ff709SChao Yu enum iostat_type io_type) 14234c8ff709SChao Yu { 14244c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 14254c8ff709SChao Yu int _submitted, compr_blocks, ret; 14264c8ff709SChao Yu int i = -1, err = 0; 14274c8ff709SChao Yu 14284c8ff709SChao Yu compr_blocks = f2fs_compressed_blocks(cc); 14294c8ff709SChao Yu if (compr_blocks < 0) { 14304c8ff709SChao Yu err = compr_blocks; 14314c8ff709SChao Yu goto out_err; 14324c8ff709SChao Yu } 14334c8ff709SChao Yu 14344c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 14354c8ff709SChao Yu if (!cc->rpages[i]) 14364c8ff709SChao Yu continue; 14374c8ff709SChao Yu retry_write: 14384c8ff709SChao Yu if (cc->rpages[i]->mapping != mapping) { 14394c8ff709SChao Yu unlock_page(cc->rpages[i]); 14404c8ff709SChao Yu continue; 14414c8ff709SChao Yu } 14424c8ff709SChao Yu 14434c8ff709SChao Yu BUG_ON(!PageLocked(cc->rpages[i])); 14444c8ff709SChao Yu 14454c8ff709SChao Yu ret = f2fs_write_single_data_page(cc->rpages[i], &_submitted, 14464c8ff709SChao Yu NULL, NULL, wbc, io_type, 14473afae09fSChao Yu compr_blocks, false); 14484c8ff709SChao Yu if (ret) { 14494c8ff709SChao Yu if (ret == AOP_WRITEPAGE_ACTIVATE) { 14504c8ff709SChao Yu unlock_page(cc->rpages[i]); 14514c8ff709SChao Yu ret = 0; 14524c8ff709SChao Yu } else if (ret == -EAGAIN) { 1453466357dcSChao Yu /* 1454466357dcSChao Yu * for quota file, just redirty left pages to 1455466357dcSChao Yu * avoid deadlock caused by cluster update race 1456466357dcSChao Yu * from foreground operation. 1457466357dcSChao Yu */ 1458466357dcSChao Yu if (IS_NOQUOTA(cc->inode)) { 1459466357dcSChao Yu err = 0; 1460466357dcSChao Yu goto out_err; 1461466357dcSChao Yu } 14624c8ff709SChao Yu ret = 0; 14634c8ff709SChao Yu cond_resched(); 14645df7731fSChao Yu congestion_wait(BLK_RW_ASYNC, 14655df7731fSChao Yu DEFAULT_IO_TIMEOUT); 14664c8ff709SChao Yu lock_page(cc->rpages[i]); 1467eb1353cfSChao Yu 1468eb1353cfSChao Yu if (!PageDirty(cc->rpages[i])) { 1469eb1353cfSChao Yu unlock_page(cc->rpages[i]); 1470eb1353cfSChao Yu continue; 1471eb1353cfSChao Yu } 1472eb1353cfSChao Yu 14734c8ff709SChao Yu clear_page_dirty_for_io(cc->rpages[i]); 14744c8ff709SChao Yu goto retry_write; 14754c8ff709SChao Yu } 14764c8ff709SChao Yu err = ret; 1477466357dcSChao Yu goto out_err; 14784c8ff709SChao Yu } 14794c8ff709SChao Yu 14804c8ff709SChao Yu *submitted += _submitted; 14814c8ff709SChao Yu } 14823afae09fSChao Yu 14833afae09fSChao Yu f2fs_balance_fs(F2FS_M_SB(mapping), true); 14843afae09fSChao Yu 14854c8ff709SChao Yu return 0; 14864c8ff709SChao Yu out_err: 14874c8ff709SChao Yu for (++i; i < cc->cluster_size; i++) { 14884c8ff709SChao Yu if (!cc->rpages[i]) 14894c8ff709SChao Yu continue; 14904c8ff709SChao Yu redirty_page_for_writepage(wbc, cc->rpages[i]); 14914c8ff709SChao Yu unlock_page(cc->rpages[i]); 14924c8ff709SChao Yu } 14934c8ff709SChao Yu return err; 14944c8ff709SChao Yu } 14954c8ff709SChao Yu 14964c8ff709SChao Yu int f2fs_write_multi_pages(struct compress_ctx *cc, 14974c8ff709SChao Yu int *submitted, 14984c8ff709SChao Yu struct writeback_control *wbc, 14994c8ff709SChao Yu enum iostat_type io_type) 15004c8ff709SChao Yu { 15014c8ff709SChao Yu int err; 15024c8ff709SChao Yu 15034c8ff709SChao Yu *submitted = 0; 15044c8ff709SChao Yu if (cluster_may_compress(cc)) { 15054c8ff709SChao Yu err = f2fs_compress_pages(cc); 15064c8ff709SChao Yu if (err == -EAGAIN) { 15074c8ff709SChao Yu goto write; 15084c8ff709SChao Yu } else if (err) { 15094c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, true, 1); 15104c8ff709SChao Yu goto destroy_out; 15114c8ff709SChao Yu } 15124c8ff709SChao Yu 15134c8ff709SChao Yu err = f2fs_write_compressed_pages(cc, submitted, 15144c8ff709SChao Yu wbc, io_type); 15154c8ff709SChao Yu if (!err) 15164c8ff709SChao Yu return 0; 15174c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), err != -EAGAIN); 15184c8ff709SChao Yu } 15194c8ff709SChao Yu write: 15204c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), *submitted); 15214c8ff709SChao Yu 15224c8ff709SChao Yu err = f2fs_write_raw_pages(cc, submitted, wbc, io_type); 15234c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, false, 0); 15244c8ff709SChao Yu destroy_out: 15254c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 15264c8ff709SChao Yu return err; 15274c8ff709SChao Yu } 15284c8ff709SChao Yu 15297f59b277SEric Biggers static void f2fs_free_dic(struct decompress_io_ctx *dic); 15307f59b277SEric Biggers 15314c8ff709SChao Yu struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc) 15324c8ff709SChao Yu { 15334c8ff709SChao Yu struct decompress_io_ctx *dic; 15344c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 15354c8ff709SChao Yu int i; 15364c8ff709SChao Yu 1537c68d6c88SChao Yu dic = kmem_cache_zalloc(dic_entry_slab, GFP_NOFS); 15384c8ff709SChao Yu if (!dic) 15394c8ff709SChao Yu return ERR_PTR(-ENOMEM); 15404c8ff709SChao Yu 154131083031SChao Yu dic->rpages = page_array_alloc(cc->inode, cc->cluster_size); 15424c8ff709SChao Yu if (!dic->rpages) { 1543c68d6c88SChao Yu kmem_cache_free(dic_entry_slab, dic); 15444c8ff709SChao Yu return ERR_PTR(-ENOMEM); 15454c8ff709SChao Yu } 15464c8ff709SChao Yu 15474c8ff709SChao Yu dic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 15484c8ff709SChao Yu dic->inode = cc->inode; 15497f59b277SEric Biggers atomic_set(&dic->remaining_pages, cc->nr_cpages); 15504c8ff709SChao Yu dic->cluster_idx = cc->cluster_idx; 15514c8ff709SChao Yu dic->cluster_size = cc->cluster_size; 15524c8ff709SChao Yu dic->log_cluster_size = cc->log_cluster_size; 15534c8ff709SChao Yu dic->nr_cpages = cc->nr_cpages; 15547f59b277SEric Biggers refcount_set(&dic->refcnt, 1); 15554c8ff709SChao Yu dic->failed = false; 15567f59b277SEric Biggers dic->need_verity = f2fs_need_verity(cc->inode, start_idx); 15574c8ff709SChao Yu 15584c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) 15594c8ff709SChao Yu dic->rpages[i] = cc->rpages[i]; 15604c8ff709SChao Yu dic->nr_rpages = cc->cluster_size; 15614c8ff709SChao Yu 156231083031SChao Yu dic->cpages = page_array_alloc(dic->inode, dic->nr_cpages); 15634c8ff709SChao Yu if (!dic->cpages) 15644c8ff709SChao Yu goto out_free; 15654c8ff709SChao Yu 15664c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 15674c8ff709SChao Yu struct page *page; 15684c8ff709SChao Yu 15695e6bbde9SChao Yu page = f2fs_compress_alloc_page(); 15704c8ff709SChao Yu if (!page) 15714c8ff709SChao Yu goto out_free; 15724c8ff709SChao Yu 15734c8ff709SChao Yu f2fs_set_compressed_page(page, cc->inode, 1574887347a0SChao Yu start_idx + i + 1, dic); 15754c8ff709SChao Yu dic->cpages[i] = page; 15764c8ff709SChao Yu } 15774c8ff709SChao Yu 15784c8ff709SChao Yu return dic; 15794c8ff709SChao Yu 15804c8ff709SChao Yu out_free: 15814c8ff709SChao Yu f2fs_free_dic(dic); 15824c8ff709SChao Yu return ERR_PTR(-ENOMEM); 15834c8ff709SChao Yu } 15844c8ff709SChao Yu 15857f59b277SEric Biggers static void f2fs_free_dic(struct decompress_io_ctx *dic) 15864c8ff709SChao Yu { 15874c8ff709SChao Yu int i; 15884c8ff709SChao Yu 15894c8ff709SChao Yu if (dic->tpages) { 15904c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) { 15914c8ff709SChao Yu if (dic->rpages[i]) 15924c8ff709SChao Yu continue; 15938908e753SChao Yu if (!dic->tpages[i]) 15948908e753SChao Yu continue; 15955e6bbde9SChao Yu f2fs_compress_free_page(dic->tpages[i]); 15964c8ff709SChao Yu } 159731083031SChao Yu page_array_free(dic->inode, dic->tpages, dic->cluster_size); 15984c8ff709SChao Yu } 15994c8ff709SChao Yu 16004c8ff709SChao Yu if (dic->cpages) { 16014c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 16024c8ff709SChao Yu if (!dic->cpages[i]) 16034c8ff709SChao Yu continue; 16045e6bbde9SChao Yu f2fs_compress_free_page(dic->cpages[i]); 16054c8ff709SChao Yu } 160631083031SChao Yu page_array_free(dic->inode, dic->cpages, dic->nr_cpages); 16074c8ff709SChao Yu } 16084c8ff709SChao Yu 160931083031SChao Yu page_array_free(dic->inode, dic->rpages, dic->nr_rpages); 1610c68d6c88SChao Yu kmem_cache_free(dic_entry_slab, dic); 16114c8ff709SChao Yu } 16124c8ff709SChao Yu 16137f59b277SEric Biggers static void f2fs_put_dic(struct decompress_io_ctx *dic) 16147f59b277SEric Biggers { 16157f59b277SEric Biggers if (refcount_dec_and_test(&dic->refcnt)) 16167f59b277SEric Biggers f2fs_free_dic(dic); 16177f59b277SEric Biggers } 16187f59b277SEric Biggers 16197f59b277SEric Biggers /* 16207f59b277SEric Biggers * Update and unlock the cluster's pagecache pages, and release the reference to 16217f59b277SEric Biggers * the decompress_io_ctx that was being held for I/O completion. 16227f59b277SEric Biggers */ 16237f59b277SEric Biggers static void __f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed) 16244c8ff709SChao Yu { 16254c8ff709SChao Yu int i; 16264c8ff709SChao Yu 16277f59b277SEric Biggers for (i = 0; i < dic->cluster_size; i++) { 16287f59b277SEric Biggers struct page *rpage = dic->rpages[i]; 16294c8ff709SChao Yu 16304c8ff709SChao Yu if (!rpage) 16314c8ff709SChao Yu continue; 16324c8ff709SChao Yu 16337f59b277SEric Biggers /* PG_error was set if verity failed. */ 16347f59b277SEric Biggers if (failed || PageError(rpage)) { 16354c8ff709SChao Yu ClearPageUptodate(rpage); 16367f59b277SEric Biggers /* will re-read again later */ 16374c8ff709SChao Yu ClearPageError(rpage); 16387f59b277SEric Biggers } else { 16397f59b277SEric Biggers SetPageUptodate(rpage); 16407f59b277SEric Biggers } 16414c8ff709SChao Yu unlock_page(rpage); 16424c8ff709SChao Yu } 16437f59b277SEric Biggers 16447f59b277SEric Biggers f2fs_put_dic(dic); 16457f59b277SEric Biggers } 16467f59b277SEric Biggers 16477f59b277SEric Biggers static void f2fs_verify_cluster(struct work_struct *work) 16487f59b277SEric Biggers { 16497f59b277SEric Biggers struct decompress_io_ctx *dic = 16507f59b277SEric Biggers container_of(work, struct decompress_io_ctx, verity_work); 16517f59b277SEric Biggers int i; 16527f59b277SEric Biggers 16537f59b277SEric Biggers /* Verify the cluster's decompressed pages with fs-verity. */ 16547f59b277SEric Biggers for (i = 0; i < dic->cluster_size; i++) { 16557f59b277SEric Biggers struct page *rpage = dic->rpages[i]; 16567f59b277SEric Biggers 16577f59b277SEric Biggers if (rpage && !fsverity_verify_page(rpage)) 16587f59b277SEric Biggers SetPageError(rpage); 16597f59b277SEric Biggers } 16607f59b277SEric Biggers 16617f59b277SEric Biggers __f2fs_decompress_end_io(dic, false); 16627f59b277SEric Biggers } 16637f59b277SEric Biggers 16647f59b277SEric Biggers /* 16657f59b277SEric Biggers * This is called when a compressed cluster has been decompressed 16667f59b277SEric Biggers * (or failed to be read and/or decompressed). 16677f59b277SEric Biggers */ 16687f59b277SEric Biggers void f2fs_decompress_end_io(struct decompress_io_ctx *dic, bool failed) 16697f59b277SEric Biggers { 16707f59b277SEric Biggers if (!failed && dic->need_verity) { 16717f59b277SEric Biggers /* 16727f59b277SEric Biggers * Note that to avoid deadlocks, the verity work can't be done 16737f59b277SEric Biggers * on the decompression workqueue. This is because verifying 16747f59b277SEric Biggers * the data pages can involve reading metadata pages from the 16757f59b277SEric Biggers * file, and these metadata pages may be compressed. 16767f59b277SEric Biggers */ 16777f59b277SEric Biggers INIT_WORK(&dic->verity_work, f2fs_verify_cluster); 16787f59b277SEric Biggers fsverity_enqueue_verify_work(&dic->verity_work); 16797f59b277SEric Biggers } else { 16807f59b277SEric Biggers __f2fs_decompress_end_io(dic, failed); 16817f59b277SEric Biggers } 16827f59b277SEric Biggers } 16837f59b277SEric Biggers 16847f59b277SEric Biggers /* 16857f59b277SEric Biggers * Put a reference to a compressed page's decompress_io_ctx. 16867f59b277SEric Biggers * 16877f59b277SEric Biggers * This is called when the page is no longer needed and can be freed. 16887f59b277SEric Biggers */ 16897f59b277SEric Biggers void f2fs_put_page_dic(struct page *page) 16907f59b277SEric Biggers { 16917f59b277SEric Biggers struct decompress_io_ctx *dic = 16927f59b277SEric Biggers (struct decompress_io_ctx *)page_private(page); 16937f59b277SEric Biggers 16947f59b277SEric Biggers f2fs_put_dic(dic); 16954c8ff709SChao Yu } 169631083031SChao Yu 169731083031SChao Yu int f2fs_init_page_array_cache(struct f2fs_sb_info *sbi) 169831083031SChao Yu { 169931083031SChao Yu dev_t dev = sbi->sb->s_bdev->bd_dev; 170031083031SChao Yu char slab_name[32]; 170131083031SChao Yu 170231083031SChao Yu sprintf(slab_name, "f2fs_page_array_entry-%u:%u", MAJOR(dev), MINOR(dev)); 170331083031SChao Yu 170431083031SChao Yu sbi->page_array_slab_size = sizeof(struct page *) << 170531083031SChao Yu F2FS_OPTION(sbi).compress_log_size; 170631083031SChao Yu 170731083031SChao Yu sbi->page_array_slab = f2fs_kmem_cache_create(slab_name, 170831083031SChao Yu sbi->page_array_slab_size); 170931083031SChao Yu if (!sbi->page_array_slab) 171031083031SChao Yu return -ENOMEM; 171131083031SChao Yu return 0; 171231083031SChao Yu } 171331083031SChao Yu 171431083031SChao Yu void f2fs_destroy_page_array_cache(struct f2fs_sb_info *sbi) 171531083031SChao Yu { 171631083031SChao Yu kmem_cache_destroy(sbi->page_array_slab); 171731083031SChao Yu } 1718c68d6c88SChao Yu 1719c68d6c88SChao Yu static int __init f2fs_init_cic_cache(void) 1720c68d6c88SChao Yu { 1721c68d6c88SChao Yu cic_entry_slab = f2fs_kmem_cache_create("f2fs_cic_entry", 1722c68d6c88SChao Yu sizeof(struct compress_io_ctx)); 1723c68d6c88SChao Yu if (!cic_entry_slab) 1724c68d6c88SChao Yu return -ENOMEM; 1725c68d6c88SChao Yu return 0; 1726c68d6c88SChao Yu } 1727c68d6c88SChao Yu 1728c68d6c88SChao Yu static void f2fs_destroy_cic_cache(void) 1729c68d6c88SChao Yu { 1730c68d6c88SChao Yu kmem_cache_destroy(cic_entry_slab); 1731c68d6c88SChao Yu } 1732c68d6c88SChao Yu 1733c68d6c88SChao Yu static int __init f2fs_init_dic_cache(void) 1734c68d6c88SChao Yu { 1735c68d6c88SChao Yu dic_entry_slab = f2fs_kmem_cache_create("f2fs_dic_entry", 1736c68d6c88SChao Yu sizeof(struct decompress_io_ctx)); 1737c68d6c88SChao Yu if (!dic_entry_slab) 1738c68d6c88SChao Yu return -ENOMEM; 1739c68d6c88SChao Yu return 0; 1740c68d6c88SChao Yu } 1741c68d6c88SChao Yu 1742c68d6c88SChao Yu static void f2fs_destroy_dic_cache(void) 1743c68d6c88SChao Yu { 1744c68d6c88SChao Yu kmem_cache_destroy(dic_entry_slab); 1745c68d6c88SChao Yu } 1746c68d6c88SChao Yu 1747c68d6c88SChao Yu int __init f2fs_init_compress_cache(void) 1748c68d6c88SChao Yu { 1749c68d6c88SChao Yu int err; 1750c68d6c88SChao Yu 1751c68d6c88SChao Yu err = f2fs_init_cic_cache(); 1752c68d6c88SChao Yu if (err) 1753c68d6c88SChao Yu goto out; 1754c68d6c88SChao Yu err = f2fs_init_dic_cache(); 1755c68d6c88SChao Yu if (err) 1756c68d6c88SChao Yu goto free_cic; 1757c68d6c88SChao Yu return 0; 1758c68d6c88SChao Yu free_cic: 1759c68d6c88SChao Yu f2fs_destroy_cic_cache(); 1760c68d6c88SChao Yu out: 1761c68d6c88SChao Yu return -ENOMEM; 1762c68d6c88SChao Yu } 1763c68d6c88SChao Yu 1764c68d6c88SChao Yu void f2fs_destroy_compress_cache(void) 1765c68d6c88SChao Yu { 1766c68d6c88SChao Yu f2fs_destroy_dic_cache(); 1767c68d6c88SChao Yu f2fs_destroy_cic_cache(); 1768c68d6c88SChao Yu } 1769