1 /* -*- linux-c -*- ------------------------------------------------------- *
3 * Copyright 2001 H. Peter Anvin - All Rights Reserved
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.
11 * ----------------------------------------------------------------------- */
14 * linux/fs/isofs/compress.c
16 * Transparent decompression of files on an iso9660 filesystem
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/bio.h>
23 #include <linux/slab.h>
24 #include <linux/vmalloc.h>
25 #include <linux/zlib.h>
30 /* This should probably be global. */
31 static char zisofs_sink_page
[PAGE_SIZE
];
34 * This contains the zlib memory allocation and the mutex for the
35 * allocation; this avoids failures at block-decompression time.
37 static void *zisofs_zlib_workspace
;
38 static DEFINE_MUTEX(zisofs_zlib_lock
);
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.
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
,
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,
59 int needblocks
= (block_size
+ (block_start
& bufmask
) + bufmask
)
63 struct buffer_head
**bhs
;
66 if (block_size
> deflateBound(1UL << zisofs_block_shift
)) {
71 if (block_size
== 0) {
72 for ( i
= 0 ; i
< pcount
; i
++ ) {
75 memset(page_address(pages
[i
]), 0, PAGE_SIZE
);
76 flush_dcache_page(pages
[i
]);
77 SetPageUptodate(pages
[i
]);
79 return ((loff_t
)pcount
) << PAGE_SHIFT
;
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
);
89 haveblocks
= isofs_get_blocks(inode
, blocknum
, bhs
, needblocks
);
90 ll_rw_block(REQ_OP_READ
, 0, haveblocks
, bhs
);
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.
104 wait_on_buffer(bhs
[0]);
105 if (!buffer_uptodate(bhs
[0])) {
110 stream
.workspace
= zisofs_zlib_workspace
;
111 mutex_lock(&zisofs_zlib_lock
);
113 zerr
= zlib_inflateInit(&stream
);
115 if (zerr
== Z_MEM_ERROR
)
119 printk(KERN_DEBUG
"zisofs: zisofs_inflateInit returned %d\n",
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
])
130 stream
.avail_out
= PAGE_SIZE
- poffset
;
133 stream
.next_out
= (void *)&zisofs_sink_page
;
134 stream
.avail_out
= PAGE_SIZE
;
137 if (!stream
.avail_in
) {
138 wait_on_buffer(bhs
[curbh
]);
139 if (!buffer_uptodate(bhs
[curbh
])) {
143 stream
.next_in
= bhs
[curbh
]->b_data
+
144 (block_start
& bufmask
);
145 stream
.avail_in
= min_t(unsigned, bufsize
-
146 (block_start
& bufmask
),
148 block_size
-= stream
.avail_in
;
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)
156 if (zerr
== Z_STREAM_END
)
159 /* EOF, error, or trying to read beyond end of input */
160 if (zerr
== Z_MEM_ERROR
)
164 "zisofs: zisofs_inflate returned"
166 " page idx = %d, bh idx = %d,"
168 " avail_out = %ld\n",
169 zerr
, inode
->i_ino
, curpage
,
170 curbh
, stream
.avail_in
,
178 if (!stream
.avail_out
) {
179 /* This page completed */
180 if (pages
[curpage
]) {
181 flush_dcache_page(pages
[curpage
]);
182 SetPageUptodate(pages
[curpage
]);
186 if (!stream
.avail_in
)
190 zlib_inflateEnd(&stream
);
193 mutex_unlock(&zisofs_zlib_lock
);
196 for (i
= 0; i
< haveblocks
; i
++)
199 return stream
.total_out
;
203 * Uncompress data so that pages[full_page] is fully uptodate and possibly
204 * fills in other pages if we have data for them.
206 static int zisofs_fill_pages(struct inode
*inode
, int full_page
, int pcount
,
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
;
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
;
222 BUG_ON(!pages
[full_page
]);
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...
229 start_off
= page_offset(pages
[full_page
]);
230 end_off
= min_t(loff_t
, start_off
+ PAGE_SIZE
, inode
->i_size
);
232 cstart_block
= start_off
>> zisofs_block_shift
;
233 cend_block
= (end_off
+ (1 << zisofs_block_shift
) - 1)
234 >> zisofs_block_shift
;
236 WARN_ON(start_off
- (full_page
<< PAGE_SHIFT
) !=
237 ((cstart_block
<< zisofs_block_shift
) & PAGE_MASK
));
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
);
246 block_start
= le32_to_cpu(*(__le32
*)
247 (bh
->b_data
+ (blockptr
& (blksize
- 1))));
249 while (cstart_block
< cend_block
&& pcount
> 0) {
250 /* Load end of the compressed block in the file */
252 /* Traversed to next block? */
253 if (!(blockptr
& (blksize
- 1))) {
256 bh
= isofs_bread(inode
, blockptr
>> blkbits
);
260 block_end
= le32_to_cpu(*(__le32
*)
261 (bh
->b_data
+ (blockptr
& (blksize
- 1))));
262 if (block_start
> block_end
) {
267 ret
= zisofs_uncompress_block(inode
, block_start
, block_end
,
268 pcount
, pages
, poffset
, &err
);
270 pages
+= poffset
>> PAGE_SHIFT
;
271 pcount
-= poffset
>> PAGE_SHIFT
;
272 full_page
-= poffset
>> PAGE_SHIFT
;
273 poffset
&= ~PAGE_MASK
;
278 * Did we finish reading the page we really wanted
286 block_start
= block_end
;
290 if (poffset
&& *pages
) {
291 memset(page_address(*pages
) + poffset
, 0,
292 PAGE_SIZE
- poffset
);
293 flush_dcache_page(*pages
);
294 SetPageUptodate(*pages
);
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.
304 static int zisofs_readpage(struct file
*file
, struct page
*page
)
306 struct inode
*inode
= file_inode(file
);
307 struct address_space
*mapping
= inode
->i_mapping
;
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;
315 pgoff_t index
= page
->index
, end_index
;
317 end_index
= (inode
->i_size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
319 * If this page is wholly outside i_size we just return zero;
320 * do_generic_file_read() will handle this for us
322 if (index
>= end_index
) {
323 SetPageUptodate(page
);
328 if (PAGE_SHIFT
<= zisofs_block_shift
) {
329 /* We have already been given one page, this is the one
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)));
339 pages
= kcalloc(max_t(unsigned int, zisofs_pages_per_cblock
, 1),
340 sizeof(*pages
), GFP_KERNEL
);
345 pages
[full_page
] = page
;
347 for (i
= 0; i
< pcount
; i
++, index
++) {
349 pages
[i
] = grab_cache_page_nowait(mapping
, index
);
351 ClearPageError(pages
[i
]);
356 err
= zisofs_fill_pages(inode
, full_page
, pcount
, pages
);
358 /* Release any residual pages, do not SetPageUptodate */
359 for (i
= 0; i
< pcount
; i
++) {
361 flush_dcache_page(pages
[i
]);
362 if (i
== full_page
&& err
)
363 SetPageError(pages
[i
]);
365 unlock_page(pages
[i
]);
371 /* At this point, err contains 0 or -EIO depending on the "critical" page */
376 const struct address_space_operations zisofs_aops
= {
377 .readpage
= zisofs_readpage
,
378 /* No bmap operation supported */
381 int __init
zisofs_init(void)
383 zisofs_zlib_workspace
= vmalloc(zlib_inflate_workspacesize());
384 if ( !zisofs_zlib_workspace
)
390 void zisofs_cleanup(void)
392 vfree(zisofs_zlib_workspace
);