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
z_erofs_load_lz4_config(struct super_block * sb,struct erofs_super_block * dsb,void * data,int size)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 */
z_erofs_lz4_prepare_dstpages(struct z_erofs_lz4_decompress_ctx * ctx,struct page ** pagepool)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
z_erofs_lz4_handle_overlap(struct z_erofs_lz4_decompress_ctx * ctx,void * inpage,void * out,unsigned int * inputmargin,int * maptype,bool may_inplace)124d67aee76SGao Xiang static void *z_erofs_lz4_handle_overlap(struct z_erofs_lz4_decompress_ctx *ctx,
125*f36d200aSGao Xiang void *inpage, void *out, unsigned int *inputmargin,
126*f36d200aSGao Xiang int *maptype, bool may_inplace)
12747e4937aSGao Xiang {
128d67aee76SGao Xiang struct z_erofs_decompress_req *rq = ctx->rq;
129*f36d200aSGao Xiang unsigned int omargin, total, i;
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
139*f36d200aSGao Xiang for (i = 0; i < ctx->inpages; ++i)
140*f36d200aSGao Xiang if (rq->out[ctx->outpages - ctx->inpages + i] !=
141*f36d200aSGao Xiang rq->in[i])
142598162d0SGao Xiang goto docopy;
143*f36d200aSGao Xiang kunmap_local(inpage);
144*f36d200aSGao Xiang *maptype = 3;
145*f36d200aSGao Xiang return out + ((ctx->outpages - ctx->inpages) << PAGE_SHIFT);
146598162d0SGao Xiang }
147598162d0SGao Xiang
148d67aee76SGao Xiang if (ctx->inpages <= 1) {
149598162d0SGao Xiang *maptype = 0;
150598162d0SGao Xiang return inpage;
151598162d0SGao Xiang }
152123ec246SGao Xiang kunmap_local(inpage);
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 */
z_erofs_fixup_insize(struct z_erofs_decompress_req * rq,const char * padbuf,unsigned int padbufsize)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
z_erofs_lz4_decompress_mem(struct z_erofs_lz4_decompress_ctx * ctx,u8 * dst)207d67aee76SGao Xiang static int z_erofs_lz4_decompress_mem(struct z_erofs_lz4_decompress_ctx *ctx,
208*f36d200aSGao Xiang u8 *dst)
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;
213*f36d200aSGao Xiang u8 *out, *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;
234*f36d200aSGao Xiang src = z_erofs_lz4_handle_overlap(ctx, headpage, dst, &inputmargin,
235ab749badSGao Xiang &maptype, may_inplace);
236598162d0SGao Xiang if (IS_ERR(src))
237598162d0SGao Xiang return PTR_ERR(src);
23847e4937aSGao Xiang
239*f36d200aSGao Xiang out = dst + rq->pageofs_out;
240af1038abSGao Xiang /* legacy format could compress extra data in a pcluster. */
241af1038abSGao Xiang if (rq->partial_decoding || !support_0padding)
24247e4937aSGao Xiang ret = LZ4_decompress_safe_partial(src + inputmargin, out,
243598162d0SGao Xiang rq->inputsize, rq->outputsize, rq->outputsize);
244af1038abSGao Xiang else
245af1038abSGao Xiang ret = LZ4_decompress_safe(src + inputmargin, out,
246598162d0SGao Xiang rq->inputsize, rq->outputsize);
247af1038abSGao Xiang
248aa99a76bSGao Xiang if (ret != rq->outputsize) {
249aa99a76bSGao Xiang erofs_err(rq->sb, "failed to decompress %d in[%u, %u] out[%u]",
250598162d0SGao Xiang ret, rq->inputsize, inputmargin, rq->outputsize);
251aa99a76bSGao Xiang
25247e4937aSGao Xiang print_hex_dump(KERN_DEBUG, "[ in]: ", DUMP_PREFIX_OFFSET,
253598162d0SGao Xiang 16, 1, src + inputmargin, rq->inputsize, true);
25447e4937aSGao Xiang print_hex_dump(KERN_DEBUG, "[out]: ", DUMP_PREFIX_OFFSET,
25547e4937aSGao Xiang 16, 1, out, rq->outputsize, true);
256aa99a76bSGao Xiang
257aa99a76bSGao Xiang if (ret >= 0)
258aa99a76bSGao Xiang memset(out + ret, 0, rq->outputsize - ret);
25947e4937aSGao Xiang ret = -EIO;
2605b6e7e12SYue Hu } else {
2615b6e7e12SYue Hu ret = 0;
26247e4937aSGao Xiang }
26347e4937aSGao Xiang
264598162d0SGao Xiang if (maptype == 0) {
265123ec246SGao Xiang kunmap_local(headpage);
266598162d0SGao Xiang } else if (maptype == 1) {
267d67aee76SGao Xiang vm_unmap_ram(src, ctx->inpages);
268598162d0SGao Xiang } else if (maptype == 2) {
269598162d0SGao Xiang erofs_put_pcpubuf(src);
270*f36d200aSGao Xiang } else if (maptype != 3) {
271598162d0SGao Xiang DBG_BUGON(1);
272598162d0SGao Xiang return -EFAULT;
273598162d0SGao Xiang }
27447e4937aSGao Xiang return ret;
27547e4937aSGao Xiang }
27647e4937aSGao Xiang
z_erofs_lz4_decompress(struct z_erofs_decompress_req * rq,struct page ** pagepool)277966edfb0SGao Xiang static int z_erofs_lz4_decompress(struct z_erofs_decompress_req *rq,
278eaa9172aSGao Xiang struct page **pagepool)
27947e4937aSGao Xiang {
280d67aee76SGao Xiang struct z_erofs_lz4_decompress_ctx ctx;
28147e4937aSGao Xiang unsigned int dst_maptype;
28247e4937aSGao Xiang void *dst;
283598162d0SGao Xiang int ret;
28447e4937aSGao Xiang
285d67aee76SGao Xiang ctx.rq = rq;
286d67aee76SGao Xiang ctx.oend = rq->pageofs_out + rq->outputsize;
287d67aee76SGao Xiang ctx.outpages = PAGE_ALIGN(ctx.oend) >> PAGE_SHIFT;
288d67aee76SGao Xiang ctx.inpages = PAGE_ALIGN(rq->inputsize) >> PAGE_SHIFT;
289d67aee76SGao Xiang
2905b6e7e12SYue Hu /* one optimized fast path only for non bigpcluster cases yet */
291d67aee76SGao Xiang if (ctx.inpages == 1 && ctx.outpages == 1 && !rq->inplace_io) {
29247e4937aSGao Xiang DBG_BUGON(!*rq->out);
293123ec246SGao Xiang dst = kmap_local_page(*rq->out);
29447e4937aSGao Xiang dst_maptype = 0;
29547e4937aSGao Xiang goto dstmap_out;
29647e4937aSGao Xiang }
29747e4937aSGao Xiang
298598162d0SGao Xiang /* general decoding path which can be used for all cases */
299d67aee76SGao Xiang ret = z_erofs_lz4_prepare_dstpages(&ctx, pagepool);
300d67aee76SGao Xiang if (ret < 0) {
30147e4937aSGao Xiang return ret;
302d67aee76SGao Xiang } else if (ret > 0) {
30347e4937aSGao Xiang dst = page_address(*rq->out);
30447e4937aSGao Xiang dst_maptype = 1;
305d67aee76SGao Xiang } else {
306d67aee76SGao Xiang dst = erofs_vm_map_ram(rq->out, ctx.outpages);
30747e4937aSGao Xiang if (!dst)
30847e4937aSGao Xiang return -ENOMEM;
30947e4937aSGao Xiang dst_maptype = 2;
310d67aee76SGao Xiang }
31147e4937aSGao Xiang
31247e4937aSGao Xiang dstmap_out:
313*f36d200aSGao Xiang ret = z_erofs_lz4_decompress_mem(&ctx, dst);
31447e4937aSGao Xiang if (!dst_maptype)
315123ec246SGao Xiang kunmap_local(dst);
31647e4937aSGao Xiang else if (dst_maptype == 2)
317d67aee76SGao Xiang vm_unmap_ram(dst, ctx.outpages);
31847e4937aSGao Xiang return ret;
31947e4937aSGao Xiang }
32047e4937aSGao Xiang
z_erofs_transform_plain(struct z_erofs_decompress_req * rq,struct page ** pagepool)321fdffc091SYue Hu static int z_erofs_transform_plain(struct z_erofs_decompress_req *rq,
322eaa9172aSGao Xiang struct page **pagepool)
32347e4937aSGao Xiang {
324fdffc091SYue Hu const unsigned int inpages = PAGE_ALIGN(rq->inputsize) >> PAGE_SHIFT;
325fdffc091SYue Hu const unsigned int outpages =
32647e4937aSGao Xiang PAGE_ALIGN(rq->pageofs_out + rq->outputsize) >> PAGE_SHIFT;
327ab749badSGao Xiang const unsigned int righthalf = min_t(unsigned int, rq->outputsize,
328ab749badSGao Xiang PAGE_SIZE - rq->pageofs_out);
329dcbe6803SGao Xiang const unsigned int lefthalf = rq->outputsize - righthalf;
330fdffc091SYue Hu const unsigned int interlaced_offset =
331fdffc091SYue Hu rq->alg == Z_EROFS_COMPRESSION_SHIFTED ? 0 : rq->pageofs_out;
332c5539762SGao Xiang u8 *src;
33347e4937aSGao Xiang
334fdffc091SYue Hu if (outpages > 2 && rq->alg == Z_EROFS_COMPRESSION_SHIFTED) {
33547e4937aSGao Xiang DBG_BUGON(1);
336fdffc091SYue Hu return -EFSCORRUPTED;
33747e4937aSGao Xiang }
33847e4937aSGao Xiang
33947e4937aSGao Xiang if (rq->out[0] == *rq->in) {
340fdffc091SYue Hu DBG_BUGON(rq->pageofs_out);
34147e4937aSGao Xiang return 0;
34247e4937aSGao Xiang }
34347e4937aSGao Xiang
344fdffc091SYue Hu src = kmap_local_page(rq->in[inpages - 1]) + rq->pageofs_in;
345c5539762SGao Xiang if (rq->out[0])
346c5539762SGao Xiang memcpy_to_page(rq->out[0], rq->pageofs_out,
347c5539762SGao Xiang src + interlaced_offset, righthalf);
34847e4937aSGao Xiang
349fdffc091SYue Hu if (outpages > inpages) {
350fdffc091SYue Hu DBG_BUGON(!rq->out[outpages - 1]);
351fdffc091SYue Hu if (rq->out[outpages - 1] != rq->in[inpages - 1]) {
352c5539762SGao Xiang memcpy_to_page(rq->out[outpages - 1], 0, src +
353c5539762SGao Xiang (interlaced_offset ? 0 : righthalf),
354c5539762SGao Xiang lefthalf);
355fdffc091SYue Hu } else if (!interlaced_offset) {
356dcbe6803SGao Xiang memmove(src, src + righthalf, lefthalf);
357c5539762SGao Xiang flush_dcache_page(rq->in[inpages - 1]);
3584d202437SGao Xiang }
3594d202437SGao Xiang }
360fdffc091SYue Hu kunmap_local(src);
36147e4937aSGao Xiang return 0;
36247e4937aSGao Xiang }
36347e4937aSGao Xiang
364597e2953SYue Hu const struct z_erofs_decompressor erofs_decompressors[] = {
365966edfb0SGao Xiang [Z_EROFS_COMPRESSION_SHIFTED] = {
366fdffc091SYue Hu .decompress = z_erofs_transform_plain,
367966edfb0SGao Xiang .name = "shifted"
368966edfb0SGao Xiang },
369fdffc091SYue Hu [Z_EROFS_COMPRESSION_INTERLACED] = {
370fdffc091SYue Hu .decompress = z_erofs_transform_plain,
371fdffc091SYue Hu .name = "interlaced"
372fdffc091SYue Hu },
373966edfb0SGao Xiang [Z_EROFS_COMPRESSION_LZ4] = {
374586814edSGao Xiang .config = z_erofs_load_lz4_config,
375966edfb0SGao Xiang .decompress = z_erofs_lz4_decompress,
376966edfb0SGao Xiang .name = "lz4"
377966edfb0SGao Xiang },
378622ceaddSGao Xiang #ifdef CONFIG_EROFS_FS_ZIP_LZMA
379622ceaddSGao Xiang [Z_EROFS_COMPRESSION_LZMA] = {
380586814edSGao Xiang .config = z_erofs_load_lzma_config,
381622ceaddSGao Xiang .decompress = z_erofs_lzma_decompress,
382622ceaddSGao Xiang .name = "lzma"
383622ceaddSGao Xiang },
384622ceaddSGao Xiang #endif
385ffa09b3bSGao Xiang #ifdef CONFIG_EROFS_FS_ZIP_DEFLATE
386ffa09b3bSGao Xiang [Z_EROFS_COMPRESSION_DEFLATE] = {
387586814edSGao Xiang .config = z_erofs_load_deflate_config,
388ffa09b3bSGao Xiang .decompress = z_erofs_deflate_decompress,
389ffa09b3bSGao Xiang .name = "deflate"
390ffa09b3bSGao Xiang },
391ffa09b3bSGao Xiang #endif
392966edfb0SGao Xiang };
393586814edSGao Xiang
z_erofs_parse_cfgs(struct super_block * sb,struct erofs_super_block * dsb)394586814edSGao Xiang int z_erofs_parse_cfgs(struct super_block *sb, struct erofs_super_block *dsb)
395586814edSGao Xiang {
396586814edSGao Xiang struct erofs_sb_info *sbi = EROFS_SB(sb);
397586814edSGao Xiang struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
398586814edSGao Xiang unsigned int algs, alg;
399586814edSGao Xiang erofs_off_t offset;
400586814edSGao Xiang int size, ret = 0;
401586814edSGao Xiang
402586814edSGao Xiang if (!erofs_sb_has_compr_cfgs(sbi)) {
403823ba1d2SGao Xiang sbi->available_compr_algs = 1 << Z_EROFS_COMPRESSION_LZ4;
404586814edSGao Xiang return z_erofs_load_lz4_config(sb, dsb, NULL, 0);
405586814edSGao Xiang }
406586814edSGao Xiang
407586814edSGao Xiang sbi->available_compr_algs = le16_to_cpu(dsb->u1.available_compr_algs);
408586814edSGao Xiang if (sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS) {
409586814edSGao Xiang erofs_err(sb, "unidentified algorithms %x, please upgrade kernel",
410586814edSGao Xiang sbi->available_compr_algs & ~Z_EROFS_ALL_COMPR_ALGS);
411586814edSGao Xiang return -EOPNOTSUPP;
412586814edSGao Xiang }
413586814edSGao Xiang
414586814edSGao Xiang erofs_init_metabuf(&buf, sb);
415586814edSGao Xiang offset = EROFS_SUPER_OFFSET + sbi->sb_size;
416586814edSGao Xiang alg = 0;
417586814edSGao Xiang for (algs = sbi->available_compr_algs; algs; algs >>= 1, ++alg) {
418586814edSGao Xiang void *data;
419586814edSGao Xiang
420586814edSGao Xiang if (!(algs & 1))
421586814edSGao Xiang continue;
422586814edSGao Xiang
423586814edSGao Xiang data = erofs_read_metadata(sb, &buf, &offset, &size);
424586814edSGao Xiang if (IS_ERR(data)) {
425586814edSGao Xiang ret = PTR_ERR(data);
426586814edSGao Xiang break;
427586814edSGao Xiang }
428586814edSGao Xiang
429586814edSGao Xiang if (alg >= ARRAY_SIZE(erofs_decompressors) ||
430586814edSGao Xiang !erofs_decompressors[alg].config) {
431586814edSGao Xiang erofs_err(sb, "algorithm %d isn't enabled on this kernel",
432586814edSGao Xiang alg);
433586814edSGao Xiang ret = -EOPNOTSUPP;
434586814edSGao Xiang } else {
435586814edSGao Xiang ret = erofs_decompressors[alg].config(sb,
436586814edSGao Xiang dsb, data, size);
437586814edSGao Xiang }
438586814edSGao Xiang
439586814edSGao Xiang kfree(data);
440586814edSGao Xiang if (ret)
441586814edSGao Xiang break;
442586814edSGao Xiang }
443586814edSGao Xiang erofs_put_metabuf(&buf);
444586814edSGao Xiang return ret;
445586814edSGao Xiang }
446