[linux-2.6-block.git] / kernel / module / decompress.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 2021 Google LLC.
 */

#include <linux/init.h>
#include <linux/highmem.h>
#include <linux/kobject.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/vmalloc.h>

#include "internal.h"

static int module_extend_max_pages(struct load_info *info, unsigned int extent)
{
	struct page **new_pages;

	new_pages = kvmalloc_array(info->max_pages + extent,
				   sizeof(info->pages), GFP_KERNEL);
	if (!new_pages)
		return -ENOMEM;

	memcpy(new_pages, info->pages, info->max_pages * sizeof(info->pages));
	kvfree(info->pages);
	info->pages = new_pages;
	info->max_pages += extent;

	return 0;
}

static struct page *module_get_next_page(struct load_info *info)
{
	struct page *page;
	int error;

	if (info->max_pages == info->used_pages) {
		error = module_extend_max_pages(info, info->used_pages);
		if (error)
			return ERR_PTR(error);
	}

	page = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
	if (!page)
		return ERR_PTR(-ENOMEM);

	info->pages[info->used_pages++] = page;
	return page;
}

#ifdef CONFIG_MODULE_COMPRESS_GZIP
#include <linux/zlib.h>
#define MODULE_COMPRESSION	gzip
#define MODULE_DECOMPRESS_FN	module_gzip_decompress

/*
 * Calculate length of the header which consists of signature, header
 * flags, time stamp and operating system ID (10 bytes total), plus
 * an optional filename.
 */
static size_t module_gzip_header_len(const u8 *buf, size_t size)
{
	const u8 signature[] = { 0x1f, 0x8b, 0x08 };
	size_t len = 10;

	if (size < len || memcmp(buf, signature, sizeof(signature)))
		return 0;

	if (buf[3] & 0x08) {
		do {
			/*
			 * If we can't find the end of the file name we must
			 * be dealing with a corrupted file.
			 */
			if (len == size)
				return 0;
		} while (buf[len++] != '\0');
	}

	return len;
}

static ssize_t module_gzip_decompress(struct load_info *info,
				      const void *buf, size_t size)
{
	struct z_stream_s s = { 0 };
	size_t new_size = 0;
	size_t gzip_hdr_len;
	ssize_t retval;
	int rc;

	gzip_hdr_len = module_gzip_header_len(buf, size);
	if (!gzip_hdr_len) {
		pr_err("not a gzip compressed module\n");
		return -EINVAL;
	}

	s.next_in = buf + gzip_hdr_len;
	s.avail_in = size - gzip_hdr_len;

	s.workspace = kmalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
	if (!s.workspace)
		return -ENOMEM;

	rc = zlib_inflateInit2(&s, -MAX_WBITS);
	if (rc != Z_OK) {
		pr_err("failed to initialize decompressor: %d\n", rc);
		retval = -EINVAL;
		goto out;
	}

	do {
		struct page *page = module_get_next_page(info);

		if (!page) {
			retval = -ENOMEM;
			goto out_inflate_end;
		}

		s.next_out = kmap_local_page(page);
		s.avail_out = PAGE_SIZE;
		rc = zlib_inflate(&s, 0);
		kunmap_local(s.next_out);

		new_size += PAGE_SIZE - s.avail_out;
	} while (rc == Z_OK);

	if (rc != Z_STREAM_END) {
		pr_err("decompression failed with status %d\n", rc);
		retval = -EINVAL;
		goto out_inflate_end;
	}

	retval = new_size;

out_inflate_end:
	zlib_inflateEnd(&s);
out:
	kfree(s.workspace);
	return retval;
}
#elif CONFIG_MODULE_COMPRESS_XZ
#include <linux/xz.h>
#define MODULE_COMPRESSION	xz
#define MODULE_DECOMPRESS_FN	module_xz_decompress

static ssize_t module_xz_decompress(struct load_info *info,
				    const void *buf, size_t size)
{
	static const u8 signature[] = { 0xfd, '7', 'z', 'X', 'Z', 0 };
	struct xz_dec *xz_dec;
	struct xz_buf xz_buf;
	enum xz_ret xz_ret;
	size_t new_size = 0;
	ssize_t retval;

	if (size < sizeof(signature) ||
	    memcmp(buf, signature, sizeof(signature))) {
		pr_err("not an xz compressed module\n");
		return -EINVAL;
	}

	xz_dec = xz_dec_init(XZ_DYNALLOC, (u32)-1);
	if (!xz_dec)
		return -ENOMEM;

	xz_buf.in_size = size;
	xz_buf.in = buf;
	xz_buf.in_pos = 0;

	do {
		struct page *page = module_get_next_page(info);

		if (!page) {
			retval = -ENOMEM;
			goto out;
		}

		xz_buf.out = kmap_local_page(page);
		xz_buf.out_pos = 0;
		xz_buf.out_size = PAGE_SIZE;
		xz_ret = xz_dec_run(xz_dec, &xz_buf);
		kunmap_local(xz_buf.out);

		new_size += xz_buf.out_pos;
	} while (xz_buf.out_pos == PAGE_SIZE && xz_ret == XZ_OK);

	if (xz_ret != XZ_STREAM_END) {
		pr_err("decompression failed with status %d\n", xz_ret);
		retval = -EINVAL;
		goto out;
	}

	retval = new_size;

 out:
	xz_dec_end(xz_dec);
	return retval;
}
#else
#error "Unexpected configuration for CONFIG_MODULE_DECOMPRESS"
#endif

