[linux-2.6-block.git] / crypto / zlib.c

/*
 * Cryptographic API.
 *
 * Zlib algorithm
 *
 * Copyright 2008 Sony Corporation
 *
 * Based on deflate.c, which is
 * Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * 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.
 */

#define pr_fmt(fmt)	"%s: " fmt, __func__

#include <linux/init.h>
#include <linux/module.h>
#include <linux/zlib.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/mm.h>
#include <linux/net.h>
#include <linux/slab.h>

#include <crypto/internal/compress.h>

#include <net/netlink.h>


struct zlib_ctx {
	struct z_stream_s comp_stream;
	struct z_stream_s decomp_stream;
	int decomp_windowBits;
};


static void zlib_comp_exit(struct zlib_ctx *ctx)
{
	struct z_stream_s *stream = &ctx->comp_stream;

	if (stream->workspace) {
		zlib_deflateEnd(stream);
		vfree(stream->workspace);
		stream->workspace = NULL;
	}
}

static void zlib_decomp_exit(struct zlib_ctx *ctx)
{
	struct z_stream_s *stream = &ctx->decomp_stream;

	if (stream->workspace) {
		zlib_inflateEnd(stream);
		kfree(stream->workspace);
		stream->workspace = NULL;
	}
}

static int zlib_init(struct crypto_tfm *tfm)
{
	return 0;
}

static void zlib_exit(struct crypto_tfm *tfm)
{
	struct zlib_ctx *ctx = crypto_tfm_ctx(tfm);

	zlib_comp_exit(ctx);
	zlib_decomp_exit(ctx);
}


static int zlib_compress_setup(struct crypto_pcomp *tfm, void *params,
			       unsigned int len)
{
	struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &ctx->comp_stream;
	struct nlattr *tb[ZLIB_COMP_MAX + 1];
	size_t workspacesize;
	int ret;

	ret = nla_parse(tb, ZLIB_COMP_MAX, params, len, NULL);
	if (ret)
		return ret;

	zlib_comp_exit(ctx);

	workspacesize = zlib_deflate_workspacesize();
	stream->workspace = vzalloc(workspacesize);
	if (!stream->workspace)
		return -ENOMEM;

	ret = zlib_deflateInit2(stream,
				tb[ZLIB_COMP_LEVEL]
					? nla_get_u32(tb[ZLIB_COMP_LEVEL])
					: Z_DEFAULT_COMPRESSION,
				tb[ZLIB_COMP_METHOD]
					? nla_get_u32(tb[ZLIB_COMP_METHOD])
					: Z_DEFLATED,
				tb[ZLIB_COMP_WINDOWBITS]
					? nla_get_u32(tb[ZLIB_COMP_WINDOWBITS])
					: MAX_WBITS,
				tb[ZLIB_COMP_MEMLEVEL]
					? nla_get_u32(tb[ZLIB_COMP_MEMLEVEL])
					: DEF_MEM_LEVEL,
				tb[ZLIB_COMP_STRATEGY]
					? nla_get_u32(tb[ZLIB_COMP_STRATEGY])
					: Z_DEFAULT_STRATEGY);
	if (ret != Z_OK) {
		vfree(stream->workspace);
		stream->workspace = NULL;
		return -EINVAL;
	}

	return 0;
}

static int zlib_compress_init(struct crypto_pcomp *tfm)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->comp_stream;

	ret = zlib_deflateReset(stream);
	if (ret != Z_OK)
		return -EINVAL;

	return 0;
}

static int zlib_compress_update(struct crypto_pcomp *tfm,
				struct comp_request *req)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->comp_stream;

	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	stream->next_in = req->next_in;
	stream->avail_in = req->avail_in;
	stream->next_out = req->next_out;
	stream->avail_out = req->avail_out;

	ret = zlib_deflate(stream, Z_NO_FLUSH);
	switch (ret) {
	case Z_OK:
		break;

	case Z_BUF_ERROR:
		pr_debug("zlib_deflate could not make progress\n");
		return -EAGAIN;

	default:
		pr_debug("zlib_deflate failed %d\n", ret);
		return -EINVAL;
	}

	ret = req->avail_out - stream->avail_out;
	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
		 stream->avail_in, stream->avail_out,
		 req->avail_in - stream->avail_in, ret);
	req->next_in = stream->next_in;
	req->avail_in = stream->avail_in;
	req->next_out = stream->next_out;
	req->avail_out = stream->avail_out;
	return ret;
}

