Subversion Repositories or1k

/*

 * kernel/lvm.c

 *

 * Copyright (C) 1997 - 2002  Heinz Mauelshagen, Sistina Software

 *

 * February-November 1997

 * April-May,July-August,November 1998

 * January-March,May,July,September,October 1999

 * January,February,July,September-November 2000

 * January-May,June,October 2001

 * May-August 2002

 * February 2003

 *

 *

 * LVM driver 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.

 *

 * LVM driver 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 GNU CC; see the file COPYING.  If not, write to

 * the Free Software Foundation, 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 *

 */

/*

 * Changelog

 *

 *    09/11/1997 - added chr ioctls VG_STATUS_GET_COUNT

 *                 and VG_STATUS_GET_NAMELIST

 *    18/01/1998 - change lvm_chr_open/close lock handling

 *    30/04/1998 - changed LV_STATUS ioctl to LV_STATUS_BYNAME and

 *               - added   LV_STATUS_BYINDEX ioctl

 *               - used lvm_status_byname_req_t and

 *                      lvm_status_byindex_req_t vars

 *    04/05/1998 - added multiple device support

 *    08/05/1998 - added support to set/clear extendable flag in volume group

 *    09/05/1998 - changed output of lvm_proc_get_global_info() because of

 *                 support for free (eg. longer) logical volume names

 *    12/05/1998 - added spin_locks (thanks to Pascal van Dam

 *                 <pascal@ramoth.xs4all.nl>)

 *    25/05/1998 - fixed handling of locked PEs in lvm_map() and

 *                 lvm_chr_ioctl()

 *    26/05/1998 - reactivated verify_area by access_ok

 *    07/06/1998 - used vmalloc/vfree instead of kmalloc/kfree to go

 *                 beyond 128/256 KB max allocation limit per call

 *               - #ifdef blocked spin_lock calls to avoid compile errors

 *                 with 2.0.x

 *    11/06/1998 - another enhancement to spinlock code in lvm_chr_open()

 *                 and use of LVM_VERSION_CODE instead of my own macros

 *                 (thanks to  Michael Marxmeier <mike@msede.com>)

 *    07/07/1998 - added statistics in lvm_map()

 *    08/07/1998 - saved statistics in lvm_do_lv_extend_reduce()

 *    25/07/1998 - used __initfunc macro

 *    02/08/1998 - changes for official char/block major numbers

 *    07/08/1998 - avoided init_module() and cleanup_module() to be static

 *    30/08/1998 - changed VG lv_open counter from sum of LV lv_open counters

 *                 to sum of LVs open (no matter how often each is)

 *    01/09/1998 - fixed lvm_gendisk.part[] index error

 *    07/09/1998 - added copying of lv_current_pe-array

 *                 in LV_STATUS_BYINDEX ioctl

 *    17/11/1998 - added KERN_* levels to printk

 *    13/01/1999 - fixed LV index bug in lvm_do_lv_create() which hit lvrename

 *    07/02/1999 - fixed spinlock handling bug in case of LVM_RESET

 *                 by moving spinlock code from lvm_chr_open()

 *                 to lvm_chr_ioctl()

 *               - added LVM_LOCK_LVM ioctl to lvm_chr_ioctl()

 *               - allowed LVM_RESET and retrieval commands to go ahead;

 *                 only other update ioctls are blocked now

 *               - fixed pv->pe to NULL for pv_status

 *               - using lv_req structure in lvm_chr_ioctl() now

 *               - fixed NULL ptr reference bug in lvm_do_lv_extend_reduce()

 *                 caused by uncontiguous PV array in lvm_chr_ioctl(VG_REDUCE)

 *    09/02/1999 - changed BLKRASET and BLKRAGET in lvm_chr_ioctl() to

 *                 handle lgoical volume private read ahead sector

 *               - implemented LV read_ahead handling with lvm_blk_read()

 *                 and lvm_blk_write()

 *    10/02/1999 - implemented 2.[12].* support function lvm_hd_name()

 *                 to be used in drivers/block/genhd.c by disk_name()

 *    12/02/1999 - fixed index bug in lvm_blk_ioctl(), HDIO_GETGEO

 *               - enhanced gendisk insert/remove handling

 *    16/02/1999 - changed to dynamic block minor number allocation to

 *                 have as much as 99 volume groups with 256 logical volumes

 *                 as the grand total; this allows having 1 volume group with

 *                 up to 256 logical volumes in it

 *    21/02/1999 - added LV open count information to proc filesystem

 *               - substituted redundant LVM_RESET code by calls

 *                 to lvm_do_vg_remove()

 *    22/02/1999 - used schedule_timeout() to be more responsive

 *                 in case of lvm_do_vg_remove() with lots of logical volumes

 *    19/03/1999 - fixed NULL pointer bug in module_init/lvm_init

 *    17/05/1999 - used DECLARE_WAIT_QUEUE_HEAD macro (>2.3.0)

 *               - enhanced lvm_hd_name support

 *    03/07/1999 - avoided use of KERNEL_VERSION macro based ifdefs and

 *                 memcpy_tofs/memcpy_fromfs macro redefinitions

 *    06/07/1999 - corrected reads/writes statistic counter copy in case

 *                 of striped logical volume

 *    28/07/1999 - implemented snapshot logical volumes

 *                 - lvm_chr_ioctl

 *                   - LV_STATUS_BYINDEX

 *                   - LV_STATUS_BYNAME

 *                 - lvm_do_lv_create

 *                 - lvm_do_lv_remove

 *                 - lvm_map

 *                 - new lvm_snapshot_remap_block

 *                 - new lvm_snapshot_remap_new_block

 *    08/10/1999 - implemented support for multiple snapshots per

 *                 original logical volume

 *    12/10/1999 - support for 2.3.19

 *    11/11/1999 - support for 2.3.28

 *    21/11/1999 - changed lvm_map() interface to buffer_head based

 *    19/12/1999 - support for 2.3.33

 *    01/01/2000 - changed locking concept in lvm_map(),

 *                 lvm_do_vg_create() and lvm_do_lv_remove()

 *    15/01/2000 - fixed PV_FLUSH bug in lvm_chr_ioctl()

 *    24/01/2000 - ported to 2.3.40 including Alan Cox's pointer changes etc.

 *    29/01/2000 - used kmalloc/kfree again for all small structures

 *    20/01/2000 - cleaned up lvm_chr_ioctl by moving code

 *                 to seperated functions

 *               - avoided "/dev/" in proc filesystem output

 *               - avoided inline strings functions lvm_strlen etc.

 *    14/02/2000 - support for 2.3.43

 *               - integrated Andrea Arcagneli's snapshot code

 *    25/06/2000 - james (chip) , IKKHAYD! roffl

 *    26/06/2000 - enhanced lv_extend_reduce for snapshot logical volume

 *                 support

 *    06/09/2000 - added devfs support

 *    07/09/2000 - changed IOP version to 9

 *               - started to add new char ioctl LV_STATUS_BYDEV_T to support

 *                 getting an lv_t based on the dev_t of the Logical Volume

 *    14/09/2000 - enhanced lvm_do_lv_create to upcall VFS functions

 *                 to sync and lock, activate snapshot and unlock the FS

 *                 (to support journaled filesystems)

 *    18/09/2000 - hardsector size support

 *    27/09/2000 - implemented lvm_do_lv_rename() and lvm_do_vg_rename()

 *    30/10/2000 - added Andi Kleen's LV_BMAP ioctl to support LILO

 *    01/11/2000 - added memory information on hash tables to

 *                 lvm_proc_get_global_info()

 *    02/11/2000 - implemented /proc/lvm/ hierarchy

 *    22/11/2000 - changed lvm_do_create_proc_entry_of_pv () to work

 *                 with devfs

 *    26/11/2000 - corrected #ifdef locations for PROC_FS

 *    28/11/2000 - fixed lvm_do_vg_extend() NULL pointer BUG

 *               - fixed lvm_do_create_proc_entry_of_pv() buffer tampering BUG

 *    08/01/2001 - Removed conditional compiles related to PROC_FS,

 *                 procfs is always supported now. (JT)

 *    12/01/2001 - avoided flushing logical volume in case of shrinking

 *                 because of unecessary overhead in case of heavy updates

 *    25/01/2001 - Allow RO open of an inactive LV so it can be reactivated.

 *    31/01/2001 - removed blk_init_queue/blk_cleanup_queue queueing will be

 *                 handled by the proper devices.

 *               - If you try and BMAP a snapshot you now get an -EPERM

 *    01/01/2001 - lvm_map() now calls buffer_IO_error on error for 2.4

 *               - factored __remap_snapshot out of lvm_map

 *    12/02/2001 - move devfs code to create VG before LVs

 *    13/02/2001 - allow VG_CREATE on /dev/lvm

 *    14/02/2001 - removed modversions.h

 *               - tidied device defines for blk.h

 *               - tidied debug statements

 *               - bug: vg[] member not set back to NULL if activation fails

 *               - more lvm_map tidying

 *    15/02/2001 - register /dev/lvm with devfs correctly (major/minor

 *                 were swapped)

 *    19/02/2001 - preallocated buffer_heads for rawio when using

 *                 snapshots [JT]

 *    28/02/2001 - introduced the P_DEV macro and changed some internel

 *                 functions to be static [AD]

 *    28/02/2001 - factored lvm_get_snapshot_use_rate out of blk_ioctl [AD]

 *               - fixed user address accessing bug in lvm_do_lv_create()

 *                 where the check for an existing LV takes place right at

 *                 the beginning

 *    01/03/2001 - Add VG_CREATE_OLD for IOP 10 compatibility

 *    02/03/2001 - Don't destroy usermode pointers in lv_t structures duing

 *                 LV_STATUS_BYxxx

 *                 and remove redundant lv_t variables from same.

 *               - avoid compilation of lvm_dummy_device_request in case of

 *                 Linux >= 2.3.0 to avoid a warning

 *               - added lvm_name argument to printk in buffer allocation

 *                 in order to avoid a warning

 *    04/03/2001 - moved linux/version.h above first use of KERNEL_VERSION

 *                 macros

 *    05/03/2001 - restore copying pe_t array in lvm_do_lv_status_byname. For

 *                 lvdisplay -v (PC)

 *               - restore copying pe_t array in lvm_do_lv_status_byindex (HM)

 *               - added copying pe_t array in lvm_do_lv_status_bydev (HM)

 *               - enhanced lvm_do_lv_status_by{name,index,dev} to be capable

 *                 to copy the lv_block_exception_t array to userspace (HM)

 *    08/03/2001 - initialize new lv_ptr->lv_COW_table_iobuf for snapshots;

 *                 removed obsolete lv_ptr->lv_COW_table_page initialization

 *               - factored lvm_do_pv_flush out of lvm_chr_ioctl (HM)

 *    09/03/2001 - Added _lock_open_count to ensure we only drop the lock

 *                 when the locking process closes.

 *    05/04/2001 - Defer writes to an extent that is being moved [JT]

 *    05/04/2001 - use b_rdev and b_rsector rather than b_dev and b_blocknr in

 *                 lvm_map() in order to make stacking devices more happy (HM)

 *    11/04/2001 - cleaned up the pvmove queue code. I no longer retain the

 *                 rw flag, instead WRITEA's are just dropped [JT]

 *    30/04/2001 - added KERNEL_VERSION > 2.4.3 get_hardsect_size() rather

 *                 than get_hardblocksize() call

 *    03/05/2001 - Use copy_to/from_user to preserve pointers in

 *                 lvm_do_status_by*

 *    11/05/2001 - avoid accesses to inactive snapshot data in

 *                 __update_hardsectsize() and lvm_do_lv_extend_reduce() (JW)

 *    28/05/2001 - implemented missing BLKSSZGET ioctl

 *    05/06/2001 - Move _pe_lock out of fast path for lvm_map when no PEs

 *                 locked.  Make buffer queue flush not need locking.

 *                 Fix lvm_user_bmap() to set b_rsector for new lvm_map(). [AED]

 *    30/06/2001 - Speed up __update_hardsectsize() by checking if PVs have

 *                 the same hardsectsize (very likely) before scanning all LEs

 *                 in the LV each time.  [AED]

 *    12/10/2001 - Use add/del_gendisk() routines in 2.4.10+

 *    01/11/2001 - Backport read_ahead change from Linus kernel [AED]

 *    24/05/2002 - fixed locking bug in lvm_do_le_remap() introduced with 1.0.4

 *    13/06/2002 - use blk_ioctl() to support various standard block ioctls

 *               - support HDIO_GETGEO_BIG ioctl

 *    05/07/2002 - fixed OBO error on vg array access [benh@kernel.crashing.org]

 *    22/07/2002 - streamlined blk_ioctl() call

 *    14/08/2002 - stored fs handle in lvm_do_lv_rename

 *                 [kaoru@bsd.tnes.nec.co.jp]

 *    06/02/2003 - fix persistent snapshot extend/reduce bug in

 *                 lvm_do_lv_extend_reduce() [dalestephenson@mac.com]

 *    04/03/2003 - snapshot extend/reduce memory leak

 *               - VG PE counter wrong [dalestephenson@mac.com]

 *

 */

