147e4937aSGao Xiang // SPDX-License-Identifier: GPL-2.0-only 247e4937aSGao Xiang /* 347e4937aSGao Xiang * Copyright (C) 2019 HUAWEI, Inc. 4592e7cd0SAlexander A. Klimov * https://www.huawei.com/ 547e4937aSGao Xiang */ 647e4937aSGao Xiang #include "compress.h" 747e4937aSGao Xiang #include <linux/module.h> 847e4937aSGao Xiang #include <linux/lz4.h> 947e4937aSGao Xiang 1047e4937aSGao Xiang #ifndef LZ4_DISTANCE_MAX /* history window size */ 1147e4937aSGao Xiang #define LZ4_DISTANCE_MAX 65535 /* set to maximum value by default */ 1247e4937aSGao Xiang #endif 1347e4937aSGao Xiang 1447e4937aSGao Xiang #define LZ4_MAX_DISTANCE_PAGES (DIV_ROUND_UP(LZ4_DISTANCE_MAX, PAGE_SIZE) + 1) 1547e4937aSGao Xiang #ifndef LZ4_DECOMPRESS_INPLACE_MARGIN 1647e4937aSGao Xiang #define LZ4_DECOMPRESS_INPLACE_MARGIN(srcsize) (((srcsize) >> 8) + 32) 1747e4937aSGao Xiang #endif 1847e4937aSGao Xiang 19d67aee76SGao Xiang struct z_erofs_lz4_decompress_ctx { 20d67aee76SGao Xiang struct z_erofs_decompress_req *rq; 21d67aee76SGao Xiang /* # of encoded, decoded pages */ 22d67aee76SGao Xiang unsigned int inpages, outpages; 23d67aee76SGao Xiang /* decoded block total length (used for in-place decompression) */ 24d67aee76SGao Xiang unsigned int oend; 25d67aee76SGao Xiang }; 26d67aee76SGao Xiang 27586814edSGao Xiang static int z_erofs_load_lz4_config(struct super_block *sb, 28586814edSGao Xiang struct erofs_super_block *dsb, void *data, int size) 295d50538fSHuang Jianan { 304fea63f7SGao Xiang struct erofs_sb_info *sbi = EROFS_SB(sb); 31586814edSGao Xiang struct z_erofs_lz4_cfgs *lz4 = data; 3246249cdeSGao Xiang u16 distance; 3346249cdeSGao Xiang 3446249cdeSGao Xiang if (lz4) { 3546249cdeSGao Xiang if (size < sizeof(struct z_erofs_lz4_cfgs)) { 3646249cdeSGao Xiang erofs_err(sb, "invalid lz4 cfgs, size=%u", size); 3746249cdeSGao Xiang return -EINVAL; 3846249cdeSGao Xiang } 3946249cdeSGao Xiang distance = le16_to_cpu(lz4->max_distance); 404fea63f7SGao Xiang 414fea63f7SGao Xiang sbi->lz4.max_pclusterblks = le16_to_cpu(lz4->max_pclusterblks); 424fea63f7SGao Xiang if (!sbi->lz4.max_pclusterblks) { 434fea63f7SGao Xiang sbi->lz4.max_pclusterblks = 1; /* reserved case */ 444fea63f7SGao Xiang } else if (sbi->lz4.max_pclusterblks > 453acea5fcSJingbo Xu erofs_blknr(sb, Z_EROFS_PCLUSTER_MAX_SIZE)) { 464fea63f7SGao Xiang erofs_err(sb, "too large lz4 pclusterblks %u", 474fea63f7SGao Xiang sbi->lz4.max_pclusterblks); 484fea63f7SGao Xiang return -EINVAL; 494fea63f7SGao Xiang } 5046249cdeSGao Xiang } else { 5114373711SGao Xiang distance = le16_to_cpu(dsb->u1.lz4_max_distance); 524fea63f7SGao Xiang sbi->lz4.max_pclusterblks = 1; 5346249cdeSGao Xiang } 545d50538fSHuang Jianan 554fea63f7SGao Xiang sbi->lz4.max_distance_pages = distance ? 565d50538fSHuang Jianan DIV_ROUND_UP(distance, PAGE_SIZE) + 1 : 575d50538fSHuang Jianan LZ4_MAX_DISTANCE_PAGES; 584fea63f7SGao Xiang return erofs_pcpubuf_growsize(sbi->lz4.max_pclusterblks); 595d50538fSHuang Jianan } 605d50538fSHuang Jianan 61966edfb0SGao Xiang /* 62966edfb0SGao Xiang * Fill all gaps with bounce pages if it's a sparse page list. Also check if 63966edfb0SGao Xiang * all physical pages are consecutive, which can be seen for moderate CR. 64966edfb0SGao Xiang */ 65d67aee76SGao Xiang static int z_erofs_lz4_prepare_dstpages(struct z_erofs_lz4_decompress_ctx *ctx, 66eaa9172aSGao Xiang struct page **pagepool) 6747e4937aSGao Xiang { 68d67aee76SGao Xiang struct z_erofs_decompress_req *rq = ctx->rq; 6947e4937aSGao Xiang struct page *availables[LZ4_MAX_DISTANCE_PAGES] = { NULL }; 7047e4937aSGao Xiang unsigned long bounced[DIV_ROUND_UP(LZ4_MAX_DISTANCE_PAGES, 7147e4937aSGao Xiang BITS_PER_LONG)] = { 0 }; 725d50538fSHuang Jianan unsigned int lz4_max_distance_pages = 735d50538fSHuang Jianan EROFS_SB(rq->sb)->lz4.max_distance_pages; 7447e4937aSGao Xiang void *kaddr = NULL; 7547e4937aSGao Xiang unsigned int i, j, top; 7647e4937aSGao Xiang 7747e4937aSGao Xiang top = 0; 78d67aee76SGao Xiang for (i = j = 0; i < ctx->outpages; ++i, ++j) { 7947e4937aSGao Xiang struct page *const page = rq->out[i]; 8047e4937aSGao Xiang struct page *victim; 8147e4937aSGao Xiang 825d50538fSHuang Jianan if (j >= lz4_max_distance_pages) 8347e4937aSGao Xiang j = 0; 8447e4937aSGao Xiang 8547e4937aSGao Xiang /* 'valid' bounced can only be tested after a complete round */ 86267f2492SGao Xiang if (!rq->fillgaps && test_bit(j, bounced)) { 875d50538fSHuang Jianan DBG_BUGON(i < lz4_max_distance_pages); 885d50538fSHuang Jianan DBG_BUGON(top >= lz4_max_distance_pages); 895d50538fSHuang Jianan availables[top++] = rq->out[i - lz4_max_distance_pages]; 9047e4937aSGao Xiang } 9147e4937aSGao Xiang 9247e4937aSGao Xiang if (page) { 9347e4937aSGao Xiang __clear_bit(j, bounced); 94448b5a15SGao Xiang if (!PageHighMem(page)) { 95448b5a15SGao Xiang if (!i) { 9647e4937aSGao Xiang kaddr = page_address(page); 97448b5a15SGao Xiang continue; 9847e4937aSGao Xiang } 99448b5a15SGao Xiang if (kaddr && 100448b5a15SGao Xiang kaddr + PAGE_SIZE == page_address(page)) { 101448b5a15SGao Xiang kaddr += PAGE_SIZE; 102448b5a15SGao Xiang continue; 103448b5a15SGao Xiang } 104448b5a15SGao Xiang } 105448b5a15SGao Xiang kaddr = NULL; 10647e4937aSGao Xiang continue; 10747e4937aSGao Xiang } 10847e4937aSGao Xiang kaddr = NULL; 10947e4937aSGao Xiang __set_bit(j, bounced); 11047e4937aSGao Xiang 11147e4937aSGao Xiang if (top) { 11247e4937aSGao Xiang victim = availables[--top]; 11347e4937aSGao Xiang get_page(victim); 11447e4937aSGao Xiang } else { 115b4892fa3SHuang Jianan victim = erofs_allocpage(pagepool, 116b4892fa3SHuang Jianan GFP_KERNEL | __GFP_NOFAIL); 1176aaa7b06SGao Xiang set_page_private(victim, Z_EROFS_SHORTLIVED_PAGE); 11847e4937aSGao Xiang } 11947e4937aSGao Xiang rq->out[i] = victim; 12047e4937aSGao Xiang } 12147e4937aSGao Xiang return kaddr ? 1 : 0; 12247e4937aSGao Xiang } 12347e4937aSGao Xiang 124d67aee76SGao Xiang static void *z_erofs_lz4_handle_overlap(struct z_erofs_lz4_decompress_ctx *ctx, 125598162d0SGao Xiang void *inpage, unsigned int *inputmargin, int *maptype, 126ab749badSGao Xiang bool may_inplace) 12747e4937aSGao Xiang { 128d67aee76SGao Xiang struct z_erofs_decompress_req *rq = ctx->rq; 129d67aee76SGao Xiang unsigned int omargin, total, i, j; 130598162d0SGao Xiang struct page **in; 131598162d0SGao Xiang void *src, *tmp; 13247e4937aSGao Xiang 133598162d0SGao Xiang if (rq->inplace_io) { 134d67aee76SGao Xiang omargin = PAGE_ALIGN(ctx->oend) - ctx->oend; 135ab749badSGao Xiang if (rq->partial_decoding || !may_inplace || 136d67aee76SGao Xiang omargin < LZ4_DECOMPRESS_INPLACE_MARGIN(rq->inputsize)) 137598162d0SGao Xiang goto docopy; 138598162d0SGao Xiang 139d67aee76SGao Xiang for (i = 0; i < ctx->inpages; ++i) { 140598162d0SGao Xiang DBG_BUGON(rq->in[i] == NULL); 141d67aee76SGao Xiang for (j = 0; j < ctx->outpages - ctx->inpages + i; ++j) 142598162d0SGao Xiang if (rq->out[j] == rq->in[i]) 143598162d0SGao Xiang goto docopy; 14447e4937aSGao Xiang } 145598162d0SGao Xiang } 146598162d0SGao Xiang 147d67aee76SGao Xiang if (ctx->inpages <= 1) { 148598162d0SGao Xiang *maptype = 0; 149598162d0SGao Xiang return inpage; 150598162d0SGao Xiang } 151123ec246SGao Xiang kunmap_local(inpage); 152598162d0SGao Xiang might_sleep(); 153d67aee76SGao Xiang src = erofs_vm_map_ram(rq->in, ctx->inpages); 154598162d0SGao Xiang if (!src) 155598162d0SGao Xiang return ERR_PTR(-ENOMEM); 156598162d0SGao Xiang *maptype = 1; 157598162d0SGao Xiang return src; 158598162d0SGao Xiang 159598162d0SGao Xiang docopy: 160598162d0SGao Xiang /* Or copy compressed data which can be overlapped to per-CPU buffer */ 161598162d0SGao Xiang in = rq->in; 162d67aee76SGao Xiang src = erofs_get_pcpubuf(ctx->inpages); 163598162d0SGao Xiang if (!src) { 164598162d0SGao Xiang DBG_BUGON(1); 165123ec246SGao Xiang kunmap_local(inpage); 166598162d0SGao Xiang return ERR_PTR(-EFAULT); 167598162d0SGao Xiang } 168598162d0SGao Xiang 169598162d0SGao Xiang tmp = src; 170598162d0SGao Xiang total = rq->inputsize; 171598162d0SGao Xiang while (total) { 172598162d0SGao Xiang unsigned int page_copycnt = 173598162d0SGao Xiang min_t(unsigned int, total, PAGE_SIZE - *inputmargin); 174598162d0SGao Xiang 175598162d0SGao Xiang if (!inpage) 176123ec246SGao Xiang inpage = kmap_local_page(*in); 177598162d0SGao Xiang memcpy(tmp, inpage + *inputmargin, page_copycnt); 178123ec246SGao Xiang kunmap_local(inpage); 179598162d0SGao Xiang inpage = NULL; 180598162d0SGao Xiang tmp += page_copycnt; 181598162d0SGao Xiang total -= page_copycnt; 182598162d0SGao Xiang ++in; 183598162d0SGao Xiang *inputmargin = 0; 184598162d0SGao Xiang } 185598162d0SGao Xiang *maptype = 2; 186598162d0SGao Xiang return src; 18747e4937aSGao Xiang } 18847e4937aSGao Xiang 18910e5f6e4SGao Xiang /* 19010e5f6e4SGao Xiang * Get the exact inputsize with zero_padding feature. 19110e5f6e4SGao Xiang * - For LZ4, it should work if zero_padding feature is on (5.3+); 19210e5f6e4SGao Xiang * - For MicroLZMA, it'd be enabled all the time. 19310e5f6e4SGao Xiang */ 19410e5f6e4SGao Xiang int z_erofs_fixup_insize(struct z_erofs_decompress_req *rq, const char *padbuf, 19510e5f6e4SGao Xiang unsigned int padbufsize) 19610e5f6e4SGao Xiang { 19710e5f6e4SGao Xiang const char *padend; 19810e5f6e4SGao Xiang 19910e5f6e4SGao Xiang padend = memchr_inv(padbuf, 0, padbufsize); 20010e5f6e4SGao Xiang if (!padend) 20110e5f6e4SGao Xiang return -EFSCORRUPTED; 20210e5f6e4SGao Xiang rq->inputsize -= padend - padbuf; 20310e5f6e4SGao Xiang rq->pageofs_in += padend - padbuf; 20410e5f6e4SGao Xiang return 0; 20510e5f6e4SGao Xiang } 20610e5f6e4SGao Xiang 207d67aee76SGao Xiang static int z_erofs_lz4_decompress_mem(struct z_erofs_lz4_decompress_ctx *ctx, 208966edfb0SGao Xiang u8 *out) 20947e4937aSGao Xiang { 210d67aee76SGao Xiang struct z_erofs_decompress_req *rq = ctx->rq; 211ab749badSGao Xiang bool support_0padding = false, may_inplace = false; 212598162d0SGao Xiang unsigned int inputmargin; 213598162d0SGao Xiang u8 *headpage, *src; 214598162d0SGao Xiang int ret, maptype; 21547e4937aSGao Xiang 216598162d0SGao Xiang DBG_BUGON(*rq->in == NULL); 217123ec246SGao Xiang headpage = kmap_local_page(*rq->in); 21847e4937aSGao Xiang 21910e5f6e4SGao Xiang /* LZ4 decompression inplace is only safe if zero_padding is enabled */ 2207e508f2cSHuang Jianan if (erofs_sb_has_zero_padding(EROFS_SB(rq->sb))) { 22147e4937aSGao Xiang support_0padding = true; 22210e5f6e4SGao Xiang ret = z_erofs_fixup_insize(rq, headpage + rq->pageofs_in, 22310e5f6e4SGao Xiang min_t(unsigned int, rq->inputsize, 2243acea5fcSJingbo Xu rq->sb->s_blocksize - rq->pageofs_in)); 22510e5f6e4SGao Xiang if (ret) { 226123ec246SGao Xiang kunmap_local(headpage); 22710e5f6e4SGao Xiang return ret; 22847e4937aSGao Xiang } 229ab749badSGao Xiang may_inplace = !((rq->pageofs_in + rq->inputsize) & 2303acea5fcSJingbo Xu (rq->sb->s_blocksize - 1)); 23147e4937aSGao Xiang } 23247e4937aSGao Xiang 23310e5f6e4SGao Xiang inputmargin = rq->pageofs_in; 234d67aee76SGao Xiang src = z_erofs_lz4_handle_overlap(ctx, headpage, &inputmargin, 235ab749badSGao Xiang &maptype, may_inplace); 236598162d0SGao Xiang if (IS_ERR(src)) 237598162d0SGao Xiang return PTR_ERR(src); 23847e4937aSGao Xiang 239af1038abSGao Xiang /* legacy format could compress extra data in a pcluster. */ 240af1038abSGao Xiang if (rq->partial_decoding || !support_0padding) 24147e4937aSGao Xiang ret = LZ4_decompress_safe_partial(src + inputmargin, out, 242598162d0SGao Xiang rq->inputsize, rq->outputsize, rq->outputsize); 243af1038abSGao Xiang else 244af1038abSGao Xiang ret = LZ4_decompress_safe(src + inputmargin, out, 245598162d0SGao Xiang rq->inputsize, rq->outputsize); 246af1038abSGao Xiang 247aa99a76bSGao Xiang if (ret != rq->outputsize) { 248aa99a76bSGao Xiang erofs_err(rq->sb, "failed to decompress %d in[%u, %u] out[%u]", 249598162d0SGao Xiang ret, rq->inputsize, inputmargin, rq->outputsize); 250aa99a76bSGao Xiang 25147e4937aSGao Xiang print_hex_dump(KERN_DEBUG, "[ in]: ", DUMP_PREFIX_OFFSET, 252598162d0SGao Xiang 16, 1, src + inputmargin, rq->inputsize, true); 25347e4937aSGao Xiang print_hex_dump(KERN_DEBUG, "[out]: ", DUMP_PREFIX_OFFSET, 25447e4937aSGao Xiang 16, 1, out, rq->outputsize, true); 255aa99a76bSGao Xiang 256aa99a76bSGao Xiang if (ret >= 0) 257aa99a76bSGao Xiang memset(out + ret, 0, rq->outputsize - ret); 25847e4937aSGao Xiang ret = -EIO; 2595b6e7e12SYue Hu } else { 2605b6e7e12SYue Hu ret = 0; 26147e4937aSGao Xiang } 26247e4937aSGao Xiang 263598162d0SGao Xiang if (maptype == 0) { 264123ec246SGao Xiang kunmap_local(headpage); 265598162d0SGao Xiang } else if (maptype == 1) { 266d67aee76SGao Xiang vm_unmap_ram(src, ctx->inpages); 267598162d0SGao Xiang } else if (maptype == 2) { 268598162d0SGao Xiang erofs_put_pcpubuf(src); 269598162d0SGao Xiang } else { 270598162d0SGao Xiang DBG_BUGON(1); 271598162d0SGao Xiang return -EFAULT; 272598162d0SGao Xiang } 27347e4937aSGao Xiang return ret; 27447e4937aSGao Xiang } 27547e4937aSGao Xiang 276966edfb0SGao Xiang static int z_erofs_lz4_decompress(struct z_erofs_decompress_req *rq, 277eaa9172aSGao Xiang struct page **pagepool) 27847e4937aSGao Xiang { 279d67aee76SGao Xiang struct z_erofs_lz4_decompress_ctx ctx; 28047e4937aSGao Xiang unsigned int dst_maptype; 28147e4937aSGao Xiang void *dst; 282598162d0SGao Xiang int ret; 28347e4937aSGao Xiang 284d67aee76SGao Xiang ctx.rq = rq; 285d67aee76SGao Xiang ctx.oend = rq->pageofs_out + rq->outputsize; 286d67aee76SGao Xiang ctx.outpages = PAGE_ALIGN(ctx.oend) >> PAGE_SHIFT; 287d67aee76SGao Xiang ctx.inpages = PAGE_ALIGN(rq->inputsize) >> PAGE_SHIFT; 288d67aee76SGao Xiang 2895b6e7e12SYue Hu /* one optimized fast path only for non bigpcluster cases yet */ 290d67aee76SGao Xiang if (ctx.inpages == 1 && ctx.outpages == 1 && !rq->inplace_io) { 29147e4937aSGao Xiang DBG_BUGON(!*rq->out); 292123ec246SGao Xiang dst = kmap_local_page(*rq->out); 29347e4937aSGao Xiang dst_maptype = 0; 29447e4937aSGao Xiang goto dstmap_out; 29547e4937aSGao Xiang } 29647e4937aSGao Xiang 297598162d0SGao Xiang /* general decoding path which can be used for all cases */ 298d67aee76SGao Xiang ret = z_erofs_lz4_prepare_dstpages(&ctx, pagepool); 299d67aee76SGao Xiang if (ret < 0) { 30047e4937aSGao Xiang return ret; 301d67aee76SGao Xiang } else if (ret > 0) { 30247e4937aSGao Xiang dst = page_address(*rq->out); 30347e4937aSGao Xiang dst_maptype = 1; 304d67aee76SGao Xiang } else { 305d67aee76SGao Xiang dst = erofs_vm_map_ram(rq->out, ctx.outpages); 30647e4937aSGao Xiang if (!dst) 30747e4937aSGao Xiang return -ENOMEM; 30847e4937aSGao Xiang dst_maptype = 2; 309d67aee76SGao Xiang } 31047e4937aSGao Xiang 31147e4937aSGao Xiang dstmap_out: 312d67aee76SGao Xiang ret = z_erofs_lz4_decompress_mem(&ctx, dst + rq->pageofs_out); 31347e4937aSGao Xiang if (!dst_maptype) 314123ec246SGao Xiang kunmap_local(dst); 31547e4937aSGao Xiang else if (dst_maptype == 2) 316d67aee76SGao Xiang vm_unmap_ram(dst, ctx.outpages); 31747e4937aSGao Xiang return ret; 31847e4937aSGao Xiang } 31947e4937aSGao Xiang 320fdffc091SYue Hu static int z_erofs_transform_plain(struct z_erofs_decompress_req *rq, 321eaa9172aSGao Xiang struct page **pagepool) 32247e4937aSGao Xiang { 323fdffc091SYue Hu const unsigned int inpages = PAGE_ALIGN(rq->inputsize) >> PAGE_SHIFT; 324fdffc091SYue Hu const unsigned int outpages = 32547e4937aSGao Xiang PAGE_ALIGN(rq->pageofs_out + rq->outputsize) >> PAGE_SHIFT; 326ab749badSGao Xiang const unsigned int righthalf = min_t(unsigned int, rq->outputsize, 327ab749badSGao Xiang PAGE_SIZE - rq->pageofs_out); 328dcbe6803SGao Xiang const unsigned int lefthalf = rq->outputsize - righthalf; 329fdffc091SYue Hu const unsigned int interlaced_offset = 330fdffc091SYue Hu rq->alg == Z_EROFS_COMPRESSION_SHIFTED ? 0 : rq->pageofs_out; 331c5539762SGao Xiang u8 *src; 33247e4937aSGao Xiang 333fdffc091SYue Hu if (outpages > 2 && rq->alg == Z_EROFS_COMPRESSION_SHIFTED) { 33447e4937aSGao Xiang DBG_BUGON(1); 335fdffc091SYue Hu return -EFSCORRUPTED; 33647e4937aSGao Xiang } 33747e4937aSGao Xiang 33847e4937aSGao Xiang if (rq->out[0] == *rq->in) { 339fdffc091SYue Hu DBG_BUGON(rq->pageofs_out); 34047e4937aSGao Xiang return 0; 34147e4937aSGao Xiang } 34247e4937aSGao Xiang 343fdffc091SYue Hu src = kmap_local_page(rq->in[inpages - 1]) + rq->pageofs_in; 344c5539762SGao Xiang if (rq->out[0]) 345c5539762SGao Xiang memcpy_to_page(rq->out[0], rq->pageofs_out, 346c5539762SGao Xiang src + interlaced_offset, righthalf); 34747e4937aSGao Xiang 348fdffc091SYue Hu if (outpages > inpages) { 349fdffc091SYue Hu DBG_BUGON(!rq->out[outpages - 1]); 350fdffc091SYue Hu if (rq->out[outpages - 1] != rq->in[inpages - 1]) { 351c5539762SGao Xiang memcpy_to_page(rq->out[outpages - 1], 0, src + 352c5539762SGao Xiang (interlaced_offset ? 0 : righthalf), 353c5539762SGao Xiang lefthalf); 354fdffc091SYue Hu } else if (!interlaced_offset) { 355dcbe6803SGao Xiang memmove(src, src + righthalf, lefthalf); 356c5539762SGao Xiang flush_dcache_page(rq->in[inpages - 1]); 3574d202437SGao Xiang } 3584d202437SGao Xiang } 359fdffc091SYue Hu kunmap_local(src); 36047e4937aSGao Xiang return 0; 36147e4937aSGao Xiang } 36247e4937aSGao Xiang 363597e2953SYue Hu const struct z_erofs_decompressor erofs_decompressors[] = { 364966edfb0SGao Xiang [Z_EROFS_COMPRESSION_SHIFTED] = { 365fdffc091SYue Hu .decompress = z_erofs_transform_plain, 366966edfb0SGao Xiang .name = "shifted" 367966edfb0SGao Xiang }, 368fdffc091SYue Hu [Z_EROFS_COMPRESSION_INTERLACED] = { 369fdffc091SYue Hu .decompress = z_erofs_transform_plain, 370fdffc091SYue Hu .name = "interlaced" 371fdffc091SYue Hu }, 372966edfb0SGao Xiang [Z_EROFS_COMPRESSION_LZ4] = { 373586814edSGao Xiang .config = z_erofs_load_lz4_config, 374966edfb0SGao Xiang .decompress = z_erofs_lz4_decompress, 375966edfb0SGao Xiang .name = "lz4" 376966edfb0SGao Xiang }, 377622ceaddSGao Xiang #ifdef CONFIG_EROFS_FS_ZIP_LZMA 378622ceaddSGao Xiang [Z_EROFS_COMPRESSION_LZMA] = { 379586814edSGao Xiang .config = z_erofs_load_lzma_config, 380622ceaddSGao Xiang .decompress = z_erofs_lzma_decompress, 381622ceaddSGao Xiang .name = "lzma" 382622ceaddSGao Xiang }, 383622ceaddSGao Xiang #endif 384ffa09b3bSGao Xiang #ifdef CONFIG_EROFS_FS_ZIP_DEFLATE 385ffa09b3bSGao Xiang [Z_EROFS_COMPRESSION_DEFLATE] = { 386586814edSGao Xiang .config = z_erofs_load_deflate_config, 387ffa09b3bSGao Xiang .decompress = z_erofs_deflate_decompress, 388ffa09b3bSGao Xiang .name = "deflate" 389ffa09b3bSGao Xiang }, 390ffa09b3bSGao Xiang #endif 391966edfb0SGao Xiang }; 392586814edSGao Xiang 393586814edSGao Xiang int z_erofs_parse_cfgs(struct super_block *sb, struct erofs_super_block *dsb) 394586814edSGao Xiang { 395586814edSGao Xiang struct erofs_sb_info *sbi = EROFS_SB(sb); 396586814edSGao Xiang struct erofs_buf buf = __EROFS_BUF_INITIALIZER; 397586814edSGao Xiang unsigned int algs, alg; 398586814edSGao Xiang erofs_off_t offset; 399586814edSGao Xiang int size, ret = 0; 400586814edSGao Xiang 401586814edSGao Xiang if (!erofs_sb_has_compr_cfgs(sbi)) { 402*823ba1d2SGao Xiang sbi->available_compr_algs = 1 << Z_EROFS_COMPRESSION_LZ4; 403586814edSGao Xiang return z_erofs_load_lz4_config(sb, dsb, NULL, 0); 404586814edSGao Xiang } 405586814edSGao Xiang 406586814edSGao Xiang sbi->available_compr_algs = le16_to_cpu(dsb->u1.available_compr_algs); 407586814edSGao Xiang if (sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS) { 408586814edSGao Xiang erofs_err(sb, "unidentified algorithms %x, please upgrade kernel", 409586814edSGao Xiang sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS); 410586814edSGao Xiang return -EOPNOTSUPP; 411586814edSGao Xiang } 412586814edSGao Xiang 413586814edSGao Xiang erofs_init_metabuf(&buf, sb); 414586814edSGao Xiang offset = EROFS_SUPER_OFFSET + sbi->sb_size; 415586814edSGao Xiang alg = 0; 416586814edSGao Xiang for (algs = sbi->available_compr_algs; algs; algs >>= 1, ++alg) { 417586814edSGao Xiang void *data; 418586814edSGao Xiang 419586814edSGao Xiang if (!(algs & 1)) 420586814edSGao Xiang continue; 421586814edSGao Xiang 422586814edSGao Xiang data = erofs_read_metadata(sb, &buf, &offset, &size); 423586814edSGao Xiang if (IS_ERR(data)) { 424586814edSGao Xiang ret = PTR_ERR(data); 425586814edSGao Xiang break; 426586814edSGao Xiang } 427586814edSGao Xiang 428586814edSGao Xiang if (alg >= ARRAY_SIZE(erofs_decompressors) || 429586814edSGao Xiang !erofs_decompressors[alg].config) { 430586814edSGao Xiang erofs_err(sb, "algorithm %d isn't enabled on this kernel", 431586814edSGao Xiang alg); 432586814edSGao Xiang ret = -EOPNOTSUPP; 433586814edSGao Xiang } else { 434586814edSGao Xiang ret = erofs_decompressors[alg].config(sb, 435586814edSGao Xiang dsb, data, size); 436586814edSGao Xiang } 437586814edSGao Xiang 438586814edSGao Xiang kfree(data); 439586814edSGao Xiang if (ret) 440586814edSGao Xiang break; 441586814edSGao Xiang } 442586814edSGao Xiang erofs_put_metabuf(&buf); 443586814edSGao Xiang return ret; 444586814edSGao Xiang } 445