[linux-2.6-block.git] / fs / squashfs / zlib_wrapper.c

/*
 * 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;
}
Commit	Line	Data
e6a6d379 PL	1	/*
	2	* Squashfs - a compressed read only filesystem for Linux
	3	*
	4	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
	5	* Phillip Lougher <phillip@lougher.demon.co.uk>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version 2,
	10	* or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	20	*
	21	* zlib_wrapper.c
	22	*/
	23
	24
	25	#include <linux/mutex.h>
	26	#include <linux/buffer_head.h>
	27	#include <linux/zlib.h>
	28
	29	#include "squashfs_fs.h"
	30	#include "squashfs_fs_sb.h"
	31	#include "squashfs_fs_i.h"
	32	#include "squashfs.h"
	33
	34	int squashfs_zlib_uncompress(struct squashfs_sb_info msblk, void *buffer,
	35	struct buffer_head **bh, int b, int offset, int length, int srclength,
	36	int pages)
	37	{
	38	int zlib_err = 0, zlib_init = 0;
	39	int avail, bytes, k = 0, page = 0;
	40
	41	mutex_lock(&msblk->read_data_mutex);
	42
	43	msblk->stream.avail_out = 0;
	44	msblk->stream.avail_in = 0;
	45
	46	bytes = length;
	47	do {
	48	if (msblk->stream.avail_in == 0 && k < b) {
	49	avail = min(bytes, msblk->devblksize - offset);
	50	bytes -= avail;
	51	wait_on_buffer(bh[k]);
	52	if (!buffer_uptodate(bh[k]))
	53	goto release_mutex;
	54
	55	if (avail == 0) {
	56	offset = 0;
	57	put_bh(bh[k++]);
	58	continue;
	59	}
	60
	61	msblk->stream.next_in = bh[k]->b_data + offset;
	62	msblk->stream.avail_in = avail;
	63	offset = 0;
	64	}
65
66	if (msblk->stream.avail_out == 0 && page < pages) {
67	msblk->stream.next_out = buffer[page++];
68	msblk->stream.avail_out = PAGE_CACHE_SIZE;
69	}
70
71	if (!zlib_init) {
72	zlib_err = zlib_inflateInit(&msblk->stream);
73	if (zlib_err != Z_OK) {
74	ERROR("zlib_inflateInit returned unexpected "
75	"result 0x%x, srclength %d\n",
76	zlib_err, srclength);
77	goto release_mutex;
78	}
79	zlib_init = 1;
80	}
81
82	zlib_err = zlib_inflate(&msblk->stream, Z_SYNC_FLUSH);
83
84	if (msblk->stream.avail_in == 0 && k < b)
85	put_bh(bh[k++]);
86	} while (zlib_err == Z_OK);
87
88	if (zlib_err != Z_STREAM_END) {
89	ERROR("zlib_inflate error, data probably corrupt\n");
90	goto release_mutex;
91	}
92
93	zlib_err = zlib_inflateEnd(&msblk->stream);
94	if (zlib_err != Z_OK) {
95	ERROR("zlib_inflate error, data probably corrupt\n");
96	goto release_mutex;
97	}
98
99	mutex_unlock(&msblk->read_data_mutex);
100	return msblk->stream.total_out;
101
102	release_mutex:
103	mutex_unlock(&msblk->read_data_mutex);
104
105	for (; k < b; k++)
106	put_bh(bh[k]);
107
108	return -EIO;
109	}