#include <linux/version.h>

#define MAJOR_NR LVM_BLK_MAJOR

#define DEVICE_OFF(device)

#define LOCAL_END_REQUEST

/* lvm_do_lv_create calls fsync_dev_lockfs()/unlockfs() */

/* #define      LVM_VFS_ENHANCEMENT */

#include <linux/config.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/vmalloc.h>

#include <linux/slab.h>

#include <linux/init.h>

#include <linux/hdreg.h>

#include <linux/stat.h>

#include <linux/fs.h>

#include <linux/proc_fs.h>

#include <linux/blkdev.h>

#include <linux/genhd.h>

#include <linux/locks.h>

#include <linux/devfs_fs_kernel.h>

#include <linux/smp_lock.h>

#include <asm/ioctl.h>

#include <asm/segment.h>

#include <asm/uaccess.h>

#ifdef CONFIG_KERNELD

#include <linux/kerneld.h>

#endif

#include <linux/blk.h>

#include <linux/blkpg.h>

#include <linux/errno.h>

#include <linux/lvm.h>

#include "lvm-internal.h"

#define LVM_CORRECT_READ_AHEAD(a)               \

do {                                            \

        if ((a) < LVM_MIN_READ_AHEAD ||         \

            (a) > LVM_MAX_READ_AHEAD)           \

                (a) = LVM_DEFAULT_READ_AHEAD;   \

        read_ahead[MAJOR_NR] = (a);             \

} while(0)