int module_decompress(struct load_info *info, const void *buf, size_t size)
{
	unsigned int n_pages;
	ssize_t data_size;
	int error;

	/*
	 * Start with number of pages twice as big as needed for
	 * compressed data.
	 */
	n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2;
	error = module_extend_max_pages(info, n_pages);

	data_size = MODULE_DECOMPRESS_FN(info, buf, size);
	if (data_size < 0) {
		error = data_size;
		goto err;
	}

	info->hdr = vmap(info->pages, info->used_pages, VM_MAP, PAGE_KERNEL);
	if (!info->hdr) {
		error = -ENOMEM;
		goto err;
	}

	info->len = data_size;
	return 0;

err:
	module_decompress_cleanup(info);
	return error;
}

void module_decompress_cleanup(struct load_info *info)
{
	int i;

	if (info->hdr)
		vunmap(info->hdr);

	for (i = 0; i < info->used_pages; i++)
		__free_page(info->pages[i]);

	kvfree(info->pages);

	info->pages = NULL;
	info->max_pages = info->used_pages = 0;
}

#ifdef CONFIG_SYSFS
static ssize_t compression_show(struct kobject *kobj,
				struct kobj_attribute *attr, char *buf)
{
	return sysfs_emit(buf, "%s\n", __stringify(MODULE_COMPRESSION));
}

static struct kobj_attribute module_compression_attr = __ATTR_RO(compression);

static int __init module_decompress_sysfs_init(void)
{
	int error;

	error = sysfs_create_file(&module_kset->kobj,
				  &module_compression_attr.attr);
	if (error)
		pr_warn("Failed to create 'compression' attribute");

	return 0;
}
late_initcall(module_decompress_sysfs_init);
#endif
Commit	Line	Data
b1ae6dc4 DT	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
cfc1d277	15	#include "internal.h"
b1ae6dc4 DT	16
	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
	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	#ifdef 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	*/
	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
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 = 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) {
285ac8dc	109	pr_err("failed to initialize decompressor: %d\n", rc);
b1ae6dc4 DT	110	retval = -EINVAL;
	111	goto out;
	112	}
	113
	114	do {
	115	struct page *page = module_get_next_page(info);
5aff4dfd	116
b1ae6dc4 DT	117	if (!page) {
	118	retval = -ENOMEM;
	119	goto out_inflate_end;
	120	}
	121
554694ba	122	s.next_out = kmap_local_page(page);
b1ae6dc4 DT	123	s.avail_out = PAGE_SIZE;
b1ae6dc4 DT	124	rc = zlib_inflate(&s, 0);
554694ba	125	kunmap_local(s.next_out);
b1ae6dc4 DT	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	kfree(s.workspace);
	142	return retval;
	143	}
	144	#elif CONFIG_MODULE_COMPRESS_XZ
	145	#include <linux/xz.h>
	146	#define MODULE_COMPRESSION xz
	147	#define MODULE_DECOMPRESS_FN module_xz_decompress
	148
	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);
5aff4dfd	175
b1ae6dc4 DT	176	if (!page) {
	177	retval = -ENOMEM;
	178	goto out;
	179	}
	180
554694ba	181	xz_buf.out = kmap_local_page(page);
b1ae6dc4 DT	182	xz_buf.out_pos = 0;
	183	xz_buf.out_size = PAGE_SIZE;
	184	xz_ret = xz_dec_run(xz_dec, &xz_buf);
554694ba	185	kunmap_local(xz_buf.out);
b1ae6dc4 DT	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	#else
	203	#error "Unexpected configuration for CONFIG_MODULE_DECOMPRESS"
	204	#endif
	205
	206	int module_decompress(struct load_info info, const void buf, size_t size)
	207	{
	208	unsigned int n_pages;
	209	ssize_t data_size;
	210	int error;
	211
	212	/*
	213	* Start with number of pages twice as big as needed for
	214	* compressed data.
	215	*/
	216	n_pages = DIV_ROUND_UP(size, PAGE_SIZE) * 2;
	217	error = module_extend_max_pages(info, n_pages);
	218
	219	data_size = MODULE_DECOMPRESS_FN(info, buf, size);
	220	if (data_size < 0) {
	221	error = data_size;
	222	goto err;
	223	}
	224
	225	info->hdr = vmap(info->pages, info->used_pages, VM_MAP, PAGE_KERNEL);
	226	if (!info->hdr) {
	227	error = -ENOMEM;
	228	goto err;
	229	}
	230
	231	info->len = data_size;
	232	return 0;
	233
	234	err:
	235	module_decompress_cleanup(info);
	236	return error;
	237	}
	238
	239	void module_decompress_cleanup(struct load_info *info)
	240	{
	241	int i;
	242
	243	if (info->hdr)
	244	vunmap(info->hdr);
	245
	246	for (i = 0; i < info->used_pages; i++)
	247	__free_page(info->pages[i]);
	248
	249	kvfree(info->pages);
250
251	info->pages = NULL;
252	info->max_pages = info->used_pages = 0;
253	}
254
a8e8f851	255	#ifdef CONFIG_SYSFS
b1ae6dc4 DT	256	static ssize_t compression_show(struct kobject *kobj,
	257	struct kobj_attribute attr, char buf)
	258	{
	259	return sysfs_emit(buf, "%s\n", __stringify(MODULE_COMPRESSION));
	260	}
5aff4dfd	261
b1ae6dc4 DT	262	static struct kobj_attribute module_compression_attr = __ATTR_RO(compression);
	263
	264	static int __init module_decompress_sysfs_init(void)
	265	{
	266	int error;
	267
	268	error = sysfs_create_file(&module_kset->kobj,
	269	&module_compression_attr.attr);
	270	if (error)
	271	pr_warn("Failed to create 'compression' attribute");
	272
	273	return 0;
	274	}
	275	late_initcall(module_decompress_sysfs_init);
a8e8f851	276	#endif