1 /* 2 * Squashfs - a compressed read only filesystem for Linux 3 * 4 * Copyright (c) 2010 LG Electronics 5 * Chan Jeong <chan.jeong@lge.com> 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 * lzo_wrapper.c 22 */ 23 24 #include <linux/mutex.h> 25 #include <linux/buffer_head.h> 26 #include <linux/slab.h> 27 #include <linux/vmalloc.h> 28 #include <linux/lzo.h> 29 30 #include "squashfs_fs.h" 31 #include "squashfs_fs_sb.h" 32 #include "squashfs.h" 33 #include "decompressor.h" 34 35 struct squashfs_lzo { 36 void *input; 37 void *output; 38 }; 39 40 static void *lzo_init(struct squashfs_sb_info *msblk, void *buff) 41 { 42 int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); 43 44 struct squashfs_lzo *stream = kzalloc(sizeof(*stream), GFP_KERNEL); 45 if (stream == NULL) 46 goto failed; 47 stream->input = vmalloc(block_size); 48 if (stream->input == NULL) 49 goto failed; 50 stream->output = vmalloc(block_size); 51 if (stream->output == NULL) 52 goto failed2; 53 54 return stream; 55 56 failed2: 57 vfree(stream->input); 58 failed: 59 ERROR("Failed to allocate lzo workspace\n"); 60 kfree(stream); 61 return ERR_PTR(-ENOMEM); 62 } 63 64 65 static void lzo_free(void *strm) 66 { 67 struct squashfs_lzo *stream = strm; 68 69 if (stream) { 70 vfree(stream->input); 71 vfree(stream->output); 72 } 73 kfree(stream); 74 } 75 76 77 static int lzo_uncompress(struct squashfs_sb_info *msblk, void *strm, 78 void **buffer, struct buffer_head **bh, int b, int offset, int length, 79 int srclength, int pages) 80 { 81 struct squashfs_lzo *stream = strm; 82 void *buff = stream->input; 83 int avail, i, bytes = length, res; 84 size_t out_len = srclength; 85 86 for (i = 0; i < b; i++) { 87 avail = min(bytes, msblk->devblksize - offset); 88 memcpy(buff, bh[i]->b_data + offset, avail); 89 buff += avail; 90 bytes -= avail; 91 offset = 0; 92 put_bh(bh[i]); 93 } 94 95 res = lzo1x_decompress_safe(stream->input, (size_t)length, 96 stream->output, &out_len); 97 if (res != LZO_E_OK) 98 goto failed; 99 100 res = bytes = (int)out_len; 101 for (i = 0, buff = stream->output; bytes && i < pages; i++) { 102 avail = min_t(int, bytes, PAGE_CACHE_SIZE); 103 memcpy(buffer[i], buff, avail); 104 buff += avail; 105 bytes -= avail; 106 } 107 108 return res; 109 110 failed: 111 return -EIO; 112 } 113 114 const struct squashfs_decompressor squashfs_lzo_comp_ops = { 115 .init = lzo_init, 116 .free = lzo_free, 117 .decompress = lzo_uncompress, 118 .id = LZO_COMPRESSION, 119 .name = "lzo", 120 .supported = 1 121 }; 122