Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 846b730e authored by Phillip Lougher's avatar Phillip Lougher
Browse files

Squashfs: Generalise paging handling in the decompressors 



Further generalise the decompressors by adding a page handler
abstraction.  This adds helpers to allow the decompressors
to access and process the output buffers in an implementation
independant manner.

This allows different types of output buffer to be passed
to the decompressors, with the implementation specific
aspects handled at decompression time, but without the
knowledge being held in the decompressor wrapper code.

This will allow the decompressors to handle Squashfs
cache buffers, and page cache pages.

This patch adds the abstraction and an implementation for
the caches.

Signed-off-by: default avatarPhillip Lougher <phillip@squashfs.org.uk>
Reviewed-by: default avatarMinchan Kim <minchan@kernel.org>
parent d208383d

fs/squashfs/block.c

+15 −12
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 
#include "squashfs_fs_sb.h"

#include "squashfs.h"

#include "decompressor.h"

#include "page_actor.h"



/*

 * Read the metadata block length, this is stored in the first two
@@ -86,16 +87,16 @@ static struct buffer_head *get_block_length(struct super_block *sb, 
 * generated a larger block - this does occasionally happen with compression

 * algorithms).

 */

int squashfs_read_data(struct super_block *sb, void **buffer, u64 index,

			int length, u64 *next_index, int srclength, int pages)

int squashfs_read_data(struct super_block *sb, u64 index, int length,

		u64 *next_index, struct squashfs_page_actor *output)

