From 7d81790ced345585b1e647ca9d0f6678e7062fa4 Mon Sep 17 00:00:00 2001 From: Dongsheng Yang Date: Sat, 31 Oct 2015 11:12:01 +0800 Subject: mtd-utils: Restructure the mtd-utils source. * There is no code modification in this commit, only moving * the files to proper place. The user tools looks a little messy as we place almost the all tools in the root directory of mtd-utils. To make it more clear, I propose to introduce the following structure for our source code. mtd-utils/ |-- lib |-- include |-- misc-utils |-- jffsX-utils |-- nand-utils |-- nor-utils |-- ubi-utils |-- ubifs-utils `-- tests Signed-off-by: Dongsheng Yang Signed-off-by: Brian Norris --- compr.c | 538 ---------------------------------------------------------------- 1 file changed, 538 deletions(-) delete mode 100644 compr.c (limited to 'compr.c') diff --git a/compr.c b/compr.c deleted file mode 100644 index cb4432e..0000000 --- a/compr.c +++ /dev/null @@ -1,538 +0,0 @@ -/* - * JFFS2 -- Journalling Flash File System, Version 2. - * - * Copyright (C) 2004 Ferenc Havasi , - * University of Szeged, Hungary - * - * For licensing information, see the file 'LICENCE' in this directory - * in the jffs2 directory. - */ - -#include "compr.h" -#include -#include -#include - -#define FAVOUR_LZO_PERCENT 80 - -extern int page_size; - -/* LIST IMPLEMENTATION (from linux/list.h) */ - -#define LIST_HEAD_INIT(name) { &(name), &(name) } - -#define LIST_HEAD(name) \ - struct list_head name = LIST_HEAD_INIT(name) - -static inline void __list_add(struct list_head *new, - struct list_head *prev, - struct list_head *next) -{ - next->prev = new; - new->next = next; - new->prev = prev; - prev->next = new; -} - -static inline void list_add(struct list_head *new, struct list_head *head) -{ - __list_add(new, head, head->next); -} - -static inline void list_add_tail(struct list_head *new, struct list_head *head) -{ - __list_add(new, head->prev, head); -} - -static inline void __list_del(struct list_head *prev, struct list_head *next) -{ - next->prev = prev; - prev->next = next; -} - -static inline void list_del(struct list_head *entry) -{ - __list_del(entry->prev, entry->next); - entry->next = (void *) 0; - entry->prev = (void *) 0; -} - -#define list_entry(ptr, type, member) \ - ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) - -#define list_for_each_entry(pos, head, member) \ - for (pos = list_entry((head)->next, typeof(*pos), member); \ - &pos->member != (head); \ - pos = list_entry(pos->member.next, typeof(*pos), member)) - - -/* Available compressors are on this list */ -static LIST_HEAD(jffs2_compressor_list); - -/* Actual compression mode */ -static int jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY; - -void jffs2_set_compression_mode(int mode) -{ - jffs2_compression_mode = mode; -} - -int jffs2_get_compression_mode(void) -{ - return jffs2_compression_mode; -} - -/* Statistics for blocks stored without compression */ -static uint32_t none_stat_compr_blocks=0,none_stat_decompr_blocks=0,none_stat_compr_size=0; - -/* Compression test stuffs */ - -static int jffs2_compression_check = 0; - -static unsigned char *jffs2_compression_check_buf = NULL; - -void jffs2_compression_check_set(int yesno) -{ - jffs2_compression_check = yesno; -} - -int jffs2_compression_check_get(void) -{ - return jffs2_compression_check; -} - -static int jffs2_error_cnt = 0; - -int jffs2_compression_check_errorcnt_get(void) -{ - return jffs2_error_cnt; -} - -#define JFFS2_BUFFER_FILL 0x55 - -/* Called before compression (if compression_check is setted) to prepare - the buffer for buffer overflow test */ -static void jffs2_decompression_test_prepare(unsigned char *buf, int size) -{ - memset(buf,JFFS2_BUFFER_FILL,size+1); -} - -/* Called after compression (if compression_check is setted) to test the result */ -static void jffs2_decompression_test(struct jffs2_compressor *compr, - unsigned char *data_in, unsigned char *output_buf, - uint32_t cdatalen, uint32_t datalen, uint32_t buf_size) -{ - uint32_t i; - - /* buffer overflow test */ - for (i=buf_size;i>cdatalen;i--) { - if (output_buf[i]!=JFFS2_BUFFER_FILL) { - fprintf(stderr,"COMPR_ERROR: buffer overflow at %s. " - "(bs=%d csize=%d b[%d]=%d)\n", compr->name, - buf_size, cdatalen, i, (int)(output_buf[i])); - jffs2_error_cnt++; - return; - } - } - /* allocing temporary buffer for decompression */ - if (!jffs2_compression_check_buf) { - jffs2_compression_check_buf = malloc(page_size); - if (!jffs2_compression_check_buf) { - fprintf(stderr,"No memory for buffer allocation. Compression check disabled.\n"); - jffs2_compression_check = 0; - return; - } - } - /* decompressing */ - if (!compr->decompress) { - fprintf(stderr,"JFFS2 compression check: there is no decompress function at %s.\n", compr->name); - jffs2_error_cnt++; - return; - } - if (compr->decompress(output_buf,jffs2_compression_check_buf,cdatalen,datalen)) { - fprintf(stderr,"JFFS2 compression check: decompression failed at %s.\n", compr->name); - jffs2_error_cnt++; - } - /* validate decompression */ - else { - for (i=0;iname, i); - jffs2_error_cnt++; - break; - } - } - } -} - -/* - * Return 1 to use this compression - */ -static int jffs2_is_best_compression(struct jffs2_compressor *this, - struct jffs2_compressor *best, uint32_t size, uint32_t bestsize) -{ - switch (jffs2_compression_mode) { - case JFFS2_COMPR_MODE_SIZE: - if (bestsize > size) - return 1; - return 0; - case JFFS2_COMPR_MODE_FAVOURLZO: - if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > size)) - return 1; - if ((best->compr != JFFS2_COMPR_LZO) && (bestsize > size)) - return 1; - if ((this->compr == JFFS2_COMPR_LZO) && (bestsize > (size * FAVOUR_LZO_PERCENT / 100))) - return 1; - if ((bestsize * FAVOUR_LZO_PERCENT / 100) > size) - return 1; - - return 0; - } - /* Shouldn't happen */ - return 0; -} - -/* jffs2_compress: - * @data: Pointer to uncompressed data - * @cdata: Pointer to returned pointer to buffer for compressed data - * @datalen: On entry, holds the amount of data available for compression. - * On exit, expected to hold the amount of data actually compressed. - * @cdatalen: On entry, holds the amount of space available for compressed - * data. On exit, expected to hold the actual size of the compressed - * data. - * - * Returns: Lower byte to be stored with data indicating compression type used. - * Zero is used to show that the data could not be compressed - the - * compressed version was actually larger than the original. - * Upper byte will be used later. (soon) - * - * If the cdata buffer isn't large enough to hold all the uncompressed data, - * jffs2_compress should compress as much as will fit, and should set - * *datalen accordingly to show the amount of data which were compressed. - */ -uint16_t jffs2_compress( unsigned char *data_in, unsigned char **cpage_out, - uint32_t *datalen, uint32_t *cdatalen) -{ - int ret = JFFS2_COMPR_NONE; - int compr_ret; - struct jffs2_compressor *this, *best=NULL; - unsigned char *output_buf = NULL, *tmp_buf; - uint32_t orig_slen, orig_dlen; - uint32_t best_slen=0, best_dlen=0; - - switch (jffs2_compression_mode) { - case JFFS2_COMPR_MODE_NONE: - break; - case JFFS2_COMPR_MODE_PRIORITY: - orig_slen = *datalen; - orig_dlen = *cdatalen; - output_buf = malloc(orig_dlen+jffs2_compression_check); - if (!output_buf) { - fprintf(stderr,"mkfs.jffs2: No memory for compressor allocation. Compression failed.\n"); - goto out; - } - list_for_each_entry(this, &jffs2_compressor_list, list) { - /* Skip decompress-only backwards-compatibility and disabled modules */ - if ((!this->compress)||(this->disabled)) - continue; - - this->usecount++; - - if (jffs2_compression_check) /*preparing output buffer for testing buffer overflow */ - jffs2_decompression_test_prepare(output_buf, orig_dlen); - - *datalen = orig_slen; - *cdatalen = orig_dlen; - compr_ret = this->compress(data_in, output_buf, datalen, cdatalen); - this->usecount--; - if (!compr_ret) { - ret = this->compr; - this->stat_compr_blocks++; - this->stat_compr_orig_size += *datalen; - this->stat_compr_new_size += *cdatalen; - if (jffs2_compression_check) - jffs2_decompression_test(this, data_in, output_buf, *cdatalen, *datalen, orig_dlen); - break; - } - } - if (ret == JFFS2_COMPR_NONE) free(output_buf); - break; - case JFFS2_COMPR_MODE_FAVOURLZO: - case JFFS2_COMPR_MODE_SIZE: - orig_slen = *datalen; - orig_dlen = *cdatalen; - list_for_each_entry(this, &jffs2_compressor_list, list) { - uint32_t needed_buf_size; - - if (jffs2_compression_mode == JFFS2_COMPR_MODE_FAVOURLZO) - needed_buf_size = orig_slen + jffs2_compression_check; - else - needed_buf_size = orig_dlen + jffs2_compression_check; - - /* Skip decompress-only backwards-compatibility and disabled modules */ - if ((!this->compress)||(this->disabled)) - continue; - /* Allocating memory for output buffer if necessary */ - if ((this->compr_buf_size < needed_buf_size) && (this->compr_buf)) { - free(this->compr_buf); - this->compr_buf_size=0; - this->compr_buf=NULL; - } - if (!this->compr_buf) { - tmp_buf = malloc(needed_buf_size); - if (!tmp_buf) { - fprintf(stderr,"mkfs.jffs2: No memory for compressor allocation. (%d bytes)\n",orig_dlen); - continue; - } - else { - this->compr_buf = tmp_buf; - this->compr_buf_size = orig_dlen; - } - } - this->usecount++; - if (jffs2_compression_check) /*preparing output buffer for testing buffer overflow */ - jffs2_decompression_test_prepare(this->compr_buf,this->compr_buf_size); - *datalen = orig_slen; - *cdatalen = orig_dlen; - compr_ret = this->compress(data_in, this->compr_buf, datalen, cdatalen); - this->usecount--; - if (!compr_ret) { - if (jffs2_compression_check) - jffs2_decompression_test(this, data_in, this->compr_buf, *cdatalen, *datalen, this->compr_buf_size); - if (((!best_dlen) || jffs2_is_best_compression(this, best, *cdatalen, best_dlen)) - && (*cdatalen < *datalen)) { - best_dlen = *cdatalen; - best_slen = *datalen; - best = this; - } - } - } - if (best_dlen) { - *cdatalen = best_dlen; - *datalen = best_slen; - output_buf = best->compr_buf; - best->compr_buf = NULL; - best->compr_buf_size = 0; - best->stat_compr_blocks++; - best->stat_compr_orig_size += best_slen; - best->stat_compr_new_size += best_dlen; - ret = best->compr; - } - break; - default: - fprintf(stderr,"mkfs.jffs2: unknown compression mode.\n"); - } -out: - if (ret == JFFS2_COMPR_NONE) { - *cpage_out = data_in; - *datalen = *cdatalen; - none_stat_compr_blocks++; - none_stat_compr_size += *datalen; - } - else { - *cpage_out = output_buf; - } - return ret; -} - - -int jffs2_register_compressor(struct jffs2_compressor *comp) -{ - struct jffs2_compressor *this; - - if (!comp->name) { - fprintf(stderr,"NULL compressor name at registering JFFS2 compressor. Failed.\n"); - return -1; - } - comp->compr_buf_size=0; - comp->compr_buf=NULL; - comp->usecount=0; - comp->stat_compr_orig_size=0; - comp->stat_compr_new_size=0; - comp->stat_compr_blocks=0; - comp->stat_decompr_blocks=0; - - list_for_each_entry(this, &jffs2_compressor_list, list) { - if (this->priority < comp->priority) { - list_add(&comp->list, this->list.prev); - goto out; - } - } - list_add_tail(&comp->list, &jffs2_compressor_list); -out: - return 0; -} - -int jffs2_unregister_compressor(struct jffs2_compressor *comp) -{ - - if (comp->usecount) { - fprintf(stderr,"mkfs.jffs2: Compressor modul is in use. Unregister failed.\n"); - return -1; - } - list_del(&comp->list); - - return 0; -} - -#define JFFS2_STAT_BUF_SIZE 16000 - -char *jffs2_list_compressors(void) -{ - struct jffs2_compressor *this; - char *buf, *act_buf; - - act_buf = buf = malloc(JFFS2_STAT_BUF_SIZE); - list_for_each_entry(this, &jffs2_compressor_list, list) { - act_buf += sprintf(act_buf, "%10s priority:%d ", this->name, this->priority); - if ((this->disabled)||(!this->compress)) - act_buf += sprintf(act_buf,"disabled"); - else - act_buf += sprintf(act_buf,"enabled"); - act_buf += sprintf(act_buf,"\n"); - } - return buf; -} - -char *jffs2_stats(void) -{ - struct jffs2_compressor *this; - char *buf, *act_buf; - - act_buf = buf = malloc(JFFS2_STAT_BUF_SIZE); - - act_buf += sprintf(act_buf,"Compression mode: "); - switch (jffs2_compression_mode) { - case JFFS2_COMPR_MODE_NONE: - act_buf += sprintf(act_buf,"none"); - break; - case JFFS2_COMPR_MODE_PRIORITY: - act_buf += sprintf(act_buf,"priority"); - break; - case JFFS2_COMPR_MODE_SIZE: - act_buf += sprintf(act_buf,"size"); - break; - case JFFS2_COMPR_MODE_FAVOURLZO: - act_buf += sprintf(act_buf, "favourlzo"); - break; - default: - act_buf += sprintf(act_buf, "unknown"); - break; - } - act_buf += sprintf(act_buf,"\nCompressors:\n"); - act_buf += sprintf(act_buf,"%10s ","none"); - act_buf += sprintf(act_buf,"compr: %d blocks (%d) decompr: %d blocks\n", none_stat_compr_blocks, - none_stat_compr_size, none_stat_decompr_blocks); - list_for_each_entry(this, &jffs2_compressor_list, list) { - act_buf += sprintf(act_buf,"%10s (prio:%d) ",this->name,this->priority); - if ((this->disabled)||(!this->compress)) - act_buf += sprintf(act_buf,"- "); - else - act_buf += sprintf(act_buf,"+ "); - act_buf += sprintf(act_buf,"compr: %d blocks (%d/%d) decompr: %d blocks ", this->stat_compr_blocks, - this->stat_compr_new_size, this->stat_compr_orig_size, - this->stat_decompr_blocks); - act_buf += sprintf(act_buf,"\n"); - } - return buf; -} - -int jffs2_set_compression_mode_name(const char *name) -{ - if (!strcmp("none",name)) { - jffs2_compression_mode = JFFS2_COMPR_MODE_NONE; - return 0; - } - if (!strcmp("priority",name)) { - jffs2_compression_mode = JFFS2_COMPR_MODE_PRIORITY; - return 0; - } - if (!strcmp("size",name)) { - jffs2_compression_mode = JFFS2_COMPR_MODE_SIZE; - return 0; - } - if (!strcmp("favourlzo", name)) { - jffs2_compression_mode = JFFS2_COMPR_MODE_FAVOURLZO; - return 0; - } - - return 1; -} - -static int jffs2_compressor_Xable(const char *name, int disabled) -{ - struct jffs2_compressor *this; - list_for_each_entry(this, &jffs2_compressor_list, list) { - if (!strcmp(this->name, name)) { - this->disabled = disabled; - return 0; - } - } - return 1; -} - -int jffs2_enable_compressor_name(const char *name) -{ - return jffs2_compressor_Xable(name, 0); -} - -int jffs2_disable_compressor_name(const char *name) -{ - return jffs2_compressor_Xable(name, 1); -} - -int jffs2_set_compressor_priority(const char *name, int priority) -{ - struct jffs2_compressor *this,*comp; - list_for_each_entry(this, &jffs2_compressor_list, list) { - if (!strcmp(this->name, name)) { - this->priority = priority; - comp = this; - goto reinsert; - } - } - fprintf(stderr,"mkfs.jffs2: compressor %s not found.\n",name); - return 1; -reinsert: - /* list is sorted in the order of priority, so if - we change it we have to reinsert it into the - good place */ - list_del(&comp->list); - list_for_each_entry(this, &jffs2_compressor_list, list) { - if (this->priority < comp->priority) { - list_add(&comp->list, this->list.prev); - return 0; - } - } - list_add_tail(&comp->list, &jffs2_compressor_list); - return 0; -} - - -int jffs2_compressors_init(void) -{ -#ifdef CONFIG_JFFS2_ZLIB - jffs2_zlib_init(); -#endif -#ifdef CONFIG_JFFS2_RTIME - jffs2_rtime_init(); -#endif -#ifdef CONFIG_JFFS2_LZO - jffs2_lzo_init(); -#endif - return 0; -} - -int jffs2_compressors_exit(void) -{ -#ifdef CONFIG_JFFS2_RTIME - jffs2_rtime_exit(); -#endif -#ifdef CONFIG_JFFS2_ZLIB - jffs2_zlib_exit(); -#endif -#ifdef CONFIG_JFFS2_LZO - jffs2_lzo_exit(); -#endif - return 0; -} -- cgit v1.2.3