Merge tag 'staging-5.2-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[sfrench/cifs-2.6.git] / fs / isofs / compress.c
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  */
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  */
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  */
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
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
390 void zisofs_cleanup(void)
391 {
392         vfree(zisofs_zlib_workspace);
393 }