#ifndef WRITEA

#  define WRITEA WRITE

#endif

/*

 * External function prototypes

 */

static int lvm_make_request_fn(request_queue_t *, int,

                               struct buffer_head *);

static int lvm_blk_ioctl(struct inode *, struct file *, uint, ulong);

static int lvm_blk_open(struct inode *, struct file *);

static int lvm_blk_close(struct inode *, struct file *);

static int lvm_get_snapshot_use_rate(lv_t * lv_ptr, void *arg);

static int lvm_user_bmap(struct inode *, struct lv_bmap *);

static int lvm_chr_open(struct inode *, struct file *);

static int lvm_chr_close(struct inode *, struct file *);

static int lvm_chr_ioctl(struct inode *, struct file *, uint, ulong);

/* End external function prototypes */

/*

 * Internal function prototypes

 */

static void lvm_cleanup(void);

static void lvm_init_vars(void);

#ifdef LVM_HD_NAME

extern void (*lvm_hd_name_ptr) (char *, int);

#endif

static int lvm_map(struct buffer_head *, int);

static int lvm_do_lock_lvm(void);

static int lvm_do_le_remap(vg_t *, void *);

static int lvm_do_pv_create(pv_t *, vg_t *, ulong);

static int lvm_do_pv_remove(vg_t *, ulong);

