jffs2: add compr=lzo and compr=zlib options (123005f3) · Commits · 戴 / test

fs/jffs2/compr.c

+84 −35

Original line number	Diff line number	Diff line
		@@ -53,7 +53,10 @@ static int jffs2_is_best_compression(struct jffs2_compressor *this,
		return 0;
		}

		/* jffs2_compress:
		/*
		* jffs2_selected_compress:
		* @compr: Explicit compression type to use (ie, JFFS2_COMPR_ZLIB).
		* If 0, just take the first available compression mode.
		* @data_in: Pointer to uncompressed data
		* @cpage_out: Pointer to returned pointer to buffer for compressed data
		* @datalen: On entry, holds the amount of data available for compression.
		@@ -62,56 +65,50 @@ static int jffs2_is_best_compression(struct jffs2_compressor *this,
		* 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.
		* Returns: the compression type used. Zero is used to show that the data
		* could not be compressed; probably because we couldn't find the requested
		* compression mode.
		*/
		uint16_t 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)
		static int jffs2_selected_compress(u8 compr, unsigned char *data_in,
		unsigned char *cpage_out, u32 datalen, u32 *cdatalen)
		{
		int ret = JFFS2_COMPR_NONE;
		int mode, compr_ret;
		struct jffs2_compressor this, best=NULL;
		unsigned char output_buf = NULL, tmp_buf;
		struct jffs2_compressor *this;
		int err, ret = JFFS2_COMPR_NONE;
		uint32_t orig_slen, orig_dlen;
		uint32_t best_slen=0, best_dlen=0;

		if (c->mount_opts.override_compr)
		mode = c->mount_opts.compr;
		else
		mode = jffs2_compression_mode;
		char *output_buf;

		switch (mode) {
		case JFFS2_COMPR_MODE_NONE:
		break;
		case JFFS2_COMPR_MODE_PRIORITY:
		output_buf = kmalloc(*cdatalen, GFP_KERNEL);
		if (!output_buf) {
		printk(KERN_WARNING "JFFS2: No memory for compressor allocation. Compression failed.\n");
		goto out;
		return ret;
		}
		orig_slen = *datalen;
		orig_dlen = *cdatalen;
		spin_lock(&jffs2_compressor_list_lock);
		list_for_each_entry(this, &jffs2_compressor_list, list) {
		/* Skip decompress-only backwards-compatibility and disabled modules */
		if ((!this->compress)\|\|(this->disabled))
		/* Skip decompress-only and disabled modules */
		if (!this->compress \|\| this->disabled)
		continue;

		/* Skip if not the desired compression type */
		if (compr && (compr != this->compr))
		continue;

		/*
		* Either compression type was unspecified, or we found our
		* compressor; either way, we're good to go.
		*/
		this->usecount++;
		spin_unlock(&jffs2_compressor_list_lock);

		*datalen = orig_slen;
		*cdatalen = orig_dlen;
		compr_ret = this->compress(data_in, output_buf, datalen, cdatalen);
		err = this->compress(data_in, output_buf, datalen, cdatalen);

		spin_lock(&jffs2_compressor_list_lock);
		this->usecount--;
		if (!compr_ret) {
		if (!err) {
		/* Success */
		ret = this->compr;
		this->stat_compr_blocks++;
		this->stat_compr_orig_size += *datalen;
		@@ -122,6 +119,52 @@ uint16_t jffs2_compress(struct jffs2_sb_info c, struct jffs2_inode_info f,
		spin_unlock(&jffs2_compressor_list_lock);
		if (ret == JFFS2_COMPR_NONE)
		kfree(output_buf);
		else
		*cpage_out = output_buf;

		return ret;
		}

		/* jffs2_compress:
		* @data_in: Pointer to uncompressed data
		* @cpage_out: 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(struct jffs2_sb_info c, struct jffs2_inode_info f,
		unsigned char data_in, unsigned char *cpage_out,
		uint32_t datalen, uint32_t cdatalen)
		{
		int ret = JFFS2_COMPR_NONE;
		int mode, 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;

		if (c->mount_opts.override_compr)
		mode = c->mount_opts.compr;
		else
		mode = jffs2_compression_mode;

		switch (mode) {
		case JFFS2_COMPR_MODE_NONE:
		break;
		case JFFS2_COMPR_MODE_PRIORITY:
		ret = jffs2_selected_compress(0, data_in, cpage_out, datalen,
		cdatalen);
		break;
		case JFFS2_COMPR_MODE_SIZE:
		case JFFS2_COMPR_MODE_FAVOURLZO:
		@@ -179,22 +222,28 @@ uint16_t jffs2_compress(struct jffs2_sb_info c, struct jffs2_inode_info f,
		best->stat_compr_orig_size += best_slen;
		best->stat_compr_new_size += best_dlen;
		ret = best->compr;
		*cpage_out = output_buf;
		}
		spin_unlock(&jffs2_compressor_list_lock);
		break;
		case JFFS2_COMPR_MODE_FORCELZO:
		ret = jffs2_selected_compress(JFFS2_COMPR_LZO, data_in,
		cpage_out, datalen, cdatalen);
		break;
		case JFFS2_COMPR_MODE_FORCEZLIB:
		ret = jffs2_selected_compress(JFFS2_COMPR_ZLIB, data_in,
		cpage_out, datalen, cdatalen);
		break;
		default:
		printk(KERN_ERR "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;
		}

fs/jffs2/compr.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,8 @@
		#define JFFS2_COMPR_MODE_PRIORITY 1
		#define JFFS2_COMPR_MODE_SIZE 2
		#define JFFS2_COMPR_MODE_FAVOURLZO 3
		#define JFFS2_COMPR_MODE_FORCELZO 4
		#define JFFS2_COMPR_MODE_FORCEZLIB 5

		#define FAVOUR_LZO_PERCENT 80

fs/jffs2/super.c

+24 −2

Original line number	Diff line number	Diff line
		@@ -82,6 +82,14 @@ static const char *jffs2_compr_name(unsigned int compr)
		switch (compr) {
		case JFFS2_COMPR_MODE_NONE:
		return "none";
		#ifdef CONFIG_JFFS2_LZO
		case JFFS2_COMPR_MODE_FORCELZO:
		return "lzo";
		#endif
		#ifdef CONFIG_JFFS2_ZLIB
		case JFFS2_COMPR_MODE_FORCEZLIB:
		return "zlib";
		#endif
		default:
		/* should never happen; programmer error */
		WARN_ON(1);
		@@ -195,11 +203,25 @@ static int jffs2_parse_options(struct jffs2_sb_info c, char data)

		if (!name)
		return -ENOMEM;
		if (!strcmp(name, "none")) {
		if (!strcmp(name, "none"))
		c->mount_opts.compr = JFFS2_COMPR_MODE_NONE;
		c->mount_opts.override_compr = true;
		#ifdef CONFIG_JFFS2_LZO
		else if (!strcmp(name, "lzo"))
		c->mount_opts.compr = JFFS2_COMPR_MODE_FORCELZO;
		#endif
		#ifdef CONFIG_JFFS2_ZLIB
		else if (!strcmp(name, "zlib"))
		c->mount_opts.compr =
		JFFS2_COMPR_MODE_FORCEZLIB;
		#endif
		else {
		printk(KERN_ERR "JFFS2 Error: unknown compressor \"%s\"",
		name);
		kfree(name);
		return -EINVAL;
		}
		kfree(name);
		c->mount_opts.override_compr = true;
		break;
		default:
		printk(KERN_ERR "JFFS2 Error: unrecognized mount option '%s' or missing value\n",

Admin message