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/config.h>
  20 #include <linux/module.h>
  21 #include <linux/init.h>
  22
  23 #include <linux/vmalloc.h>
  24 #include <linux/zlib.h>
  25
  26 #include "isofs.h"
  27 #include "zisofs.h"
  28
  29 /* This should probably be global. */
  30 static char zisofs_sink_page[PAGE_CACHE_SIZE];
  31
  32 /*
  33  * This contains the zlib memory allocation and the mutex for the
  34  * allocation; this avoids failures at block-decompression time.
  35  */
  36 static void *zisofs_zlib_workspace;
  37 static struct semaphore zisofs_zlib_semaphore;
  38
  39 /*
  40  * When decompressing, we typically obtain more than one page
  41  * per reference.  We inject the additional pages into the page
  42  * cache as a form of readahead.
  43  */
  44 static int zisofs_readpage(struct file *file, struct page *page)
  45 {
  46         struct inode *inode = file->f_dentry->d_inode;
  47         struct address_space *mapping = inode->i_mapping;
  48         unsigned int maxpage, xpage, fpage, blockindex;
  49         unsigned long offset;
  50         unsigned long blockptr, blockendptr, cstart, cend, csize;
  51         struct buffer_head *bh, *ptrbh[2];
  52         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
  53         unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
  54         unsigned long bufmask  = bufsize - 1;
  55         int err = -EIO;
  56         int i;
  57         unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
  58         unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
  59         /* unsigned long zisofs_block_size = 1UL << zisofs_block_shift; */
  60         unsigned int zisofs_block_page_shift = zisofs_block_shift-PAGE_CACHE_SHIFT;
  61         unsigned long zisofs_block_pages = 1UL << zisofs_block_page_shift;
  62         unsigned long zisofs_block_page_mask = zisofs_block_pages-1;
  63         struct page *pages[zisofs_block_pages];
  64         unsigned long index = page->index;
  65         int indexblocks;
  66
  67         /* We have already been given one page, this is the one
  68            we must do. */
  69         xpage = index & zisofs_block_page_mask;
  70         pages[xpage] = page;
  71
  72         /* The remaining pages need to be allocated and inserted */
  73         offset = index & ~zisofs_block_page_mask;
  74         blockindex = offset >> zisofs_block_page_shift;
  75         maxpage = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
  76         maxpage = min(zisofs_block_pages, maxpage-offset);
  77
  78         for ( i = 0 ; i < maxpage ; i++, offset++ ) {
  79                 if ( i != xpage ) {
  80                         pages[i] = grab_cache_page_nowait(mapping, offset);
  81                 }
  82                 page = pages[i];
  83                 if ( page ) {
  84                         ClearPageError(page);
  85                         kmap(page);
  86                 }
  87         }
  88
  89         /* This is the last page filled, plus one; used in case of abort. */
  90         fpage = 0;
  91
  92         /* Find the pointer to this specific chunk */
  93         /* Note: we're not using isonum_731() here because the data is known aligned */
  94         /* Note: header_size is in 32-bit words (4 bytes) */
  95         blockptr = (header_size + blockindex) << 2;
  96         blockendptr = blockptr + 4;
  97
  98         indexblocks = ((blockptr^blockendptr) >> bufshift) ? 2 : 1;
  99         ptrbh[0] = ptrbh[1] = NULL;
 100
 101         if ( isofs_get_blocks(inode, blockptr >> bufshift, ptrbh, indexblocks) != indexblocks ) {
 102                 if ( ptrbh[0] ) brelse(ptrbh[0]);
 103                 printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %lu, block = %lu\n",
 104                        inode->i_ino, blockptr >> bufshift);
 105                 goto eio;
 106         }
 107         ll_rw_block(READ, indexblocks, ptrbh);
 108
 109         bh = ptrbh[0];
 110         if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
 111                 printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
 112                        inode->i_ino, blockptr >> bufshift);
 113                 if ( ptrbh[1] )
 114                         brelse(ptrbh[1]);
 115                 goto eio;
 116         }
 117         cstart = le32_to_cpu(*(__le32 *)(bh->b_data + (blockptr & bufmask)));
 118
 119         if ( indexblocks == 2 ) {
 120                 /* We just crossed a block boundary.  Switch to the next block */
 121                 brelse(bh);
 122                 bh = ptrbh[1];
 123                 if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
 124                         printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
 125                                inode->i_ino, blockendptr >> bufshift);
 126                         goto eio;
 127                 }
 128         }
 129         cend = le32_to_cpu(*(__le32 *)(bh->b_data + (blockendptr & bufmask)));
 130         brelse(bh);
 131
 132         csize = cend-cstart;
 133
 134         /* Now page[] contains an array of pages, any of which can be NULL,
 135            and the locks on which we hold.  We should now read the data and
 136            release the pages.  If the pages are NULL the decompressed data
 137            for that particular page should be discarded. */
 138
 139         if ( csize == 0 ) {
 140                 /* This data block is empty. */
 141
 142                 for ( fpage = 0 ; fpage < maxpage ; fpage++ ) {
 143                         if ( (page = pages[fpage]) != NULL ) {
 144                                 memset(page_address(page), 0, PAGE_CACHE_SIZE);
 145
 146                                 flush_dcache_page(page);
 147                                 SetPageUptodate(page);
 148                                 kunmap(page);
 149                                 unlock_page(page);
 150                                 if ( fpage == xpage )
 151                                         err = 0; /* The critical page */
 152                                 else
 153                                         page_cache_release(page);
 154                         }
 155                 }
 156         } else {
 157                 /* This data block is compressed. */
 158                 z_stream stream;
 159                 int bail = 0, left_out = -1;
 160                 int zerr;
 161                 int needblocks = (csize + (cstart & bufmask) + bufmask) >> bufshift;
 162                 int haveblocks;
 163                 struct buffer_head *bhs[needblocks+1];
 164                 struct buffer_head **bhptr;
 165
 166                 /* Because zlib is not thread-safe, do all the I/O at the top. */
 167
 168                 blockptr = cstart >> bufshift;
 169                 memset(bhs, 0, (needblocks+1)*sizeof(struct buffer_head *));
 170                 haveblocks = isofs_get_blocks(inode, blockptr, bhs, needblocks);
 171                 ll_rw_block(READ, haveblocks, bhs);
 172
 173                 bhptr = &bhs[0];
 174                 bh = *bhptr++;
 175
 176                 /* First block is special since it may be fractional.
 177                    We also wait for it before grabbing the zlib
 178                    semaphore; odds are that the subsequent blocks are
 179                    going to come in in short order so we don't hold
 180                    the zlib semaphore longer than necessary. */
 181
 182                 if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
 183                         printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
 184                                fpage, xpage, csize);
 185                         goto b_eio;
 186                 }
 187                 stream.next_in  = bh->b_data + (cstart & bufmask);
 188                 stream.avail_in = min(bufsize-(cstart & bufmask), csize);
 189                 csize -= stream.avail_in;
 190
 191                 stream.workspace = zisofs_zlib_workspace;
 192                 down(&zisofs_zlib_semaphore);
 193
 194                 zerr = zlib_inflateInit(&stream);
 195                 if ( zerr != Z_OK ) {
 196                         if ( err && zerr == Z_MEM_ERROR )
 197                                 err = -ENOMEM;
 198                         printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
 199                                zerr);
 200                         goto z_eio;
 201                 }
 202
 203                 while ( !bail && fpage < maxpage ) {
 204                         page = pages[fpage];
 205                         if ( page )
 206                                 stream.next_out = page_address(page);
 207                         else
 208                                 stream.next_out = (void *)&zisofs_sink_page;
 209                         stream.avail_out = PAGE_CACHE_SIZE;
 210
 211                         while ( stream.avail_out ) {
 212                                 int ao, ai;
 213                                 if ( stream.avail_in == 0 && left_out ) {
 214                                         if ( !csize ) {
 215                                                 printk(KERN_WARNING "zisofs: ZF read beyond end of input\n");
 216                                                 bail = 1;
 217                                                 break;
 218                                         } else {
 219                                                 bh = *bhptr++;
 220                                                 if ( !bh ||
 221                                                      (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
 222                                                         /* Reached an EIO */
 223                                                         printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
 224                                                                fpage, xpage, csize);
 225
 226                                                         bail = 1;
 227                                                         break;
 228                                                 }
 229                                                 stream.next_in = bh->b_data;
 230                                                 stream.avail_in = min(csize,bufsize);
 231                                                 csize -= stream.avail_in;
 232                                         }
 233                                 }
 234                                 ao = stream.avail_out;  ai = stream.avail_in;
 235                                 zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
 236                                 left_out = stream.avail_out;
 237                                 if ( zerr == Z_BUF_ERROR && stream.avail_in == 0 )
 238                                         continue;
 239                                 if ( zerr != Z_OK ) {
 240                                         /* EOF, error, or trying to read beyond end of input */
 241                                         if ( err && zerr == Z_MEM_ERROR )
 242                                                 err = -ENOMEM;
 243                                         if ( zerr != Z_STREAM_END )
 244                                                 printk(KERN_DEBUG "zisofs: zisofs_inflate returned %d, inode = %lu, index = %lu, fpage = %d, xpage = %d, avail_in = %d, avail_out = %d, ai = %d, ao = %d\n",
 245                                                        zerr, inode->i_ino, index,
 246                                                        fpage, xpage,
 247                                                        stream.avail_in, stream.avail_out,
 248                                                        ai, ao);
 249                                         bail = 1;
 250                                         break;
 251                                 }
 252                         }
 253
 254                         if ( stream.avail_out && zerr == Z_STREAM_END ) {
 255                                 /* Fractional page written before EOF.  This may
 256                                    be the last page in the file. */
 257                                 memset(stream.next_out, 0, stream.avail_out);
 258                                 stream.avail_out = 0;
 259                         }
 260
 261                         if ( !stream.avail_out ) {
 262                                 /* This page completed */
 263                                 if ( page ) {
 264                                         flush_dcache_page(page);
 265                                         SetPageUptodate(page);
 266                                         kunmap(page);
 267                                         unlock_page(page);
 268                                         if ( fpage == xpage )
 269                                                 err = 0; /* The critical page */
 270                                         else
 271                                                 page_cache_release(page);
 272                                 }
 273                                 fpage++;
 274                         }
 275                 }
 276                 zlib_inflateEnd(&stream);
 277
 278         z_eio:
 279                 up(&zisofs_zlib_semaphore);
 280
 281         b_eio:
 282                 for ( i = 0 ; i < haveblocks ; i++ ) {
 283                         if ( bhs[i] )
 284                                 brelse(bhs[i]);
 285                 }
 286         }
 287
 288 eio:
 289
 290         /* Release any residual pages, do not SetPageUptodate */
 291         while ( fpage < maxpage ) {
 292                 page = pages[fpage];
 293                 if ( page ) {
 294                         flush_dcache_page(page);
 295                         if ( fpage == xpage )
 296                                 SetPageError(page);
 297                         kunmap(page);
 298                         unlock_page(page);
 299                         if ( fpage != xpage )
 300                                 page_cache_release(page);
 301                 }
 302                 fpage++;
 303         }
 304
 305         /* At this point, err contains 0 or -EIO depending on the "critical" page */
 306         return err;
 307 }
 308
 309 struct address_space_operations zisofs_aops = {
 310         .readpage = zisofs_readpage,
 311         /* No sync_page operation supported? */
 312         /* No bmap operation supported */
 313 };
 314
 315 static int initialized;
 316
 317 int __init zisofs_init(void)
 318 {
 319         if ( initialized ) {
 320                 printk("zisofs_init: called more than once\n");
 321                 return 0;
 322         }
 323
 324         zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
 325         if ( !zisofs_zlib_workspace )
 326                 return -ENOMEM;
 327         init_MUTEX(&zisofs_zlib_semaphore);
 328
 329         initialized = 1;
 330         return 0;
 331 }
 332
 333 void zisofs_cleanup(void)
 334 {
 335         if ( !initialized ) {
 336                 printk("zisofs_cleanup: called without initialization\n");
 337                 return;
 338         }
 339
 340         vfree(zisofs_zlib_workspace);
 341         initialized = 0;
 342 }