diff options
Diffstat (limited to 'ANDROID_3.4.5/fs/isofs/compress.c')
| -rw-r--r-- | ANDROID_3.4.5/fs/isofs/compress.c | 380 |
1 files changed, 0 insertions, 380 deletions
diff --git a/ANDROID_3.4.5/fs/isofs/compress.c b/ANDROID_3.4.5/fs/isofs/compress.c deleted file mode 100644 index 0b3fa797..00000000 --- a/ANDROID_3.4.5/fs/isofs/compress.c +++ /dev/null @@ -1,380 +0,0 @@ -/* -*- 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/module.h> -#include <linux/init.h> - -#include <linux/vmalloc.h> -#include <linux/zlib.h> - -#include "isofs.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 DEFINE_MUTEX(zisofs_zlib_lock); - -/* - * Read data of @inode from @block_start to @block_end and uncompress - * to one zisofs block. Store the data in the @pages array with @pcount - * entries. Start storing at offset @poffset of the first page. - */ -static loff_t zisofs_uncompress_block(struct inode *inode, loff_t block_start, - loff_t block_end, int pcount, - struct page **pages, unsigned poffset, - int *errp) -{ - unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1]; - unsigned int bufsize = ISOFS_BUFFER_SIZE(inode); - unsigned int bufshift = ISOFS_BUFFER_BITS(inode); - unsigned int bufmask = bufsize - 1; - int i, block_size = block_end - block_start; - z_stream stream = { .total_out = 0, - .avail_in = 0, - .avail_out = 0, }; - int zerr; - int needblocks = (block_size + (block_start & bufmask) + bufmask) - >> bufshift; - int haveblocks; - blkcnt_t blocknum; - struct buffer_head *bhs[needblocks + 1]; - int curbh, curpage; - - if (block_size > deflateBound(1UL << zisofs_block_shift)) { - *errp = -EIO; - return 0; - } - /* Empty block? */ - if (block_size == 0) { - for ( i = 0 ; i < pcount ; i++ ) { - if (!pages[i]) - continue; - memset(page_address(pages[i]), 0, PAGE_CACHE_SIZE); - flush_dcache_page(pages[i]); - SetPageUptodate(pages[i]); - } - return ((loff_t)pcount) << PAGE_CACHE_SHIFT; - } - - /* Because zlib is not thread-safe, do all the I/O at the top. */ - blocknum = block_start >> bufshift; - memset(bhs, 0, (needblocks + 1) * sizeof(struct buffer_head *)); - haveblocks = isofs_get_blocks(inode, blocknum, bhs, needblocks); - ll_rw_block(READ, haveblocks, bhs); - - curbh = 0; - curpage = 0; - /* - * First block is special since it may be fractional. We also wait for - * it before grabbing the zlib mutex; odds are that the subsequent - * blocks are going to come in in short order so we don't hold the zlib - * mutex longer than necessary. - */ - - if (!bhs[0]) - goto b_eio; - - wait_on_buffer(bhs[0]); - if (!buffer_uptodate(bhs[0])) { - *errp = -EIO; - goto b_eio; - } - - stream.workspace = zisofs_zlib_workspace; - mutex_lock(&zisofs_zlib_lock); - - zerr = zlib_inflateInit(&stream); - if (zerr != Z_OK) { - if (zerr == Z_MEM_ERROR) - *errp = -ENOMEM; - else - *errp = -EIO; - printk(KERN_DEBUG "zisofs: zisofs_inflateInit returned %d\n", - zerr); - goto z_eio; - } - - while (curpage < pcount && curbh < haveblocks && - zerr != Z_STREAM_END) { - if (!stream.avail_out) { - if (pages[curpage]) { - stream.next_out = page_address(pages[curpage]) - + poffset; - stream.avail_out = PAGE_CACHE_SIZE - poffset; - poffset = 0; - } else { - stream.next_out = (void *)&zisofs_sink_page; - stream.avail_out = PAGE_CACHE_SIZE; - } - } - if (!stream.avail_in) { - wait_on_buffer(bhs[curbh]); - if (!buffer_uptodate(bhs[curbh])) { - *errp = -EIO; - break; - } - stream.next_in = bhs[curbh]->b_data + - (block_start & bufmask); - stream.avail_in = min_t(unsigned, bufsize - - (block_start & bufmask), - block_size); - block_size -= stream.avail_in; - block_start = 0; - } - - while (stream.avail_out && stream.avail_in) { - zerr = zlib_inflate(&stream, Z_SYNC_FLUSH); - if (zerr == Z_BUF_ERROR && stream.avail_in == 0) - break; - if (zerr == Z_STREAM_END) - break; - if (zerr != Z_OK) { - /* EOF, error, or trying to read beyond end of input */ - if (zerr == Z_MEM_ERROR) - *errp = -ENOMEM; - else { - printk(KERN_DEBUG - "zisofs: zisofs_inflate returned" - " %d, inode = %lu," - " page idx = %d, bh idx = %d," - " avail_in = %d," - " avail_out = %d\n", - zerr, inode->i_ino, curpage, - curbh, stream.avail_in, - stream.avail_out); - *errp = -EIO; - } - goto inflate_out; - } - } - - if (!stream.avail_out) { - /* This page completed */ - if (pages[curpage]) { - flush_dcache_page(pages[curpage]); - SetPageUptodate(pages[curpage]); - } - curpage++; - } - if (!stream.avail_in) - curbh++; - } -inflate_out: - zlib_inflateEnd(&stream); - -z_eio: - mutex_unlock(&zisofs_zlib_lock); - -b_eio: - for (i = 0; i < haveblocks; i++) - brelse(bhs[i]); - return stream.total_out; -} - -/* - * Uncompress data so that pages[full_page] is fully uptodate and possibly - * fills in other pages if we have data for them. - */ -static int zisofs_fill_pages(struct inode *inode, int full_page, int pcount, - struct page **pages) -{ - loff_t start_off, end_off; - loff_t block_start, block_end; - unsigned int header_size = ISOFS_I(inode)->i_format_parm[0]; - unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1]; - unsigned int blockptr; - loff_t poffset = 0; - blkcnt_t cstart_block, cend_block; - struct buffer_head *bh; - unsigned int blkbits = ISOFS_BUFFER_BITS(inode); - unsigned int blksize = 1 << blkbits; - int err; - loff_t ret; - - BUG_ON(!pages[full_page]); - - /* - * We want to read at least 'full_page' page. Because we have to - * uncompress the whole compression block anyway, fill the surrounding - * pages with the data we have anyway... - */ - start_off = page_offset(pages[full_page]); - end_off = min_t(loff_t, start_off + PAGE_CACHE_SIZE, inode->i_size); - - cstart_block = start_off >> zisofs_block_shift; - cend_block = (end_off + (1 << zisofs_block_shift) - 1) - >> zisofs_block_shift; - - WARN_ON(start_off - (full_page << PAGE_CACHE_SHIFT) != - ((cstart_block << zisofs_block_shift) & PAGE_CACHE_MASK)); - - /* 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 + cstart_block) << 2; - bh = isofs_bread(inode, blockptr >> blkbits); - if (!bh) - return -EIO; - block_start = le32_to_cpu(*(__le32 *) - (bh->b_data + (blockptr & (blksize - 1)))); - - while (cstart_block < cend_block && pcount > 0) { - /* Load end of the compressed block in the file */ - blockptr += 4; - /* Traversed to next block? */ - if (!(blockptr & (blksize - 1))) { - brelse(bh); - - bh = isofs_bread(inode, blockptr >> blkbits); - if (!bh) - return -EIO; - } - block_end = le32_to_cpu(*(__le32 *) - (bh->b_data + (blockptr & (blksize - 1)))); - if (block_start > block_end) { - brelse(bh); - return -EIO; - } - err = 0; - ret = zisofs_uncompress_block(inode, block_start, block_end, - pcount, pages, poffset, &err); - poffset += ret; - pages += poffset >> PAGE_CACHE_SHIFT; - pcount -= poffset >> PAGE_CACHE_SHIFT; - full_page -= poffset >> PAGE_CACHE_SHIFT; - poffset &= ~PAGE_CACHE_MASK; - - if (err) { - brelse(bh); - /* - * Did we finish reading the page we really wanted - * to read? - */ - if (full_page < 0) - return 0; - return err; - } - - block_start = block_end; - cstart_block++; - } - - if (poffset && *pages) { - memset(page_address(*pages) + poffset, 0, - PAGE_CACHE_SIZE - poffset); - flush_dcache_page(*pages); - SetPageUptodate(*pages); - } - return 0; -} - -/* - * 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_path.dentry->d_inode; - struct address_space *mapping = inode->i_mapping; - int err; - int i, pcount, full_page; - unsigned int zisofs_block_shift = ISOFS_I(inode)->i_format_parm[1]; - unsigned int zisofs_pages_per_cblock = - PAGE_CACHE_SHIFT <= zisofs_block_shift ? - (1 << (zisofs_block_shift - PAGE_CACHE_SHIFT)) : 0; - struct page *pages[max_t(unsigned, zisofs_pages_per_cblock, 1)]; - pgoff_t index = page->index, end_index; - - end_index = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT; - /* - * If this page is wholly outside i_size we just return zero; - * do_generic_file_read() will handle this for us - */ - if (index >= end_index) { - SetPageUptodate(page); - unlock_page(page); - return 0; - } - - if (PAGE_CACHE_SHIFT <= zisofs_block_shift) { - /* We have already been given one page, this is the one - we must do. */ - full_page = index & (zisofs_pages_per_cblock - 1); - pcount = min_t(int, zisofs_pages_per_cblock, - end_index - (index & ~(zisofs_pages_per_cblock - 1))); - index -= full_page; - } else { - full_page = 0; - pcount = 1; - } - pages[full_page] = page; - - for (i = 0; i < pcount; i++, index++) { - if (i != full_page) - pages[i] = grab_cache_page_nowait(mapping, index); - if (pages[i]) { - ClearPageError(pages[i]); - kmap(pages[i]); - } - } - - err = zisofs_fill_pages(inode, full_page, pcount, pages); - - /* Release any residual pages, do not SetPageUptodate */ - for (i = 0; i < pcount; i++) { - if (pages[i]) { - flush_dcache_page(pages[i]); - if (i == full_page && err) - SetPageError(pages[i]); - kunmap(pages[i]); - unlock_page(pages[i]); - if (i != full_page) - page_cache_release(pages[i]); - } - } - - /* At this point, err contains 0 or -EIO depending on the "critical" page */ - return err; -} - -const struct address_space_operations zisofs_aops = { - .readpage = zisofs_readpage, - /* No sync_page operation supported? */ - /* No bmap operation supported */ -}; - -int __init zisofs_init(void) -{ - zisofs_zlib_workspace = vmalloc(zlib_inflate_workspacesize()); - if ( !zisofs_zlib_workspace ) - return -ENOMEM; - - return 0; -} - -void zisofs_cleanup(void) -{ - vfree(zisofs_zlib_workspace); -} |