static int zlib_compress_final(struct crypto_pcomp *tfm,
			       struct comp_request *req)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->comp_stream;

	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	stream->next_in = req->next_in;
	stream->avail_in = req->avail_in;
	stream->next_out = req->next_out;
	stream->avail_out = req->avail_out;

	ret = zlib_deflate(stream, Z_FINISH);
	if (ret != Z_STREAM_END) {
		pr_debug("zlib_deflate failed %d\n", ret);
		return -EINVAL;
	}

	ret = req->avail_out - stream->avail_out;
	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
		 stream->avail_in, stream->avail_out,
		 req->avail_in - stream->avail_in, ret);
	req->next_in = stream->next_in;
	req->avail_in = stream->avail_in;
	req->next_out = stream->next_out;
	req->avail_out = stream->avail_out;
	return ret;
}


static int zlib_decompress_setup(struct crypto_pcomp *tfm, void *params,
				 unsigned int len)
{
	struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &ctx->decomp_stream;
	struct nlattr *tb[ZLIB_DECOMP_MAX + 1];
	int ret = 0;

	ret = nla_parse(tb, ZLIB_DECOMP_MAX, params, len, NULL);
	if (ret)
		return ret;

	zlib_decomp_exit(ctx);

	ctx->decomp_windowBits = tb[ZLIB_DECOMP_WINDOWBITS]
				 ? nla_get_u32(tb[ZLIB_DECOMP_WINDOWBITS])
				 : DEF_WBITS;

	stream->workspace = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
	if (!stream->workspace)
		return -ENOMEM;

	ret = zlib_inflateInit2(stream, ctx->decomp_windowBits);
	if (ret != Z_OK) {
		kfree(stream->workspace);
		stream->workspace = NULL;
		return -EINVAL;
	}

	return 0;
}

static int zlib_decompress_init(struct crypto_pcomp *tfm)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->decomp_stream;

	ret = zlib_inflateReset(stream);
	if (ret != Z_OK)
		return -EINVAL;

	return 0;
}

static int zlib_decompress_update(struct crypto_pcomp *tfm,
				  struct comp_request *req)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->decomp_stream;

	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	stream->next_in = req->next_in;
	stream->avail_in = req->avail_in;
	stream->next_out = req->next_out;
	stream->avail_out = req->avail_out;

	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	switch (ret) {
	case Z_OK:
	case Z_STREAM_END:
		break;

	case Z_BUF_ERROR:
		pr_debug("zlib_inflate could not make progress\n");
		return -EAGAIN;

	default:
		pr_debug("zlib_inflate failed %d\n", ret);
		return -EINVAL;
	}

	ret = req->avail_out - stream->avail_out;
	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
		 stream->avail_in, stream->avail_out,
		 req->avail_in - stream->avail_in, ret);
	req->next_in = stream->next_in;
	req->avail_in = stream->avail_in;
	req->next_out = stream->next_out;
	req->avail_out = stream->avail_out;
	return ret;
}

static int zlib_decompress_final(struct crypto_pcomp *tfm,
				 struct comp_request *req)
{
	int ret;
	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	struct z_stream_s *stream = &dctx->decomp_stream;

	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	stream->next_in = req->next_in;
	stream->avail_in = req->avail_in;
	stream->next_out = req->next_out;
	stream->avail_out = req->avail_out;

