xref: /openbmc/linux/kernel/module/decompress.c (revision ada57fd3)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright 2021 Google LLC.
4  */
5 
6 #include <linux/init.h>
7 #include <linux/highmem.h>
8 #include <linux/kobject.h>
9 #include <linux/mm.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/sysfs.h>
13 #include <linux/vmalloc.h>
14 
15 #include "internal.h"
16 
module_extend_max_pages(struct load_info * info,unsigned int extent)17 static int module_extend_max_pages(struct load_info *info, unsigned int extent)
18 {
19 	struct page **new_pages;
20 
21 	new_pages = kvmalloc_array(info->max_pages + extent,
22 				   sizeof(info->pages), GFP_KERNEL);
23 	if (!new_pages)
24 		return -ENOMEM;
25 
26 	memcpy(new_pages, info->pages, info->max_pages * sizeof(info->pages));
27 	kvfree(info->pages);
28 	info->pages = new_pages;
29 	info->max_pages += extent;
30 
31 	return 0;
32 }
33 
module_get_next_page(struct load_info * info)34 static struct page *module_get_next_page(struct load_info *info)
35 {
36 	struct page *page;
37 	int error;
38 
39 	if (info->max_pages == info->used_pages) {
40 		error = module_extend_max_pages(info, info->used_pages);
41 		if (error)
42 			return ERR_PTR(error);
43 	}
44 
45 	page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
46 	if (!page)
47 		return ERR_PTR(-ENOMEM);
48 
49 	info->pages[info->used_pages++] = page;
50 	return page;
51 }
52 
53 #if defined(CONFIG_MODULE_COMPRESS_GZIP)
54 #include <linux/zlib.h>
55 #define MODULE_COMPRESSION	gzip
56 #define MODULE_DECOMPRESS_FN	module_gzip_decompress
57 
58 /*
59  * Calculate length of the header which consists of signature, header
60  * flags, time stamp and operating system ID (10 bytes total), plus
61  * an optional filename.
62  */
module_gzip_header_len(const u8 * buf,size_t size)63 static size_t module_gzip_header_len(const u8 *buf, size_t size)
64 {
65 	const u8 signature[] = { 0x1f, 0x8b, 0x08 };
66 	size_t len = 10;
67 
68 	if (size < len || memcmp(buf, signature, sizeof(signature)))
69 		return 0;
70 
71 	if (buf[3] & 0x08) {
72 		do {
73 			/*
74 			 * If we can't find the end of the file name we must
75 			 * be dealing with a corrupted file.
76 			 */
77 			if (len == size)
78 				return 0;
79 		} while (buf[len++] != '\0');
80 	}
81 
82 	return len;
83 }
84 
module_gzip_decompress(struct load_info * info,const void * buf,size_t size)85 static ssize_t module_gzip_decompress(struct load_info *info,
86 				      const void *buf, size_t size)
87 {
88 	struct z_stream_s s = { 0 };
89 	size_t new_size = 0;
90 	size_t gzip_hdr_len;
91 	ssize_t retval;
92 	int rc;
93 
94 	gzip_hdr_len = module_gzip_header_len(buf, size);
95 	if (!gzip_hdr_len) {
96 		pr_err("not a gzip compressed module\n");
97 		return -EINVAL;
98 	}
99 
100 	s.next_in = buf + gzip_hdr_len;
101 	s.avail_in = size - gzip_hdr_len;
102 
103 	s.workspace = kvmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
104 	if (!s.workspace)
105 		return -ENOMEM;
106 
107 	rc = zlib_inflateInit2(&s, -MAX_WBITS);
108 	if (rc != Z_OK) {
109 		pr_err("failed to initialize decompressor: %d\n", rc);
110 		retval = -EINVAL;
111 		goto out;
112 	}
113 
114 	do {
115 		struct page *page = module_get_next_page(info);
116 
117 		if (IS_ERR(page)) {
118 			retval = PTR_ERR(page);
119 			goto out_inflate_end;
120 		}
121 
122 		s.next_out = kmap_local_page(page);
123 		s.avail_out = PAGE_SIZE;
124 		rc = zlib_inflate(&s, 0);
125 		kunmap_local(s.next_out);
126 
127 		new_size += PAGE_SIZE - s.avail_out;
128 	} while (rc == Z_OK);
129 
130 	if (rc != Z_STREAM_END) {
131 		pr_err("decompression failed with status %d\n", rc);
132 		retval = -EINVAL;
133 		goto out_inflate_end;
134 	}
135 
136 	retval = new_size;
137 
138 out_inflate_end:
139 	zlib_inflateEnd(&s);
140 out:
141 	kvfree(s.workspace);
142 	return retval;
143 }
144 #elif defined(CONFIG_MODULE_COMPRESS_XZ)
145 #include <linux/xz.h>
146 #define MODULE_COMPRESSION	xz
147 #define MODULE_DECOMPRESS_FN	module_xz_decompress
148 
module_xz_decompress(struct load_info * info,const void * buf,size_t size)149 static ssize_t module_xz_decompress(struct load_info *info,
150 				    const void *buf, size_t size)
151 {
152 	static const u8 signature[] = { 0xfd, '7', 'z', 'X', 'Z', 0 };
153 	struct xz_dec *xz_dec;
154 	struct xz_buf xz_buf;
155 	enum xz_ret xz_ret;
156 	size_t new_size = 0;
157 	ssize_t retval;
158 
159 	if (size < sizeof(signature) ||
160 	    memcmp(buf, signature, sizeof(signature))) {
161 		pr_err("not an xz compressed module\n");
162 		return -EINVAL;
163 	}
164 
165 	xz_dec = xz_dec_init(XZ_DYNALLOC, (u32)-1);
166 	if (!xz_dec)
167 		return -ENOMEM;
168 
169 	xz_buf.in_size = size;
170 	xz_buf.in = buf;
171 	xz_buf.in_pos = 0;
172 
173 	do {
174 		struct page *page = module_get_next_page(info);
175 
176 		if (IS_ERR(page)) {
177 			retval = PTR_ERR(page);
178 			goto out;
179 		}
180 
181 		xz_buf.out = kmap_local_page(page);
182 		xz_buf.out_pos = 0;
183 		xz_buf.out_size = PAGE_SIZE;
184 		xz_ret = xz_dec_run(xz_dec, &xz_buf);
185 		kunmap_local(xz_buf.out);
186 
187 		new_size += xz_buf.out_pos;
188 	} while (xz_buf.out_pos == PAGE_SIZE && xz_ret == XZ_OK);
189 
190 	if (xz_ret != XZ_STREAM_END) {
191 		pr_err("decompression failed with status %d\n", xz_ret);
192 		retval = -EINVAL;
193 		goto out;
194 	}
195 
196 	retval = new_size;
197 
198  out:
199 	xz_dec_end(xz_dec);
200 	return retval;
201 }
202 #elif defined(CONFIG_MODULE_COMPRESS_ZSTD)
203 #include <linux/zstd.h>
204 #define MODULE_COMPRESSION	zstd
205 #define MODULE_DECOMPRESS_FN	module_zstd_decompress
206 
module_zstd_decompress(struct load_info * info,const void * buf,size_t size)207 static ssize_t module_zstd_decompress(struct load_info *info,
208 				    const void *buf, size_t size)
209 {
210 	static const u8 signature[] = { 0x28, 0xb5, 0x2f, 0xfd };
211 	ZSTD_outBuffer zstd_dec;
212 	ZSTD_inBuffer zstd_buf;
213 	zstd_frame_header header;
214 	size_t wksp_size;
215 	void *wksp = NULL;
216 	ZSTD_DStream *dstream;
217 	size_t ret;
218 	size_t new_size = 0;
219 	int retval;
220 
221 	if (size < sizeof(signature) ||
222 	    memcmp(buf, signature, sizeof(signature))) {
223 		pr_err("not a zstd compressed module\n");
224 		return -EINVAL;
225 	}
226 
227 	zstd_buf.src = buf;
228 	zstd_buf.pos = 0;
229 	zstd_buf.size = size;
230 
231 	ret = zstd_get_frame_header(&header, zstd_buf.src, zstd_buf.size);
232 	if (ret != 0) {
233 		pr_err("ZSTD-compressed data has an incomplete frame header\n");
234 		retval = -EINVAL;
235 		goto out;
236 	}
237 	if (header.windowSize > (1 << ZSTD_WINDOWLOG_MAX)) {
238 		pr_err("ZSTD-compressed data has too large a window size\n");
239 		retval = -EINVAL;
240 		goto out;
241 	}
242 
243 	wksp_size = zstd_dstream_workspace_bound(header.windowSize);
244 	wksp = kvmalloc(wksp_size, GFP_KERNEL);
245 	if (!wksp) {
246 		retval = -ENOMEM;
247 		goto out;
248 	}
249 
250 	dstream = zstd_init_dstream(header.windowSize, wksp, wksp_size);
251 	if (!dstream) {
252 		pr_err("Can't initialize ZSTD stream\n");
253 		retval = -ENOMEM;
254 		goto out;
255 	}
256 
257 	do {
258 		struct page *page = module_get_next_page(info);
259 
260 		if (IS_ERR(page)) {
261 			retval = PTR_ERR(page);
262 			goto out;
263 		}
264 
265 		zstd_dec.dst = kmap_local_page(page);
266 		zstd_dec.pos = 0;
267 		zstd_dec.size = PAGE_SIZE;
268 
269 		ret = zstd_decompress_stream(dstream, &zstd_dec, &zstd_buf);
270 		kunmap_local(zstd_dec.dst);
271 		retval = zstd_get_error_code(ret);
272 		if (retval)
273 			break;
274 
275 		new_size += zstd_dec.pos;
276 	} while (zstd_dec.pos == PAGE_SIZE && ret != 0);
277 
278 	if (retval) {
279 		pr_err("ZSTD-decompression failed with status %d\n", retval);
280 		retval = -EINVAL;
281 		goto out;
282 	}
283 
284 	retval = new_size;
285 
286  out:
287 	kvfree(wksp);
288 	return retval;
289 }
290 #else
291 #error "Unexpected configuration for CONFIG_MODULE_DECOMPRESS"
292 #endif
293 
module_decompress(struct load_info * info,const void * buf,size_t size)294 int module_decompress(struct load_info *info, const void *buf, size_t size)
295 {
296 	unsigned int n_pages;
297 	ssize_t data_size;
298 	int error;
299 
300 #if defined(CONFIG_MODULE_STATS)
301 	info->compressed_len = size;
302 #endif
303 
304 	/*
305 	 * Start with number of pages twice as big as needed for
306 	 * compressed data.
307 	 */
308 	n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2;
309 	error = module_extend_max_pages(info, n_pages);
310 
311 	data_size = MODULE_DECOMPRESS_FN(info, buf, size);
312 	if (data_size < 0) {
313 		error = data_size;
314 		goto err;
315 	}
316 
317 	info->hdr = vmap(info->pages, info->used_pages, VM_MAP, PAGE_KERNEL);
318 	if (!info->hdr) {
319 		error = -ENOMEM;
320 		goto err;
321 	}
322 
323 	info->len = data_size;
324 	return 0;
325 
326 err:
327 	module_decompress_cleanup(info);
328 	return error;
329 }
330 
module_decompress_cleanup(struct load_info * info)331 void module_decompress_cleanup(struct load_info *info)
332 {
333 	int i;
334 
335 	if (info->hdr)
336 		vunmap(info->hdr);
337 
338 	for (i = 0; i < info->used_pages; i++)
339 		__free_page(info->pages[i]);
340 
341 	kvfree(info->pages);
342 
343 	info->pages = NULL;
344 	info->max_pages = info->used_pages = 0;
345 }
346 
347 #ifdef CONFIG_SYSFS
compression_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)348 static ssize_t compression_show(struct kobject *kobj,
349 				struct kobj_attribute *attr, char *buf)
350 {
351 	return sysfs_emit(buf, __stringify(MODULE_COMPRESSION) "\n");
352 }
353 
354 static struct kobj_attribute module_compression_attr = __ATTR_RO(compression);
355 
module_decompress_sysfs_init(void)356 static int __init module_decompress_sysfs_init(void)
357 {
358 	int error;
359 
360 	error = sysfs_create_file(&module_kset->kobj,
361 				  &module_compression_attr.attr);
362 	if (error)
363 		pr_warn("Failed to create 'compression' attribute");
364 
365 	return 0;
366 }
367 late_initcall(module_decompress_sysfs_init);
368 #endif
369