static int lvm_do_lv_create(int, char *, lv_t *);

static int lvm_do_lv_extend_reduce(int, char *, lv_t *);

static int lvm_do_lv_remove(int, char *, int);

static int lvm_do_lv_rename(vg_t *, lv_req_t *, lv_t *);

static int lvm_do_lv_status_byname(vg_t * r, void *);

static int lvm_do_lv_status_byindex(vg_t *, void *);

static int lvm_do_lv_status_bydev(vg_t *, void *);

static int lvm_do_pe_lock_unlock(vg_t * r, void *);

static int lvm_do_pv_change(vg_t *, void *);

static int lvm_do_pv_status(vg_t *, void *);

static int lvm_do_pv_flush(void *);

static int lvm_do_vg_create(void *, int minor);

static int lvm_do_vg_extend(vg_t *, void *);

static int lvm_do_vg_reduce(vg_t *, void *);

static int lvm_do_vg_rename(vg_t *, void *);

static int lvm_do_vg_remove(int);

static void lvm_geninit(struct gendisk *);

static void __update_hardsectsize(lv_t * lv);

static void _queue_io(struct buffer_head *bh, int rw);

static struct buffer_head *_dequeue_io(void);

static void _flush_io(struct buffer_head *bh);

static int _open_pv(pv_t * pv);

