git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/compress.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "bcachefs.h"
   3 #include "checksum.h"
   4 #include "compress.h"
   5 #include "extents.h"
   6 #include "io.h"
   7 #include "super-io.h"
   8
   9 #include <linux/lz4.h>
  10 #include <linux/zlib.h>
  11 #include <linux/zstd.h>
  12
  13 /* Bounce buffer: */
  14 struct bbuf {
  15         void            *b;
  16         enum {
  17                 BB_NONE,
  18                 BB_VMAP,
  19                 BB_KMALLOC,
  20                 BB_MEMPOOL,
  21         }               type;
  22         int             rw;
  23 };
  24
  25 static struct bbuf __bounce_alloc(struct bch_fs *c, unsigned size, int rw)
  26 {
  27         void *b;
  28
  29         BUG_ON(size > c->opts.encoded_extent_max);
  30
  31         b = kmalloc(size, GFP_NOFS|__GFP_NOWARN);
  32         if (b)
  33                 return (struct bbuf) { .b = b, .type = BB_KMALLOC, .rw = rw };
  34
  35         b = mempool_alloc(&c->compression_bounce[rw], GFP_NOFS);
  36         if (b)
  37                 return (struct bbuf) { .b = b, .type = BB_MEMPOOL, .rw = rw };
  38
  39         BUG();
  40 }
  41
  42 static bool bio_phys_contig(struct bio *bio, struct bvec_iter start)
  43 {
  44         struct bio_vec bv;
  45         struct bvec_iter iter;
  46         void *expected_start = NULL;
  47
  48         __bio_for_each_bvec(bv, bio, iter, start) {
  49                 if (expected_start &&
  50                     expected_start != page_address(bv.bv_page) + bv.bv_offset)
  51                         return false;
  52
  53                 expected_start = page_address(bv.bv_page) +
  54                         bv.bv_offset + bv.bv_len;
  55         }
  56
  57         return true;
  58 }
  59
  60 static struct bbuf __bio_map_or_bounce(struct bch_fs *c, struct bio *bio,
  61                                        struct bvec_iter start, int rw)
  62 {
  63         struct bbuf ret;
  64         struct bio_vec bv;
  65         struct bvec_iter iter;
  66         unsigned nr_pages = 0;
  67         struct page *stack_pages[16];
  68         struct page **pages = NULL;
  69         void *data;
  70
  71         BUG_ON(start.bi_size > c->opts.encoded_extent_max);
  72
  73         if (!PageHighMem(bio_iter_page(bio, start)) &&
  74             bio_phys_contig(bio, start))
  75                 return (struct bbuf) {
  76                         .b = page_address(bio_iter_page(bio, start)) +
  77                                 bio_iter_offset(bio, start),
  78                         .type = BB_NONE, .rw = rw
  79                 };
  80
  81         /* check if we can map the pages contiguously: */
  82         __bio_for_each_segment(bv, bio, iter, start) {
  83                 if (iter.bi_size != start.bi_size &&
  84                     bv.bv_offset)
  85                         goto bounce;
  86
  87                 if (bv.bv_len < iter.bi_size &&
  88                     bv.bv_offset + bv.bv_len < PAGE_SIZE)
  89                         goto bounce;
  90
  91                 nr_pages++;
  92         }
  93
  94         BUG_ON(DIV_ROUND_UP(start.bi_size, PAGE_SIZE) > nr_pages);
  95
  96         pages = nr_pages > ARRAY_SIZE(stack_pages)
  97                 ? kmalloc_array(nr_pages, sizeof(struct page *), GFP_NOFS)
  98                 : stack_pages;
  99         if (!pages)
 100                 goto bounce;
 101
 102         nr_pages = 0;
 103         __bio_for_each_segment(bv, bio, iter, start)
 104                 pages[nr_pages++] = bv.bv_page;
 105
 106         data = vmap(pages, nr_pages, VM_MAP, PAGE_KERNEL);
 107         if (pages != stack_pages)
 108                 kfree(pages);
 109
 110         if (data)
 111                 return (struct bbuf) {
 112                         .b = data + bio_iter_offset(bio, start),
 113                         .type = BB_VMAP, .rw = rw
 114                 };
 115 bounce:
 116         ret = __bounce_alloc(c, start.bi_size, rw);
 117
 118         if (rw == READ)
 119                 memcpy_from_bio(ret.b, bio, start);
 120
 121         return ret;
 122 }
 123
 124 static struct bbuf bio_map_or_bounce(struct bch_fs *c, struct bio *bio, int rw)
 125 {
 126         return __bio_map_or_bounce(c, bio, bio->bi_iter, rw);
 127 }
 128
 129 static void bio_unmap_or_unbounce(struct bch_fs *c, struct bbuf buf)
 130 {
 131         switch (buf.type) {
 132         case BB_NONE:
 133                 break;
 134         case BB_VMAP:
 135                 vunmap((void *) ((unsigned long) buf.b & PAGE_MASK));
 136                 break;
 137         case BB_KMALLOC:
 138                 kfree(buf.b);
 139                 break;
 140         case BB_MEMPOOL:
 141                 mempool_free(buf.b, &c->compression_bounce[buf.rw]);
 142                 break;
 143         }
 144 }
 145
 146 static inline void zlib_set_workspace(z_stream *strm, void *workspace)
 147 {
 148 #ifdef __KERNEL__
 149         strm->workspace = workspace;
 150 #endif
 151 }
 152
 153 static int __bio_uncompress(struct bch_fs *c, struct bio *src,
 154                             void *dst_data, struct bch_extent_crc_unpacked crc)
 155 {
 156         struct bbuf src_data = { NULL };
 157         size_t src_len = src->bi_iter.bi_size;
 158         size_t dst_len = crc.uncompressed_size << 9;
 159         void *workspace;
 160         int ret;
 161
 162         src_data = bio_map_or_bounce(c, src, READ);
 163
 164         switch (crc.compression_type) {
 165         case BCH_COMPRESSION_TYPE_lz4_old:
 166         case BCH_COMPRESSION_TYPE_lz4:
 167                 ret = LZ4_decompress_safe_partial(src_data.b, dst_data,
 168                                                   src_len, dst_len, dst_len);
 169                 if (ret != dst_len)
 170                         goto err;
 171                 break;
 172         case BCH_COMPRESSION_TYPE_gzip: {
 173                 z_stream strm = {
 174                         .next_in        = src_data.b,
 175                         .avail_in       = src_len,
 176                         .next_out       = dst_data,
 177                         .avail_out      = dst_len,
 178                 };
 179
 180                 workspace = mempool_alloc(&c->decompress_workspace, GFP_NOFS);
 181
 182                 zlib_set_workspace(&strm, workspace);
 183                 zlib_inflateInit2(&strm, -MAX_WBITS);
 184                 ret = zlib_inflate(&strm, Z_FINISH);
 185
 186                 mempool_free(workspace, &c->decompress_workspace);
 187
 188                 if (ret != Z_STREAM_END)
 189                         goto err;
 190                 break;
 191         }
 192         case BCH_COMPRESSION_TYPE_zstd: {
 193                 ZSTD_DCtx *ctx;
 194                 size_t real_src_len = le32_to_cpup(src_data.b);
 195
 196                 if (real_src_len > src_len - 4)
 197                         goto err;
 198
 199                 workspace = mempool_alloc(&c->decompress_workspace, GFP_NOFS);
 200                 ctx = zstd_init_dctx(workspace, zstd_dctx_workspace_bound());
 201
 202                 ret = zstd_decompress_dctx(ctx,
 203                                 dst_data,       dst_len,
 204                                 src_data.b + 4, real_src_len);
 205
 206                 mempool_free(workspace, &c->decompress_workspace);
 207
 208                 if (ret != dst_len)
 209                         goto err;
 210                 break;
 211         }
 212         default:
 213                 BUG();
 214         }
 215         ret = 0;
 216 out:
 217         bio_unmap_or_unbounce(c, src_data);
 218         return ret;
 219 err:
 220         ret = -EIO;
 221         goto out;
 222 }
 223
 224 int bch2_bio_uncompress_inplace(struct bch_fs *c, struct bio *bio,
 225                                 struct bch_extent_crc_unpacked *crc)
 226 {
 227         struct bbuf data = { NULL };
 228         size_t dst_len = crc->uncompressed_size << 9;
 229
 230         /* bio must own its pages: */
 231         BUG_ON(!bio->bi_vcnt);
 232         BUG_ON(DIV_ROUND_UP(crc->live_size, PAGE_SECTORS) > bio->bi_max_vecs);
 233
 234         if (crc->uncompressed_size << 9 > c->opts.encoded_extent_max ||
 235             crc->compressed_size << 9   > c->opts.encoded_extent_max) {
 236                 bch_err(c, "error rewriting existing data: extent too big");
 237                 return -EIO;
 238         }
 239
 240         data = __bounce_alloc(c, dst_len, WRITE);
 241
 242         if (__bio_uncompress(c, bio, data.b, *crc)) {
 243                 if (!c->opts.no_data_io)
 244                         bch_err(c, "error rewriting existing data: decompression error");
 245                 bio_unmap_or_unbounce(c, data);
 246                 return -EIO;
 247         }
 248
 249         /*
 250          * XXX: don't have a good way to assert that the bio was allocated with
 251          * enough space, we depend on bch2_move_extent doing the right thing
 252          */
 253         bio->bi_iter.bi_size = crc->live_size << 9;
 254
 255         memcpy_to_bio(bio, bio->bi_iter, data.b + (crc->offset << 9));
 256
 257         crc->csum_type          = 0;
 258         crc->compression_type   = 0;
 259         crc->compressed_size    = crc->live_size;
 260         crc->uncompressed_size  = crc->live_size;
 261         crc->offset             = 0;
 262         crc->csum               = (struct bch_csum) { 0, 0 };
 263
 264         bio_unmap_or_unbounce(c, data);
 265         return 0;
 266 }
 267
 268 int bch2_bio_uncompress(struct bch_fs *c, struct bio *src,
 269                        struct bio *dst, struct bvec_iter dst_iter,
 270                        struct bch_extent_crc_unpacked crc)
 271 {
 272         struct bbuf dst_data = { NULL };
 273         size_t dst_len = crc.uncompressed_size << 9;
 274         int ret;
 275
 276         if (crc.uncompressed_size << 9  > c->opts.encoded_extent_max ||
 277             crc.compressed_size << 9    > c->opts.encoded_extent_max)
 278                 return -EIO;
 279
 280         dst_data = dst_len == dst_iter.bi_size
 281                 ? __bio_map_or_bounce(c, dst, dst_iter, WRITE)
 282                 : __bounce_alloc(c, dst_len, WRITE);
 283
 284         ret = __bio_uncompress(c, src, dst_data.b, crc);
 285         if (ret)
 286                 goto err;
 287
 288         if (dst_data.type != BB_NONE &&
 289             dst_data.type != BB_VMAP)
 290                 memcpy_to_bio(dst, dst_iter, dst_data.b + (crc.offset << 9));
 291 err:
 292         bio_unmap_or_unbounce(c, dst_data);
 293         return ret;
 294 }
 295
 296 static int attempt_compress(struct bch_fs *c,
 297                             void *workspace,
 298                             void *dst, size_t dst_len,
 299                             void *src, size_t src_len,
 300                             struct bch_compression_opt compression)
 301 {
 302         enum bch_compression_type compression_type =
 303                 __bch2_compression_opt_to_type[compression.type];
 304
 305         switch (compression_type) {
 306         case BCH_COMPRESSION_TYPE_lz4:
 307                 if (compression.level < LZ4HC_MIN_CLEVEL) {
 308                         int len = src_len;
 309                         int ret = LZ4_compress_destSize(
 310                                         src,            dst,
 311                                         &len,           dst_len,
 312                                         workspace);
 313                         if (len < src_len)
 314                                 return -len;
 315
 316                         return ret;
 317                 } else {
 318                         int ret = LZ4_compress_HC(
 319                                         src,            dst,
 320                                         src_len,        dst_len,
 321                                         compression.level,
 322                                         workspace);
 323
 324                         return ret ?: -1;
 325                 }
 326         case BCH_COMPRESSION_TYPE_gzip: {
 327                 z_stream strm = {
 328                         .next_in        = src,
 329                         .avail_in       = src_len,
 330                         .next_out       = dst,
 331                         .avail_out      = dst_len,
 332                 };
 333
 334                 zlib_set_workspace(&strm, workspace);
 335                 zlib_deflateInit2(&strm,
 336                                   compression.level
 337                                   ? clamp_t(unsigned, compression.level,
 338                                             Z_BEST_SPEED, Z_BEST_COMPRESSION)
 339                                   : Z_DEFAULT_COMPRESSION,
 340                                   Z_DEFLATED, -MAX_WBITS, DEF_MEM_LEVEL,
 341                                   Z_DEFAULT_STRATEGY);
 342
 343                 if (zlib_deflate(&strm, Z_FINISH) != Z_STREAM_END)
 344                         return 0;
 345
 346                 if (zlib_deflateEnd(&strm) != Z_OK)
 347                         return 0;
 348
 349                 return strm.total_out;
 350         }
 351         case BCH_COMPRESSION_TYPE_zstd: {
 352                 /*
 353                  * rescale:
 354                  * zstd max compression level is 22, our max level is 15
 355                  */
 356                 unsigned level = min((compression.level * 3) / 2, zstd_max_clevel());
 357                 ZSTD_parameters params = zstd_get_params(level, c->opts.encoded_extent_max);
 358                 ZSTD_CCtx *ctx = zstd_init_cctx(workspace,
 359                         zstd_cctx_workspace_bound(&params.cParams));
 360
 361                 /*
 362                  * ZSTD requires that when we decompress we pass in the exact
 363                  * compressed size - rounding it up to the nearest sector
 364                  * doesn't work, so we use the first 4 bytes of the buffer for
 365                  * that.
 366                  *
 367                  * Additionally, the ZSTD code seems to have a bug where it will
 368                  * write just past the end of the buffer - so subtract a fudge
 369                  * factor (7 bytes) from the dst buffer size to account for
 370                  * that.
 371                  */
 372                 size_t len = zstd_compress_cctx(ctx,
 373                                 dst + 4,        dst_len - 4 - 7,
 374                                 src,            src_len,
 375                                 &c->zstd_params);
 376                 if (zstd_is_error(len))
 377                         return 0;
 378
 379                 *((__le32 *) dst) = cpu_to_le32(len);
 380                 return len + 4;
 381         }
 382         default:
 383                 BUG();
 384         }
 385 }
 386
 387 static unsigned __bio_compress(struct bch_fs *c,
 388                                struct bio *dst, size_t *dst_len,
 389                                struct bio *src, size_t *src_len,
 390                                struct bch_compression_opt compression)
 391 {
 392         struct bbuf src_data = { NULL }, dst_data = { NULL };
 393         void *workspace;
 394         enum bch_compression_type compression_type =
 395                 __bch2_compression_opt_to_type[compression.type];
 396         unsigned pad;
 397         int ret = 0;
 398
 399         BUG_ON(compression_type >= BCH_COMPRESSION_TYPE_NR);
 400         BUG_ON(!mempool_initialized(&c->compress_workspace[compression_type]));
 401
 402         /* If it's only one block, don't bother trying to compress: */
 403         if (src->bi_iter.bi_size <= c->opts.block_size)
 404                 return BCH_COMPRESSION_TYPE_incompressible;
 405
 406         dst_data = bio_map_or_bounce(c, dst, WRITE);
 407         src_data = bio_map_or_bounce(c, src, READ);
 408
 409         workspace = mempool_alloc(&c->compress_workspace[compression_type], GFP_NOFS);
 410
 411         *src_len = src->bi_iter.bi_size;
 412         *dst_len = dst->bi_iter.bi_size;
 413
 414         /*
 415          * XXX: this algorithm sucks when the compression code doesn't tell us
 416          * how much would fit, like LZ4 does:
 417          */
 418         while (1) {
 419                 if (*src_len <= block_bytes(c)) {
 420                         ret = -1;
 421                         break;
 422                 }
 423
 424                 ret = attempt_compress(c, workspace,
 425                                        dst_data.b,      *dst_len,
 426                                        src_data.b,      *src_len,
 427                                        compression);
 428                 if (ret > 0) {
 429                         *dst_len = ret;
 430                         ret = 0;
 431                         break;
 432                 }
 433
 434                 /* Didn't fit: should we retry with a smaller amount?  */
 435                 if (*src_len <= *dst_len) {
 436                         ret = -1;
 437                         break;
 438                 }
 439
 440                 /*
 441                  * If ret is negative, it's a hint as to how much data would fit
 442                  */
 443                 BUG_ON(-ret >= *src_len);
 444
 445                 if (ret < 0)
 446                         *src_len = -ret;
 447                 else
 448                         *src_len -= (*src_len - *dst_len) / 2;
 449                 *src_len = round_down(*src_len, block_bytes(c));
 450         }
 451
 452         mempool_free(workspace, &c->compress_workspace[compression_type]);
 453
 454         if (ret)
 455                 goto err;
 456
 457         /* Didn't get smaller: */
 458         if (round_up(*dst_len, block_bytes(c)) >= *src_len)
 459                 goto err;
 460
 461         pad = round_up(*dst_len, block_bytes(c)) - *dst_len;
 462
 463         memset(dst_data.b + *dst_len, 0, pad);
 464         *dst_len += pad;
 465
 466         if (dst_data.type != BB_NONE &&
 467             dst_data.type != BB_VMAP)
 468                 memcpy_to_bio(dst, dst->bi_iter, dst_data.b);
 469
 470         BUG_ON(!*dst_len || *dst_len > dst->bi_iter.bi_size);
 471         BUG_ON(!*src_len || *src_len > src->bi_iter.bi_size);
 472         BUG_ON(*dst_len & (block_bytes(c) - 1));
 473         BUG_ON(*src_len & (block_bytes(c) - 1));
 474         ret = compression_type;
 475 out:
 476         bio_unmap_or_unbounce(c, src_data);
 477         bio_unmap_or_unbounce(c, dst_data);
 478         return ret;
 479 err:
 480         ret = BCH_COMPRESSION_TYPE_incompressible;
 481         goto out;
 482 }
 483
 484 unsigned bch2_bio_compress(struct bch_fs *c,
 485                            struct bio *dst, size_t *dst_len,
 486                            struct bio *src, size_t *src_len,
 487                            unsigned compression_opt)
 488 {
 489         unsigned orig_dst = dst->bi_iter.bi_size;
 490         unsigned orig_src = src->bi_iter.bi_size;
 491         unsigned compression_type;
 492
 493         /* Don't consume more than BCH_ENCODED_EXTENT_MAX from @src: */
 494         src->bi_iter.bi_size = min_t(unsigned, src->bi_iter.bi_size,
 495                                      c->opts.encoded_extent_max);
 496         /* Don't generate a bigger output than input: */
 497         dst->bi_iter.bi_size = min(dst->bi_iter.bi_size, src->bi_iter.bi_size);
 498
 499         compression_type =
 500                 __bio_compress(c, dst, dst_len, src, src_len,
 501                                bch2_compression_decode(compression_opt));
 502
 503         dst->bi_iter.bi_size = orig_dst;
 504         src->bi_iter.bi_size = orig_src;
 505         return compression_type;
 506 }
 507
 508 static int __bch2_fs_compress_init(struct bch_fs *, u64);
 509
 510 #define BCH_FEATURE_none        0
 511
 512 static const unsigned bch2_compression_opt_to_feature[] = {
 513 #define x(t, n) [BCH_COMPRESSION_OPT_##t] = BCH_FEATURE_##t,
 514         BCH_COMPRESSION_OPTS()
 515 #undef x
 516 };
 517
 518 #undef BCH_FEATURE_none
 519
 520 static int __bch2_check_set_has_compressed_data(struct bch_fs *c, u64 f)
 521 {
 522         int ret = 0;
 523
 524         if ((c->sb.features & f) == f)
 525                 return 0;
 526
 527         mutex_lock(&c->sb_lock);
 528
 529         if ((c->sb.features & f) == f) {
 530                 mutex_unlock(&c->sb_lock);
 531                 return 0;
 532         }
 533
 534         ret = __bch2_fs_compress_init(c, c->sb.features|f);
 535         if (ret) {
 536                 mutex_unlock(&c->sb_lock);
 537                 return ret;
 538         }
 539
 540         c->disk_sb.sb->features[0] |= cpu_to_le64(f);
 541         bch2_write_super(c);
 542         mutex_unlock(&c->sb_lock);
 543
 544         return 0;
 545 }
 546
 547 int bch2_check_set_has_compressed_data(struct bch_fs *c,
 548                                        unsigned compression_opt)
 549 {
 550         unsigned compression_type = bch2_compression_decode(compression_opt).type;
 551
 552         BUG_ON(compression_type >= ARRAY_SIZE(bch2_compression_opt_to_feature));
 553
 554         return compression_type
 555                 ? __bch2_check_set_has_compressed_data(c,
 556                                 1ULL << bch2_compression_opt_to_feature[compression_type])
 557                 : 0;
 558 }
 559
 560 void bch2_fs_compress_exit(struct bch_fs *c)
 561 {
 562         unsigned i;
 563
 564         mempool_exit(&c->decompress_workspace);
 565         for (i = 0; i < ARRAY_SIZE(c->compress_workspace); i++)
 566                 mempool_exit(&c->compress_workspace[i]);
 567         mempool_exit(&c->compression_bounce[WRITE]);
 568         mempool_exit(&c->compression_bounce[READ]);
 569 }
 570
 571 static int __bch2_fs_compress_init(struct bch_fs *c, u64 features)
 572 {
 573         size_t decompress_workspace_size = 0;
 574         bool decompress_workspace_needed;
 575         ZSTD_parameters params = zstd_get_params(zstd_max_clevel(),
 576                                                  c->opts.encoded_extent_max);
 577         struct {
 578                 unsigned                        feature;
 579                 enum bch_compression_type       type;
 580                 size_t                          compress_workspace;
 581                 size_t                          decompress_workspace;
 582         } compression_types[] = {
 583                 { BCH_FEATURE_lz4, BCH_COMPRESSION_TYPE_lz4,
 584                         max_t(size_t, LZ4_MEM_COMPRESS, LZ4HC_MEM_COMPRESS) },
 585                 { BCH_FEATURE_gzip, BCH_COMPRESSION_TYPE_gzip,
 586                         zlib_deflate_workspacesize(MAX_WBITS, DEF_MEM_LEVEL),
 587                         zlib_inflate_workspacesize(), },
 588                 { BCH_FEATURE_zstd, BCH_COMPRESSION_TYPE_zstd,
 589                         zstd_cctx_workspace_bound(&params.cParams),
 590                         zstd_dctx_workspace_bound() },
 591         }, *i;
 592         bool have_compressed = false;
 593
 594         c->zstd_params = params;
 595
 596         for (i = compression_types;
 597              i < compression_types + ARRAY_SIZE(compression_types);
 598              i++)
 599                 have_compressed |= (features & (1 << i->feature)) != 0;
 600
 601         if (!have_compressed)
 602                 return 0;
 603
 604         if (!mempool_initialized(&c->compression_bounce[READ]) &&
 605             mempool_init_kvpmalloc_pool(&c->compression_bounce[READ],
 606                                         1, c->opts.encoded_extent_max))
 607                 return -BCH_ERR_ENOMEM_compression_bounce_read_init;
 608
 609         if (!mempool_initialized(&c->compression_bounce[WRITE]) &&
 610             mempool_init_kvpmalloc_pool(&c->compression_bounce[WRITE],
 611                                         1, c->opts.encoded_extent_max))
 612                 return -BCH_ERR_ENOMEM_compression_bounce_write_init;
 613
 614         for (i = compression_types;
 615              i < compression_types + ARRAY_SIZE(compression_types);
 616              i++) {
 617                 decompress_workspace_size =
 618                         max(decompress_workspace_size, i->decompress_workspace);
 619
 620                 if (!(features & (1 << i->feature)))
 621                         continue;
 622
 623                 if (i->decompress_workspace)
 624                         decompress_workspace_needed = true;
 625
 626                 if (mempool_initialized(&c->compress_workspace[i->type]))
 627                         continue;
 628
 629                 if (mempool_init_kvpmalloc_pool(
 630                                 &c->compress_workspace[i->type],
 631                                 1, i->compress_workspace))
 632                         return -BCH_ERR_ENOMEM_compression_workspace_init;
 633         }
 634
 635         if (!mempool_initialized(&c->decompress_workspace) &&
 636             mempool_init_kvpmalloc_pool(&c->decompress_workspace,
 637                                         1, decompress_workspace_size))
 638                 return -BCH_ERR_ENOMEM_decompression_workspace_init;
 639
 640         return 0;
 641 }
 642
 643 static u64 compression_opt_to_feature(unsigned v)
 644 {
 645         unsigned type = bch2_compression_decode(v).type;
 646         return 1ULL << bch2_compression_opt_to_feature[type];
 647 }
 648
 649 int bch2_fs_compress_init(struct bch_fs *c)
 650 {
 651         u64 f = c->sb.features;
 652
 653         f |= compression_opt_to_feature(c->opts.compression);
 654         f |= compression_opt_to_feature(c->opts.background_compression);
 655
 656         return __bch2_fs_compress_init(c, f);
 657 }
 658
 659 int bch2_opt_compression_parse(struct bch_fs *c, const char *_val, u64 *res,
 660                                struct printbuf *err)
 661 {
 662         char *val = kstrdup(_val, GFP_KERNEL);
 663         char *p = val, *type_str, *level_str;
 664         struct bch_compression_opt opt = { 0 };
 665         int ret;
 666
 667         if (!val)
 668                 return -ENOMEM;
 669
 670         type_str = strsep(&p, ":");
 671         level_str = p;
 672
 673         ret = match_string(bch2_compression_opts, -1, type_str);
 674         if (ret < 0 && err)
 675                 prt_str(err, "invalid compression type");
 676         if (ret < 0)
 677                 goto err;
 678
 679         opt.type = ret;
 680
 681         if (level_str) {
 682                 unsigned level;
 683
 684                 ret = kstrtouint(level_str, 10, &level);
 685                 if (!ret && !opt.type && level)
 686                         ret = -EINVAL;
 687                 if (!ret && level > 15)
 688                         ret = -EINVAL;
 689                 if (ret < 0 && err)
 690                         prt_str(err, "invalid compression level");
 691                 if (ret < 0)
 692                         goto err;
 693
 694                 opt.level = level;
 695         }
 696
 697         *res = bch2_compression_encode(opt);
 698 err:
 699         kfree(val);
 700         return ret;
 701 }
 702
 703 void bch2_opt_compression_to_text(struct printbuf *out,
 704                                   struct bch_fs *c,
 705                                   struct bch_sb *sb,
 706                                   u64 v)
 707 {
 708         struct bch_compression_opt opt = bch2_compression_decode(v);
 709
 710         prt_str(out, bch2_compression_opts[opt.type]);
 711         if (opt.level)
 712                 prt_printf(out, ":%u", opt.level);
 713 }