[deliverable/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/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 DEFINE_MUTEX(zisofs_zlib_lock);

/*
 * 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_path.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);

	if (cstart > cend)
		goto eio;
		
	csize = cend-cstart;

	if (csize > deflateBound(1UL << zisofs_block_shift))
		goto eio;

	/* 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
		   mutex; odds are that the subsequent blocks are
		   going to come in in short order so we don't hold
		   the zlib mutex 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;
		mutex_lock(&zisofs_zlib_lock);
		
		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:
		mutex_unlock(&zisofs_zlib_lock);

	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;
}

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

int __init zisofs_init(void)
{
	zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
	if ( !zisofs_zlib_workspace )
		return -ENOMEM;

	return 0;
}

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