On Wed, Sep 16, 2009 at 03:50:47PM -0700, Greg KH wrote:
> On Thu, Sep 17, 2009 at 01:16:29AM +0400, Denis Kirjanov <kirjanov@xxxxxxxxx wrote:
> > Good time of day.
> >
> > I want to take on work related to the cowloop driver. Anybody else
> > involved with this?
>
> The original author is, you should also copy him.
>
> Attached is his latest version, if you could turn this into a patch
> against Linus's latest tree, that would be wonderful. Unfortunaly, I
> have to take a last-minute-business trip tomorrow and can't get to it
> for a few weeks :(
Doh, here's the file...
/*
** COWLOOP block device driver (2.6 kernel compliant)
** =======================================================================
** Read-write loop-driver with copy-on-write functionality.
**
** Synopsis:
**
** modprobe cowloop [maxcows=..] [rdofile=..... cowfile=.... [option=r]]
**
** Definition of number of configured cowdevices:
** maxcows= number of configured cowdevices (default: 16)
** (do not confuse this with MAXCOWS: absolute maximum as compiled)
**
** One pair of filenames can be supplied during insmod/modprobe to open
** the first cowdevice:
** rdofile= read-only file (or filesystem)
** cowfile= storage-space for modified blocks of read-only file(system)
** option=r repair cowfile automatically if it appears to be dirty
**
** Other cowdevices can be activated via the command "cowdev"
** whenever the cowloop-driver is loaded.
**
** The read-only file may be of type 'regular' or 'block-device'.
**
** The cowfile must be of type 'regular'.
** If an existing regular file is used as cowfile, its contents will be
** used again for the current read-only file. When the cowfile has not been
** closed properly during a previous session (i.e. rmmod cowloop), the
** cowloop-driver refuses to open it unless the parameter "option=r" is
** specified.
**
** Layout of cowfile:
**
** +-----------------------------+
** | cow head block | MAPUNIT bytes
** |-----------------------------|
** | | MAPUNIT bytes
** |--- ---|
** | | MAPUNIT bytes
** |--- ---|
** | used-block bitmap | MAPUNIT bytes
** |-----------------------------|
** | gap to align start-offset |
** | to 4K multiple |
** |-----------------------------| <---- start-offset cow blocks
** | |
** | written cow blocks | MAPUNIT bytes
** | ..... |
**
** cowhead block:
** - contains general info about the rdofile which is related
** to this cowfile
**
** used-block bitmap:
** - contains one bit per block with a size of MAPUNIT bytes
** - bit-value '1' = block has been written on cow
** '0' = block unused on cow
** - total bitmap rounded to multiples of MAPUNIT
**
** ============================================================================
** Author: Gerlof Langeveld - AT Computing (March 2003)
** Current maintainer: Hendrik-Jan Thomassen - AT Computing (Summer 2006)
** Email: hjt@xxxxxxxxxxxxxx
** ----------------------------------------------------------------------------
** Copyright (C) 2003-2009 AT Consultancy
**
** 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; either version 2, or (at your option) any
** later version.
**
** This program is distributed in the hope that it will be useful, but
** WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
** See the GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
** ----------------------------------------------------------------------------
**
** Major modifications:
**
** 200405 Ported to kernel-version 2.6 Hendrik-Jan Thomassen
** 200405 Added cowhead to cowfile to garantee
** consistency with read-only file Gerlof Langeveld
** 200405 Postponed flushing of bitmaps to improve
** performance. Gerlof Langeveld
** 200405 Inline recovery for dirty cowfiles. Gerlof Langeveld
** 200502 Redesign to support more cowdevices. Gerlof Langeveld
** 200502 Support devices/file > 2 Gbytes. Gerlof Langeveld
** 200507 Check for free space to expand cowfile. Gerlof Langeveld
** 200902 Upgrade for kernel 2.6.28 Hendrik-Jan Thomassen
** 200909 Upgrade for kernel 2.6.30 and cleaned up the code
** for inclusion in main kernel tree Hendrik-Jan Thomassen
**
** Inspired by
** loop.c by Theodore Ts'o and
** cloop.c by Paul `Rusty' Russell & Klaus Knopper.
**
** Design-considerations:
**
** For the first experiments with the cowloop-driver, the request-queue
** made use of the do_generic_file_read() which worked fine except
** in combination with the cloop-driver; that combination
** resulted in a non-interruptible hangup of the system during
** heavy load. Other experiments using the `make_request' interface also
** resulted in unpredictable system hangups (with proper use of spinlocks).
**
** To overcome these problems, the cowloop-driver starts a kernel-thread
** for every active cowdevice.
** All read- and write-request on the read-only file and copy-on-write file
** are handled in the context of that thread.
** A scheme has been designed to wakeup the kernel-thread as
** soon as I/O-requests are available in the request-queue; this thread
** handles the requests one-by-one by calling the proper read- or
** write-function related to the open read-only file or copy-on-write file.
** When all pending requests have been handled, the kernel-thread goes
** back to sleep-state.
** This approach requires some additional context-switches; however the
** performance loss during heavy I/O is less than 3%.
**
** -------------------------------------------------------------------------*/
/* The following is the cowloop package version number. It must be
identical to the content of the include-file "version.h" that is
used in all supporting utilities: */
static char cowloop_version[] = "3.2";
#define COWMAJOR 241
/* #define COWDEBUG */
#ifdef COWDEBUG
#define DEBUGP printk
#define DCOW KERN_ALERT
#else /* define DEBUGP to be nothing */
#define DEBUGP(format, x...)
#endif
#include <linux/types.h>
#include <linux/autoconf.h>
#ifndef AUTOCONF_INCLUDED
#include <linux/config.h>
#endif
#include <linux/module.h>
#include <linux/version.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/sched.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/stat.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/semaphore.h>
#include <linux/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/hdreg.h>
#include <linux/genhd.h>
#include <linux/statfs.h>
#include "cowloop.h"
MODULE_LICENSE("GPL");
/* Original author is (but the e-mail address is now obsolete): */
/* MODULE_AUTHOR("Gerlof Langeveld <gerlof@xxxxxxxxxxxxxx>"); */
/* Current maintainer is: */
MODULE_AUTHOR("Hendrik-Jan Thomassen <hjt@xxxxxxxxxxxxxx>");
MODULE_DESCRIPTION("Copy-on-write loop driver");
MODULE_PARM_DESC(maxcows, " Number of configured cowdevices (default 16)");
MODULE_PARM_DESC(rdofile, " Read-only file for /dev/cow/0");
MODULE_PARM_DESC(cowfile, " Cowfile for /dev/cow/0");
MODULE_PARM_DESC(option, " Repair cowfile if inconsistent: option=r");
#define DEVICE_NAME "cow"
#define DFLCOWS 16 /* default cowloop devices */
static int maxcows = DFLCOWS;
module_param(maxcows, int, 0);
static char *rdofile = "";
module_param(rdofile, charp, 0);
static char *cowfile = "";
module_param(cowfile, charp, 0);
static char *option = "";
module_param(option, charp, 0);
/*
** per cowdevice several bitmap chunks are allowed of MAPCHUNKSZ each
**
** each bitmap chunk can describe MAPCHUNKSZ * 8 * MAPUNIT bytes of data
** suppose:
** MAPCHUNKSZ 4096 and MAPUNIT 1024 --> 4096 * 8 * 1024 = 32 Mb per chunk
*/
#define MAPCHUNKSZ 4096 /* #bytes per bitmap chunk (do not change) */
#define SPCMINBLK 100 /* space threshold to give warning messages */
#define SPCDFLINTVL 16 /* once every SPCDFLINTVL writes to cowfile, */
/* available space in filesystem is checked */
#define CALCMAP(x) ((x)/(MAPCHUNKSZ*8))
#define CALCBYTE(x) (((x)%(MAPCHUNKSZ*8))>>3)
#define CALCBIT(x) ((x)&7)
#define ALLCOW 1
#define ALLRDO 2
#define MIXEDUP 3
static char allzeroes[MAPUNIT];
/*
** administration per cowdevice (pair of cowfile/rdofile)
*/
/* bit-values for state */
#define COWDEVOPEN 0x01 /* cowdevice opened */
#define COWRWCOWOPEN 0x02 /* cowfile opened read-write */
#define COWRDCOWOPEN 0x04 /* cowfile opened read-only */
#define COWWATCHDOG 0x08 /* ioctl for watchdog cowfile space active */
#define COWCOWOPEN (COWRWCOWOPEN|COWRDCOWOPEN)
struct cowloop_device {
/*
** current status
*/
int state; /* bit-values (see above) */
int opencnt; /* # opens for cowdevice */
/*
** open file pointers
*/
struct file *rdofp, *cowfp; /* open file pointers */
char *rdoname, *cowname; /* file names */
/*
** request queue administration
*/
struct request_queue *rqueue;
spinlock_t rqlock;
struct gendisk *gd;
/*
** administration about read-only file
*/
unsigned int numblocks; /* # blocks input file in MAPUNIT */
unsigned int blocksz; /* minimum unit to access this dev */
unsigned long fingerprint; /* fingerprint of current rdofile */
struct block_device *belowdev; /* block device below us */
struct gendisk *belowgd; /* gendisk for blk dev below us */
struct request_queue *belowq; /* req. queue of blk dev below us */
/*
** bitmap administration to register which blocks are modified
*/
long int mapsize; /* total size of bitmap (bytes) */
long int mapremain; /* remaining bytes in last bitmap */
int mapcount; /* number of bitmaps in use */
char **mapcache; /* area with pointers to bitmaps */
char *iobuf; /* databuffer of MAPUNIT bytes */
struct cowhead *cowhead; /* buffer containing cowhead */
/*
** administration for interface with the kernel-thread
*/
int pid; /* pid==0: no thread available */
struct request *req; /* request to be handled now */
wait_queue_head_t waitq; /* wait-Q: thread waits for work */
char closedown; /* boolean: thread exit required */
char qfilled; /* boolean: I/O request pending */
char iobusy; /* boolean: req under treatment */
/*
** administration to keep track of free space in cowfile filesystem
*/
unsigned long blksize; /* block size of fs (bytes) */
unsigned long blktotal; /* recent total space in fs (blocks) */
unsigned long blkavail; /* recent free space in fs (blocks) */
wait_queue_head_t watchq; /* wait-Q: watcher awaits threshold */
unsigned long watchthresh; /* threshold of watcher (blocks) */
/*
** statistical counters
*/
unsigned long rdoreads; /* number of read-actions rdo */
unsigned long cowreads; /* number of read-actions cow */
unsigned long cowwrites; /* number of write-actions */
unsigned long nrcowblocks; /* number of blocks in use on cow */
};
static struct cowloop_device **cowdevall; /* ptr to ptrs to all cowdevices */
static struct semaphore cowdevlock; /* generic lock for cowdevs */
static struct gendisk *cowctlgd; /* gendisk control channel */
static spinlock_t cowctlrqlock; /* for req.q. of ctrl. channel */
/*
** private directory /proc/cow
*/
static struct proc_dir_entry *cowlo_procdir;
/*
** function prototypes
*/
static long int cowlo_do_request(struct request *req);
static void cowlo_sync(void);
static int cowlo_checkio(struct cowloop_device *, int, loff_t);
static int cowlo_readmix(struct cowloop_device *, void *, int, loff_t);
static int cowlo_writemix(struct cowloop_device *, void *, int, loff_t);
static long int cowlo_readrdo(struct cowloop_device *, void *, int, loff_t);
static long int cowlo_readcow(struct cowloop_device *, void *, int, loff_t);
static long int cowlo_readcowraw(struct cowloop_device *, void *, int, loff_t);
static long int cowlo_writecow(struct cowloop_device *, void *, int, loff_t);
static long int cowlo_writecowraw(struct cowloop_device *, void *, int, loff_t);
static int cowlo_ioctl(struct block_device *, fmode_t,
unsigned int, unsigned long);
static int cowlo_makepair(struct cowpair __user *);
static int cowlo_removepair(unsigned long __user *);
static int cowlo_watch(struct cowpair __user *);
static int cowlo_cowctl(unsigned long __user *, int);
static int cowlo_openpair(char *, char *, int, int);
static int cowlo_closepair(struct cowloop_device *);
static int cowlo_openrdo(struct cowloop_device *, char *);
static int cowlo_opencow(struct cowloop_device *, char *, int);
static void cowlo_undo_openrdo(struct cowloop_device *);
static void cowlo_undo_opencow(struct cowloop_device *);
/*****************************************************************************/
/* System call handling */
/*****************************************************************************/
/*
** handle system call open()/mount()
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_open(struct block_device *bdev, fmode_t mode)
{
struct inode *inode = bdev->bd_inode;
if (!inode)
return -EINVAL;
if (imajor(inode) != COWMAJOR) {
printk(KERN_WARNING
"cowloop - unexpected major %d\n", imajor(inode));
return -ENODEV;
}
switch (iminor(inode)) {
case COWCTL:
DEBUGP(DCOW"cowloop - open %d control\n", COWCTL);
break;
default:
DEBUGP(DCOW"cowloop - open minor %d\n", iminor(inode));
if (iminor(inode) >= maxcows)
return -ENODEV;
if (!((cowdevall[iminor(inode)])->state & COWDEVOPEN))
return -ENODEV;
(cowdevall[iminor(inode)])->opencnt++;
}
return 0;
}
/*
** handle system call close()/umount()
**
** returns:
** 0 - okay
*/
static int
cowlo_release(struct gendisk *gd, fmode_t mode)
{
struct block_device *bdev;
struct inode *inode;
bdev = bdget_disk(gd, 0);
inode = bdev->bd_inode;
if (!inode)
return 0;
DEBUGP(DCOW"cowloop - release (close) minor %d\n", iminor(inode));
if (iminor(inode) != COWCTL)
(cowdevall[iminor(inode)])->opencnt--;
return 0;
}
/*
** handle system call ioctl()
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_ioctl(struct block_device *bdev, fmode_t mode,
unsigned int cmd, unsigned long arg)
{
struct hd_geometry geo;
struct inode *inode = bdev->bd_inode;
DEBUGP(DCOW "cowloop - ioctl cmd %x\n", cmd);
switch (iminor(inode)) {
/*
** allowed via control device only
*/
case COWCTL:
switch (cmd) {
/*
** write all bitmap chunks and cowheaders to cowfiles
*/
case COWSYNC:
down(&cowdevlock);
cowlo_sync();
up(&cowdevlock);
return 0;
/*
** open a new cowdevice (pair of rdofile/cowfile)
*/
case COWMKPAIR:
return cowlo_makepair((void __user *)arg);
/*
** close a cowdevice (pair of rdofile/cowfile)
*/
case COWRMPAIR:
return cowlo_removepair((void __user *)arg);
/*
** watch free space of filesystem containing cowfile
*/
case COWWATCH:
return cowlo_watch((void __user *)arg);
/*
** close cowfile for active device
*/
case COWCLOSE:
return cowlo_cowctl((void __user *)arg, COWCLOSE);
/*
** reopen cowfile read-only for active device
*/
case COWRDOPEN:
return cowlo_cowctl((void __user *)arg, COWRDOPEN);
default:
return -EINVAL;
} /* end of switch on command */
/*
** allowed for any other cowdevice
*/
default:
switch (cmd) {
/*
** HDIO_GETGEO must be supported for fdisk, etc
*/
case HDIO_GETGEO:
geo.cylinders = 0;
geo.heads = 0;
geo.sectors = 0;
if (copy_to_user((void __user *)arg, &geo, sizeof geo))
return -EFAULT;
return 0;
default:
return -EINVAL;
} /* end of switch on ioctl-cmd code parameter */
} /* end of switch on minor number */
}
static struct block_device_operations cowlo_fops = {
.owner = THIS_MODULE,
.open = cowlo_open, /* called upon open */
.release = cowlo_release, /* called upon close */
.ioctl = cowlo_ioctl, /* called upon ioctl */
};
/*
** handle ioctl-command COWMKPAIR:
** open a new cowdevice (pair of rdofile/cowfile) on-the-fly
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_makepair(struct cowpair __user *arg)
{
int i, retval = 0;
struct cowpair cowpair;
unsigned char *cowpath;
unsigned char *rdopath;
/*
** retrieve info about pathnames
*/
if (copy_from_user(&cowpair, arg, sizeof cowpair))
return -EFAULT;
if ((MAJOR(cowpair.device) != COWMAJOR) && (cowpair.device != ANYDEV))
return -EINVAL;
if ((MINOR(cowpair.device) >= maxcows) && (cowpair.device != ANYDEV))
return -EINVAL;
/*
** retrieve pathname strings
*/
if ((cowpair.cowflen > PATH_MAX) || (cowpair.rdoflen > PATH_MAX))
return -ENAMETOOLONG;
cowpath = kmalloc(cowpair.cowflen+1, GFP_KERNEL);
if (cowpath == NULL)
return -ENOMEM;
if (copy_from_user(cowpath, (void __user *)cowpair.cowfile,
cowpair.cowflen)) {
kfree(cowpath);
return -EFAULT;
}
*(cowpath+cowpair.cowflen) = 0;
rdopath = kmalloc(cowpair.rdoflen+1, GFP_KERNEL);
if (rdopath == NULL) {
kfree(cowpath);
return -ENOMEM;
}
if (copy_from_user(rdopath, (void __user *)cowpair.rdofile,
cowpair.rdoflen)) {
kfree(rdopath);
kfree(cowpath);
return -EFAULT;
}
*(rdopath+cowpair.rdoflen) = 0;
/*
** open new cowdevice
*/
if (cowpair.device == ANYDEV) {
/*
** search first unused minor
*/
for (i = 0, retval = -EBUSY; i < maxcows; i++) {
if (!((cowdevall[i])->state & COWDEVOPEN)) {
retval = cowlo_openpair(rdopath, cowpath, 0, i);
break;
}
}
if (retval) { /* open failed? */
kfree(rdopath);
kfree(cowpath);
return retval;
}
/*
** return newly allocated cowdevice to user space
*/
cowpair.device = MKDEV(COWMAJOR, i);
if (copy_to_user(arg, &cowpair, sizeof cowpair)) {
kfree(rdopath);
kfree(cowpath);
return -EFAULT;
}
} else { /* specific minor requested */
retval = cowlo_openpair(rdopath, cowpath, 0,
MINOR(cowpair.device));
if (retval) {
kfree(rdopath);
kfree(cowpath);
return retval;
}
}
return 0;
}
/*
** handle ioctl-command COWRMPAIR:
** deactivate an existing cowdevice (pair of rdofile/cowfile) on-the-fly
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_removepair(unsigned long __user *arg)
{
unsigned long cowdevice;
struct cowloop_device *cowdev;
/*
** retrieve info about device to be removed
*/
if (copy_from_user(&cowdevice, arg, sizeof cowdevice))
return -EFAULT;
/*
** verify major-minor number
*/
if (MAJOR(cowdevice) != COWMAJOR)
return -EINVAL;
if (MINOR(cowdevice) >= maxcows)
return -EINVAL;
cowdev = cowdevall[MINOR(cowdevice)];
if (!(cowdev->state & COWDEVOPEN))
return -ENODEV;
/*
** synchronize bitmaps and close cowdevice
*/
if (cowdev->state & COWRWCOWOPEN) {
down(&cowdevlock);
cowlo_sync();
up(&cowdevlock);
}
return cowlo_closepair(cowdev);
}
/*
** handle ioctl-command COWWATCH:
** watch the free space of the filesystem containing a cowfile
** of an open cowdevice
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_watch(struct cowpair __user *arg)
{
struct cowloop_device *cowdev;
struct cowwatch cowwatch;
/*
** retrieve structure holding info
*/
if (copy_from_user(&cowwatch, arg, sizeof cowwatch))
return -EFAULT;
/*
** verify if cowdevice exists and is currently open
*/
if (MINOR(cowwatch.device) >= maxcows)
return -EINVAL;
cowdev = cowdevall[MINOR(cowwatch.device)];
if (!(cowdev->state & COWDEVOPEN))
return -ENODEV;
/*
** if the WATCHWAIT-option is set, wait until the indicated
** threshold is reached (only one waiter allowed)
*/
if (cowwatch.flags & WATCHWAIT) {
/*
** check if already another waiter active
** for this cowdevice
*/
if (cowdev->state & COWWATCHDOG)
return -EAGAIN;
cowdev->state |= COWWATCHDOG;
cowdev->watchthresh = (unsigned long long)
cowwatch.threshold /
(cowdev->blksize / 1024);
if (wait_event_interruptible(cowdev->watchq,
cowdev->watchthresh >= cowdev->blkavail)) {
cowdev->state &= ~COWWATCHDOG;
return EINTR;
}
cowdev->state &= ~COWWATCHDOG;
}
cowwatch.totalkb = (unsigned long long)cowdev->blktotal *
cowdev->blksize / 1024;
cowwatch.availkb = (unsigned long long)cowdev->blkavail *
cowdev->blksize / 1024;
if (copy_to_user(arg, &cowwatch, sizeof cowwatch))
return -EFAULT;
return 0;
}
/*
** handle ioctl-commands COWCLOSE and COWRDOPEN:
** COWCLOSE - close the cowfile while the cowdevice remains open;
** this allows an unmount of the filesystem on which
** the cowfile resides
** COWRDOPEN - close the cowfile and reopen it for read-only;
** this allows a remount read-ony of the filesystem
** on which the cowfile resides
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_cowctl(unsigned long __user *arg, int cmd)
{
struct cowloop_device *cowdev;
unsigned long cowdevice;
/*
** retrieve info about device to be removed
*/
if (copy_from_user(&cowdevice, arg, sizeof cowdevice))
return -EFAULT;
/*
** verify major-minor number
*/
if (MAJOR(cowdevice) != COWMAJOR)
return -EINVAL;
if (MINOR(cowdevice) >= maxcows)
return -EINVAL;
cowdev = cowdevall[MINOR(cowdevice)];
if (!(cowdev->state & COWDEVOPEN))
return -ENODEV;
/*
** synchronize bitmaps and close cowfile
*/
if (cowdev->state & COWRWCOWOPEN) {
down(&cowdevlock);
cowlo_sync();
up(&cowdevlock);
}
/*
** handle specific ioctl-command
*/
switch (cmd) {
case COWRDOPEN:
/*
** if the cowfile is still opened read-write
*/
if (cowdev->state & COWRWCOWOPEN) {
/*
** close the cowfile
*/
if (cowdev->cowfp)
filp_close(cowdev->cowfp, 0);
cowdev->state &= ~COWRWCOWOPEN;
/*
** open again for read-only
*/
cowdev->cowfp = filp_open(cowdev->cowname,
O_RDONLY|O_LARGEFILE, 0600);
if ((cowdev->cowfp == NULL) || IS_ERR(cowdev->cowfp)) {
printk(KERN_ERR
"cowloop - failed to reopen cowfile %s\n",
cowdev->cowname);
return -EINVAL;
}
/*
** mark cowfile open for read-only
*/
cowdev->state |= COWRDCOWOPEN;
} else {
return -EINVAL;
}
break;
case COWCLOSE:
/*
** if the cowfile is still open
*/
if (cowdev->state & COWCOWOPEN) {
/*
** close the cowfile
*/
if (cowdev->cowfp)
filp_close(cowdev->cowfp, 0);
cowdev->state &= ~COWCOWOPEN;
}
}
return 0;
}
/*****************************************************************************/
/* Handling of I/O-requests for a cowdevice */
/*****************************************************************************/
/*
** function to be called by core-kernel to handle the I/O-requests
** in the queue
*/
static void
cowlo_request(struct request_queue *q)
{
struct request *req;
struct cowloop_device *cowdev;
DEBUGP(DCOW "cowloop - request function called....\n");
while ((req = blk_peek_request(q)) != NULL) {
DEBUGP(DCOW "cowloop - got next request\n");
if (!blk_fs_request(req)) {
/* this is not a normal file system request */
__blk_end_request_cur(req, -EIO);
continue;
}
cowdev = req->rq_disk->private_data;
if (cowdev->iobusy)
return;
else
cowdev->iobusy = 1;
/*
** when no kernel-thread is available, the request will
** produce an I/O-error
*/
if (!cowdev->pid) {
printk(KERN_ERR"cowloop - no thread available\n");
__blk_end_request_cur(req, -EIO); /* request failed */
cowdev->iobusy = 0;
continue;
}
/*
** handle I/O-request in the context of the kernel-thread
*/
cowdev->req = req;
cowdev->qfilled = 1;
wake_up_interruptible_sync(&cowdev->waitq);
/*
** get out of this function now while the I/O-request is
** under treatment of the kernel-thread; this function
** will be called again after the current I/O-request has
** been finished by the thread
*/
return;
}
}
/*
** daemon-process (kernel-thread) executes this function
*/
static int
cowlo_daemon(struct cowloop_device *cowdev)
{
int retval;
int minor;
char myname[16];
for (minor = 0; minor < maxcows; minor++) {
if (cowdev == cowdevall[minor])
break;
}
sprintf(myname, "cowloopd%d", minor);
daemonize(myname);
while (!cowdev->closedown) {
/*
** sleep while waiting for an I/O request;
** note that no non-interruptible wait has been used
** because the non-interruptible version of
** a *synchronous* wake_up does not exist (any more)
*/
if (wait_event_interruptible(cowdev->waitq, cowdev->qfilled)) {
flush_signals(current); /* ignore signal-based wakeup */
continue;
}
if (cowdev->closedown) /* module will be unloaded ? */{
cowdev->pid = 0;
return 0;
}
/*
** woken up by the I/O-request handler: treat requested I/O
*/
cowdev->qfilled = 0;
retval = cowlo_do_request(cowdev->req);
/*
** reacquire the queue-spinlock for manipulating
** the request-queue and dequeue the request
*/
spin_lock_irq(&cowdev->rqlock);
__blk_end_request_cur(cowdev->req, retval);
cowdev->iobusy = 0;
/*
** initiate the next request from the queue
*/
cowlo_request(cowdev->rqueue);
spin_unlock_irq(&cowdev->rqlock);
}
return 0;
}
/*
** function to be called in the context of the kernel thread
** to handle the queued I/O-requests
**
** returns:
** 0 - fail
** 1 - success
*/
static long int
cowlo_do_request(struct request *req)
{
unsigned long len;
long int retval;
loff_t offset;
struct cowloop_device *cowdev = req->rq_disk->private_data;
/*
** calculate some variables which are needed later on
*/
len = blk_rq_cur_sectors(req) << 9;
offset = (loff_t) blk_rq_pos(req) << 9;
DEBUGP(DCOW"cowloop - req cmd=%d offset=%lld len=%lu addr=%p\n",
*(req->cmd), offset, len, req->buffer);
/*
** handle READ- or WRITE-request
*/
switch (rq_data_dir(req)) {
/**********************************************************/
case READ:
switch (cowlo_checkio(cowdev, len, offset)) {
case ALLCOW:
retval = cowlo_readcow(cowdev, req->buffer,
len, offset);
break;
case ALLRDO:
retval = cowlo_readrdo(cowdev, req->buffer,
len, offset);
break;
case MIXEDUP:
retval = cowlo_readmix(cowdev, req->buffer,
len, offset);
break;
default:
retval = 0; /* never happens */
}
break;
/**********************************************************/
case WRITE:
switch (cowlo_checkio(cowdev, len, offset)) {
case ALLCOW:
/*
** straight-forward write will do...
*/
DEBUGP(DCOW"cowloop - write straight ");
retval = cowlo_writecow(cowdev, req->buffer,
len, offset);
break; /* from switch */
case ALLRDO:
if ((len & MUMASK) == 0) {
DEBUGP(DCOW"cowloop - write straight ");
retval = cowlo_writecow(cowdev, req->buffer,
len, offset);
break;
}
case MIXEDUP:
retval = cowlo_writemix(cowdev, req->buffer,
len, offset);
break;
default:
retval = 0; /* never happens */
}
break;
default:
printk(KERN_ERR
"cowloop - unrecognized command %d\n", *(req->cmd));
retval = 0;
}
return (retval <= 0 ? 0 : 1);
}
/*
** check for a given I/O-request if all underlying blocks
** (with size MAPUNIT) are either in the read-only file or in
** the cowfile (or a combination of the two)
**
** returns:
** ALLRDO - all underlying blocks in rdofile
** ALLCOW - all underlying blocks in cowfile
** MIXEDUP - underlying blocks partly in rdofile and partly in cowfile
*/
static int
cowlo_checkio(struct cowloop_device *cowdev, int len, loff_t offset)
{
unsigned long mapnum, bytenum, bitnum, blocknr, partlen;
long int totcnt, cowcnt;
char *mc;
/*
** notice that the requested block might cross
** a blocksize boundary while one of the concerned
** blocks resides in the read-only file and another
** one in the copy-on-write file; in that case the
** request will be broken up into pieces
*/
if ((len <= MAPUNIT) &&
(MAPUNIT - (offset & MUMASK) <= len)) {
/*
** easy situation:
** requested data-block entirely fits within
** the mapunit used for the bitmap
** check if that block is located in rdofile or
** cowfile
*/
blocknr = offset >> MUSHIFT;
mapnum = CALCMAP(blocknr);
bytenum = CALCBYTE(blocknr);
bitnum = CALCBIT(blocknr);
if (*(*(cowdev->mapcache+mapnum)+bytenum)&(1<<bitnum))
return ALLCOW;
else
return ALLRDO;
}
/*
** less easy situation:
** the requested data-block does not fit within the mapunit
** used for the bitmap
** check if *all* underlying blocks involved reside on the rdofile
** or the cowfile (so still no breakup required)
*/
for (cowcnt = totcnt = 0; len > 0; len -= partlen,
offset += partlen, totcnt++) {
/*
** calculate blocknr of involved block
*/
blocknr = offset >> MUSHIFT;
/*
** calculate partial length for this transfer
*/
partlen = MAPUNIT - (offset & MUMASK);
if (partlen > len)
partlen = len;
/*
** is this block located in the cowfile
*/
mapnum = CALCMAP(blocknr);
bytenum = CALCBYTE(blocknr);
bitnum = CALCBIT(blocknr);
mc = *(cowdev->mapcache+mapnum);
if (*(mc+bytenum)&(1<<bitnum))
cowcnt++;;
DEBUGP(DCOW
"cowloop - check %lu - map %lu, byte %lu, bit %lu, "
"cowcnt %ld, totcnt %ld %02x %p\n",
blocknr, mapnum, bytenum, bitnum, cowcnt, totcnt,
*(mc+bytenum), mc);
}
if (cowcnt == 0) /* all involved blocks on rdofile? */
return ALLRDO;
if (cowcnt == totcnt) /* all involved blocks on cowfile? */
return ALLCOW;
/*
** situation somewhat more complicated:
** involved underlying blocks spread over both files
*/
return MIXEDUP;
}
/*
** read requested chunk partly from rdofile and partly from cowfile
**
** returns:
** 0 - fail
** 1 - success
*/
static int
cowlo_readmix(struct cowloop_device *cowdev, void *buf, int len, loff_t offset)
{
unsigned long mapnum, bytenum, bitnum, blocknr, partlen;
long int retval;
char *mc;
/*
** complicated approach: breakup required of read-request
*/
for (retval = 1; len > 0;
len -= partlen, buf += partlen, offset += partlen) {
/*
** calculate blocknr of entire block
*/
blocknr = offset >> MUSHIFT;
/*
** calculate partial length for this transfer
*/
partlen = MAPUNIT - (offset & MUMASK);
if (partlen > len)
partlen = len;
/*
** is this block located in the cowfile
*/
mapnum = CALCMAP(blocknr);
bytenum = CALCBYTE(blocknr);
bitnum = CALCBIT(blocknr);
mc = *(cowdev->mapcache+mapnum);
if (*(mc+bytenum)&(1<<bitnum)) {
/*
** read (partial) block from cowfile
*/
DEBUGP(DCOW"cowloop - split read "
"cow partlen=%ld off=%lld\n", partlen, offset);
if (cowlo_readcow(cowdev, buf, partlen, offset) <= 0)
retval = 0;
} else {
/*
** read (partial) block from rdofile
*/
DEBUGP(DCOW"cowloop - split read "
"rdo partlen=%ld off=%lld\n", partlen, offset);
if (cowlo_readrdo(cowdev, buf, partlen, offset) <= 0)
retval = 0;
}
}
return retval;
}
/*
** chunk to be written to the cowfile needs pieces to be
** read from the rdofile
**
** returns:
** 0 - fail
** 1 - success
*/
static int
cowlo_writemix(struct cowloop_device *cowdev, void *buf, int len, loff_t offset)
{
unsigned long mapnum, bytenum, bitnum, blocknr, partlen;
long int retval;
char *mc;
/*
** somewhat more complicated stuff is required:
** if the request is larger than one underlying
** block or is spread over two underlying blocks,
** split the request into pieces; if a block does not
** start at a block boundary, take care that
** surrounding data is read first (if needed),
** fit the new data in and write it as a full block
*/
for (retval = 1; len > 0;
len -= partlen, buf += partlen, offset += partlen) {
/*
** calculate partial length for this transfer
*/
partlen = MAPUNIT - (offset & MUMASK);
if (partlen > len)
partlen = len;
/*
** calculate blocknr of entire block
*/
blocknr = offset >> MUSHIFT;
/*
** has this block been written before?
*/
mapnum = CALCMAP(blocknr);
bytenum = CALCBYTE(blocknr);
bitnum = CALCBIT(blocknr);
mc = *(cowdev->mapcache+mapnum);
if (*(mc+bytenum)&(1<<bitnum)) {
/*
** block has been written before;
** write transparantly to cowfile
*/
DEBUGP(DCOW
"cowloop - splitwr transp\n");
if (cowlo_writecow(cowdev, buf, partlen, offset) <= 0)
retval = 0;
} else {
/*
** block has never been written before,
** so read entire block from
** read-only file first, unless
** a full block is requested to
** be written
*/
if (partlen < MAPUNIT) {
if (cowlo_readrdo(cowdev, cowdev->iobuf,
MAPUNIT, (loff_t)blocknr << MUSHIFT) <= 0)
retval = 0;
}
/*
** transfer modified part into
** the block just read
*/
memcpy(cowdev->iobuf + (offset & MUMASK), buf, partlen);
/*
** write entire block to cowfile
*/
DEBUGP(DCOW"cowloop - split "
"partlen=%ld off=%lld\n",
partlen, (loff_t)blocknr << MUSHIFT);
if (cowlo_writecow(cowdev, cowdev->iobuf, MAPUNIT,
(loff_t)blocknr << MUSHIFT) <= 0)
retval = 0;
}
}
return retval;
}
/*****************************************************************************/
/* I/O-support for read-only file and copy-on-write file */
/*****************************************************************************/
/*
** read data from the read-only file
**
** return-value: similar to user-mode read
*/
static long int
cowlo_readrdo(struct cowloop_device *cowdev, void *buf, int len, loff_t offset)
{
long int retval;
mm_segment_t old_fs;
loff_t saveoffset = offset;
DEBUGP(DCOW"cowloop - readrdo called\n");
old_fs = get_fs();
set_fs(get_ds());
retval = cowdev->rdofp->f_op->read(cowdev->rdofp, buf, len, &offset);
set_fs(old_fs);
if (retval < len) {
printk(KERN_WARNING "cowloop - read-failure %ld on rdofile"
"- offset=%lld len=%d\n",
retval, saveoffset, len);
}
cowdev->rdoreads++;
return retval;
}
/*
** read cowfile from a modified offset, i.e. skipping the bitmap and cowhead
**
** return-value: similar to user-mode read
*/
static long int
cowlo_readcow(struct cowloop_device *cowdev, void *buf, int len, loff_t offset)
{
DEBUGP(DCOW"cowloop - readcow called\n");
offset += cowdev->cowhead->doffset;
return cowlo_readcowraw(cowdev, buf, len, offset);
}
/*
** read cowfile from an absolute offset
**
** return-value: similar to user-mode read
*/
static long int
cowlo_readcowraw(struct cowloop_device *cowdev,
void *buf, int len, loff_t offset)
{
long int retval;
mm_segment_t old_fs;
loff_t saveoffset = offset;
DEBUGP(DCOW"cowloop - readcowraw called\n");
/*
** be sure that cowfile is opened for read-write
*/
if (!(cowdev->state & COWCOWOPEN)) {
printk(KERN_WARNING
"cowloop - read request from cowfile refused\n");
return -EBADF;
}
/*
** issue low level read
*/
old_fs = get_fs();
set_fs(get_ds());
retval = cowdev->cowfp->f_op->read(cowdev->cowfp, buf, len, &offset);
set_fs(old_fs);
if (retval < len) {
printk(KERN_WARNING
"cowloop - read-failure %ld on cowfile"
"- offset=%lld len=%d\n", retval, saveoffset, len);
}
cowdev->cowreads++;
return retval;
}
/*
** write cowfile from a modified offset, i.e. skipping the bitmap and cowhead
**
** if a block is written for the first time while its contents consists
** of binary zeroes only, the concerning bitmap is flushed to the cowfile
**
** return-value: similar to user-mode write
*/
static long int
cowlo_writecow(struct cowloop_device *cowdev, void *buf, int len, loff_t offset)
{
long int retval;
unsigned long mapnum = 0, mapbyte = 0, mapbit = 0;
unsigned long cowblock = 0, partlen;
char *tmpptr, *mapptr = NULL;
loff_t tmpoffset, mapoffset = 0;
DEBUGP(DCOW"cowloop - writecow called\n");
/*
** be sure that cowfile is opened for read-write
*/
if (!(cowdev->state & COWRWCOWOPEN)) {
printk(KERN_WARNING
"cowloop - Write request to cowfile refused\n");
return -EBADF;
}
/*
** write the entire block to the cowfile
*/
tmpoffset = offset + cowdev->cowhead->doffset;
retval = cowlo_writecowraw(cowdev, buf, len, tmpoffset);
/*
** verify if enough space available on filesystem holding
** the cowfile
** - when the last write failed (might be caused by lack of space)
** - when a watcher is active (to react adequately)
** - when the previous check indicated fs was almost full
** - with regular intervals
*/
if ((retval <= 0) ||
(cowdev->state & COWWATCHDOG) ||
(cowdev->blkavail / 2 < SPCDFLINTVL) ||
(cowdev->cowwrites % SPCDFLINTVL == 0)) {
struct kstatfs ks;
if (vfs_statfs(cowdev->cowfp->f_dentry, &ks) == 0) {
if (ks.f_bavail <= SPCMINBLK) {
switch (ks.f_bavail) {
case 0:
case 1:
case 2:
case 3:
printk(KERN_ALERT
"cowloop - "
"ALERT: cowfile full!\n");
break;
default:
printk(KERN_WARNING
"cowloop - cowfile almost "
"full (only %llu Kb free)\n",
(unsigned long long)
ks.f_bsize*ks.f_bavail/1024);
}
}
cowdev->blktotal = ks.f_blocks;
cowdev->blkavail = ks.f_bavail;
/*
** wakeup watcher if threshold has been reached
*/
if ((cowdev->state & COWWATCHDOG) &&
(cowdev->watchthresh >= cowdev->blkavail)) {
wake_up_interruptible(&cowdev->watchq);
}
}
}
if (retval <= 0)
return retval;
DEBUGP(DCOW"cowloop - block written\n");
/*
** check if block(s) is/are written to the cowfile
** for the first time; if so, adapt the bitmap
*/
for (; len > 0; len -= partlen, offset += partlen, buf += partlen) {
/*
** calculate partial length for this transfer
*/
partlen = MAPUNIT - (offset & MUMASK);
if (partlen > len)
partlen = len;
/*
** calculate bitno of written chunk of cowblock
*/
cowblock = offset >> MUSHIFT;
mapnum = CALCMAP(cowblock);
mapbyte = CALCBYTE(cowblock);
mapbit = CALCBIT(cowblock);
if (*(*(cowdev->mapcache+mapnum)+mapbyte) & (1<<mapbit))
continue; /* already written before */
/*
** if the block is written for the first time,
** the corresponding bit should be set in the bitmap
*/
*(*(cowdev->mapcache+mapnum)+mapbyte) |= (1<<mapbit);
cowdev->nrcowblocks++;
DEBUGP(DCOW"cowloop - bitupdate blk=%ld map=%ld "
"byte=%ld bit=%ld\n",
cowblock, mapnum, mapbyte, mapbit);
/*
** check if the cowhead in the cowfile is currently
** marked clean; if so, mark it dirty and flush it
*/
if (!(cowdev->cowhead->flags & COWDIRTY)) {
cowdev->cowhead->flags |= COWDIRTY;
cowlo_writecowraw(cowdev, cowdev->cowhead,
MAPUNIT, (loff_t)0);
}
/*
** if the written datablock contained binary zeroes,
** the bitmap block should be marked to be flushed to disk
** (blocks containing all zeroes cannot be recovered by
** the cowrepair-program later on if cowloop is not properly
** removed via rmmod)
*/
if (memcmp(buf, allzeroes, partlen)) /* not all zeroes? */
continue; /* no flush needed */
/*
** calculate positions of bitmap block to be flushed
** - pointer of bitmap block in memory
** - offset of bitmap block in cowfile
*/
tmpptr = *(cowdev->mapcache+mapnum) + (mapbyte & (~MUMASK));
tmpoffset = (loff_t) MAPUNIT + mapnum * MAPCHUNKSZ +
(mapbyte & (~MUMASK));
/*
** flush a bitmap block at the moment that all bits have
** been set in that block, i.e. at the moment that we
** switch to another bitmap block
*/
if ((mapoffset != 0) && (mapoffset != tmpoffset)) {
if (cowlo_writecowraw(cowdev, mapptr, MAPUNIT,
mapoffset) < 0) {
printk(KERN_WARNING
"cowloop - write-failure on bitmap - "
"blk=%ld map=%ld byte=%ld bit=%ld\n",
cowblock, mapnum, mapbyte, mapbit);
}
DEBUGP(DCOW"cowloop - bitmap blk written %lld\n",
mapoffset);
}
/*
** remember offset in cowfile and offset in memory
** for bitmap to be flushed; flushing will be done
** as soon as all updates in this bitmap block have
** been done
*/
mapoffset = tmpoffset;
mapptr = tmpptr;
}
/*
** any new block written containing binary zeroes?
*/
if (mapoffset) {
if (cowlo_writecowraw(cowdev, mapptr, MAPUNIT, mapoffset) < 0) {
printk(KERN_WARNING
"cowloop - write-failure on bitmap - "
"blk=%ld map=%ld byte=%ld bit=%ld\n",
cowblock, mapnum, mapbyte, mapbit);
}
DEBUGP(DCOW"cowloop - bitmap block written %lld\n", mapoffset);
}
return retval;
}
/*
** write cowfile from an absolute offset
**
** return-value: similar to user-mode write
*/
static long int
cowlo_writecowraw(struct cowloop_device *cowdev,
void *buf, int len, loff_t offset)
{
long int retval;
mm_segment_t old_fs;
loff_t saveoffset = offset;
DEBUGP(DCOW"cowloop - writecowraw called\n");
/*
** be sure that cowfile is opened for read-write
*/
if (!(cowdev->state & COWRWCOWOPEN)) {
printk(KERN_WARNING
"cowloop - write request to cowfile refused\n");
return -EBADF;
}
/*
** issue low level write
*/
old_fs = get_fs();
set_fs(get_ds());
retval = cowdev->cowfp->f_op->write(cowdev->cowfp, buf, len, &offset);
set_fs(old_fs);
if (retval < len) {
printk(KERN_WARNING
"cowloop - write-failure %ld on cowfile"
"- offset=%lld len=%d\n", retval, saveoffset, len);
}
cowdev->cowwrites++;
return retval;
}
/*
** readproc-function: called when the corresponding /proc-file is read
*/
static int
cowlo_readproc(char *buf, char **start, off_t pos, int cnt, int *eof, void *p)
{
struct cowloop_device *cowdev = p;
return sprintf(buf,
" cowloop version: %9s\n\n"
" device state: %s%s%s%s\n"
" number of opens: %9d\n"
" pid of thread: %9d\n\n"
" read-only file: %9s\n"
" rdoreads: %9lu\n\n"
"copy-on-write file: %9s\n"
" state cowfile: %9s\n"
" bitmap-blocks: %9lu (of %d bytes)\n"
" cowblocks in use: %9lu (of %d bytes)\n"
" cowreads: %9lu\n"
" cowwrites: %9lu\n",
cowloop_version,
cowdev->state & COWDEVOPEN ? "devopen " : "",
cowdev->state & COWRWCOWOPEN ? "cowopenrw " : "",
cowdev->state & COWRDCOWOPEN ? "cowopenro " : "",
cowdev->state & COWWATCHDOG ? "watchdog " : "",
cowdev->opencnt,
cowdev->pid,
cowdev->rdoname,
cowdev->rdoreads,
cowdev->cowname,
cowdev->cowhead->flags & COWDIRTY ? "dirty" : "clean",
cowdev->mapsize >> MUSHIFT, MAPUNIT,
cowdev->nrcowblocks, MAPUNIT,
cowdev->cowreads,
cowdev->cowwrites);
}
/*****************************************************************************/
/* Setup and destroy cowdevices */
/*****************************************************************************/
/*
** open and prepare a cowdevice (rdofile and cowfile) and allocate bitmaps
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_openpair(char *rdof, char *cowf, int autorecover, int minor)
{
long int retval;
struct cowloop_device *cowdev = cowdevall[minor];
struct kstatfs ks;
down(&cowdevlock);
/*
** requested device exists?
*/
if (minor >= maxcows) {
up(&cowdevlock);
return -ENODEV;
}
/*
** requested device already assigned to cowdevice?
*/
if (cowdev->state & COWDEVOPEN) {
up(&cowdevlock);
return -EBUSY;
}
/*
** initialize administration
*/
memset(cowdev, 0, sizeof *cowdev);
spin_lock_init(&cowdev->rqlock);
init_waitqueue_head(&cowdev->waitq);
init_waitqueue_head(&cowdev->watchq);
/*
** open the read-only file
*/
DEBUGP(DCOW"cowloop - call openrdo....\n");
retval = cowlo_openrdo(cowdev, rdof);
if (retval) {
cowlo_undo_openrdo(cowdev);
up(&cowdevlock);
return retval;
}
/*
** open the cowfile
*/
DEBUGP(DCOW"cowloop - call opencow....\n");
retval = cowlo_opencow(cowdev, cowf, autorecover);
if (retval) {
cowlo_undo_openrdo(cowdev);
cowlo_undo_opencow(cowdev);
up(&cowdevlock);
return retval;
}
/*
** administer total and available size of filesystem holding cowfile
*/
if (vfs_statfs(cowdev->cowfp->f_dentry, &ks) == 0) {
cowdev->blksize = ks.f_bsize;
cowdev->blktotal = ks.f_blocks;
cowdev->blkavail = ks.f_bavail;
} else {
cowdev->blksize = 1024; /* avoid division by zero */
}
/*
** flush the (recovered) bitmaps and cowhead to the cowfile
*/
DEBUGP(DCOW"cowloop - call cowsync....\n");
cowlo_sync();
/*
** allocate gendisk for the cow device
*/
DEBUGP(DCOW"cowloop - alloc disk....\n");
cowdev->gd = alloc_disk(1);
if (cowdev->gd == NULL) {
printk(KERN_WARNING
"cowloop - unable to alloc_disk for cowloop\n");
cowlo_undo_openrdo(cowdev);
cowlo_undo_opencow(cowdev);
up(&cowdevlock);
return -ENOMEM;
}
cowdev->gd->major = COWMAJOR;
cowdev->gd->first_minor = minor;
cowdev->gd->minors = 1;
cowdev->gd->fops = &cowlo_fops;
cowdev->gd->private_data = cowdev;
sprintf(cowdev->gd->disk_name, "%s%d", DEVICE_NAME, minor);
/* in .5 Kb units */
set_capacity(cowdev->gd, (cowdev->numblocks*(MAPUNIT/512)));
DEBUGP(DCOW"cowloop - init request queue....\n");
cowdev->rqueue = blk_init_queue(cowlo_request, &cowdev->rqlock);
if (cowdev->rqueue == NULL) {
printk(KERN_WARNING
"cowloop - unable to get request queue for cowloop\n");
del_gendisk(cowdev->gd);
cowlo_undo_openrdo(cowdev);
cowlo_undo_opencow(cowdev);
up(&cowdevlock);
return -EINVAL;
}
blk_queue_logical_block_size(cowdev->rqueue, cowdev->blocksz);
cowdev->gd->queue = cowdev->rqueue;
/*
** start kernel thread to handle requests
*/
DEBUGP(DCOW"cowloop - kickoff daemon....\n");
cowdev->pid = kernel_thread((int (*)(void *))cowlo_daemon, cowdev, 0);
/*
** create a file below directory /proc/cow for this new cowdevice
*/
if (cowlo_procdir) {
char tmpname[64];
sprintf(tmpname, "%d", minor);
create_proc_read_entry(tmpname, 0 , cowlo_procdir,
cowlo_readproc, cowdev);
}
cowdev->state |= COWDEVOPEN;
cowdev->rdoname = rdof;
cowdev->cowname = cowf;
/*
** enable the new disk; this triggers the first request!
*/
DEBUGP(DCOW"cowloop - call add_disk....\n");
add_disk(cowdev->gd);
up(&cowdevlock);
return 0;
}
/*
** close a cowdevice (pair of rdofile/cowfile) and release memory
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_closepair(struct cowloop_device *cowdev)
{
int minor;
down(&cowdevlock);
/*
** if cowdevice is not activated at all, refuse
*/
if (!(cowdev->state & COWDEVOPEN)) {
up(&cowdevlock);
return -ENODEV;
}
/*
** if this cowdevice is still open, refuse
*/
if (cowdev->opencnt > 0) {
up(&cowdevlock);
return -EBUSY;
}
up(&cowdevlock);
/*
** wakeup watcher (if any)
*/
if (cowdev->state & COWWATCHDOG) {
cowdev->watchthresh = cowdev->blkavail;
wake_up_interruptible(&cowdev->watchq);
}
/*
** wakeup kernel-thread to be able to exit
** and wait until it has exited
*/
cowdev->closedown = 1;
cowdev->qfilled = 1;
wake_up_interruptible(&cowdev->waitq);
while (cowdev->pid)
schedule();
del_gendisk(cowdev->gd); /* revert the alloc_disk() */
put_disk(cowdev->gd); /* revert the add_disk() */
if (cowlo_procdir) {
char tmpname[64];
for (minor = 0; minor < maxcows; minor++) {
if (cowdev == cowdevall[minor])
break;
}
sprintf(tmpname, "%d", minor);
remove_proc_entry(tmpname, cowlo_procdir);
}
blk_cleanup_queue(cowdev->rqueue);
/*
** release memory for filenames if these names have
** been allocated dynamically
*/
if ((cowdev->cowname) && (cowdev->cowname != cowfile))
kfree(cowdev->cowname);
if ((cowdev->rdoname) && (cowdev->rdoname != rdofile))
kfree(cowdev->rdoname);
cowlo_undo_openrdo(cowdev);
cowlo_undo_opencow(cowdev);
cowdev->state &= ~COWDEVOPEN;
return 0;
}
/*
** open the read-only file
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_openrdo(struct cowloop_device *cowdev, char *rdof)
{
struct file *f;
struct inode *inode;
long int i, nrval;
DEBUGP(DCOW"cowloop - openrdo called\n");
/*
** open the read-only file
*/
if (*rdof == '\0') {
printk(KERN_ERR
"cowloop - specify name for read-only file\n\n");
return -EINVAL;
}
f = filp_open(rdof, O_RDONLY|O_LARGEFILE, 0);
if ((f == NULL) || IS_ERR(f)) {
printk(KERN_ERR
"cowloop - open of rdofile %s failed\n", rdof);
return -EINVAL;
}
cowdev->rdofp = f;
inode = f->f_dentry->d_inode;
if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode)) {
printk(KERN_ERR
"cowloop - %s not regular file or blockdev\n", rdof);
return -EINVAL;
}
DEBUGP(DCOW"cowloop - determine size rdo....\n");
/*
** determine block-size and total size of read-only file
*/
if (S_ISREG(inode->i_mode)) {
/*
** read-only file is a regular file
*/
cowdev->blocksz = 512; /* other value fails */
cowdev->numblocks = inode->i_size >> MUSHIFT;
if (inode->i_size & MUMASK) {
printk(KERN_WARNING
"cowloop - rdofile %s truncated to multiple "
"of %d bytes\n", rdof, MAPUNIT);
}
DEBUGP(DCOW"cowloop - RO=regular: numblocks=%d, blocksz=%d\n",
cowdev->numblocks, cowdev->blocksz);
} else {
/*
** read-only file is a block device
*/
cowdev->belowdev = inode->i_bdev;
cowdev->belowgd = cowdev->belowdev->bd_disk; /* gendisk */
if (cowdev->belowdev->bd_part) {
cowdev->numblocks = cowdev->belowdev->bd_part->nr_sects
/ (MAPUNIT/512);
}
if (cowdev->belowgd) {
cowdev->belowq = cowdev->belowgd->queue;
if (cowdev->numblocks == 0) {
cowdev->numblocks =
get_capacity(cowdev->belowgd)/(MAPUNIT/512);
}
}
if (cowdev->belowq) {
cowdev->blocksz =
queue_logical_block_size(cowdev->belowq);
}
if (cowdev->blocksz == 0)
cowdev->blocksz = BLOCK_SIZE; /* default 2^10 */
DEBUGP(DCOW"cowloop - numblocks=%d, "
"blocksz=%d, belowgd=%p, belowq=%p\n",
cowdev->numblocks, cowdev->blocksz,
cowdev->belowgd, cowdev->belowq);
DEBUGP(DCOW"cowloop - belowdev.bd_block_size=%d\n",
cowdev->belowdev->bd_block_size);
}
if (cowdev->numblocks == 0) {
printk(KERN_ERR "cowloop - %s has no contents\n", rdof);
return -EINVAL;
}
/*
** reserve space in memory as generic I/O buffer
*/
cowdev->iobuf = kmalloc(MAPUNIT, GFP_KERNEL);
if (!cowdev->iobuf) {
printk(KERN_ERR
"cowloop - cannot get space for buffer %d\n", MAPUNIT);
return -ENOMEM;
}
DEBUGP(DCOW"cowloop - determine fingerprint rdo....\n");
/*
** determine fingerprint for read-only file
** calculate fingerprint from first four datablocks
** which do not contain binary zeroes
*/
for (i = 0, cowdev->fingerprint = 0, nrval = 0;
(nrval < 4) && (i < cowdev->numblocks); i++) {
int j;
unsigned char cs;
/*
** read next block
*/
if (cowlo_readrdo(cowdev, cowdev->iobuf, MAPUNIT,
(loff_t)i << MUSHIFT) < 1)
break;
/*
** calculate fingerprint by adding all byte-values
*/
for (j = 0, cs = 0; j < MAPUNIT; j++)
cs += *(cowdev->iobuf+j);
if (cs == 0) /* block probably contained zeroes */
continue;
/*
** shift byte-value to proper place in final fingerprint
*/
cowdev->fingerprint |= cs << (nrval*8);
nrval++;
}
return 0;
}
/*
** undo memory allocs and file opens issued so far
** related to the read-only file
*/
static void
cowlo_undo_openrdo(struct cowloop_device *cowdev)
{
kfree(cowdev->iobuf);
if (cowdev->rdofp)
filp_close(cowdev->rdofp, 0);
}
/*
** open the cowfile
**
** returns:
** 0 - okay
** < 0 - error value
*/
static int
cowlo_opencow(struct cowloop_device *cowdev, char *cowf, int autorecover)
{
long int i;
int minor;
unsigned long nb;
struct file *f;
struct inode *inode;
loff_t offset;
struct cowloop_device *cowtmp;
DEBUGP(DCOW"cowloop - opencow called\n");
/*
** open copy-on-write file (read-write)
*/
if (cowf[0] == '\0') {
printk(KERN_ERR
"cowloop - specify name of copy-on-write file\n\n");
return -EINVAL;
}
f = filp_open(cowf, O_RDWR|O_LARGEFILE, 0600);
if ((f == NULL) || IS_ERR(f)) {
/*
** non-existing cowfile: try to create
*/
f = filp_open(cowf, O_RDWR|O_CREAT|O_LARGEFILE, 0600);
if ((f == NULL) || IS_ERR(f)) {
printk(KERN_ERR
"cowloop - failed to open file %s for read-write\n\n",
cowf);
return -EINVAL;
}
}
cowdev->cowfp = f;
inode = f->f_dentry->d_inode;
if (!S_ISREG(inode->i_mode)) {
printk(KERN_ERR "cowloop - %s is not regular file\n", cowf);
return -EINVAL;
}
/*
** check if this cowfile is already in use for another cowdevice
*/
for (minor = 0; minor < maxcows; minor++) {
cowtmp = cowdevall[minor];
if (!(cowtmp->state & COWDEVOPEN))
continue;
if (cowtmp == cowdev)
continue;
if (cowtmp->cowfp->f_dentry->d_inode == f->f_dentry->d_inode) {
printk(KERN_ERR
"cowloop - %s: already in use as cow\n", cowf);
return -EBUSY;
}
}
/*
** mark cowfile open for read-write
*/
cowdev->state |= COWRWCOWOPEN;
/*
** calculate size (in bytes) for total bitmap in cowfile;
** when the size of the cowhead block is added, the start-offset
** for the modified data blocks can be found
*/
nb = cowdev->numblocks;
if (nb%8) /* transform #bits to #bytes */
nb += 8; /* rounded if necessary */
nb /= 8;
if (nb & MUMASK) /* round up #bytes to MAPUNIT chunks */
cowdev->mapsize = ((nb >> MUSHIFT) + 1) << MUSHIFT;
else
cowdev->mapsize = nb;
/*
** reserve space in memory for the cowhead
*/
cowdev->cowhead = kmalloc(MAPUNIT, GFP_KERNEL);
if (!cowdev->cowhead) {
printk(KERN_ERR "cowloop - cannot get space for cowhead %d\n",
MAPUNIT);
return -ENOMEM;
}
memset(cowdev->cowhead, 0, MAPUNIT);
DEBUGP(DCOW"cowloop - prepare cowhead....\n");
/*
** check if the cowfile exists or should be created
*/
if (inode->i_size != 0) {
/*
** existing cowfile: read the cow head
*/
if (inode->i_size < MAPUNIT) {
printk(KERN_ERR
"cowloop - existing cowfile %s too small\n",
cowf);
return -EINVAL;
}
cowlo_readcowraw(cowdev, cowdev->cowhead, MAPUNIT, (loff_t) 0);
/*
** verify if the existing file is really a cowfile
*/
if (cowdev->cowhead->magic != COWMAGIC) {
printk(KERN_ERR
"cowloop - cowfile %s has incorrect format\n",
cowf);
return -EINVAL;
}
/*
** verify the cowhead version of the cowfile
*/
if (cowdev->cowhead->version > COWVERSION) {
printk(KERN_ERR
"cowloop - cowfile %s newer than this driver\n",
cowf);
return -EINVAL;
}
/*
** make sure that this is not a packed cowfile
*/
if (cowdev->cowhead->flags & COWPACKED) {
printk(KERN_ERR
"cowloop - packed cowfile %s not accepted\n", cowf);
return -EINVAL;
}
/*
** verify if the cowfile has been properly closed
*/
if (cowdev->cowhead->flags & COWDIRTY) {
/*
** cowfile was not properly closed;
** check if automatic recovery is required
** (actual recovery will be done later on)
*/
if (!autorecover) {
printk(KERN_ERR
"cowloop - cowfile %s is dirty "
"(not properly closed by rmmod?)\n",
cowf);
printk(KERN_ERR
"cowloop - run cowrepair or specify "
"'option=r' to recover\n");
return -EINVAL;
}
}
/*
** verify if the cowfile is really related to this rdofile
*/
if (cowdev->cowhead->rdoblocks != cowdev->numblocks) {
printk(KERN_ERR
"cowloop - cowfile %s (size %lld) not related "
"to rdofile (size %lld)\n",
cowf,
(long long)cowdev->cowhead->rdoblocks << MUSHIFT,
(long long)cowdev->numblocks << MUSHIFT);
return -EINVAL;
}
if (cowdev->cowhead->rdofingerprint != cowdev->fingerprint) {
printk(KERN_ERR
"cowloop - cowfile %s not related to rdofile "
" (fingerprint err - rdofile modified?)\n", cowf);
return -EINVAL;
}
} else {
/*
** new cowfile: determine the minimal size (cowhead+bitmap)
*/
offset = (loff_t) MAPUNIT + cowdev->mapsize - 1;
if (cowlo_writecowraw(cowdev, "", 1, offset) < 1) {
printk(KERN_ERR
"cowloop - cannot set cowfile to size %lld\n",
offset+1);
return -EINVAL;
}
/*
** prepare new cowhead
*/
cowdev->cowhead->magic = COWMAGIC;
cowdev->cowhead->version = COWVERSION;
cowdev->cowhead->mapunit = MAPUNIT;
cowdev->cowhead->mapsize = cowdev->mapsize;
cowdev->cowhead->rdoblocks = cowdev->numblocks;
cowdev->cowhead->rdofingerprint = cowdev->fingerprint;
cowdev->cowhead->cowused = 0;
/*
** calculate start offset of data in cowfile,
** rounded up to multiple of 4K to avoid
** unnecessary disk-usage for written datablocks in
** the sparsed cowfile on e.g. 4K filesystems
*/
cowdev->cowhead->doffset =
((MAPUNIT+cowdev->mapsize+4095)>>12)<<12;
}
cowdev->cowhead->flags = 0;
DEBUGP(DCOW"cowloop - reserve space bitmap....\n");
/*
** reserve space in memory for the entire bitmap and
** fill it with the bitmap-data from disk; the entire
** bitmap is allocated in several chunks because kmalloc
** has restrictions regarding the allowed size per kmalloc
*/
cowdev->mapcount = (cowdev->mapsize+MAPCHUNKSZ-1)/MAPCHUNKSZ;
/*
** the size of every bitmap chunk will be MAPCHUNKSZ bytes, except for
** the last bitmap chunk: calculate remaining size for this chunk
*/
if (cowdev->mapsize % MAPCHUNKSZ == 0)
cowdev->mapremain = MAPCHUNKSZ;
else
cowdev->mapremain = cowdev->mapsize % MAPCHUNKSZ;
/*
** allocate space to store all pointers for the bitmap-chunks
** (initialize area with zeroes to allow proper undo)
*/
cowdev->mapcache = kmalloc(cowdev->mapcount * sizeof(char *),
GFP_KERNEL);
if (!cowdev->mapcache) {
printk(KERN_ERR
"cowloop - can not allocate space for bitmap ptrs\n");
return -ENOMEM;
}
memset(cowdev->mapcache, 0, cowdev->mapcount * sizeof(char *));
/*
** allocate space to store the bitmap-chunks themselves
*/
for (i = 0; i < cowdev->mapcount; i++) {
if (i < (cowdev->mapcount-1))
*(cowdev->mapcache+i) = kmalloc(MAPCHUNKSZ, GFP_KERNEL);
else
*(cowdev->mapcache+i) = kmalloc(cowdev->mapremain,
GFP_KERNEL);
if (*(cowdev->mapcache+i) == NULL) {
printk(KERN_ERR "cowloop - no space for bitmapchunk %ld"
" totmapsz=%ld, mapcnt=%d mapunit=%d\n",
i, cowdev->mapsize, cowdev->mapcount,
MAPUNIT);
return -ENOMEM;
}
}
DEBUGP(DCOW"cowloop - read bitmap from cow....\n");
/*
** read the entire bitmap from the cowfile into the in-memory cache;
** count the number of blocks that are in use already
** (statistical purposes)
*/
for (i = 0, offset = MAPUNIT; i < cowdev->mapcount;
i++, offset += MAPCHUNKSZ) {
unsigned long numbytes;
if (i < (cowdev->mapcount-1))
/*
** full bitmap chunk
*/
numbytes = MAPCHUNKSZ;
else
/*
** last bitmap chunk: might be partly filled
*/
numbytes = cowdev->mapremain;
cowlo_readcowraw(cowdev, *(cowdev->mapcache+i),
numbytes, offset);
}
/*
** if the cowfile was dirty and automatic recovery is required,
** reconstruct a proper bitmap in memory now
*/
if (cowdev->cowhead->flags & COWDIRTY) {
unsigned long long blocknum;
char databuf[MAPUNIT];
unsigned long mapnum, mapbyte, mapbit;
printk(KERN_NOTICE "cowloop - recover dirty cowfile %s....\n",
cowf);
/*
** read all data blocks
*/
for (blocknum = 0, offset = 0;
cowlo_readcow(cowdev, databuf, MAPUNIT, offset) > 0;
blocknum++, offset += MAPUNIT) {
/*
** if this datablock contains real data (not binary
** zeroes), set the corresponding bit in the bitmap
*/
if (memcmp(databuf, allzeroes, MAPUNIT) == 0)
continue;
mapnum = CALCMAP(blocknum);
mapbyte = CALCBYTE(blocknum);
mapbit = CALCBIT(blocknum);
*(*(cowdev->mapcache+mapnum)+mapbyte) |= (1<<mapbit);
}
printk(KERN_NOTICE "cowloop - cowfile recovery completed\n");
}
/*
** count all bits set in the bitmaps for statistical purposes
*/
for (i = 0, cowdev->nrcowblocks = 0; i < cowdev->mapcount; i++) {
long numbytes;
char *p;
if (i < (cowdev->mapcount-1))
numbytes = MAPCHUNKSZ;
else
numbytes = cowdev->mapremain;
p = *(cowdev->mapcache+i);
for (numbytes--; numbytes >= 0; numbytes--, p++) {
/*
** for only eight checks the following construction
** is faster than a loop-construction
*/
if ((*p) & 0x01)
cowdev->nrcowblocks++;
if ((*p) & 0x02)
cowdev->nrcowblocks++;
if ((*p) & 0x04)
cowdev->nrcowblocks++;
if ((*p) & 0x08)
cowdev->nrcowblocks++;
if ((*p) & 0x10)
cowdev->nrcowblocks++;
if ((*p) & 0x20)
cowdev->nrcowblocks++;
if ((*p) & 0x40)
cowdev->nrcowblocks++;
if ((*p) & 0x80)
cowdev->nrcowblocks++;
}
}
/*
** consistency-check for number of bits set in bitmap
*/
if (!(cowdev->cowhead->flags & COWDIRTY) &&
(cowdev->cowhead->cowused != cowdev->nrcowblocks)) {
printk(KERN_ERR "cowloop - inconsistent cowfile admi\n");
return -EINVAL;
}
return 0;
}
/*
** undo memory allocs and file opens issued so far
** related to the cowfile
*/
static void
cowlo_undo_opencow(struct cowloop_device *cowdev)
{
int i;
if (cowdev->mapcache) {
for (i = 0; i < cowdev->mapcount; i++) {
/* kfree(NULL) is safe, no pre-check needed */
kfree(*(cowdev->mapcache+i));
}
kfree(cowdev->mapcache);
}
kfree(cowdev->cowhead);
if ((cowdev->state & COWCOWOPEN) && (cowdev->cowfp))
filp_close(cowdev->cowfp, 0);
/*
** mark cowfile closed
*/
cowdev->state &= ~COWCOWOPEN;
}
/*
** flush the entire bitmap and the cowhead (clean) to the cowfile
**
** must be called with the cowdevices-lock set
*/
static void
cowlo_sync(void)
{
int i, minor;
loff_t offset;
struct cowloop_device *cowdev;
for (minor = 0; minor < maxcows; minor++) {
cowdev = cowdevall[minor];
if (!(cowdev->state & COWRWCOWOPEN))
continue;
for (i = 0, offset = MAPUNIT; i < cowdev->mapcount;
i++, offset += MAPCHUNKSZ) {
unsigned long numbytes;
if (i < (cowdev->mapcount-1))
/*
** full bitmap chunk
*/
numbytes = MAPCHUNKSZ;
else
/*
** last bitmap chunk: might be partly filled
*/
numbytes = cowdev->mapremain;
DEBUGP(DCOW
"cowloop - flushing bitmap %2d (%3ld Kb)\n",
i, numbytes / 1024);
if (cowlo_writecowraw(cowdev, *(cowdev->mapcache+i),
numbytes, offset) < numbytes) {
break;
}
}
/*
** flush clean up-to-date cowhead to cowfile
*/
cowdev->cowhead->cowused = cowdev->nrcowblocks;
cowdev->cowhead->flags &= ~COWDIRTY;
DEBUGP(DCOW "cowloop - flushing cowhead (%3d Kb)\n",
MAPUNIT / 1024);
cowlo_writecowraw(cowdev, cowdev->cowhead, MAPUNIT, (loff_t) 0);
}
}
/*****************************************************************************/
/* Module loading/unloading */
/*****************************************************************************/
/*
** called during insmod/modprobe
*/
static int __init
cowlo_init_module(void)
{
int retval;
int minor, uptocows;
printk(KERN_NOTICE "cowloop - (C) 2009 ATComputing.nl - version: %s\n",
cowloop_version);
printk(KERN_NOTICE "cowloop - info: www.ATComputing.nl/cowloop\n");
memset(allzeroes, 0, MAPUNIT);
/*
** Setup administration for all possible cowdevices.
** Note that their minor numbers go from 0 to MAXCOWS-1 inclusive
** and minor == MAXCOWS-1 is reserved for the control device.
*/
if ((maxcows < 1) || (maxcows > MAXCOWS)) {
printk(KERN_WARNING
"cowloop - maxcows exceeds maximum of %d\n", MAXCOWS);
maxcows = DFLCOWS;
}
/* allocate room for a table with a pointer to each cowloop_device: */
cowdevall = kmalloc(maxcows * sizeof(struct cowloop_device *),
GFP_KERNEL);
if (cowdevall == NULL) {
printk(KERN_WARNING
"cowloop - can not alloc table for %d devs\n", maxcows);
uptocows = 0;
retval = -ENOMEM;
goto error_out;
}
memset(cowdevall, 0, maxcows * sizeof(struct cowloop_device *));
/* then hook an actual cowloop_device struct to each pointer: */
for (minor = 0; minor < maxcows; minor++) {
cowdevall[minor] =
kmalloc(sizeof(struct cowloop_device), GFP_KERNEL);
if (cowdevall[minor] == NULL) {
printk(KERN_WARNING "cowloop - can not alloc "
"admin-struct for dev no %d\n", minor);
uptocows = minor; /* this is how far we got.... */
retval = -ENOMEM;
goto error_out;
}
memset(cowdevall[minor], 0, sizeof(struct cowloop_device));
}
uptocows = maxcows; /* we got all devices */
sema_init(&cowdevlock, 1);
/*
** register cowloop module
*/
if (register_blkdev(COWMAJOR, DEVICE_NAME) < 0) {
printk(KERN_WARNING
"cowloop - unable to get major %d for cowloop\n", COWMAJOR);
retval = -EIO;
goto error_out;
}
/*
** create a directory below /proc to allocate a file
** for each cowdevice that is allocated later on
*/
cowlo_procdir = proc_mkdir("cow", NULL);
/*
** check if a cowdevice has to be opened during insmod/modprobe;
** two parameters should be specified then: rdofile= and cowfile=
*/
if ((rdofile[0] != '\0') && (cowfile[0] != '\0')) {
char *po = option;
int wantrecover = 0;
/*
** check if automatic recovery is wanted
*/
while (*po) {
if (*po == 'r') {
wantrecover = 1;
break;
}
po++;
}
/*
** open new cowdevice with minor number 0
*/
retval = cowlo_openpair(rdofile, cowfile, wantrecover, 0);
if (retval) {
remove_proc_entry("cow", NULL);
unregister_blkdev(COWMAJOR, DEVICE_NAME);
goto error_out;
}
} else {
/*
** check if only one parameter has been specified
*/
if ((rdofile[0] != '\0') || (cowfile[0] != '\0')) {
printk(KERN_ERR
"cowloop - only one filename specified\n");
remove_proc_entry("cow", NULL);
unregister_blkdev(COWMAJOR, DEVICE_NAME);
retval = -EINVAL;
goto error_out;
}
}
/*
** allocate fake disk as control channel to handle the requests
** to activate and deactivate cowdevices dynamically
*/
cowctlgd = alloc_disk(1);
if (cowctlgd == NULL) {
printk(KERN_WARNING
"cowloop - unable to alloc_disk for cowctl\n");
remove_proc_entry("cow", NULL);
(void) cowlo_closepair(cowdevall[0]);
unregister_blkdev(COWMAJOR, DEVICE_NAME);
retval = -ENOMEM;
goto error_out;
}
spin_lock_init(&cowctlrqlock);
cowctlgd->major = COWMAJOR;
cowctlgd->first_minor = COWCTL;
cowctlgd->minors = 1;
cowctlgd->fops = &cowlo_fops;
cowctlgd->private_data = NULL;
/* the device has capacity 0, so there will be no q-requests */
cowctlgd->queue = blk_init_queue(NULL, &cowctlrqlock);
sprintf(cowctlgd->disk_name, "cowctl");
set_capacity(cowctlgd, 0);
add_disk(cowctlgd);
printk(KERN_NOTICE "cowloop - number of configured cowdevices: %d\n",
maxcows);
if (rdofile[0] != '\0') {
printk(KERN_NOTICE "cowloop - initialized on rdofile=%s\n",
rdofile);
} else {
printk(KERN_NOTICE "cowloop - initialized "
"without rdofile yet\n");
}
return 0;
error_out:
for (minor = 0; minor < uptocows; minor++)
kfree(cowdevall[minor]);
kfree(cowdevall);
return retval;
}
/*
** called during rmmod
*/
static void __exit
cowlo_cleanup_module(void)
{
int minor;
/*
** flush bitmaps and cowheads to the cowfiles
*/
down(&cowdevlock);
cowlo_sync();
up(&cowdevlock);
/*
** close all cowdevices
*/
for (minor = 0; minor < maxcows; minor++)
(void) cowlo_closepair(cowdevall[minor]);
unregister_blkdev(COWMAJOR, DEVICE_NAME);
/*
** get rid of /proc/cow and unregister the driver
*/
remove_proc_entry("cow", NULL);
for (minor = 0; minor < maxcows; minor++)
kfree(cowdevall[minor]);
kfree(cowdevall);
del_gendisk(cowctlgd); /* revert the alloc_disk() */
put_disk(cowctlgd); /* revert the add_disk() */
blk_cleanup_queue(cowctlgd->queue); /* cleanup the empty queue */
printk(KERN_NOTICE "cowloop - unloaded\n");
}
module_init(cowlo_init_module);
module_exit(cowlo_cleanup_module);
_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/devel
