Update bcachefs sources to ed6b7f81a7 six locks: Disable percpu read lock mode in...

[bcachefs-tools-debian] / libbcachefs / compress.c

diff --git a/libbcachefs/compress.c b/libbcachefs/compress.c
index 7d9ebcc9a4457bcf28a567e4fd28552c7f3d6e9d..38a3475b1897d7a501aefacac36dcd098355806b 100644 (file)
--- a/libbcachefs/compress.c
+++ b/libbcachefs/compress.c
@@ -28,11 +28,11 @@ static struct bbuf __bounce_alloc(struct bch_fs *c, unsigned size, int rw)
 
        BUG_ON(size > c->opts.encoded_extent_max);
 
-       b = kmalloc(size, GFP_NOIO|__GFP_NOWARN);
+       b = kmalloc(size, GFP_NOFS|__GFP_NOWARN);
        if (b)
                return (struct bbuf) { .b = b, .type = BB_KMALLOC, .rw = rw };
 
-       b = mempool_alloc(&c->compression_bounce[rw], GFP_NOIO);
+       b = mempool_alloc(&c->compression_bounce[rw], GFP_NOFS);
        if (b)
                return (struct bbuf) { .b = b, .type = BB_MEMPOOL, .rw = rw };
 
@@ -94,7 +94,7 @@ static struct bbuf __bio_map_or_bounce(struct bch_fs *c, struct bio *bio,
        BUG_ON(DIV_ROUND_UP(start.bi_size, PAGE_SIZE) > nr_pages);
 
        pages = nr_pages > ARRAY_SIZE(stack_pages)
-               ? kmalloc_array(nr_pages, sizeof(struct page *), GFP_NOIO)
+               ? kmalloc_array(nr_pages, sizeof(struct page *), GFP_NOFS)
                : stack_pages;
        if (!pages)
                goto bounce;
@@ -177,7 +177,7 @@ static int __bio_uncompress(struct bch_fs *c, struct bio *src,
                        .avail_out      = dst_len,
                };
 
-               workspace = mempool_alloc(&c->decompress_workspace, GFP_NOIO);
+               workspace = mempool_alloc(&c->decompress_workspace, GFP_NOFS);
 
                zlib_set_workspace(&strm, workspace);
                zlib_inflateInit2(&strm, -MAX_WBITS);
@@ -196,11 +196,9 @@ static int __bio_uncompress(struct bch_fs *c, struct bio *src,
                if (real_src_len > src_len - 4)
                        goto err;
 
-               workspace = mempool_alloc(&c->decompress_workspace, GFP_NOIO);
+               workspace = mempool_alloc(&c->decompress_workspace, GFP_NOFS);
                ctx = zstd_init_dctx(workspace, zstd_dctx_workspace_bound());
 
-               src_len = le32_to_cpup(src_data.b);
-
                ret = zstd_decompress_dctx(ctx,
                                dst_data,       dst_len,
                                src_data.b + 4, real_src_len);
@@ -272,7 +270,7 @@ int bch2_bio_uncompress(struct bch_fs *c, struct bio *src,
 {
        struct bbuf dst_data = { NULL };
        size_t dst_len = crc.uncompressed_size << 9;
-       int ret = -ENOMEM;
+       int ret;
 
        if (crc.uncompressed_size << 9  > c->opts.encoded_extent_max ||
            crc.compressed_size << 9    > c->opts.encoded_extent_max)
@@ -379,12 +377,12 @@ static unsigned __bio_compress(struct bch_fs *c,
 
        /* If it's only one block, don't bother trying to compress: */
        if (src->bi_iter.bi_size <= c->opts.block_size)
-               return 0;
+               return BCH_COMPRESSION_TYPE_incompressible;
 
        dst_data = bio_map_or_bounce(c, dst, WRITE);
        src_data = bio_map_or_bounce(c, src, READ);
 
-       workspace = mempool_alloc(&c->compress_workspace[compression_type], GFP_NOIO);
+       workspace = mempool_alloc(&c->compress_workspace[compression_type], GFP_NOFS);
 
        *src_len = src->bi_iter.bi_size;
        *dst_len = dst->bi_iter.bi_size;
@@ -544,7 +542,7 @@ void bch2_fs_compress_exit(struct bch_fs *c)
        mempool_exit(&c->compression_bounce[READ]);
 }
 
-static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
+static int _bch2_fs_compress_init(struct bch_fs *c, u64 features)
 {
        size_t decompress_workspace_size = 0;
        bool decompress_workspace_needed;
@@ -563,34 +561,27 @@ static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
                        zstd_cctx_workspace_bound(&params.cParams),
                        zstd_dctx_workspace_bound() },
        }, *i;
-       int ret = 0;
-
-       pr_verbose_init(c->opts, "");
+       bool have_compressed = false;
 
        c->zstd_params = params;
 
        for (i = compression_types;
             i < compression_types + ARRAY_SIZE(compression_types);
             i++)
-               if (features & (1 << i->feature))
-                       goto have_compressed;
+               have_compressed |= (features & (1 << i->feature)) != 0;
 
-       goto out;
-have_compressed:
+       if (!have_compressed)
+               return 0;
 
-       if (!mempool_initialized(&c->compression_bounce[READ])) {
-               ret = mempool_init_kvpmalloc_pool(&c->compression_bounce[READ],
-                                                 1, c->opts.encoded_extent_max);
-               if (ret)
-                       goto out;
-       }
+       if (!mempool_initialized(&c->compression_bounce[READ]) &&
+           mempool_init_kvpmalloc_pool(&c->compression_bounce[READ],
+                                       1, c->opts.encoded_extent_max))
+               return -BCH_ERR_ENOMEM_compression_bounce_read_init;
 
-       if (!mempool_initialized(&c->compression_bounce[WRITE])) {
-               ret = mempool_init_kvpmalloc_pool(&c->compression_bounce[WRITE],
-                                                 1, c->opts.encoded_extent_max);
-               if (ret)
-                       goto out;
-       }
+       if (!mempool_initialized(&c->compression_bounce[WRITE]) &&
+           mempool_init_kvpmalloc_pool(&c->compression_bounce[WRITE],
+                                       1, c->opts.encoded_extent_max))
+               return -BCH_ERR_ENOMEM_compression_bounce_write_init;
 
        for (i = compression_types;
             i < compression_types + ARRAY_SIZE(compression_types);
@@ -607,22 +598,28 @@ have_compressed:
                if (mempool_initialized(&c->compress_workspace[i->type]))
                        continue;
 
-               ret = mempool_init_kvpmalloc_pool(
+               if (mempool_init_kvpmalloc_pool(
                                &c->compress_workspace[i->type],
-                               1, i->compress_workspace);
-               if (ret)
-                       goto out;
+                               1, i->compress_workspace))
+                       return -BCH_ERR_ENOMEM_compression_workspace_init;
        }
 
-       if (!mempool_initialized(&c->decompress_workspace)) {
-               ret = mempool_init_kvpmalloc_pool(
-                               &c->decompress_workspace,
-                               1, decompress_workspace_size);
-               if (ret)
-                       goto out;
-       }
-out:
+       if (!mempool_initialized(&c->decompress_workspace) &&
+           mempool_init_kvpmalloc_pool(&c->decompress_workspace,
+                                       1, decompress_workspace_size))
+               return -BCH_ERR_ENOMEM_decompression_workspace_init;
+
+       return 0;
+}
+
+static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
+{
+       int ret;
+
+       pr_verbose_init(c->opts, "");
+       ret = _bch2_fs_compress_init(c, features);
        pr_verbose_init(c->opts, "ret %i", ret);
+
        return ret;
 }