Squashfs: move zlib decompression wrapper code into a separate file (e6a6d379) · Commits · e / devices / samsung / android_kernel_samsung_exynos7580-common

fs/squashfs/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -4,4 +4,4 @@

	obj-$(CONFIG_SQUASHFS) += squashfs.o		obj-$(CONFIG_SQUASHFS) += squashfs.o
	squashfs-y += block.o cache.o dir.o export.o file.o fragment.o id.o inode.o		squashfs-y += block.o cache.o dir.o export.o file.o fragment.o id.o inode.o
	squashfs-y += namei.o super.o symlink.o		squashfs-y += namei.o super.o symlink.o zlib_wrapper.o

fs/squashfs/block.c

+4 −70

Original line number	Original line	Diff line number	Diff line
	@@ -29,7 +29,6 @@
	#include <linux/fs.h>		#include <linux/fs.h>
	#include <linux/vfs.h>		#include <linux/vfs.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	#include <linux/mutex.h>
	#include <linux/string.h>		#include <linux/string.h>
	#include <linux/buffer_head.h>		#include <linux/buffer_head.h>
	#include <linux/zlib.h>		#include <linux/zlib.h>
	@@ -153,72 +152,10 @@ int squashfs_read_data(struct super_block sb, void *buffer, u64 index,
	}		}

	if (compressed) {		if (compressed) {
	int zlib_err = 0, zlib_init = 0;		length = squashfs_zlib_uncompress(msblk, buffer, bh, b, offset,
			length, srclength, pages);
	/*		if (length < 0)
	* Uncompress block.		goto read_failure;
	*/

	mutex_lock(&msblk->read_data_mutex);

	msblk->stream.avail_out = 0;
	msblk->stream.avail_in = 0;

	bytes = length;
	do {
	if (msblk->stream.avail_in == 0 && k < b) {
	avail = min(bytes, msblk->devblksize - offset);
	bytes -= avail;
	wait_on_buffer(bh[k]);
	if (!buffer_uptodate(bh[k]))
	goto release_mutex;

	if (avail == 0) {
	offset = 0;
	put_bh(bh[k++]);
	continue;
	}

	msblk->stream.next_in = bh[k]->b_data + offset;
	msblk->stream.avail_in = avail;
	offset = 0;
	}

	if (msblk->stream.avail_out == 0 && page < pages) {
	msblk->stream.next_out = buffer[page++];
	msblk->stream.avail_out = PAGE_CACHE_SIZE;
	}

	if (!zlib_init) {
	zlib_err = zlib_inflateInit(&msblk->stream);
	if (zlib_err != Z_OK) {
	ERROR("zlib_inflateInit returned"
	" unexpected result 0x%x,"
	" srclength %d\n", zlib_err,
	srclength);
	goto release_mutex;
	}
	zlib_init = 1;
	}

	zlib_err = zlib_inflate(&msblk->stream, Z_SYNC_FLUSH);

	if (msblk->stream.avail_in == 0 && k < b)
	put_bh(bh[k++]);
	} while (zlib_err == Z_OK);

	if (zlib_err != Z_STREAM_END) {
	ERROR("zlib_inflate error, data probably corrupt\n");
	goto release_mutex;
	}

	zlib_err = zlib_inflateEnd(&msblk->stream);
	if (zlib_err != Z_OK) {
	ERROR("zlib_inflate error, data probably corrupt\n");
	goto release_mutex;
	}
	length = msblk->stream.total_out;
	mutex_unlock(&msblk->read_data_mutex);
	} else {		} else {
	/*		/*
	* Block is uncompressed.		* Block is uncompressed.
	@@ -255,9 +192,6 @@ int squashfs_read_data(struct super_block sb, void *buffer, u64 index,
	kfree(bh);		kfree(bh);
	return length;		return length;

	release_mutex:
	mutex_unlock(&msblk->read_data_mutex);

	block_release:		block_release:
	for (; k < b; k++)		for (; k < b; k++)
	put_bh(bh[k]);		put_bh(bh[k]);

fs/squashfs/squashfs.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -70,6 +70,10 @@ extern struct inode squashfs_iget(struct super_block , long long,
	unsigned int);		unsigned int);
	extern int squashfs_read_inode(struct inode *, long long);		extern int squashfs_read_inode(struct inode *, long long);

			/* zlib_wrapper.c */
			extern int squashfs_zlib_uncompress(struct squashfs_sb_info , void *,
			struct buffer_head **, int, int, int, int, int);

	/*		/*
	* Inodes and files operations		* Inodes and files operations
	*/		*/

fs/squashfs/zlib_wrapper.c

0 → 100644

+109 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Squashfs - a compressed read only filesystem for Linux
			*
			* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
			* Phillip Lougher <phillip@lougher.demon.co.uk>
			*
			* This program is free software; you can redistribute it and/or
			* modify it under the terms of the GNU General Public License
			* as published by the Free Software Foundation; either version 2,
			* or (at your option) any later version.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*
			* You should have received a copy of the GNU General Public License
			* along with this program; if not, write to the Free Software
			* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
			*
			* zlib_wrapper.c
			*/


			#include <linux/mutex.h>
			#include <linux/buffer_head.h>
			#include <linux/zlib.h>

			#include "squashfs_fs.h"
			#include "squashfs_fs_sb.h"
			#include "squashfs_fs_i.h"
			#include "squashfs.h"

			int squashfs_zlib_uncompress(struct squashfs_sb_info msblk, void *buffer,
			struct buffer_head **bh, int b, int offset, int length, int srclength,
			int pages)
			{
			int zlib_err = 0, zlib_init = 0;
			int avail, bytes, k = 0, page = 0;

			mutex_lock(&msblk->read_data_mutex);

			msblk->stream.avail_out = 0;
			msblk->stream.avail_in = 0;

			bytes = length;
			do {
			if (msblk->stream.avail_in == 0 && k < b) {
			avail = min(bytes, msblk->devblksize - offset);
			bytes -= avail;
			wait_on_buffer(bh[k]);
			if (!buffer_uptodate(bh[k]))
			goto release_mutex;

			if (avail == 0) {
			offset = 0;
			put_bh(bh[k++]);
			continue;
			}

			msblk->stream.next_in = bh[k]->b_data + offset;
			msblk->stream.avail_in = avail;
			offset = 0;
			}

			if (msblk->stream.avail_out == 0 && page < pages) {
			msblk->stream.next_out = buffer[page++];
			msblk->stream.avail_out = PAGE_CACHE_SIZE;
			}

			if (!zlib_init) {
			zlib_err = zlib_inflateInit(&msblk->stream);
			if (zlib_err != Z_OK) {
			ERROR("zlib_inflateInit returned unexpected "
			"result 0x%x, srclength %d\n",
			zlib_err, srclength);
			goto release_mutex;
			}
			zlib_init = 1;
			}

			zlib_err = zlib_inflate(&msblk->stream, Z_SYNC_FLUSH);

			if (msblk->stream.avail_in == 0 && k < b)
			put_bh(bh[k++]);
			} while (zlib_err == Z_OK);

			if (zlib_err != Z_STREAM_END) {
			ERROR("zlib_inflate error, data probably corrupt\n");
			goto release_mutex;
			}

			zlib_err = zlib_inflateEnd(&msblk->stream);
			if (zlib_err != Z_OK) {
			ERROR("zlib_inflate error, data probably corrupt\n");
			goto release_mutex;
			}

			mutex_unlock(&msblk->read_data_mutex);
			return msblk->stream.total_out;

			release_mutex:
			mutex_unlock(&msblk->read_data_mutex);

			for (; k < b; k++)
			put_bh(bh[k]);

			return -EIO;
			}