{

	struct squashfs_sb_info *msblk = sb->s_fs_info;

	struct buffer_head **bh;

	int offset = index & ((1 << msblk->devblksize_log2) - 1);

	u64 cur_index = index >> msblk->devblksize_log2;

	int bytes, compressed, b = 0, k = 0, page = 0, avail, i;

	int bytes, compressed, b = 0, k = 0, avail, i;



	bh = kcalloc(((srclength + msblk->devblksize - 1)

	bh = kcalloc(((output->length + msblk->devblksize - 1)

		>> msblk->devblksize_log2) + 1, sizeof(*bh), GFP_KERNEL);

	if (bh == NULL)

		return -ENOMEM;
@@ -111,9 +112,9 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index, 
			*next_index = index + length;



		TRACE("Block @ 0x%llx, %scompressed size %d, src size %d\n",

			index, compressed ? "" : "un", length, srclength);

			index, compressed ? "" : "un", length, output->length);



		if (length < 0 || length > srclength ||

		if (length < 0 || length > output->length ||

				(index + length) > msblk->bytes_used)

			goto read_failure;
@@ -145,7 +146,7 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index, 
		TRACE("Block @ 0x%llx, %scompressed size %d\n", index,

				compressed ? "" : "un", length);



		if (length < 0 || length > srclength ||

		if (length < 0 || length > output->length ||

					(index + length) > msblk->bytes_used)

			goto block_release;
@@ -165,8 +166,8 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index, 
	}



	if (compressed) {

		length = squashfs_decompress(msblk, buffer, bh, b, offset,

			 length, srclength, pages);

		length = squashfs_decompress(msblk, bh, b, offset, length,

			output);

		if (length < 0)

			goto read_failure;

	} else {
@@ -174,19 +175,20 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index, 
		 * Block is uncompressed.

		 */

		int in, pg_offset = 0;

		void *data = squashfs_first_page(output);



		for (bytes = length; k < b; k++) {

			in = min(bytes, msblk->devblksize - offset);

			bytes -= in;

			while (in) {

				if (pg_offset == PAGE_CACHE_SIZE) {

					page++;

					data = squashfs_next_page(output);

					pg_offset = 0;

				}

				avail = min_t(int, in, PAGE_CACHE_SIZE -

						pg_offset);

				memcpy(buffer[page] + pg_offset,

						bh[k]->b_data + offset, avail);

				memcpy(data + pg_offset, bh[k]->b_data + offset,

						avail);

				in -= avail;

				pg_offset += avail;

				offset += avail;
@@ -194,6 +196,7 @@ int squashfs_read_data(struct super_block *sb, void **buffer, u64 index, 
			offset = 0;

			put_bh(bh[k]);

		}

		squashfs_finish_page(output);

	}



	kfree(bh);

fs/squashfs/cache.c

+23 −5
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ 
#include "squashfs_fs.h"

#include "squashfs_fs_sb.h"

#include "squashfs.h"

#include "page_actor.h"



/*

 * Look-up block in cache, and increment usage count.  If not in cache, read
@@ -119,9 +120,8 @@ struct squashfs_cache_entry *squashfs_cache_get(struct super_block *sb, 
			entry->error = 0;

			spin_unlock(&cache->lock);



			entry->length = squashfs_read_data(sb, entry->data,

				block, length, &entry->next_index,

				cache->block_size, cache->pages);

			entry->length = squashfs_read_data(sb, block, length,

				&entry->next_index, entry->actor);



			spin_lock(&cache->lock);
@@ -220,6 +220,7 @@ void squashfs_cache_delete(struct squashfs_cache *cache) 
				kfree(cache->entry[i].data[j]);

			kfree(cache->entry[i].data);

		}

		kfree(cache->entry[i].actor);

	}



	kfree(cache->entry);
@@ -280,6 +281,13 @@ struct squashfs_cache *squashfs_cache_init(char *name, int entries, 
				goto cleanup;

			}

		}



		entry->actor = squashfs_page_actor_init(entry->data,

						cache->pages, 0);

		if (entry->actor == NULL) {

			ERROR("Failed to allocate %s cache entry\n", name);

			goto cleanup;

		}

	}



	return cache;
@@ -410,6 +418,7 @@ void *squashfs_read_table(struct super_block *sb, u64 block, int length) 
	int pages = (length + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;

	int i, res;

	void *table, *buffer, **data;

	struct squashfs_page_actor *actor;



	table = buffer = kmalloc(length, GFP_KERNEL);

	if (table == NULL)
@@ -421,19 +430,28 @@ void *squashfs_read_table(struct super_block *sb, u64 block, int length) 
		goto failed;

	}



	actor = squashfs_page_actor_init(data, pages, length);

	if (actor == NULL) {

		res = -ENOMEM;

		goto failed2;

	}



	for (i = 0; i < pages; i++, buffer += PAGE_CACHE_SIZE)

		data[i] = buffer;



	res = squashfs_read_data(sb, data, block, length |

		SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, length, pages);

	res = squashfs_read_data(sb, block, length |

		SQUASHFS_COMPRESSED_BIT_BLOCK, NULL, actor);



	kfree(data);

	kfree(actor);



	if (res < 0)

		goto failed;



	return table;



failed2:

	kfree(data);

failed:

	kfree(table);

	return ERR_PTR(res);

fs/squashfs/decompressor.c

+11 −3
Original line number Diff line number Diff line
@@ -30,6 +30,7 @@ 
#include "squashfs_fs_sb.h"

#include "decompressor.h"

#include "squashfs.h"

#include "page_actor.h"



/*

 * This file (and decompressor.h) implements a decompressor framework for
@@ -87,6 +88,7 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags) 
{

	struct squashfs_sb_info *msblk = sb->s_fs_info;

	void *buffer = NULL, *comp_opts;

	struct squashfs_page_actor *actor = NULL;

	int length = 0;



	/*
@@ -99,9 +101,14 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags) 
			goto out;

		}



		length = squashfs_read_data(sb, &buffer,

			sizeof(struct squashfs_super_block), 0, NULL,

				PAGE_CACHE_SIZE, 1);

		actor = squashfs_page_actor_init(&buffer, 1, 0);

		if (actor == NULL) {

			comp_opts = ERR_PTR(-ENOMEM);

			goto out;

		}



		length = squashfs_read_data(sb,

			sizeof(struct squashfs_super_block), 0, NULL, actor);



		if (length < 0) {

			comp_opts = ERR_PTR(length);
@@ -112,6 +119,7 @@ static void *get_comp_opts(struct super_block *sb, unsigned short flags) 
	comp_opts = squashfs_comp_opts(msblk, buffer, length);



out:

	kfree(actor);

	kfree(buffer);

	return comp_opts;

}

fs/squashfs/decompressor.h

+3 −2
Original line number Diff line number Diff line
@@ -27,8 +27,9 @@ struct squashfs_decompressor { 
	void	*(*init)(struct squashfs_sb_info *, void *);

	void	*(*comp_opts)(struct squashfs_sb_info *, void *, int);

	void	(*free)(void *);

	int	(*decompress)(struct squashfs_sb_info *, void *, void **,

		struct buffer_head **, int, int, int, int, int);

	int	(*decompress)(struct squashfs_sb_info *, void *,

		struct buffer_head **, int, int, int,

		struct squashfs_page_actor *);

	int	id;

	char	*name;

	int	supported;

fs/squashfs/decompressor_multi.c

+3 −4
Original line number Diff line number Diff line
@@ -183,15 +183,14 @@ wait: 
}





int squashfs_decompress(struct squashfs_sb_info *msblk,

	void **buffer, struct buffer_head **bh, int b, int offset, int length,

	int srclength, int pages)

int squashfs_decompress(struct squashfs_sb_info *msblk, struct buffer_head **bh,

	int b, int offset, int length, struct squashfs_page_actor *output)

{

	int res;

	struct squashfs_stream *stream = msblk->stream;

	struct decomp_stream *decomp_stream = get_decomp_stream(msblk, stream);

	res = msblk->decompressor->decompress(msblk, decomp_stream->stream,

		buffer, bh, b, offset, length, srclength, pages);

		bh, b, offset, length, output);

	put_decomp_stream(decomp_stream, stream);

	if (res < 0)

		ERROR("%s decompression failed, data probably corrupt\n",