1 /* 2 * Copyright (c) 2013, 2014 3 * Phillip Lougher <phillip@squashfs.org.uk> 4 * 5 * This work is licensed under the terms of the GNU GPL, version 2. See 6 * the COPYING file in the top-level directory. 7 */ 8 9 #include <linux/buffer_head.h> 10 #include <linux/mutex.h> 11 #include <linux/slab.h> 12 #include <linux/vmalloc.h> 13 #include <linux/lz4.h> 14 15 #include "squashfs_fs.h" 16 #include "squashfs_fs_sb.h" 17 #include "squashfs.h" 18 #include "decompressor.h" 19 #include "page_actor.h" 20 21 #define LZ4_LEGACY 1 22 23 struct lz4_comp_opts { 24 __le32 version; 25 __le32 flags; 26 }; 27 28 struct squashfs_lz4 { 29 void *input; 30 void *output; 31 }; 32 33 34 static void *lz4_comp_opts(struct squashfs_sb_info *msblk, 35 void *buff, int len) 36 { 37 struct lz4_comp_opts *comp_opts = buff; 38 39 /* LZ4 compressed filesystems always have compression options */ 40 if (comp_opts == NULL || len < sizeof(*comp_opts)) 41 return ERR_PTR(-EIO); 42 43 if (le32_to_cpu(comp_opts->version) != LZ4_LEGACY) { 44 /* LZ4 format currently used by the kernel is the 'legacy' 45 * format */ 46 ERROR("Unknown LZ4 version\n"); 47 return ERR_PTR(-EINVAL); 48 } 49 50 return NULL; 51 } 52 53 54 static void *lz4_init(struct squashfs_sb_info *msblk, void *buff) 55 { 56 int block_size = max_t(int, msblk->block_size, SQUASHFS_METADATA_SIZE); 57 struct squashfs_lz4 *stream; 58 59 stream = kzalloc(sizeof(*stream), GFP_KERNEL); 60 if (stream == NULL) 61 goto failed; 62 stream->input = vmalloc(block_size); 63 if (stream->input == NULL) 64 goto failed2; 65 stream->output = vmalloc(block_size); 66 if (stream->output == NULL) 67 goto failed3; 68 69 return stream; 70 71 failed3: 72 vfree(stream->input); 73 failed2: 74 kfree(stream); 75 failed: 76 ERROR("Failed to initialise LZ4 decompressor\n"); 77 return ERR_PTR(-ENOMEM); 78 } 79 80 81 static void lz4_free(void *strm) 82 { 83 struct squashfs_lz4 *stream = strm; 84 85 if (stream) { 86 vfree(stream->input); 87 vfree(stream->output); 88 } 89 kfree(stream); 90 } 91 92 93 static int lz4_uncompress(struct squashfs_sb_info *msblk, void *strm, 94 struct buffer_head **bh, int b, int offset, int length, 95 struct squashfs_page_actor *output) 96 { 97 struct squashfs_lz4 *stream = strm; 98 void *buff = stream->input, *data; 99 int avail, i, bytes = length, res; 100 size_t dest_len = output->length; 101 102 for (i = 0; i < b; i++) { 103 avail = min(bytes, msblk->devblksize - offset); 104 memcpy(buff, bh[i]->b_data + offset, avail); 105 buff += avail; 106 bytes -= avail; 107 offset = 0; 108 put_bh(bh[i]); 109 } 110 111 res = lz4_decompress_unknownoutputsize(stream->input, length, 112 stream->output, &dest_len); 113 if (res) 114 return -EIO; 115 116 bytes = dest_len; 117 data = squashfs_first_page(output); 118 buff = stream->output; 119 while (data) { 120 if (bytes <= PAGE_CACHE_SIZE) { 121 memcpy(data, buff, bytes); 122 break; 123 } 124 memcpy(data, buff, PAGE_CACHE_SIZE); 125 buff += PAGE_CACHE_SIZE; 126 bytes -= PAGE_CACHE_SIZE; 127 data = squashfs_next_page(output); 128 } 129 squashfs_finish_page(output); 130 131 return dest_len; 132 } 133 134 const struct squashfs_decompressor squashfs_lz4_comp_ops = { 135 .init = lz4_init, 136 .comp_opts = lz4_comp_opts, 137 .free = lz4_free, 138 .decompress = lz4_uncompress, 139 .id = LZ4_COMPRESSION, 140 .name = "lz4", 141 .supported = 1 142 }; 143