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
 17static 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
 34static 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 */
 63static 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
 85static 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 = kmalloc(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
138out_inflate_end:
139	zlib_inflateEnd(&s);
140out:
141	kfree(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
149static 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
207static 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 = kmalloc(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(page);
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	kfree(wksp);
288	return retval;
289}
290#else
291#error "Unexpected configuration for CONFIG_MODULE_DECOMPRESS"
292#endif
293
294int 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	/*
301	 * Start with number of pages twice as big as needed for
302	 * compressed data.
303	 */
304	n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2;
305	error = module_extend_max_pages(info, n_pages);
306
307	data_size = MODULE_DECOMPRESS_FN(info, buf, size);
308	if (data_size < 0) {
309		error = data_size;
310		goto err;
311	}
312
313	info->hdr = vmap(info->pages, info->used_pages, VM_MAP, PAGE_KERNEL);
314	if (!info->hdr) {
315		error = -ENOMEM;
316		goto err;
317	}
318
319	info->len = data_size;
320	return 0;
321
322err:
323	module_decompress_cleanup(info);
324	return error;
325}
326
327void module_decompress_cleanup(struct load_info *info)
328{
329	int i;
330
331	if (info->hdr)
332		vunmap(info->hdr);
333
334	for (i = 0; i < info->used_pages; i++)
335		__free_page(info->pages[i]);
336
337	kvfree(info->pages);
338
339	info->pages = NULL;
340	info->max_pages = info->used_pages = 0;
341}
342
343#ifdef CONFIG_SYSFS
344static ssize_t compression_show(struct kobject *kobj,
345				struct kobj_attribute *attr, char *buf)
346{
347	return sysfs_emit(buf, __stringify(MODULE_COMPRESSION) "\n");
348}
349
350static struct kobj_attribute module_compression_attr = __ATTR_RO(compression);
351
352static int __init module_decompress_sysfs_init(void)
353{
354	int error;
355
356	error = sysfs_create_file(&module_kset->kobj,
357				  &module_compression_attr.attr);
358	if (error)
359		pr_warn("Failed to create 'compression' attribute");
360
361	return 0;
362}
363late_initcall(module_decompress_sysfs_init);
364#endif