static void _close_pv(pv_t * pv);

static unsigned long _sectors_to_k(unsigned long sect);

#ifdef LVM_HD_NAME

void lvm_hd_name(char *, int);

#endif

/* END Internal function prototypes */

/* variables */

char *lvm_version =

    "LVM version " LVM_RELEASE_NAME "(" LVM_RELEASE_DATE ")";

ushort lvm_iop_version = LVM_DRIVER_IOP_VERSION;

int loadtime = 0;

const char *const lvm_name = LVM_NAME;

/* volume group descriptor area pointers */

vg_t *vg[ABS_MAX_VG + 1];

/* map from block minor number to VG and LV numbers */

static struct {

        int vg_number;

        int lv_number;

} vg_lv_map[ABS_MAX_LV];

/* Request structures (lvm_chr_ioctl()) */

static pv_change_req_t pv_change_req;

static pv_status_req_t pv_status_req;

volatile static pe_lock_req_t pe_lock_req;

static le_remap_req_t le_remap_req;

static lv_req_t lv_req;

#ifdef LVM_TOTAL_RESET

static int lvm_reset_spindown = 0;

#endif

static char pv_name[NAME_LEN];

/* static char rootvg[NAME_LEN] = { 0, }; */

static int lock = 0;

static int _lock_open_count = 0;

static uint vg_count = 0;

static long lvm_chr_open_count = 0;

static DECLARE_WAIT_QUEUE_HEAD(lvm_wait);

static spinlock_t lvm_lock = SPIN_LOCK_UNLOCKED;

static spinlock_t lvm_snapshot_lock = SPIN_LOCK_UNLOCKED;

static struct buffer_head *_pe_requests;

static DECLARE_RWSEM(_pe_lock);

struct file_operations lvm_chr_fops = {

        owner:THIS_MODULE,

        open:lvm_chr_open,

        release:lvm_chr_close,

        ioctl:lvm_chr_ioctl,

};

/* block device operations structure needed for 2.3.38? and above */

struct block_device_operations lvm_blk_dops = {

        .owner          = THIS_MODULE,

        .open           = lvm_blk_open,

        .release        = lvm_blk_close,

        .ioctl          = lvm_blk_ioctl,

};

/* gendisk structures */

static struct hd_struct lvm_hd_struct[MAX_LV];

static int lvm_blocksizes[MAX_LV];

static int lvm_hardsectsizes[MAX_LV];

static int lvm_size[MAX_LV];

static struct gendisk lvm_gendisk = {

        .major          = MAJOR_NR,

        .major_name     = LVM_NAME,

        .minor_shift    = 0,

        .max_p          = 1,

        .part           = lvm_hd_struct,

        .sizes          = lvm_size,

        .nr_real        = MAX_LV,

};

/*

 * Driver initialization...

 */

int lvm_init(void)

{

        if (devfs_register_chrdev(LVM_CHAR_MAJOR,

                                  lvm_name, &lvm_chr_fops) < 0) {

                printk(KERN_ERR "%s -- devfs_register_chrdev failed\n",

                       lvm_name);

                return -EIO;

        }

        if (devfs_register_blkdev(MAJOR_NR, lvm_name, &lvm_blk_dops) < 0)

        {

                printk("%s -- devfs_register_blkdev failed\n", lvm_name);

                if (devfs_unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)

                        printk(KERN_ERR

                               "%s -- devfs_unregister_chrdev failed\n",

                               lvm_name);

                return -EIO;

        }

        lvm_init_fs();

        lvm_init_vars();

        lvm_geninit(&lvm_gendisk);

        /* insert our gendisk at the corresponding major */

        add_gendisk(&lvm_gendisk);

#ifdef LVM_HD_NAME

        /* reference from drivers/block/genhd.c */

        lvm_hd_name_ptr = lvm_hd_name;

#endif

        blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR),

                               lvm_make_request_fn);

        /* initialise the pe lock */

        pe_lock_req.lock = UNLOCK_PE;

        /* optional read root VGDA */

