| /* |
| * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC. |
| * Copyright (C) 2007 The Regents of the University of California. |
| * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER). |
| * Written by Brian Behlendorf <behlendorf1@llnl.gov>. |
| * UCRL-CODE-235197 |
| * |
| * This file is part of the SPL, Solaris Porting Layer. |
| * |
| * The SPL 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. |
| * |
| * The SPL is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * for more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with the SPL. If not, see <http://www.gnu.org/licenses/>. |
| * |
| * |
| * z_compress_level/z_uncompress are nearly identical copies of the |
| * compress2/uncompress functions provided by the official zlib package |
| * available at http://zlib.net/. The only changes made we to slightly |
| * adapt the functions called to match the linux kernel implementation |
| * of zlib. The full zlib license follows: |
| * |
| * zlib.h -- interface of the 'zlib' general purpose compression library |
| * version 1.2.5, April 19th, 2010 |
| * |
| * Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler |
| * |
| * This software is provided 'as-is', without any express or implied |
| * warranty. In no event will the authors be held liable for any damages |
| * arising from the use of this software. |
| * |
| * Permission is granted to anyone to use this software for any purpose, |
| * including commercial applications, and to alter it and redistribute it |
| * freely, subject to the following restrictions: |
| * |
| * 1. The origin of this software must not be misrepresented; you must not |
| * claim that you wrote the original software. If you use this software |
| * in a product, an acknowledgment in the product documentation would be |
| * appreciated but is not required. |
| * 2. Altered source versions must be plainly marked as such, and must not be |
| * misrepresented as being the original software. |
| * 3. This notice may not be removed or altered from any source distribution. |
| * |
| * Jean-loup Gailly |
| * Mark Adler |
| */ |
| |
| |
| #include <linux/percpu_compat.h> |
| #include <sys/kmem.h> |
| #include <sys/kmem_cache.h> |
| #include <sys/zmod.h> |
| |
| static spl_kmem_cache_t *zlib_workspace_cache; |
| |
| /* |
| * A kmem_cache is used for the zlib workspaces to avoid having to vmalloc |
| * and vfree for every call. Using a kmem_cache also has the advantage |
| * that improves the odds that the memory used will be local to this cpu. |
| * To further improve things it might be wise to create a dedicated per-cpu |
| * workspace for use. This would take some additional care because we then |
| * must disable preemption around the critical section, and verify that |
| * zlib_deflate* and zlib_inflate* never internally call schedule(). |
| */ |
| static void * |
| zlib_workspace_alloc(int flags) |
| { |
| return (kmem_cache_alloc(zlib_workspace_cache, flags & ~(__GFP_FS))); |
| } |
| |
| static void |
| zlib_workspace_free(void *workspace) |
| { |
| kmem_cache_free(zlib_workspace_cache, workspace); |
| } |
| |
| /* |
| * Compresses the source buffer into the destination buffer. The level |
| * parameter has the same meaning as in deflateInit. sourceLen is the byte |
| * length of the source buffer. Upon entry, destLen is the total size of the |
| * destination buffer, which must be at least 0.1% larger than sourceLen plus |
| * 12 bytes. Upon exit, destLen is the actual size of the compressed buffer. |
| * |
| * compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough |
| * memory, Z_BUF_ERROR if there was not enough room in the output buffer, |
| * Z_STREAM_ERROR if the level parameter is invalid. |
| */ |
| int |
| z_compress_level(void *dest, size_t *destLen, const void *source, |
| size_t sourceLen, int level) |
| { |
| z_stream stream; |
| int err; |
| |
| stream.next_in = (Byte *)source; |
| stream.avail_in = (uInt)sourceLen; |
| stream.next_out = dest; |
| stream.avail_out = (uInt)*destLen; |
| |
| if ((size_t)stream.avail_out != *destLen) |
| return (Z_BUF_ERROR); |
| |
| stream.workspace = zlib_workspace_alloc(KM_SLEEP); |
| if (!stream.workspace) |
| return (Z_MEM_ERROR); |
| |
| err = zlib_deflateInit(&stream, level); |
| if (err != Z_OK) { |
| zlib_workspace_free(stream.workspace); |
| return (err); |
| } |
| |
| err = zlib_deflate(&stream, Z_FINISH); |
| if (err != Z_STREAM_END) { |
| zlib_deflateEnd(&stream); |
| zlib_workspace_free(stream.workspace); |
| return (err == Z_OK ? Z_BUF_ERROR : err); |
| } |
| *destLen = stream.total_out; |
| |
| err = zlib_deflateEnd(&stream); |
| zlib_workspace_free(stream.workspace); |
| |
| return (err); |
| } |
| EXPORT_SYMBOL(z_compress_level); |
| |
| /* |
| * Decompresses the source buffer into the destination buffer. sourceLen is |
| * the byte length of the source buffer. Upon entry, destLen is the total |
| * size of the destination buffer, which must be large enough to hold the |
| * entire uncompressed data. (The size of the uncompressed data must have |
| * been saved previously by the compressor and transmitted to the decompressor |
| * by some mechanism outside the scope of this compression library.) |
| * Upon exit, destLen is the actual size of the compressed buffer. |
| * This function can be used to decompress a whole file at once if the |
| * input file is mmap'ed. |
| * |
| * uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
| * enough memory, Z_BUF_ERROR if there was not enough room in the output |
| * buffer, or Z_DATA_ERROR if the input data was corrupted. |
| */ |
| int |
| z_uncompress(void *dest, size_t *destLen, const void *source, size_t sourceLen) |
| { |
| z_stream stream; |
| int err; |
| |
| stream.next_in = (Byte *)source; |
| stream.avail_in = (uInt)sourceLen; |
| stream.next_out = dest; |
| stream.avail_out = (uInt)*destLen; |
| |
| if ((size_t)stream.avail_out != *destLen) |
| return (Z_BUF_ERROR); |
| |
| stream.workspace = zlib_workspace_alloc(KM_SLEEP); |
| if (!stream.workspace) |
| return (Z_MEM_ERROR); |
| |
| err = zlib_inflateInit(&stream); |
| if (err != Z_OK) { |
| zlib_workspace_free(stream.workspace); |
| return (err); |
| } |
| |
| err = zlib_inflate(&stream, Z_FINISH); |
| if (err != Z_STREAM_END) { |
| zlib_inflateEnd(&stream); |
| zlib_workspace_free(stream.workspace); |
| |
| if (err == Z_NEED_DICT || |
| (err == Z_BUF_ERROR && stream.avail_in == 0)) |
| return (Z_DATA_ERROR); |
| |
| return (err); |
| } |
| *destLen = stream.total_out; |
| |
| err = zlib_inflateEnd(&stream); |
| zlib_workspace_free(stream.workspace); |
| |
| return (err); |
| } |
| EXPORT_SYMBOL(z_uncompress); |
| |
| int |
| spl_zlib_init(void) |
| { |
| int size; |
| |
| size = MAX(zlib_deflate_workspacesize(MAX_WBITS, MAX_MEM_LEVEL), |
| zlib_inflate_workspacesize()); |
| |
| zlib_workspace_cache = kmem_cache_create( |
| "spl_zlib_workspace_cache", |
| size, 0, NULL, NULL, NULL, NULL, NULL, |
| KMC_KVMEM); |
| if (!zlib_workspace_cache) |
| return (1); |
| |
| return (0); |
| } |
| |
| void |
| spl_zlib_fini(void) |
| { |
| kmem_cache_destroy(zlib_workspace_cache); |
| zlib_workspace_cache = NULL; |
| } |