1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* -*- linux-c -*- ------------------------------------------------------- *
4 * Copyright 2001 H. Peter Anvin - All Rights Reserved
6 * ----------------------------------------------------------------------- */
9 * linux/fs/isofs/compress.c
11 * Transparent decompression of files on an iso9660 filesystem
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/bio.h>
18 #include <linux/slab.h>
19 #include <linux/vmalloc.h>
20 #include <linux/zlib.h>
25 /* This should probably be global. */
26 static char zisofs_sink_page
[PAGE_SIZE
];
29 * This contains the zlib memory allocation and the mutex for the
30 * allocation; this avoids failures at block-decompression time.
32 static void *zisofs_zlib_workspace
;
33 static DEFINE_MUTEX(zisofs_zlib_lock
);
36 * Read data of @inode from @block_start to @block_end and uncompress
37 * to one zisofs block. Store the data in the @pages array with @pcount
38 * entries. Start storing at offset @poffset of the first page.
40 static loff_t
zisofs_uncompress_block(struct inode
*inode
, loff_t block_start
,
41 loff_t block_end
, int pcount
,
42 struct page
**pages
, unsigned poffset
,
45 unsigned int zisofs_block_shift
= ISOFS_I(inode
)->i_format_parm
[1];
46 unsigned int bufsize
= ISOFS_BUFFER_SIZE(inode
);
47 unsigned int bufshift
= ISOFS_BUFFER_BITS(inode
);
48 unsigned int bufmask
= bufsize
- 1;
49 int i
, block_size
= block_end
- block_start
;
50 z_stream stream
= { .total_out
= 0,
54 int needblocks
= (block_size
+ (block_start
& bufmask
) + bufmask
)
58 struct buffer_head
**bhs
;
61 if (block_size
> deflateBound(1UL << zisofs_block_shift
)) {
66 if (block_size
== 0) {
67 for ( i
= 0 ; i
< pcount
; i
++ ) {
70 memzero_page(pages
[i
], 0, PAGE_SIZE
);
71 SetPageUptodate(pages
[i
]);
73 return ((loff_t
)pcount
) << PAGE_SHIFT
;
76 /* Because zlib is not thread-safe, do all the I/O at the top. */
77 blocknum
= block_start
>> bufshift
;
78 bhs
= kcalloc(needblocks
+ 1, sizeof(*bhs
), GFP_KERNEL
);
83 haveblocks
= isofs_get_blocks(inode
, blocknum
, bhs
, needblocks
);
84 bh_read_batch(haveblocks
, bhs
);
89 * First block is special since it may be fractional. We also wait for
90 * it before grabbing the zlib mutex; odds are that the subsequent
91 * blocks are going to come in in short order so we don't hold the zlib
92 * mutex longer than necessary.
98 wait_on_buffer(bhs
[0]);
99 if (!buffer_uptodate(bhs
[0])) {
104 stream
.workspace
= zisofs_zlib_workspace
;
105 mutex_lock(&zisofs_zlib_lock
);
107 zerr
= zlib_inflateInit(&stream
);
109 if (zerr
== Z_MEM_ERROR
)
113 printk(KERN_DEBUG
"zisofs: zisofs_inflateInit returned %d\n",
118 while (curpage
< pcount
&& curbh
< haveblocks
&&
119 zerr
!= Z_STREAM_END
) {
120 if (!stream
.avail_out
) {
121 if (pages
[curpage
]) {
122 stream
.next_out
= kmap_local_page(pages
[curpage
])
124 stream
.avail_out
= PAGE_SIZE
- poffset
;
127 stream
.next_out
= (void *)&zisofs_sink_page
;
128 stream
.avail_out
= PAGE_SIZE
;
131 if (!stream
.avail_in
) {
132 wait_on_buffer(bhs
[curbh
]);
133 if (!buffer_uptodate(bhs
[curbh
])) {
137 stream
.next_in
= bhs
[curbh
]->b_data
+
138 (block_start
& bufmask
);
139 stream
.avail_in
= min_t(unsigned, bufsize
-
140 (block_start
& bufmask
),
142 block_size
-= stream
.avail_in
;
146 while (stream
.avail_out
&& stream
.avail_in
) {
147 zerr
= zlib_inflate(&stream
, Z_SYNC_FLUSH
);
148 if (zerr
== Z_BUF_ERROR
&& stream
.avail_in
== 0)
150 if (zerr
== Z_STREAM_END
)
153 /* EOF, error, or trying to read beyond end of input */
154 if (zerr
== Z_MEM_ERROR
)
158 "zisofs: zisofs_inflate returned"
160 " page idx = %d, bh idx = %d,"
162 " avail_out = %ld\n",
163 zerr
, inode
->i_ino
, curpage
,
164 curbh
, stream
.avail_in
,
172 if (!stream
.avail_out
) {
173 /* This page completed */
174 if (pages
[curpage
]) {
175 flush_dcache_page(pages
[curpage
]);
176 SetPageUptodate(pages
[curpage
]);
178 if (stream
.next_out
!= (unsigned char *)zisofs_sink_page
) {
179 kunmap_local(stream
.next_out
);
180 stream
.next_out
= NULL
;
184 if (!stream
.avail_in
)
188 zlib_inflateEnd(&stream
);
189 if (stream
.next_out
&& stream
.next_out
!= (unsigned char *)zisofs_sink_page
)
190 kunmap_local(stream
.next_out
);
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 memzero_page(*pages
, poffset
, PAGE_SIZE
- poffset
);
292 SetPageUptodate(*pages
);
298 * When decompressing, we typically obtain more than one page
299 * per reference. We inject the additional pages into the page
300 * cache as a form of readahead.
302 static int zisofs_read_folio(struct file
*file
, struct folio
*folio
)
304 struct page
*page
= &folio
->page
;
305 struct inode
*inode
= file_inode(file
);
306 struct address_space
*mapping
= inode
->i_mapping
;
308 int i
, pcount
, full_page
;
309 unsigned int zisofs_block_shift
= ISOFS_I(inode
)->i_format_parm
[1];
310 unsigned int zisofs_pages_per_cblock
=
311 PAGE_SHIFT
<= zisofs_block_shift
?
312 (1 << (zisofs_block_shift
- PAGE_SHIFT
)) : 0;
314 pgoff_t index
= page
->index
, end_index
;
316 end_index
= (inode
->i_size
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
318 * If this page is wholly outside i_size we just return zero;
319 * do_generic_file_read() will handle this for us
321 if (index
>= end_index
) {
322 SetPageUptodate(page
);
327 if (PAGE_SHIFT
<= zisofs_block_shift
) {
328 /* We have already been given one page, this is the one
330 full_page
= index
& (zisofs_pages_per_cblock
- 1);
331 pcount
= min_t(int, zisofs_pages_per_cblock
,
332 end_index
- (index
& ~(zisofs_pages_per_cblock
- 1)));
338 pages
= kcalloc(max_t(unsigned int, zisofs_pages_per_cblock
, 1),
339 sizeof(*pages
), GFP_KERNEL
);
344 pages
[full_page
] = page
;
346 for (i
= 0; i
< pcount
; i
++, index
++) {
348 pages
[i
] = grab_cache_page_nowait(mapping
, index
);
350 ClearPageError(pages
[i
]);
353 err
= zisofs_fill_pages(inode
, full_page
, pcount
, pages
);
355 /* Release any residual pages, do not SetPageUptodate */
356 for (i
= 0; i
< pcount
; i
++) {
358 flush_dcache_page(pages
[i
]);
359 if (i
== full_page
&& err
)
360 SetPageError(pages
[i
]);
361 unlock_page(pages
[i
]);
367 /* At this point, err contains 0 or -EIO depending on the "critical" page */
372 const struct address_space_operations zisofs_aops
= {
373 .read_folio
= zisofs_read_folio
,
374 /* No bmap operation supported */
377 int __init
zisofs_init(void)
379 zisofs_zlib_workspace
= vmalloc(zlib_inflate_workspacesize());
380 if ( !zisofs_zlib_workspace
)
386 void zisofs_cleanup(void)
388 vfree(zisofs_zlib_workspace
);