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. */
26static 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 */
32static void *zisofs_zlib_workspace;
33static 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 */
40static 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(needblocks + 1, 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(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 }
187inflate_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
192z_eio:
193 mutex_unlock(lock: &zisofs_zlib_lock);
194
195b_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 */
206static 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(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 */
302static int zisofs_read_folio(struct file *file, struct folio *folio)
303{
304 struct inode *inode = file_inode(f: file);
305 struct address_space *mapping = inode->i_mapping;
306 int err;
307 int i, pcount, full_page;
308 unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
309 unsigned int zisofs_pages_per_cblock =
310 PAGE_SHIFT <= zisofs_block_shift ?
311 (1 << (zisofs_block_shift - PAGE_SHIFT)) : 0;
312 struct page **pages;
313 pgoff_t index = folio->index, end_index;
314
315 end_index = (inode->i_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
316 /*
317 * If this folio is wholly outside i_size we just return zero;
318 * do_generic_file_read() will handle this for us
319 */
320 if (index >= end_index) {
321 folio_end_read(folio, success: true);
322 return 0;
323 }
324
325 if (PAGE_SHIFT <= zisofs_block_shift) {
326 /* We have already been given one page, this is the one
327 we must do. */
328 full_page = index & (zisofs_pages_per_cblock - 1);
329 pcount = min_t(int, zisofs_pages_per_cblock,
330 end_index - (index & ~(zisofs_pages_per_cblock - 1)));
331 index -= full_page;
332 } else {
333 full_page = 0;
334 pcount = 1;
335 }
336 pages = kcalloc(max_t(unsigned int, zisofs_pages_per_cblock, 1),
337 sizeof(*pages), GFP_KERNEL);
338 if (!pages) {
339 folio_unlock(folio);
340 return -ENOMEM;
341 }
342 pages[full_page] = &folio->page;
343
344 for (i = 0; i < pcount; i++, index++) {
345 if (i != full_page)
346 pages[i] = grab_cache_page_nowait(mapping, index);
347 }
348
349 err = zisofs_fill_pages(inode, full_page, pcount, pages);
350
351 /* Release any residual pages, do not SetPageUptodate */
352 for (i = 0; i < pcount; i++) {
353 if (pages[i]) {
354 flush_dcache_page(page: pages[i]);
355 unlock_page(page: pages[i]);
356 if (i != full_page)
357 put_page(page: pages[i]);
358 }
359 }
360
361 /* At this point, err contains 0 or -EIO depending on the "critical" page */
362 kfree(objp: pages);
363 return err;
364}
365
366const struct address_space_operations zisofs_aops = {
367 .read_folio = zisofs_read_folio,
368 /* No bmap operation supported */
369};
370
371int __init zisofs_init(void)
372{
373 zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
374 if ( !zisofs_zlib_workspace )
375 return -ENOMEM;
376
377 return 0;
378}
379
380void zisofs_cleanup(void)
381{
382 vfree(addr: zisofs_zlib_workspace);
383}
384