	if (dctx->decomp_windowBits < 0) {
		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) {
			const void *saved_next_in = stream->next_in;
			u8 zerostuff = 0;

			stream->next_in = &zerostuff;
			stream->avail_in = 1;
			ret = zlib_inflate(stream, Z_FINISH);
			stream->next_in = saved_next_in;
			stream->avail_in = 0;
		}
	} else
		ret = zlib_inflate(stream, Z_FINISH);
	if (ret != Z_STREAM_END) {
		pr_debug("zlib_inflate failed %d\n", ret);
		return -EINVAL;
	}

	ret = req->avail_out - stream->avail_out;
	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
		 stream->avail_in, stream->avail_out,
		 req->avail_in - stream->avail_in, ret);
	req->next_in = stream->next_in;
	req->avail_in = stream->avail_in;
	req->next_out = stream->next_out;
	req->avail_out = stream->avail_out;
	return ret;
}


static struct pcomp_alg zlib_alg = {
	.compress_setup		= zlib_compress_setup,
	.compress_init		= zlib_compress_init,
	.compress_update	= zlib_compress_update,
	.compress_final		= zlib_compress_final,
	.decompress_setup	= zlib_decompress_setup,
	.decompress_init	= zlib_decompress_init,
	.decompress_update	= zlib_decompress_update,
	.decompress_final	= zlib_decompress_final,

	.base			= {
		.cra_name	= "zlib",
		.cra_flags	= CRYPTO_ALG_TYPE_PCOMPRESS,
		.cra_ctxsize	= sizeof(struct zlib_ctx),
		.cra_module	= THIS_MODULE,
		.cra_init	= zlib_init,
		.cra_exit	= zlib_exit,
	}
};

static int __init zlib_mod_init(void)
{
	return crypto_register_pcomp(&zlib_alg);
}

static void __exit zlib_mod_fini(void)
{
	crypto_unregister_pcomp(&zlib_alg);
}

