kernel/module/decompress.c - linux - Git at Google

 // 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;
 }

 #if defined(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 (IS_ERR(page)) {
 			retval = PTR_ERR(page);
 			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 defined(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 (IS_ERR(page)) {
 			retval = PTR_ERR(page);
 			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;
 }
 #elif defined(CONFIG_MODULE_COMPRESS_ZSTD)
 #include <linux/zstd.h>
 #define MODULE_COMPRESSION	zstd
 #define MODULE_DECOMPRESS_FN	module_zstd_decompress

 static ssize_t module_zstd_decompress(struct load_info *info,
 				    const void *buf, size_t size)
 {
 	static const u8 signature[] = { 0x28, 0xb5, 0x2f, 0xfd };
 	ZSTD_outBuffer zstd_dec;
 	ZSTD_inBuffer zstd_buf;
 	zstd_frame_header header;
 	size_t wksp_size;
 	void *wksp = NULL;
 	ZSTD_DStream *dstream;
 	size_t ret;
 	size_t new_size = 0;
 	int retval;

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

 	zstd_buf.src = buf;
 	zstd_buf.pos = 0;
 	zstd_buf.size = size;

 	ret = zstd_get_frame_header(&header, zstd_buf.src, zstd_buf.size);
 	if (ret != 0) {
 		pr_err("ZSTD-compressed data has an incomplete frame header\n");
 		retval = -EINVAL;
 		goto out;
 	}
 	if (header.windowSize > (1 << ZSTD_WINDOWLOG_MAX)) {
 		pr_err("ZSTD-compressed data has too large a window size\n");
 		retval = -EINVAL;
 		goto out;
 	}

 	wksp_size = zstd_dstream_workspace_bound(header.windowSize);
 	wksp = vmalloc(wksp_size);
 	if (!wksp) {
 		retval = -ENOMEM;
 		goto out;
 	}

 	dstream = zstd_init_dstream(header.windowSize, wksp, wksp_size);
 	if (!dstream) {
 		pr_err("Can't initialize ZSTD stream\n");
 		retval = -ENOMEM;
 		goto out;
 	}

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

 		if (IS_ERR(page)) {
 			retval = PTR_ERR(page);
 			goto out;
 		}

 		zstd_dec.dst = kmap_local_page(page);
 		zstd_dec.pos = 0;
 		zstd_dec.size = PAGE_SIZE;

 		ret = zstd_decompress_stream(dstream, &zstd_dec, &zstd_buf);
 		kunmap_local(zstd_dec.dst);
 		retval = zstd_get_error_code(ret);
 		if (retval)
 			break;

 		new_size += zstd_dec.pos;
 	} while (zstd_dec.pos == PAGE_SIZE && ret != 0);

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

 	retval = new_size;

  out:
 	vfree(wksp);
 	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;

 #if defined(CONFIG_MODULE_STATS)
 	info->compressed_len = size;
 #endif

 	/*
 	 * 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, __stringify(MODULE_COMPRESSION) "\n");
 }

 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
	// 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;
	}

	#if defined(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 (IS_ERR(page)) {
	retval = PTR_ERR(page);
	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 defined(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 (IS_ERR(page)) {
	retval = PTR_ERR(page);
	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;
	}
	#elif defined(CONFIG_MODULE_COMPRESS_ZSTD)
	#include <linux/zstd.h>
	#define MODULE_COMPRESSION zstd
	#define MODULE_DECOMPRESS_FN module_zstd_decompress

	static ssize_t module_zstd_decompress(struct load_info *info,
	const void *buf, size_t size)
	{
	static const u8 signature[] = { 0x28, 0xb5, 0x2f, 0xfd };
	ZSTD_outBuffer zstd_dec;
	ZSTD_inBuffer zstd_buf;
	zstd_frame_header header;
	size_t wksp_size;
	void *wksp = NULL;
	ZSTD_DStream *dstream;
	size_t ret;
	size_t new_size = 0;
	int retval;

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

	zstd_buf.src = buf;
	zstd_buf.pos = 0;
	zstd_buf.size = size;

	ret = zstd_get_frame_header(&header, zstd_buf.src, zstd_buf.size);
	if (ret != 0) {
	pr_err("ZSTD-compressed data has an incomplete frame header\n");
	retval = -EINVAL;
	goto out;
	}
	if (header.windowSize > (1 << ZSTD_WINDOWLOG_MAX)) {
	pr_err("ZSTD-compressed data has too large a window size\n");
	retval = -EINVAL;
	goto out;
	}

	wksp_size = zstd_dstream_workspace_bound(header.windowSize);
	wksp = vmalloc(wksp_size);
	if (!wksp) {
	retval = -ENOMEM;
	goto out;
	}

	dstream = zstd_init_dstream(header.windowSize, wksp, wksp_size);
	if (!dstream) {
	pr_err("Can't initialize ZSTD stream\n");
	retval = -ENOMEM;
	goto out;
	}

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

	if (IS_ERR(page)) {
	retval = PTR_ERR(page);
	goto out;
	}

	zstd_dec.dst = kmap_local_page(page);
	zstd_dec.pos = 0;
	zstd_dec.size = PAGE_SIZE;

	ret = zstd_decompress_stream(dstream, &zstd_dec, &zstd_buf);
	kunmap_local(zstd_dec.dst);
	retval = zstd_get_error_code(ret);
	if (retval)
	break;

	new_size += zstd_dec.pos;
	} while (zstd_dec.pos == PAGE_SIZE && ret != 0);

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

	retval = new_size;

	out:
	vfree(wksp);
	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;

	#if defined(CONFIG_MODULE_STATS)
	info->compressed_len = size;
	#endif

	/*
	* 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, __stringify(MODULE_COMPRESSION) "\n");
	}

	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