1/*
2 *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
3 *  Copyright (C) 2007 The Regents of the University of California.
4 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
5 *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
6 *  UCRL-CODE-235197
7 *
8 *  This file is part of the SPL, Solaris Porting Layer.
9 *
10 *  The SPL is free software; you can redistribute it and/or modify it
11 *  under the terms of the GNU General Public License as published by the
12 *  Free Software Foundation; either version 2 of the License, or (at your
13 *  option) any later version.
14 *
15 *  The SPL is distributed in the hope that it will be useful, but WITHOUT
16 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18 *  for more details.
19 *
20 *  You should have received a copy of the GNU General Public License along
21 *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
22 *
23 *
24 *  z_compress_level/z_uncompress are nearly identical copies of the
25 *  compress2/uncompress functions provided by the official zlib package
26 *  available at http://zlib.net/.  The only changes made we to slightly
27 *  adapt the functions called to match the linux kernel implementation
28 *  of zlib.  The full zlib license follows:
29 *
30 *  zlib.h -- interface of the 'zlib' general purpose compression library
31 *  version 1.2.5, April 19th, 2010
32 *
33 *  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
34 *
35 *  This software is provided 'as-is', without any express or implied
36 *  warranty.  In no event will the authors be held liable for any damages
37 *  arising from the use of this software.
38 *
39 *  Permission is granted to anyone to use this software for any purpose,
40 *  including commercial applications, and to alter it and redistribute it
41 *  freely, subject to the following restrictions:
42 *
43 *  1. The origin of this software must not be misrepresented; you must not
44 *     claim that you wrote the original software. If you use this software
45 *     in a product, an acknowledgment in the product documentation would be
46 *     appreciated but is not required.
47 *  2. Altered source versions must be plainly marked as such, and must not be
48 *     misrepresented as being the original software.
49 *  3. This notice may not be removed or altered from any source distribution.
50 *
51 *  Jean-loup Gailly
52 *  Mark Adler
53 */
54
55
56#include <linux/percpu_compat.h>
57#include <sys/kmem.h>
58#include <sys/kmem_cache.h>
59#include <sys/zmod.h>
60
61static spl_kmem_cache_t *zlib_workspace_cache;
62
63/*
64 * A kmem_cache is used for the zlib workspaces to avoid having to vmalloc
65 * and vfree for every call.  Using a kmem_cache also has the advantage
66 * that improves the odds that the memory used will be local to this cpu.
67 * To further improve things it might be wise to create a dedicated per-cpu
68 * workspace for use.  This would take some additional care because we then
69 * must disable preemption around the critical section, and verify that
70 * zlib_deflate* and zlib_inflate* never internally call schedule().
71 */
72static void *
73zlib_workspace_alloc(int flags)
74{
75	return (kmem_cache_alloc(zlib_workspace_cache, flags & ~(__GFP_FS)));
76}
77
78static void
79zlib_workspace_free(void *workspace)
80{
81	kmem_cache_free(zlib_workspace_cache, workspace);
82}
83
84/*
85 * Compresses the source buffer into the destination buffer. The level
86 * parameter has the same meaning as in deflateInit.  sourceLen is the byte
87 * length of the source buffer. Upon entry, destLen is the total size of the
88 * destination buffer, which must be at least 0.1% larger than sourceLen plus
89 * 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
90 *
91 * compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
92 * memory, Z_BUF_ERROR if there was not enough room in the output buffer,
93 * Z_STREAM_ERROR if the level parameter is invalid.
94 */
95int
96z_compress_level(void *dest, size_t *destLen, const void *source,
97    size_t sourceLen, int level)
98{
99	z_stream stream;
100	int err;
101
102	stream.next_in = (Byte *)source;
103	stream.avail_in = (uInt)sourceLen;
104	stream.next_out = dest;
105	stream.avail_out = (uInt)*destLen;
106
107	if ((size_t)stream.avail_out != *destLen)
108		return (Z_BUF_ERROR);
109
110	stream.workspace = zlib_workspace_alloc(KM_SLEEP);
111	if (!stream.workspace)
112		return (Z_MEM_ERROR);
113
114	err = zlib_deflateInit(&stream, level);
115	if (err != Z_OK) {
116		zlib_workspace_free(stream.workspace);
117		return (err);
118	}
119
120	err = zlib_deflate(&stream, Z_FINISH);
121	if (err != Z_STREAM_END) {
122		zlib_deflateEnd(&stream);
123		zlib_workspace_free(stream.workspace);
124		return (err == Z_OK ? Z_BUF_ERROR : err);
125	}
126	*destLen = stream.total_out;
127
128	err = zlib_deflateEnd(&stream);
129	zlib_workspace_free(stream.workspace);
130
131	return (err);
132}
133EXPORT_SYMBOL(z_compress_level);
134
135/*
136 * Decompresses the source buffer into the destination buffer.  sourceLen is
137 * the byte length of the source buffer. Upon entry, destLen is the total
138 * size of the destination buffer, which must be large enough to hold the
139 * entire uncompressed data. (The size of the uncompressed data must have
140 * been saved previously by the compressor and transmitted to the decompressor
141 * by some mechanism outside the scope of this compression library.)
142 * Upon exit, destLen is the actual size of the compressed buffer.
143 * This function can be used to decompress a whole file at once if the
144 * input file is mmap'ed.
145 *
146 * uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
147 * enough memory, Z_BUF_ERROR if there was not enough room in the output
148 * buffer, or Z_DATA_ERROR if the input data was corrupted.
149 */
150int
151z_uncompress(void *dest, size_t *destLen, const void *source, size_t sourceLen)
152{
153	z_stream stream;
154	int err;
155
156	stream.next_in = (Byte *)source;
157	stream.avail_in = (uInt)sourceLen;
158	stream.next_out = dest;
159	stream.avail_out = (uInt)*destLen;
160
161	if ((size_t)stream.avail_out != *destLen)
162		return (Z_BUF_ERROR);
163
164	stream.workspace = zlib_workspace_alloc(KM_SLEEP);
165	if (!stream.workspace)
166		return (Z_MEM_ERROR);
167
168	err = zlib_inflateInit(&stream);
169	if (err != Z_OK) {
170		zlib_workspace_free(stream.workspace);
171		return (err);
172	}
173
174	err = zlib_inflate(&stream, Z_FINISH);
175	if (err != Z_STREAM_END) {
176		zlib_inflateEnd(&stream);
177		zlib_workspace_free(stream.workspace);
178
179		if (err == Z_NEED_DICT ||
180		    (err == Z_BUF_ERROR && stream.avail_in == 0))
181			return (Z_DATA_ERROR);
182
183		return (err);
184	}
185	*destLen = stream.total_out;
186
187	err = zlib_inflateEnd(&stream);
188	zlib_workspace_free(stream.workspace);
189
190	return (err);
191}
192EXPORT_SYMBOL(z_uncompress);
193
194int
195spl_zlib_init(void)
196{
197	int size;
198
199	size = MAX(zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL),
200	    zlib_inflate_workspacesize());
201
202	zlib_workspace_cache = kmem_cache_create(
203	    "spl_zlib_workspace_cache",
204	    size, 0, NULL, NULL, NULL, NULL, NULL,
205	    KMC_KVMEM);
206	if (!zlib_workspace_cache)
207		return (-ENOMEM);
208
209	return (0);
210}
211
212void
213spl_zlib_fini(void)
214{
215	kmem_cache_destroy(zlib_workspace_cache);
216	zlib_workspace_cache = NULL;
217}
218