[linux.git] / fs / isofs / compress.c

/* -*- linux-c -*- ------------------------------------------------------- *
 *   
 *   Copyright 2001 H. Peter Anvin - All Rights Reserved
 *
 *   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, Inc., 675 Mass Ave, Cambridge MA 02139,
 *   USA; either version 2 of the License, or (at your option) any later
 *   version; incorporated herein by reference.
 *
 * ----------------------------------------------------------------------- */

/*
 * linux/fs/isofs/compress.c
 *
 * Transparent decompression of files on an iso9660 filesystem
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/init.h>

#include <linux/vmalloc.h>
#include <linux/zlib.h>

#include "isofs.h"
#include "zisofs.h"

/* This should probably be global. */
static char zisofs_sink_page[PAGE_CACHE_SIZE];

/*
 * This contains the zlib memory allocation and the mutex for the
 * allocation; this avoids failures at block-decompression time.
 */
static void *zisofs_zlib_workspace;
static struct semaphore zisofs_zlib_semaphore;

/*
 * When decompressing, we typically obtain more than one page
 * per reference.  We inject the additional pages into the page
 * cache as a form of readahead.
 */
static int zisofs_readpage(struct file *file, struct page *page)
{
	struct inode *inode = file->f_dentry->d_inode;
	struct address_space *mapping = inode->i_mapping;
	unsigned int maxpage, xpage, fpage, blockindex;
	unsigned long offset;
	unsigned long blockptr, blockendptr, cstart, cend, csize;
	struct buffer_head *bh, *ptrbh[2];
	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
	unsigned long bufmask  = bufsize - 1;
	int err = -EIO;
	int i;
	unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
	unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
	/* unsigned long zisofs_block_size = 1UL << zisofs_block_shift; */
	unsigned int zisofs_block_page_shift = zisofs_block_shift-PAGE_CACHE_SHIFT;
	unsigned long zisofs_block_pages = 1UL << zisofs_block_page_shift;
	unsigned long zisofs_block_page_mask = zisofs_block_pages-1;
	struct page *pages[zisofs_block_pages];
	unsigned long index = page->index;
	int indexblocks;

	/* We have already been given one page, this is the one
	   we must do. */
	xpage = index & zisofs_block_page_mask;
	pages[xpage] = page;
 
	/* The remaining pages need to be allocated and inserted */
	offset = index & ~zisofs_block_page_mask;
	blockindex = offset >> zisofs_block_page_shift;
	maxpage = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	maxpage = min(zisofs_block_pages, maxpage-offset);

	for ( i = 0 ; i < maxpage ; i++, offset++ ) {
		if ( i != xpage ) {
			pages[i] = grab_cache_page_nowait(mapping, offset);
		}
		page = pages[i];
		if ( page ) {
			ClearPageError(page);
			kmap(page);
		}
	}

	/* This is the last page filled, plus one; used in case of abort. */
	fpage = 0;

	/* Find the pointer to this specific chunk */
	/* Note: we're not using isonum_731() here because the data is known aligned */
	/* Note: header_size is in 32-bit words (4 bytes) */
	blockptr = (header_size + blockindex) << 2;
	blockendptr = blockptr + 4;

	indexblocks = ((blockptr^blockendptr) >> bufshift) ? 2 : 1;
	ptrbh[0] = ptrbh[1] = NULL;

	if ( isofs_get_blocks(inode, blockptr >> bufshift, ptrbh, indexblocks) != indexblocks ) {
		if ( ptrbh[0] ) brelse(ptrbh[0]);
		printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %lu, block = %lu\n",
		       inode->i_ino, blockptr >> bufshift);
		goto eio;
	}
	ll_rw_block(READ, indexblocks, ptrbh);

	bh = ptrbh[0];
	if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
		printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
		       inode->i_ino, blockptr >> bufshift);
		if ( ptrbh[1] )
			brelse(ptrbh[1]);
		goto eio;
	}
	cstart = le32_to_cpu(*(__le32 *)(bh->b_data + (blockptr & bufmask)));

	if ( indexblocks == 2 ) {
		/* We just crossed a block boundary.  Switch to the next block */
		brelse(bh);
		bh = ptrbh[1];
		if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
			printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
			       inode->i_ino, blockendptr >> bufshift);
			goto eio;
		}
	}
	cend = le32_to_cpu(*(__le32 *)(bh->b_data + (blockendptr & bufmask)));
	brelse(bh);

	csize = cend-cstart;

	/* Now page[] contains an array of pages, any of which can be NULL,
	   and the locks on which we hold.  We should now read the data and
	   release the pages.  If the pages are NULL the decompressed data
	   for that particular page should be discarded. */
	
	if ( csize == 0 ) {
		/* This data block is empty. */

		for ( fpage = 0 ; fpage < maxpage ; fpage++ ) {
			if ( (page = pages[fpage]) != NULL ) {
				memset(page_address(page), 0, PAGE_CACHE_SIZE);
				
				flush_dcache_page(page);
				SetPageUptodate(page);
				kunmap(page);
				unlock_page(page);
				if ( fpage == xpage )
					err = 0; /* The critical page */
				else
					page_cache_release(page);
			}
		}
	} else {
		/* This data block is compressed. */
		z_stream stream;
		int bail = 0, left_out = -1;
		int zerr;
		int needblocks = (csize + (cstart & bufmask) + bufmask) >> bufshift;
		int haveblocks;
		struct buffer_head *bhs[needblocks+1];
		struct buffer_head **bhptr;

		/* Because zlib is not thread-safe, do all the I/O at the top. */

		blockptr = cstart >> bufshift;
		memset(bhs, 0, (needblocks+1)*sizeof(struct buffer_head *));
		haveblocks = isofs_get_blocks(inode, blockptr, bhs, needblocks);
		ll_rw_block(READ, haveblocks, bhs);

		bhptr = &bhs[0];
		bh = *bhptr++;

		/* First block is special since it may be fractional.
		   We also wait for it before grabbing the zlib
		   semaphore; odds are that the subsequent blocks are
		   going to come in in short order so we don't hold
		   the zlib semaphore longer than necessary. */

		if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
			printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
			       fpage, xpage, csize);
			goto b_eio;
		}
		stream.next_in  = bh->b_data + (cstart & bufmask);
		stream.avail_in = min(bufsize-(cstart & bufmask), csize);
		csize -= stream.avail_in;

		stream.workspace = zisofs_zlib_workspace;
		down(&zisofs_zlib_semaphore);
		
		zerr = zlib_inflateInit(&stream);
		if ( zerr != Z_OK ) {
			if ( err && zerr == Z_MEM_ERROR )
				err = -ENOMEM;
			printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
			       zerr);
			goto z_eio;
		}

		while ( !bail && fpage < maxpage ) {
			page = pages[fpage];
			if ( page )
				stream.next_out = page_address(page);
			else
				stream.next_out = (void *)&zisofs_sink_page;
			stream.avail_out = PAGE_CACHE_SIZE;

			while ( stream.avail_out ) {
				int ao, ai;
				if ( stream.avail_in == 0 && left_out ) {
					if ( !csize ) {
						printk(KERN_WARNING "zisofs: ZF read beyond end of input\n");
						bail = 1;
						break;
					} else {
						bh = *bhptr++;
						if ( !bh ||
						     (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
							/* Reached an EIO */
 							printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
							       fpage, xpage, csize);
							       
							bail = 1;
							break;
						}
						stream.next_in = bh->b_data;
						stream.avail_in = min(csize,bufsize);
						csize -= stream.avail_in;
					}
				}
				ao = stream.avail_out;  ai = stream.avail_in;
				zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
				left_out = stream.avail_out;
				if ( zerr == Z_BUF_ERROR && stream.avail_in == 0 )
					continue;
				if ( zerr != Z_OK ) {
					/* EOF, error, or trying to read beyond end of input */
					if ( err && zerr == Z_MEM_ERROR )
						err = -ENOMEM;
					if ( zerr != Z_STREAM_END )
						printk(KERN_DEBUG "zisofs: zisofs_inflate returned %d, inode = %lu, index = %lu, fpage = %d, xpage = %d, avail_in = %d, avail_out = %d, ai = %d, ao = %d\n",
						       zerr, inode->i_ino, index,
						       fpage, xpage,
						       stream.avail_in, stream.avail_out,
						       ai, ao);
					bail = 1;
					break;
				}
			}

			if ( stream.avail_out && zerr == Z_STREAM_END ) {
				/* Fractional page written before EOF.  This may
				   be the last page in the file. */
				memset(stream.next_out, 0, stream.avail_out);
				stream.avail_out = 0;
			}

			if ( !stream.avail_out ) {
				/* This page completed */
				if ( page ) {
					flush_dcache_page(page);
					SetPageUptodate(page);
					kunmap(page);
					unlock_page(page);
					if ( fpage == xpage )
						err = 0; /* The critical page */
					else
						page_cache_release(page);
				}
				fpage++;
			}
		}
		zlib_inflateEnd(&stream);

	z_eio:
		up(&zisofs_zlib_semaphore);

	b_eio:
		for ( i = 0 ; i < haveblocks ; i++ ) {
			if ( bhs[i] )
				brelse(bhs[i]);
		}
	}

