1 /* 2 * This file is part of UBIFS. 3 * 4 * Copyright (C) 2006-2008 Nokia Corporation. 5 * Copyright (C) 2006, 2007 University of Szeged, Hungary 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License version 2 as published by 9 * the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 51 18 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 19 * 20 * Authors: Adrian Hunter 21 * Artem Bityutskiy (Битюцкий Артём) 22 * Zoltan Sogor 23 */ 24 25 /* 26 * This file provides a single place to access to compression and 27 * decompression. 28 */ 29 30 #include <linux/crypto.h> 31 #include "ubifs.h" 32 33 /* Fake description object for the "none" compressor */ 34 static struct ubifs_compressor none_compr = { 35 .compr_type = UBIFS_COMPR_NONE, 36 .name = "none", 37 .capi_name = "", 38 }; 39 40 #ifdef CONFIG_UBIFS_FS_LZO 41 static DEFINE_MUTEX(lzo_mutex); 42 43 static struct ubifs_compressor lzo_compr = { 44 .compr_type = UBIFS_COMPR_LZO, 45 .comp_mutex = &lzo_mutex, 46 .name = "lzo", 47 .capi_name = "lzo", 48 }; 49 #else 50 static struct ubifs_compressor lzo_compr = { 51 .compr_type = UBIFS_COMPR_LZO, 52 .name = "lzo", 53 }; 54 #endif 55 56 #ifdef CONFIG_UBIFS_FS_ZLIB 57 static DEFINE_MUTEX(deflate_mutex); 58 static DEFINE_MUTEX(inflate_mutex); 59 60 static struct ubifs_compressor zlib_compr = { 61 .compr_type = UBIFS_COMPR_ZLIB, 62 .comp_mutex = &deflate_mutex, 63 .decomp_mutex = &inflate_mutex, 64 .name = "zlib", 65 .capi_name = "deflate", 66 }; 67 #else 68 static struct ubifs_compressor zlib_compr = { 69 .compr_type = UBIFS_COMPR_ZLIB, 70 .name = "zlib", 71 }; 72 #endif 73 74 /* All UBIFS compressors */ 75 struct ubifs_compressor *ubifs_compressors[UBIFS_COMPR_TYPES_CNT]; 76 77 /** 78 * ubifs_compress - compress data. 79 * @in_buf: data to compress 80 * @in_len: length of the data to compress 81 * @out_buf: output buffer where compressed data should be stored 82 * @out_len: output buffer length is returned here 83 * @compr_type: type of compression to use on enter, actually used compression 84 * type on exit 85 * 86 * This function compresses input buffer @in_buf of length @in_len and stores 87 * the result in the output buffer @out_buf and the resulting length in 88 * @out_len. If the input buffer does not compress, it is just copied to the 89 * @out_buf. The same happens if @compr_type is %UBIFS_COMPR_NONE or if 90 * compression error occurred. 91 * 92 * Note, if the input buffer was not compressed, it is copied to the output 93 * buffer and %UBIFS_COMPR_NONE is returned in @compr_type. 94 */ 95 void ubifs_compress(const void *in_buf, int in_len, void *out_buf, int *out_len, 96 int *compr_type) 97 { 98 int err; 99 struct ubifs_compressor *compr = ubifs_compressors[*compr_type]; 100 101 if (*compr_type == UBIFS_COMPR_NONE) 102 goto no_compr; 103 104 /* If the input data is small, do not even try to compress it */ 105 if (in_len < UBIFS_MIN_COMPR_LEN) 106 goto no_compr; 107 108 if (compr->comp_mutex) 109 mutex_lock(compr->comp_mutex); 110 err = crypto_comp_compress(compr->cc, in_buf, in_len, out_buf, 111 (unsigned int *)out_len); 112 if (compr->comp_mutex) 113 mutex_unlock(compr->comp_mutex); 114 if (unlikely(err)) { 115 ubifs_warn("cannot compress %d bytes, compressor %s, " 116 "error %d, leave data uncompressed", 117 in_len, compr->name, err); 118 goto no_compr; 119 } 120 121 /* 122 * If the data compressed only slightly, it is better to leave it 123 * uncompressed to improve read speed. 124 */ 125 if (in_len - *out_len < UBIFS_MIN_COMPRESS_DIFF) 126 goto no_compr; 127 128 return; 129 130 no_compr: 131 memcpy(out_buf, in_buf, in_len); 132 *out_len = in_len; 133 *compr_type = UBIFS_COMPR_NONE; 134 } 135 136 /** 137 * ubifs_decompress - decompress data. 138 * @in_buf: data to decompress 139 * @in_len: length of the data to decompress 140 * @out_buf: output buffer where decompressed data should 141 * @out_len: output length is returned here 142 * @compr_type: type of compression 143 * 144 * This function decompresses data from buffer @in_buf into buffer @out_buf. 145 * The length of the uncompressed data is returned in @out_len. This functions 146 * returns %0 on success or a negative error code on failure. 147 */ 148 int ubifs_decompress(const void *in_buf, int in_len, void *out_buf, 149 int *out_len, int compr_type) 150 { 151 int err; 152 struct ubifs_compressor *compr; 153 154 if (unlikely(compr_type < 0 || compr_type >= UBIFS_COMPR_TYPES_CNT)) { 155 ubifs_err("invalid compression type %d", compr_type); 156 return -EINVAL; 157 } 158 159 compr = ubifs_compressors[compr_type]; 160 161 if (unlikely(!compr->capi_name)) { 162 ubifs_err("%s compression is not compiled in", compr->name); 163 return -EINVAL; 164 } 165 166 if (compr_type == UBIFS_COMPR_NONE) { 167 memcpy(out_buf, in_buf, in_len); 168 *out_len = in_len; 169 return 0; 170 } 171 172 if (compr->decomp_mutex) 173 mutex_lock(compr->decomp_mutex); 174 err = crypto_comp_decompress(compr->cc, in_buf, in_len, out_buf, 175 (unsigned int *)out_len); 176 if (compr->decomp_mutex) 177 mutex_unlock(compr->decomp_mutex); 178 if (err) 179 ubifs_err("cannot decompress %d bytes, compressor %s, " 180 "error %d", in_len, compr->name, err); 181 182 return err; 183 } 184 185 /** 186 * compr_init - initialize a compressor. 187 * @compr: compressor description object 188 * 189 * This function initializes the requested compressor and returns zero in case 190 * of success or a negative error code in case of failure. 191 */ 192 static int __init compr_init(struct ubifs_compressor *compr) 193 { 194 if (compr->capi_name) { 195 compr->cc = crypto_alloc_comp(compr->capi_name, 0, 0); 196 if (IS_ERR(compr->cc)) { 197 ubifs_err("cannot initialize compressor %s, error %ld", 198 compr->name, PTR_ERR(compr->cc)); 199 return PTR_ERR(compr->cc); 200 } 201 } 202 203 ubifs_compressors[compr->compr_type] = compr; 204 return 0; 205 } 206 207 /** 208 * compr_exit - de-initialize a compressor. 209 * @compr: compressor description object 210 */ 211 static void compr_exit(struct ubifs_compressor *compr) 212 { 213 if (compr->capi_name) 214 crypto_free_comp(compr->cc); 215 return; 216 } 217 218 /** 219 * ubifs_compressors_init - initialize UBIFS compressors. 220 * 221 * This function initializes the compressor which were compiled in. Returns 222 * zero in case of success and a negative error code in case of failure. 223 */ 224 int __init ubifs_compressors_init(void) 225 { 226 int err; 227 228 err = compr_init(&lzo_compr); 229 if (err) 230 return err; 231 232 err = compr_init(&zlib_compr); 233 if (err) 234 goto out_lzo; 235 236 ubifs_compressors[UBIFS_COMPR_NONE] = &none_compr; 237 return 0; 238 239 out_lzo: 240 compr_exit(&lzo_compr); 241 return err; 242 } 243 244 /** 245 * ubifs_compressors_exit - de-initialize UBIFS compressors. 246 */ 247 void ubifs_compressors_exit(void) 248 { 249 compr_exit(&lzo_compr); 250 compr_exit(&zlib_compr); 251 } 252