/*

   if ( *rootvg != 0) vg_read_with_pv_and_lv ( rootvg, &vg);

*/

#ifdef MODULE

        printk(KERN_INFO "%s module loaded\n", lvm_version);

#else

        printk(KERN_INFO "%s\n", lvm_version);

#endif

        return 0;

}                               /* lvm_init() */

/*

 * cleanup...

 */

static void lvm_cleanup(void)

{

        if (devfs_unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)

                printk(KERN_ERR "%s -- devfs_unregister_chrdev failed\n",

                       lvm_name);

        if (devfs_unregister_blkdev(MAJOR_NR, lvm_name) < 0)

                printk(KERN_ERR "%s -- devfs_unregister_blkdev failed\n",

                       lvm_name);

        /* delete our gendisk from chain */

        del_gendisk(&lvm_gendisk);

        blk_size[MAJOR_NR] = NULL;

        blksize_size[MAJOR_NR] = NULL;

        hardsect_size[MAJOR_NR] = NULL;

#ifdef LVM_HD_NAME

        /* reference from linux/drivers/block/genhd.c */

        lvm_hd_name_ptr = NULL;

#endif

        /* unregister with procfs and devfs */

        lvm_fin_fs();

#ifdef MODULE

        printk(KERN_INFO "%s -- Module successfully deactivated\n",

               lvm_name);

#endif

        return;

}                               /* lvm_cleanup() */

/*

 * support function to initialize lvm variables

 */

static void __init lvm_init_vars(void)

{

        int v;

        loadtime = CURRENT_TIME;

        lvm_lock = lvm_snapshot_lock = SPIN_LOCK_UNLOCKED;

        pe_lock_req.lock = UNLOCK_PE;

        pe_lock_req.data.lv_dev = 0;

        pe_lock_req.data.pv_dev = 0;

        pe_lock_req.data.pv_offset = 0;

        /* Initialize VG pointers */

        for (v = 0; v < ABS_MAX_VG + 1; v++)

                vg[v] = NULL;

        /* Initialize LV -> VG association */

        for (v = 0; v < ABS_MAX_LV; v++) {

                /* index ABS_MAX_VG never used for real VG */

                vg_lv_map[v].vg_number = ABS_MAX_VG;

                vg_lv_map[v].lv_number = -1;

        }

        return;

}                               /* lvm_init_vars() */

/********************************************************************

 *

 * Character device functions

 *

 ********************************************************************/

#define MODE_TO_STR(mode) (mode) & FMODE_READ ? "READ" : "", \

                          (mode) & FMODE_WRITE ? "WRITE" : ""

/*

 * character device open routine

 */

static int lvm_chr_open(struct inode *inode, struct file *file)

{

        int minor = MINOR(inode->i_rdev);

        P_DEV("chr_open MINOR: %d  VG#: %d  mode: %s%s  lock: %d\n",

              minor, VG_CHR(minor), MODE_TO_STR(file->f_mode), lock);

        /* super user validation */

        if (!capable(CAP_SYS_ADMIN))

                return -EACCES;

        /* Group special file open */

        if (VG_CHR(minor) > MAX_VG)

                return -ENXIO;

        spin_lock(&lvm_lock);

        if (lock == current->pid)

                _lock_open_count++;

        spin_unlock(&lvm_lock);

        lvm_chr_open_count++;

        MOD_INC_USE_COUNT;

        return 0;

}                               /* lvm_chr_open() */

/*

 * character device i/o-control routine

 *

 * Only one changing process can do changing ioctl at one time,

 * others will block.

 *

 */

static int lvm_chr_ioctl(struct inode *inode, struct file *file,

                         uint command, ulong a)

