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/module.h>
20 #include <linux/init.h>
21 #include <linux/bio.h>
22
23 #include <linux/slab.h>
24 #include <linux/vmalloc.h>
25 #include <linux/zlib.h>
26
27 #include "isofs.h"
28 #include "zisofs.h"
29
30 /* This should probably be global. */
31 static char zisofs_sink_page[PAGE_SIZE];
32
33 /*
34 * This contains the zlib memory allocation and the mutex for the
35 * allocation; this avoids failures at block-decompression time.
36 */
37 static void *zisofs_zlib_workspace;
38 static DEFINE_MUTEX(zisofs_zlib_lock);
39
40 /*
41 * Read data of @inode from @block_start to @block_end and uncompress
42 * to one zisofs block. Store the data in the @pages array with @pcount
43 * entries. Start storing at offset @poffset of the first page.
44 */
zisofs_uncompress_block(struct inode * inode,loff_t block_start,loff_t block_end,int pcount,struct page ** pages,unsigned poffset,int * errp)45 static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start,
46 loff_t block_end, int pcount,
47 struct page **pages, unsigned poffset,
48 int *errp)
49 {
50 unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
51 unsigned int bufsize = ISOFS_BUFFER_SIZE(inode);
52 unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
53 unsigned int bufmask = bufsize - 1;
54 int i, block_size = block_end - block_start;
55 z_stream stream = { .total_out = 0,
56 .avail_in = 0,
57 .avail_out = 0, };
58 int zerr;
59 int needblocks = (block_size + (block_start & bufmask) + bufmask)
60 >> bufshift;
61 int haveblocks;
62 blkcnt_t blocknum;
63 struct buffer_head **bhs;
64 int curbh, curpage;
65
66 if (block_size > deflateBound(1UL << zisofs_block_shift)) {
67 *errp = -EIO;
68 return 0;
69 }
70 /* Empty block? */
71 if (block_size == 0) {
72 for ( i = 0 ; i < pcount ; i++ ) {
73 if (!pages[i])
74 continue;
75 memset(page_address(pages[i]), 0, PAGE_SIZE);
76 flush_dcache_page(pages[i]);
77 SetPageUptodate(pages[i]);
78 }
79 return ((loff_t)pcount) << PAGE_SHIFT;
80 }
81
82 /* Because zlib is not thread-safe, do all the I/O at the top. */
83 blocknum = block_start >> bufshift;
84 bhs = kcalloc(needblocks + 1, sizeof(*bhs), GFP_KERNEL);
85 if (!bhs) {
86 *errp = -ENOMEM;
87 return 0;
88 }
89 haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks);
90 ll_rw_block(REQ_OP_READ, 0, haveblocks, bhs);
91
92 curbh = 0;
93 curpage = 0;
94 /*
95 * First block is special since it may be fractional. We also wait for
96 * it before grabbing the zlib mutex; odds are that the subsequent
97 * blocks are going to come in in short order so we don't hold the zlib
98 * mutex longer than necessary.
99 */
100
101 if (!bhs[0])
102 goto b_eio;
103
104 wait_on_buffer(bhs[0]);
105 if (!buffer_uptodate(bhs[0])) {
106 *errp = -EIO;
107 goto b_eio;
108 }
109
110 stream.workspace = zisofs_zlib_workspace;
111 mutex_lock(&zisofs_zlib_lock);
112
113 zerr = zlib_inflateInit(&stream);
114 if (zerr != Z_OK) {
115 if (zerr == Z_MEM_ERROR)
116 *errp = -ENOMEM;
117 else
118 *errp = -EIO;
119 printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
120 zerr);
121 goto z_eio;
122 }
123
124 while (curpage < pcount && curbh < haveblocks &&
125 zerr != Z_STREAM_END) {
126 if (!stream.avail_out) {
127 if (pages[curpage]) {
128 stream.next_out = page_address(pages[curpage])
129 + poffset;
130 stream.avail_out = PAGE_SIZE - poffset;
131 poffset = 0;
132 } else {
133 stream.next_out = (void *)&zisofs_sink_page;
134 stream.avail_out = PAGE_SIZE;
135 }
136 }
137 if (!stream.avail_in) {
138 wait_on_buffer(bhs[curbh]);
139 if (!buffer_uptodate(bhs[curbh])) {
140 *errp = -EIO;
141 break;
142 }
143 stream.next_in = bhs[curbh]->b_data +
144 (block_start & bufmask);
145 stream.avail_in = min_t(unsigned, bufsize -
146 (block_start & bufmask),
147 block_size);
148 block_size -= stream.avail_in;
149 block_start = 0;
150 }
151
152 while (stream.avail_out && stream.avail_in) {
153 zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
154 if (zerr == Z_BUF_ERROR && stream.avail_in == 0)
155 break;
156 if (zerr == Z_STREAM_END)
157 break;
158 if (zerr != Z_OK) {
159 /* EOF, error, or trying to read beyond end of input */
160 if (zerr == Z_MEM_ERROR)
161 *errp = -ENOMEM;
162 else {
163 printk(KERN_DEBUG
164 "zisofs: zisofs_inflate returned"
165 " %d, inode = %lu,"
166 " page idx = %d, bh idx = %d,"
167 " avail_in = %ld,"
168 " avail_out = %ld\n",
169 zerr, inode->i_ino, curpage,
170 curbh, stream.avail_in,
171 stream.avail_out);
172 *errp = -EIO;
173 }
174 goto inflate_out;
175 }
176 }
177
178 if (!stream.avail_out) {
179 /* This page completed */
180 if (pages[curpage]) {
181 flush_dcache_page(pages[curpage]);
182 SetPageUptodate(pages[curpage]);
183 }
184 curpage++;
185 }
186 if (!stream.avail_in)
187 curbh++;
188 }
189 inflate_out:
190 zlib_inflateEnd(&stream);
191
192 z_eio:
193 mutex_unlock(&zisofs_zlib_lock);
194
195 b_eio:
196 for (i = 0; i < haveblocks; i++)
197 brelse(bhs[i]);
198 kfree(bhs);
199 return stream.total_out;
200 }
201
202 /*
203 * Uncompress data so that pages[full_page] is fully uptodate and possibly
204 * fills in other pages if we have data for them.
205 */
zisofs_fill_pages(struct inode * inode,int full_page,int pcount,struct page ** pages)206 static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount,
207 struct page **pages)
208 {
209 loff_t start_off, end_off;
210 loff_t block_start, block_end;
211 unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
212 unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
213 unsigned int blockptr;
214 loff_t poffset = 0;
215 blkcnt_t cstart_block, cend_block;
216 struct buffer_head *bh;
217 unsigned int blkbits = ISOFS_BUFFER_BITS(inode);
218 unsigned int blksize = 1 << blkbits;
219 int err;
220 loff_t ret;
221
222 BUG_ON(!pages[full_page]);
223
224 /*
225 * We want to read at least 'full_page' page. Because we have to
226 * uncompress the whole compression block anyway, fill the surrounding
227 * pages with the data we have anyway...
228 */
229 start_off = page_offset(pages[full_page]);
230 end_off = min_t(loff_t, start_off + PAGE_SIZE, inode->i_size);
231
232 cstart_block = start_off >> zisofs_block_shift;
233 cend_block = (end_off + (1 << zisofs_block_shift) - 1)
234 >> zisofs_block_shift;
235
236 WARN_ON(start_off - (full_page << PAGE_SHIFT) !=
237 ((cstart_block << zisofs_block_shift) & PAGE_MASK));
238
239 /* Find the pointer to this specific chunk */
240 /* Note: we're not using isonum_731() here because the data is known aligned */
241 /* Note: header_size is in 32-bit words (4 bytes) */
242 blockptr = (header_size + cstart_block) << 2;
243 bh = isofs_bread(inode, blockptr >> blkbits);
244 if (!bh)
245 return -EIO;
246 block_start = le32_to_cpu(*(__le32 *)
247 (bh->b_data + (blockptr & (blksize - 1))));
248
249 while (cstart_block < cend_block && pcount > 0) {
250 /* Load end of the compressed block in the file */
251 blockptr += 4;
252 /* Traversed to next block? */
253 if (!(blockptr & (blksize - 1))) {
254 brelse(bh);
255
256 bh = isofs_bread(inode, blockptr >> blkbits);
257 if (!bh)
258 return -EIO;
259 }
260 block_end = le32_to_cpu(*(__le32 *)
261 (bh->b_data + (blockptr & (blksize - 1))));
262 if (block_start > block_end) {
263 brelse(bh);
264 return -EIO;
265 }
266 err = 0;
267 ret = zisofs_uncompress_block(inode, block_start, block_end,
268 pcount, pages, poffset, &err);
269 poffset += ret;
270 pages += poffset >> PAGE_SHIFT;
271 pcount -= poffset >> PAGE_SHIFT;
272 full_page -= poffset >> PAGE_SHIFT;
273 poffset &= ~PAGE_MASK;
274
275 if (err) {
276 brelse(bh);
277 /*
278 * Did we finish reading the page we really wanted
279 * to read?
280 */
281 if (full_page < 0)
282 return 0;
283 return err;
284 }
285
286 block_start = block_end;
287 cstart_block++;
288 }
289
290 if (poffset && *pages) {
291 memset(page_address(*pages) + poffset, 0,
292 PAGE_SIZE - poffset);
293 flush_dcache_page(*pages);
294 SetPageUptodate(*pages);
295 }
296 return 0;
297 }
298
299 /*
300 * When decompressing, we typically obtain more than one page
301 * per reference. We inject the additional pages into the page
302 * cache as a form of readahead.
303 */
zisofs_readpage(struct file * file,struct page * page)304 static int zisofs_readpage(struct file *file, struct page *page)
305 {
306 struct inode *inode = file_inode(file);
307 struct address_space *mapping = inode->i_mapping;
308 int err;
309 int i, pcount, full_page;
310 unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
311 unsigned int zisofs_pages_per_cblock =
312 PAGE_SHIFT <= zisofs_block_shift ?
313 (1 << (zisofs_block_shift - PAGE_SHIFT)) : 0;
314 struct page **pages;
315 pgoff_t index = page->index, end_index;
316
317 end_index = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
318 /*
319 * If this page is wholly outside i_size we just return zero;
320 * do_generic_file_read() will handle this for us
321 */
322 if (index >= end_index) {
323 SetPageUptodate(page);
324 unlock_page(page);
325 return 0;
326 }
327
328 if (PAGE_SHIFT <= zisofs_block_shift) {
329 /* We have already been given one page, this is the one
330 we must do. */
331 full_page = index & (zisofs_pages_per_cblock - 1);
332 pcount = min_t(int, zisofs_pages_per_cblock,
333 end_index - (index & ~(zisofs_pages_per_cblock - 1)));
334 index -= full_page;
335 } else {
336 full_page = 0;
337 pcount = 1;
338 }
339 pages = kcalloc(max_t(unsigned int, zisofs_pages_per_cblock, 1),
340 sizeof(*pages), GFP_KERNEL);
341 if (!pages) {
342 unlock_page(page);
343 return -ENOMEM;
344 }
345 pages[full_page] = page;
346
347 for (i = 0; i < pcount; i++, index++) {
348 if (i != full_page)
349 pages[i] = grab_cache_page_nowait(mapping, index);
350 if (pages[i]) {
351 ClearPageError(pages[i]);
352 kmap(pages[i]);
353 }
354 }
355
356 err = zisofs_fill_pages(inode, full_page, pcount, pages);
357
358 /* Release any residual pages, do not SetPageUptodate */
359 for (i = 0; i < pcount; i++) {
360 if (pages[i]) {
361 flush_dcache_page(pages[i]);
362 if (i == full_page && err)
363 SetPageError(pages[i]);
364 kunmap(pages[i]);
365 unlock_page(pages[i]);
366 if (i != full_page)
367 put_page(pages[i]);
368 }
369 }
370
371 /* At this point, err contains 0 or -EIO depending on the "critical" page */
372 kfree(pages);
373 return err;
374 }
375
376 const struct address_space_operations zisofs_aops = {
377 .readpage = zisofs_readpage,
378 /* No bmap operation supported */
379 };
380
zisofs_init(void)381 int __init zisofs_init(void)
382 {
383 zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
384 if ( !zisofs_zlib_workspace )
385 return -ENOMEM;
386
387 return 0;
388 }
389
zisofs_cleanup(void)390 void zisofs_cleanup(void)
391 {
392 vfree(zisofs_zlib_workspace);
393 }
394