blob: 6bbbdb53581d1bb42b1db87f88a4de9799b82808 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* -*- 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/init.h>
Al Viro94f2f7152005-04-25 18:32:12 -070021
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/vmalloc.h>
23#include <linux/zlib.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Al Viro94f2f7152005-04-25 18:32:12 -070025#include "isofs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "zisofs.h"
27
28/* This should probably be global. */
29static 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 */
35static void *zisofs_zlib_workspace;
36static struct semaphore zisofs_zlib_semaphore;
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 */
43static int zisofs_readpage(struct file *file, struct page *page)
44{
Josef "Jeff" Sipek24858222006-12-08 02:36:40 -080045 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 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
Linus Torvaldsfab5a602005-08-06 09:42:06 -0700131 if (cstart > cend)
132 goto eio;
133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 csize = cend-cstart;
135
Linus Torvaldsfab5a602005-08-06 09:42:06 -0700136 if (csize > deflateBound(1UL << zisofs_block_shift))
137 goto eio;
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 /* 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
183 semaphore; odds are that the subsequent blocks are
184 going to come in in short order so we don't hold
185 the zlib semaphore longer than necessary. */
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;
197 down(&zisofs_zlib_semaphore);
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:
284 up(&zisofs_zlib_semaphore);
285
286 b_eio:
287 for ( i = 0 ; i < haveblocks ; i++ ) {
288 if ( bhs[i] )
289 brelse(bhs[i]);
290 }
291 }
292
293eio:
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
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700314const struct address_space_operations zisofs_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 .readpage = zisofs_readpage,
316 /* No sync_page operation supported? */
317 /* No bmap operation supported */
318};
319
320static int initialized;
321
322int __init zisofs_init(void)
323{
324 if ( initialized ) {
325 printk("zisofs_init: called more than once\n");
326 return 0;
327 }
328
329 zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
330 if ( !zisofs_zlib_workspace )
331 return -ENOMEM;
332 init_MUTEX(&zisofs_zlib_semaphore);
333
334 initialized = 1;
335 return 0;
336}
337
338void zisofs_cleanup(void)
339{
340 if ( !initialized ) {
341 printk("zisofs_cleanup: called without initialization\n");
342 return;
343 }
344
345 vfree(zisofs_zlib_workspace);
346 initialized = 0;
347}