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 <sys/kmem.h>
57 #include <sys/kmem_cache.h>
58 #include <sys/zmod.h>
59
60 static spl_kmem_cache_t *zlib_workspace_cache;
61
62 /*
63 * A kmem_cache is used for the zlib workspaces to avoid having to vmalloc
64 * and vfree for every call. Using a kmem_cache also has the advantage
65 * that improves the odds that the memory used will be local to this cpu.
66 * To further improve things it might be wise to create a dedicated per-cpu
67 * workspace for use. This would take some additional care because we then
68 * must disable preemption around the critical section, and verify that
69 * zlib_deflate* and zlib_inflate* never internally call schedule().
70 */
71 static void *
zlib_workspace_alloc(int flags)72 zlib_workspace_alloc(int flags)
73 {
74 return (kmem_cache_alloc(zlib_workspace_cache, flags & ~(__GFP_FS)));
75 }
76
77 static void
zlib_workspace_free(void * workspace)78 zlib_workspace_free(void *workspace)
79 {
80 kmem_cache_free(zlib_workspace_cache, workspace);
81 }
82
83 /*
84 * Compresses the source buffer into the destination buffer. The level
85 * parameter has the same meaning as in deflateInit. sourceLen is the byte
86 * length of the source buffer. Upon entry, destLen is the total size of the
87 * destination buffer, which must be at least 0.1% larger than sourceLen plus
88 * 12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
89 *
90 * compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
91 * memory, Z_BUF_ERROR if there was not enough room in the output buffer,
92 * Z_STREAM_ERROR if the level parameter is invalid.
93 */
94 int
z_compress_level(void * dest,size_t * destLen,const void * source,size_t sourceLen,int level)95 z_compress_level(void *dest, size_t *destLen, const void *source,
96 size_t sourceLen, int level)
97 {
98 z_stream stream;
99 int err;
100
101 stream.next_in = (Byte *)source;
102 stream.avail_in = (uInt)sourceLen;
103 stream.next_out = dest;
104 stream.avail_out = (uInt)*destLen;
105
106 if ((size_t)stream.avail_out != *destLen)
107 return (Z_BUF_ERROR);
108
109 stream.workspace = zlib_workspace_alloc(KM_SLEEP);
110 if (!stream.workspace)
111 return (Z_MEM_ERROR);
112
113 err = zlib_deflateInit(&stream, level);
114 if (err != Z_OK) {
115 zlib_workspace_free(stream.workspace);
116 return (err);
117 }
118
119 err = zlib_deflate(&stream, Z_FINISH);
120 if (err != Z_STREAM_END) {
121 zlib_deflateEnd(&stream);
122 zlib_workspace_free(stream.workspace);
123 return (err == Z_OK ? Z_BUF_ERROR : err);
124 }
125 *destLen = stream.total_out;
126
127 err = zlib_deflateEnd(&stream);
128 zlib_workspace_free(stream.workspace);
129
130 return (err);
131 }
132 EXPORT_SYMBOL(z_compress_level);
133
134 /*
135 * Decompresses the source buffer into the destination buffer. sourceLen is
136 * the byte length of the source buffer. Upon entry, destLen is the total
137 * size of the destination buffer, which must be large enough to hold the
138 * entire uncompressed data. (The size of the uncompressed data must have
139 * been saved previously by the compressor and transmitted to the decompressor
140 * by some mechanism outside the scope of this compression library.)
141 * Upon exit, destLen is the actual size of the compressed buffer.
142 * This function can be used to decompress a whole file at once if the
143 * input file is mmap'ed.
144 *
145 * uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
146 * enough memory, Z_BUF_ERROR if there was not enough room in the output
147 * buffer, or Z_DATA_ERROR if the input data was corrupted.
148 */
149 int
z_uncompress(void * dest,size_t * destLen,const void * source,size_t sourceLen)150 z_uncompress(void *dest, size_t *destLen, const void *source, size_t sourceLen)
151 {
152 z_stream stream;
153 int err;
154
155 stream.next_in = (Byte *)source;
156 stream.avail_in = (uInt)sourceLen;
157 stream.next_out = dest;
158 stream.avail_out = (uInt)*destLen;
159
160 if ((size_t)stream.avail_out != *destLen)
161 return (Z_BUF_ERROR);
162
163 stream.workspace = zlib_workspace_alloc(KM_SLEEP);
164 if (!stream.workspace)
165 return (Z_MEM_ERROR);
166
167 err = zlib_inflateInit(&stream);
168 if (err != Z_OK) {
169 zlib_workspace_free(stream.workspace);
170 return (err);
171 }
172
173 err = zlib_inflate(&stream, Z_FINISH);
174 if (err != Z_STREAM_END) {
175 zlib_inflateEnd(&stream);
176 zlib_workspace_free(stream.workspace);
177
178 if (err == Z_NEED_DICT ||
179 (err == Z_BUF_ERROR && stream.avail_in == 0))
180 return (Z_DATA_ERROR);
181
182 return (err);
183 }
184 *destLen = stream.total_out;
185
186 err = zlib_inflateEnd(&stream);
187 zlib_workspace_free(stream.workspace);
188
189 return (err);
190 }
191 EXPORT_SYMBOL(z_uncompress);
192
193 int
spl_zlib_init(void)194 spl_zlib_init(void)
195 {
196 int size;
197
198 size = MAX(zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL),
199 zlib_inflate_workspacesize());
200
201 zlib_workspace_cache = kmem_cache_create(
202 "spl_zlib_workspace_cache",
203 size, 0, NULL, NULL, NULL, NULL, NULL,
204 KMC_KVMEM | KMC_RECLAIMABLE);
205 if (!zlib_workspace_cache)
206 return (-ENOMEM);
207
208 return (0);
209 }
210
211 void
spl_zlib_fini(void)212 spl_zlib_fini(void)
213 {
214 kmem_cache_destroy(zlib_workspace_cache);
215 zlib_workspace_cache = NULL;
216 }
217