aboutsummaryrefslogtreecommitdiffstats
path: root/fs/jffs2/compr.c
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
committerLinus Torvalds <torvalds@ppc970.osdl.org>2005-04-16 18:20:36 -0400
commit1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch)
tree0bba044c4ce775e45a88a51686b5d9f90697ea9d /fs/jffs2/compr.c
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
Diffstat (limited to 'fs/jffs2/compr.c')
-rw-r--r--fs/jffs2/compr.c469
1 files changed, 469 insertions, 0 deletions
diff --git a/fs/jffs2/compr.c b/fs/jffs2/compr.c
new file mode 100644
index 000000000000..af922a9618ac
--- /dev/null
+++ b/fs/jffs2/compr.c
@@ -0,0 +1,469 @@
1/*
2 * JFFS2 -- Journalling Flash File System, Version 2.
3 *
4 * Copyright (C) 2001-2003 Red Hat, Inc.
5 * Created by Arjan van de Ven <arjanv@redhat.com>
6 *
7 * Copyright (C) 2004 Ferenc Havasi <havasi@inf.u-szeged.hu>,
8 * University of Szeged, Hungary
9 *
10 * For licensing information, see the file 'LICENCE' in this directory.
11 *
12 * $Id: compr.c,v 1.42 2004/08/07 21:56:08 dwmw2 Exp $
13 *
14 */
15
16#include "compr.h"
17
18static DEFINE_SPINLOCK(jffs2_compressor_list_lock);
19
20/* Available compressors are on this list */
21static LIST_HEAD(jffs2_compressor_list);
22
23/* Actual compression mode */
24static int jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY;
25
26/* Statistics for blocks stored without compression */
27static uint32_t none_stat_compr_blocks=0,none_stat_decompr_blocks=0,none_stat_compr_size=0;
28
29/* jffs2_compress:
30 * @data: Pointer to uncompressed data
31 * @cdata: Pointer to returned pointer to buffer for compressed data
32 * @datalen: On entry, holds the amount of data available for compression.
33 * On exit, expected to hold the amount of data actually compressed.
34 * @cdatalen: On entry, holds the amount of space available for compressed
35 * data. On exit, expected to hold the actual size of the compressed
36 * data.
37 *
38 * Returns: Lower byte to be stored with data indicating compression type used.
39 * Zero is used to show that the data could not be compressed - the
40 * compressed version was actually larger than the original.
41 * Upper byte will be used later. (soon)
42 *
43 * If the cdata buffer isn't large enough to hold all the uncompressed data,
44 * jffs2_compress should compress as much as will fit, and should set
45 * *datalen accordingly to show the amount of data which were compressed.
46 */
47uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
48 unsigned char *data_in, unsigned char **cpage_out,
49 uint32_t *datalen, uint32_t *cdatalen)
50{
51 int ret = JFFS2_COMPR_NONE;
52 int compr_ret;
53 struct jffs2_compressor *this, *best=NULL;
54 unsigned char *output_buf = NULL, *tmp_buf;
55 uint32_t orig_slen, orig_dlen;
56 uint32_t best_slen=0, best_dlen=0;
57
58 switch (jffs2_compression_mode) {
59 case JFFS2_COMPR_MODE_NONE:
60 break;
61 case JFFS2_COMPR_MODE_PRIORITY:
62 output_buf = kmalloc(*cdatalen,GFP_KERNEL);
63 if (!output_buf) {
64 printk(KERN_WARNING "JFFS2: No memory for compressor allocation. Compression failed.\n");
65 goto out;
66 }
67 orig_slen = *datalen;
68 orig_dlen = *cdatalen;
69 spin_lock(&jffs2_compressor_list_lock);
70 list_for_each_entry(this, &jffs2_compressor_list, list) {
71 /* Skip decompress-only backwards-compatibility and disabled modules */
72 if ((!this->compress)||(this->disabled))
73 continue;
74
75 this->usecount++;
76 spin_unlock(&jffs2_compressor_list_lock);
77 *datalen = orig_slen;
78 *cdatalen = orig_dlen;
79 compr_ret = this->compress(data_in, output_buf, datalen, cdatalen, NULL);
80 spin_lock(&jffs2_compressor_list_lock);
81 this->usecount--;
82 if (!compr_ret) {
83 ret = this->compr;
84 this->stat_compr_blocks++;
85 this->stat_compr_orig_size += *datalen;
86 this->stat_compr_new_size += *cdatalen;
87 break;
88 }
89 }
90 spin_unlock(&jffs2_compressor_list_lock);
91 if (ret == JFFS2_COMPR_NONE) kfree(output_buf);
92 break;
93 case JFFS2_COMPR_MODE_SIZE:
94 orig_slen = *datalen;
95 orig_dlen = *cdatalen;
96 spin_lock(&jffs2_compressor_list_lock);
97 list_for_each_entry(this, &jffs2_compressor_list, list) {
98 /* Skip decompress-only backwards-compatibility and disabled modules */
99 if ((!this->compress)||(this->disabled))
100 continue;
101 /* Allocating memory for output buffer if necessary */
102 if ((this->compr_buf_size<orig_dlen)&&(this->compr_buf)) {
103 spin_unlock(&jffs2_compressor_list_lock);
104 kfree(this->compr_buf);
105 spin_lock(&jffs2_compressor_list_lock);
106 this->compr_buf_size=0;
107 this->compr_buf=NULL;
108 }
109 if (!this->compr_buf) {
110 spin_unlock(&jffs2_compressor_list_lock);
111 tmp_buf = kmalloc(orig_dlen,GFP_KERNEL);
112 spin_lock(&jffs2_compressor_list_lock);
113 if (!tmp_buf) {
114 printk(KERN_WARNING "JFFS2: No memory for compressor allocation. (%d bytes)\n",orig_dlen);
115 continue;
116 }
117 else {
118 this->compr_buf = tmp_buf;
119 this->compr_buf_size = orig_dlen;
120 }
121 }
122 this->usecount++;
123 spin_unlock(&jffs2_compressor_list_lock);
124 *datalen = orig_slen;
125 *cdatalen = orig_dlen;
126 compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen, NULL);
127 spin_lock(&jffs2_compressor_list_lock);
128 this->usecount--;
129 if (!compr_ret) {
130 if ((!best_dlen)||(best_dlen>*cdatalen)) {
131 best_dlen = *cdatalen;
132 best_slen = *datalen;
133 best = this;
134 }
135 }
136 }
137 if (best_dlen) {
138 *cdatalen = best_dlen;
139 *datalen = best_slen;
140 output_buf = best->compr_buf;
141 best->compr_buf = NULL;
142 best->compr_buf_size = 0;
143 best->stat_compr_blocks++;
144 best->stat_compr_orig_size += best_slen;
145 best->stat_compr_new_size += best_dlen;
146 ret = best->compr;
147 }
148 spin_unlock(&jffs2_compressor_list_lock);
149 break;
150 default:
151 printk(KERN_ERR "JFFS2: unknow compression mode.\n");
152 }
153 out:
154 if (ret == JFFS2_COMPR_NONE) {
155 *cpage_out = data_in;
156 *datalen = *cdatalen;
157 none_stat_compr_blocks++;
158 none_stat_compr_size += *datalen;
159 }
160 else {
161 *cpage_out = output_buf;
162 }
163 return ret;
164}
165
166int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
167 uint16_t comprtype, unsigned char *cdata_in,
168 unsigned char *data_out, uint32_t cdatalen, uint32_t datalen)
169{
170 struct jffs2_compressor *this;
171 int ret;
172
173 /* Older code had a bug where it would write non-zero 'usercompr'
174 fields. Deal with it. */
175 if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB)
176 comprtype &= 0xff;
177
178 switch (comprtype & 0xff) {
179 case JFFS2_COMPR_NONE:
180 /* This should be special-cased elsewhere, but we might as well deal with it */
181 memcpy(data_out, cdata_in, datalen);
182 none_stat_decompr_blocks++;
183 break;
184 case JFFS2_COMPR_ZERO:
185 memset(data_out, 0, datalen);
186 break;
187 default:
188 spin_lock(&jffs2_compressor_list_lock);
189 list_for_each_entry(this, &jffs2_compressor_list, list) {
190 if (comprtype == this->compr) {
191 this->usecount++;
192 spin_unlock(&jffs2_compressor_list_lock);
193 ret = this->decompress(cdata_in, data_out, cdatalen, datalen, NULL);
194 spin_lock(&jffs2_compressor_list_lock);
195 if (ret) {
196 printk(KERN_WARNING "Decompressor \"%s\" returned %d\n", this->name, ret);
197 }
198 else {
199 this->stat_decompr_blocks++;
200 }
201 this->usecount--;
202 spin_unlock(&jffs2_compressor_list_lock);
203 return ret;
204 }
205 }
206 printk(KERN_WARNING "JFFS2 compression type 0x%02x not available.\n", comprtype);
207 spin_unlock(&jffs2_compressor_list_lock);
208 return -EIO;
209 }
210 return 0;
211}
212
213int jffs2_register_compressor(struct jffs2_compressor *comp)
214{
215 struct jffs2_compressor *this;
216
217 if (!comp->name) {
218 printk(KERN_WARNING "NULL compressor name at registering JFFS2 compressor. Failed.\n");
219 return -1;
220 }
221 comp->compr_buf_size=0;
222 comp->compr_buf=NULL;
223 comp->usecount=0;
224 comp->stat_compr_orig_size=0;
225 comp->stat_compr_new_size=0;
226 comp->stat_compr_blocks=0;
227 comp->stat_decompr_blocks=0;
228 D1(printk(KERN_DEBUG "Registering JFFS2 compressor \"%s\"\n", comp->name));
229
230 spin_lock(&jffs2_compressor_list_lock);
231
232 list_for_each_entry(this, &jffs2_compressor_list, list) {
233 if (this->priority < comp->priority) {
234 list_add(&comp->list, this->list.prev);
235 goto out;
236 }
237 }
238 list_add_tail(&comp->list, &jffs2_compressor_list);
239out:
240 D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
241 printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
242 })
243
244 spin_unlock(&jffs2_compressor_list_lock);
245
246 return 0;
247}
248
249int jffs2_unregister_compressor(struct jffs2_compressor *comp)
250{
251 D2(struct jffs2_compressor *this;)
252
253 D1(printk(KERN_DEBUG "Unregistering JFFS2 compressor \"%s\"\n", comp->name));
254
255 spin_lock(&jffs2_compressor_list_lock);
256
257 if (comp->usecount) {
258 spin_unlock(&jffs2_compressor_list_lock);
259 printk(KERN_WARNING "JFFS2: Compressor modul is in use. Unregister failed.\n");
260 return -1;
261 }
262 list_del(&comp->list);
263
264 D2(list_for_each_entry(this, &jffs2_compressor_list, list) {
265 printk(KERN_DEBUG "Compressor \"%s\", prio %d\n", this->name, this->priority);
266 })
267 spin_unlock(&jffs2_compressor_list_lock);
268 return 0;
269}
270
271#ifdef CONFIG_JFFS2_PROC
272
273#define JFFS2_STAT_BUF_SIZE 16000
274
275char *jffs2_list_compressors(void)
276{
277 struct jffs2_compressor *this;
278 char *buf, *act_buf;
279
280 act_buf = buf = kmalloc(JFFS2_STAT_BUF_SIZE,GFP_KERNEL);
281 list_for_each_entry(this, &jffs2_compressor_list, list) {
282 act_buf += sprintf(act_buf, "%10s priority:%d ", this->name, this->priority);
283 if ((this->disabled)||(!this->compress))
284 act_buf += sprintf(act_buf,"disabled");
285 else
286 act_buf += sprintf(act_buf,"enabled");
287 act_buf += sprintf(act_buf,"\n");
288 }
289 return buf;
290}
291
292char *jffs2_stats(void)
293{
294 struct jffs2_compressor *this;
295 char *buf, *act_buf;
296
297 act_buf = buf = kmalloc(JFFS2_STAT_BUF_SIZE,GFP_KERNEL);
298
299 act_buf += sprintf(act_buf,"JFFS2 compressor statistics:\n");
300 act_buf += sprintf(act_buf,"%10s ","none");
301 act_buf += sprintf(act_buf,"compr: %d blocks (%d) decompr: %d blocks\n", none_stat_compr_blocks,
302 none_stat_compr_size, none_stat_decompr_blocks);
303 spin_lock(&jffs2_compressor_list_lock);
304 list_for_each_entry(this, &jffs2_compressor_list, list) {
305 act_buf += sprintf(act_buf,"%10s ",this->name);
306 if ((this->disabled)||(!this->compress))
307 act_buf += sprintf(act_buf,"- ");
308 else
309 act_buf += sprintf(act_buf,"+ ");
310 act_buf += sprintf(act_buf,"compr: %d blocks (%d/%d) decompr: %d blocks ", this->stat_compr_blocks,
311 this->stat_compr_new_size, this->stat_compr_orig_size,
312 this->stat_decompr_blocks);
313 act_buf += sprintf(act_buf,"\n");
314 }
315 spin_unlock(&jffs2_compressor_list_lock);
316
317 return buf;
318}
319
320char *jffs2_get_compression_mode_name(void)
321{
322 switch (jffs2_compression_mode) {
323 case JFFS2_COMPR_MODE_NONE:
324 return "none";
325 case JFFS2_COMPR_MODE_PRIORITY:
326 return "priority";
327 case JFFS2_COMPR_MODE_SIZE:
328 return "size";
329 }
330 return "unkown";
331}
332
333int jffs2_set_compression_mode_name(const char *name)
334{
335 if (!strcmp("none",name)) {
336 jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
337 return 0;
338 }
339 if (!strcmp("priority",name)) {
340 jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY;
341 return 0;
342 }
343 if (!strcmp("size",name)) {
344 jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
345 return 0;
346 }
347 return 1;
348}
349
350static int jffs2_compressor_Xable(const char *name, int disabled)
351{
352 struct jffs2_compressor *this;
353 spin_lock(&jffs2_compressor_list_lock);
354 list_for_each_entry(this, &jffs2_compressor_list, list) {
355 if (!strcmp(this->name, name)) {
356 this->disabled = disabled;
357 spin_unlock(&jffs2_compressor_list_lock);
358 return 0;
359 }
360 }
361 spin_unlock(&jffs2_compressor_list_lock);
362 printk(KERN_WARNING "JFFS2: compressor %s not found.\n",name);
363 return 1;
364}
365
366int jffs2_enable_compressor_name(const char *name)
367{
368 return jffs2_compressor_Xable(name, 0);
369}
370
371int jffs2_disable_compressor_name(const char *name)
372{
373 return jffs2_compressor_Xable(name, 1);
374}
375
376int jffs2_set_compressor_priority(const char *name, int priority)
377{
378 struct jffs2_compressor *this,*comp;
379 spin_lock(&jffs2_compressor_list_lock);
380 list_for_each_entry(this, &jffs2_compressor_list, list) {
381 if (!strcmp(this->name, name)) {
382 this->priority = priority;
383 comp = this;
384 goto reinsert;
385 }
386 }
387 spin_unlock(&jffs2_compressor_list_lock);
388 printk(KERN_WARNING "JFFS2: compressor %s not found.\n",name);
389 return 1;
390reinsert:
391 /* list is sorted in the order of priority, so if
392 we change it we have to reinsert it into the
393 good place */
394 list_del(&comp->list);
395 list_for_each_entry(this, &jffs2_compressor_list, list) {
396 if (this->priority < comp->priority) {
397 list_add(&comp->list, this->list.prev);
398 spin_unlock(&jffs2_compressor_list_lock);
399 return 0;
400 }
401 }
402 list_add_tail(&comp->list, &jffs2_compressor_list);
403 spin_unlock(&jffs2_compressor_list_lock);
404 return 0;
405}
406
407#endif
408
409void jffs2_free_comprbuf(unsigned char *comprbuf, unsigned char *orig)
410{
411 if (orig != comprbuf)
412 kfree(comprbuf);
413}
414
415int jffs2_compressors_init(void)
416{
417/* Registering compressors */
418#ifdef CONFIG_JFFS2_ZLIB
419 jffs2_zlib_init();
420#endif
421#ifdef CONFIG_JFFS2_RTIME
422 jffs2_rtime_init();
423#endif
424#ifdef CONFIG_JFFS2_RUBIN
425 jffs2_rubinmips_init();
426 jffs2_dynrubin_init();
427#endif
428#ifdef CONFIG_JFFS2_LZARI
429 jffs2_lzari_init();
430#endif
431#ifdef CONFIG_JFFS2_LZO
432 jffs2_lzo_init();
433#endif
434/* Setting default compression mode */
435#ifdef CONFIG_JFFS2_CMODE_NONE
436 jffs2_compression_mode = JFFS2_COMPR_MODE_NONE;
437 D1(printk(KERN_INFO "JFFS2: default compression mode: none\n");)
438#else
439#ifdef CONFIG_JFFS2_CMODE_SIZE
440 jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE;
441 D1(printk(KERN_INFO "JFFS2: default compression mode: size\n");)
442#else
443 D1(printk(KERN_INFO "JFFS2: default compression mode: priority\n");)
444#endif
445#endif
446 return 0;
447}
448
449int jffs2_compressors_exit(void)
450{
451/* Unregistering compressors */
452#ifdef CONFIG_JFFS2_LZO
453 jffs2_lzo_exit();
454#endif
455#ifdef CONFIG_JFFS2_LZARI
456 jffs2_lzari_exit();
457#endif
458#ifdef CONFIG_JFFS2_RUBIN
459 jffs2_dynrubin_exit();
460 jffs2_rubinmips_exit();
461#endif
462#ifdef CONFIG_JFFS2_RTIME
463 jffs2_rtime_exit();
464#endif
465#ifdef CONFIG_JFFS2_ZLIB
466 jffs2_zlib_exit();
467#endif
468 return 0;
469}