/* -*- 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
  ",
  			       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
  ",
  					       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_inode(file);
  	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);
  }