{

        int minor = MINOR(inode->i_rdev);

        uint extendable, l, v;

        void *arg = (void *) a;

        lv_t lv;

        vg_t *vg_ptr = vg[VG_CHR(minor)];

        /* otherwise cc will complain about unused variables */

        (void) lvm_lock;

        P_IOCTL

            ("chr MINOR: %d  command: 0x%X  arg: %p  VG#: %d  mode: %s%s\n",

             minor, command, arg, VG_CHR(minor),

             MODE_TO_STR(file->f_mode));

#ifdef LVM_TOTAL_RESET

        if (lvm_reset_spindown > 0)

                return -EACCES;

#endif

        /* Main command switch */

        switch (command) {

        case LVM_LOCK_LVM:

                /* lock the LVM */

                return lvm_do_lock_lvm();

        case LVM_GET_IOP_VERSION:

                /* check lvm version to ensure driver/tools+lib

                   interoperability */

                if (copy_to_user(arg, &lvm_iop_version, sizeof(ushort)) !=

                    0)

                        return -EFAULT;

                return 0;

#ifdef LVM_TOTAL_RESET

        case LVM_RESET:

                /* lock reset function */

                lvm_reset_spindown = 1;

                for (v = 0; v < ABS_MAX_VG; v++) {

                        if (vg[v] != NULL)

                                lvm_do_vg_remove(v);

                }

#ifdef MODULE

                while (GET_USE_COUNT(&__this_module) < 1)

                        MOD_INC_USE_COUNT;

                while (GET_USE_COUNT(&__this_module) > 1)

                        MOD_DEC_USE_COUNT;

#endif                          /* MODULE */

                lock = 0;        /* release lock */

                wake_up_interruptible(&lvm_wait);

                return 0;

#endif                          /* LVM_TOTAL_RESET */

        case LE_REMAP:

                /* remap a logical extent (after moving the physical extent) */

                return lvm_do_le_remap(vg_ptr, arg);

        case PE_LOCK_UNLOCK:

                /* lock/unlock i/o to a physical extent to move it to another

                   physical volume (move's done in user space's pvmove) */

                return lvm_do_pe_lock_unlock(vg_ptr, arg);

        case VG_CREATE_OLD:

                /* create a VGDA */

                return lvm_do_vg_create(arg, minor);

        case VG_CREATE:

                /* create a VGDA, assume VG number is filled in */

                return lvm_do_vg_create(arg, -1);

        case VG_EXTEND:

                /* extend a volume group */

                return lvm_do_vg_extend(vg_ptr, arg);

        case VG_REDUCE:

                /* reduce a volume group */

                return lvm_do_vg_reduce(vg_ptr, arg);

        case VG_RENAME:

                /* rename a volume group */

                return lvm_do_vg_rename(vg_ptr, arg);

        case VG_REMOVE:

                /* remove an inactive VGDA */

                return lvm_do_vg_remove(minor);

        case VG_SET_EXTENDABLE:

                /* set/clear extendability flag of volume group */

                if (vg_ptr == NULL)

                        return -ENXIO;

                if (copy_from_user(&extendable, arg, sizeof(extendable)) !=

                    0)

                        return -EFAULT;

                if (extendable == VG_EXTENDABLE ||

                    extendable == ~VG_EXTENDABLE) {

                        if (extendable == VG_EXTENDABLE)

                                vg_ptr->vg_status |= VG_EXTENDABLE;

                        else

                                vg_ptr->vg_status &= ~VG_EXTENDABLE;

                } else

                        return -EINVAL;

                return 0;

        case VG_STATUS:

                /* get volume group data (only the vg_t struct) */

                if (vg_ptr == NULL)

                        return -ENXIO;

                if (copy_to_user(arg, vg_ptr, sizeof(vg_t)) != 0)

                        return -EFAULT;

                return 0;

        case VG_STATUS_GET_COUNT:

                /* get volume group count */

                if (copy_to_user(arg, &vg_count, sizeof(vg_count)) != 0)

                        return -EFAULT;

                return 0;

        case VG_STATUS_GET_NAMELIST:

                /* get volume group names */

                for (l = v = 0; v < ABS_MAX_VG; v++) {

                        if (vg[v] != NULL) {

                                if (copy_to_user(arg + l * NAME_LEN,

                                                 vg[v]->vg_name,

                                                 NAME_LEN) != 0)

                                        return -EFAULT;

                                l++;

                        }

                }

                return 0;

        case LV_CREATE: