Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 359 insertions, 0 deletions

diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
new file mode 100644
index 000000000000..fb42c3f3bf0d
--- /dev/null
+++ b/fs/isofs/compress.c
@@ -0,0 +1,359 @@
+/* -*- linux-c -*- ------------------------------------------------------- *
+ *   
+ *   Copyright 2001 H. Peter Anvin - All Rights Reserved
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
+ *   USA; either version 2 of the License, or (at your option) any later
+ *   version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * linux/fs/isofs/compress.c
+ *
+ * Transparent decompression of files on an iso9660 filesystem
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+
+#include <linux/stat.h>
+#include <linux/time.h>
+#include <linux/iso_fs.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/nls.h>
+#include <linux/ctype.h>
+#include <linux/smp_lock.h>
+#include <linux/blkdev.h>
+#include <linux/vmalloc.h>
+#include <linux/zlib.h>
+#include <linux/buffer_head.h>
+
+#include <asm/system.h>
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+
+#include "zisofs.h"
+
+/* This should probably be global. */
+static char zisofs_sink_page[PAGE_CACHE_SIZE];
+
+/*
+ * This contains the zlib memory allocation and the mutex for the
+ * allocation; this avoids failures at block-decompression time.
+ */
+static void *zisofs_zlib_workspace;
+static struct semaphore zisofs_zlib_semaphore;
+
+/*
+ * When decompressing, we typically obtain more than one page
+ * per reference.  We inject the additional pages into the page
+ * cache as a form of readahead.
+ */
+static int zisofs_readpage(struct file *file, struct page *page)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct address_space *mapping = inode->i_mapping;
+        unsigned int maxpage, xpage, fpage, blockindex;
+        unsigned long offset;
+        unsigned long blockptr, blockendptr, cstart, cend, csize;
+        struct buffer_head *bh, *ptrbh[2];
+        unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
+        unsigned int bufshift = ISOFS_BUFFER_BITS(inode);
+        unsigned long bufmask  = bufsize - 1;
+        int err = -EIO;
+        int i;
+        unsigned int header_size = ISOFS_I(inode)->i_format_parm[0];
+        unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1];
+        /* unsigned long zisofs_block_size = 1UL << zisofs_block_shift; */
+        unsigned int zisofs_block_page_shift = zisofs_block_shift-PAGE_CACHE_SHIFT;
+        unsigned long zisofs_block_pages = 1UL << zisofs_block_page_shift;
+        unsigned long zisofs_block_page_mask = zisofs_block_pages-1;
+        struct page *pages[zisofs_block_pages];
+        unsigned long index = page->index;
+        int indexblocks;
+
+        /* We have already been given one page, this is the one
+           we must do. */
+        xpage = index & zisofs_block_page_mask;
+        pages[xpage] = page;
+ 
+        /* The remaining pages need to be allocated and inserted */
+        offset = index & ~zisofs_block_page_mask;
+        blockindex = offset >> zisofs_block_page_shift;
+        maxpage = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        maxpage = min(zisofs_block_pages, maxpage-offset);
+
+        for ( i = 0 ; i < maxpage ; i++, offset++ ) {
+                if ( i != xpage ) {
+                        pages[i] = grab_cache_page_nowait(mapping, offset);
+                }
+                page = pages[i];
+                if ( page ) {
+                        ClearPageError(page);
+                        kmap(page);
+                }
+        }
+
+        /* This is the last page filled, plus one; used in case of abort. */
+        fpage = 0;
+
+        /* Find the pointer to this specific chunk */
+        /* Note: we're not using isonum_731() here because the data is known aligned */
+        /* Note: header_size is in 32-bit words (4 bytes) */
+        blockptr = (header_size + blockindex) << 2;
+        blockendptr = blockptr + 4;
+
+        indexblocks = ((blockptr^blockendptr) >> bufshift) ? 2 : 1;
+        ptrbh[0] = ptrbh[1] = NULL;
+
+        if ( isofs_get_blocks(inode, blockptr >> bufshift, ptrbh, indexblocks) != indexblocks ) {
+                if ( ptrbh[0] ) brelse(ptrbh[0]);
+                printk(KERN_DEBUG "zisofs: Null buffer on reading block table, inode = %lu, block = %lu\n",
+                       inode->i_ino, blockptr >> bufshift);
+                goto eio;
+        }
+        ll_rw_block(READ, indexblocks, ptrbh);
+
+        bh = ptrbh[0];
+        if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
+                printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
+                       inode->i_ino, blockptr >> bufshift);
+                if ( ptrbh[1] )
+                        brelse(ptrbh[1]);
+                goto eio;
+        }
+        cstart = le32_to_cpu(*(__le32 *)(bh->b_data + (blockptr & bufmask)));
+
+        if ( indexblocks == 2 ) {
+                /* We just crossed a block boundary.  Switch to the next block */
+                brelse(bh);
+                bh = ptrbh[1];
+                if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
+                        printk(KERN_DEBUG "zisofs: Failed to read block table, inode = %lu, block = %lu\n",
+                               inode->i_ino, blockendptr >> bufshift);
+                        goto eio;
+                }
+        }
+        cend = le32_to_cpu(*(__le32 *)(bh->b_data + (blockendptr & bufmask)));
+        brelse(bh);
+
+        csize = cend-cstart;
+
+        /* Now page[] contains an array of pages, any of which can be NULL,
+           and the locks on which we hold.  We should now read the data and
+           release the pages.  If the pages are NULL the decompressed data
+           for that particular page should be discarded. */
+        
+        if ( csize == 0 ) {
+                /* This data block is empty. */
+
+                for ( fpage = 0 ; fpage < maxpage ; fpage++ ) {
+                        if ( (page = pages[fpage]) != NULL ) {
+                                memset(page_address(page), 0, PAGE_CACHE_SIZE);
+                                
+                                flush_dcache_page(page);
+                                SetPageUptodate(page);
+                                kunmap(page);
+                                unlock_page(page);
+                                if ( fpage == xpage )
+                                        err = 0; /* The critical page */
+                                else
+                                        page_cache_release(page);
+                        }
+                }
+        } else {
+                /* This data block is compressed. */
+                z_stream stream;
+                int bail = 0, left_out = -1;
+                int zerr;
+                int needblocks = (csize + (cstart & bufmask) + bufmask) >> bufshift;
+                int haveblocks;
+                struct buffer_head *bhs[needblocks+1];
+                struct buffer_head **bhptr;
+
+                /* Because zlib is not thread-safe, do all the I/O at the top. */
+
+                blockptr = cstart >> bufshift;
+                memset(bhs, 0, (needblocks+1)*sizeof(struct buffer_head *));
+                haveblocks = isofs_get_blocks(inode, blockptr, bhs, needblocks);
+                ll_rw_block(READ, haveblocks, bhs);
+
+                bhptr = &bhs[0];
+                bh = *bhptr++;
+
+                /* First block is special since it may be fractional.
+                   We also wait for it before grabbing the zlib
+                   semaphore; odds are that the subsequent blocks are
+                   going to come in in short order so we don't hold
+                   the zlib semaphore longer than necessary. */
+
+                if ( !bh || (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
+                        printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
+                               fpage, xpage, csize);
+                        goto b_eio;
+                }
+                stream.next_in  = bh->b_data + (cstart & bufmask);
+                stream.avail_in = min(bufsize-(cstart & bufmask), csize);
+                csize -= stream.avail_in;
+
+                stream.workspace = zisofs_zlib_workspace;
+                down(&zisofs_zlib_semaphore);
+                
+                zerr = zlib_inflateInit(&stream);
+                if ( zerr != Z_OK ) {
+                        if ( err && zerr == Z_MEM_ERROR )
+                                err = -ENOMEM;
+                        printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n",
+                               zerr);
+                        goto z_eio;
+                }
+
+                while ( !bail && fpage < maxpage ) {
+                        page = pages[fpage];
+                        if ( page )
+                                stream.next_out = page_address(page);
+                        else
+                                stream.next_out = (void *)&zisofs_sink_page;
+                        stream.avail_out = PAGE_CACHE_SIZE;
+
+                        while ( stream.avail_out ) {
+                                int ao, ai;
+                                if ( stream.avail_in == 0 && left_out ) {
+                                        if ( !csize ) {
+                                                printk(KERN_WARNING "zisofs: ZF read beyond end of input\n");
+                                                bail = 1;
+                                                break;
+                                        } else {
+                                                bh = *bhptr++;
+                                                if ( !bh ||
+                                                     (wait_on_buffer(bh), !buffer_uptodate(bh)) ) {
+                                                        /* Reached an EIO */
+                                                        printk(KERN_DEBUG "zisofs: Hit null buffer, fpage = %d, xpage = %d, csize = %ld\n",
+                                                               fpage, xpage, csize);
+                                                               
+                                                        bail = 1;
+                                                        break;
+                                                }
+                                                stream.next_in = bh->b_data;
+                                                stream.avail_in = min(csize,bufsize);
+                                                csize -= stream.avail_in;
+                                        }
+                                }
+                                ao = stream.avail_out;  ai = stream.avail_in;
+                                zerr = zlib_inflate(&stream, Z_SYNC_FLUSH);
+                                left_out = stream.avail_out;
+                                if ( zerr == Z_BUF_ERROR && stream.avail_in == 0 )
+                                        continue;
+                                if ( zerr != Z_OK ) {
+                                        /* EOF, error, or trying to read beyond end of input */
+                                        if ( err && zerr == Z_MEM_ERROR )
+                                                err = -ENOMEM;
+                                        if ( zerr != Z_STREAM_END )
+                                                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",
+                                                       zerr, inode->i_ino, index,
+                                                       fpage, xpage,
+                                                       stream.avail_in, stream.avail_out,
+                                                       ai, ao);
+                                        bail = 1;
+                                        break;
+                                }
+                        }
+
+                        if ( stream.avail_out && zerr == Z_STREAM_END ) {
+                                /* Fractional page written before EOF.  This may
+                                   be the last page in the file. */
+                                memset(stream.next_out, 0, stream.avail_out);
+                                stream.avail_out = 0;
+                        }
+
+                        if ( !stream.avail_out ) {
+                                /* This page completed */
+                                if ( page ) {
+                                        flush_dcache_page(page);
+                                        SetPageUptodate(page);
+                                        kunmap(page);
+                                        unlock_page(page);
+                                        if ( fpage == xpage )
+                                                err = 0; /* The critical page */
+                                        else
+                                                page_cache_release(page);
+                                }
+                                fpage++;
+                        }
+                }
+                zlib_inflateEnd(&stream);
+
+        z_eio:
+                up(&zisofs_zlib_semaphore);
+
+        b_eio:
+                for ( i = 0 ; i < haveblocks ; i++ ) {
+                        if ( bhs[i] )
+                                brelse(bhs[i]);
+                }
+        }
+
+eio:
+
+        /* Release any residual pages, do not SetPageUptodate */
+        while ( fpage < maxpage ) {
+                page = pages[fpage];
+                if ( page ) {
+                        flush_dcache_page(page);
+                        if ( fpage == xpage )
+                                SetPageError(page);
+                        kunmap(page);
+                        unlock_page(page);
+                        if ( fpage != xpage )
+                                page_cache_release(page);
+                }
+                fpage++;
+        }                       
+
+        /* At this point, err contains 0 or -EIO depending on the "critical" page */
+        return err;
+}
+
+struct address_space_operations zisofs_aops = {
+        .readpage = zisofs_readpage,
+        /* No sync_page operation supported? */
+        /* No bmap operation supported */
+};
+
+static int initialized;
+
+int __init zisofs_init(void)
+{
+        if ( initialized ) {
+                printk("zisofs_init: called more than once\n");
+                return 0;
+        }
+
+        zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize());
+        if ( !zisofs_zlib_workspace )
+                return -ENOMEM;
+        init_MUTEX(&zisofs_zlib_semaphore);
+
+        initialized = 1;
+        return 0;
+}
+
+void zisofs_cleanup(void)
+{
+        if ( !initialized ) {
+                printk("zisofs_cleanup: called without initialization\n");
+                return;
+        }
+
+        vfree(zisofs_zlib_workspace);
+        initialized = 0;
+}