eio:

	/* Release any residual pages, do not SetPageUptodate */
	while ( fpage < maxpage ) {
		page = pages[fpage];
		if ( page ) {
			flush_dcache_page(page);
			if ( fpage == xpage )
				SetPageError(page);
			kunmap(page);
			unlock_page(page);
			if ( fpage != xpage )
				page_cache_release(page);
		}
		fpage++;
	}			

	/* At this point, err contains 0 or -EIO depending on the "critical" page */
	return err;
}

struct address_space_operations zisofs_aops = {
	.readpage = zisofs_readpage,
	/* No sync_page operation supported? */
	/* No bmap operation supported */
};

static int initialized;

int __init zisofs_init(void)
{
	if ( initialized ) {
		printk("zisofs_init: called more than once\n");
		return 0;
	}

	zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
	if ( !zisofs_zlib_workspace )
		return -ENOMEM;
	init_MUTEX(&zisofs_zlib_semaphore);

	initialized = 1;
	return 0;
}

void zisofs_cleanup(void)
{
	if ( !initialized ) {
		printk("zisofs_cleanup: called without initialization\n");
		return;
	}

	vfree(zisofs_zlib_workspace);
	initialized = 0;
}
Commit	Line	Data
1da177e4 LT	1	/* -- linux-c -- ------------------------------------------------------- *
	2	*
	3	* Copyright 2001 H. Peter Anvin - All Rights Reserved
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
	8	* USA; either version 2 of the License, or (at your option) any later
	9	* version; incorporated herein by reference.
	10	*
	11	* ----------------------------------------------------------------------- */
	12
	13	/*
	14	* linux/fs/isofs/compress.c
	15	*
	16	* Transparent decompression of files on an iso9660 filesystem
	17	*/
	18
	19	#include <linux/config.h>
	20	#include <linux/module.h>
