Commit 08cabc7d authored by Herbert Xu's avatar Herbert Xu
Browse files

crypto: deflate - Convert to acomp 

This based on work by Ard Biesheuvel <ardb@kernel.org>.

Convert deflate from scomp to acomp.  This removes the need for
the caller to linearise the source and destination.

Link: https://lore.kernel.org/all/20230718125847.3869700-21-ardb@kernel.org/


Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 9c8cf582

crypto/deflate.c

+187 −176
Original line number Diff line number Diff line
@@ -6,246 +6,255 @@ 
 * by IPCOMP (RFC 3173 & RFC 2394).

 *

 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>

 *

 * FIXME: deflate transforms will require up to a total of about 436k of kernel

 * memory on i386 (390k for compression, the rest for decompression), as the

 * current zlib kernel code uses a worst case pre-allocation system by default.

 * This needs to be fixed so that the amount of memory required is properly

 * related to the  winbits and memlevel parameters.

 *

 * The default winbits of 11 should suit most packets, and it may be something

 * to configure on a per-tfm basis in the future.

 *

 * Currently, compression history is not maintained between tfm calls, as

 * it is not needed for IPCOMP and keeps the code simpler.  It can be

 * implemented if someone wants it.

 * Copyright (c) 2023 Google, LLC. <ardb@kernel.org>

 * Copyright (c) 2025 Herbert Xu <herbert@gondor.apana.org.au>

 */

#include <crypto/internal/acompress.h>

#include <crypto/scatterwalk.h>

#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/crypto.h>

#include <linux/mutex.h>

#include <linux/percpu.h>

#include <linux/scatterlist.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/zlib.h>

#include <linux/vmalloc.h>

#include <linux/interrupt.h>

#include <linux/mm.h>

#include <linux/net.h>

#include <crypto/internal/scompress.h>



#define DEFLATE_DEF_LEVEL		Z_DEFAULT_COMPRESSION

#define DEFLATE_DEF_WINBITS		11

#define DEFLATE_DEF_MEMLEVEL		MAX_MEM_LEVEL



struct deflate_ctx {

	struct z_stream_s comp_stream;

	struct z_stream_s decomp_stream;

struct deflate_stream {

	struct z_stream_s stream;

