fs/jffs2/compr.c

   1 /*
   2  * JFFS2 -- Journalling Flash File System, Version 2.
   3  *
   4  * Copyright © 2001-2007 Red Hat, Inc.
   5  * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
   6  * Copyright © 2004 Ferenc Havasi <havasi@inf.u-szeged.hu>,
   7  *                  University of Szeged, Hungary
   8  *
   9  * Created by Arjan van de Ven <arjan@infradead.org>
  10  *
  11  * For licensing information, see the file 'LICENCE' in this directory.
  12  *
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #include "compr.h"
  18
  19 static DEFINE_SPINLOCK(jffs2_compressor_list_lock);
  20
  21 /* Available compressors are on this list */
  22 static LIST_HEAD(jffs2_compressor_list);
  23
  24 /* Actual compression mode */
  25 static int jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY;
  26
  27 /* Statistics for blocks stored without compression */
  28 static uint32_t none_stat_compr_blocks=0,none_stat_decompr_blocks=0,none_stat_compr_size=0;
  29
  30
  31 /*
  32  * Return 1 to use this compression
  33  */
  34 static int jffs2_is_best_compression(struct jffs2_compressor *this,
  35                 struct jffs2_compressor *best, uint32_t size, uint32_t bestsize)
  36 {
  37         switch (jffs2_compression_mode) {
  38         case JFFS2_COMPR_MODE_SIZE:
  39                 if (bestsize > size)
  40                         return 1;
  41                 return 0;
  42         case JFFS2_COMPR_MODE_FAVOURLZO:
  43                 if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > size))
  44                         return 1;
  45                 if ((best->compr != JFFS2_COMPR_LZO) && (bestsize > size))
  46                         return 1;
  47                 if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > (size * FAVOUR_LZO_PERCENT / 100)))
  48                         return 1;
  49                 if ((bestsize * FAVOUR_LZO_PERCENT / 100) > size)
  50                         return 1;
  51
  52                 return 0;
  53         }
  54         /* Shouldn't happen */
  55         return 0;
  56 }
  57
  58 /*
  59  * jffs2_selected_compress:
  60  * @compr: Explicit compression type to use (ie, JFFS2_COMPR_ZLIB).
  61  *      If 0, just take the first available compression mode.
  62  * @data_in: Pointer to uncompressed data
  63  * @cpage_out: Pointer to returned pointer to buffer for compressed data
  64  * @datalen: On entry, holds the amount of data available for compression.
  65  *      On exit, expected to hold the amount of data actually compressed.
  66  * @cdatalen: On entry, holds the amount of space available for compressed
  67  *      data. On exit, expected to hold the actual size of the compressed
  68  *      data.
  69  *
  70  * Returns: the compression type used.  Zero is used to show that the data
  71  * could not be compressed; probably because we couldn't find the requested
  72  * compression mode.
  73  */
  74 static int jffs2_selected_compress(u8 compr, unsigned char *data_in,
  75                 unsigned char **cpage_out, u32 *datalen, u32 *cdatalen)
  76 {
  77         struct jffs2_compressor *this;
  78         int err, ret = JFFS2_COMPR_NONE;
  79         uint32_t orig_slen, orig_dlen;
  80         char *output_buf;
  81
  82         output_buf = kmalloc(*cdatalen, GFP_KERNEL);
  83         if (!output_buf) {
  84                 pr_warn("No memory for compressor allocation. Compression failed.\n");
  85                 return ret;
  86         }
  87         orig_slen = *datalen;
  88         orig_dlen = *cdatalen;
  89         spin_lock(&jffs2_compressor_list_lock);
  90         list_for_each_entry(this, &jffs2_compressor_list, list) {
  91                 /* Skip decompress-only and disabled modules */
  92                 if (!this->compress || this->disabled)
  93                         continue;
  94
  95                 /* Skip if not the desired compression type */
  96                 if (compr && (compr != this->compr))
  97                         continue;
  98
  99                 /*
 100                  * Either compression type was unspecified, or we found our
 101                  * compressor; either way, we're good to go.
 102                  */
 103                 this->usecount++;
 104                 spin_unlock(&jffs2_compressor_list_lock);
 105
 106                 *datalen  = orig_slen;
 107                 *cdatalen = orig_dlen;
 108                 err = this->compress(data_in, output_buf, datalen, cdatalen);
 109
 110                 spin_lock(&jffs2_compressor_list_lock);
 111                 this->usecount--;
 112                 if (!err) {
 113                         /* Success */
 114                         ret = this->compr;
 115                         this->stat_compr_blocks++;
 116                         this->stat_compr_orig_size += *datalen;
 117                         this->stat_compr_new_size += *cdatalen;
 118                         break;
 119                 }
 120         }
 121         spin_unlock(&jffs2_compressor_list_lock);
 122         if (ret == JFFS2_COMPR_NONE)
 123                 kfree(output_buf);
 124         else
 125                 *cpage_out = output_buf;
 126
 127         return ret;
 128 }
 129
 130 /* jffs2_compress:
 131  * @data_in: Pointer to uncompressed data
 132  * @cpage_out: Pointer to returned pointer to buffer for compressed data
 133  * @datalen: On entry, holds the amount of data available for compression.
 134  *      On exit, expected to hold the amount of data actually compressed.
 135  * @cdatalen: On entry, holds the amount of space available for compressed
 136  *      data. On exit, expected to hold the actual size of the compressed
 137  *      data.
 138  *
 139  * Returns: Lower byte to be stored with data indicating compression type used.
 140  * Zero is used to show that the data could not be compressed - the
 141  * compressed version was actually larger than the original.
 142  * Upper byte will be used later. (soon)
 143  *
 144  * If the cdata buffer isn't large enough to hold all the uncompressed data,
 145  * jffs2_compress should compress as much as will fit, and should set
 146  * *datalen accordingly to show the amount of data which were compressed.
 147  */
 148 uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 149                         unsigned char *data_in, unsigned char **cpage_out,
 150                         uint32_t *datalen, uint32_t *cdatalen)
 151 {
 152         int ret = JFFS2_COMPR_NONE;
 153         int mode, compr_ret;
 154         struct jffs2_compressor *this, *best=NULL;
 155         unsigned char *output_buf = NULL, *tmp_buf;
 156         uint32_t orig_slen, orig_dlen;
 157         uint32_t best_slen=0, best_dlen=0;
 158
 159         if (c->mount_opts.override_compr)
 160                 mode = c->mount_opts.compr;
 161         else
 162                 mode = jffs2_compression_mode;
 163
 164         switch (mode) {
 165         case JFFS2_COMPR_MODE_NONE:
 166                 break;
 167         case JFFS2_COMPR_MODE_PRIORITY:
 168                 ret = jffs2_selected_compress(0, data_in, cpage_out, datalen,
 169                                 cdatalen);
 170                 break;
 171         case JFFS2_COMPR_MODE_SIZE:
 172         case JFFS2_COMPR_MODE_FAVOURLZO:
 173                 orig_slen = *datalen;
 174                 orig_dlen = *cdatalen;
 175                 spin_lock(&jffs2_compressor_list_lock);
 176                 list_for_each_entry(this, &jffs2_compressor_list, list) {
 177                         /* Skip decompress-only backwards-compatibility and disabled modules */
 178                         if ((!this->compress)||(this->disabled))
 179                                 continue;
 180                         /* Allocating memory for output buffer if necessary */
 181                         if ((this->compr_buf_size < orig_slen) && (this->compr_buf)) {
 182                                 spin_unlock(&jffs2_compressor_list_lock);
 183                                 kfree(this->compr_buf);
 184                                 spin_lock(&jffs2_compressor_list_lock);
 185                                 this->compr_buf_size=0;
 186                                 this->compr_buf=NULL;
 187                         }
 188                         if (!this->compr_buf) {
 189                                 spin_unlock(&jffs2_compressor_list_lock);
 190                                 tmp_buf = kmalloc(orig_slen, GFP_KERNEL);
 191                                 spin_lock(&jffs2_compressor_list_lock);
 192                                 if (!tmp_buf) {
 193                                         pr_warn("No memory for compressor allocation. (%d bytes)\n",
 194                                                 orig_slen);
 195                                         continue;
 196                                 }
 197                                 else {
 198                                         this->compr_buf = tmp_buf;
 199                                         this->compr_buf_size = orig_slen;
 200                                 }
 201                         }
 202                         this->usecount++;
 203                         spin_unlock(&jffs2_compressor_list_lock);
 204                         *datalen  = orig_slen;
 205                         *cdatalen = orig_dlen;
 206                         compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen);
 207                         spin_lock(&jffs2_compressor_list_lock);
 208                         this->usecount--;
 209                         if (!compr_ret) {
 210                                 if (((!best_dlen) || jffs2_is_best_compression(this, best, *cdatalen, best_dlen))
 211                                                 && (*cdatalen < *datalen)) {
 212                                         best_dlen = *cdatalen;
 213                                         best_slen = *datalen;
 214                                         best = this;
 215                                 }
 216                         }
 217                 }
 218                 if (best_dlen) {
 219                         *cdatalen = best_dlen;
 220                         *datalen  = best_slen;
 221                         output_buf = best->compr_buf;
 222                         best->compr_buf = NULL;
 223                         best->compr_buf_size = 0;
 224                         best->stat_compr_blocks++;
 225                         best->stat_compr_orig_size += best_slen;
 226                         best->stat_compr_new_size  += best_dlen;
 227                         ret = best->compr;
 228                         *cpage_out = output_buf;
 229                 }
 230                 spin_unlock(&jffs2_compressor_list_lock);
 231                 break;
 232         case JFFS2_COMPR_MODE_FORCELZO:
 233                 ret = jffs2_selected_compress(JFFS2_COMPR_LZO, data_in,
 234                                 cpage_out, datalen, cdatalen);
 235                 break;
 236         case JFFS2_COMPR_MODE_FORCEZLIB:
 237                 ret = jffs2_selected_compress(JFFS2_COMPR_ZLIB, data_in,
 238                                 cpage_out, datalen, cdatalen);
 239                 break;
 240         default:
 241                 pr_err("unknown compression mode\n");
 242         }
 243
 244         if (ret == JFFS2_COMPR_NONE) {
 245                 *cpage_out = data_in;
 246                 *datalen = *cdatalen;
 247                 none_stat_compr_blocks++;
 248                 none_stat_compr_size += *datalen;
 249         }
 250         return ret;
 251 }
 252
 253 int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
 254                      uint16_t comprtype, unsigned char *cdata_in,
 255                      unsigned char *data_out, uint32_t cdatalen, uint32_t datalen)
 256 {
 257         struct jffs2_compressor *this;
 258         int ret;
 259
 260         /* Older code had a bug where it would write non-zero 'usercompr'
 261            fields. Deal with it. */
 262         if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB)
 263                 comprtype &= 0xff;
 264
 265         switch (comprtype & 0xff) {
 266         case JFFS2_COMPR_NONE:
 267                 /* This should be special-cased elsewhere, but we might as well deal with it */
 268                 memcpy(data_out, cdata_in, datalen);
 269                 none_stat_decompr_blocks++;
 270                 break;
 271         case JFFS2_COMPR_ZERO:
 272                 memset(data_out, 0, datalen);
 273                 break;
 274         default:
 275                 spin_lock(&jffs2_compressor_list_lock);
 276                 list_for_each_entry(this, &jffs2_compressor_list, list) {
 277                         if (comprtype == this->compr) {
 278                                 this->usecount++;
 279                                 spin_unlock(&jffs2_compressor_list_lock);
 280                                 ret = this->decompress(cdata_in, data_out, cdatalen, datalen);
 281                                 spin_lock(&jffs2_compressor_list_lock);
 282                                 if (ret) {
 283                                         pr_warn("Decompressor \"%s\" returned %d\n",
 284                                                 this->name, ret);
 285                                 }
 286                                 else {
 287                                         this->stat_decompr_blocks++;
 288                                 }
 289                                 this->usecount--;
 290                                 spin_unlock(&jffs2_compressor_list_lock);
 291                                 return ret;
 292                         }
 293                 }
 294                 pr_warn("compression type 0x%02x not available\n", comprtype);
 295                 spin_unlock(&jffs2_compressor_list_lock);
 296                 return -EIO;
 297         }
 298         return 0;
 299 }
 300
 301 int jffs2_register_compressor(struct jffs2_compressor *comp)
 302 {
 303         struct jffs2_compressor *this;
 304
 305         if (!comp->name) {
 306                 pr_warn("NULL compressor name at registering JFFS2 compressor. Failed.\n");
 307                 return -1;
 308         }
 309         comp->compr_buf_size=0;
 310         comp->compr_buf=NULL;
 311         comp->usecount=0;
 312         comp->stat_compr_orig_size=0;
 313         comp->stat_compr_new_size=0;
 314         comp->stat_compr_blocks=0;
 315         comp->stat_decompr_blocks=0;
 316         jffs2_dbg(1, "Registering JFFS2 compressor \"%s\"\n", comp->name);
 317
 318         spin_lock(&jffs2_compressor_list_lock);
 319
 320         list_for_each_entry(this, &jffs2_compressor_list, list) {
 321                 if (this->priority < comp->priority) {
 322                         list_add(&comp->list, this->list.prev);
 323                         goto out;
 324                 }
 325         }
 326         list_add_tail(&comp->list, &jffs2_compressor_list);
 327 out:
 328         D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
 329                 printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
 330         })
 331
 332         spin_unlock(&jffs2_compressor_list_lock);
 333
 334         return 0;
 335 }
 336
 337 int jffs2_unregister_compressor(struct jffs2_compressor *comp)
 338 {
 339         D2(struct jffs2_compressor *this);
 340
 341         jffs2_dbg(1, "Unregistering JFFS2 compressor \"%s\"\n", comp->name);
 342
 343         spin_lock(&jffs2_compressor_list_lock);
 344
 345         if (comp->usecount) {
 346                 spin_unlock(&jffs2_compressor_list_lock);
 347                 pr_warn("Compressor module is in use. Unregister failed.\n");
 348                 return -1;
 349         }
 350         list_del(&comp->list);
 351
 352         D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
 353                 printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
 354         })
 355         spin_unlock(&jffs2_compressor_list_lock);
 356         return 0;
 357 }
 358
 359 void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig)
 360 {
 361         if (orig != comprbuf)
 362                 kfree(comprbuf);
 363 }
 364
 365 int __init jffs2_compressors_init(void)
 366 {
 367 /* Registering compressors */
 368 #ifdef CONFIG_JFFS2_ZLIB
 369         jffs2_zlib_init();
 370 #endif
 371 #ifdef CONFIG_JFFS2_RTIME
 372         jffs2_rtime_init();
 373 #endif
 374 #ifdef CONFIG_JFFS2_RUBIN
 375         jffs2_rubinmips_init();
 376         jffs2_dynrubin_init();
 377 #endif
 378 #ifdef CONFIG_JFFS2_LZO
 379         jffs2_lzo_init();
 380 #endif
 381 /* Setting default compression mode */
 382 #ifdef CONFIG_JFFS2_CMODE_NONE
 383         jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
 384         jffs2_dbg(1, "default compression mode: none\n");
 385 #else
 386 #ifdef CONFIG_JFFS2_CMODE_SIZE
 387         jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
 388         jffs2_dbg(1, "default compression mode: size\n");
 389 #else
 390 #ifdef CONFIG_JFFS2_CMODE_FAVOURLZO
 391         jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO;
 392         jffs2_dbg(1, "default compression mode: favourlzo\n");
 393 #else
 394         jffs2_dbg(1, "default compression mode: priority\n");
 395 #endif
 396 #endif
 397 #endif
 398         return 0;
 399 }
 400
 401 int jffs2_compressors_exit(void)
 402 {
 403 /* Unregistering compressors */
 404 #ifdef CONFIG_JFFS2_LZO
 405         jffs2_lzo_exit();
 406 #endif
 407 #ifdef CONFIG_JFFS2_RUBIN
 408         jffs2_dynrubin_exit();
 409         jffs2_rubinmips_exit();
 410 #endif
 411 #ifdef CONFIG_JFFS2_RTIME
 412         jffs2_rtime_exit();
 413 #endif
 414 #ifdef CONFIG_JFFS2_ZLIB
 415         jffs2_zlib_exit();
 416 #endif
 417         return 0;
 418 }