1da177e4	21	#include <linux/init.h>
94f2f715	22
1da177e4 LT	23	#include <linux/vmalloc.h>
1da177e4 LT	24	#include <linux/zlib.h>
1da177e4	25
94f2f715	26	#include "isofs.h"
1da177e4 LT	27	#include "zisofs.h"
	28
	29	/* This should probably be global. */
	30	static char zisofs_sink_page[PAGE_CACHE_SIZE];
	31
	32	/*
	33	* This contains the zlib memory allocation and the mutex for the
	34	* allocation; this avoids failures at block-decompression time.
	35	*/
	36	static void *zisofs_zlib_workspace;
	37	static struct semaphore zisofs_zlib_semaphore;
	38
	39	/*
	40	* When decompressing, we typically obtain more than one page
	41	* per reference. We inject the additional pages into the page
	42	* cache as a form of readahead.
	43	*/
	44	static int zisofs_readpage(struct file file, struct page page)
	45	{
	46	struct inode *inode = file->f_dentry->d_inode;
	47	struct address_space *mapping = inode->i_mapping;
	48	unsigned int maxpage, xpage, fpage, blockindex;
	49	unsigned long offset;
	50	unsigned long blockptr, blockendptr, cstart, cend, csize;
	51	struct buffer_head bh, ptrbh[2];
	52	unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
	53	unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
	54	unsigned long bufmask = bufsize - 1;
	55	int err = -EIO;
	56	int i;
	57	unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
	58	unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
	59	/* unsigned long zisofs_block_size = 1UL << zisofs_block_shift; */
	60	unsigned int zisofs_block_page_shift = zisofs_block_shift-PAGE_CACHE_SHIFT;
	61	unsigned long zisofs_block_pages = 1UL << zisofs_block_page_shift;
	62	unsigned long zisofs_block_page_mask = zisofs_block_pages-1;
	63	struct page *pages[zisofs_block_pages];
	64	unsigned long index = page->index;
	65	int indexblocks;
	66
	67	/* We have already been given one page, this is the one
	68	we must do. */
	69	xpage = index & zisofs_block_page_mask;
	70	pages[xpage] = page;
	71
	72	/* The remaining pages need to be allocated and inserted */
	73	offset = index & ~zisofs_block_page_mask;
	74	blockindex = offset >> zisofs_block_page_shift;
	75	maxpage = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
	76	maxpage = min(zisofs_block_pages, maxpage-offset);
	77
	78	for ( i = 0 ; i < maxpage ; i++, offset++ ) {
	79	if ( i != xpage ) {
	80	pages[i] = grab_cache_page_nowait(mapping, offset);
	81	}
	82	page = pages[i];
	83	if ( page ) {
	84	ClearPageError(page);
	85	kmap(page);
	86	}
	87	}
	88
	89	/* This is the last page filled, plus one; used in case of abort. */
	90	fpage = 0;
91
92	/* Find the pointer to this specific chunk */
93	/* Note: we're not using isonum_731() here because the data is known aligned */
94	/* Note: header_size is in 32-bit words (4 bytes) */
95	blockptr = (header_size + blockindex) << 2;
96	blockendptr = blockptr + 4;
97
98	indexblocks = ((blockptr^blockendptr) >> bufshift) ? 2 : 1;
99	ptrbh[0] = ptrbh[1] = NULL;
100
101	if ( isofs_get_blocks(inode, blockptr >> bufshift, ptrbh, indexblocks) != indexblocks ) {
102	if ( ptrbh[0] ) brelse(ptrbh[0]);
103	printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %lu, block = %lu\n",
104	inode->i_ino, blockptr >> bufshift);
105	goto eio;
106	}
107	ll_rw_block(READ, indexblocks, ptrbh);
108
109	bh = ptrbh[0];
110	if ( !bh \|\| (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
111	printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
112	inode->i_ino, blockptr >> bufshift);
113	if ( ptrbh[1] )
114	brelse(ptrbh[1]);
115	goto eio;
116	}
117	cstart = le32_to_cpu((__le32 )(bh->b_data + (blockptr & bufmask)));
118
119	if ( indexblocks == 2 ) {
120	/* We just crossed a block boundary. Switch to the next block */
121	brelse(bh);
122	bh = ptrbh[1];
123	if ( !bh \|\| (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
124	printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
125	inode->i_ino, blockendptr >> bufshift);
126	goto eio;
127	}
128	}
129	cend = le32_to_cpu((__le32 )(bh->b_data + (blockendptr & bufmask)));
130	brelse(bh);
131
132	csize = cend-cstart;
133
134	/* Now page[] contains an array of pages, any of which can be NULL,
135	and the locks on which we hold. We should now read the data and
136	release the pages. If the pages are NULL the decompressed data
137	for that particular page should be discarded. */
138
139	if ( csize == 0 ) {
140	/* This data block is empty. */
141
142	for ( fpage = 0 ; fpage < maxpage ; fpage++ ) {
143	if ( (page = pages[fpage]) != NULL ) {
144	memset(page_address(page), 0, PAGE_CACHE_SIZE);
145
146	flush_dcache_page(page);
147	SetPageUptodate(page);
148	kunmap(page);
149	unlock_page(page);
150	if ( fpage == xpage )
151	err = 0; /* The critical page */
152	else
153	page_cache_release(page);
154	}
155	}
156	} else {
157	/* This data block is compressed. */
158	z_stream stream;
159	int bail = 0, left_out = -1;
160	int zerr;
161	int needblocks = (csize + (cstart & bufmask) + bufmask) >> bufshift;
162	int haveblocks;
163	struct buffer_head *bhs[needblocks+1];
164	struct buffer_head **bhptr;
165
166	/* Because zlib is not thread-safe, do all the I/O at the top. */
167
168	blockptr = cstart >> bufshift;
169	memset(bhs, 0, (needblocks+1)sizeof(struct buffer_head ));
170	haveblocks = isofs_get_blocks(inode, blockptr, bhs, needblocks);
171	ll_rw_block(READ, haveblocks, bhs);
172
173	bhptr = &bhs[0];
174	bh = *bhptr++;
175
176	/* First block is special since it may be fractional.
177	We also wait for it before grabbing the zlib
178	semaphore; odds are that the subsequent blocks are
179	going to come in in short order so we don't hold
180	the zlib semaphore longer than necessary. */
181
182	if ( !bh \|\| (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
183	printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
184	fpage, xpage, csize);
185	goto b_eio;
186	}
187	stream.next_in = bh->b_data + (cstart & bufmask);
188	stream.avail_in = min(bufsize-(cstart & bufmask), csize);
189	csize -= stream.avail_in;
190
191	stream.workspace = zisofs_zlib_workspace;
192	down(&zisofs_zlib_semaphore);
193
194	zerr = zlib_inflateInit(&stream);
195	if ( zerr != Z_OK ) {
196	if ( err && zerr == Z_MEM_ERROR )
197	err = -ENOMEM;
198	printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
199	zerr);
200	goto z_eio;
201	}
202
203	while ( !bail && fpage < maxpage ) {
204	page = pages[fpage];
205	if ( page )
206	stream.next_out = page_address(page);
207	else
208	stream.next_out = (void *)&zisofs_sink_page;
209	stream.avail_out = PAGE_CACHE_SIZE;
210
211	while ( stream.avail_out ) {
212	int ao, ai;
213	if ( stream.avail_in == 0 && left_out ) {
214	if ( !csize ) {
215	printk(KERN_WARNING "zisofs: ZF read beyond end of input\n");
216	bail = 1;
217	break;
218	} else {
219	bh = *bhptr++;
220	if ( !bh \|\|
221	(wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
222	/* Reached an EIO */
223	printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
224	fpage, xpage, csize);
225
226	bail = 1;
227	break;
228	}
229	stream.next_in = bh->b_data;
230	stream.avail_in = min(csize,bufsize);
231	csize -= stream.avail_in;
232	}
233	}
234	ao = stream.avail_out; ai = stream.avail_in;
235	zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
236	left_out = stream.avail_out;
237	if ( zerr == Z_BUF_ERROR && stream.avail_in == 0 )
238	continue;
239	if ( zerr != Z_OK ) {
240	/* EOF, error, or trying to read beyond end of input */
241	if ( err && zerr == Z_MEM_ERROR )
242	err = -ENOMEM;
243	if ( zerr != Z_STREAM_END )
244	printk(KERN_DEBUG "zisofs: zisofs_inflate returned %d, inode = %lu, index = %lu, fpage = %d, xpage = %d, avail_in = %d, avail_out = %d, ai = %d, ao = %d\n",
245	zerr, inode->i_ino, index,
246	fpage, xpage,
247	stream.avail_in, stream.avail_out,
248	ai, ao);
249	bail = 1;
250	break;
251	}
252	}
253
254	if ( stream.avail_out && zerr == Z_STREAM_END ) {
255	/* Fractional page written before EOF. This may
256	be the last page in the file. */
257	memset(stream.next_out, 0, stream.avail_out);
258	stream.avail_out = 0;
259	}
260
261	if ( !stream.avail_out ) {
262	/* This page completed */
263	if ( page ) {
264	flush_dcache_page(page);
265	SetPageUptodate(page);
266	kunmap(page);
267	unlock_page(page);
268	if ( fpage == xpage )
269	err = 0; /* The critical page */
270	else
271	page_cache_release(page);
272	}
273	fpage++;
274	}
275	}
276	zlib_inflateEnd(&stream);
277
278	z_eio:
279	up(&zisofs_zlib_semaphore);
280
281	b_eio:
282	for ( i = 0 ; i < haveblocks ; i++ ) {
283	if ( bhs[i] )
284	brelse(bhs[i]);
285	}
286	}
287
288	eio:
289
290	/* Release any residual pages, do not SetPageUptodate */
291	while ( fpage < maxpage ) {
292	page = pages[fpage];
293	if ( page ) {
294	flush_dcache_page(page);
295	if ( fpage == xpage )
296	SetPageError(page);
297	kunmap(page);
298	unlock_page(page);
299	if ( fpage != xpage )
300	page_cache_release(page);
301	}
302	fpage++;
303	}
304
305	/* At this point, err contains 0 or -EIO depending on the "critical" page */
306	return err;
307	}
308
309	struct address_space_operations zisofs_aops = {
310	.readpage = zisofs_readpage,
311	/* No sync_page operation supported? */
312	/* No bmap operation supported */
313	};
314
315	static int initialized;
316
317	int __init zisofs_init(void)
318	{
319	if ( initialized ) {
320	printk("zisofs_init: called more than once\n");
321	return 0;
322	}
323
324	zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
325	if ( !zisofs_zlib_workspace )
326	return -ENOMEM;
327	init_MUTEX(&zisofs_zlib_semaphore);
328
329	initialized = 1;
330	return 0;
331	}
332
333	void zisofs_cleanup(void)
334	{
335	if ( !initialized ) {
336	printk("zisofs_cleanup: called without initialization\n");
337	return;
338	}
339
340	vfree(zisofs_zlib_workspace);
341	initialized = 0;
342	}