fs/isofs/compress.c

   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(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(pages[i], 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(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(bhs[0]);
  99         if (!buffer_uptodate(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(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(bhs[curbh]);
 133                         if (!buffer_uptodate(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(&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(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(&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(&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                 memzero_page(*pages, 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(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                                         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(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(pages[i]);
 359                         if (i == full_page && err)
 360                                 SetPageError(pages[i]);
 361                         unlock_page(pages[i]);
 362                         if (i != full_page)
 363                                 put_page(pages[i]);
 364                 }
 365         }
 366
 367         /* At this point, err contains 0 or -EIO depending on the "critical" page */
 368         kfree(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(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(zisofs_zlib_workspace);
 389 }