root/morphix/trunk/cloop/compressed_loop.c

/*
 *  compressed_loop.c: Read-only compressed loop blockdevice
 *  hacked up by Rusty in 1999, extended and maintained by Klaus Knopper
 *
 *  cloop file looks like:
 *  [32-bit uncompressed block size: network order]
 *  [32-bit number of blocks (n_blocks): network order]
 *  [64-bit file offsets of start of blocks: network order]
 *    * (n_blocks + 1).
 * n_blocks of:
 *   [compressed block]
 *
 *  Inspired by loop.c by Theodore Ts'o, 3/29/93.
 *
 * Copyright 1999-2003 by Paul `Rusty' Russell & Klaus Knopper.
 * Redistribution of this file is permitted under the GNU Public License.
 *
 * CHANGES: (see CHANGELOG file)
 *
 * Hacked to load on 2.6 kernels, patch from Olivier Evalet (ntohl adding)
 */

#define CLOOP_NAME "cloop"
#define CLOOP_VERSION "2.01"
#define CLOOP_MAX 64

/* Define this if you are using Greenshoe Linux */
/* #define REDHAT_KERNEL */

#include <linux/version.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/major.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/devfs_fs_kernel.h>
#include <asm/semaphore.h>
#include <asm/div64.h> /* do_div() for 64bit division */
#include <asm/uaccess.h>
/* Use zlib_inflate from lib/zlib_inflate */
#include <linux/zutil.h>
#include <linux/loop.h>
// #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
// #include <linux/buffer_head.h>
// #endif
#include "compressed_loop.h"

/**
 * I had this error message so I have hadded the ntohl function
 * ntohl: Unknown symbol in module
 *
 * patch from Olivier Evalet
 */
#undef ntohl
uint32_t ntohl(x)
uint32_t x;
{
#if BYTE_ORDER == LITTLE_ENDIAN
        u_char *s = (u_char *)&x;
        return (uint32_t)(s[0] << 24 | s[1] << 16 | s[2] << 8 | s[3]);
#else
        return x;
#endif
}

/* end patch */

/* New License scheme */
#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
#ifdef MODULE_AUTHOR
MODULE_AUTHOR("Klaus Knopper (Kernel 2.4 and up, Knoppix version), Paul Russel (initial version)");
#endif
#ifdef MODULE_DESCRIPTION
MODULE_DESCRIPTION("Transparently decompressing loopback block device");
#endif

#ifndef MIN
#define MIN(x,y) ((x) < (y) ? (x) : (y))
#endif

#ifndef MAX
#define MAX(x,y) ((x) > (y) ? (x) : (y))
#endif

/* Use experimental major for now */
#define MAJOR_NR 240

#define DEVICE_NAME CLOOP_NAME
#define DEVICE_NR(device) (MINOR(device))
#define DEVICE_ON(device)
#define DEVICE_OFF(device)
#define DEVICE_NO_RANDOM
#define TIMEOUT_VALUE (6 * HZ)

#include <linux/blkdev.h>
#include <linux/buffer_head.h>

#if 0
#define DEBUGP printk
#else
#define DEBUGP(format, x...)
#endif

/* One file can be opened at module insertion time */
/* insmod cloop file=/path/to/file */
static char *file=NULL;
MODULE_PARM(file, "s");
MODULE_PARM_DESC(file, "Initial cloop image file (full path) for /dev/cloop");
static struct file *initial_file=NULL;

struct cloop_device
{
 /* Copied straight from the file */
 struct cloop_head head;

 /* An array of offsets of compressed blocks within the file */
 loff_t *offsets;

 /* We buffer one uncompressed `block' */
 int buffered_blocknum;
 void *buffer;
 void *compressed_buffer;

 z_stream zstream;

 struct file   *backing_file;  /* associated file */
 struct inode  *backing_inode; /* for bmap */