module_init(zlib_mod_init);
module_exit(zlib_mod_fini);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Zlib Compression Algorithm");
MODULE_AUTHOR("Sony Corporation");
Commit	Line	Data
bf68e65e GU	1	/*
	2	* Cryptographic API.
	3	*
	4	* Zlib algorithm
	5	*
	6	* Copyright 2008 Sony Corporation
	7	*
	8	* Based on deflate.c, which is
	9	* Copyright (c) 2003 James Morris <jmorris@intercode.com.au>
	10	*
	11	* This program is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License as published by the Free
	13	* Software Foundation; either version 2 of the License, or (at your option)
	14	* any later version.
	15	*
	16	* FIXME: deflate transforms will require up to a total of about 436k of kernel
	17	* memory on i386 (390k for compression, the rest for decompression), as the
	18	* current zlib kernel code uses a worst case pre-allocation system by default.
	19	* This needs to be fixed so that the amount of memory required is properly
	20	* related to the winbits and memlevel parameters.
	21	*/
	22
	23	#define pr_fmt(fmt) "%s: " fmt, __func__
	24
	25	#include <linux/init.h>
	26	#include <linux/module.h>
	27	#include <linux/zlib.h>
	28	#include <linux/vmalloc.h>
	29	#include <linux/interrupt.h>
	30	#include <linux/mm.h>
	31	#include <linux/net.h>
	32	#include <linux/slab.h>
	33
	34	#include <crypto/internal/compress.h>
	35
	36	#include <net/netlink.h>
	37
	38
	39	struct zlib_ctx {
	40	struct z_stream_s comp_stream;
	41	struct z_stream_s decomp_stream;
	42	int decomp_windowBits;
	43	};
	44
	45
	46	static void zlib_comp_exit(struct zlib_ctx *ctx)
	47	{
	48	struct z_stream_s *stream = &ctx->comp_stream;
	49
	50	if (stream->workspace) {
	51	zlib_deflateEnd(stream);
	52	vfree(stream->workspace);
	53	stream->workspace = NULL;
	54	}
	55	}
	56
	57	static void zlib_decomp_exit(struct zlib_ctx *ctx)
	58	{
	59	struct z_stream_s *stream = &ctx->decomp_stream;
	60
	61	if (stream->workspace) {
	62	zlib_inflateEnd(stream);
	63	kfree(stream->workspace);
	64	stream->workspace = NULL;
65	}
66	}
67
68	static int zlib_init(struct crypto_tfm *tfm)
69	{
70	return 0;
71	}
72
73	static void zlib_exit(struct crypto_tfm *tfm)
74	{
75	struct zlib_ctx *ctx = crypto_tfm_ctx(tfm);
76
77	zlib_comp_exit(ctx);
78	zlib_decomp_exit(ctx);
79	}
80
81
82	static int zlib_compress_setup(struct crypto_pcomp tfm, void params,
83	unsigned int len)
84	{
85	struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
86	struct z_stream_s *stream = &ctx->comp_stream;
87	struct nlattr *tb[ZLIB_COMP_MAX + 1];
88	size_t workspacesize;
89	int ret;
90
91	ret = nla_parse(tb, ZLIB_COMP_MAX, params, len, NULL);
92	if (ret)
93	return ret;
94
95	zlib_comp_exit(ctx);
96
97	workspacesize = zlib_deflate_workspacesize();
c8484594	98	stream->workspace = vzalloc(workspacesize);
bf68e65e GU	99	if (!stream->workspace)
	100	return -ENOMEM;
	101
bf68e65e GU	102	ret = zlib_deflateInit2(stream,
	103	tb[ZLIB_COMP_LEVEL]
	104	? nla_get_u32(tb[ZLIB_COMP_LEVEL])
	105	: Z_DEFAULT_COMPRESSION,
	106	tb[ZLIB_COMP_METHOD]
	107	? nla_get_u32(tb[ZLIB_COMP_METHOD])
	108	: Z_DEFLATED,
	109	tb[ZLIB_COMP_WINDOWBITS]
	110	? nla_get_u32(tb[ZLIB_COMP_WINDOWBITS])
	111	: MAX_WBITS,
	112	tb[ZLIB_COMP_MEMLEVEL]
	113	? nla_get_u32(tb[ZLIB_COMP_MEMLEVEL])
	114	: DEF_MEM_LEVEL,
	115	tb[ZLIB_COMP_STRATEGY]
	116	? nla_get_u32(tb[ZLIB_COMP_STRATEGY])
	117	: Z_DEFAULT_STRATEGY);
	118	if (ret != Z_OK) {
	119	vfree(stream->workspace);
	120	stream->workspace = NULL;
	121	return -EINVAL;
	122	}
	123
	124	return 0;
	125	}
	126
	127	static int zlib_compress_init(struct crypto_pcomp *tfm)
	128	{
	129	int ret;
	130	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	131	struct z_stream_s *stream = &dctx->comp_stream;
	132
	133	ret = zlib_deflateReset(stream);
	134	if (ret != Z_OK)
	135	return -EINVAL;
	136
	137	return 0;
	138	}
	139
	140	static int zlib_compress_update(struct crypto_pcomp *tfm,
	141	struct comp_request *req)
	142	{
	143	int ret;
	144	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	145	struct z_stream_s *stream = &dctx->comp_stream;
	146
	147	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	148	stream->next_in = req->next_in;
	149	stream->avail_in = req->avail_in;
	150	stream->next_out = req->next_out;
	151	stream->avail_out = req->avail_out;
	152
	153	ret = zlib_deflate(stream, Z_NO_FLUSH);
	154	switch (ret) {
	155	case Z_OK:
	156	break;
	157
	158	case Z_BUF_ERROR:
	159	pr_debug("zlib_deflate could not make progress\n");
	160	return -EAGAIN;
	161
	162	default:
	163	pr_debug("zlib_deflate failed %d\n", ret);
	164	return -EINVAL;
	165	}
166
3ce858cb	167	ret = req->avail_out - stream->avail_out;
bf68e65e GU	168	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
bf68e65e GU	169	stream->avail_in, stream->avail_out,
3ce858cb	170	req->avail_in - stream->avail_in, ret);
bf68e65e GU	171	req->next_in = stream->next_in;
	172	req->avail_in = stream->avail_in;
	173	req->next_out = stream->next_out;
	174	req->avail_out = stream->avail_out;
3ce858cb	175	return ret;
bf68e65e GU	176	}
	177
	178	static int zlib_compress_final(struct crypto_pcomp *tfm,
	179	struct comp_request *req)
	180	{
	181	int ret;
	182	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	183	struct z_stream_s *stream = &dctx->comp_stream;
	184
	185	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	186	stream->next_in = req->next_in;
	187	stream->avail_in = req->avail_in;
	188	stream->next_out = req->next_out;
	189	stream->avail_out = req->avail_out;
	190
	191	ret = zlib_deflate(stream, Z_FINISH);
	192	if (ret != Z_STREAM_END) {
	193	pr_debug("zlib_deflate failed %d\n", ret);
	194	return -EINVAL;
	195	}
	196
3ce858cb	197	ret = req->avail_out - stream->avail_out;
bf68e65e GU	198	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
bf68e65e GU	199	stream->avail_in, stream->avail_out,
3ce858cb	200	req->avail_in - stream->avail_in, ret);
bf68e65e GU	201	req->next_in = stream->next_in;
	202	req->avail_in = stream->avail_in;
	203	req->next_out = stream->next_out;
	204	req->avail_out = stream->avail_out;
3ce858cb	205	return ret;
bf68e65e GU	206	}
	207
	208
	209	static int zlib_decompress_setup(struct crypto_pcomp tfm, void params,
	210	unsigned int len)
	211	{
	212	struct zlib_ctx *ctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	213	struct z_stream_s *stream = &ctx->decomp_stream;
	214	struct nlattr *tb[ZLIB_DECOMP_MAX + 1];
	215	int ret = 0;
	216
	217	ret = nla_parse(tb, ZLIB_DECOMP_MAX, params, len, NULL);
	218	if (ret)
	219	return ret;
	220
	221	zlib_decomp_exit(ctx);
	222
	223	ctx->decomp_windowBits = tb[ZLIB_DECOMP_WINDOWBITS]
	224	? nla_get_u32(tb[ZLIB_DECOMP_WINDOWBITS])
	225	: DEF_WBITS;
	226
	227	stream->workspace = kzalloc(zlib_inflate_workspacesize(), GFP_KERNEL);
	228	if (!stream->workspace)
	229	return -ENOMEM;
	230
	231	ret = zlib_inflateInit2(stream, ctx->decomp_windowBits);
	232	if (ret != Z_OK) {
	233	kfree(stream->workspace);
	234	stream->workspace = NULL;
	235	return -EINVAL;
	236	}
	237
	238	return 0;
	239	}
	240
	241	static int zlib_decompress_init(struct crypto_pcomp *tfm)
	242	{
	243	int ret;
	244	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	245	struct z_stream_s *stream = &dctx->decomp_stream;
	246
	247	ret = zlib_inflateReset(stream);
	248	if (ret != Z_OK)
	249	return -EINVAL;
	250
	251	return 0;
	252	}
	253
	254	static int zlib_decompress_update(struct crypto_pcomp *tfm,
	255	struct comp_request *req)
	256	{
	257	int ret;
	258	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	259	struct z_stream_s *stream = &dctx->decomp_stream;
	260
	261	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	262	stream->next_in = req->next_in;
	263	stream->avail_in = req->avail_in;
	264	stream->next_out = req->next_out;
	265	stream->avail_out = req->avail_out;
	266
	267	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	268	switch (ret) {
	269	case Z_OK:
270	case Z_STREAM_END:
271	break;
272
273	case Z_BUF_ERROR:
274	pr_debug("zlib_inflate could not make progress\n");
275	return -EAGAIN;
276
277	default:
278	pr_debug("zlib_inflate failed %d\n", ret);
279	return -EINVAL;
280	}
281
3ce858cb	282	ret = req->avail_out - stream->avail_out;
bf68e65e GU	283	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
bf68e65e GU	284	stream->avail_in, stream->avail_out,
3ce858cb	285	req->avail_in - stream->avail_in, ret);
bf68e65e GU	286	req->next_in = stream->next_in;
	287	req->avail_in = stream->avail_in;
	288	req->next_out = stream->next_out;
	289	req->avail_out = stream->avail_out;
3ce858cb	290	return ret;
bf68e65e GU	291	}
	292
	293	static int zlib_decompress_final(struct crypto_pcomp *tfm,
	294	struct comp_request *req)
	295	{
	296	int ret;
	297	struct zlib_ctx *dctx = crypto_tfm_ctx(crypto_pcomp_tfm(tfm));
	298	struct z_stream_s *stream = &dctx->decomp_stream;
	299
	300	pr_debug("avail_in %u, avail_out %u\n", req->avail_in, req->avail_out);
	301	stream->next_in = req->next_in;
	302	stream->avail_in = req->avail_in;
	303	stream->next_out = req->next_out;
	304	stream->avail_out = req->avail_out;
	305
	306	if (dctx->decomp_windowBits < 0) {
	307	ret = zlib_inflate(stream, Z_SYNC_FLUSH);
	308	/*
	309	* Work around a bug in zlib, which sometimes wants to taste an
	310	* extra byte when being used in the (undocumented) raw deflate
	311	* mode. (From USAGI).
	312	*/
	313	if (ret == Z_OK && !stream->avail_in && stream->avail_out) {
	314	const void *saved_next_in = stream->next_in;
	315	u8 zerostuff = 0;
	316
	317	stream->next_in = &zerostuff;
	318	stream->avail_in = 1;
	319	ret = zlib_inflate(stream, Z_FINISH);
	320	stream->next_in = saved_next_in;
	321	stream->avail_in = 0;
	322	}
	323	} else
	324	ret = zlib_inflate(stream, Z_FINISH);
	325	if (ret != Z_STREAM_END) {
	326	pr_debug("zlib_inflate failed %d\n", ret);
	327	return -EINVAL;
	328	}
	329
3ce858cb	330	ret = req->avail_out - stream->avail_out;
bf68e65e GU	331	pr_debug("avail_in %u, avail_out %u (consumed %u, produced %u)\n",
bf68e65e GU	332	stream->avail_in, stream->avail_out,
3ce858cb	333	req->avail_in - stream->avail_in, ret);
bf68e65e GU	334	req->next_in = stream->next_in;
	335	req->avail_in = stream->avail_in;
	336	req->next_out = stream->next_out;
	337	req->avail_out = stream->avail_out;
3ce858cb	338	return ret;
bf68e65e GU	339	}
	340
	341
	342	static struct pcomp_alg zlib_alg = {
	343	.compress_setup = zlib_compress_setup,
	344	.compress_init = zlib_compress_init,
	345	.compress_update = zlib_compress_update,
	346	.compress_final = zlib_compress_final,
	347	.decompress_setup = zlib_decompress_setup,
	348	.decompress_init = zlib_decompress_init,
	349	.decompress_update = zlib_decompress_update,
	350	.decompress_final = zlib_decompress_final,
	351
	352	.base = {
	353	.cra_name = "zlib",
	354	.cra_flags = CRYPTO_ALG_TYPE_PCOMPRESS,
	355	.cra_ctxsize = sizeof(struct zlib_ctx),
	356	.cra_module = THIS_MODULE,
	357	.cra_init = zlib_init,
	358	.cra_exit = zlib_exit,
	359	}
	360	};
	361
	362	static int __init zlib_mod_init(void)
	363	{
	364	return crypto_register_pcomp(&zlib_alg);
	365	}
	366
	367	static void __exit zlib_mod_fini(void)
	368	{
	369	crypto_unregister_pcomp(&zlib_alg);
	370	}
	371
	372	module_init(zlib_mod_init);
	373	module_exit(zlib_mod_fini);
	374
	375	MODULE_LICENSE("GPL");
	376	MODULE_DESCRIPTION("Zlib Compression Algorithm");
	377	MODULE_AUTHOR("Sony Corporation");