11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * JFFS2 -- Journalling Flash File System, Version 2. 31da177e4SLinus Torvalds * 4c00c310eSDavid Woodhouse * Copyright © 2001-2007 Red Hat, Inc. 56088c058SDavid Woodhouse * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org> 6c00c310eSDavid Woodhouse * Copyright © 2004 Ferenc Havasi <havasi@inf.u-szeged.hu>, 71da177e4SLinus Torvalds * University of Szeged, Hungary 81da177e4SLinus Torvalds * 96088c058SDavid Woodhouse * Created by Arjan van de Ven <arjan@infradead.org> 106088c058SDavid Woodhouse * 111da177e4SLinus Torvalds * For licensing information, see the file 'LICENCE' in this directory. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds */ 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds #include "compr.h" 161da177e4SLinus Torvalds 171da177e4SLinus Torvalds static DEFINE_SPINLOCK(jffs2_compressor_list_lock); 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds /* Available compressors are on this list */ 201da177e4SLinus Torvalds static LIST_HEAD(jffs2_compressor_list); 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds /* Actual compression mode */ 231da177e4SLinus Torvalds static int jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY; 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds /* Statistics for blocks stored without compression */ 261da177e4SLinus Torvalds static uint32_t none_stat_compr_blocks=0,none_stat_decompr_blocks=0,none_stat_compr_size=0; 271da177e4SLinus Torvalds 283b23c1f5SRichard Purdie 293b23c1f5SRichard Purdie /* 303b23c1f5SRichard Purdie * Return 1 to use this compression 313b23c1f5SRichard Purdie */ 323b23c1f5SRichard Purdie static int jffs2_is_best_compression(struct jffs2_compressor *this, 333b23c1f5SRichard Purdie struct jffs2_compressor *best, uint32_t size, uint32_t bestsize) 343b23c1f5SRichard Purdie { 353b23c1f5SRichard Purdie switch (jffs2_compression_mode) { 363b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_SIZE: 373b23c1f5SRichard Purdie if (bestsize > size) 383b23c1f5SRichard Purdie return 1; 393b23c1f5SRichard Purdie return 0; 403b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_FAVOURLZO: 413b23c1f5SRichard Purdie if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > size)) 423b23c1f5SRichard Purdie return 1; 433b23c1f5SRichard Purdie if ((best->compr != JFFS2_COMPR_LZO) && (bestsize > size)) 443b23c1f5SRichard Purdie return 1; 453b23c1f5SRichard Purdie if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > (size * FAVOUR_LZO_PERCENT / 100))) 463b23c1f5SRichard Purdie return 1; 473b23c1f5SRichard Purdie if ((bestsize * FAVOUR_LZO_PERCENT / 100) > size) 483b23c1f5SRichard Purdie return 1; 493b23c1f5SRichard Purdie 503b23c1f5SRichard Purdie return 0; 513b23c1f5SRichard Purdie } 523b23c1f5SRichard Purdie /* Shouldn't happen */ 533b23c1f5SRichard Purdie return 0; 543b23c1f5SRichard Purdie } 553b23c1f5SRichard Purdie 56123005f3SAndres Salomon /* 57123005f3SAndres Salomon * jffs2_selected_compress: 58123005f3SAndres Salomon * @compr: Explicit compression type to use (ie, JFFS2_COMPR_ZLIB). 59123005f3SAndres Salomon * If 0, just take the first available compression mode. 60123005f3SAndres Salomon * @data_in: Pointer to uncompressed data 61123005f3SAndres Salomon * @cpage_out: Pointer to returned pointer to buffer for compressed data 62123005f3SAndres Salomon * @datalen: On entry, holds the amount of data available for compression. 63123005f3SAndres Salomon * On exit, expected to hold the amount of data actually compressed. 64123005f3SAndres Salomon * @cdatalen: On entry, holds the amount of space available for compressed 65123005f3SAndres Salomon * data. On exit, expected to hold the actual size of the compressed 66123005f3SAndres Salomon * data. 67123005f3SAndres Salomon * 68123005f3SAndres Salomon * Returns: the compression type used. Zero is used to show that the data 69123005f3SAndres Salomon * could not be compressed; probably because we couldn't find the requested 70123005f3SAndres Salomon * compression mode. 71123005f3SAndres Salomon */ 72123005f3SAndres Salomon static int jffs2_selected_compress(u8 compr, unsigned char *data_in, 73123005f3SAndres Salomon unsigned char **cpage_out, u32 *datalen, u32 *cdatalen) 74123005f3SAndres Salomon { 75123005f3SAndres Salomon struct jffs2_compressor *this; 76123005f3SAndres Salomon int err, ret = JFFS2_COMPR_NONE; 77123005f3SAndres Salomon uint32_t orig_slen, orig_dlen; 78123005f3SAndres Salomon char *output_buf; 79123005f3SAndres Salomon 80123005f3SAndres Salomon output_buf = kmalloc(*cdatalen, GFP_KERNEL); 81123005f3SAndres Salomon if (!output_buf) { 82da320f05SJoe Perches pr_warn("JFFS2: No memory for compressor allocation. Compression failed.\n"); 83123005f3SAndres Salomon return ret; 84123005f3SAndres Salomon } 85123005f3SAndres Salomon orig_slen = *datalen; 86123005f3SAndres Salomon orig_dlen = *cdatalen; 87123005f3SAndres Salomon spin_lock(&jffs2_compressor_list_lock); 88123005f3SAndres Salomon list_for_each_entry(this, &jffs2_compressor_list, list) { 89123005f3SAndres Salomon /* Skip decompress-only and disabled modules */ 90123005f3SAndres Salomon if (!this->compress || this->disabled) 91123005f3SAndres Salomon continue; 92123005f3SAndres Salomon 93123005f3SAndres Salomon /* Skip if not the desired compression type */ 94123005f3SAndres Salomon if (compr && (compr != this->compr)) 95123005f3SAndres Salomon continue; 96123005f3SAndres Salomon 97123005f3SAndres Salomon /* 98123005f3SAndres Salomon * Either compression type was unspecified, or we found our 99123005f3SAndres Salomon * compressor; either way, we're good to go. 100123005f3SAndres Salomon */ 101123005f3SAndres Salomon this->usecount++; 102123005f3SAndres Salomon spin_unlock(&jffs2_compressor_list_lock); 103123005f3SAndres Salomon 104123005f3SAndres Salomon *datalen = orig_slen; 105123005f3SAndres Salomon *cdatalen = orig_dlen; 106123005f3SAndres Salomon err = this->compress(data_in, output_buf, datalen, cdatalen); 107123005f3SAndres Salomon 108123005f3SAndres Salomon spin_lock(&jffs2_compressor_list_lock); 109123005f3SAndres Salomon this->usecount--; 110123005f3SAndres Salomon if (!err) { 111123005f3SAndres Salomon /* Success */ 112123005f3SAndres Salomon ret = this->compr; 113123005f3SAndres Salomon this->stat_compr_blocks++; 114123005f3SAndres Salomon this->stat_compr_orig_size += *datalen; 115123005f3SAndres Salomon this->stat_compr_new_size += *cdatalen; 116123005f3SAndres Salomon break; 117123005f3SAndres Salomon } 118123005f3SAndres Salomon } 119123005f3SAndres Salomon spin_unlock(&jffs2_compressor_list_lock); 120123005f3SAndres Salomon if (ret == JFFS2_COMPR_NONE) 121123005f3SAndres Salomon kfree(output_buf); 122123005f3SAndres Salomon else 123123005f3SAndres Salomon *cpage_out = output_buf; 124123005f3SAndres Salomon 125123005f3SAndres Salomon return ret; 126123005f3SAndres Salomon } 127123005f3SAndres Salomon 1281da177e4SLinus Torvalds /* jffs2_compress: 129faa5c2a1SGeert Uytterhoeven * @data_in: Pointer to uncompressed data 130faa5c2a1SGeert Uytterhoeven * @cpage_out: Pointer to returned pointer to buffer for compressed data 1311da177e4SLinus Torvalds * @datalen: On entry, holds the amount of data available for compression. 1321da177e4SLinus Torvalds * On exit, expected to hold the amount of data actually compressed. 1331da177e4SLinus Torvalds * @cdatalen: On entry, holds the amount of space available for compressed 1341da177e4SLinus Torvalds * data. On exit, expected to hold the actual size of the compressed 1351da177e4SLinus Torvalds * data. 1361da177e4SLinus Torvalds * 1371da177e4SLinus Torvalds * Returns: Lower byte to be stored with data indicating compression type used. 1381da177e4SLinus Torvalds * Zero is used to show that the data could not be compressed - the 1391da177e4SLinus Torvalds * compressed version was actually larger than the original. 1401da177e4SLinus Torvalds * Upper byte will be used later. (soon) 1411da177e4SLinus Torvalds * 1421da177e4SLinus Torvalds * If the cdata buffer isn't large enough to hold all the uncompressed data, 1431da177e4SLinus Torvalds * jffs2_compress should compress as much as will fit, and should set 1441da177e4SLinus Torvalds * *datalen accordingly to show the amount of data which were compressed. 1451da177e4SLinus Torvalds */ 1461da177e4SLinus Torvalds uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 1471da177e4SLinus Torvalds unsigned char *data_in, unsigned char **cpage_out, 1481da177e4SLinus Torvalds uint32_t *datalen, uint32_t *cdatalen) 1491da177e4SLinus Torvalds { 1501da177e4SLinus Torvalds int ret = JFFS2_COMPR_NONE; 15192abc475SAndres Salomon int mode, compr_ret; 1521da177e4SLinus Torvalds struct jffs2_compressor *this, *best=NULL; 1531da177e4SLinus Torvalds unsigned char *output_buf = NULL, *tmp_buf; 1541da177e4SLinus Torvalds uint32_t orig_slen, orig_dlen; 1551da177e4SLinus Torvalds uint32_t best_slen=0, best_dlen=0; 1561da177e4SLinus Torvalds 15792abc475SAndres Salomon if (c->mount_opts.override_compr) 15892abc475SAndres Salomon mode = c->mount_opts.compr; 15992abc475SAndres Salomon else 16092abc475SAndres Salomon mode = jffs2_compression_mode; 16192abc475SAndres Salomon 16292abc475SAndres Salomon switch (mode) { 1631da177e4SLinus Torvalds case JFFS2_COMPR_MODE_NONE: 1641da177e4SLinus Torvalds break; 1651da177e4SLinus Torvalds case JFFS2_COMPR_MODE_PRIORITY: 166123005f3SAndres Salomon ret = jffs2_selected_compress(0, data_in, cpage_out, datalen, 167123005f3SAndres Salomon cdatalen); 1681da177e4SLinus Torvalds break; 1691da177e4SLinus Torvalds case JFFS2_COMPR_MODE_SIZE: 1703b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_FAVOURLZO: 1711da177e4SLinus Torvalds orig_slen = *datalen; 1721da177e4SLinus Torvalds orig_dlen = *cdatalen; 1731da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1741da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 1751da177e4SLinus Torvalds /* Skip decompress-only backwards-compatibility and disabled modules */ 1761da177e4SLinus Torvalds if ((!this->compress)||(this->disabled)) 1771da177e4SLinus Torvalds continue; 1781da177e4SLinus Torvalds /* Allocating memory for output buffer if necessary */ 1793b23c1f5SRichard Purdie if ((this->compr_buf_size < orig_slen) && (this->compr_buf)) { 1801da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 1811da177e4SLinus Torvalds kfree(this->compr_buf); 1821da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1831da177e4SLinus Torvalds this->compr_buf_size=0; 1841da177e4SLinus Torvalds this->compr_buf=NULL; 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds if (!this->compr_buf) { 1871da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 1883b23c1f5SRichard Purdie tmp_buf = kmalloc(orig_slen, GFP_KERNEL); 1891da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1901da177e4SLinus Torvalds if (!tmp_buf) { 191da320f05SJoe Perches pr_warn("JFFS2: No memory for compressor allocation. (%d bytes)\n", 192da320f05SJoe Perches orig_slen); 1931da177e4SLinus Torvalds continue; 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds else { 1961da177e4SLinus Torvalds this->compr_buf = tmp_buf; 1973b23c1f5SRichard Purdie this->compr_buf_size = orig_slen; 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds this->usecount++; 2011da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2021da177e4SLinus Torvalds *datalen = orig_slen; 2031da177e4SLinus Torvalds *cdatalen = orig_dlen; 204088bd455SMike Frysinger compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen); 2051da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2061da177e4SLinus Torvalds this->usecount--; 2071da177e4SLinus Torvalds if (!compr_ret) { 2083b23c1f5SRichard Purdie if (((!best_dlen) || jffs2_is_best_compression(this, best, *cdatalen, best_dlen)) 2093b23c1f5SRichard Purdie && (*cdatalen < *datalen)) { 2101da177e4SLinus Torvalds best_dlen = *cdatalen; 2111da177e4SLinus Torvalds best_slen = *datalen; 2121da177e4SLinus Torvalds best = this; 2131da177e4SLinus Torvalds } 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds if (best_dlen) { 2171da177e4SLinus Torvalds *cdatalen = best_dlen; 2181da177e4SLinus Torvalds *datalen = best_slen; 2191da177e4SLinus Torvalds output_buf = best->compr_buf; 2201da177e4SLinus Torvalds best->compr_buf = NULL; 2211da177e4SLinus Torvalds best->compr_buf_size = 0; 2221da177e4SLinus Torvalds best->stat_compr_blocks++; 2231da177e4SLinus Torvalds best->stat_compr_orig_size += best_slen; 2241da177e4SLinus Torvalds best->stat_compr_new_size += best_dlen; 2251da177e4SLinus Torvalds ret = best->compr; 226123005f3SAndres Salomon *cpage_out = output_buf; 2271da177e4SLinus Torvalds } 2281da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2291da177e4SLinus Torvalds break; 230123005f3SAndres Salomon case JFFS2_COMPR_MODE_FORCELZO: 231123005f3SAndres Salomon ret = jffs2_selected_compress(JFFS2_COMPR_LZO, data_in, 232123005f3SAndres Salomon cpage_out, datalen, cdatalen); 233123005f3SAndres Salomon break; 234123005f3SAndres Salomon case JFFS2_COMPR_MODE_FORCEZLIB: 235123005f3SAndres Salomon ret = jffs2_selected_compress(JFFS2_COMPR_ZLIB, data_in, 236123005f3SAndres Salomon cpage_out, datalen, cdatalen); 237123005f3SAndres Salomon break; 2381da177e4SLinus Torvalds default: 239da320f05SJoe Perches pr_err("JFFS2: unknown compression mode\n"); 2401da177e4SLinus Torvalds } 241123005f3SAndres Salomon 2421da177e4SLinus Torvalds if (ret == JFFS2_COMPR_NONE) { 2431da177e4SLinus Torvalds *cpage_out = data_in; 2441da177e4SLinus Torvalds *datalen = *cdatalen; 2451da177e4SLinus Torvalds none_stat_compr_blocks++; 2461da177e4SLinus Torvalds none_stat_compr_size += *datalen; 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds return ret; 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2521da177e4SLinus Torvalds uint16_t comprtype, unsigned char *cdata_in, 2531da177e4SLinus Torvalds unsigned char *data_out, uint32_t cdatalen, uint32_t datalen) 2541da177e4SLinus Torvalds { 2551da177e4SLinus Torvalds struct jffs2_compressor *this; 2561da177e4SLinus Torvalds int ret; 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds /* Older code had a bug where it would write non-zero 'usercompr' 2591da177e4SLinus Torvalds fields. Deal with it. */ 2601da177e4SLinus Torvalds if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB) 2611da177e4SLinus Torvalds comprtype &= 0xff; 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds switch (comprtype & 0xff) { 2641da177e4SLinus Torvalds case JFFS2_COMPR_NONE: 2651da177e4SLinus Torvalds /* This should be special-cased elsewhere, but we might as well deal with it */ 2661da177e4SLinus Torvalds memcpy(data_out, cdata_in, datalen); 2671da177e4SLinus Torvalds none_stat_decompr_blocks++; 2681da177e4SLinus Torvalds break; 2691da177e4SLinus Torvalds case JFFS2_COMPR_ZERO: 2701da177e4SLinus Torvalds memset(data_out, 0, datalen); 2711da177e4SLinus Torvalds break; 2721da177e4SLinus Torvalds default: 2731da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2741da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 2751da177e4SLinus Torvalds if (comprtype == this->compr) { 2761da177e4SLinus Torvalds this->usecount++; 2771da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 278088bd455SMike Frysinger ret = this->decompress(cdata_in, data_out, cdatalen, datalen); 2791da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2801da177e4SLinus Torvalds if (ret) { 281da320f05SJoe Perches pr_warn("Decompressor \"%s\" returned %d\n", 282da320f05SJoe Perches this->name, ret); 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds else { 2851da177e4SLinus Torvalds this->stat_decompr_blocks++; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds this->usecount--; 2881da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2891da177e4SLinus Torvalds return ret; 2901da177e4SLinus Torvalds } 2911da177e4SLinus Torvalds } 292da320f05SJoe Perches pr_warn("JFFS2 compression type 0x%02x not available\n", 293da320f05SJoe Perches comprtype); 2941da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2951da177e4SLinus Torvalds return -EIO; 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds return 0; 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds int jffs2_register_compressor(struct jffs2_compressor *comp) 3011da177e4SLinus Torvalds { 3021da177e4SLinus Torvalds struct jffs2_compressor *this; 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds if (!comp->name) { 305da320f05SJoe Perches pr_warn("NULL compressor name at registering JFFS2 compressor. Failed.\n"); 3061da177e4SLinus Torvalds return -1; 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds comp->compr_buf_size=0; 3091da177e4SLinus Torvalds comp->compr_buf=NULL; 3101da177e4SLinus Torvalds comp->usecount=0; 3111da177e4SLinus Torvalds comp->stat_compr_orig_size=0; 3121da177e4SLinus Torvalds comp->stat_compr_new_size=0; 3131da177e4SLinus Torvalds comp->stat_compr_blocks=0; 3141da177e4SLinus Torvalds comp->stat_decompr_blocks=0; 3159c261b33SJoe Perches jffs2_dbg(1, "Registering JFFS2 compressor \"%s\"\n", comp->name); 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 3181da177e4SLinus Torvalds 3191da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 3201da177e4SLinus Torvalds if (this->priority < comp->priority) { 3211da177e4SLinus Torvalds list_add(&comp->list, this->list.prev); 3221da177e4SLinus Torvalds goto out; 3231da177e4SLinus Torvalds } 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds list_add_tail(&comp->list, &jffs2_compressor_list); 3261da177e4SLinus Torvalds out: 3271da177e4SLinus Torvalds D2(list_for_each_entry(this, &jffs2_compressor_list, list) { 3281da177e4SLinus Torvalds printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority); 3291da177e4SLinus Torvalds }) 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds return 0; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds int jffs2_unregister_compressor(struct jffs2_compressor *comp) 3371da177e4SLinus Torvalds { 3389c261b33SJoe Perches D2(struct jffs2_compressor *this); 3391da177e4SLinus Torvalds 3409c261b33SJoe Perches jffs2_dbg(1, "Unregistering JFFS2 compressor \"%s\"\n", comp->name); 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds if (comp->usecount) { 3451da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 346da320f05SJoe Perches pr_warn("JFFS2: Compressor module is in use. Unregister failed.\n"); 3471da177e4SLinus Torvalds return -1; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds list_del(&comp->list); 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds D2(list_for_each_entry(this, &jffs2_compressor_list, list) { 3521da177e4SLinus Torvalds printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority); 3531da177e4SLinus Torvalds }) 3541da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 3551da177e4SLinus Torvalds return 0; 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig) 3591da177e4SLinus Torvalds { 3601da177e4SLinus Torvalds if (orig != comprbuf) 3611da177e4SLinus Torvalds kfree(comprbuf); 3621da177e4SLinus Torvalds } 3631da177e4SLinus Torvalds 3647d2beb13SDavid Brownell int __init jffs2_compressors_init(void) 3651da177e4SLinus Torvalds { 3661da177e4SLinus Torvalds /* Registering compressors */ 3671da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_ZLIB 3681da177e4SLinus Torvalds jffs2_zlib_init(); 3691da177e4SLinus Torvalds #endif 3701da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RTIME 3711da177e4SLinus Torvalds jffs2_rtime_init(); 3721da177e4SLinus Torvalds #endif 3731da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RUBIN 3741da177e4SLinus Torvalds jffs2_rubinmips_init(); 3751da177e4SLinus Torvalds jffs2_dynrubin_init(); 3761da177e4SLinus Torvalds #endif 377c799aca3SRichard Purdie #ifdef CONFIG_JFFS2_LZO 378c799aca3SRichard Purdie jffs2_lzo_init(); 379c799aca3SRichard Purdie #endif 3801da177e4SLinus Torvalds /* Setting default compression mode */ 3811da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_NONE 3821da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_NONE; 3839c261b33SJoe Perches jffs2_dbg(1, "JFFS2: default compression mode: none\n"); 3841da177e4SLinus Torvalds #else 3851da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_SIZE 3861da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE; 3879c261b33SJoe Perches jffs2_dbg(1, "JFFS2: default compression mode: size\n"); 3881da177e4SLinus Torvalds #else 3893b23c1f5SRichard Purdie #ifdef CONFIG_JFFS2_CMODE_FAVOURLZO 3903b23c1f5SRichard Purdie jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO; 3919c261b33SJoe Perches jffs2_dbg(1, "JFFS2: default compression mode: favourlzo\n"); 3923b23c1f5SRichard Purdie #else 3939c261b33SJoe Perches jffs2_dbg(1, "JFFS2: default compression mode: priority\n"); 3941da177e4SLinus Torvalds #endif 3951da177e4SLinus Torvalds #endif 3963b23c1f5SRichard Purdie #endif 3971da177e4SLinus Torvalds return 0; 3981da177e4SLinus Torvalds } 3991da177e4SLinus Torvalds 4003bcc86f5SDavid Woodhouse int jffs2_compressors_exit(void) 4011da177e4SLinus Torvalds { 4021da177e4SLinus Torvalds /* Unregistering compressors */ 403c799aca3SRichard Purdie #ifdef CONFIG_JFFS2_LZO 404c799aca3SRichard Purdie jffs2_lzo_exit(); 405c799aca3SRichard Purdie #endif 4061da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RUBIN 4071da177e4SLinus Torvalds jffs2_dynrubin_exit(); 4081da177e4SLinus Torvalds jffs2_rubinmips_exit(); 4091da177e4SLinus Torvalds #endif 4101da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RTIME 4111da177e4SLinus Torvalds jffs2_rtime_exit(); 4121da177e4SLinus Torvalds #endif 4131da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_ZLIB 4141da177e4SLinus Torvalds jffs2_zlib_exit(); 4151da177e4SLinus Torvalds #endif 4161da177e4SLinus Torvalds return 0; 4171da177e4SLinus Torvalds } 418