 unsigned int underlying_blksize;
 int refcnt;
 struct block_device *bdev;
 int isblkdev;
 struct semaphore clo_lock;
 struct gendisk *disk;
 request_queue_t *clo_queue;
};

static struct cloop_device cloop_dev[CLOOP_MAX];
static char *cloop_name=CLOOP_NAME;
static const int max_cloop = CLOOP_MAX;

#if (!(defined(CONFIG_ZLIB_INFLATE) || defined(CONFIG_ZLIB_INFLATE_MODULE))) /* Must be compiled into kernel. */
#error  "Invalid Kernel configuration. CONFIG_ZLIB_INFLATE support is needed for cloop."
#endif

static int uncompress(struct cloop_device *clo, char *dest, unsigned long *destLen,
                      char *source, unsigned long sourceLen)
{
 /* Most of this code can be found in fs/cramfs/uncompress.c */
 int err;
 clo->zstream.next_in = source;
 clo->zstream.avail_in = sourceLen;
 clo->zstream.next_out = dest;
 clo->zstream.avail_out = *destLen;
 err = zlib_inflateReset(&clo->zstream);
 if (err != Z_OK)
  {
   printk(KERN_ERR "%s: zlib_inflateReset error %d\n", cloop_name, err);
   zlib_inflateEnd(&clo->zstream); zlib_inflateInit(&clo->zstream);
  }
 err = zlib_inflate(&clo->zstream, Z_FINISH);
 *destLen = clo->zstream.total_out;
 if (err != Z_STREAM_END) return err;
 return Z_OK;
}

/* This is more complicated than it looks. */
struct clo_read_data
{
 struct cloop_device *clo;
 char *data; /* We need to keep track of where we are in the buffer */
 int bsize;
};

/* We need this for do_generic_file_read() because the default function */
/* wants to read into user-space for an unknown reason. :-/ See loop.c. */
static int clo_read_actor(read_descriptor_t * desc, struct page *page,
                          unsigned long offset, unsigned long size)
{
 char *kaddr;
 struct clo_read_data *p = (struct clo_read_data*)desc->arg.buf;
 unsigned long count = desc->count;
 if (size > count) size = count;
 kaddr = kmap(page);
 memcpy(p->data, kaddr + offset, size);
 kunmap(page);
 desc->count = count - size;
 desc->written += size;
 p->data += size;
 return size;
}

static size_t clo_read_from_file(struct cloop_device *clo, struct file *f, char *buf,
  loff_t pos, size_t buf_len)
{
 size_t buf_done=0;
 while (buf_done < buf_len)
  {
   size_t size = buf_len - buf_done;
   struct clo_read_data cd={ /* do_generic_file_read() needs this. */
           clo,              /* struct cloop_device *clo */
           (char *)(buf + buf_done), /* char *data */
           size};            /* Actual data size */
   read_descriptor_t desc;
   desc.written = 0;
   desc.count   = size;
   desc.arg.buf     = (char*)&cd;
   desc.error   = 0;
#ifdef REDHAT_KERNEL /* Greenshoe Linux */
   do_generic_file_read(f, &pos, &desc, clo_read_actor, 0);
#else /* Normal Kernel */
   do_generic_file_read(f, &pos, &desc, clo_read_actor);
#endif
   if(desc.error||desc.written<=0)
    {
     int left = size - desc.written;
     if(left<0) left = 0; /* better safe than sorry */
     printk(KERN_ERR "%s: Read error at pos %Lu in file %s, %d bytes lost.\n",
            cloop_name, pos, file, left);
     memset(buf + buf_len - left, 0, left);
     break;
    }
   buf_done+=desc.written;
  }
 return buf_done;
}

