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 204c8ff709SChao Yu struct f2fs_compress_ops { 214c8ff709SChao Yu int (*init_compress_ctx)(struct compress_ctx *cc); 224c8ff709SChao Yu void (*destroy_compress_ctx)(struct compress_ctx *cc); 234c8ff709SChao Yu int (*compress_pages)(struct compress_ctx *cc); 2423b1faaaSChao Yu int (*init_decompress_ctx)(struct decompress_io_ctx *dic); 2523b1faaaSChao Yu void (*destroy_decompress_ctx)(struct decompress_io_ctx *dic); 264c8ff709SChao Yu int (*decompress_pages)(struct decompress_io_ctx *dic); 274c8ff709SChao Yu }; 284c8ff709SChao Yu 294c8ff709SChao Yu static unsigned int offset_in_cluster(struct compress_ctx *cc, pgoff_t index) 304c8ff709SChao Yu { 314c8ff709SChao Yu return index & (cc->cluster_size - 1); 324c8ff709SChao Yu } 334c8ff709SChao Yu 344c8ff709SChao Yu static pgoff_t cluster_idx(struct compress_ctx *cc, pgoff_t index) 354c8ff709SChao Yu { 364c8ff709SChao Yu return index >> cc->log_cluster_size; 374c8ff709SChao Yu } 384c8ff709SChao Yu 394c8ff709SChao Yu static pgoff_t start_idx_of_cluster(struct compress_ctx *cc) 404c8ff709SChao Yu { 414c8ff709SChao Yu return cc->cluster_idx << cc->log_cluster_size; 424c8ff709SChao Yu } 434c8ff709SChao Yu 444c8ff709SChao Yu bool f2fs_is_compressed_page(struct page *page) 454c8ff709SChao Yu { 464c8ff709SChao Yu if (!PagePrivate(page)) 474c8ff709SChao Yu return false; 484c8ff709SChao Yu if (!page_private(page)) 494c8ff709SChao Yu return false; 504c8ff709SChao Yu if (IS_ATOMIC_WRITTEN_PAGE(page) || IS_DUMMY_WRITTEN_PAGE(page)) 514c8ff709SChao Yu return false; 52*29b993c7SYu Changchun /* 53*29b993c7SYu Changchun * page->private may be set with pid. 54*29b993c7SYu Changchun * pid_max is enough to check if it is traced. 55*29b993c7SYu Changchun */ 56*29b993c7SYu Changchun if (IS_IO_TRACED_PAGE(page)) 57*29b993c7SYu Changchun return false; 58*29b993c7SYu Changchun 594c8ff709SChao Yu f2fs_bug_on(F2FS_M_SB(page->mapping), 604c8ff709SChao Yu *((u32 *)page_private(page)) != F2FS_COMPRESSED_PAGE_MAGIC); 614c8ff709SChao Yu return true; 624c8ff709SChao Yu } 634c8ff709SChao Yu 644c8ff709SChao Yu static void f2fs_set_compressed_page(struct page *page, 65887347a0SChao Yu struct inode *inode, pgoff_t index, void *data) 664c8ff709SChao Yu { 674c8ff709SChao Yu SetPagePrivate(page); 684c8ff709SChao Yu set_page_private(page, (unsigned long)data); 694c8ff709SChao Yu 704c8ff709SChao Yu /* i_crypto_info and iv index */ 714c8ff709SChao Yu page->index = index; 724c8ff709SChao Yu page->mapping = inode->i_mapping; 734c8ff709SChao Yu } 744c8ff709SChao Yu 754c8ff709SChao Yu static void f2fs_drop_rpages(struct compress_ctx *cc, int len, bool unlock) 764c8ff709SChao Yu { 774c8ff709SChao Yu int i; 784c8ff709SChao Yu 794c8ff709SChao Yu for (i = 0; i < len; i++) { 804c8ff709SChao Yu if (!cc->rpages[i]) 814c8ff709SChao Yu continue; 824c8ff709SChao Yu if (unlock) 834c8ff709SChao Yu unlock_page(cc->rpages[i]); 844c8ff709SChao Yu else 854c8ff709SChao Yu put_page(cc->rpages[i]); 864c8ff709SChao Yu } 874c8ff709SChao Yu } 884c8ff709SChao Yu 894c8ff709SChao Yu static void f2fs_put_rpages(struct compress_ctx *cc) 904c8ff709SChao Yu { 914c8ff709SChao Yu f2fs_drop_rpages(cc, cc->cluster_size, false); 924c8ff709SChao Yu } 934c8ff709SChao Yu 944c8ff709SChao Yu static void f2fs_unlock_rpages(struct compress_ctx *cc, int len) 954c8ff709SChao Yu { 964c8ff709SChao Yu f2fs_drop_rpages(cc, len, true); 974c8ff709SChao Yu } 984c8ff709SChao Yu 99bc67c5d0SChao Yu static void f2fs_put_rpages_mapping(struct address_space *mapping, 1004c8ff709SChao Yu pgoff_t start, int len) 1014c8ff709SChao Yu { 1024c8ff709SChao Yu int i; 1034c8ff709SChao Yu 1044c8ff709SChao Yu for (i = 0; i < len; i++) { 1054c8ff709SChao Yu struct page *page = find_get_page(mapping, start + i); 1064c8ff709SChao Yu 1074c8ff709SChao Yu put_page(page); 1084c8ff709SChao Yu put_page(page); 1094c8ff709SChao Yu } 1104c8ff709SChao Yu } 1114c8ff709SChao Yu 1124c8ff709SChao Yu static void f2fs_put_rpages_wbc(struct compress_ctx *cc, 1134c8ff709SChao Yu struct writeback_control *wbc, bool redirty, int unlock) 1144c8ff709SChao Yu { 1154c8ff709SChao Yu unsigned int i; 1164c8ff709SChao Yu 1174c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1184c8ff709SChao Yu if (!cc->rpages[i]) 1194c8ff709SChao Yu continue; 1204c8ff709SChao Yu if (redirty) 1214c8ff709SChao Yu redirty_page_for_writepage(wbc, cc->rpages[i]); 1224c8ff709SChao Yu f2fs_put_page(cc->rpages[i], unlock); 1234c8ff709SChao Yu } 1244c8ff709SChao Yu } 1254c8ff709SChao Yu 1264c8ff709SChao Yu struct page *f2fs_compress_control_page(struct page *page) 1274c8ff709SChao Yu { 1284c8ff709SChao Yu return ((struct compress_io_ctx *)page_private(page))->rpages[0]; 1294c8ff709SChao Yu } 1304c8ff709SChao Yu 1314c8ff709SChao Yu int f2fs_init_compress_ctx(struct compress_ctx *cc) 1324c8ff709SChao Yu { 1334c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 1344c8ff709SChao Yu 1354c8ff709SChao Yu if (cc->nr_rpages) 1364c8ff709SChao Yu return 0; 1374c8ff709SChao Yu 1384c8ff709SChao Yu cc->rpages = f2fs_kzalloc(sbi, sizeof(struct page *) << 1394c8ff709SChao Yu cc->log_cluster_size, GFP_NOFS); 1404c8ff709SChao Yu return cc->rpages ? 0 : -ENOMEM; 1414c8ff709SChao Yu } 1424c8ff709SChao Yu 1434c8ff709SChao Yu void f2fs_destroy_compress_ctx(struct compress_ctx *cc) 1444c8ff709SChao Yu { 1454c8ff709SChao Yu kfree(cc->rpages); 1464c8ff709SChao Yu cc->rpages = NULL; 1474c8ff709SChao Yu cc->nr_rpages = 0; 1484c8ff709SChao Yu cc->nr_cpages = 0; 1494c8ff709SChao Yu cc->cluster_idx = NULL_CLUSTER; 1504c8ff709SChao Yu } 1514c8ff709SChao Yu 1524c8ff709SChao Yu void f2fs_compress_ctx_add_page(struct compress_ctx *cc, struct page *page) 1534c8ff709SChao Yu { 1544c8ff709SChao Yu unsigned int cluster_ofs; 1554c8ff709SChao Yu 1564c8ff709SChao Yu if (!f2fs_cluster_can_merge_page(cc, page->index)) 1574c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), 1); 1584c8ff709SChao Yu 1594c8ff709SChao Yu cluster_ofs = offset_in_cluster(cc, page->index); 1604c8ff709SChao Yu cc->rpages[cluster_ofs] = page; 1614c8ff709SChao Yu cc->nr_rpages++; 1624c8ff709SChao Yu cc->cluster_idx = cluster_idx(cc, page->index); 1634c8ff709SChao Yu } 1644c8ff709SChao Yu 1654c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 1664c8ff709SChao Yu static int lzo_init_compress_ctx(struct compress_ctx *cc) 1674c8ff709SChao Yu { 1684c8ff709SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 1694c8ff709SChao Yu LZO1X_MEM_COMPRESS, GFP_NOFS); 1704c8ff709SChao Yu if (!cc->private) 1714c8ff709SChao Yu return -ENOMEM; 1724c8ff709SChao Yu 1734c8ff709SChao Yu cc->clen = lzo1x_worst_compress(PAGE_SIZE << cc->log_cluster_size); 1744c8ff709SChao Yu return 0; 1754c8ff709SChao Yu } 1764c8ff709SChao Yu 1774c8ff709SChao Yu static void lzo_destroy_compress_ctx(struct compress_ctx *cc) 1784c8ff709SChao Yu { 1794c8ff709SChao Yu kvfree(cc->private); 1804c8ff709SChao Yu cc->private = NULL; 1814c8ff709SChao Yu } 1824c8ff709SChao Yu 1834c8ff709SChao Yu static int lzo_compress_pages(struct compress_ctx *cc) 1844c8ff709SChao Yu { 1854c8ff709SChao Yu int ret; 1864c8ff709SChao Yu 1874c8ff709SChao Yu ret = lzo1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 1884c8ff709SChao Yu &cc->clen, cc->private); 1894c8ff709SChao Yu if (ret != LZO_E_OK) { 1904c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo compress failed, ret:%d\n", 1914c8ff709SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 1924c8ff709SChao Yu return -EIO; 1934c8ff709SChao Yu } 1944c8ff709SChao Yu return 0; 1954c8ff709SChao Yu } 1964c8ff709SChao Yu 1974c8ff709SChao Yu static int lzo_decompress_pages(struct decompress_io_ctx *dic) 1984c8ff709SChao Yu { 1994c8ff709SChao Yu int ret; 2004c8ff709SChao Yu 2014c8ff709SChao Yu ret = lzo1x_decompress_safe(dic->cbuf->cdata, dic->clen, 2024c8ff709SChao Yu dic->rbuf, &dic->rlen); 2034c8ff709SChao Yu if (ret != LZO_E_OK) { 2044c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo decompress failed, ret:%d\n", 2054c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 2064c8ff709SChao Yu return -EIO; 2074c8ff709SChao Yu } 2084c8ff709SChao Yu 2094c8ff709SChao Yu if (dic->rlen != PAGE_SIZE << dic->log_cluster_size) { 2104c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo invalid rlen:%zu, " 2114c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 2124c8ff709SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 2134c8ff709SChao Yu dic->rlen, 2144c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 2154c8ff709SChao Yu return -EIO; 2164c8ff709SChao Yu } 2174c8ff709SChao Yu return 0; 2184c8ff709SChao Yu } 2194c8ff709SChao Yu 2204c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lzo_ops = { 2214c8ff709SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 2224c8ff709SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 2234c8ff709SChao Yu .compress_pages = lzo_compress_pages, 2244c8ff709SChao Yu .decompress_pages = lzo_decompress_pages, 2254c8ff709SChao Yu }; 2264c8ff709SChao Yu #endif 2274c8ff709SChao Yu 2284c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 2294c8ff709SChao Yu static int lz4_init_compress_ctx(struct compress_ctx *cc) 2304c8ff709SChao Yu { 2314c8ff709SChao Yu cc->private = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 2324c8ff709SChao Yu LZ4_MEM_COMPRESS, GFP_NOFS); 2334c8ff709SChao Yu if (!cc->private) 2344c8ff709SChao Yu return -ENOMEM; 2354c8ff709SChao Yu 236f6644143SChao Yu /* 237f6644143SChao Yu * we do not change cc->clen to LZ4_compressBound(inputsize) to 238f6644143SChao Yu * adapt worst compress case, because lz4 compressor can handle 239f6644143SChao Yu * output budget properly. 240f6644143SChao Yu */ 241f6644143SChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 2424c8ff709SChao Yu return 0; 2434c8ff709SChao Yu } 2444c8ff709SChao Yu 2454c8ff709SChao Yu static void lz4_destroy_compress_ctx(struct compress_ctx *cc) 2464c8ff709SChao Yu { 2474c8ff709SChao Yu kvfree(cc->private); 2484c8ff709SChao Yu cc->private = NULL; 2494c8ff709SChao Yu } 2504c8ff709SChao Yu 2514c8ff709SChao Yu static int lz4_compress_pages(struct compress_ctx *cc) 2524c8ff709SChao Yu { 2534c8ff709SChao Yu int len; 2544c8ff709SChao Yu 2554c8ff709SChao Yu len = LZ4_compress_default(cc->rbuf, cc->cbuf->cdata, cc->rlen, 2564c8ff709SChao Yu cc->clen, cc->private); 257f6644143SChao Yu if (!len) 258f6644143SChao Yu return -EAGAIN; 259f6644143SChao Yu 2604c8ff709SChao Yu cc->clen = len; 2614c8ff709SChao Yu return 0; 2624c8ff709SChao Yu } 2634c8ff709SChao Yu 2644c8ff709SChao Yu static int lz4_decompress_pages(struct decompress_io_ctx *dic) 2654c8ff709SChao Yu { 2664c8ff709SChao Yu int ret; 2674c8ff709SChao Yu 2684c8ff709SChao Yu ret = LZ4_decompress_safe(dic->cbuf->cdata, dic->rbuf, 2694c8ff709SChao Yu dic->clen, dic->rlen); 2704c8ff709SChao Yu if (ret < 0) { 2714c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 decompress failed, ret:%d\n", 2724c8ff709SChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, ret); 2734c8ff709SChao Yu return -EIO; 2744c8ff709SChao Yu } 2754c8ff709SChao Yu 2764c8ff709SChao Yu if (ret != PAGE_SIZE << dic->log_cluster_size) { 2774c8ff709SChao Yu printk_ratelimited("%sF2FS-fs (%s): lz4 invalid rlen:%zu, " 2784c8ff709SChao Yu "expected:%lu\n", KERN_ERR, 2794c8ff709SChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 2804c8ff709SChao Yu dic->rlen, 2814c8ff709SChao Yu PAGE_SIZE << dic->log_cluster_size); 2824c8ff709SChao Yu return -EIO; 2834c8ff709SChao Yu } 2844c8ff709SChao Yu return 0; 2854c8ff709SChao Yu } 2864c8ff709SChao Yu 2874c8ff709SChao Yu static const struct f2fs_compress_ops f2fs_lz4_ops = { 2884c8ff709SChao Yu .init_compress_ctx = lz4_init_compress_ctx, 2894c8ff709SChao Yu .destroy_compress_ctx = lz4_destroy_compress_ctx, 2904c8ff709SChao Yu .compress_pages = lz4_compress_pages, 2914c8ff709SChao Yu .decompress_pages = lz4_decompress_pages, 2924c8ff709SChao Yu }; 2934c8ff709SChao Yu #endif 2944c8ff709SChao Yu 29550cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 29650cfa66fSChao Yu #define F2FS_ZSTD_DEFAULT_CLEVEL 1 29750cfa66fSChao Yu 29850cfa66fSChao Yu static int zstd_init_compress_ctx(struct compress_ctx *cc) 29950cfa66fSChao Yu { 30050cfa66fSChao Yu ZSTD_parameters params; 30150cfa66fSChao Yu ZSTD_CStream *stream; 30250cfa66fSChao Yu void *workspace; 30350cfa66fSChao Yu unsigned int workspace_size; 30450cfa66fSChao Yu 30550cfa66fSChao Yu params = ZSTD_getParams(F2FS_ZSTD_DEFAULT_CLEVEL, cc->rlen, 0); 30650cfa66fSChao Yu workspace_size = ZSTD_CStreamWorkspaceBound(params.cParams); 30750cfa66fSChao Yu 30850cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(cc->inode), 30950cfa66fSChao Yu workspace_size, GFP_NOFS); 31050cfa66fSChao Yu if (!workspace) 31150cfa66fSChao Yu return -ENOMEM; 31250cfa66fSChao Yu 31350cfa66fSChao Yu stream = ZSTD_initCStream(params, 0, workspace, workspace_size); 31450cfa66fSChao Yu if (!stream) { 31550cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_initCStream failed\n", 31650cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 31750cfa66fSChao Yu __func__); 31850cfa66fSChao Yu kvfree(workspace); 31950cfa66fSChao Yu return -EIO; 32050cfa66fSChao Yu } 32150cfa66fSChao Yu 32250cfa66fSChao Yu cc->private = workspace; 32350cfa66fSChao Yu cc->private2 = stream; 32450cfa66fSChao Yu 32550cfa66fSChao Yu cc->clen = cc->rlen - PAGE_SIZE - COMPRESS_HEADER_SIZE; 32650cfa66fSChao Yu return 0; 32750cfa66fSChao Yu } 32850cfa66fSChao Yu 32950cfa66fSChao Yu static void zstd_destroy_compress_ctx(struct compress_ctx *cc) 33050cfa66fSChao Yu { 33150cfa66fSChao Yu kvfree(cc->private); 33250cfa66fSChao Yu cc->private = NULL; 33350cfa66fSChao Yu cc->private2 = NULL; 33450cfa66fSChao Yu } 33550cfa66fSChao Yu 33650cfa66fSChao Yu static int zstd_compress_pages(struct compress_ctx *cc) 33750cfa66fSChao Yu { 33850cfa66fSChao Yu ZSTD_CStream *stream = cc->private2; 33950cfa66fSChao Yu ZSTD_inBuffer inbuf; 34050cfa66fSChao Yu ZSTD_outBuffer outbuf; 34150cfa66fSChao Yu int src_size = cc->rlen; 34250cfa66fSChao Yu int dst_size = src_size - PAGE_SIZE - COMPRESS_HEADER_SIZE; 34350cfa66fSChao Yu int ret; 34450cfa66fSChao Yu 34550cfa66fSChao Yu inbuf.pos = 0; 34650cfa66fSChao Yu inbuf.src = cc->rbuf; 34750cfa66fSChao Yu inbuf.size = src_size; 34850cfa66fSChao Yu 34950cfa66fSChao Yu outbuf.pos = 0; 35050cfa66fSChao Yu outbuf.dst = cc->cbuf->cdata; 35150cfa66fSChao Yu outbuf.size = dst_size; 35250cfa66fSChao Yu 35350cfa66fSChao Yu ret = ZSTD_compressStream(stream, &outbuf, &inbuf); 35450cfa66fSChao Yu if (ZSTD_isError(ret)) { 35550cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_compressStream failed, ret: %d\n", 35650cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 35750cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 35850cfa66fSChao Yu return -EIO; 35950cfa66fSChao Yu } 36050cfa66fSChao Yu 36150cfa66fSChao Yu ret = ZSTD_endStream(stream, &outbuf); 36250cfa66fSChao Yu if (ZSTD_isError(ret)) { 36350cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_endStream returned %d\n", 36450cfa66fSChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, 36550cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 36650cfa66fSChao Yu return -EIO; 36750cfa66fSChao Yu } 36850cfa66fSChao Yu 3691454c978SChao Yu /* 3701454c978SChao Yu * there is compressed data remained in intermediate buffer due to 3711454c978SChao Yu * no more space in cbuf.cdata 3721454c978SChao Yu */ 3731454c978SChao Yu if (ret) 3741454c978SChao Yu return -EAGAIN; 3751454c978SChao Yu 37650cfa66fSChao Yu cc->clen = outbuf.pos; 37750cfa66fSChao Yu return 0; 37850cfa66fSChao Yu } 37950cfa66fSChao Yu 38050cfa66fSChao Yu static int zstd_init_decompress_ctx(struct decompress_io_ctx *dic) 38150cfa66fSChao Yu { 38250cfa66fSChao Yu ZSTD_DStream *stream; 38350cfa66fSChao Yu void *workspace; 38450cfa66fSChao Yu unsigned int workspace_size; 38550cfa66fSChao Yu 38650cfa66fSChao Yu workspace_size = ZSTD_DStreamWorkspaceBound(MAX_COMPRESS_WINDOW_SIZE); 38750cfa66fSChao Yu 38850cfa66fSChao Yu workspace = f2fs_kvmalloc(F2FS_I_SB(dic->inode), 38950cfa66fSChao Yu workspace_size, GFP_NOFS); 39050cfa66fSChao Yu if (!workspace) 39150cfa66fSChao Yu return -ENOMEM; 39250cfa66fSChao Yu 39350cfa66fSChao Yu stream = ZSTD_initDStream(MAX_COMPRESS_WINDOW_SIZE, 39450cfa66fSChao Yu workspace, workspace_size); 39550cfa66fSChao Yu if (!stream) { 39650cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_initDStream failed\n", 39750cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 39850cfa66fSChao Yu __func__); 39950cfa66fSChao Yu kvfree(workspace); 40050cfa66fSChao Yu return -EIO; 40150cfa66fSChao Yu } 40250cfa66fSChao Yu 40350cfa66fSChao Yu dic->private = workspace; 40450cfa66fSChao Yu dic->private2 = stream; 40550cfa66fSChao Yu 40650cfa66fSChao Yu return 0; 40750cfa66fSChao Yu } 40850cfa66fSChao Yu 40950cfa66fSChao Yu static void zstd_destroy_decompress_ctx(struct decompress_io_ctx *dic) 41050cfa66fSChao Yu { 41150cfa66fSChao Yu kvfree(dic->private); 41250cfa66fSChao Yu dic->private = NULL; 41350cfa66fSChao Yu dic->private2 = NULL; 41450cfa66fSChao Yu } 41550cfa66fSChao Yu 41650cfa66fSChao Yu static int zstd_decompress_pages(struct decompress_io_ctx *dic) 41750cfa66fSChao Yu { 41850cfa66fSChao Yu ZSTD_DStream *stream = dic->private2; 41950cfa66fSChao Yu ZSTD_inBuffer inbuf; 42050cfa66fSChao Yu ZSTD_outBuffer outbuf; 42150cfa66fSChao Yu int ret; 42250cfa66fSChao Yu 42350cfa66fSChao Yu inbuf.pos = 0; 42450cfa66fSChao Yu inbuf.src = dic->cbuf->cdata; 42550cfa66fSChao Yu inbuf.size = dic->clen; 42650cfa66fSChao Yu 42750cfa66fSChao Yu outbuf.pos = 0; 42850cfa66fSChao Yu outbuf.dst = dic->rbuf; 42950cfa66fSChao Yu outbuf.size = dic->rlen; 43050cfa66fSChao Yu 43150cfa66fSChao Yu ret = ZSTD_decompressStream(stream, &outbuf, &inbuf); 43250cfa66fSChao Yu if (ZSTD_isError(ret)) { 43350cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD_compressStream failed, ret: %d\n", 43450cfa66fSChao Yu KERN_ERR, F2FS_I_SB(dic->inode)->sb->s_id, 43550cfa66fSChao Yu __func__, ZSTD_getErrorCode(ret)); 43650cfa66fSChao Yu return -EIO; 43750cfa66fSChao Yu } 43850cfa66fSChao Yu 43950cfa66fSChao Yu if (dic->rlen != outbuf.pos) { 44050cfa66fSChao Yu printk_ratelimited("%sF2FS-fs (%s): %s ZSTD invalid rlen:%zu, " 44150cfa66fSChao Yu "expected:%lu\n", KERN_ERR, 44250cfa66fSChao Yu F2FS_I_SB(dic->inode)->sb->s_id, 44350cfa66fSChao Yu __func__, dic->rlen, 44450cfa66fSChao Yu PAGE_SIZE << dic->log_cluster_size); 44550cfa66fSChao Yu return -EIO; 44650cfa66fSChao Yu } 44750cfa66fSChao Yu 44850cfa66fSChao Yu return 0; 44950cfa66fSChao Yu } 45050cfa66fSChao Yu 45150cfa66fSChao Yu static const struct f2fs_compress_ops f2fs_zstd_ops = { 45250cfa66fSChao Yu .init_compress_ctx = zstd_init_compress_ctx, 45350cfa66fSChao Yu .destroy_compress_ctx = zstd_destroy_compress_ctx, 45450cfa66fSChao Yu .compress_pages = zstd_compress_pages, 45550cfa66fSChao Yu .init_decompress_ctx = zstd_init_decompress_ctx, 45650cfa66fSChao Yu .destroy_decompress_ctx = zstd_destroy_decompress_ctx, 45750cfa66fSChao Yu .decompress_pages = zstd_decompress_pages, 45850cfa66fSChao Yu }; 45950cfa66fSChao Yu #endif 46050cfa66fSChao Yu 4616d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZO 4626d92b201SChao Yu #ifdef CONFIG_F2FS_FS_LZORLE 4636d92b201SChao Yu static int lzorle_compress_pages(struct compress_ctx *cc) 4646d92b201SChao Yu { 4656d92b201SChao Yu int ret; 4666d92b201SChao Yu 4676d92b201SChao Yu ret = lzorle1x_1_compress(cc->rbuf, cc->rlen, cc->cbuf->cdata, 4686d92b201SChao Yu &cc->clen, cc->private); 4696d92b201SChao Yu if (ret != LZO_E_OK) { 4706d92b201SChao Yu printk_ratelimited("%sF2FS-fs (%s): lzo-rle compress failed, ret:%d\n", 4716d92b201SChao Yu KERN_ERR, F2FS_I_SB(cc->inode)->sb->s_id, ret); 4726d92b201SChao Yu return -EIO; 4736d92b201SChao Yu } 4746d92b201SChao Yu return 0; 4756d92b201SChao Yu } 4766d92b201SChao Yu 4776d92b201SChao Yu static const struct f2fs_compress_ops f2fs_lzorle_ops = { 4786d92b201SChao Yu .init_compress_ctx = lzo_init_compress_ctx, 4796d92b201SChao Yu .destroy_compress_ctx = lzo_destroy_compress_ctx, 4806d92b201SChao Yu .compress_pages = lzorle_compress_pages, 4816d92b201SChao Yu .decompress_pages = lzo_decompress_pages, 4826d92b201SChao Yu }; 4836d92b201SChao Yu #endif 4846d92b201SChao Yu #endif 4856d92b201SChao Yu 4864c8ff709SChao Yu static const struct f2fs_compress_ops *f2fs_cops[COMPRESS_MAX] = { 4874c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZO 4884c8ff709SChao Yu &f2fs_lzo_ops, 4894c8ff709SChao Yu #else 4904c8ff709SChao Yu NULL, 4914c8ff709SChao Yu #endif 4924c8ff709SChao Yu #ifdef CONFIG_F2FS_FS_LZ4 4934c8ff709SChao Yu &f2fs_lz4_ops, 4944c8ff709SChao Yu #else 4954c8ff709SChao Yu NULL, 4964c8ff709SChao Yu #endif 49750cfa66fSChao Yu #ifdef CONFIG_F2FS_FS_ZSTD 49850cfa66fSChao Yu &f2fs_zstd_ops, 49950cfa66fSChao Yu #else 50050cfa66fSChao Yu NULL, 50150cfa66fSChao Yu #endif 5026d92b201SChao Yu #if defined(CONFIG_F2FS_FS_LZO) && defined(CONFIG_F2FS_FS_LZORLE) 5036d92b201SChao Yu &f2fs_lzorle_ops, 5046d92b201SChao Yu #else 5056d92b201SChao Yu NULL, 5066d92b201SChao Yu #endif 5074c8ff709SChao Yu }; 5084c8ff709SChao Yu 5094c8ff709SChao Yu bool f2fs_is_compress_backend_ready(struct inode *inode) 5104c8ff709SChao Yu { 5114c8ff709SChao Yu if (!f2fs_compressed_file(inode)) 5124c8ff709SChao Yu return true; 5134c8ff709SChao Yu return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; 5144c8ff709SChao Yu } 5154c8ff709SChao Yu 51699bbe307SJaegeuk Kim static mempool_t *compress_page_pool; 5175e6bbde9SChao Yu static int num_compress_pages = 512; 5185e6bbde9SChao Yu module_param(num_compress_pages, uint, 0444); 5195e6bbde9SChao Yu MODULE_PARM_DESC(num_compress_pages, 5205e6bbde9SChao Yu "Number of intermediate compress pages to preallocate"); 5215e6bbde9SChao Yu 5225e6bbde9SChao Yu int f2fs_init_compress_mempool(void) 5235e6bbde9SChao Yu { 5245e6bbde9SChao Yu compress_page_pool = mempool_create_page_pool(num_compress_pages, 0); 5255e6bbde9SChao Yu if (!compress_page_pool) 5265e6bbde9SChao Yu return -ENOMEM; 5275e6bbde9SChao Yu 5285e6bbde9SChao Yu return 0; 5295e6bbde9SChao Yu } 5305e6bbde9SChao Yu 5315e6bbde9SChao Yu void f2fs_destroy_compress_mempool(void) 5325e6bbde9SChao Yu { 5335e6bbde9SChao Yu mempool_destroy(compress_page_pool); 5345e6bbde9SChao Yu } 5355e6bbde9SChao Yu 5365e6bbde9SChao Yu static struct page *f2fs_compress_alloc_page(void) 5374c8ff709SChao Yu { 5384c8ff709SChao Yu struct page *page; 5394c8ff709SChao Yu 5405e6bbde9SChao Yu page = mempool_alloc(compress_page_pool, GFP_NOFS); 5414c8ff709SChao Yu lock_page(page); 5425e6bbde9SChao Yu 5434c8ff709SChao Yu return page; 5444c8ff709SChao Yu } 5454c8ff709SChao Yu 5465e6bbde9SChao Yu static void f2fs_compress_free_page(struct page *page) 5475e6bbde9SChao Yu { 5485e6bbde9SChao Yu if (!page) 5495e6bbde9SChao Yu return; 5505e6bbde9SChao Yu set_page_private(page, (unsigned long)NULL); 5515e6bbde9SChao Yu ClearPagePrivate(page); 5525e6bbde9SChao Yu page->mapping = NULL; 5535e6bbde9SChao Yu unlock_page(page); 5545e6bbde9SChao Yu mempool_free(page, compress_page_pool); 5555e6bbde9SChao Yu } 5565e6bbde9SChao Yu 5574c8ff709SChao Yu static int f2fs_compress_pages(struct compress_ctx *cc) 5584c8ff709SChao Yu { 5594c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 5604c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(cc->inode); 5614c8ff709SChao Yu const struct f2fs_compress_ops *cops = 5624c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 5634c8ff709SChao Yu unsigned int max_len, nr_cpages; 5644c8ff709SChao Yu int i, ret; 5654c8ff709SChao Yu 5664c8ff709SChao Yu trace_f2fs_compress_pages_start(cc->inode, cc->cluster_idx, 5674c8ff709SChao Yu cc->cluster_size, fi->i_compress_algorithm); 5684c8ff709SChao Yu 56923b1faaaSChao Yu if (cops->init_compress_ctx) { 5704c8ff709SChao Yu ret = cops->init_compress_ctx(cc); 5714c8ff709SChao Yu if (ret) 5724c8ff709SChao Yu goto out; 57323b1faaaSChao Yu } 5744c8ff709SChao Yu 5754c8ff709SChao Yu max_len = COMPRESS_HEADER_SIZE + cc->clen; 5764c8ff709SChao Yu cc->nr_cpages = DIV_ROUND_UP(max_len, PAGE_SIZE); 5774c8ff709SChao Yu 5784c8ff709SChao Yu cc->cpages = f2fs_kzalloc(sbi, sizeof(struct page *) * 5794c8ff709SChao Yu cc->nr_cpages, GFP_NOFS); 5804c8ff709SChao Yu if (!cc->cpages) { 5814c8ff709SChao Yu ret = -ENOMEM; 5824c8ff709SChao Yu goto destroy_compress_ctx; 5834c8ff709SChao Yu } 5844c8ff709SChao Yu 5854c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 5865e6bbde9SChao Yu cc->cpages[i] = f2fs_compress_alloc_page(); 5874c8ff709SChao Yu if (!cc->cpages[i]) { 5884c8ff709SChao Yu ret = -ENOMEM; 5894c8ff709SChao Yu goto out_free_cpages; 5904c8ff709SChao Yu } 5914c8ff709SChao Yu } 5924c8ff709SChao Yu 5934c8ff709SChao Yu cc->rbuf = vmap(cc->rpages, cc->cluster_size, VM_MAP, PAGE_KERNEL_RO); 5944c8ff709SChao Yu if (!cc->rbuf) { 5954c8ff709SChao Yu ret = -ENOMEM; 5964c8ff709SChao Yu goto out_free_cpages; 5974c8ff709SChao Yu } 5984c8ff709SChao Yu 5994c8ff709SChao Yu cc->cbuf = vmap(cc->cpages, cc->nr_cpages, VM_MAP, PAGE_KERNEL); 6004c8ff709SChao Yu if (!cc->cbuf) { 6014c8ff709SChao Yu ret = -ENOMEM; 6024c8ff709SChao Yu goto out_vunmap_rbuf; 6034c8ff709SChao Yu } 6044c8ff709SChao Yu 6054c8ff709SChao Yu ret = cops->compress_pages(cc); 6064c8ff709SChao Yu if (ret) 6074c8ff709SChao Yu goto out_vunmap_cbuf; 6084c8ff709SChao Yu 6094c8ff709SChao Yu max_len = PAGE_SIZE * (cc->cluster_size - 1) - COMPRESS_HEADER_SIZE; 6104c8ff709SChao Yu 6114c8ff709SChao Yu if (cc->clen > max_len) { 6124c8ff709SChao Yu ret = -EAGAIN; 6134c8ff709SChao Yu goto out_vunmap_cbuf; 6144c8ff709SChao Yu } 6154c8ff709SChao Yu 6164c8ff709SChao Yu cc->cbuf->clen = cpu_to_le32(cc->clen); 6174c8ff709SChao Yu 6184c8ff709SChao Yu for (i = 0; i < COMPRESS_DATA_RESERVED_SIZE; i++) 6194c8ff709SChao Yu cc->cbuf->reserved[i] = cpu_to_le32(0); 6204c8ff709SChao Yu 6217fa6d598SEric Biggers nr_cpages = DIV_ROUND_UP(cc->clen + COMPRESS_HEADER_SIZE, PAGE_SIZE); 6227fa6d598SEric Biggers 6237fa6d598SEric Biggers /* zero out any unused part of the last page */ 6247fa6d598SEric Biggers memset(&cc->cbuf->cdata[cc->clen], 0, 6257fa6d598SEric Biggers (nr_cpages * PAGE_SIZE) - (cc->clen + COMPRESS_HEADER_SIZE)); 6267fa6d598SEric Biggers 6274c8ff709SChao Yu vunmap(cc->cbuf); 6284c8ff709SChao Yu vunmap(cc->rbuf); 6294c8ff709SChao Yu 6304c8ff709SChao Yu for (i = nr_cpages; i < cc->nr_cpages; i++) { 6315e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 6324c8ff709SChao Yu cc->cpages[i] = NULL; 6334c8ff709SChao Yu } 6344c8ff709SChao Yu 63523b1faaaSChao Yu if (cops->destroy_compress_ctx) 63609ff4801SChao Yu cops->destroy_compress_ctx(cc); 63709ff4801SChao Yu 6384c8ff709SChao Yu cc->nr_cpages = nr_cpages; 6394c8ff709SChao Yu 6404c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 6414c8ff709SChao Yu cc->clen, ret); 6424c8ff709SChao Yu return 0; 6434c8ff709SChao Yu 6444c8ff709SChao Yu out_vunmap_cbuf: 6454c8ff709SChao Yu vunmap(cc->cbuf); 6464c8ff709SChao Yu out_vunmap_rbuf: 6474c8ff709SChao Yu vunmap(cc->rbuf); 6484c8ff709SChao Yu out_free_cpages: 6494c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 6504c8ff709SChao Yu if (cc->cpages[i]) 6515e6bbde9SChao Yu f2fs_compress_free_page(cc->cpages[i]); 6524c8ff709SChao Yu } 6534c8ff709SChao Yu kfree(cc->cpages); 6544c8ff709SChao Yu cc->cpages = NULL; 6554c8ff709SChao Yu destroy_compress_ctx: 65623b1faaaSChao Yu if (cops->destroy_compress_ctx) 6574c8ff709SChao Yu cops->destroy_compress_ctx(cc); 6584c8ff709SChao Yu out: 6594c8ff709SChao Yu trace_f2fs_compress_pages_end(cc->inode, cc->cluster_idx, 6604c8ff709SChao Yu cc->clen, ret); 6614c8ff709SChao Yu return ret; 6624c8ff709SChao Yu } 6634c8ff709SChao Yu 6644c8ff709SChao Yu void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity) 6654c8ff709SChao Yu { 6664c8ff709SChao Yu struct decompress_io_ctx *dic = 6674c8ff709SChao Yu (struct decompress_io_ctx *)page_private(page); 6684c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dic->inode); 6694c8ff709SChao Yu struct f2fs_inode_info *fi= F2FS_I(dic->inode); 6704c8ff709SChao Yu const struct f2fs_compress_ops *cops = 6714c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 6724c8ff709SChao Yu int ret; 6734c8ff709SChao Yu 6744c8ff709SChao Yu dec_page_count(sbi, F2FS_RD_DATA); 6754c8ff709SChao Yu 6764c8ff709SChao Yu if (bio->bi_status || PageError(page)) 6774c8ff709SChao Yu dic->failed = true; 6784c8ff709SChao Yu 6794c8ff709SChao Yu if (refcount_dec_not_one(&dic->ref)) 6804c8ff709SChao Yu return; 6814c8ff709SChao Yu 6824c8ff709SChao Yu trace_f2fs_decompress_pages_start(dic->inode, dic->cluster_idx, 6834c8ff709SChao Yu dic->cluster_size, fi->i_compress_algorithm); 6844c8ff709SChao Yu 6854c8ff709SChao Yu /* submit partial compressed pages */ 6864c8ff709SChao Yu if (dic->failed) { 6874c8ff709SChao Yu ret = -EIO; 6884c8ff709SChao Yu goto out_free_dic; 6894c8ff709SChao Yu } 6904c8ff709SChao Yu 69123b1faaaSChao Yu if (cops->init_decompress_ctx) { 69223b1faaaSChao Yu ret = cops->init_decompress_ctx(dic); 69323b1faaaSChao Yu if (ret) 69423b1faaaSChao Yu goto out_free_dic; 69523b1faaaSChao Yu } 69623b1faaaSChao Yu 6974c8ff709SChao Yu dic->rbuf = vmap(dic->tpages, dic->cluster_size, VM_MAP, PAGE_KERNEL); 6984c8ff709SChao Yu if (!dic->rbuf) { 6994c8ff709SChao Yu ret = -ENOMEM; 70023b1faaaSChao Yu goto destroy_decompress_ctx; 7014c8ff709SChao Yu } 7024c8ff709SChao Yu 7034c8ff709SChao Yu dic->cbuf = vmap(dic->cpages, dic->nr_cpages, VM_MAP, PAGE_KERNEL_RO); 7044c8ff709SChao Yu if (!dic->cbuf) { 7054c8ff709SChao Yu ret = -ENOMEM; 7064c8ff709SChao Yu goto out_vunmap_rbuf; 7074c8ff709SChao Yu } 7084c8ff709SChao Yu 7094c8ff709SChao Yu dic->clen = le32_to_cpu(dic->cbuf->clen); 7104c8ff709SChao Yu dic->rlen = PAGE_SIZE << dic->log_cluster_size; 7114c8ff709SChao Yu 7124c8ff709SChao Yu if (dic->clen > PAGE_SIZE * dic->nr_cpages - COMPRESS_HEADER_SIZE) { 7134c8ff709SChao Yu ret = -EFSCORRUPTED; 7144c8ff709SChao Yu goto out_vunmap_cbuf; 7154c8ff709SChao Yu } 7164c8ff709SChao Yu 7174c8ff709SChao Yu ret = cops->decompress_pages(dic); 7184c8ff709SChao Yu 7194c8ff709SChao Yu out_vunmap_cbuf: 7204c8ff709SChao Yu vunmap(dic->cbuf); 7214c8ff709SChao Yu out_vunmap_rbuf: 7224c8ff709SChao Yu vunmap(dic->rbuf); 72323b1faaaSChao Yu destroy_decompress_ctx: 72423b1faaaSChao Yu if (cops->destroy_decompress_ctx) 72523b1faaaSChao Yu cops->destroy_decompress_ctx(dic); 7264c8ff709SChao Yu out_free_dic: 72779bbefb1SChao Yu if (verity) 728887347a0SChao Yu refcount_set(&dic->ref, dic->nr_cpages); 7294c8ff709SChao Yu if (!verity) 7304c8ff709SChao Yu f2fs_decompress_end_io(dic->rpages, dic->cluster_size, 7314c8ff709SChao Yu ret, false); 7324c8ff709SChao Yu 7334c8ff709SChao Yu trace_f2fs_decompress_pages_end(dic->inode, dic->cluster_idx, 7344c8ff709SChao Yu dic->clen, ret); 7354c8ff709SChao Yu if (!verity) 7364c8ff709SChao Yu f2fs_free_dic(dic); 7374c8ff709SChao Yu } 7384c8ff709SChao Yu 7394c8ff709SChao Yu static bool is_page_in_cluster(struct compress_ctx *cc, pgoff_t index) 7404c8ff709SChao Yu { 7414c8ff709SChao Yu if (cc->cluster_idx == NULL_CLUSTER) 7424c8ff709SChao Yu return true; 7434c8ff709SChao Yu return cc->cluster_idx == cluster_idx(cc, index); 7444c8ff709SChao Yu } 7454c8ff709SChao Yu 7464c8ff709SChao Yu bool f2fs_cluster_is_empty(struct compress_ctx *cc) 7474c8ff709SChao Yu { 7484c8ff709SChao Yu return cc->nr_rpages == 0; 7494c8ff709SChao Yu } 7504c8ff709SChao Yu 7514c8ff709SChao Yu static bool f2fs_cluster_is_full(struct compress_ctx *cc) 7524c8ff709SChao Yu { 7534c8ff709SChao Yu return cc->cluster_size == cc->nr_rpages; 7544c8ff709SChao Yu } 7554c8ff709SChao Yu 7564c8ff709SChao Yu bool f2fs_cluster_can_merge_page(struct compress_ctx *cc, pgoff_t index) 7574c8ff709SChao Yu { 7584c8ff709SChao Yu if (f2fs_cluster_is_empty(cc)) 7594c8ff709SChao Yu return true; 7604c8ff709SChao Yu return is_page_in_cluster(cc, index); 7614c8ff709SChao Yu } 7624c8ff709SChao Yu 7634c8ff709SChao Yu static bool __cluster_may_compress(struct compress_ctx *cc) 7644c8ff709SChao Yu { 7654c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 7664c8ff709SChao Yu loff_t i_size = i_size_read(cc->inode); 7674c8ff709SChao Yu unsigned nr_pages = DIV_ROUND_UP(i_size, PAGE_SIZE); 7684c8ff709SChao Yu int i; 7694c8ff709SChao Yu 7704c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 7714c8ff709SChao Yu struct page *page = cc->rpages[i]; 7724c8ff709SChao Yu 7734c8ff709SChao Yu f2fs_bug_on(sbi, !page); 7744c8ff709SChao Yu 7754c8ff709SChao Yu if (unlikely(f2fs_cp_error(sbi))) 7764c8ff709SChao Yu return false; 7774c8ff709SChao Yu if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING))) 7784c8ff709SChao Yu return false; 7794c8ff709SChao Yu 7804c8ff709SChao Yu /* beyond EOF */ 7814c8ff709SChao Yu if (page->index >= nr_pages) 7824c8ff709SChao Yu return false; 7834c8ff709SChao Yu } 7844c8ff709SChao Yu return true; 7854c8ff709SChao Yu } 7864c8ff709SChao Yu 7871a67cbe1SChao Yu static int __f2fs_cluster_blocks(struct compress_ctx *cc, bool compr) 7884c8ff709SChao Yu { 7894c8ff709SChao Yu struct dnode_of_data dn; 7904c8ff709SChao Yu int ret; 7914c8ff709SChao Yu 7924c8ff709SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 7934c8ff709SChao Yu ret = f2fs_get_dnode_of_data(&dn, start_idx_of_cluster(cc), 7944c8ff709SChao Yu LOOKUP_NODE); 7954c8ff709SChao Yu if (ret) { 7964c8ff709SChao Yu if (ret == -ENOENT) 7974c8ff709SChao Yu ret = 0; 7984c8ff709SChao Yu goto fail; 7994c8ff709SChao Yu } 8004c8ff709SChao Yu 8014c8ff709SChao Yu if (dn.data_blkaddr == COMPRESS_ADDR) { 8024c8ff709SChao Yu int i; 8034c8ff709SChao Yu 8044c8ff709SChao Yu ret = 1; 8054c8ff709SChao Yu for (i = 1; i < cc->cluster_size; i++) { 8064c8ff709SChao Yu block_t blkaddr; 8074c8ff709SChao Yu 808a2ced1ceSChao Yu blkaddr = data_blkaddr(dn.inode, 8094c8ff709SChao Yu dn.node_page, dn.ofs_in_node + i); 8101a67cbe1SChao Yu if (compr) { 8111a67cbe1SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 8121a67cbe1SChao Yu ret++; 8131a67cbe1SChao Yu } else { 8144c8ff709SChao Yu if (blkaddr != NULL_ADDR) 8154c8ff709SChao Yu ret++; 8164c8ff709SChao Yu } 8174c8ff709SChao Yu } 8181a67cbe1SChao Yu } 8194c8ff709SChao Yu fail: 8204c8ff709SChao Yu f2fs_put_dnode(&dn); 8214c8ff709SChao Yu return ret; 8224c8ff709SChao Yu } 8234c8ff709SChao Yu 8241a67cbe1SChao Yu /* return # of compressed blocks in compressed cluster */ 8251a67cbe1SChao Yu static int f2fs_compressed_blocks(struct compress_ctx *cc) 8261a67cbe1SChao Yu { 8271a67cbe1SChao Yu return __f2fs_cluster_blocks(cc, true); 8281a67cbe1SChao Yu } 8291a67cbe1SChao Yu 8301a67cbe1SChao Yu /* return # of valid blocks in compressed cluster */ 831d078319dSWang Xiaojun static int f2fs_cluster_blocks(struct compress_ctx *cc) 8321a67cbe1SChao Yu { 8331a67cbe1SChao Yu return __f2fs_cluster_blocks(cc, false); 8341a67cbe1SChao Yu } 8351a67cbe1SChao Yu 8364c8ff709SChao Yu int f2fs_is_compressed_cluster(struct inode *inode, pgoff_t index) 8374c8ff709SChao Yu { 8384c8ff709SChao Yu struct compress_ctx cc = { 8394c8ff709SChao Yu .inode = inode, 8404c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 8414c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 8424c8ff709SChao Yu .cluster_idx = index >> F2FS_I(inode)->i_log_cluster_size, 8434c8ff709SChao Yu }; 8444c8ff709SChao Yu 845d078319dSWang Xiaojun return f2fs_cluster_blocks(&cc); 8464c8ff709SChao Yu } 8474c8ff709SChao Yu 8484c8ff709SChao Yu static bool cluster_may_compress(struct compress_ctx *cc) 8494c8ff709SChao Yu { 8504c8ff709SChao Yu if (!f2fs_compressed_file(cc->inode)) 8514c8ff709SChao Yu return false; 8524c8ff709SChao Yu if (f2fs_is_atomic_file(cc->inode)) 8534c8ff709SChao Yu return false; 8544c8ff709SChao Yu if (f2fs_is_mmap_file(cc->inode)) 8554c8ff709SChao Yu return false; 8564c8ff709SChao Yu if (!f2fs_cluster_is_full(cc)) 8574c8ff709SChao Yu return false; 858dc35d73aSChao Yu if (unlikely(f2fs_cp_error(F2FS_I_SB(cc->inode)))) 859dc35d73aSChao Yu return false; 8604c8ff709SChao Yu return __cluster_may_compress(cc); 8614c8ff709SChao Yu } 8624c8ff709SChao Yu 8634c8ff709SChao Yu static void set_cluster_writeback(struct compress_ctx *cc) 8644c8ff709SChao Yu { 8654c8ff709SChao Yu int i; 8664c8ff709SChao Yu 8674c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 8684c8ff709SChao Yu if (cc->rpages[i]) 8694c8ff709SChao Yu set_page_writeback(cc->rpages[i]); 8704c8ff709SChao Yu } 8714c8ff709SChao Yu } 8724c8ff709SChao Yu 8734c8ff709SChao Yu static void set_cluster_dirty(struct compress_ctx *cc) 8744c8ff709SChao Yu { 8754c8ff709SChao Yu int i; 8764c8ff709SChao Yu 8774c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 8784c8ff709SChao Yu if (cc->rpages[i]) 8794c8ff709SChao Yu set_page_dirty(cc->rpages[i]); 8804c8ff709SChao Yu } 8814c8ff709SChao Yu 8824c8ff709SChao Yu static int prepare_compress_overwrite(struct compress_ctx *cc, 8834c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 8844c8ff709SChao Yu { 8854c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 8864c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 8874c8ff709SChao Yu struct page *page; 8884c8ff709SChao Yu struct dnode_of_data dn; 8894c8ff709SChao Yu sector_t last_block_in_bio; 8904c8ff709SChao Yu unsigned fgp_flag = FGP_LOCK | FGP_WRITE | FGP_CREAT; 8914c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 8924c8ff709SChao Yu int i, ret; 8934c8ff709SChao Yu bool prealloc; 8944c8ff709SChao Yu 8954c8ff709SChao Yu retry: 896d078319dSWang Xiaojun ret = f2fs_cluster_blocks(cc); 8974c8ff709SChao Yu if (ret <= 0) 8984c8ff709SChao Yu return ret; 8994c8ff709SChao Yu 9004c8ff709SChao Yu /* compressed case */ 9014c8ff709SChao Yu prealloc = (ret < cc->cluster_size); 9024c8ff709SChao Yu 9034c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 9044c8ff709SChao Yu if (ret) 9054c8ff709SChao Yu return ret; 9064c8ff709SChao Yu 9074c8ff709SChao Yu /* keep page reference to avoid page reclaim */ 9084c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 9094c8ff709SChao Yu page = f2fs_pagecache_get_page(mapping, start_idx + i, 9104c8ff709SChao Yu fgp_flag, GFP_NOFS); 9114c8ff709SChao Yu if (!page) { 9124c8ff709SChao Yu ret = -ENOMEM; 9134c8ff709SChao Yu goto unlock_pages; 9144c8ff709SChao Yu } 9154c8ff709SChao Yu 9164c8ff709SChao Yu if (PageUptodate(page)) 9174c8ff709SChao Yu unlock_page(page); 9184c8ff709SChao Yu else 9194c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 9204c8ff709SChao Yu } 9214c8ff709SChao Yu 9224c8ff709SChao Yu if (!f2fs_cluster_is_empty(cc)) { 9234c8ff709SChao Yu struct bio *bio = NULL; 9244c8ff709SChao Yu 9254c8ff709SChao Yu ret = f2fs_read_multi_pages(cc, &bio, cc->cluster_size, 9260683728aSChao Yu &last_block_in_bio, false, true); 9274c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 9284c8ff709SChao Yu if (ret) 9294c8ff709SChao Yu goto release_pages; 9304c8ff709SChao Yu if (bio) 9314c8ff709SChao Yu f2fs_submit_bio(sbi, bio, DATA); 9324c8ff709SChao Yu 9334c8ff709SChao Yu ret = f2fs_init_compress_ctx(cc); 9344c8ff709SChao Yu if (ret) 9354c8ff709SChao Yu goto release_pages; 9364c8ff709SChao Yu } 9374c8ff709SChao Yu 9384c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 9394c8ff709SChao Yu f2fs_bug_on(sbi, cc->rpages[i]); 9404c8ff709SChao Yu 9414c8ff709SChao Yu page = find_lock_page(mapping, start_idx + i); 9424c8ff709SChao Yu f2fs_bug_on(sbi, !page); 9434c8ff709SChao Yu 9444c8ff709SChao Yu f2fs_wait_on_page_writeback(page, DATA, true, true); 9454c8ff709SChao Yu 9464c8ff709SChao Yu f2fs_compress_ctx_add_page(cc, page); 9474c8ff709SChao Yu f2fs_put_page(page, 0); 9484c8ff709SChao Yu 9494c8ff709SChao Yu if (!PageUptodate(page)) { 9504c8ff709SChao Yu f2fs_unlock_rpages(cc, i + 1); 951bc67c5d0SChao Yu f2fs_put_rpages_mapping(mapping, start_idx, 9524c8ff709SChao Yu cc->cluster_size); 9534c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 9544c8ff709SChao Yu goto retry; 9554c8ff709SChao Yu } 9564c8ff709SChao Yu } 9574c8ff709SChao Yu 9584c8ff709SChao Yu if (prealloc) { 9590ef81833SChao Yu f2fs_do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true); 9604c8ff709SChao Yu 9614c8ff709SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 9624c8ff709SChao Yu 9634c8ff709SChao Yu for (i = cc->cluster_size - 1; i > 0; i--) { 9644c8ff709SChao Yu ret = f2fs_get_block(&dn, start_idx + i); 9654c8ff709SChao Yu if (ret) { 9664c8ff709SChao Yu i = cc->cluster_size; 9674c8ff709SChao Yu break; 9684c8ff709SChao Yu } 9694c8ff709SChao Yu 9704c8ff709SChao Yu if (dn.data_blkaddr != NEW_ADDR) 9714c8ff709SChao Yu break; 9724c8ff709SChao Yu } 9734c8ff709SChao Yu 9740ef81833SChao Yu f2fs_do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false); 9754c8ff709SChao Yu } 9764c8ff709SChao Yu 9774c8ff709SChao Yu if (likely(!ret)) { 9784c8ff709SChao Yu *fsdata = cc->rpages; 9794c8ff709SChao Yu *pagep = cc->rpages[offset_in_cluster(cc, index)]; 9804c8ff709SChao Yu return cc->cluster_size; 9814c8ff709SChao Yu } 9824c8ff709SChao Yu 9834c8ff709SChao Yu unlock_pages: 9844c8ff709SChao Yu f2fs_unlock_rpages(cc, i); 9854c8ff709SChao Yu release_pages: 986bc67c5d0SChao Yu f2fs_put_rpages_mapping(mapping, start_idx, i); 9874c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 9884c8ff709SChao Yu return ret; 9894c8ff709SChao Yu } 9904c8ff709SChao Yu 9914c8ff709SChao Yu int f2fs_prepare_compress_overwrite(struct inode *inode, 9924c8ff709SChao Yu struct page **pagep, pgoff_t index, void **fsdata) 9934c8ff709SChao Yu { 9944c8ff709SChao Yu struct compress_ctx cc = { 9954c8ff709SChao Yu .inode = inode, 9964c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 9974c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 9984c8ff709SChao Yu .cluster_idx = index >> F2FS_I(inode)->i_log_cluster_size, 9994c8ff709SChao Yu .rpages = NULL, 10004c8ff709SChao Yu .nr_rpages = 0, 10014c8ff709SChao Yu }; 10024c8ff709SChao Yu 10034c8ff709SChao Yu return prepare_compress_overwrite(&cc, pagep, index, fsdata); 10044c8ff709SChao Yu } 10054c8ff709SChao Yu 10064c8ff709SChao Yu bool f2fs_compress_write_end(struct inode *inode, void *fsdata, 10074c8ff709SChao Yu pgoff_t index, unsigned copied) 10084c8ff709SChao Yu 10094c8ff709SChao Yu { 10104c8ff709SChao Yu struct compress_ctx cc = { 10114c8ff709SChao Yu .log_cluster_size = F2FS_I(inode)->i_log_cluster_size, 10124c8ff709SChao Yu .cluster_size = F2FS_I(inode)->i_cluster_size, 10134c8ff709SChao Yu .rpages = fsdata, 10144c8ff709SChao Yu }; 10154c8ff709SChao Yu bool first_index = (index == cc.rpages[0]->index); 10164c8ff709SChao Yu 10174c8ff709SChao Yu if (copied) 10184c8ff709SChao Yu set_cluster_dirty(&cc); 10194c8ff709SChao Yu 10204c8ff709SChao Yu f2fs_put_rpages_wbc(&cc, NULL, false, 1); 10214c8ff709SChao Yu f2fs_destroy_compress_ctx(&cc); 10224c8ff709SChao Yu 10234c8ff709SChao Yu return first_index; 10244c8ff709SChao Yu } 10254c8ff709SChao Yu 10263265d3dbSChao Yu int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock) 10273265d3dbSChao Yu { 10283265d3dbSChao Yu void *fsdata = NULL; 10293265d3dbSChao Yu struct page *pagep; 10303265d3dbSChao Yu int log_cluster_size = F2FS_I(inode)->i_log_cluster_size; 10313265d3dbSChao Yu pgoff_t start_idx = from >> (PAGE_SHIFT + log_cluster_size) << 10323265d3dbSChao Yu log_cluster_size; 10333265d3dbSChao Yu int err; 10343265d3dbSChao Yu 10353265d3dbSChao Yu err = f2fs_is_compressed_cluster(inode, start_idx); 10363265d3dbSChao Yu if (err < 0) 10373265d3dbSChao Yu return err; 10383265d3dbSChao Yu 10393265d3dbSChao Yu /* truncate normal cluster */ 10403265d3dbSChao Yu if (!err) 10413265d3dbSChao Yu return f2fs_do_truncate_blocks(inode, from, lock); 10423265d3dbSChao Yu 10433265d3dbSChao Yu /* truncate compressed cluster */ 10443265d3dbSChao Yu err = f2fs_prepare_compress_overwrite(inode, &pagep, 10453265d3dbSChao Yu start_idx, &fsdata); 10463265d3dbSChao Yu 10473265d3dbSChao Yu /* should not be a normal cluster */ 10483265d3dbSChao Yu f2fs_bug_on(F2FS_I_SB(inode), err == 0); 10493265d3dbSChao Yu 10503265d3dbSChao Yu if (err <= 0) 10513265d3dbSChao Yu return err; 10523265d3dbSChao Yu 10533265d3dbSChao Yu if (err > 0) { 10543265d3dbSChao Yu struct page **rpages = fsdata; 10553265d3dbSChao Yu int cluster_size = F2FS_I(inode)->i_cluster_size; 10563265d3dbSChao Yu int i; 10573265d3dbSChao Yu 10583265d3dbSChao Yu for (i = cluster_size - 1; i >= 0; i--) { 10593265d3dbSChao Yu loff_t start = rpages[i]->index << PAGE_SHIFT; 10603265d3dbSChao Yu 10613265d3dbSChao Yu if (from <= start) { 10623265d3dbSChao Yu zero_user_segment(rpages[i], 0, PAGE_SIZE); 10633265d3dbSChao Yu } else { 10643265d3dbSChao Yu zero_user_segment(rpages[i], from - start, 10653265d3dbSChao Yu PAGE_SIZE); 10663265d3dbSChao Yu break; 10673265d3dbSChao Yu } 10683265d3dbSChao Yu } 10693265d3dbSChao Yu 10703265d3dbSChao Yu f2fs_compress_write_end(inode, fsdata, start_idx, true); 10713265d3dbSChao Yu } 10723265d3dbSChao Yu return 0; 10733265d3dbSChao Yu } 10743265d3dbSChao Yu 10754c8ff709SChao Yu static int f2fs_write_compressed_pages(struct compress_ctx *cc, 10764c8ff709SChao Yu int *submitted, 10774c8ff709SChao Yu struct writeback_control *wbc, 10784c8ff709SChao Yu enum iostat_type io_type) 10794c8ff709SChao Yu { 10804c8ff709SChao Yu struct inode *inode = cc->inode; 10814c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 10824c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(inode); 10834c8ff709SChao Yu struct f2fs_io_info fio = { 10844c8ff709SChao Yu .sbi = sbi, 10854c8ff709SChao Yu .ino = cc->inode->i_ino, 10864c8ff709SChao Yu .type = DATA, 10874c8ff709SChao Yu .op = REQ_OP_WRITE, 10884c8ff709SChao Yu .op_flags = wbc_to_write_flags(wbc), 10894c8ff709SChao Yu .old_blkaddr = NEW_ADDR, 10904c8ff709SChao Yu .page = NULL, 10914c8ff709SChao Yu .encrypted_page = NULL, 10924c8ff709SChao Yu .compressed_page = NULL, 10934c8ff709SChao Yu .submitted = false, 10944c8ff709SChao Yu .io_type = io_type, 10954c8ff709SChao Yu .io_wbc = wbc, 10964c8ff709SChao Yu .encrypted = f2fs_encrypted_file(cc->inode), 10974c8ff709SChao Yu }; 10984c8ff709SChao Yu struct dnode_of_data dn; 10994c8ff709SChao Yu struct node_info ni; 11004c8ff709SChao Yu struct compress_io_ctx *cic; 11014c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 11024c8ff709SChao Yu unsigned int last_index = cc->cluster_size - 1; 11034c8ff709SChao Yu loff_t psize; 11044c8ff709SChao Yu int i, err; 11054c8ff709SChao Yu 110679963d96SChao Yu if (IS_NOQUOTA(inode)) { 110779963d96SChao Yu /* 110879963d96SChao Yu * We need to wait for node_write to avoid block allocation during 110979963d96SChao Yu * checkpoint. This can only happen to quota writes which can cause 111079963d96SChao Yu * the below discard race condition. 111179963d96SChao Yu */ 111279963d96SChao Yu down_read(&sbi->node_write); 111379963d96SChao Yu } else if (!f2fs_trylock_op(sbi)) { 1114df77fbd8SChao Yu return -EAGAIN; 111579963d96SChao Yu } 11164c8ff709SChao Yu 1117df77fbd8SChao Yu set_new_dnode(&dn, cc->inode, NULL, NULL, 0); 11184c8ff709SChao Yu 11194c8ff709SChao Yu err = f2fs_get_dnode_of_data(&dn, start_idx, LOOKUP_NODE); 11204c8ff709SChao Yu if (err) 11214c8ff709SChao Yu goto out_unlock_op; 11224c8ff709SChao Yu 11234c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 1124a2ced1ceSChao Yu if (data_blkaddr(dn.inode, dn.node_page, 11254c8ff709SChao Yu dn.ofs_in_node + i) == NULL_ADDR) 11264c8ff709SChao Yu goto out_put_dnode; 11274c8ff709SChao Yu } 11284c8ff709SChao Yu 11294c8ff709SChao Yu psize = (loff_t)(cc->rpages[last_index]->index + 1) << PAGE_SHIFT; 11304c8ff709SChao Yu 11314c8ff709SChao Yu err = f2fs_get_node_info(fio.sbi, dn.nid, &ni); 11324c8ff709SChao Yu if (err) 11334c8ff709SChao Yu goto out_put_dnode; 11344c8ff709SChao Yu 11354c8ff709SChao Yu fio.version = ni.version; 11364c8ff709SChao Yu 11374c8ff709SChao Yu cic = f2fs_kzalloc(sbi, sizeof(struct compress_io_ctx), GFP_NOFS); 11384c8ff709SChao Yu if (!cic) 11394c8ff709SChao Yu goto out_put_dnode; 11404c8ff709SChao Yu 11414c8ff709SChao Yu cic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 11424c8ff709SChao Yu cic->inode = inode; 1143887347a0SChao Yu refcount_set(&cic->ref, cc->nr_cpages); 11444c8ff709SChao Yu cic->rpages = f2fs_kzalloc(sbi, sizeof(struct page *) << 11454c8ff709SChao Yu cc->log_cluster_size, GFP_NOFS); 11464c8ff709SChao Yu if (!cic->rpages) 11474c8ff709SChao Yu goto out_put_cic; 11484c8ff709SChao Yu 11494c8ff709SChao Yu cic->nr_rpages = cc->cluster_size; 11504c8ff709SChao Yu 11514c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 11524c8ff709SChao Yu f2fs_set_compressed_page(cc->cpages[i], inode, 1153887347a0SChao Yu cc->rpages[i + 1]->index, cic); 11544c8ff709SChao Yu fio.compressed_page = cc->cpages[i]; 11554c8ff709SChao Yu if (fio.encrypted) { 11564c8ff709SChao Yu fio.page = cc->rpages[i + 1]; 11574c8ff709SChao Yu err = f2fs_encrypt_one_page(&fio); 11584c8ff709SChao Yu if (err) 11594c8ff709SChao Yu goto out_destroy_crypt; 11604c8ff709SChao Yu cc->cpages[i] = fio.encrypted_page; 11614c8ff709SChao Yu } 11624c8ff709SChao Yu } 11634c8ff709SChao Yu 11644c8ff709SChao Yu set_cluster_writeback(cc); 11654c8ff709SChao Yu 11664c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) 11674c8ff709SChao Yu cic->rpages[i] = cc->rpages[i]; 11684c8ff709SChao Yu 11694c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++, dn.ofs_in_node++) { 11704c8ff709SChao Yu block_t blkaddr; 11714c8ff709SChao Yu 1172a2ced1ceSChao Yu blkaddr = f2fs_data_blkaddr(&dn); 117395978caaSChao Yu fio.page = cc->rpages[i]; 11744c8ff709SChao Yu fio.old_blkaddr = blkaddr; 11754c8ff709SChao Yu 11764c8ff709SChao Yu /* cluster header */ 11774c8ff709SChao Yu if (i == 0) { 11784c8ff709SChao Yu if (blkaddr == COMPRESS_ADDR) 11794c8ff709SChao Yu fio.compr_blocks++; 11804c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) 11814c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 11824c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, COMPRESS_ADDR); 11834c8ff709SChao Yu goto unlock_continue; 11844c8ff709SChao Yu } 11854c8ff709SChao Yu 11864c8ff709SChao Yu if (fio.compr_blocks && __is_valid_data_blkaddr(blkaddr)) 11874c8ff709SChao Yu fio.compr_blocks++; 11884c8ff709SChao Yu 11894c8ff709SChao Yu if (i > cc->nr_cpages) { 11904c8ff709SChao Yu if (__is_valid_data_blkaddr(blkaddr)) { 11914c8ff709SChao Yu f2fs_invalidate_blocks(sbi, blkaddr); 11924c8ff709SChao Yu f2fs_update_data_blkaddr(&dn, NEW_ADDR); 11934c8ff709SChao Yu } 11944c8ff709SChao Yu goto unlock_continue; 11954c8ff709SChao Yu } 11964c8ff709SChao Yu 11974c8ff709SChao Yu f2fs_bug_on(fio.sbi, blkaddr == NULL_ADDR); 11984c8ff709SChao Yu 11994c8ff709SChao Yu if (fio.encrypted) 12004c8ff709SChao Yu fio.encrypted_page = cc->cpages[i - 1]; 12014c8ff709SChao Yu else 12024c8ff709SChao Yu fio.compressed_page = cc->cpages[i - 1]; 12034c8ff709SChao Yu 12044c8ff709SChao Yu cc->cpages[i - 1] = NULL; 12054c8ff709SChao Yu f2fs_outplace_write_data(&dn, &fio); 12064c8ff709SChao Yu (*submitted)++; 12074c8ff709SChao Yu unlock_continue: 12084c8ff709SChao Yu inode_dec_dirty_pages(cc->inode); 12094c8ff709SChao Yu unlock_page(fio.page); 12104c8ff709SChao Yu } 12114c8ff709SChao Yu 12124c8ff709SChao Yu if (fio.compr_blocks) 12134c8ff709SChao Yu f2fs_i_compr_blocks_update(inode, fio.compr_blocks - 1, false); 12144c8ff709SChao Yu f2fs_i_compr_blocks_update(inode, cc->nr_cpages, true); 12154c8ff709SChao Yu 12164c8ff709SChao Yu set_inode_flag(cc->inode, FI_APPEND_WRITE); 12174c8ff709SChao Yu if (cc->cluster_idx == 0) 12184c8ff709SChao Yu set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN); 12194c8ff709SChao Yu 12204c8ff709SChao Yu f2fs_put_dnode(&dn); 122179963d96SChao Yu if (IS_NOQUOTA(inode)) 122279963d96SChao Yu up_read(&sbi->node_write); 122379963d96SChao Yu else 12244c8ff709SChao Yu f2fs_unlock_op(sbi); 12254c8ff709SChao Yu 1226c10c9820SChao Yu spin_lock(&fi->i_size_lock); 12274c8ff709SChao Yu if (fi->last_disk_size < psize) 12284c8ff709SChao Yu fi->last_disk_size = psize; 1229c10c9820SChao Yu spin_unlock(&fi->i_size_lock); 12304c8ff709SChao Yu 12314c8ff709SChao Yu f2fs_put_rpages(cc); 12324c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 12334c8ff709SChao Yu return 0; 12344c8ff709SChao Yu 12354c8ff709SChao Yu out_destroy_crypt: 12364c8ff709SChao Yu kfree(cic->rpages); 12374c8ff709SChao Yu 12384c8ff709SChao Yu for (--i; i >= 0; i--) 12394c8ff709SChao Yu fscrypt_finalize_bounce_page(&cc->cpages[i]); 12404c8ff709SChao Yu for (i = 0; i < cc->nr_cpages; i++) { 12414c8ff709SChao Yu if (!cc->cpages[i]) 12424c8ff709SChao Yu continue; 12434c8ff709SChao Yu f2fs_put_page(cc->cpages[i], 1); 12444c8ff709SChao Yu } 12454c8ff709SChao Yu out_put_cic: 12464c8ff709SChao Yu kfree(cic); 12474c8ff709SChao Yu out_put_dnode: 12484c8ff709SChao Yu f2fs_put_dnode(&dn); 12494c8ff709SChao Yu out_unlock_op: 125079963d96SChao Yu if (IS_NOQUOTA(inode)) 125179963d96SChao Yu up_read(&sbi->node_write); 125279963d96SChao Yu else 12534c8ff709SChao Yu f2fs_unlock_op(sbi); 12544c8ff709SChao Yu return -EAGAIN; 12554c8ff709SChao Yu } 12564c8ff709SChao Yu 12574c8ff709SChao Yu void f2fs_compress_write_end_io(struct bio *bio, struct page *page) 12584c8ff709SChao Yu { 12594c8ff709SChao Yu struct f2fs_sb_info *sbi = bio->bi_private; 12604c8ff709SChao Yu struct compress_io_ctx *cic = 12614c8ff709SChao Yu (struct compress_io_ctx *)page_private(page); 12624c8ff709SChao Yu int i; 12634c8ff709SChao Yu 12644c8ff709SChao Yu if (unlikely(bio->bi_status)) 12654c8ff709SChao Yu mapping_set_error(cic->inode->i_mapping, -EIO); 12664c8ff709SChao Yu 12675e6bbde9SChao Yu f2fs_compress_free_page(page); 12684c8ff709SChao Yu 12694c8ff709SChao Yu dec_page_count(sbi, F2FS_WB_DATA); 12704c8ff709SChao Yu 12714c8ff709SChao Yu if (refcount_dec_not_one(&cic->ref)) 12724c8ff709SChao Yu return; 12734c8ff709SChao Yu 12744c8ff709SChao Yu for (i = 0; i < cic->nr_rpages; i++) { 12754c8ff709SChao Yu WARN_ON(!cic->rpages[i]); 12764c8ff709SChao Yu clear_cold_data(cic->rpages[i]); 12774c8ff709SChao Yu end_page_writeback(cic->rpages[i]); 12784c8ff709SChao Yu } 12794c8ff709SChao Yu 12804c8ff709SChao Yu kfree(cic->rpages); 12814c8ff709SChao Yu kfree(cic); 12824c8ff709SChao Yu } 12834c8ff709SChao Yu 12844c8ff709SChao Yu static int f2fs_write_raw_pages(struct compress_ctx *cc, 12854c8ff709SChao Yu int *submitted, 12864c8ff709SChao Yu struct writeback_control *wbc, 12874c8ff709SChao Yu enum iostat_type io_type) 12884c8ff709SChao Yu { 12894c8ff709SChao Yu struct address_space *mapping = cc->inode->i_mapping; 12904c8ff709SChao Yu int _submitted, compr_blocks, ret; 12914c8ff709SChao Yu int i = -1, err = 0; 12924c8ff709SChao Yu 12934c8ff709SChao Yu compr_blocks = f2fs_compressed_blocks(cc); 12944c8ff709SChao Yu if (compr_blocks < 0) { 12954c8ff709SChao Yu err = compr_blocks; 12964c8ff709SChao Yu goto out_err; 12974c8ff709SChao Yu } 12984c8ff709SChao Yu 12994c8ff709SChao Yu for (i = 0; i < cc->cluster_size; i++) { 13004c8ff709SChao Yu if (!cc->rpages[i]) 13014c8ff709SChao Yu continue; 13024c8ff709SChao Yu retry_write: 13034c8ff709SChao Yu if (cc->rpages[i]->mapping != mapping) { 13044c8ff709SChao Yu unlock_page(cc->rpages[i]); 13054c8ff709SChao Yu continue; 13064c8ff709SChao Yu } 13074c8ff709SChao Yu 13084c8ff709SChao Yu BUG_ON(!PageLocked(cc->rpages[i])); 13094c8ff709SChao Yu 13104c8ff709SChao Yu ret = f2fs_write_single_data_page(cc->rpages[i], &_submitted, 13114c8ff709SChao Yu NULL, NULL, wbc, io_type, 13124c8ff709SChao Yu compr_blocks); 13134c8ff709SChao Yu if (ret) { 13144c8ff709SChao Yu if (ret == AOP_WRITEPAGE_ACTIVATE) { 13154c8ff709SChao Yu unlock_page(cc->rpages[i]); 13164c8ff709SChao Yu ret = 0; 13174c8ff709SChao Yu } else if (ret == -EAGAIN) { 1318466357dcSChao Yu /* 1319466357dcSChao Yu * for quota file, just redirty left pages to 1320466357dcSChao Yu * avoid deadlock caused by cluster update race 1321466357dcSChao Yu * from foreground operation. 1322466357dcSChao Yu */ 1323466357dcSChao Yu if (IS_NOQUOTA(cc->inode)) { 1324466357dcSChao Yu err = 0; 1325466357dcSChao Yu goto out_err; 1326466357dcSChao Yu } 13274c8ff709SChao Yu ret = 0; 13284c8ff709SChao Yu cond_resched(); 13295df7731fSChao Yu congestion_wait(BLK_RW_ASYNC, 13305df7731fSChao Yu DEFAULT_IO_TIMEOUT); 13314c8ff709SChao Yu lock_page(cc->rpages[i]); 1332eb1353cfSChao Yu 1333eb1353cfSChao Yu if (!PageDirty(cc->rpages[i])) { 1334eb1353cfSChao Yu unlock_page(cc->rpages[i]); 1335eb1353cfSChao Yu continue; 1336eb1353cfSChao Yu } 1337eb1353cfSChao Yu 13384c8ff709SChao Yu clear_page_dirty_for_io(cc->rpages[i]); 13394c8ff709SChao Yu goto retry_write; 13404c8ff709SChao Yu } 13414c8ff709SChao Yu err = ret; 1342466357dcSChao Yu goto out_err; 13434c8ff709SChao Yu } 13444c8ff709SChao Yu 13454c8ff709SChao Yu *submitted += _submitted; 13464c8ff709SChao Yu } 13474c8ff709SChao Yu return 0; 13484c8ff709SChao Yu out_err: 13494c8ff709SChao Yu for (++i; i < cc->cluster_size; i++) { 13504c8ff709SChao Yu if (!cc->rpages[i]) 13514c8ff709SChao Yu continue; 13524c8ff709SChao Yu redirty_page_for_writepage(wbc, cc->rpages[i]); 13534c8ff709SChao Yu unlock_page(cc->rpages[i]); 13544c8ff709SChao Yu } 13554c8ff709SChao Yu return err; 13564c8ff709SChao Yu } 13574c8ff709SChao Yu 13584c8ff709SChao Yu int f2fs_write_multi_pages(struct compress_ctx *cc, 13594c8ff709SChao Yu int *submitted, 13604c8ff709SChao Yu struct writeback_control *wbc, 13614c8ff709SChao Yu enum iostat_type io_type) 13624c8ff709SChao Yu { 13634c8ff709SChao Yu struct f2fs_inode_info *fi = F2FS_I(cc->inode); 13644c8ff709SChao Yu const struct f2fs_compress_ops *cops = 13654c8ff709SChao Yu f2fs_cops[fi->i_compress_algorithm]; 13664c8ff709SChao Yu int err; 13674c8ff709SChao Yu 13684c8ff709SChao Yu *submitted = 0; 13694c8ff709SChao Yu if (cluster_may_compress(cc)) { 13704c8ff709SChao Yu err = f2fs_compress_pages(cc); 13714c8ff709SChao Yu if (err == -EAGAIN) { 13724c8ff709SChao Yu goto write; 13734c8ff709SChao Yu } else if (err) { 13744c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, true, 1); 13754c8ff709SChao Yu goto destroy_out; 13764c8ff709SChao Yu } 13774c8ff709SChao Yu 13784c8ff709SChao Yu err = f2fs_write_compressed_pages(cc, submitted, 13794c8ff709SChao Yu wbc, io_type); 13804c8ff709SChao Yu cops->destroy_compress_ctx(cc); 13814c8ff709SChao Yu if (!err) 13824c8ff709SChao Yu return 0; 13834c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), err != -EAGAIN); 13844c8ff709SChao Yu } 13854c8ff709SChao Yu write: 13864c8ff709SChao Yu f2fs_bug_on(F2FS_I_SB(cc->inode), *submitted); 13874c8ff709SChao Yu 13884c8ff709SChao Yu err = f2fs_write_raw_pages(cc, submitted, wbc, io_type); 13894c8ff709SChao Yu f2fs_put_rpages_wbc(cc, wbc, false, 0); 13904c8ff709SChao Yu destroy_out: 13914c8ff709SChao Yu f2fs_destroy_compress_ctx(cc); 13924c8ff709SChao Yu return err; 13934c8ff709SChao Yu } 13944c8ff709SChao Yu 13954c8ff709SChao Yu struct decompress_io_ctx *f2fs_alloc_dic(struct compress_ctx *cc) 13964c8ff709SChao Yu { 13974c8ff709SChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(cc->inode); 13984c8ff709SChao Yu struct decompress_io_ctx *dic; 13994c8ff709SChao Yu pgoff_t start_idx = start_idx_of_cluster(cc); 14004c8ff709SChao Yu int i; 14014c8ff709SChao Yu 14024c8ff709SChao Yu dic = f2fs_kzalloc(sbi, sizeof(struct decompress_io_ctx), GFP_NOFS); 14034c8ff709SChao Yu if (!dic) 14044c8ff709SChao Yu return ERR_PTR(-ENOMEM); 14054c8ff709SChao Yu 14064c8ff709SChao Yu dic->rpages = f2fs_kzalloc(sbi, sizeof(struct page *) << 14074c8ff709SChao Yu cc->log_cluster_size, GFP_NOFS); 14084c8ff709SChao Yu if (!dic->rpages) { 14094c8ff709SChao Yu kfree(dic); 14104c8ff709SChao Yu return ERR_PTR(-ENOMEM); 14114c8ff709SChao Yu } 14124c8ff709SChao Yu 14134c8ff709SChao Yu dic->magic = F2FS_COMPRESSED_PAGE_MAGIC; 14144c8ff709SChao Yu dic->inode = cc->inode; 1415887347a0SChao Yu refcount_set(&dic->ref, cc->nr_cpages); 14164c8ff709SChao Yu dic->cluster_idx = cc->cluster_idx; 14174c8ff709SChao Yu dic->cluster_size = cc->cluster_size; 14184c8ff709SChao Yu dic->log_cluster_size = cc->log_cluster_size; 14194c8ff709SChao Yu dic->nr_cpages = cc->nr_cpages; 14204c8ff709SChao Yu dic->failed = false; 14214c8ff709SChao Yu 14224c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) 14234c8ff709SChao Yu dic->rpages[i] = cc->rpages[i]; 14244c8ff709SChao Yu dic->nr_rpages = cc->cluster_size; 14254c8ff709SChao Yu 14264c8ff709SChao Yu dic->cpages = f2fs_kzalloc(sbi, sizeof(struct page *) * 14274c8ff709SChao Yu dic->nr_cpages, GFP_NOFS); 14284c8ff709SChao Yu if (!dic->cpages) 14294c8ff709SChao Yu goto out_free; 14304c8ff709SChao Yu 14314c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 14324c8ff709SChao Yu struct page *page; 14334c8ff709SChao Yu 14345e6bbde9SChao Yu page = f2fs_compress_alloc_page(); 14354c8ff709SChao Yu if (!page) 14364c8ff709SChao Yu goto out_free; 14374c8ff709SChao Yu 14384c8ff709SChao Yu f2fs_set_compressed_page(page, cc->inode, 1439887347a0SChao Yu start_idx + i + 1, dic); 14404c8ff709SChao Yu dic->cpages[i] = page; 14414c8ff709SChao Yu } 14424c8ff709SChao Yu 14434c8ff709SChao Yu dic->tpages = f2fs_kzalloc(sbi, sizeof(struct page *) * 14444c8ff709SChao Yu dic->cluster_size, GFP_NOFS); 14454c8ff709SChao Yu if (!dic->tpages) 14464c8ff709SChao Yu goto out_free; 14474c8ff709SChao Yu 14484c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) { 144980d0d45aSChao Yu if (cc->rpages[i]) { 145080d0d45aSChao Yu dic->tpages[i] = cc->rpages[i]; 14514c8ff709SChao Yu continue; 145280d0d45aSChao Yu } 14534c8ff709SChao Yu 14545e6bbde9SChao Yu dic->tpages[i] = f2fs_compress_alloc_page(); 14554c8ff709SChao Yu if (!dic->tpages[i]) 14564c8ff709SChao Yu goto out_free; 14574c8ff709SChao Yu } 14584c8ff709SChao Yu 14594c8ff709SChao Yu return dic; 14604c8ff709SChao Yu 14614c8ff709SChao Yu out_free: 14624c8ff709SChao Yu f2fs_free_dic(dic); 14634c8ff709SChao Yu return ERR_PTR(-ENOMEM); 14644c8ff709SChao Yu } 14654c8ff709SChao Yu 14664c8ff709SChao Yu void f2fs_free_dic(struct decompress_io_ctx *dic) 14674c8ff709SChao Yu { 14684c8ff709SChao Yu int i; 14694c8ff709SChao Yu 14704c8ff709SChao Yu if (dic->tpages) { 14714c8ff709SChao Yu for (i = 0; i < dic->cluster_size; i++) { 14724c8ff709SChao Yu if (dic->rpages[i]) 14734c8ff709SChao Yu continue; 14748908e753SChao Yu if (!dic->tpages[i]) 14758908e753SChao Yu continue; 14765e6bbde9SChao Yu f2fs_compress_free_page(dic->tpages[i]); 14774c8ff709SChao Yu } 14784c8ff709SChao Yu kfree(dic->tpages); 14794c8ff709SChao Yu } 14804c8ff709SChao Yu 14814c8ff709SChao Yu if (dic->cpages) { 14824c8ff709SChao Yu for (i = 0; i < dic->nr_cpages; i++) { 14834c8ff709SChao Yu if (!dic->cpages[i]) 14844c8ff709SChao Yu continue; 14855e6bbde9SChao Yu f2fs_compress_free_page(dic->cpages[i]); 14864c8ff709SChao Yu } 14874c8ff709SChao Yu kfree(dic->cpages); 14884c8ff709SChao Yu } 14894c8ff709SChao Yu 14904c8ff709SChao Yu kfree(dic->rpages); 14914c8ff709SChao Yu kfree(dic); 14924c8ff709SChao Yu } 14934c8ff709SChao Yu 14944c8ff709SChao Yu void f2fs_decompress_end_io(struct page **rpages, 14954c8ff709SChao Yu unsigned int cluster_size, bool err, bool verity) 14964c8ff709SChao Yu { 14974c8ff709SChao Yu int i; 14984c8ff709SChao Yu 14994c8ff709SChao Yu for (i = 0; i < cluster_size; i++) { 15004c8ff709SChao Yu struct page *rpage = rpages[i]; 15014c8ff709SChao Yu 15024c8ff709SChao Yu if (!rpage) 15034c8ff709SChao Yu continue; 15044c8ff709SChao Yu 150523c51bedSChao Yu if (err || PageError(rpage)) 150623c51bedSChao Yu goto clear_uptodate; 150723c51bedSChao Yu 150823c51bedSChao Yu if (!verity || fsverity_verify_page(rpage)) { 150923c51bedSChao Yu SetPageUptodate(rpage); 151023c51bedSChao Yu goto unlock; 151123c51bedSChao Yu } 151223c51bedSChao Yu clear_uptodate: 15134c8ff709SChao Yu ClearPageUptodate(rpage); 15144c8ff709SChao Yu ClearPageError(rpage); 151523c51bedSChao Yu unlock: 15164c8ff709SChao Yu unlock_page(rpage); 15174c8ff709SChao Yu } 15184c8ff709SChao Yu } 1519