patch-2.4.19 linux-2.4.19/drivers/md/lvm.c
Next file: linux-2.4.19/drivers/md/md.c
Previous file: linux-2.4.19/drivers/md/lvm-snap.c
Back to the patch index
Back to the overall index
- Lines: 2631
- Date:
Fri Aug 2 17:39:44 2002
- Orig file:
linux-2.4.18/drivers/md/lvm.c
- Orig date:
Mon Nov 19 09:56:04 2001
diff -urN linux-2.4.18/drivers/md/lvm.c linux-2.4.19/drivers/md/lvm.c
@@ -1,13 +1,13 @@
/*
* kernel/lvm.c
*
- * Copyright (C) 1997 - 2000 Heinz Mauelshagen, Sistina Software
+ * Copyright (C) 1997 - 2001 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 2001
+ * January-April 2001
*
*
* LVM driver is free software; you can redistribute it and/or modify
@@ -43,7 +43,8 @@
* 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()
+ * 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
@@ -125,7 +126,8 @@
* 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
+ * 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
@@ -147,15 +149,24 @@
* 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 unnecessary overhead in case of heavy updates
+ * 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 - If you try and BMAP a snapshot you now get an -EPERM
- * 01/02/2001 - factored __remap_snapshot out of lvm_map
+ * 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
- * 14/02/2001 - tidied device defines for blk.h
+ * 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
- * 14/02/2001 - bug: vg[] member not set back to NULL if activation fails
+ * 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]
@@ -163,25 +174,50 @@
* 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.
+ * 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 - factored lvm_do_pv_flush out of lvm_chr_ioctl [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 - lvm_map bugs: don't use b_blocknr/b_dev in lvm_map, it
- * destroys stacking devices. call b_end_io on failed maps.
- * (Jens Axboe)
- * - Defer writes to an extent that is being moved [JT + AD]
- * 28/05/2001 - implemented missing BLKSSZGET ioctl [AD]
+ * 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]
*
*/
+#include <linux/version.h>
#define MAJOR_NR LVM_BLK_MAJOR
#define DEVICE_OFF(device)
@@ -191,11 +227,10 @@
/* #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>
@@ -206,6 +241,8 @@
#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>
@@ -224,9 +261,13 @@
#include "lvm-internal.h"
-#define LVM_CORRECT_READ_AHEAD( a) \
- if ( a < LVM_MIN_READ_AHEAD || \
- a > LVM_MAX_READ_AHEAD) a = LVM_MAX_READ_AHEAD;
+#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
@@ -236,13 +277,14 @@
/*
* External function prototypes
*/
-static int lvm_make_request_fn(request_queue_t*, int, struct buffer_head*);
+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_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 *);
@@ -272,13 +314,13 @@
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_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_pe_lock_unlock(vg_t * r, void *);
-static int lvm_do_pv_change(vg_t*, 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 *);
@@ -288,15 +330,15 @@
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 __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 int _open_pv(pv_t * pv);
+static void _close_pv(pv_t * pv);
static unsigned long _sectors_to_k(unsigned long sect);
@@ -307,7 +349,8 @@
/* variables */
-char *lvm_version = "LVM version "LVM_RELEASE_NAME"("LVM_RELEASE_DATE")";
+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;
@@ -351,18 +394,17 @@
struct file_operations lvm_chr_fops = {
- open: lvm_chr_open,
- release: lvm_chr_close,
- ioctl: lvm_chr_ioctl,
+ 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,
+struct block_device_operations lvm_blk_dops = {
+ owner:THIS_MODULE,
+ open:lvm_blk_open,
+ release:lvm_blk_close,
+ ioctl:lvm_blk_ioctl,
};
@@ -372,17 +414,17 @@
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,
+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...
*/
@@ -394,7 +436,6 @@
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);
@@ -409,6 +450,7 @@
lvm_init_vars();
lvm_geninit(&lvm_gendisk);
+ /* insert our gendisk at the corresponding major */
add_gendisk(&lvm_gendisk);
#ifdef LVM_HD_NAME
@@ -416,7 +458,8 @@
lvm_hd_name_ptr = lvm_hd_name;
#endif
- blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), lvm_make_request_fn);
+ blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR),
+ lvm_make_request_fn);
/* initialise the pe lock */
@@ -434,12 +477,12 @@
#endif
return 0;
-} /* lvm_init() */
-
+} /* lvm_init() */
/*
* cleanup...
*/
+
static void lvm_cleanup(void)
{
if (devfs_unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)
@@ -449,6 +492,9 @@
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;
@@ -464,11 +510,12 @@
lvm_fin_fs();
#ifdef MODULE
- printk(KERN_INFO "%s -- Module successfully deactivated\n", lvm_name);
+ printk(KERN_INFO "%s -- Module successfully deactivated\n",
+ lvm_name);
#endif
return;
-} /* lvm_cleanup() */
+} /* lvm_cleanup() */
/*
* support function to initialize lvm variables
@@ -487,7 +534,8 @@
pe_lock_req.data.pv_offset = 0;
/* Initialize VG pointers */
- for (v = 0; v < ABS_MAX_VG; v++) vg[v] = NULL;
+ for (v = 0; v < ABS_MAX_VG; v++)
+ vg[v] = NULL;
/* Initialize LV -> VG association */
for (v = 0; v < ABS_MAX_LV; v++) {
@@ -497,7 +545,7 @@
}
return;
-} /* lvm_init_vars() */
+} /* lvm_init_vars() */
/********************************************************************
@@ -514,28 +562,30 @@
*/
static int lvm_chr_open(struct inode *inode, struct file *file)
{
- unsigned int minor = MINOR(inode->i_rdev);
+ 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;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
/* Group special file open */
- if (VG_CHR(minor) > MAX_VG) return -ENXIO;
+ if (VG_CHR(minor) > MAX_VG)
+ return -ENXIO;
- spin_lock(&lvm_lock);
- if(lock == current->pid)
- _lock_open_count++;
- spin_unlock(&lvm_lock);
+ 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() */
+} /* lvm_chr_open() */
/*
@@ -546,22 +596,25 @@
*
*/
static int lvm_chr_ioctl(struct inode *inode, struct file *file,
- uint command, ulong a)
+ 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)];
+ 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));
+ 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;
+ if (lvm_reset_spindown > 0)
+ return -EACCES;
#endif
/* Main command switch */
@@ -573,8 +626,8 @@
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;
+ if (copy_to_user(arg, &lvm_iop_version, sizeof(ushort)) !=
+ 0) return -EFAULT;
return 0;
#ifdef LVM_TOTAL_RESET
@@ -582,7 +635,8 @@
/* lock reset function */
lvm_reset_spindown = 1;
for (v = 0; v < ABS_MAX_VG; v++) {
- if (vg[v] != NULL) lvm_do_vg_remove(v);
+ if (vg[v] != NULL)
+ lvm_do_vg_remove(v);
}
#ifdef MODULE
@@ -590,28 +644,28 @@
MOD_INC_USE_COUNT;
while (GET_USE_COUNT(&__this_module) > 1)
MOD_DEC_USE_COUNT;
-#endif /* MODULE */
+#endif /* MODULE */
lock = 0; /* release lock */
wake_up_interruptible(&lvm_wait);
return 0;
-#endif /* LVM_TOTAL_RESET */
+#endif /* LVM_TOTAL_RESET */
case LE_REMAP:
/* remap a logical extent (after moving the physical extent) */
- return lvm_do_le_remap(vg_ptr,arg);
+ 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);
+ 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 */
+ case VG_CREATE:
+ /* create a VGDA, assume VG number is filled in */
return lvm_do_vg_create(arg, -1);
case VG_EXTEND:
@@ -633,9 +687,10 @@
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 (vg_ptr == NULL)
+ return -ENXIO;
+ if (copy_from_user(&extendable, arg, sizeof(extendable)) !=
+ 0) return -EFAULT;
if (extendable == VG_EXTENDABLE ||
extendable == ~VG_EXTENDABLE) {
@@ -643,13 +698,15 @@
vg_ptr->vg_status |= VG_EXTENDABLE;
else
vg_ptr->vg_status &= ~VG_EXTENDABLE;
- } else return -EINVAL;
+ } else
+ return -EINVAL;
return 0;
case VG_STATUS:
/* get volume group data (only the vg_t struct) */
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_to_user(arg, vg_ptr, sizeof(vg_t)) != 0)
return -EFAULT;
return 0;
@@ -682,21 +739,25 @@
case LV_REMOVE:
case LV_RENAME:
/* create, extend, reduce, remove or rename a logical volume */
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&lv_req, arg, sizeof(lv_req)) != 0)
return -EFAULT;
if (command != LV_REMOVE) {
- if (copy_from_user(&lv, lv_req.lv, sizeof(lv_t)) != 0)
- return -EFAULT;
+ if (copy_from_user(&lv, lv_req.lv, sizeof(lv_t)) !=
+ 0) return -EFAULT;
}
switch (command) {
case LV_CREATE:
- return lvm_do_lv_create(minor, lv_req.lv_name, &lv);
+ return lvm_do_lv_create(minor, lv_req.lv_name,
+ &lv);
case LV_EXTEND:
case LV_REDUCE:
- return lvm_do_lv_extend_reduce(minor, lv_req.lv_name, &lv);
+ return lvm_do_lv_extend_reduce(minor,
+ lv_req.lv_name,
+ &lv);
case LV_REMOVE:
return lvm_do_lv_remove(minor, lv_req.lv_name, -1);
@@ -724,17 +785,17 @@
case PV_CHANGE:
/* change a physical volume */
- return lvm_do_pv_change(vg_ptr,arg);
+ return lvm_do_pv_change(vg_ptr, arg);
case PV_STATUS:
/* get physical volume data (pv_t structure only) */
- return lvm_do_pv_status(vg_ptr,arg);
+ return lvm_do_pv_status(vg_ptr, arg);
case PV_FLUSH:
/* physical volume buffer flush/invalidate */
- return lvm_do_pv_flush(arg);
+ return lvm_do_pv_flush(arg);
default:
@@ -745,7 +806,7 @@
}
return 0;
-} /* lvm_chr_ioctl */
+} /* lvm_chr_ioctl */
/*
@@ -763,23 +824,25 @@
}
#endif
- if (lvm_chr_open_count > 0) lvm_chr_open_count--;
+ if (lvm_chr_open_count > 0)
+ lvm_chr_open_count--;
- spin_lock(&lvm_lock);
- if(lock == current->pid) {
- if(!_lock_open_count) {
- P_DEV("chr_close: unlocking LVM for pid %d\n", lock);
- lock = 0;
- wake_up_interruptible(&lvm_wait);
- } else
- _lock_open_count--;
+ spin_lock(&lvm_lock);
+ if (lock == current->pid) {
+ if (!_lock_open_count) {
+ P_DEV("chr_close: unlocking LVM for pid %d\n",
+ lock);
+ lock = 0;
+ wake_up_interruptible(&lvm_wait);
+ } else
+ _lock_open_count--;
}
- spin_unlock(&lvm_lock);
+ spin_unlock(&lvm_lock);
MOD_DEC_USE_COUNT;
return 0;
-} /* lvm_chr_close() */
+} /* lvm_chr_close() */
@@ -799,7 +862,8 @@
vg_t *vg_ptr = vg[VG_BLK(minor)];
P_DEV("blk_open MINOR: %d VG#: %d LV#: %d mode: %s%s\n",
- minor, VG_BLK(minor), LV_BLK(minor), MODE_TO_STR(file->f_mode));
+ minor, VG_BLK(minor), LV_BLK(minor),
+ MODE_TO_STR(file->f_mode));
#ifdef LVM_TOTAL_RESET
if (lvm_reset_spindown > 0)
@@ -809,26 +873,25 @@
if (vg_ptr != NULL &&
(vg_ptr->vg_status & VG_ACTIVE) &&
(lv_ptr = vg_ptr->lv[LV_BLK(minor)]) != NULL &&
- LV_BLK(minor) >= 0 &&
- LV_BLK(minor) < vg_ptr->lv_max) {
+ LV_BLK(minor) >= 0 && LV_BLK(minor) < vg_ptr->lv_max) {
/* Check parallel LV spindown (LV remove) */
- if (lv_ptr->lv_status & LV_SPINDOWN) return -EPERM;
+ if (lv_ptr->lv_status & LV_SPINDOWN)
+ return -EPERM;
/* Check inactive LV and open for read/write */
/* We need to be able to "read" an inactive LV
to re-activate it again */
if ((file->f_mode & FMODE_WRITE) &&
- (!(lv_ptr->lv_status & LV_ACTIVE)))
- return -EPERM;
+ (!(lv_ptr->lv_status & LV_ACTIVE))) return -EPERM;
if (!(lv_ptr->lv_access & LV_WRITE) &&
- (file->f_mode & FMODE_WRITE))
- return -EACCES;
+ (file->f_mode & FMODE_WRITE)) return -EACCES;
- /* be sure to increment VG counter */
- if (lv_ptr->lv_open == 0) vg_ptr->lv_open++;
+ /* be sure to increment VG counter */
+ if (lv_ptr->lv_open == 0)
+ vg_ptr->lv_open++;
lv_ptr->lv_open++;
MOD_INC_USE_COUNT;
@@ -838,7 +901,7 @@
return 0;
}
return -ENXIO;
-} /* lvm_blk_open() */
+} /* lvm_blk_open() */
/*
@@ -860,24 +923,26 @@
switch (command) {
case BLKSSZGET:
/* get block device sector size as needed e.g. by fdisk */
- return put_user(get_hardsect_size(inode->i_rdev), (int *) arg);
+ return put_user(lvm_sectsize(inode->i_rdev), (int *) arg);
case BLKGETSIZE:
/* return device size */
P_IOCTL("BLKGETSIZE: %u\n", lv_ptr->lv_size);
- if (put_user(lv_ptr->lv_size, (unsigned long *)arg))
+ if (put_user(lv_ptr->lv_size, (unsigned long *) arg))
return -EFAULT;
break;
+#ifdef BLKGETSIZE64
case BLKGETSIZE64:
- if (put_user((u64)lv_ptr->lv_size << 9, (u64 *)arg))
+ if (put_user((u64) lv_ptr->lv_size << 9, (u64 *) arg))
return -EFAULT;
break;
-
+#endif
case BLKFLSBUF:
/* flush buffer cache */
- if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
P_IOCTL("BLKFLSBUF\n");
@@ -888,22 +953,24 @@
case BLKRASET:
/* set read ahead for block device */
- if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
P_IOCTL("BLKRASET: %ld sectors for %s\n",
(long) arg, kdevname(inode->i_rdev));
if ((long) arg < LVM_MIN_READ_AHEAD ||
- (long) arg > LVM_MAX_READ_AHEAD)
- return -EINVAL;
+ (long) arg > LVM_MAX_READ_AHEAD) return -EINVAL;
lv_ptr->lv_read_ahead = (long) arg;
+ LVM_CORRECT_READ_AHEAD(lv_ptr->lv_read_ahead);
+ read_ahead[MAJOR_NR] = lv_ptr->lv_read_ahead;
break;
case BLKRAGET:
/* get current read ahead setting */
P_IOCTL("BLKRAGET %d\n", lv_ptr->lv_read_ahead);
- if (put_user(lv_ptr->lv_read_ahead, (long *)arg))
+ if (put_user(lv_ptr->lv_read_ahead, (long *) arg))
return -EFAULT;
break;
@@ -917,16 +984,18 @@
unsigned char heads = 64;
unsigned char sectors = 32;
long start = 0;
- short cylinders = lv_ptr->lv_size / heads / sectors;
+ short cylinders =
+ lv_ptr->lv_size / heads / sectors;
if (copy_to_user((char *) &hd->heads, &heads,
sizeof(heads)) != 0 ||
copy_to_user((char *) &hd->sectors, §ors,
sizeof(sectors)) != 0 ||
copy_to_user((short *) &hd->cylinders,
- &cylinders, sizeof(cylinders)) != 0 ||
- copy_to_user((long *) &hd->start, &start,
- sizeof(start)) != 0)
+ &cylinders,
+ sizeof(cylinders)) != 0
+ || copy_to_user((long *) &hd->start, &start,
+ sizeof(start)) != 0)
return -EFAULT;
P_IOCTL("%s -- lvm_blk_ioctl -- cylinders: %d\n",
@@ -937,9 +1006,10 @@
case LV_SET_ACCESS:
/* set access flags of a logical volume */
- if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
lv_ptr->lv_access = (ulong) arg;
- if ( lv_ptr->lv_access & LV_WRITE)
+ if (lv_ptr->lv_access & LV_WRITE)
set_device_ro(lv_ptr->lv_dev, 0);
else
set_device_ro(lv_ptr->lv_dev, 1);
@@ -948,23 +1018,25 @@
case LV_SET_STATUS:
/* set status flags of a logical volume */
- if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
if (!((ulong) arg & LV_ACTIVE) && lv_ptr->lv_open > 1)
return -EPERM;
lv_ptr->lv_status = (ulong) arg;
break;
case LV_BMAP:
- /* turn logical block into (dev_t, block). non privileged. */
- /* don't bmap a snapshot, since the mapping can change */
- if(lv_ptr->lv_access & LV_SNAPSHOT)
+ /* turn logical block into (dev_t, block). non privileged. */
+ /* don't bmap a snapshot, since the mapping can change */
+ if (lv_ptr->lv_access & LV_SNAPSHOT)
return -EPERM;
return lvm_user_bmap(inode, (struct lv_bmap *) arg);
case LV_SET_ALLOCATION:
/* set allocation flags of a logical volume */
- if (!capable(CAP_SYS_ADMIN)) return -EACCES;
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
lv_ptr->lv_allocation = (ulong) arg;
break;
@@ -979,7 +1051,7 @@
}
return 0;
-} /* lvm_blk_ioctl() */
+} /* lvm_blk_ioctl() */
/*
@@ -994,15 +1066,16 @@
P_DEV("blk_close MINOR: %d VG#: %d LV#: %d\n",
minor, VG_BLK(minor), LV_BLK(minor));
- if (lv_ptr->lv_open == 1) vg_ptr->lv_open--;
+ if (lv_ptr->lv_open == 1)
+ vg_ptr->lv_open--;
lv_ptr->lv_open--;
MOD_DEC_USE_COUNT;
return 0;
-} /* lvm_blk_close() */
+} /* lvm_blk_close() */
-static int lvm_get_snapshot_use_rate(lv_t *lv, void *arg)
+static int lvm_get_snapshot_use_rate(lv_t * lv, void *arg)
{
lv_snapshot_use_rate_req_t lv_rate_req;
@@ -1020,7 +1093,7 @@
lv->lv_snapshot_use_rate = lv_rate_req.rate;
if (lv->lv_remap_ptr * 100 / lv->lv_remap_end <
lv->lv_snapshot_use_rate)
- interruptible_sleep_on(&lv->lv_snapshot_wait);
+ interruptible_sleep_on(&lv->lv_snapshot_wait);
break;
case O_NONBLOCK:
@@ -1044,19 +1117,20 @@
if (get_user(block, &user_result->lv_block))
return -EFAULT;
- memset(&bh,0,sizeof bh);
+ memset(&bh, 0, sizeof bh);
bh.b_blocknr = block;
bh.b_dev = bh.b_rdev = inode->i_rdev;
bh.b_size = lvm_get_blksize(bh.b_dev);
- bh.b_rsector = block * (bh.b_size >> 9);
- if ((err=lvm_map(&bh, READ)) < 0) {
+ bh.b_rsector = block * (bh.b_size >> 9);
+ bh.b_end_io = NULL;
+ if ((err = lvm_map(&bh, READ)) < 0) {
printk("lvm map failed: %d\n", err);
return -EINVAL;
}
return put_user(kdev_t_to_nr(bh.b_rdev), &user_result->lv_dev) ||
- put_user(bh.b_rsector/(bh.b_size>>9), &user_result->lv_block) ?
- -EFAULT : 0;
+ put_user(bh.b_rsector / (bh.b_size >> 9),
+ &user_result->lv_block) ? -EFAULT : 0;
}
@@ -1065,7 +1139,8 @@
* (see init_module/lvm_init)
*/
static void __remap_snapshot(kdev_t rdev, ulong rsector,
- ulong pe_start, lv_t *lv, vg_t *vg) {
+ ulong pe_start, lv_t * lv, vg_t * vg)
+{
/* copy a chunk from the origin to a snapshot device */
down_write(&lv->lv_lock);
@@ -1080,7 +1155,8 @@
}
static inline void _remap_snapshot(kdev_t rdev, ulong rsector,
- ulong pe_start, lv_t *lv, vg_t *vg) {
+ ulong pe_start, lv_t * lv, vg_t * vg)
+{
int r;
/* check to see if this chunk is already in the snapshot */
@@ -1097,7 +1173,8 @@
/*
* extents destined for a pe that is on the move should be deferred
*/
-static inline int _should_defer(kdev_t pv, ulong sector, uint32_t pe_size) {
+static inline int _should_defer(kdev_t pv, ulong sector, uint32_t pe_size)
+{
return ((pe_lock_req.lock == LOCK_PE) &&
(pv == pe_lock_req.data.pv_dev) &&
(sector >= pe_lock_req.data.pv_offset) &&
@@ -1122,6 +1199,7 @@
return 0;
}
+
static int lvm_map(struct buffer_head *bh, int rw)
{
int minor = MINOR(bh->b_rdev);
@@ -1143,34 +1221,32 @@
goto bad;
}
- if ((rw == WRITE || rw == WRITEA) &&
- !(lv->lv_access & LV_WRITE)) {
+ if ((rw == WRITE || rw == WRITEA) && !(lv->lv_access & LV_WRITE)) {
printk(KERN_CRIT
"%s - lvm_map: ll_rw_blk write for readonly LV %s\n",
lvm_name, lv->lv_name);
goto bad;
}
- P_MAP("%s - lvm_map minor: %d *rdev: %s *rsector: %lu size:%lu\n",
- lvm_name, minor,
- kdevname(bh->b_rdev),
- rsector_org, size);
+ P_MAP
+ ("%s - lvm_map minor: %d *rdev: %s *rsector: %lu size:%lu\n",
+ lvm_name, minor, kdevname(bh->b_rdev), rsector_org, size);
if (rsector_org + size > lv->lv_size) {
printk(KERN_ALERT
"%s - lvm_map access beyond end of device; *rsector: "
- "%lu or size: %lu wrong for minor: %2d\n",
- lvm_name, rsector_org, size, minor);
+ "%lu or size: %lu wrong for minor: %2d\n",
+ lvm_name, rsector_org, size, minor);
goto bad;
}
- if (lv->lv_stripes < 2) { /* linear mapping */
+ if (lv->lv_stripes < 2) { /* linear mapping */
/* get the index */
index = rsector_org / vg_this->pe_size;
pe_start = lv->lv_current_pe[index].pe;
rsector_map = lv->lv_current_pe[index].pe +
- (rsector_org % vg_this->pe_size);
+ (rsector_org % vg_this->pe_size);
rdev_map = lv->lv_current_pe[index].dev;
P_MAP("lv_current_pe[%ld].pe: %d rdev: %s rsector:%ld\n",
@@ -1183,22 +1259,23 @@
stripe_length = vg_this->pe_size * lv->lv_stripes;
stripe_index = (rsector_org % stripe_length) /
- lv->lv_stripesize;
+ lv->lv_stripesize;
index = rsector_org / stripe_length +
- (stripe_index % lv->lv_stripes) *
- (lv->lv_allocated_le / lv->lv_stripes);
+ (stripe_index % lv->lv_stripes) *
+ (lv->lv_allocated_le / lv->lv_stripes);
pe_start = lv->lv_current_pe[index].pe;
rsector_map = lv->lv_current_pe[index].pe +
- (rsector_org % stripe_length) -
- (stripe_index % lv->lv_stripes) * lv->lv_stripesize -
- stripe_index / lv->lv_stripes *
- (lv->lv_stripes - 1) * lv->lv_stripesize;
+ (rsector_org % stripe_length) -
+ (stripe_index % lv->lv_stripes) * lv->lv_stripesize -
+ stripe_index / lv->lv_stripes *
+ (lv->lv_stripes - 1) * lv->lv_stripesize;
rdev_map = lv->lv_current_pe[index].dev;
P_MAP("lv_current_pe[%ld].pe: %d rdev: %s rsector:%ld\n"
"stripe_length: %ld stripe_index: %ld\n",
- index, lv->lv_current_pe[index].pe, kdevname(rdev_map),
- rsector_map, stripe_length, stripe_index);
+ index, lv->lv_current_pe[index].pe,
+ kdevname(rdev_map), rsector_map, stripe_length,
+ stripe_index);
}
/*
@@ -1207,8 +1284,8 @@
* we need to queue this request, because this is in the fast path.
*/
if (rw == WRITE || rw == WRITEA) {
- if(_defer_extent(bh, rw, rdev_map,
- rsector_map, vg_this->pe_size)) {
+ if (_defer_extent(bh, rw, rdev_map,
+ rsector_map, vg_this->pe_size)) {
up_read(&lv->lv_lock);
return 0;
@@ -1219,17 +1296,14 @@
lv->lv_current_pe[index].reads++; /* statistic */
/* snapshot volume exception handling on physical device address base */
- if (!(lv->lv_access & (LV_SNAPSHOT|LV_SNAPSHOT_ORG)))
+ if (!(lv->lv_access & (LV_SNAPSHOT | LV_SNAPSHOT_ORG)))
goto out;
- if (lv->lv_access & LV_SNAPSHOT) { /* remap snapshot */
- if (lv->lv_block_exception)
- lvm_snapshot_remap_block(&rdev_map, &rsector_map,
- pe_start, lv);
- else
- goto bad;
-
- } else if (rw == WRITE || rw == WRITEA) { /* snapshot origin */
+ if (lv->lv_access & LV_SNAPSHOT) { /* remap snapshot */
+ if (lvm_snapshot_remap_block
+ (&rdev_map, &rsector_map, pe_start, lv) < 0)
+ goto bad;
+ } else if (rw == WRITE || rw == WRITEA) { /* snapshot origin */
lv_t *snap;
/* start with first snapshot and loop through all of
@@ -1243,21 +1317,21 @@
/* Serializes the COW with the accesses to the
snapshot device */
_remap_snapshot(rdev_map, rsector_map,
- pe_start, snap, vg_this);
+ pe_start, snap, vg_this);
}
- }
+ }
- out:
+ out:
bh->b_rdev = rdev_map;
bh->b_rsector = rsector_map;
up_read(&lv->lv_lock);
return 1;
- bad:
- buffer_IO_error(bh);
+ bad:
+ if (bh->b_end_io) buffer_IO_error(bh);
up_read(&lv->lv_lock);
return -1;
-} /* lvm_map() */
+} /* lvm_map() */
/*
@@ -1284,12 +1358,14 @@
#endif
+
+
/*
* make request function
*/
-static int lvm_make_request_fn(request_queue_t *q,
- int rw,
- struct buffer_head *bh) {
+static int lvm_make_request_fn(request_queue_t * q,
+ int rw, struct buffer_head *bh)
+{
return (lvm_map(bh, rw) <= 0) ? 0 : 1;
}
@@ -1304,7 +1380,7 @@
*/
static int lvm_do_lock_lvm(void)
{
-lock_try_again:
+ lock_try_again:
spin_lock(&lvm_lock);
if (lock != 0 && lock != current->pid) {
P_DEV("lvm_do_lock_lvm: locked by pid %d ...\n", lock);
@@ -1322,19 +1398,20 @@
P_DEV("lvm_do_lock_lvm: locking LVM for pid %d\n", lock);
spin_unlock(&lvm_lock);
return 0;
-} /* lvm_do_lock_lvm */
+} /* lvm_do_lock_lvm */
/*
* character device support function lock/unlock physical extend
*/
-static int lvm_do_pe_lock_unlock(vg_t *vg_ptr, void *arg)
+static int lvm_do_pe_lock_unlock(vg_t * vg_ptr, void *arg)
{
pe_lock_req_t new_lock;
struct buffer_head *bh;
uint p;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&new_lock, arg, sizeof(new_lock)) != 0)
return -EFAULT;
@@ -1345,7 +1422,8 @@
new_lock.data.pv_dev == vg_ptr->pv[p]->pv_dev)
break;
}
- if (p == vg_ptr->pv_max) return -ENXIO;
+ if (p == vg_ptr->pv_max)
+ return -ENXIO;
/*
* this sync releaves memory pressure to lessen the
@@ -1396,21 +1474,20 @@
/*
* character device support function logical extend remap
*/
-static int lvm_do_le_remap(vg_t *vg_ptr, void *arg)
+static int lvm_do_le_remap(vg_t * vg_ptr, void *arg)
{
uint l, le;
lv_t *lv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&le_remap_req, arg,
- sizeof(le_remap_req_t)) != 0)
- return -EFAULT;
+ sizeof(le_remap_req_t)) != 0) return -EFAULT;
for (l = 0; l < vg_ptr->lv_max; l++) {
lv_ptr = vg_ptr->lv[l];
if (lv_ptr != NULL &&
- strcmp(lv_ptr->lv_name,
- le_remap_req.lv_name) == 0) {
+ strcmp(lv_ptr->lv_name, le_remap_req.lv_name) == 0) {
for (le = 0; le < lv_ptr->lv_allocated_le; le++) {
if (lv_ptr->lv_current_pe[le].dev ==
le_remap_req.old_dev &&
@@ -1429,7 +1506,7 @@
}
}
return -ENXIO;
-} /* lvm_do_le_remap() */
+} /* lvm_do_le_remap() */
/*
@@ -1443,7 +1520,7 @@
vg_t *vg_ptr;
lv_t **snap_lv_ptr;
- if ((vg_ptr = kmalloc(sizeof(vg_t),GFP_KERNEL)) == NULL) {
+ if ((vg_ptr = kmalloc(sizeof(vg_t), GFP_KERNEL)) == NULL) {
printk(KERN_CRIT
"%s -- VG_CREATE: kmalloc error VG at line %d\n",
lvm_name, __LINE__);
@@ -1451,20 +1528,22 @@
}
/* get the volume group structure */
if (copy_from_user(vg_ptr, arg, sizeof(vg_t)) != 0) {
- P_IOCTL("lvm_do_vg_create ERROR: copy VG ptr %p (%d bytes)\n",
- arg, sizeof(vg_t));
+ P_IOCTL
+ ("lvm_do_vg_create ERROR: copy VG ptr %p (%d bytes)\n",
+ arg, sizeof(vg_t));
kfree(vg_ptr);
return -EFAULT;
}
- /* VG_CREATE now uses minor number in VG structure */
- if (minor == -1) minor = vg_ptr->vg_number;
+ /* VG_CREATE now uses minor number in VG structure */
+ if (minor == -1)
+ minor = vg_ptr->vg_number;
/* Validate it */
- if (vg[VG_CHR(minor)] != NULL) {
+ if (vg[VG_CHR(minor)] != NULL) {
P_IOCTL("lvm_do_vg_create ERROR: VG %d in use\n", minor);
kfree(vg_ptr);
- return -EPERM;
+ return -EPERM;
}
/* we are not that active so far... */
@@ -1481,7 +1560,7 @@
if (vg_ptr->lv_max > ABS_MAX_LV) {
printk(KERN_WARNING
- "%s -- Can't activate VG: ABS_MAX_LV too small for %u\n",
+ "%s -- Can't activate VG: ABS_MAX_LV too small for %u\n",
lvm_name, vg_ptr->lv_max);
kfree(vg_ptr);
return -EPERM;
@@ -1499,7 +1578,7 @@
/* user space address */
if ((pvp = vg_ptr->pv[p]) != NULL) {
ret = lvm_do_pv_create(pvp, vg_ptr, p);
- if ( ret != 0) {
+ if (ret != 0) {
lvm_do_vg_remove(minor);
return ret;
}
@@ -1507,7 +1586,7 @@
}
size = vg_ptr->lv_max * sizeof(lv_t *);
- if ((snap_lv_ptr = vmalloc ( size)) == NULL) {
+ if ((snap_lv_ptr = vmalloc(size)) == NULL) {
printk(KERN_CRIT
"%s -- VG_CREATE: vmalloc error snapshot LVs at line %d\n",
lvm_name, __LINE__);
@@ -1523,12 +1602,13 @@
/* user space address */
if ((lvp = vg_ptr->lv[l]) != NULL) {
if (copy_from_user(&lv, lvp, sizeof(lv_t)) != 0) {
- P_IOCTL("ERROR: copying LV ptr %p (%d bytes)\n",
- lvp, sizeof(lv_t));
+ P_IOCTL
+ ("ERROR: copying LV ptr %p (%d bytes)\n",
+ lvp, sizeof(lv_t));
lvm_do_vg_remove(minor);
return -EFAULT;
}
- if ( lv.lv_access & LV_SNAPSHOT) {
+ if (lv.lv_access & LV_SNAPSHOT) {
snap_lv_ptr[ls] = lvp;
vg_ptr->lv[l] = NULL;
ls++;
@@ -1568,24 +1648,26 @@
vg_ptr->vg_status |= VG_ACTIVE;
return 0;
-} /* lvm_do_vg_create() */
+} /* lvm_do_vg_create() */
/*
* character device support function VGDA extend
*/
-static int lvm_do_vg_extend(vg_t *vg_ptr, void *arg)
+static int lvm_do_vg_extend(vg_t * vg_ptr, void *arg)
{
int ret = 0;
uint p;
pv_t *pv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (vg_ptr->pv_cur < vg_ptr->pv_max) {
for (p = 0; p < vg_ptr->pv_max; p++) {
- if ( ( pv_ptr = vg_ptr->pv[p]) == NULL) {
+ if ((pv_ptr = vg_ptr->pv[p]) == NULL) {
ret = lvm_do_pv_create(arg, vg_ptr, p);
- if ( ret != 0) return ret;
+ if (ret != 0)
+ return ret;
pv_ptr = vg_ptr->pv[p];
vg_ptr->pe_total += pv_ptr->pe_total;
return 0;
@@ -1593,26 +1675,28 @@
}
}
return -EPERM;
-} /* lvm_do_vg_extend() */
+} /* lvm_do_vg_extend() */
/*
* character device support function VGDA reduce
*/
-static int lvm_do_vg_reduce(vg_t *vg_ptr, void *arg) {
+static int lvm_do_vg_reduce(vg_t * vg_ptr, void *arg)
+{
uint p;
pv_t *pv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(pv_name, arg, sizeof(pv_name)) != 0)
return -EFAULT;
for (p = 0; p < vg_ptr->pv_max; p++) {
pv_ptr = vg_ptr->pv[p];
if (pv_ptr != NULL &&
- strcmp(pv_ptr->pv_name,
- pv_name) == 0) {
- if (pv_ptr->lv_cur > 0) return -EPERM;
+ strcmp(pv_ptr->pv_name, pv_name) == 0) {
+ if (pv_ptr->lv_cur > 0)
+ return -EPERM;
lvm_do_pv_remove(vg_ptr, p);
/* Make PV pointer array contiguous */
for (; p < vg_ptr->pv_max - 1; p++)
@@ -1622,52 +1706,55 @@
}
}
return -ENXIO;
-} /* lvm_do_vg_reduce */
+} /* lvm_do_vg_reduce */
/*
* character device support function VG rename
*/
-static int lvm_do_vg_rename(vg_t *vg_ptr, void *arg)
+static int lvm_do_vg_rename(vg_t * vg_ptr, void *arg)
{
int l = 0, p = 0, len = 0;
- char vg_name[NAME_LEN] = { 0,};
- char lv_name[NAME_LEN] = { 0,};
+ char vg_name[NAME_LEN] = { 0, };
+ char lv_name[NAME_LEN] = { 0, };
char *ptr = NULL;
lv_t *lv_ptr = NULL;
pv_t *pv_ptr = NULL;
- if (vg_ptr == NULL) return -ENXIO;
+ /* If the VG doesn't exist in the kernel then just exit */
+ if (!vg_ptr)
+ return 0;
if (copy_from_user(vg_name, arg, sizeof(vg_name)) != 0)
return -EFAULT;
lvm_fs_remove_vg(vg_ptr);
- strncpy ( vg_ptr->vg_name, vg_name, sizeof ( vg_name)-1);
- for ( l = 0; l < vg_ptr->lv_max; l++)
- {
- if ((lv_ptr = vg_ptr->lv[l]) == NULL) continue;
- strncpy(lv_ptr->vg_name, vg_name, sizeof ( vg_name));
+ strncpy(vg_ptr->vg_name, vg_name, sizeof(vg_name) - 1);
+ for (l = 0; l < vg_ptr->lv_max; l++) {
+ if ((lv_ptr = vg_ptr->lv[l]) == NULL)
+ continue;
+ strncpy(lv_ptr->vg_name, vg_name, sizeof(vg_name));
ptr = strrchr(lv_ptr->lv_name, '/');
- if (ptr == NULL) ptr = lv_ptr->lv_name;
- strncpy(lv_name, ptr, sizeof ( lv_name));
+ if (ptr == NULL)
+ ptr = lv_ptr->lv_name;
+ strncpy(lv_name, ptr, sizeof(lv_name));
len = sizeof(LVM_DIR_PREFIX);
strcpy(lv_ptr->lv_name, LVM_DIR_PREFIX);
strncat(lv_ptr->lv_name, vg_name, NAME_LEN - len);
- len += strlen ( vg_name);
+ len += strlen(vg_name);
strncat(lv_ptr->lv_name, lv_name, NAME_LEN - len);
}
- for ( p = 0; p < vg_ptr->pv_max; p++)
- {
- if ( (pv_ptr = vg_ptr->pv[p]) == NULL) continue;
+ for (p = 0; p < vg_ptr->pv_max; p++) {
+ if ((pv_ptr = vg_ptr->pv[p]) == NULL)
+ continue;
strncpy(pv_ptr->vg_name, vg_name, NAME_LEN);
}
lvm_fs_create_vg(vg_ptr);
return 0;
-} /* lvm_do_vg_rename */
+} /* lvm_do_vg_rename */
/*
@@ -1679,7 +1766,8 @@
vg_t *vg_ptr = vg[VG_CHR(minor)];
pv_t *pv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
#ifdef LVM_TOTAL_RESET
if (vg_ptr->lv_open > 0 && lvm_reset_spindown == 0)
@@ -1730,17 +1818,18 @@
MOD_DEC_USE_COUNT;
return 0;
-} /* lvm_do_vg_remove() */
+} /* lvm_do_vg_remove() */
/*
* character device support function physical volume create
*/
-static int lvm_do_pv_create(pv_t *pvp, vg_t *vg_ptr, ulong p) {
+static int lvm_do_pv_create(pv_t * pvp, vg_t * vg_ptr, ulong p)
+{
pv_t *pv;
int err;
- pv = kmalloc(sizeof(pv_t),GFP_KERNEL);
+ pv = kmalloc(sizeof(pv_t), GFP_KERNEL);
if (pv == NULL) {
printk(KERN_CRIT
"%s -- PV_CREATE: kmalloc error PV at line %d\n",
@@ -1751,8 +1840,9 @@
memset(pv, 0, sizeof(*pv));
if (copy_from_user(pv, pvp, sizeof(pv_t)) != 0) {
- P_IOCTL("lvm_do_pv_create ERROR: copy PV ptr %p (%d bytes)\n",
- pvp, sizeof(pv_t));
+ P_IOCTL
+ ("lvm_do_pv_create ERROR: copy PV ptr %p (%d bytes)\n",
+ pvp, sizeof(pv_t));
kfree(pv);
return -EFAULT;
}
@@ -1773,13 +1863,14 @@
vg_ptr->pv[p] = pv;
return 0;
-} /* lvm_do_pv_create() */
+} /* lvm_do_pv_create() */
/*
* character device support function physical volume remove
*/
-static int lvm_do_pv_remove(vg_t *vg_ptr, ulong p) {
+static int lvm_do_pv_remove(vg_t * vg_ptr, ulong p)
+{
pv_t *pv = vg_ptr->pv[p];
lvm_fs_remove_pv(vg_ptr, pv);
@@ -1797,37 +1888,68 @@
}
-static void __update_hardsectsize(lv_t *lv) {
- int le, e;
- int max_hardsectsize = 0, hardsectsize;
-
- for (le = 0; le < lv->lv_allocated_le; le++) {
- hardsectsize = get_hardsect_size(lv->lv_current_pe[le].dev);
- if (hardsectsize == 0)
- hardsectsize = 512;
- if (hardsectsize > max_hardsectsize)
- max_hardsectsize = hardsectsize;
- }
-
- /* only perform this operation on active snapshots */
- if ((lv->lv_access & LV_SNAPSHOT) &&
- (lv->lv_status & LV_ACTIVE)) {
- for (e = 0; e < lv->lv_remap_end; e++) {
- hardsectsize = get_hardsect_size( lv->lv_block_exception[e].rdev_new);
- if (hardsectsize == 0)
- hardsectsize = 512;
- if (hardsectsize > max_hardsectsize)
+static void __update_hardsectsize(lv_t * lv)
+{
+ int max_hardsectsize = 0, hardsectsize = 0;
+ int p;
+
+ /* Check PVs first to see if they all have same sector size */
+ for (p = 0; p < lv->vg->pv_cur; p++) {
+ pv_t *pv = lv->vg->pv[p];
+ if (pv && (hardsectsize = lvm_sectsize(pv->pv_dev))) {
+ if (max_hardsectsize == 0)
+ max_hardsectsize = hardsectsize;
+ else if (hardsectsize != max_hardsectsize) {
+ P_DEV
+ ("%s PV[%d] (%s) sector size %d, not %d\n",
+ lv->lv_name, p, kdevname(pv->pv_dev),
+ hardsectsize, max_hardsectsize);
+ break;
+ }
+ }
+ }
+
+ /* PVs have different block size, need to check each LE sector size */
+ if (hardsectsize != max_hardsectsize) {
+ int le;
+ for (le = 0; le < lv->lv_allocated_le; le++) {
+ hardsectsize =
+ lvm_sectsize(lv->lv_current_pe[le].dev);
+ if (hardsectsize > max_hardsectsize) {
+ P_DEV
+ ("%s LE[%d] (%s) blocksize %d not %d\n",
+ lv->lv_name, le,
+ kdevname(lv->lv_current_pe[le].dev),
+ hardsectsize, max_hardsectsize);
max_hardsectsize = hardsectsize;
+ }
+ }
+
+ /* only perform this operation on active snapshots */
+ if ((lv->lv_access & LV_SNAPSHOT) &&
+ (lv->lv_status & LV_ACTIVE)) {
+ int e;
+ for (e = 0; e < lv->lv_remap_end; e++) {
+ hardsectsize =
+ lvm_sectsize(lv->lv_block_exception[e].
+ rdev_new);
+ if (hardsectsize > max_hardsectsize)
+ max_hardsectsize = hardsectsize;
+ }
}
}
+ if (max_hardsectsize == 0)
+ max_hardsectsize = SECTOR_SIZE;
+ P_DEV("hardblocksize for LV %s is %d\n",
+ kdevname(lv->lv_dev), max_hardsectsize);
lvm_hardsectsizes[MINOR(lv->lv_dev)] = max_hardsectsize;
}
/*
* character device support function logical volume create
*/
-static int lvm_do_lv_create(int minor, char *lv_name, lv_t *lv)
+static int lvm_do_lv_create(int minor, char *lv_name, lv_t * lv)
{
int e, ret, l, le, l_new, p, size, activate = 1;
ulong lv_status_save;
@@ -1855,14 +1977,18 @@
else {
for (l = 0; l < vg_ptr->lv_max; l++) {
if (vg_ptr->lv[l] == NULL)
- if (l_new == -1) l_new = l;
+ if (l_new == -1)
+ l_new = l;
}
}
- if (l_new == -1) return -EPERM;
- else l = l_new;
+ if (l_new == -1)
+ return -EPERM;
+ else
+ l = l_new;
- if ((lv_ptr = kmalloc(sizeof(lv_t),GFP_KERNEL)) == NULL) {;
- printk(KERN_CRIT "%s -- LV_CREATE: kmalloc error LV at line %d\n",
+ if ((lv_ptr = kmalloc(sizeof(lv_t), GFP_KERNEL)) == NULL) {;
+ printk(KERN_CRIT
+ "%s -- LV_CREATE: kmalloc error LV at line %d\n",
lvm_name, __LINE__);
return -ENOMEM;
}
@@ -1876,7 +2002,7 @@
lv_ptr->lv_snapshot_next = NULL;
lv_ptr->lv_block_exception = NULL;
lv_ptr->lv_iobuf = NULL;
- lv_ptr->lv_COW_table_iobuf = NULL;
+ lv_ptr->lv_COW_table_iobuf = NULL;
lv_ptr->lv_snapshot_hash_table = NULL;
lv_ptr->lv_snapshot_hash_table_size = 0;
lv_ptr->lv_snapshot_hash_mask = 0;
@@ -1894,8 +2020,7 @@
if ((lv_ptr->lv_current_pe = vmalloc(size)) == NULL) {
printk(KERN_CRIT
"%s -- LV_CREATE: vmalloc error LV_CURRENT_PE of %d Byte "
- "at line %d\n",
- lvm_name, size, __LINE__);
+ "at line %d\n", lvm_name, size, __LINE__);
P_KFREE("%s -- kfree %d\n", lvm_name, __LINE__);
kfree(lv_ptr);
vg_ptr->lv[l] = NULL;
@@ -1924,9 +2049,11 @@
lv_ptr->lv_snapshot_org =
vg_ptr->lv[LV_BLK(lv_ptr->lv_snapshot_minor)];
if (lv_ptr->lv_snapshot_org != NULL) {
- size = lv_ptr->lv_remap_end * sizeof(lv_block_exception_t);
+ size =
+ lv_ptr->lv_remap_end *
+ sizeof(lv_block_exception_t);
- if(!size) {
+ if (!size) {
printk(KERN_WARNING
"%s -- zero length exception table requested\n",
lvm_name);
@@ -1934,34 +2061,37 @@
return -EINVAL;
}
- if ((lv_ptr->lv_block_exception = vmalloc(size)) == NULL) {
+ if (
+ (lv_ptr->lv_block_exception =
+ vmalloc(size)) == NULL) {
printk(KERN_CRIT
"%s -- lvm_do_lv_create: vmalloc error LV_BLOCK_EXCEPTION "
"of %d byte at line %d\n",
lvm_name, size, __LINE__);
- P_KFREE("%s -- kfree %d\n", lvm_name,
- __LINE__);
+ P_KFREE("%s -- kfree %d\n",
+ lvm_name, __LINE__);
kfree(lv_ptr);
vg_ptr->lv[l] = NULL;
return -ENOMEM;
}
- if (copy_from_user(lv_ptr->lv_block_exception, lvbe, size)) {
+ if (copy_from_user
+ (lv_ptr->lv_block_exception, lvbe,
+ size)) {
vfree(lv_ptr->lv_block_exception);
kfree(lv_ptr);
vg_ptr->lv[l] = NULL;
return -EFAULT;
}
- if(lv_ptr->lv_block_exception[0].rsector_org ==
- LVM_SNAPSHOT_DROPPED_SECTOR)
- {
+ if (lv_ptr->lv_block_exception[0].
+ rsector_org ==
+ LVM_SNAPSHOT_DROPPED_SECTOR) {
printk(KERN_WARNING
- "%s -- lvm_do_lv_create: snapshot has been dropped and will not be activated\n",
+ "%s -- lvm_do_lv_create: snapshot has been dropped and will not be activated\n",
lvm_name);
activate = 0;
}
-
/* point to the original logical volume */
lv_ptr = lv_ptr->lv_snapshot_org;
@@ -1971,36 +2101,54 @@
which can be the original logical volume */
lv_ptr = vg_ptr->lv[l];
/* now lv_ptr points to our new last snapshot logical volume */
- lv_ptr->lv_current_pe = lv_ptr->lv_snapshot_org->lv_current_pe;
- lv_ptr->lv_allocated_snapshot_le = lv_ptr->lv_allocated_le;
- lv_ptr->lv_allocated_le = lv_ptr->lv_snapshot_org->lv_allocated_le;
- lv_ptr->lv_current_le = lv_ptr->lv_snapshot_org->lv_current_le;
- lv_ptr->lv_size = lv_ptr->lv_snapshot_org->lv_size;
- lv_ptr->lv_stripes = lv_ptr->lv_snapshot_org->lv_stripes;
- lv_ptr->lv_stripesize = lv_ptr->lv_snapshot_org->lv_stripesize;
+ lv_ptr->lv_current_pe =
+ lv_ptr->lv_snapshot_org->lv_current_pe;
+ lv_ptr->lv_allocated_snapshot_le =
+ lv_ptr->lv_allocated_le;
+ lv_ptr->lv_allocated_le =
+ lv_ptr->lv_snapshot_org->
+ lv_allocated_le;
+ lv_ptr->lv_current_le =
+ lv_ptr->lv_snapshot_org->lv_current_le;
+ lv_ptr->lv_size =
+ lv_ptr->lv_snapshot_org->lv_size;
+ lv_ptr->lv_stripes =
+ lv_ptr->lv_snapshot_org->lv_stripes;
+ lv_ptr->lv_stripesize =
+ lv_ptr->lv_snapshot_org->lv_stripesize;
/* Update the VG PE(s) used by snapshot reserve space. */
- vg_ptr->pe_allocated += lv_ptr->lv_allocated_snapshot_le;
+ vg_ptr->pe_allocated +=
+ lv_ptr->lv_allocated_snapshot_le;
- if ((ret = lvm_snapshot_alloc(lv_ptr)) != 0)
- {
+ if ((ret = lvm_snapshot_alloc(lv_ptr)) !=
+ 0) {
vfree(lv_ptr->lv_block_exception);
kfree(lv_ptr);
vg_ptr->lv[l] = NULL;
return ret;
}
- for ( e = 0; e < lv_ptr->lv_remap_ptr; e++)
- lvm_hash_link (lv_ptr->lv_block_exception + e,
- lv_ptr->lv_block_exception[e].rdev_org,
- lv_ptr->lv_block_exception[e].rsector_org, lv_ptr);
+ for (e = 0; e < lv_ptr->lv_remap_ptr; e++)
+ lvm_hash_link(lv_ptr->
+ lv_block_exception +
+ e,
+ lv_ptr->
+ lv_block_exception
+ [e].rdev_org,
+ lv_ptr->
+ lv_block_exception
+ [e].rsector_org,
+ lv_ptr);
/* need to fill the COW exception table data
into the page for disk i/o */
- if(lvm_snapshot_fill_COW_page(vg_ptr, lv_ptr)) {
- kfree(lv_ptr);
- vg_ptr->lv[l] = NULL;
- return -EINVAL;
- }
- init_waitqueue_head(&lv_ptr->lv_snapshot_wait);
+ if (lvm_snapshot_fill_COW_page
+ (vg_ptr, lv_ptr)) {
+ kfree(lv_ptr);
+ vg_ptr->lv[l] = NULL;
+ return -EINVAL;
+ }
+ init_waitqueue_head(&lv_ptr->
+ lv_snapshot_wait);
} else {
kfree(lv_ptr);
vg_ptr->lv[l] = NULL;
@@ -2011,7 +2159,7 @@
vg_ptr->lv[l] = NULL;
return -EINVAL;
}
- } /* if ( vg[VG_CHR(minor)]->lv[l]->lv_access & LV_SNAPSHOT) */
+ } /* if ( vg[VG_CHR(minor)]->lv[l]->lv_access & LV_SNAPSHOT) */
lv_ptr = vg_ptr->lv[l];
lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].start_sect = 0;
@@ -2022,6 +2170,7 @@
LVM_CORRECT_READ_AHEAD(lv_ptr->lv_read_ahead);
vg_ptr->lv_cur++;
lv_ptr->lv_status = lv_status_save;
+ lv_ptr->vg = vg_ptr;
__update_hardsectsize(lv_ptr);
@@ -2038,22 +2187,24 @@
down_write(&org->lv_lock);
org->lv_access |= LV_SNAPSHOT_ORG;
- lv_ptr->lv_access &= ~LV_SNAPSHOT_ORG; /* this can only hide an userspace bug */
+ lv_ptr->lv_access &= ~LV_SNAPSHOT_ORG; /* this can only hide an userspace bug */
+
/* Link in the list of snapshot volumes */
- for (last = org; last->lv_snapshot_next; last = last->lv_snapshot_next);
+ for (last = org; last->lv_snapshot_next;
+ last = last->lv_snapshot_next);
lv_ptr->lv_snapshot_prev = last;
last->lv_snapshot_next = lv_ptr;
up_write(&org->lv_lock);
}
/* activate the logical volume */
- if(activate)
+ if (activate)
lv_ptr->lv_status |= LV_ACTIVE;
else
lv_ptr->lv_status &= ~LV_ACTIVE;
- if ( lv_ptr->lv_access & LV_WRITE)
+ if (lv_ptr->lv_access & LV_WRITE)
set_device_ro(lv_ptr->lv_dev, 0);
else
set_device_ro(lv_ptr->lv_dev, 1);
@@ -2064,13 +2215,10 @@
unlockfs(lv_ptr->lv_snapshot_org->lv_dev);
#endif
- lv_ptr->vg = vg_ptr;
-
lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].de =
- lvm_fs_create_lv(vg_ptr, lv_ptr);
-
+ lvm_fs_create_lv(vg_ptr, lv_ptr);
return 0;
-} /* lvm_do_lv_create() */
+} /* lvm_do_lv_create() */
/*
@@ -2090,7 +2238,8 @@
}
}
}
- if (l == vg_ptr->lv_max) return -ENXIO;
+ if (l == vg_ptr->lv_max)
+ return -ENXIO;
lv_ptr = vg_ptr->lv[l];
#ifdef LVM_TOTAL_RESET
@@ -2113,11 +2262,12 @@
* Atomically make the the snapshot invisible
* to the original lv before playing with it.
*/
- lv_t * org = lv_ptr->lv_snapshot_org;
+ lv_t *org = lv_ptr->lv_snapshot_org;
down_write(&org->lv_lock);
/* remove this snapshot logical volume from the chain */
- lv_ptr->lv_snapshot_prev->lv_snapshot_next = lv_ptr->lv_snapshot_next;
+ lv_ptr->lv_snapshot_prev->lv_snapshot_next =
+ lv_ptr->lv_snapshot_next;
if (lv_ptr->lv_snapshot_next != NULL) {
lv_ptr->lv_snapshot_next->lv_snapshot_prev =
lv_ptr->lv_snapshot_prev;
@@ -2156,7 +2306,7 @@
vg_lv_map[MINOR(lv_ptr->lv_dev)].lv_number = -1;
/* correct the PE count in PVs if this is not a snapshot
- logical volume */
+ logical volume */
if (!(lv_ptr->lv_access & LV_SNAPSHOT)) {
/* only if this is no snapshot logical volume because
we share the lv_current_pe[] structs with the
@@ -2177,228 +2327,240 @@
vg_ptr->lv[l] = NULL;
vg_ptr->lv_cur--;
return 0;
-} /* lvm_do_lv_remove() */
+} /* lvm_do_lv_remove() */
/*
* logical volume extend / reduce
*/
-static int __extend_reduce_snapshot(vg_t *vg_ptr, lv_t *old_lv, lv_t *new_lv) {
- ulong size;
- lv_block_exception_t *lvbe;
-
- if (!new_lv->lv_block_exception)
- return -ENXIO;
-
- size = new_lv->lv_remap_end * sizeof(lv_block_exception_t);
- if ((lvbe = vmalloc(size)) == NULL) {
- printk(KERN_CRIT
- "%s -- lvm_do_lv_extend_reduce: vmalloc "
- "error LV_BLOCK_EXCEPTION of %lu Byte at line %d\n",
- lvm_name, size, __LINE__);
- return -ENOMEM;
- }
-
- if ((new_lv->lv_remap_end > old_lv->lv_remap_end) &&
- (copy_from_user(lvbe, new_lv->lv_block_exception, size))) {
- vfree(lvbe);
- return -EFAULT;
- }
- new_lv->lv_block_exception = lvbe;
-
- if (lvm_snapshot_alloc_hash_table(new_lv)) {
- vfree(new_lv->lv_block_exception);
- return -ENOMEM;
- }
+static int __extend_reduce_snapshot(vg_t * vg_ptr, lv_t * old_lv,
+ lv_t * new_lv)
+{
+ ulong size;
+ lv_block_exception_t *lvbe;
- return 0;
+ if (!new_lv->lv_block_exception)
+ return -ENXIO;
+
+ size = new_lv->lv_remap_end * sizeof(lv_block_exception_t);
+ if ((lvbe = vmalloc(size)) == NULL) {
+ printk(KERN_CRIT
+ "%s -- lvm_do_lv_extend_reduce: vmalloc "
+ "error LV_BLOCK_EXCEPTION of %lu Byte at line %d\n",
+ lvm_name, size, __LINE__);
+ return -ENOMEM;
+ }
+
+ if ((new_lv->lv_remap_end > old_lv->lv_remap_end) &&
+ (copy_from_user(lvbe, new_lv->lv_block_exception, size))) {
+ vfree(lvbe);
+ return -EFAULT;
+ }
+ new_lv->lv_block_exception = lvbe;
+
+ if (lvm_snapshot_alloc_hash_table(new_lv)) {
+ vfree(new_lv->lv_block_exception);
+ return -ENOMEM;
+ }
+
+ return 0;
}
-static int __extend_reduce(vg_t *vg_ptr, lv_t *old_lv, lv_t *new_lv) {
- ulong size, l, p, end;
- pe_t *pe;
-
- /* allocate space for new pe structures */
- size = new_lv->lv_current_le * sizeof(pe_t);
- if ((pe = vmalloc(size)) == NULL) {
- printk(KERN_CRIT
- "%s -- lvm_do_lv_extend_reduce: "
- "vmalloc error LV_CURRENT_PE of %lu Byte at line %d\n",
- lvm_name, size, __LINE__);
- return -ENOMEM;
- }
-
- /* get the PE structures from user space */
- if (copy_from_user(pe, new_lv->lv_current_pe, size)) {
- if(old_lv->lv_access & LV_SNAPSHOT)
- vfree(new_lv->lv_snapshot_hash_table);
- vfree(pe);
- return -EFAULT;
- }
-
- new_lv->lv_current_pe = pe;
-
- /* reduce allocation counters on PV(s) */
- for (l = 0; l < old_lv->lv_allocated_le; l++) {
- vg_ptr->pe_allocated--;
- for (p = 0; p < vg_ptr->pv_cur; p++) {
- if (vg_ptr->pv[p]->pv_dev ==
- old_lv->lv_current_pe[l].dev) {
- vg_ptr->pv[p]->pe_allocated--;
- break;
- }
- }
- }
-
- /* extend the PE count in PVs */
- for (l = 0; l < new_lv->lv_allocated_le; l++) {
- vg_ptr->pe_allocated++;
- for (p = 0; p < vg_ptr->pv_cur; p++) {
- if (vg_ptr->pv[p]->pv_dev ==
- new_lv->lv_current_pe[l].dev) {
- vg_ptr->pv[p]->pe_allocated++;
- break;
- }
- }
- }
-
- /* save availiable i/o statistic data */
- if (old_lv->lv_stripes < 2) { /* linear logical volume */
- end = min(old_lv->lv_current_le, new_lv->lv_current_le);
- for (l = 0; l < end; l++) {
- new_lv->lv_current_pe[l].reads +=
- old_lv->lv_current_pe[l].reads;
-
- new_lv->lv_current_pe[l].writes +=
- old_lv->lv_current_pe[l].writes;
- }
-
- } else { /* striped logical volume */
- uint i, j, source, dest, end, old_stripe_size, new_stripe_size;
-
- old_stripe_size = old_lv->lv_allocated_le / old_lv->lv_stripes;
- new_stripe_size = new_lv->lv_allocated_le / new_lv->lv_stripes;
- end = min(old_stripe_size, new_stripe_size);
-
- for (i = source = dest = 0;
- i < new_lv->lv_stripes; i++) {
- for (j = 0; j < end; j++) {
- new_lv->lv_current_pe[dest + j].reads +=
- old_lv->lv_current_pe[source + j].reads;
- new_lv->lv_current_pe[dest + j].writes +=
- old_lv->lv_current_pe[source + j].writes;
- }
- source += old_stripe_size;
- dest += new_stripe_size;
- }
- }
+static int __extend_reduce(vg_t * vg_ptr, lv_t * old_lv, lv_t * new_lv)
+{
+ ulong size, l, p, end;
+ pe_t *pe;
+
+ /* allocate space for new pe structures */
+ size = new_lv->lv_current_le * sizeof(pe_t);
+ if ((pe = vmalloc(size)) == NULL) {
+ printk(KERN_CRIT
+ "%s -- lvm_do_lv_extend_reduce: "
+ "vmalloc error LV_CURRENT_PE of %lu Byte at line %d\n",
+ lvm_name, size, __LINE__);
+ return -ENOMEM;
+ }
+
+ /* get the PE structures from user space */
+ if (copy_from_user(pe, new_lv->lv_current_pe, size)) {
+ if (old_lv->lv_access & LV_SNAPSHOT)
+ vfree(new_lv->lv_snapshot_hash_table);
+ vfree(pe);
+ return -EFAULT;
+ }
+
+ new_lv->lv_current_pe = pe;
+
+ /* reduce allocation counters on PV(s) */
+ for (l = 0; l < old_lv->lv_allocated_le; l++) {
+ vg_ptr->pe_allocated--;
+ for (p = 0; p < vg_ptr->pv_cur; p++) {
+ if (vg_ptr->pv[p]->pv_dev ==
+ old_lv->lv_current_pe[l].dev) {
+ vg_ptr->pv[p]->pe_allocated--;
+ break;
+ }
+ }
+ }
+
+ /* extend the PE count in PVs */
+ for (l = 0; l < new_lv->lv_allocated_le; l++) {
+ vg_ptr->pe_allocated++;
+ for (p = 0; p < vg_ptr->pv_cur; p++) {
+ if (vg_ptr->pv[p]->pv_dev ==
+ new_lv->lv_current_pe[l].dev) {
+ vg_ptr->pv[p]->pe_allocated++;
+ break;
+ }
+ }
+ }
+
+ /* save availiable i/o statistic data */
+ if (old_lv->lv_stripes < 2) { /* linear logical volume */
+ end = min(old_lv->lv_current_le, new_lv->lv_current_le);
+ for (l = 0; l < end; l++) {
+ new_lv->lv_current_pe[l].reads +=
+ old_lv->lv_current_pe[l].reads;
+
+ new_lv->lv_current_pe[l].writes +=
+ old_lv->lv_current_pe[l].writes;
+ }
+
+ } else { /* striped logical volume */
+ uint i, j, source, dest, end, old_stripe_size,
+ new_stripe_size;
+
+ old_stripe_size =
+ old_lv->lv_allocated_le / old_lv->lv_stripes;
+ new_stripe_size =
+ new_lv->lv_allocated_le / new_lv->lv_stripes;
+ end = min(old_stripe_size, new_stripe_size);
+
+ for (i = source = dest = 0; i < new_lv->lv_stripes; i++) {
+ for (j = 0; j < end; j++) {
+ new_lv->lv_current_pe[dest + j].reads +=
+ old_lv->lv_current_pe[source +
+ j].reads;
+ new_lv->lv_current_pe[dest + j].writes +=
+ old_lv->lv_current_pe[source +
+ j].writes;
+ }
+ source += old_stripe_size;
+ dest += new_stripe_size;
+ }
+ }
- return 0;
+ return 0;
}
-static int lvm_do_lv_extend_reduce(int minor, char *lv_name, lv_t *new_lv)
+static int lvm_do_lv_extend_reduce(int minor, char *lv_name, lv_t * new_lv)
{
- int r;
- ulong l, e, size;
- vg_t *vg_ptr = vg[VG_CHR(minor)];
- lv_t *old_lv;
- pe_t *pe;
+ int r;
+ ulong l, e, size;
+ vg_t *vg_ptr = vg[VG_CHR(minor)];
+ lv_t *old_lv;
+ pe_t *pe;
- if ((pe = new_lv->lv_current_pe) == NULL)
- return -EINVAL;
+ if ((pe = new_lv->lv_current_pe) == NULL)
+ return -EINVAL;
- for (l = 0; l < vg_ptr->lv_max; l++)
- if (vg_ptr->lv[l] && !strcmp(vg_ptr->lv[l]->lv_name, lv_name))
- break;
+ for (l = 0; l < vg_ptr->lv_max; l++)
+ if (vg_ptr->lv[l]
+ && !strcmp(vg_ptr->lv[l]->lv_name, lv_name)) break;
- if (l == vg_ptr->lv_max)
- return -ENXIO;
+ if (l == vg_ptr->lv_max)
+ return -ENXIO;
- old_lv = vg_ptr->lv[l];
+ old_lv = vg_ptr->lv[l];
if (old_lv->lv_access & LV_SNAPSHOT) {
/* only perform this operation on active snapshots */
if (old_lv->lv_status & LV_ACTIVE)
- r = __extend_reduce_snapshot(vg_ptr, old_lv, new_lv);
- else
+ r =
+ __extend_reduce_snapshot(vg_ptr, old_lv,
+ new_lv);
+ else
r = -EPERM;
} else
- r = __extend_reduce(vg_ptr, old_lv, new_lv);
+ r = __extend_reduce(vg_ptr, old_lv, new_lv);
- if(r)
- return r;
+ if (r)
+ return r;
- /* copy relevent fields */
+ /* copy relevent fields */
down_write(&old_lv->lv_lock);
- if(new_lv->lv_access & LV_SNAPSHOT) {
- size = (new_lv->lv_remap_end > old_lv->lv_remap_end) ?
- old_lv->lv_remap_ptr : new_lv->lv_remap_end;
- size *= sizeof(lv_block_exception_t);
- memcpy(new_lv->lv_block_exception,
- old_lv->lv_block_exception, size);
-
- old_lv->lv_remap_end = new_lv->lv_remap_end;
- old_lv->lv_block_exception = new_lv->lv_block_exception;
- old_lv->lv_snapshot_hash_table =
- new_lv->lv_snapshot_hash_table;
- old_lv->lv_snapshot_hash_table_size =
- new_lv->lv_snapshot_hash_table_size;
- old_lv->lv_snapshot_hash_mask =
- new_lv->lv_snapshot_hash_mask;
-
- for (e = 0; e < new_lv->lv_remap_ptr; e++)
- lvm_hash_link(new_lv->lv_block_exception + e,
- new_lv->lv_block_exception[e].rdev_org,
- new_lv->lv_block_exception[e].rsector_org,
- new_lv);
-
- } else {
-
- vfree(old_lv->lv_current_pe);
- vfree(old_lv->lv_snapshot_hash_table);
-
- old_lv->lv_size = new_lv->lv_size;
- old_lv->lv_allocated_le = new_lv->lv_allocated_le;
- old_lv->lv_current_le = new_lv->lv_current_le;
- old_lv->lv_current_pe = new_lv->lv_current_pe;
- lvm_gendisk.part[MINOR(old_lv->lv_dev)].nr_sects =
- old_lv->lv_size;
- lvm_size[MINOR(old_lv->lv_dev)] = old_lv->lv_size >> 1;
-
- if (old_lv->lv_access & LV_SNAPSHOT_ORG) {
- lv_t *snap;
- for(snap = old_lv->lv_snapshot_next; snap;
- snap = snap->lv_snapshot_next) {
+ if (new_lv->lv_access & LV_SNAPSHOT) {
+ size = (new_lv->lv_remap_end > old_lv->lv_remap_end) ?
+ old_lv->lv_remap_ptr : new_lv->lv_remap_end;
+ size *= sizeof(lv_block_exception_t);
+ memcpy(new_lv->lv_block_exception,
+ old_lv->lv_block_exception, size);
+
+ old_lv->lv_remap_end = new_lv->lv_remap_end;
+ old_lv->lv_block_exception = new_lv->lv_block_exception;
+ old_lv->lv_snapshot_hash_table =
+ new_lv->lv_snapshot_hash_table;
+ old_lv->lv_snapshot_hash_table_size =
+ new_lv->lv_snapshot_hash_table_size;
+ old_lv->lv_snapshot_hash_mask =
+ new_lv->lv_snapshot_hash_mask;
+
+ for (e = 0; e < new_lv->lv_remap_ptr; e++)
+ lvm_hash_link(new_lv->lv_block_exception + e,
+ new_lv->lv_block_exception[e].
+ rdev_org,
+ new_lv->lv_block_exception[e].
+ rsector_org, new_lv);
+
+ } else {
+
+ vfree(old_lv->lv_current_pe);
+ vfree(old_lv->lv_snapshot_hash_table);
+
+ old_lv->lv_size = new_lv->lv_size;
+ old_lv->lv_allocated_le = new_lv->lv_allocated_le;
+ old_lv->lv_current_le = new_lv->lv_current_le;
+ old_lv->lv_current_pe = new_lv->lv_current_pe;
+ lvm_gendisk.part[MINOR(old_lv->lv_dev)].nr_sects =
+ old_lv->lv_size;
+ lvm_size[MINOR(old_lv->lv_dev)] = old_lv->lv_size >> 1;
+
+ if (old_lv->lv_access & LV_SNAPSHOT_ORG) {
+ lv_t *snap;
+ for (snap = old_lv->lv_snapshot_next; snap;
+ snap = snap->lv_snapshot_next) {
down_write(&snap->lv_lock);
- snap->lv_current_pe = old_lv->lv_current_pe;
- snap->lv_allocated_le =
- old_lv->lv_allocated_le;
- snap->lv_current_le = old_lv->lv_current_le;
- snap->lv_size = old_lv->lv_size;
-
- lvm_gendisk.part[MINOR(snap->lv_dev)].nr_sects
- = old_lv->lv_size;
- lvm_size[MINOR(snap->lv_dev)] =
- old_lv->lv_size >> 1;
- __update_hardsectsize(snap);
+ snap->lv_current_pe =
+ old_lv->lv_current_pe;
+ snap->lv_allocated_le =
+ old_lv->lv_allocated_le;
+ snap->lv_current_le =
+ old_lv->lv_current_le;
+ snap->lv_size = old_lv->lv_size;
+
+ lvm_gendisk.part[MINOR(snap->lv_dev)].
+ nr_sects = old_lv->lv_size;
+ lvm_size[MINOR(snap->lv_dev)] =
+ old_lv->lv_size >> 1;
+ __update_hardsectsize(snap);
up_write(&snap->lv_lock);
- }
- }
- }
+ }
+ }
+ }
- __update_hardsectsize(old_lv);
+ __update_hardsectsize(old_lv);
up_write(&old_lv->lv_lock);
- return 0;
-} /* lvm_do_lv_extend_reduce() */
+ return 0;
+} /* lvm_do_lv_extend_reduce() */
/*
* character device support function logical volume status by name
*/
-static int lvm_do_lv_status_byname(vg_t *vg_ptr, void *arg)
+static int lvm_do_lv_status_byname(vg_t * vg_ptr, void *arg)
{
uint l;
lv_status_byname_req_t lv_status_byname_req;
@@ -2406,184 +2568,206 @@
void *saved_ptr2;
lv_t *lv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&lv_status_byname_req, arg,
sizeof(lv_status_byname_req_t)) != 0)
return -EFAULT;
- if (lv_status_byname_req.lv == NULL) return -EINVAL;
+ if (lv_status_byname_req.lv == NULL)
+ return -EINVAL;
for (l = 0; l < vg_ptr->lv_max; l++) {
if ((lv_ptr = vg_ptr->lv[l]) != NULL &&
strcmp(lv_ptr->lv_name,
lv_status_byname_req.lv_name) == 0) {
- /* Save usermode pointers */
- if (copy_from_user(&saved_ptr1, &lv_status_byname_req.lv->lv_current_pe, sizeof(void*)) != 0)
+ /* Save usermode pointers */
+ if (copy_from_user
+ (&saved_ptr1,
+ &lv_status_byname_req.lv->lv_current_pe,
+ sizeof(void *)) != 0)
return -EFAULT;
- if (copy_from_user(&saved_ptr2, &lv_status_byname_req.lv->lv_block_exception, sizeof(void*)) != 0)
- return -EFAULT;
- if (copy_to_user(lv_status_byname_req.lv,
- lv_ptr,
- sizeof(lv_t)) != 0)
+ if (copy_from_user
+ (&saved_ptr2,
+ &lv_status_byname_req.lv->lv_block_exception,
+ sizeof(void *)) != 0)
+ return -EFAULT;
+ if (copy_to_user(lv_status_byname_req.lv,
+ lv_ptr, sizeof(lv_t)) != 0)
return -EFAULT;
-
if (saved_ptr1 != NULL) {
if (copy_to_user(saved_ptr1,
lv_ptr->lv_current_pe,
lv_ptr->lv_allocated_le *
- sizeof(pe_t)) != 0)
+ sizeof(pe_t)) != 0)
return -EFAULT;
}
/* Restore usermode pointers */
- if (copy_to_user(&lv_status_byname_req.lv->lv_current_pe, &saved_ptr1, sizeof(void*)) != 0)
- return -EFAULT;
+ if (copy_to_user
+ (&lv_status_byname_req.lv->lv_current_pe,
+ &saved_ptr1, sizeof(void *)) != 0)
+ return -EFAULT;
return 0;
}
}
return -ENXIO;
-} /* lvm_do_lv_status_byname() */
+} /* lvm_do_lv_status_byname() */
/*
* character device support function logical volume status by index
*/
-static int lvm_do_lv_status_byindex(vg_t *vg_ptr,void *arg)
+static int lvm_do_lv_status_byindex(vg_t * vg_ptr, void *arg)
{
lv_status_byindex_req_t lv_status_byindex_req;
void *saved_ptr1;
void *saved_ptr2;
lv_t *lv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&lv_status_byindex_req, arg,
sizeof(lv_status_byindex_req)) != 0)
return -EFAULT;
if (lv_status_byindex_req.lv == NULL)
return -EINVAL;
- if (lv_status_byindex_req.lv_index <0 ||
- lv_status_byindex_req.lv_index >= MAX_LV)
+ if (lv_status_byindex_req.lv_index < 0 ||
+ lv_status_byindex_req.lv_index >= MAX_LV)
return -EINVAL;
- if ( ( lv_ptr = vg_ptr->lv[lv_status_byindex_req.lv_index]) == NULL)
+ if ((lv_ptr = vg_ptr->lv[lv_status_byindex_req.lv_index]) == NULL)
return -ENXIO;
/* Save usermode pointers */
- if (copy_from_user(&saved_ptr1, &lv_status_byindex_req.lv->lv_current_pe, sizeof(void*)) != 0)
- return -EFAULT;
- if (copy_from_user(&saved_ptr2, &lv_status_byindex_req.lv->lv_block_exception, sizeof(void*)) != 0)
- return -EFAULT;
-
- if (copy_to_user(lv_status_byindex_req.lv, lv_ptr, sizeof(lv_t)) != 0)
+ if (copy_from_user
+ (&saved_ptr1, &lv_status_byindex_req.lv->lv_current_pe,
+ sizeof(void *)) != 0)
+ return -EFAULT;
+ if (copy_from_user
+ (&saved_ptr2, &lv_status_byindex_req.lv->lv_block_exception,
+ sizeof(void *)) != 0)
return -EFAULT;
+
+ if (copy_to_user(lv_status_byindex_req.lv, lv_ptr, sizeof(lv_t)) !=
+ 0) return -EFAULT;
if (saved_ptr1 != NULL) {
if (copy_to_user(saved_ptr1,
lv_ptr->lv_current_pe,
lv_ptr->lv_allocated_le *
- sizeof(pe_t)) != 0)
- return -EFAULT;
+ sizeof(pe_t)) != 0) return -EFAULT;
}
/* Restore usermode pointers */
- if (copy_to_user(&lv_status_byindex_req.lv->lv_current_pe, &saved_ptr1, sizeof(void *)) != 0)
- return -EFAULT;
+ if (copy_to_user
+ (&lv_status_byindex_req.lv->lv_current_pe, &saved_ptr1,
+ sizeof(void *)) != 0)
+ return -EFAULT;
return 0;
-} /* lvm_do_lv_status_byindex() */
+} /* lvm_do_lv_status_byindex() */
/*
* character device support function logical volume status by device number
*/
-static int lvm_do_lv_status_bydev(vg_t * vg_ptr, void * arg) {
+static int lvm_do_lv_status_bydev(vg_t * vg_ptr, void *arg)
+{
int l;
lv_status_bydev_req_t lv_status_bydev_req;
void *saved_ptr1;
void *saved_ptr2;
lv_t *lv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&lv_status_bydev_req, arg,
sizeof(lv_status_bydev_req)) != 0)
return -EFAULT;
- for ( l = 0; l < vg_ptr->lv_max; l++) {
- if ( vg_ptr->lv[l] == NULL) continue;
- if ( vg_ptr->lv[l]->lv_dev == lv_status_bydev_req.dev) break;
+ for (l = 0; l < vg_ptr->lv_max; l++) {
+ if (vg_ptr->lv[l] == NULL)
+ continue;
+ if (vg_ptr->lv[l]->lv_dev == lv_status_bydev_req.dev)
+ break;
}
- if ( l == vg_ptr->lv_max) return -ENXIO;
+ if (l == vg_ptr->lv_max)
+ return -ENXIO;
lv_ptr = vg_ptr->lv[l];
/* Save usermode pointers */
- if (copy_from_user(&saved_ptr1, &lv_status_bydev_req.lv->lv_current_pe, sizeof(void*)) != 0)
- return -EFAULT;
- if (copy_from_user(&saved_ptr2, &lv_status_bydev_req.lv->lv_block_exception, sizeof(void*)) != 0)
- return -EFAULT;
-
- if (copy_to_user(lv_status_bydev_req.lv, lv_ptr, sizeof(lv_t)) != 0)
+ if (copy_from_user
+ (&saved_ptr1, &lv_status_bydev_req.lv->lv_current_pe,
+ sizeof(void *)) != 0)
return -EFAULT;
+ if (copy_from_user
+ (&saved_ptr2, &lv_status_bydev_req.lv->lv_block_exception,
+ sizeof(void *)) != 0)
+ return -EFAULT;
+
+ if (copy_to_user(lv_status_bydev_req.lv, lv_ptr, sizeof(lv_t)) !=
+ 0) return -EFAULT;
if (saved_ptr1 != NULL) {
if (copy_to_user(saved_ptr1,
lv_ptr->lv_current_pe,
lv_ptr->lv_allocated_le *
- sizeof(pe_t)) != 0)
- return -EFAULT;
+ sizeof(pe_t)) != 0) return -EFAULT;
}
/* Restore usermode pointers */
- if (copy_to_user(&lv_status_bydev_req.lv->lv_current_pe, &saved_ptr1, sizeof(void *)) != 0)
- return -EFAULT;
+ if (copy_to_user
+ (&lv_status_bydev_req.lv->lv_current_pe, &saved_ptr1,
+ sizeof(void *)) != 0)
+ return -EFAULT;
return 0;
-} /* lvm_do_lv_status_bydev() */
+} /* lvm_do_lv_status_bydev() */
/*
* character device support function rename a logical volume
*/
-static int lvm_do_lv_rename(vg_t *vg_ptr, lv_req_t *lv_req, lv_t *lv)
+static int lvm_do_lv_rename(vg_t * vg_ptr, lv_req_t * lv_req, lv_t * lv)
{
int l = 0;
int ret = 0;
lv_t *lv_ptr = NULL;
- for (l = 0; l < vg_ptr->lv_max; l++)
- {
- if ( (lv_ptr = vg_ptr->lv[l]) == NULL) continue;
- if (lv_ptr->lv_dev == lv->lv_dev)
- {
+ for (l = 0; l < vg_ptr->lv_max; l++) {
+ if ((lv_ptr = vg_ptr->lv[l]) == NULL)
+ continue;
+ if (lv_ptr->lv_dev == lv->lv_dev) {
lvm_fs_remove_lv(vg_ptr, lv_ptr);
- strncpy(lv_ptr->lv_name,
- lv_req->lv_name,
+ strncpy(lv_ptr->lv_name, lv_req->lv_name,
NAME_LEN);
lvm_fs_create_lv(vg_ptr, lv_ptr);
break;
}
}
- if (l == vg_ptr->lv_max) ret = -ENODEV;
+ if (l == vg_ptr->lv_max)
+ ret = -ENODEV;
return ret;
-} /* lvm_do_lv_rename */
+} /* lvm_do_lv_rename */
/*
* character device support function physical volume change
*/
-static int lvm_do_pv_change(vg_t *vg_ptr, void *arg)
+static int lvm_do_pv_change(vg_t * vg_ptr, void *arg)
{
uint p;
pv_t *pv_ptr;
struct block_device *bd;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&pv_change_req, arg,
- sizeof(pv_change_req)) != 0)
- return -EFAULT;
+ sizeof(pv_change_req)) != 0) return -EFAULT;
for (p = 0; p < vg_ptr->pv_max; p++) {
pv_ptr = vg_ptr->pv[p];
if (pv_ptr != NULL &&
- strcmp(pv_ptr->pv_name,
- pv_change_req.pv_name) == 0) {
+ strcmp(pv_ptr->pv_name, pv_change_req.pv_name) == 0) {
bd = pv_ptr->bd;
if (copy_from_user(pv_ptr,
@@ -2599,53 +2783,52 @@
}
}
return -ENXIO;
-} /* lvm_do_pv_change() */
+} /* lvm_do_pv_change() */
/*
* character device support function get physical volume status
*/
-static int lvm_do_pv_status(vg_t *vg_ptr, void *arg)
+static int lvm_do_pv_status(vg_t * vg_ptr, void *arg)
{
uint p;
pv_t *pv_ptr;
- if (vg_ptr == NULL) return -ENXIO;
+ if (vg_ptr == NULL)
+ return -ENXIO;
if (copy_from_user(&pv_status_req, arg,
- sizeof(pv_status_req)) != 0)
- return -EFAULT;
+ sizeof(pv_status_req)) != 0) return -EFAULT;
for (p = 0; p < vg_ptr->pv_max; p++) {
pv_ptr = vg_ptr->pv[p];
if (pv_ptr != NULL &&
- strcmp(pv_ptr->pv_name,
- pv_status_req.pv_name) == 0) {
+ strcmp(pv_ptr->pv_name, pv_status_req.pv_name) == 0) {
if (copy_to_user(pv_status_req.pv,
- pv_ptr,
- sizeof(pv_t)) != 0)
+ pv_ptr, sizeof(pv_t)) != 0)
return -EFAULT;
return 0;
}
}
return -ENXIO;
-} /* lvm_do_pv_status() */
+} /* lvm_do_pv_status() */
+
/*
* character device support function flush and invalidate all buffers of a PV
*/
static int lvm_do_pv_flush(void *arg)
{
- pv_flush_req_t pv_flush_req;
+ pv_flush_req_t pv_flush_req;
- if (copy_from_user(&pv_flush_req, arg,
- sizeof(pv_flush_req)) != 0)
- return -EFAULT;
+ if (copy_from_user(&pv_flush_req, arg, sizeof(pv_flush_req)) != 0)
+ return -EFAULT;
- fsync_dev(pv_flush_req.pv_dev);
- invalidate_buffers(pv_flush_req.pv_dev);
+ fsync_dev(pv_flush_req.pv_dev);
+ invalidate_buffers(pv_flush_req.pv_dev);
- return 0;
+ return 0;
}
+
/*
* support function initialize gendisk variables
*/
@@ -2668,13 +2851,15 @@
hardsect_size[MAJOR_NR] = lvm_hardsectsizes;
return;
-} /* lvm_gen_init() */
+} /* lvm_gen_init() */
/* Must have down_write(_pe_lock) when we enqueue buffers */
-static void _queue_io(struct buffer_head *bh, int rw) {
- if (bh->b_reqnext) BUG();
+static void _queue_io(struct buffer_head *bh, int rw)
+{
+ if (bh->b_reqnext)
+ BUG();
bh->b_reqnext = _pe_requests;
_pe_requests = bh;
}
@@ -2708,17 +2893,19 @@
}
}
+
/*
* we must open the pv's before we use them
*/
-static int _open_pv(pv_t *pv) {
+static int _open_pv(pv_t * pv)
+{
int err;
struct block_device *bd;
if (!(bd = bdget(kdev_t_to_nr(pv->pv_dev))))
return -ENOMEM;
- err = blkdev_get(bd, FMODE_READ|FMODE_WRITE, 0, BDEV_FILE);
+ err = blkdev_get(bd, FMODE_READ | FMODE_WRITE, 0, BDEV_FILE);
if (err)
return err;
@@ -2726,7 +2913,8 @@
return 0;
}
-static void _close_pv(pv_t *pv) {
+static void _close_pv(pv_t * pv)
+{
if (pv) {
struct block_device *bdev = pv->bd;
pv->bd = NULL;
@@ -2735,15 +2923,21 @@
}
}
+
static unsigned long _sectors_to_k(unsigned long sect)
{
- if(SECTOR_SIZE > 1024) {
+ if (SECTOR_SIZE > 1024) {
return sect * (SECTOR_SIZE / 1024);
}
return sect / (1024 / SECTOR_SIZE);
}
+MODULE_AUTHOR("Heinz Mauelshagen, Sistina Software");
+MODULE_DESCRIPTION("Logical Volume Manager");
+#ifdef MODULE_LICENSE
+MODULE_LICENSE("GPL");
+#endif
+
module_init(lvm_init);
module_exit(lvm_cleanup);
-MODULE_LICENSE("GPL");
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)