1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* -*- linux-c -*- ------------------------------------------------------- * |
3 | * |
4 | * Copyright 2001 H. Peter Anvin - All Rights Reserved |
5 | * |
6 | * ----------------------------------------------------------------------- */ |
7 | |
8 | /* |
9 | * linux/fs/isofs/compress.c |
10 | * |
11 | * Transparent decompression of files on an iso9660 filesystem |
12 | */ |
13 | |
14 | #include <linux/module.h> |
15 | #include <linux/init.h> |
16 | #include <linux/bio.h> |
17 | |
18 | #include <linux/slab.h> |
19 | #include <linux/vmalloc.h> |
20 | #include <linux/zlib.h> |
21 | |
22 | #include "isofs.h" |
23 | #include "zisofs.h" |
24 | |
25 | /* This should probably be global. */ |
26 | static char zisofs_sink_page[PAGE_SIZE]; |
27 | |
28 | /* |
29 | * This contains the zlib memory allocation and the mutex for the |
30 | * allocation; this avoids failures at block-decompression time. |
31 | */ |
32 | static void *zisofs_zlib_workspace; |
33 | static DEFINE_MUTEX(zisofs_zlib_lock); |
34 | |
35 | /* |
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. |
39 | */ |
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, |
43 | int *errp) |
44 | { |
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, |
51 | .avail_in = 0, |
52 | .avail_out = 0, }; |
53 | int zerr; |
54 | int needblocks = (block_size + (block_start & bufmask) + bufmask) |
55 | >> bufshift; |
56 | int haveblocks; |
57 | blkcnt_t blocknum; |
58 | struct buffer_head **bhs; |
59 | int curbh, curpage; |
60 | |
61 | if (block_size > deflateBound(s: 1UL << zisofs_block_shift)) { |
62 | *errp = -EIO; |
63 | return 0; |
64 | } |
65 | /* Empty block? */ |
66 | if (block_size == 0) { |
67 | for ( i = 0 ; i < pcount ; i++ ) { |
68 | if (!pages[i]) |
69 | continue; |
70 | memzero_page(page: pages[i], offset: 0, PAGE_SIZE); |
71 | SetPageUptodate(pages[i]); |
72 | } |
73 | return ((loff_t)pcount) << PAGE_SHIFT; |
74 | } |
75 | |
76 | /* Because zlib is not thread-safe, do all the I/O at the top. */ |
77 | blocknum = block_start >> bufshift; |
78 | bhs = kcalloc(n: needblocks + 1, size: sizeof(*bhs), GFP_KERNEL); |
79 | if (!bhs) { |
80 | *errp = -ENOMEM; |
81 | return 0; |
82 | } |
83 | haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks); |
84 | bh_read_batch(nr: haveblocks, bhs); |
85 | |
86 | curbh = 0; |
87 | curpage = 0; |
88 | /* |
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. |
93 | */ |
94 | |
95 | if (!bhs[0]) |
96 | goto b_eio; |
97 | |
98 | wait_on_buffer(bh: bhs[0]); |
99 | if (!buffer_uptodate(bh: bhs[0])) { |
100 | *errp = -EIO; |
101 | goto b_eio; |
102 | } |
103 | |
104 | stream.workspace = zisofs_zlib_workspace; |
105 | mutex_lock(&zisofs_zlib_lock); |
106 | |
107 | zerr = zlib_inflateInit(&stream); |
108 | if (zerr != Z_OK) { |
109 | if (zerr == Z_MEM_ERROR) |
110 | *errp = -ENOMEM; |
111 | else |
112 | *errp = -EIO; |
113 | printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n" , |
114 | zerr); |
115 | goto z_eio; |
116 | } |
117 | |
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(page: pages[curpage]) |
123 | + poffset; |
124 | stream.avail_out = PAGE_SIZE - poffset; |
125 | poffset = 0; |
126 | } else { |
127 | stream.next_out = (void *)&zisofs_sink_page; |
128 | stream.avail_out = PAGE_SIZE; |
129 | } |
130 | } |
131 | if (!stream.avail_in) { |
132 | wait_on_buffer(bh: bhs[curbh]); |
133 | if (!buffer_uptodate(bh: bhs[curbh])) { |
134 | *errp = -EIO; |
135 | break; |
136 | } |
137 | stream.next_in = bhs[curbh]->b_data + |
138 | (block_start & bufmask); |
139 | stream.avail_in = min_t(unsigned, bufsize - |
140 | (block_start & bufmask), |
141 | block_size); |
142 | block_size -= stream.avail_in; |
143 | block_start = 0; |
144 | } |
145 | |
146 | while (stream.avail_out && stream.avail_in) { |
147 | zerr = zlib_inflate(strm: &stream, Z_SYNC_FLUSH); |
148 | if (zerr == Z_BUF_ERROR && stream.avail_in == 0) |
149 | break; |
150 | if (zerr == Z_STREAM_END) |
151 | break; |
152 | if (zerr != Z_OK) { |
153 | /* EOF, error, or trying to read beyond end of input */ |
154 | if (zerr == Z_MEM_ERROR) |
155 | *errp = -ENOMEM; |
156 | else { |
157 | printk(KERN_DEBUG |
158 | "zisofs: zisofs_inflate returned" |
159 | " %d, inode = %lu," |
160 | " page idx = %d, bh idx = %d," |
161 | " avail_in = %ld," |
162 | " avail_out = %ld\n" , |
163 | zerr, inode->i_ino, curpage, |
164 | curbh, stream.avail_in, |
165 | stream.avail_out); |
166 | *errp = -EIO; |
167 | } |
168 | goto inflate_out; |
169 | } |
170 | } |
171 | |
172 | if (!stream.avail_out) { |
173 | /* This page completed */ |
174 | if (pages[curpage]) { |
175 | flush_dcache_page(page: pages[curpage]); |
176 | SetPageUptodate(pages[curpage]); |
177 | } |
178 | if (stream.next_out != (unsigned char *)zisofs_sink_page) { |
179 | kunmap_local(stream.next_out); |
180 | stream.next_out = NULL; |
181 | } |
182 | curpage++; |
183 | } |
184 | if (!stream.avail_in) |
185 | curbh++; |
186 | } |
187 | inflate_out: |
188 | zlib_inflateEnd(strm: &stream); |
189 | if (stream.next_out && stream.next_out != (unsigned char *)zisofs_sink_page) |
190 | kunmap_local(stream.next_out); |
191 | |
192 | z_eio: |
193 | mutex_unlock(lock: &zisofs_zlib_lock); |
194 | |
195 | b_eio: |
196 | for (i = 0; i < haveblocks; i++) |
197 | brelse(bh: bhs[i]); |
198 | kfree(objp: 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 | */ |
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 = 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(page: 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, errp: &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 | memzero_page(page: *pages, offset: poffset, PAGE_SIZE - poffset); |
292 | SetPageUptodate(*pages); |
293 | } |
294 | return 0; |
295 | } |
296 | |
297 | /* |
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. |
301 | */ |
302 | static int zisofs_read_folio(struct file *file, struct folio *folio) |
303 | { |
304 | struct page *page = &folio->page; |
305 | struct inode *inode = file_inode(f: file); |
306 | struct address_space *mapping = inode->i_mapping; |
307 | int err; |
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; |
313 | struct page **pages; |
314 | pgoff_t index = page->index, end_index; |
315 | |
316 | end_index = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT; |
317 | /* |
318 | * If this page is wholly outside i_size we just return zero; |
319 | * do_generic_file_read() will handle this for us |
320 | */ |
321 | if (index >= end_index) { |
322 | SetPageUptodate(page); |
323 | unlock_page(page); |
324 | return 0; |
325 | } |
326 | |
327 | if (PAGE_SHIFT <= zisofs_block_shift) { |
328 | /* We have already been given one page, this is the one |
329 | we must do. */ |
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))); |
333 | index -= full_page; |
334 | } else { |
335 | full_page = 0; |
336 | pcount = 1; |
337 | } |
338 | pages = kcalloc(max_t(unsigned int, zisofs_pages_per_cblock, 1), |
339 | size: sizeof(*pages), GFP_KERNEL); |
340 | if (!pages) { |
341 | unlock_page(page); |
342 | return -ENOMEM; |
343 | } |
344 | pages[full_page] = page; |
345 | |
346 | for (i = 0; i < pcount; i++, index++) { |
347 | if (i != full_page) |
348 | pages[i] = grab_cache_page_nowait(mapping, index); |
349 | if (pages[i]) |
350 | ClearPageError(page: pages[i]); |
351 | } |
352 | |
353 | err = zisofs_fill_pages(inode, full_page, pcount, pages); |
354 | |
355 | /* Release any residual pages, do not SetPageUptodate */ |
356 | for (i = 0; i < pcount; i++) { |
357 | if (pages[i]) { |
358 | flush_dcache_page(page: pages[i]); |
359 | if (i == full_page && err) |
360 | SetPageError(pages[i]); |
361 | unlock_page(page: pages[i]); |
362 | if (i != full_page) |
363 | put_page(page: pages[i]); |
364 | } |
365 | } |
366 | |
367 | /* At this point, err contains 0 or -EIO depending on the "critical" page */ |
368 | kfree(objp: pages); |
369 | return err; |
370 | } |
371 | |
372 | const struct address_space_operations zisofs_aops = { |
373 | .read_folio = zisofs_read_folio, |
374 | /* No bmap operation supported */ |
375 | }; |
376 | |
377 | int __init zisofs_init(void) |
378 | { |
379 | zisofs_zlib_workspace = vmalloc(size: zlib_inflate_workspacesize()); |
380 | if ( !zisofs_zlib_workspace ) |
381 | return -ENOMEM; |
382 | |
383 | return 0; |
384 | } |
385 | |
386 | void zisofs_cleanup(void) |
387 | { |
388 | vfree(addr: zisofs_zlib_workspace); |
389 | } |
390 | |