1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Squashfs - a compressed read only filesystem for Linux
4 *
5 * Copyright (c) 2016-present, Facebook, Inc.
6 * All rights reserved.
7 *
8 * zstd_wrapper.c
9 */
10
11 #include <linux/mutex.h>
12 #include <linux/bio.h>
13 #include <linux/slab.h>
14 #include <linux/zstd.h>
15 #include <linux/vmalloc.h>
16
17 #include "squashfs_fs.h"
18 #include "squashfs_fs_sb.h"
19 #include "squashfs.h"
20 #include "decompressor.h"
21 #include "page_actor.h"
22
23 struct workspace {
24 void *mem;
25 size_t mem_size;
26 size_t window_size;
27 };
28
zstd_init(struct squashfs_sb_info * msblk,void * buff)29 static void *zstd_init(struct squashfs_sb_info *msblk, void *buff)
30 {
31 struct workspace *wksp = kmalloc(sizeof(*wksp), GFP_KERNEL);
32
33 if (wksp == NULL)
34 goto failed;
35 wksp->window_size = max_t(size_t,
36 msblk->block_size, SQUASHFS_METADATA_SIZE);
37 wksp->mem_size = ZSTD_DStreamWorkspaceBound(wksp->window_size);
38 wksp->mem = vmalloc(wksp->mem_size);
39 if (wksp->mem == NULL)
40 goto failed;
41
42 return wksp;
43
44 failed:
45 ERROR("Failed to allocate zstd workspace\n");
46 kfree(wksp);
47 return ERR_PTR(-ENOMEM);
48 }
49
50
zstd_free(void * strm)51 static void zstd_free(void *strm)
52 {
53 struct workspace *wksp = strm;
54
55 if (wksp)
56 vfree(wksp->mem);
57 kfree(wksp);
58 }
59
60
zstd_uncompress(struct squashfs_sb_info * msblk,void * strm,struct bio * bio,int offset,int length,struct squashfs_page_actor * output)61 static int zstd_uncompress(struct squashfs_sb_info *msblk, void *strm,
62 struct bio *bio, int offset, int length,
63 struct squashfs_page_actor *output)
64 {
65 struct workspace *wksp = strm;
66 ZSTD_DStream *stream;
67 size_t total_out = 0;
68 int error = 0;
69 ZSTD_inBuffer in_buf = { NULL, 0, 0 };
70 ZSTD_outBuffer out_buf = { NULL, 0, 0 };
71 struct bvec_iter_all iter_all = {};
72 struct bio_vec *bvec = bvec_init_iter_all(&iter_all);
73
74 stream = ZSTD_initDStream(wksp->window_size, wksp->mem, wksp->mem_size);
75
76 if (!stream) {
77 ERROR("Failed to initialize zstd decompressor\n");
78 return -EIO;
79 }
80
81 out_buf.size = PAGE_SIZE;
82 out_buf.dst = squashfs_first_page(output);
83
84 for (;;) {
85 size_t zstd_err;
86
87 if (in_buf.pos == in_buf.size) {
88 const void *data;
89 int avail;
90
91 if (!bio_next_segment(bio, &iter_all)) {
92 error = -EIO;
93 break;
94 }
95
96 avail = min(length, ((int)bvec->bv_len) - offset);
97 data = page_address(bvec->bv_page) + bvec->bv_offset;
98 length -= avail;
99 in_buf.src = data + offset;
100 in_buf.size = avail;
101 in_buf.pos = 0;
102 offset = 0;
103 }
104
105 if (out_buf.pos == out_buf.size) {
106 out_buf.dst = squashfs_next_page(output);
107 if (out_buf.dst == NULL) {
108 /* Shouldn't run out of pages
109 * before stream is done.
110 */
111 error = -EIO;
112 break;
113 }
114 out_buf.pos = 0;
115 out_buf.size = PAGE_SIZE;
116 }
117
118 total_out -= out_buf.pos;
119 zstd_err = ZSTD_decompressStream(stream, &out_buf, &in_buf);
120 total_out += out_buf.pos; /* add the additional data produced */
121 if (zstd_err == 0)
122 break;
123
124 if (ZSTD_isError(zstd_err)) {
125 ERROR("zstd decompression error: %d\n",
126 (int)ZSTD_getErrorCode(zstd_err));
127 error = -EIO;
128 break;
129 }
130 }
131
132 squashfs_finish_page(output);
133
134 return error ? error : total_out;
135 }
136
137 const struct squashfs_decompressor squashfs_zstd_comp_ops = {
138 .init = zstd_init,
139 .free = zstd_free,
140 .decompress = zstd_uncompress,
141 .id = ZSTD_COMPRESSION,
142 .name = "zstd",
143 .supported = 1
144 };
145