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 155a528957SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 165a528957SJoe Perches 171da177e4SLinus Torvalds #include "compr.h" 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds static DEFINE_SPINLOCK(jffs2_compressor_list_lock); 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds /* Available compressors are on this list */ 221da177e4SLinus Torvalds static LIST_HEAD(jffs2_compressor_list); 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds /* Actual compression mode */ 251da177e4SLinus Torvalds static int jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY; 261da177e4SLinus Torvalds 271da177e4SLinus Torvalds /* Statistics for blocks stored without compression */ 281da177e4SLinus Torvalds static uint32_t none_stat_compr_blocks=0,none_stat_decompr_blocks=0,none_stat_compr_size=0; 291da177e4SLinus Torvalds 303b23c1f5SRichard Purdie 313b23c1f5SRichard Purdie /* 323b23c1f5SRichard Purdie * Return 1 to use this compression 333b23c1f5SRichard Purdie */ 343b23c1f5SRichard Purdie static int jffs2_is_best_compression(struct jffs2_compressor *this, 353b23c1f5SRichard Purdie struct jffs2_compressor *best, uint32_t size, uint32_t bestsize) 363b23c1f5SRichard Purdie { 373b23c1f5SRichard Purdie switch (jffs2_compression_mode) { 383b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_SIZE: 393b23c1f5SRichard Purdie if (bestsize > size) 403b23c1f5SRichard Purdie return 1; 413b23c1f5SRichard Purdie return 0; 423b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_FAVOURLZO: 433b23c1f5SRichard Purdie if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > size)) 443b23c1f5SRichard Purdie return 1; 453b23c1f5SRichard Purdie if ((best->compr != JFFS2_COMPR_LZO) && (bestsize > size)) 463b23c1f5SRichard Purdie return 1; 473b23c1f5SRichard Purdie if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > (size * FAVOUR_LZO_PERCENT / 100))) 483b23c1f5SRichard Purdie return 1; 493b23c1f5SRichard Purdie if ((bestsize * FAVOUR_LZO_PERCENT / 100) > size) 503b23c1f5SRichard Purdie return 1; 513b23c1f5SRichard Purdie 523b23c1f5SRichard Purdie return 0; 533b23c1f5SRichard Purdie } 543b23c1f5SRichard Purdie /* Shouldn't happen */ 553b23c1f5SRichard Purdie return 0; 563b23c1f5SRichard Purdie } 573b23c1f5SRichard Purdie 58123005f3SAndres Salomon /* 59123005f3SAndres Salomon * jffs2_selected_compress: 60123005f3SAndres Salomon * @compr: Explicit compression type to use (ie, JFFS2_COMPR_ZLIB). 61123005f3SAndres Salomon * If 0, just take the first available compression mode. 62123005f3SAndres Salomon * @data_in: Pointer to uncompressed data 63123005f3SAndres Salomon * @cpage_out: Pointer to returned pointer to buffer for compressed data 64123005f3SAndres Salomon * @datalen: On entry, holds the amount of data available for compression. 65123005f3SAndres Salomon * On exit, expected to hold the amount of data actually compressed. 66123005f3SAndres Salomon * @cdatalen: On entry, holds the amount of space available for compressed 67123005f3SAndres Salomon * data. On exit, expected to hold the actual size of the compressed 68123005f3SAndres Salomon * data. 69123005f3SAndres Salomon * 70123005f3SAndres Salomon * Returns: the compression type used. Zero is used to show that the data 71123005f3SAndres Salomon * could not be compressed; probably because we couldn't find the requested 72123005f3SAndres Salomon * compression mode. 73123005f3SAndres Salomon */ 74123005f3SAndres Salomon static int jffs2_selected_compress(u8 compr, unsigned char *data_in, 75123005f3SAndres Salomon unsigned char **cpage_out, u32 *datalen, u32 *cdatalen) 76123005f3SAndres Salomon { 77123005f3SAndres Salomon struct jffs2_compressor *this; 78123005f3SAndres Salomon int err, ret = JFFS2_COMPR_NONE; 79123005f3SAndres Salomon uint32_t orig_slen, orig_dlen; 80123005f3SAndres Salomon char *output_buf; 81123005f3SAndres Salomon 82123005f3SAndres Salomon output_buf = kmalloc(*cdatalen, GFP_KERNEL); 83123005f3SAndres Salomon if (!output_buf) { 845a528957SJoe Perches pr_warn("No memory for compressor allocation. Compression failed.\n"); 85123005f3SAndres Salomon return ret; 86123005f3SAndres Salomon } 87123005f3SAndres Salomon orig_slen = *datalen; 88123005f3SAndres Salomon orig_dlen = *cdatalen; 89123005f3SAndres Salomon spin_lock(&jffs2_compressor_list_lock); 90123005f3SAndres Salomon list_for_each_entry(this, &jffs2_compressor_list, list) { 91123005f3SAndres Salomon /* Skip decompress-only and disabled modules */ 92123005f3SAndres Salomon if (!this->compress || this->disabled) 93123005f3SAndres Salomon continue; 94123005f3SAndres Salomon 95123005f3SAndres Salomon /* Skip if not the desired compression type */ 96123005f3SAndres Salomon if (compr && (compr != this->compr)) 97123005f3SAndres Salomon continue; 98123005f3SAndres Salomon 99123005f3SAndres Salomon /* 100123005f3SAndres Salomon * Either compression type was unspecified, or we found our 101123005f3SAndres Salomon * compressor; either way, we're good to go. 102123005f3SAndres Salomon */ 103123005f3SAndres Salomon this->usecount++; 104123005f3SAndres Salomon spin_unlock(&jffs2_compressor_list_lock); 105123005f3SAndres Salomon 106123005f3SAndres Salomon *datalen = orig_slen; 107123005f3SAndres Salomon *cdatalen = orig_dlen; 108123005f3SAndres Salomon err = this->compress(data_in, output_buf, datalen, cdatalen); 109123005f3SAndres Salomon 110123005f3SAndres Salomon spin_lock(&jffs2_compressor_list_lock); 111123005f3SAndres Salomon this->usecount--; 112123005f3SAndres Salomon if (!err) { 113123005f3SAndres Salomon /* Success */ 114123005f3SAndres Salomon ret = this->compr; 115123005f3SAndres Salomon this->stat_compr_blocks++; 116123005f3SAndres Salomon this->stat_compr_orig_size += *datalen; 117123005f3SAndres Salomon this->stat_compr_new_size += *cdatalen; 118123005f3SAndres Salomon break; 119123005f3SAndres Salomon } 120123005f3SAndres Salomon } 121123005f3SAndres Salomon spin_unlock(&jffs2_compressor_list_lock); 122123005f3SAndres Salomon if (ret == JFFS2_COMPR_NONE) 123123005f3SAndres Salomon kfree(output_buf); 124123005f3SAndres Salomon else 125123005f3SAndres Salomon *cpage_out = output_buf; 126123005f3SAndres Salomon 127123005f3SAndres Salomon return ret; 128123005f3SAndres Salomon } 129123005f3SAndres Salomon 1301da177e4SLinus Torvalds /* jffs2_compress: 131faa5c2a1SGeert Uytterhoeven * @data_in: Pointer to uncompressed data 132faa5c2a1SGeert Uytterhoeven * @cpage_out: Pointer to returned pointer to buffer for compressed data 1331da177e4SLinus Torvalds * @datalen: On entry, holds the amount of data available for compression. 1341da177e4SLinus Torvalds * On exit, expected to hold the amount of data actually compressed. 1351da177e4SLinus Torvalds * @cdatalen: On entry, holds the amount of space available for compressed 1361da177e4SLinus Torvalds * data. On exit, expected to hold the actual size of the compressed 1371da177e4SLinus Torvalds * data. 1381da177e4SLinus Torvalds * 1391da177e4SLinus Torvalds * Returns: Lower byte to be stored with data indicating compression type used. 1401da177e4SLinus Torvalds * Zero is used to show that the data could not be compressed - the 1411da177e4SLinus Torvalds * compressed version was actually larger than the original. 1421da177e4SLinus Torvalds * Upper byte will be used later. (soon) 1431da177e4SLinus Torvalds * 1441da177e4SLinus Torvalds * If the cdata buffer isn't large enough to hold all the uncompressed data, 1451da177e4SLinus Torvalds * jffs2_compress should compress as much as will fit, and should set 1461da177e4SLinus Torvalds * *datalen accordingly to show the amount of data which were compressed. 1471da177e4SLinus Torvalds */ 1481da177e4SLinus Torvalds uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 1491da177e4SLinus Torvalds unsigned char *data_in, unsigned char **cpage_out, 1501da177e4SLinus Torvalds uint32_t *datalen, uint32_t *cdatalen) 1511da177e4SLinus Torvalds { 1521da177e4SLinus Torvalds int ret = JFFS2_COMPR_NONE; 15392abc475SAndres Salomon int mode, compr_ret; 1541da177e4SLinus Torvalds struct jffs2_compressor *this, *best=NULL; 1551da177e4SLinus Torvalds unsigned char *output_buf = NULL, *tmp_buf; 1561da177e4SLinus Torvalds uint32_t orig_slen, orig_dlen; 1571da177e4SLinus Torvalds uint32_t best_slen=0, best_dlen=0; 1581da177e4SLinus Torvalds 15992abc475SAndres Salomon if (c->mount_opts.override_compr) 16092abc475SAndres Salomon mode = c->mount_opts.compr; 16192abc475SAndres Salomon else 16292abc475SAndres Salomon mode = jffs2_compression_mode; 16392abc475SAndres Salomon 16492abc475SAndres Salomon switch (mode) { 1651da177e4SLinus Torvalds case JFFS2_COMPR_MODE_NONE: 1661da177e4SLinus Torvalds break; 1671da177e4SLinus Torvalds case JFFS2_COMPR_MODE_PRIORITY: 168123005f3SAndres Salomon ret = jffs2_selected_compress(0, data_in, cpage_out, datalen, 169123005f3SAndres Salomon cdatalen); 1701da177e4SLinus Torvalds break; 1711da177e4SLinus Torvalds case JFFS2_COMPR_MODE_SIZE: 1723b23c1f5SRichard Purdie case JFFS2_COMPR_MODE_FAVOURLZO: 1731da177e4SLinus Torvalds orig_slen = *datalen; 1741da177e4SLinus Torvalds orig_dlen = *cdatalen; 1751da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1761da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 1771da177e4SLinus Torvalds /* Skip decompress-only backwards-compatibility and disabled modules */ 1781da177e4SLinus Torvalds if ((!this->compress)||(this->disabled)) 1791da177e4SLinus Torvalds continue; 1801da177e4SLinus Torvalds /* Allocating memory for output buffer if necessary */ 1813b23c1f5SRichard Purdie if ((this->compr_buf_size < orig_slen) && (this->compr_buf)) { 1821da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 1831da177e4SLinus Torvalds kfree(this->compr_buf); 1841da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1851da177e4SLinus Torvalds this->compr_buf_size=0; 1861da177e4SLinus Torvalds this->compr_buf=NULL; 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds if (!this->compr_buf) { 1891da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 1903b23c1f5SRichard Purdie tmp_buf = kmalloc(orig_slen, GFP_KERNEL); 1911da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 1921da177e4SLinus Torvalds if (!tmp_buf) { 1935a528957SJoe Perches pr_warn("No memory for compressor allocation. (%d bytes)\n", 194da320f05SJoe Perches orig_slen); 1951da177e4SLinus Torvalds continue; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds else { 1981da177e4SLinus Torvalds this->compr_buf = tmp_buf; 1993b23c1f5SRichard Purdie this->compr_buf_size = orig_slen; 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds this->usecount++; 2031da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2041da177e4SLinus Torvalds *datalen = orig_slen; 2051da177e4SLinus Torvalds *cdatalen = orig_dlen; 206088bd455SMike Frysinger compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen); 2071da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2081da177e4SLinus Torvalds this->usecount--; 2091da177e4SLinus Torvalds if (!compr_ret) { 2103b23c1f5SRichard Purdie if (((!best_dlen) || jffs2_is_best_compression(this, best, *cdatalen, best_dlen)) 2113b23c1f5SRichard Purdie && (*cdatalen < *datalen)) { 2121da177e4SLinus Torvalds best_dlen = *cdatalen; 2131da177e4SLinus Torvalds best_slen = *datalen; 2141da177e4SLinus Torvalds best = this; 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds if (best_dlen) { 2191da177e4SLinus Torvalds *cdatalen = best_dlen; 2201da177e4SLinus Torvalds *datalen = best_slen; 2211da177e4SLinus Torvalds output_buf = best->compr_buf; 2221da177e4SLinus Torvalds best->compr_buf = NULL; 2231da177e4SLinus Torvalds best->compr_buf_size = 0; 2241da177e4SLinus Torvalds best->stat_compr_blocks++; 2251da177e4SLinus Torvalds best->stat_compr_orig_size += best_slen; 2261da177e4SLinus Torvalds best->stat_compr_new_size += best_dlen; 2271da177e4SLinus Torvalds ret = best->compr; 228123005f3SAndres Salomon *cpage_out = output_buf; 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2311da177e4SLinus Torvalds break; 232123005f3SAndres Salomon case JFFS2_COMPR_MODE_FORCELZO: 233123005f3SAndres Salomon ret = jffs2_selected_compress(JFFS2_COMPR_LZO, data_in, 234123005f3SAndres Salomon cpage_out, datalen, cdatalen); 235123005f3SAndres Salomon break; 236123005f3SAndres Salomon case JFFS2_COMPR_MODE_FORCEZLIB: 237123005f3SAndres Salomon ret = jffs2_selected_compress(JFFS2_COMPR_ZLIB, data_in, 238123005f3SAndres Salomon cpage_out, datalen, cdatalen); 239123005f3SAndres Salomon break; 2401da177e4SLinus Torvalds default: 2415a528957SJoe Perches pr_err("unknown compression mode\n"); 2421da177e4SLinus Torvalds } 243123005f3SAndres Salomon 2441da177e4SLinus Torvalds if (ret == JFFS2_COMPR_NONE) { 2451da177e4SLinus Torvalds *cpage_out = data_in; 2461da177e4SLinus Torvalds *datalen = *cdatalen; 2471da177e4SLinus Torvalds none_stat_compr_blocks++; 2481da177e4SLinus Torvalds none_stat_compr_size += *datalen; 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds return ret; 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, 2541da177e4SLinus Torvalds uint16_t comprtype, unsigned char *cdata_in, 2551da177e4SLinus Torvalds unsigned char *data_out, uint32_t cdatalen, uint32_t datalen) 2561da177e4SLinus Torvalds { 2571da177e4SLinus Torvalds struct jffs2_compressor *this; 2581da177e4SLinus Torvalds int ret; 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds /* Older code had a bug where it would write non-zero 'usercompr' 2611da177e4SLinus Torvalds fields. Deal with it. */ 2621da177e4SLinus Torvalds if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB) 2631da177e4SLinus Torvalds comprtype &= 0xff; 2641da177e4SLinus Torvalds 2651da177e4SLinus Torvalds switch (comprtype & 0xff) { 2661da177e4SLinus Torvalds case JFFS2_COMPR_NONE: 2671da177e4SLinus Torvalds /* This should be special-cased elsewhere, but we might as well deal with it */ 2681da177e4SLinus Torvalds memcpy(data_out, cdata_in, datalen); 2691da177e4SLinus Torvalds none_stat_decompr_blocks++; 2701da177e4SLinus Torvalds break; 2711da177e4SLinus Torvalds case JFFS2_COMPR_ZERO: 2721da177e4SLinus Torvalds memset(data_out, 0, datalen); 2731da177e4SLinus Torvalds break; 2741da177e4SLinus Torvalds default: 2751da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2761da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 2771da177e4SLinus Torvalds if (comprtype == this->compr) { 2781da177e4SLinus Torvalds this->usecount++; 2791da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 280088bd455SMike Frysinger ret = this->decompress(cdata_in, data_out, cdatalen, datalen); 2811da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 2821da177e4SLinus Torvalds if (ret) { 283da320f05SJoe Perches pr_warn("Decompressor \"%s\" returned %d\n", 284da320f05SJoe Perches this->name, ret); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds else { 2871da177e4SLinus Torvalds this->stat_decompr_blocks++; 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds this->usecount--; 2901da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2911da177e4SLinus Torvalds return ret; 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds } 2945a528957SJoe Perches pr_warn("compression type 0x%02x not available\n", comprtype); 2951da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 2961da177e4SLinus Torvalds return -EIO; 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds return 0; 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds int jffs2_register_compressor(struct jffs2_compressor *comp) 3021da177e4SLinus Torvalds { 3031da177e4SLinus Torvalds struct jffs2_compressor *this; 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds if (!comp->name) { 306da320f05SJoe Perches pr_warn("NULL compressor name at registering JFFS2 compressor. Failed.\n"); 3071da177e4SLinus Torvalds return -1; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds comp->compr_buf_size=0; 3101da177e4SLinus Torvalds comp->compr_buf=NULL; 3111da177e4SLinus Torvalds comp->usecount=0; 3121da177e4SLinus Torvalds comp->stat_compr_orig_size=0; 3131da177e4SLinus Torvalds comp->stat_compr_new_size=0; 3141da177e4SLinus Torvalds comp->stat_compr_blocks=0; 3151da177e4SLinus Torvalds comp->stat_decompr_blocks=0; 3169c261b33SJoe Perches jffs2_dbg(1, "Registering JFFS2 compressor \"%s\"\n", comp->name); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds list_for_each_entry(this, &jffs2_compressor_list, list) { 3211da177e4SLinus Torvalds if (this->priority < comp->priority) { 3221da177e4SLinus Torvalds list_add(&comp->list, this->list.prev); 3231da177e4SLinus Torvalds goto out; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds list_add_tail(&comp->list, &jffs2_compressor_list); 3271da177e4SLinus Torvalds out: 3281da177e4SLinus Torvalds D2(list_for_each_entry(this, &jffs2_compressor_list, list) { 3291da177e4SLinus Torvalds printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority); 3301da177e4SLinus Torvalds }) 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds return 0; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds int jffs2_unregister_compressor(struct jffs2_compressor *comp) 3381da177e4SLinus Torvalds { 3399c261b33SJoe Perches D2(struct jffs2_compressor *this); 3401da177e4SLinus Torvalds 3419c261b33SJoe Perches jffs2_dbg(1, "Unregistering JFFS2 compressor \"%s\"\n", comp->name); 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds spin_lock(&jffs2_compressor_list_lock); 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds if (comp->usecount) { 3461da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 3475a528957SJoe Perches pr_warn("Compressor module is in use. Unregister failed.\n"); 3481da177e4SLinus Torvalds return -1; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds list_del(&comp->list); 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds D2(list_for_each_entry(this, &jffs2_compressor_list, list) { 3531da177e4SLinus Torvalds printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority); 3541da177e4SLinus Torvalds }) 3551da177e4SLinus Torvalds spin_unlock(&jffs2_compressor_list_lock); 3561da177e4SLinus Torvalds return 0; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds 3591da177e4SLinus Torvalds void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig) 3601da177e4SLinus Torvalds { 3611da177e4SLinus Torvalds if (orig != comprbuf) 3621da177e4SLinus Torvalds kfree(comprbuf); 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds 3657d2beb13SDavid Brownell int __init jffs2_compressors_init(void) 3661da177e4SLinus Torvalds { 3671da177e4SLinus Torvalds /* Registering compressors */ 3681da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_ZLIB 3691da177e4SLinus Torvalds jffs2_zlib_init(); 3701da177e4SLinus Torvalds #endif 3711da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RTIME 3721da177e4SLinus Torvalds jffs2_rtime_init(); 3731da177e4SLinus Torvalds #endif 3741da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RUBIN 3751da177e4SLinus Torvalds jffs2_rubinmips_init(); 3761da177e4SLinus Torvalds jffs2_dynrubin_init(); 3771da177e4SLinus Torvalds #endif 378c799aca3SRichard Purdie #ifdef CONFIG_JFFS2_LZO 379c799aca3SRichard Purdie jffs2_lzo_init(); 380c799aca3SRichard Purdie #endif 3811da177e4SLinus Torvalds /* Setting default compression mode */ 3821da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_NONE 3831da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_NONE; 3845a528957SJoe Perches jffs2_dbg(1, "default compression mode: none\n"); 3851da177e4SLinus Torvalds #else 3861da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_SIZE 3871da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE; 3885a528957SJoe Perches jffs2_dbg(1, "default compression mode: size\n"); 3891da177e4SLinus Torvalds #else 3903b23c1f5SRichard Purdie #ifdef CONFIG_JFFS2_CMODE_FAVOURLZO 3913b23c1f5SRichard Purdie jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO; 3925a528957SJoe Perches jffs2_dbg(1, "default compression mode: favourlzo\n"); 3933b23c1f5SRichard Purdie #else 3945a528957SJoe Perches jffs2_dbg(1, "default compression mode: priority\n"); 3951da177e4SLinus Torvalds #endif 3961da177e4SLinus Torvalds #endif 3973b23c1f5SRichard Purdie #endif 3981da177e4SLinus Torvalds return 0; 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds 4013bcc86f5SDavid Woodhouse int jffs2_compressors_exit(void) 4021da177e4SLinus Torvalds { 4031da177e4SLinus Torvalds /* Unregistering compressors */ 404c799aca3SRichard Purdie #ifdef CONFIG_JFFS2_LZO 405c799aca3SRichard Purdie jffs2_lzo_exit(); 406c799aca3SRichard Purdie #endif 4071da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RUBIN 4081da177e4SLinus Torvalds jffs2_dynrubin_exit(); 4091da177e4SLinus Torvalds jffs2_rubinmips_exit(); 4101da177e4SLinus Torvalds #endif 4111da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_RTIME 4121da177e4SLinus Torvalds jffs2_rtime_exit(); 4131da177e4SLinus Torvalds #endif 4141da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_ZLIB 4151da177e4SLinus Torvalds jffs2_zlib_exit(); 4161da177e4SLinus Torvalds #endif 4171da177e4SLinus Torvalds return 0; 4181da177e4SLinus Torvalds } 419