	u8 workspace[];

};



static int deflate_comp_init(struct deflate_ctx *ctx)

static DEFINE_MUTEX(deflate_stream_lock);



static void *deflate_alloc_stream(void)

{

	int ret = 0;

	struct z_stream_s *stream = &ctx->comp_stream;

	size_t size = max(zlib_inflate_workspacesize(),

			  zlib_deflate_workspacesize(-DEFLATE_DEF_WINBITS,

						     DEFLATE_DEF_MEMLEVEL));

	struct deflate_stream *ctx;



	stream->workspace = vzalloc(zlib_deflate_workspacesize(

				    -DEFLATE_DEF_WINBITS, MAX_MEM_LEVEL));

	if (!stream->workspace) {

		ret = -ENOMEM;

		goto out;

	}

	ret = zlib_deflateInit2(stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,

				-DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,

				Z_DEFAULT_STRATEGY);

	if (ret != Z_OK) {

		ret = -EINVAL;

		goto out_free;

	ctx = kvmalloc(sizeof(*ctx) + size, GFP_KERNEL);

	if (!ctx)

		return ERR_PTR(-ENOMEM);



	ctx->stream.workspace = ctx->workspace;



	return ctx;

}

out:



static struct crypto_acomp_streams deflate_streams = {

	.alloc_ctx = deflate_alloc_stream,

	.cfree_ctx = kvfree,

};



static int deflate_compress_one(struct acomp_req *req,

				struct deflate_stream *ds)

{

	struct z_stream_s *stream = &ds->stream;

	struct acomp_walk walk;

	int ret;



	ret = acomp_walk_virt(&walk, req);

	if (ret)

		return ret;

out_free:

	vfree(stream->workspace);

	goto out;



	do {

		unsigned int dcur;



		dcur = acomp_walk_next_dst(&walk);

		if (!dcur)

			return -ENOSPC;



		stream->avail_out = dcur;

		stream->next_out = walk.dst.virt.addr;



		do {

			int flush = Z_FINISH;

			unsigned int scur;



			stream->avail_in = 0;

			stream->next_in = NULL;



			scur = acomp_walk_next_src(&walk);

			if (scur) {

				if (acomp_walk_more_src(&walk, scur))

					flush = Z_NO_FLUSH;

				stream->avail_in = scur;

				stream->next_in = walk.src.virt.addr;

			}



static int deflate_decomp_init(struct deflate_ctx *ctx)

{

	int ret = 0;

	struct z_stream_s *stream = &ctx->decomp_stream;

			ret = zlib_deflate(stream, flush);



	stream->workspace = vzalloc(zlib_inflate_workspacesize());

	if (!stream->workspace) {

		ret = -ENOMEM;

		goto out;

			if (scur) {

				scur -= stream->avail_in;

				acomp_walk_done_src(&walk, scur);

			}

	ret = zlib_inflateInit2(stream, -DEFLATE_DEF_WINBITS);

	if (ret != Z_OK) {

		ret = -EINVAL;

		goto out_free;

		} while (ret == Z_OK && stream->avail_out);



		acomp_walk_done_dst(&walk, dcur);

	} while (ret == Z_OK);



	if (ret != Z_STREAM_END)

		return -EINVAL;



	req->dlen = stream->total_out;

	return 0;

}

out:

	return ret;

out_free:

	vfree(stream->workspace);



static int deflate_compress(struct acomp_req *req)

{

	struct crypto_acomp_stream *s;

	struct deflate_stream *ds;

	struct acomp_req *r2;

	int err;



	s = crypto_acomp_lock_stream_bh(&deflate_streams);

	ds = s->ctx;



	err = zlib_deflateInit2(&ds->stream, DEFLATE_DEF_LEVEL, Z_DEFLATED,

				-DEFLATE_DEF_WINBITS, DEFLATE_DEF_MEMLEVEL,

				Z_DEFAULT_STRATEGY);

	if (err != Z_OK) {

		err = -EINVAL;

		goto out;

	}



static void deflate_comp_exit(struct deflate_ctx *ctx)

{

	zlib_deflateEnd(&ctx->comp_stream);

	vfree(ctx->comp_stream.workspace);

	err = deflate_compress_one(req, ds);

	req->base.err = err;



	list_for_each_entry(r2, &req->base.list, base.list) {

		zlib_deflateReset(&ds->stream);

		r2->base.err = deflate_compress_one(r2, ds);

	}



static void deflate_decomp_exit(struct deflate_ctx *ctx)

{

	zlib_inflateEnd(&ctx->decomp_stream);

	vfree(ctx->decomp_stream.workspace);

out:

	crypto_acomp_unlock_stream_bh(s);



	return err;

}



static int __deflate_init(void *ctx)

static int deflate_decompress_one(struct acomp_req *req,

				  struct deflate_stream *ds)

{

	struct z_stream_s *stream = &ds->stream;

	bool out_of_space = false;

	struct acomp_walk walk;

	int ret;



	ret = deflate_comp_init(ctx);

	ret = acomp_walk_virt(&walk, req);

	if (ret)

		goto out;

	ret = deflate_decomp_init(ctx);

	if (ret)

		deflate_comp_exit(ctx);

out:

		return ret;

}



static void *deflate_alloc_ctx(void)

{

	struct deflate_ctx *ctx;

	int ret;

	do {

		unsigned int scur;



	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);

	if (!ctx)

		return ERR_PTR(-ENOMEM);

		stream->avail_in = 0;

		stream->next_in = NULL;



	ret = __deflate_init(ctx);

	if (ret) {

		kfree(ctx);

		return ERR_PTR(ret);

		scur = acomp_walk_next_src(&walk);

		if (scur) {

			stream->avail_in = scur;

			stream->next_in = walk.src.virt.addr;

		}



	return ctx;

}

		do {

			unsigned int dcur;



static void __deflate_exit(void *ctx)

{

	deflate_comp_exit(ctx);

	deflate_decomp_exit(ctx);

			dcur = acomp_walk_next_dst(&walk);

			if (!dcur) {

				out_of_space = true;

				break;

			}



static void deflate_free_ctx(void *ctx)

{

	__deflate_exit(ctx);

	kfree_sensitive(ctx);

}

			stream->avail_out = dcur;

			stream->next_out = walk.dst.virt.addr;



static int __deflate_compress(const u8 *src, unsigned int slen,

			      u8 *dst, unsigned int *dlen, void *ctx)

{

	int ret = 0;

	struct deflate_ctx *dctx = ctx;

	struct z_stream_s *stream = &dctx->comp_stream;

			ret = zlib_inflate(stream, Z_NO_FLUSH);



	ret = zlib_deflateReset(stream);

	if (ret != Z_OK) {

		ret = -EINVAL;

		goto out;

	}

			dcur -= stream->avail_out;

			acomp_walk_done_dst(&walk, dcur);

		} while (ret == Z_OK && stream->avail_in);



	stream->next_in = (u8 *)src;

	stream->avail_in = slen;

	stream->next_out = (u8 *)dst;

	stream->avail_out = *dlen;

		if (scur)

			acomp_walk_done_src(&walk, scur);



	ret = zlib_deflate(stream, Z_FINISH);

	if (ret != Z_STREAM_END) {

		ret = -EINVAL;

		goto out;

	}

	ret = 0;

	*dlen = stream->total_out;

out:

	return ret;

}

		if (out_of_space)

			return -ENOSPC;

	} while (ret == Z_OK);



static int deflate_scompress(struct crypto_scomp *tfm, const u8 *src,

			     unsigned int slen, u8 *dst, unsigned int *dlen,

			     void *ctx)

{

	return __deflate_compress(src, slen, dst, dlen, ctx);

	if (ret != Z_STREAM_END)

		return -EINVAL;



	req->dlen = stream->total_out;

	return 0;

}



static int __deflate_decompress(const u8 *src, unsigned int slen,

				u8 *dst, unsigned int *dlen, void *ctx)

static int deflate_decompress(struct acomp_req *req)

{

	struct crypto_acomp_stream *s;

	struct deflate_stream *ds;

	struct acomp_req *r2;

	int err;



	int ret = 0;

	struct deflate_ctx *dctx = ctx;

	struct z_stream_s *stream = &dctx->decomp_stream;

	s = crypto_acomp_lock_stream_bh(&deflate_streams);

	ds = s->ctx;



	ret = zlib_inflateReset(stream);

	if (ret != Z_OK) {

		ret = -EINVAL;

	err = zlib_inflateInit2(&ds->stream, -DEFLATE_DEF_WINBITS);

	if (err != Z_OK) {

		err = -EINVAL;

		goto out;

	}



	stream->next_in = (u8 *)src;

	stream->avail_in = slen;

	stream->next_out = (u8 *)dst;

	stream->avail_out = *dlen;

	err = deflate_decompress_one(req, ds);

	req->base.err = err;



	ret = zlib_inflate(stream, Z_SYNC_FLUSH);

	/*

	 * Work around a bug in zlib, which sometimes wants to taste an extra

	 * byte when being used in the (undocumented) raw deflate mode.

	 * (From USAGI).

	 */

	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {

		u8 zerostuff = 0;

		stream->next_in = &zerostuff;

		stream->avail_in = 1;

		ret = zlib_inflate(stream, Z_FINISH);

	list_for_each_entry(r2, &req->base.list, base.list) {

		zlib_inflateReset(&ds->stream);

		r2->base.err = deflate_decompress_one(r2, ds);

	}

	if (ret != Z_STREAM_END) {

		ret = -EINVAL;

		goto out;

	}

	ret = 0;

	*dlen = stream->total_out;



out:

	return ret;

	crypto_acomp_unlock_stream_bh(s);



	return err;

}



static int deflate_sdecompress(struct crypto_scomp *tfm, const u8 *src,

			       unsigned int slen, u8 *dst, unsigned int *dlen,

			       void *ctx)

static int deflate_init(struct crypto_acomp *tfm)

{

	return __deflate_decompress(src, slen, dst, dlen, ctx);

}

	int ret;



	mutex_lock(&deflate_stream_lock);

	ret = crypto_acomp_alloc_streams(&deflate_streams);

	mutex_unlock(&deflate_stream_lock);



static struct scomp_alg scomp = {

	.alloc_ctx		= deflate_alloc_ctx,

	.free_ctx		= deflate_free_ctx,

	.compress		= deflate_scompress,

	.decompress		= deflate_sdecompress,

	.base			= {

		.cra_name	= "deflate",

		.cra_driver_name = "deflate-scomp",

		.cra_module	 = THIS_MODULE,

	return ret;

}



static struct acomp_alg acomp = {

	.compress		= deflate_compress,

	.decompress		= deflate_decompress,

	.init			= deflate_init,

	.base.cra_name		= "deflate",

	.base.cra_driver_name	= "deflate-generic",

	.base.cra_flags		= CRYPTO_ALG_REQ_CHAIN,

	.base.cra_module	= THIS_MODULE,

};



static int __init deflate_mod_init(void)

{

	return crypto_register_scomp(&scomp);

	return crypto_register_acomp(&acomp);

}



static void __exit deflate_mod_fini(void)

{

	crypto_unregister_scomp(&scomp);

	crypto_unregister_acomp(&acomp);

	crypto_acomp_free_streams(&deflate_streams);

}



subsys_initcall(deflate_mod_init);
@@ -254,5 +263,7 @@ module_exit(deflate_mod_fini); 
MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("Deflate Compression Algorithm for IPCOMP");

MODULE_AUTHOR("James Morris <jmorris@intercode.com.au>");

MODULE_AUTHOR("Ard Biesheuvel <ardb@kernel.org>");

MODULE_AUTHOR("Herbert Xu <herbert@gondor.apana.org.au>");

MODULE_ALIAS_CRYPTO("deflate");

MODULE_ALIAS_CRYPTO("deflate-generic");