/* This looks more complicated than it is */
static int load_buffer(struct cloop_device *clo, int blocknum)
{
 unsigned int buf_done = 0;
 unsigned long buflen;
 unsigned int buf_length;
 int ret;

 if(blocknum > ntohl(clo->head.num_blocks) || blocknum < 0)
  {
   printk(KERN_WARNING "%s: Invalid block number %d requested.\n",
                       cloop_name, blocknum);
   clo->buffered_blocknum = -1;
   return 0;
  }

 if (blocknum == clo->buffered_blocknum) return 1;

 /* Is there a ntohl for 64-bit values? */
 buf_length = be64_to_cpu(clo->offsets[blocknum+1]) - be64_to_cpu(clo->offsets[blocknum]);

/* Load one compressed block from the file. */
 clo_read_from_file(clo, clo->backing_file, (char *)clo->compressed_buffer,
                    be64_to_cpu(clo->offsets[blocknum]), buf_length);

 /* Do decompression into real buffer. */
 buflen = ntohl(clo->head.block_size);

 /* Do the uncompression */
 ret = uncompress(clo, clo->buffer, &buflen, clo->compressed_buffer,
                  buf_length);
 /* DEBUGP("cloop: buflen after uncompress: %ld\n",buflen); */
 if (ret != 0)
  {
   printk(KERN_ERR "%s: error %i uncompressing block %u %u/%lu/%u/%u "
          "%Lu-%Lu\n", cloop_name, ret, blocknum,
          ntohl(clo->head.block_size), buflen, buf_length, buf_done,
          be64_to_cpu(clo->offsets[blocknum]), be64_to_cpu(clo->offsets[blocknum+1]));
   clo->buffered_blocknum = -1;
   return 0;
  }
 clo->buffered_blocknum = blocknum;
 return 1;
}

static int make_clo_request(request_queue_t *q, struct bio *bio)
{
 struct cloop_device *cloop;
 int status = 0;
 unsigned int len;
 loff_t offset;
 char *dest;

 int rw = bio_rw(bio);
 unsigned int vecnr;
 cloop = q->queuedata;

 /* quick sanity checks */
 if (rw != READ && rw != READA)
  {
   DEBUGP("do_clo_request: bad command\n");
   goto out;
  }

 if (!cloop->backing_file)
  {
   DEBUGP("do_clo_request: not connected to a file\n");
   goto out;
  }

 down(&cloop->clo_lock);
 offset     = (loff_t)bio->bi_sector << 9;
 for(vecnr=0; vecnr < bio->bi_vcnt; vecnr++)
  {
   struct bio_vec *bvec=&bio->bi_io_vec[vecnr];
   len = bvec->bv_len;
   dest= kmap(bvec->bv_page) + bvec->bv_offset;
  
 while(len > 0)
  {
   u_int32_t length_in_buffer;
   loff_t block_offset=offset;
  
   /* do_div (div64.h) returns the 64bit division remainder and  */
   /* puts the result in the first argument, i.e. block_offset   */
   /* becomes the blocknumber to load, and offset_in_buffer the  */
   /* position in the buffer */
   u_int32_t offset_in_buffer;
   offset_in_buffer = do_div(block_offset, ntohl(cloop->head.block_size));
 
   status=load_buffer(cloop,block_offset);
   if(!status) break; /* invalid data, leave inner loop, goto next request */
  
   /* Now, at least part of what we want will be in the buffer. */
   length_in_buffer = ntohl(cloop->head.block_size) - offset_in_buffer;
  
   if(length_in_buffer > len)
    {
/*     DEBUGP("Warning: length_in_buffer=%u > len=%u\n",
                        length_in_buffer,len); */
     length_in_buffer = len;
    }

   memcpy(dest, cloop->buffer + offset_in_buffer, length_in_buffer);

   dest   += length_in_buffer;
   len    -= length_in_buffer;
   offset += length_in_buffer;
  } /* while inner loop */

   kunmap(bvec->bv_page);
  } /* end for vecnr*/

 up(&cloop->clo_lock);

out:
 bio_endio(bio, bio->bi_size,status==0);
 return 0;
}

