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 * 72 zlib_workspace_alloc(int flags) 73 { 74 return (kmem_cache_alloc(zlib_workspace_cache, flags & ~(__GFP_FS))); 75 } 76 77 static void 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 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 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 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 212 spl_zlib_fini(void) 213 { 214 kmem_cache_destroy(zlib_workspace_cache); 215 zlib_workspace_cache = NULL; 216 } 217