1 /* 2 * Squashfs - a compressed read only filesystem for Linux 3 * 4 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 5 * Phillip Lougher <phillip@squashfs.org.uk> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2, 10 * or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * zlib_wrapper.c 22 */ 23 24 25 #include <linux/mutex.h> 26 #include <linux/buffer_head.h> 27 #include <linux/slab.h> 28 #include <linux/zlib.h> 29 #include <linux/vmalloc.h> 30 31 #include "squashfs_fs.h" 32 #include "squashfs_fs_sb.h" 33 #include "squashfs.h" 34 #include "decompressor.h" 35 #include "page_actor.h" 36 37 static void *zlib_init(struct squashfs_sb_info *dummy, void *buff) 38 { 39 z_stream *stream = kmalloc(sizeof(z_stream), GFP_KERNEL); 40 if (stream == NULL) 41 goto failed; 42 stream->workspace = vmalloc(zlib_inflate_workspacesize()); 43 if (stream->workspace == NULL) 44 goto failed; 45 46 return stream; 47 48 failed: 49 ERROR("Failed to allocate zlib workspace\n"); 50 kfree(stream); 51 return ERR_PTR(-ENOMEM); 52 } 53 54 55 static void zlib_free(void *strm) 56 { 57 z_stream *stream = strm; 58 59 if (stream) 60 vfree(stream->workspace); 61 kfree(stream); 62 } 63 64 65 static int zlib_uncompress(struct squashfs_sb_info *msblk, void *strm, 66 struct buffer_head **bh, int b, int offset, int length, 67 struct squashfs_page_actor *output) 68 { 69 int zlib_err, zlib_init = 0, k = 0; 70 z_stream *stream = strm; 71 72 stream->avail_out = PAGE_CACHE_SIZE; 73 stream->next_out = squashfs_first_page(output); 74 stream->avail_in = 0; 75 76 do { 77 if (stream->avail_in == 0 && k < b) { 78 int avail = min(length, msblk->devblksize - offset); 79 length -= avail; 80 stream->next_in = bh[k]->b_data + offset; 81 stream->avail_in = avail; 82 offset = 0; 83 } 84 85 if (stream->avail_out == 0) { 86 stream->next_out = squashfs_next_page(output); 87 if (stream->next_out != NULL) 88 stream->avail_out = PAGE_CACHE_SIZE; 89 } 90 91 if (!zlib_init) { 92 zlib_err = zlib_inflateInit(stream); 93 if (zlib_err != Z_OK) { 94 squashfs_finish_page(output); 95 goto out; 96 } 97 zlib_init = 1; 98 } 99 100 zlib_err = zlib_inflate(stream, Z_SYNC_FLUSH); 101 102 if (stream->avail_in == 0 && k < b) 103 put_bh(bh[k++]); 104 } while (zlib_err == Z_OK); 105 106 squashfs_finish_page(output); 107 108 if (zlib_err != Z_STREAM_END) 109 goto out; 110 111 zlib_err = zlib_inflateEnd(stream); 112 if (zlib_err != Z_OK) 113 goto out; 114 115 if (k < b) 116 goto out; 117 118 return stream->total_out; 119 120 out: 121 for (; k < b; k++) 122 put_bh(bh[k]); 123 124 return -EIO; 125 } 126 127 const struct squashfs_decompressor squashfs_zlib_comp_ops = { 128 .init = zlib_init, 129 .free = zlib_free, 130 .decompress = zlib_uncompress, 131 .id = ZLIB_COMPRESSION, 132 .name = "zlib", 133 .supported = 1 134 }; 135 136