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 */
jffs2_is_best_compression(struct jffs2_compressor * this,struct jffs2_compressor * best,uint32_t size,uint32_t bestsize)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 */
jffs2_selected_compress(u8 compr,unsigned char * data_in,unsigned char ** cpage_out,u32 * datalen,u32 * cdatalen)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 */
jffs2_compress(struct jffs2_sb_info * c,struct jffs2_inode_info * f,unsigned char * data_in,unsigned char ** cpage_out,uint32_t * datalen,uint32_t * cdatalen)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
jffs2_decompress(struct jffs2_sb_info * c,struct jffs2_inode_info * f,uint16_t comprtype,unsigned char * cdata_in,unsigned char * data_out,uint32_t cdatalen,uint32_t datalen)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
jffs2_register_compressor(struct jffs2_compressor * comp)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
jffs2_unregister_compressor(struct jffs2_compressor * comp)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
jffs2_free_comprbuf(unsigned char * comprbuf,unsigned char * orig)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
jffs2_compressors_init(void)3657d2beb13SDavid Brownell int __init jffs2_compressors_init(void)
3661da177e4SLinus Torvalds {
367*3432e574SZhang Xiaoxu int ret = 0;
3681da177e4SLinus Torvalds /* Registering compressors */
369*3432e574SZhang Xiaoxu ret = jffs2_zlib_init();
370*3432e574SZhang Xiaoxu if (ret)
371*3432e574SZhang Xiaoxu goto exit;
372*3432e574SZhang Xiaoxu ret = jffs2_rtime_init();
373*3432e574SZhang Xiaoxu if (ret)
374*3432e574SZhang Xiaoxu goto exit_zlib;
375*3432e574SZhang Xiaoxu ret = jffs2_rubinmips_init();
376*3432e574SZhang Xiaoxu if (ret)
377*3432e574SZhang Xiaoxu goto exit_rtime;
378*3432e574SZhang Xiaoxu ret = jffs2_dynrubin_init();
379*3432e574SZhang Xiaoxu if (ret)
380*3432e574SZhang Xiaoxu goto exit_runinmips;
381*3432e574SZhang Xiaoxu ret = jffs2_lzo_init();
382*3432e574SZhang Xiaoxu if (ret)
383*3432e574SZhang Xiaoxu goto exit_dynrubin;
384*3432e574SZhang Xiaoxu
385d5711ae5SZhang Xiaoxu
3861da177e4SLinus Torvalds /* Setting default compression mode */
3871da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_NONE
3881da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
3895a528957SJoe Perches jffs2_dbg(1, "default compression mode: none\n");
3901da177e4SLinus Torvalds #else
3911da177e4SLinus Torvalds #ifdef CONFIG_JFFS2_CMODE_SIZE
3921da177e4SLinus Torvalds jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
3935a528957SJoe Perches jffs2_dbg(1, "default compression mode: size\n");
3941da177e4SLinus Torvalds #else
3953b23c1f5SRichard Purdie #ifdef CONFIG_JFFS2_CMODE_FAVOURLZO
3963b23c1f5SRichard Purdie jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO;
3975a528957SJoe Perches jffs2_dbg(1, "default compression mode: favourlzo\n");
3983b23c1f5SRichard Purdie #else
3995a528957SJoe Perches jffs2_dbg(1, "default compression mode: priority\n");
4001da177e4SLinus Torvalds #endif
4011da177e4SLinus Torvalds #endif
4023b23c1f5SRichard Purdie #endif
4031da177e4SLinus Torvalds return 0;
404*3432e574SZhang Xiaoxu
405*3432e574SZhang Xiaoxu exit_dynrubin:
406*3432e574SZhang Xiaoxu jffs2_dynrubin_exit();
407*3432e574SZhang Xiaoxu exit_runinmips:
408*3432e574SZhang Xiaoxu jffs2_rubinmips_exit();
409*3432e574SZhang Xiaoxu exit_rtime:
410*3432e574SZhang Xiaoxu jffs2_rtime_exit();
411*3432e574SZhang Xiaoxu exit_zlib:
412*3432e574SZhang Xiaoxu jffs2_zlib_exit();
413*3432e574SZhang Xiaoxu exit:
414*3432e574SZhang Xiaoxu return ret;
4151da177e4SLinus Torvalds }
4161da177e4SLinus Torvalds
jffs2_compressors_exit(void)4173bcc86f5SDavid Woodhouse int jffs2_compressors_exit(void)
4181da177e4SLinus Torvalds {
4191da177e4SLinus Torvalds /* Unregistering compressors */
420c799aca3SRichard Purdie jffs2_lzo_exit();
4211da177e4SLinus Torvalds jffs2_dynrubin_exit();
4221da177e4SLinus Torvalds jffs2_rubinmips_exit();
4231da177e4SLinus Torvalds jffs2_rtime_exit();
4241da177e4SLinus Torvalds jffs2_zlib_exit();
4251da177e4SLinus Torvalds return 0;
4261da177e4SLinus Torvalds }
427