/* Read header and offsets from already opened file */
static int clo_set_file(int cloop_num, struct file *file, char *filename)
{
 struct cloop_device *clo=&cloop_dev[cloop_num];
 struct inode *inode;
 char *bbuf=NULL;
 unsigned int i, offsets_read, total_offsets;
 unsigned long largest_block=0;
 int isblkdev;

 int error = 0;

 inode = file->f_dentry->d_inode;
 isblkdev=S_ISBLK(inode->i_mode)?1:0;
 if(!isblkdev&&!S_ISREG(inode->i_mode))
  {
   printk(KERN_ERR "%s: %s not a regular file or block device\n",
                   cloop_name, filename);
   error=-EBADF; goto error_release;
  }

 clo->backing_file = file;
 clo->backing_inode= inode ;

 if(!isblkdev&&inode->i_size<sizeof(struct cloop_head))
  {
   printk(KERN_ERR "%s: %lu bytes (must be >= %u bytes)\n",
                   cloop_name, (unsigned long)inode->i_size,
                   (unsigned)sizeof(struct cloop_head));
   error=-EBADF; goto error_release;
  }
/* Somehow blksize_size doesn't exist anymore, so we ignore this bit...
 if(isblkdev)
  {
   request_queue_t *q = bdev_get_queue(inode->i_bdev);
   blk_queue_max_sectors(clo->clo_queue, q->max_sectors);
   blk_queue_max_phys_segments(clo->clo_queue,q->max_phys_segments);
   blk_queue_max_hw_segments(clo->clo_queue, q->max_hw_segments);
   blk_queue_max_segment_size(clo->clo_queue, q->max_segment_size);
   blk_queue_segment_boundary(clo->clo_queue, q->seg_boundary_mask);
   blk_queue_merge_bvec(clo->clo_queue, q->merge_bvec_fn);
   clo->underlying_blksize = blksize_size(inode->i_bdev);
 }
 else */
   clo->underlying_blksize = inode->i_blksize;

 DEBUGP("Underlying blocksize is %u\n", clo->underlying_blksize);

 bbuf = vmalloc(clo->underlying_blksize);
 if(!bbuf)
  {
   printk(KERN_ERR "%s: out of kernel mem for block buffer (%lu bytes)\n",
                   cloop_name, (unsigned long)clo->underlying_blksize);
   error=-ENOMEM; goto error_release;
  }
 total_offsets = 1; /* Dummy total_offsets: will be filled in first time around */
 for (i = 0, offsets_read = 0; offsets_read < total_offsets; i++)
  {
   unsigned int offset = 0, num_readable;

   /* Kernel 2.4 version */
   size_t bytes_read = clo_read_from_file(clo, file, bbuf,
                                          i*clo->underlying_blksize,
                                          clo->underlying_blksize);
   if(bytes_read != clo->underlying_blksize) { error=-EBADF; goto error_release; }

   /* Header will be in block zero */
   if(i==0)
    {
     memcpy(&clo->head, bbuf, sizeof(struct cloop_head));
     offset = sizeof(struct cloop_head);
     if (ntohl(clo->head.block_size) % 512 != 0)
      {
       printk(KERN_ERR "%s: blocksize %u not multiple of 512\n",
              cloop_name, ntohl(clo->head.block_size));
       error=-EBADF; goto error_release;
      }

     if (clo->head.preamble[0x0B]!='V'||clo->head.preamble[0x0C]<'1')
      {
       printk(KERN_ERR "%s: Cannot read old 32-bit (version 0.68) images, "
                       "please use an older version of %s for this file.\n",
                       cloop_name, cloop_name);
       error=-EBADF; goto error_release;
      }

     if (clo->head.preamble[0x0C]<'2')
      {
       printk(KERN_ERR "%s: Cannot read old architecture-dependent "
                       "(format <= 1.0) images, please use an older "
                       "version of %s for this file.\n",
                       cloop_name, cloop_name);
       error=-EBADF; goto error_release;
      }

     total_offsets=ntohl(clo->head.num_blocks)+1;

     if (!isblkdev && (sizeof(struct cloop_head)+sizeof(loff_t)*
                       total_offsets > inode->i_size))
      {
       printk(KERN_ERR "%s: file too small for %u blocks\n",
              cloop_name, ntohl(clo->head.num_blocks));
       error=-EBADF; goto error_release;
      }

     clo->offsets = vmalloc(sizeof(loff_t) * total_offsets);
     if (!clo->offsets)
      {
       printk(KERN_ERR "%s: out of kernel mem for offsets\n", cloop_name);
       error=-ENOMEM; goto error_release;
      }
    }

   num_readable = MIN(total_offsets - offsets_read,
                      (clo->underlying_blksize - offset) 
                      / sizeof(loff_t));
   memcpy(&clo->offsets[offsets_read], bbuf+offset, num_readable * sizeof(loff_t));
   offsets_read += num_readable;
  }

  { /* Search for largest block rather than estimate. KK. */
   int i;
   for(i=0;i<total_offsets-1;i++)
    {
     loff_t d=be64_to_cpu(clo->offsets[i+1]) - be64_to_cpu(clo->offsets[i]);
     largest_block=MAX(largest_block,d);
    }
   printk("%s: %s: %u blocks, %u bytes/block, largest block is %lu bytes.\n",
          cloop_name, filename, ntohl(clo->head.num_blocks),
          ntohl(clo->head.block_size), largest_block);
  }

/* Combo kmalloc used too large chunks (>130000). */
 clo->buffer = vmalloc(ntohl(clo->head.block_size));
 if(!clo->buffer)
  {
   printk(KERN_ERR "%s: out of memory for buffer %lu\n",
          cloop_name, (unsigned long) ntohl(clo->head.block_size));
   error=-ENOMEM; goto error_release_free;
  }

 clo->compressed_buffer = vmalloc(largest_block);

 if(!clo->compressed_buffer)
  {
   printk(KERN_ERR "%s: out of memory for compressed buffer %lu\n",
          cloop_name, largest_block);
   error=-ENOMEM; goto error_release_free_buffer;
  }
 clo->zstream.workspace = vmalloc(zlib_inflate_workspacesize());
 if(!clo->zstream.workspace)
  {
   printk(KERN_ERR "%s: out of mem for zlib working area %u\n",
          cloop_name, zlib_inflate_workspacesize());
   error=-ENOMEM; goto error_release_free_all;
  }
 zlib_inflateInit(&clo->zstream);

 if(!isblkdev &&
    be64_to_cpu(clo->offsets[ntohl(clo->head.num_blocks)]) != inode->i_size)
  {
   printk(KERN_ERR "%s: final offset wrong (%Lu not %Lu)\n",
          cloop_name,
          be64_to_cpu(clo->offsets[ntohl(clo->head.num_blocks)]),
          inode->i_size);
   vfree(clo->zstream.workspace); clo->zstream.workspace=NULL;
   goto error_release_free_all;
  }

 clo->buffered_blocknum = -1;
 set_capacity(clo->disk, (sector_t)(ntohl(clo->head.num_blocks)*(ntohl(clo->head.block_size)>>9)));
 return error;

error_release_free_all:
 vfree(clo->compressed_buffer);
 clo->compressed_buffer=NULL;
error_release_free_buffer:
 vfree(clo->buffer);
 clo->buffer=NULL;
error_release_free:
 vfree(clo->offsets);
 clo->offsets=NULL;
error_release:
 if(bbuf) vfree(bbuf);
 clo->backing_file=NULL;
 return error;
}

/* Code adapted from Theodore Ts'o's linux/drivers/block/loop.c */ 
/* Get file from ioctl arg (losetup) */
static int clo_set_fd(int cloop_num, struct file *clo_file,