开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
lvm.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：75k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

lvm.c：源码内容
  1. /*
  2.  * kernel/lvm.c
  3.  *
  4.  * Copyright (C) 1997 - 2000  Heinz Mauelshagen, Sistina Software
  5.  *
  6.  * February-November 1997
  7.  * April-May,July-August,November 1998
  8.  * January-March,May,July,September,October 1999
  9.  * January,February,July,September-November 2000
  10.  * January 2001
  11.  *
  12.  *
  13.  * LVM driver is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2, or (at your option)
  16.  * any later version.
  17.  *
  18.  * LVM driver is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with GNU CC; see the file COPYING.  If not, write to
  25.  * the Free Software Foundation, 59 Temple Place - Suite 330,
  26.  * Boston, MA 02111-1307, USA.
  27.  *
  28.  */
  30. /*
  31.  * Changelog
  32.  *
  33.  *    09/11/1997 - added chr ioctls VG_STATUS_GET_COUNT
  34.  *                 and VG_STATUS_GET_NAMELIST
  35.  *    18/01/1998 - change lvm_chr_open/close lock handling
  36.  *    30/04/1998 - changed LV_STATUS ioctl to LV_STATUS_BYNAME and
  37.  *               - added   LV_STATUS_BYINDEX ioctl
  38.  *               - used lvm_status_byname_req_t and
  39.  *                      lvm_status_byindex_req_t vars
  40.  *    04/05/1998 - added multiple device support
  41.  *    08/05/1998 - added support to set/clear extendable flag in volume group
  42.  *    09/05/1998 - changed output of lvm_proc_get_global_info() because of
  43.  *                 support for free (eg. longer) logical volume names
  44.  *    12/05/1998 - added spin_locks (thanks to Pascal van Dam
  45.  *                 <pascal@ramoth.xs4all.nl>)
  46.  *    25/05/1998 - fixed handling of locked PEs in lvm_map() and lvm_chr_ioctl()
  47.  *    26/05/1998 - reactivated verify_area by access_ok
  48.  *    07/06/1998 - used vmalloc/vfree instead of kmalloc/kfree to go
  49.  *                 beyond 128/256 KB max allocation limit per call
  50.  *               - #ifdef blocked spin_lock calls to avoid compile errors
  51.  *                 with 2.0.x
  52.  *    11/06/1998 - another enhancement to spinlock code in lvm_chr_open()
  53.  *                 and use of LVM_VERSION_CODE instead of my own macros
  54.  *                 (thanks to  Michael Marxmeier <mike@msede.com>)
  55.  *    07/07/1998 - added statistics in lvm_map()
  56.  *    08/07/1998 - saved statistics in lvm_do_lv_extend_reduce()
  57.  *    25/07/1998 - used __initfunc macro
  58.  *    02/08/1998 - changes for official char/block major numbers
  59.  *    07/08/1998 - avoided init_module() and cleanup_module() to be static
  60.  *    30/08/1998 - changed VG lv_open counter from sum of LV lv_open counters
  61.  *                 to sum of LVs open (no matter how often each is)
  62.  *    01/09/1998 - fixed lvm_gendisk.part[] index error
  63.  *    07/09/1998 - added copying of lv_current_pe-array
  64.  *                 in LV_STATUS_BYINDEX ioctl
  65.  *    17/11/1998 - added KERN_* levels to printk
  66.  *    13/01/1999 - fixed LV index bug in lvm_do_lv_create() which hit lvrename
  67.  *    07/02/1999 - fixed spinlock handling bug in case of LVM_RESET
  68.  *                 by moving spinlock code from lvm_chr_open()
  69.  *                 to lvm_chr_ioctl()
  70.  *               - added LVM_LOCK_LVM ioctl to lvm_chr_ioctl()
  71.  *               - allowed LVM_RESET and retrieval commands to go ahead;
  72.  *                 only other update ioctls are blocked now
  73.  *               - fixed pv->pe to NULL for pv_status
  74.  *               - using lv_req structure in lvm_chr_ioctl() now
  75.  *               - fixed NULL ptr reference bug in lvm_do_lv_extend_reduce()
  76.  *                 caused by uncontiguous PV array in lvm_chr_ioctl(VG_REDUCE)
  77.  *    09/02/1999 - changed BLKRASET and BLKRAGET in lvm_chr_ioctl() to
  78.  *                 handle lgoical volume private read ahead sector
  79.  *               - implemented LV read_ahead handling with lvm_blk_read()
  80.  *                 and lvm_blk_write()
  81.  *    10/02/1999 - implemented 2.[12].* support function lvm_hd_name()
  82.  *                 to be used in drivers/block/genhd.c by disk_name()
  83.  *    12/02/1999 - fixed index bug in lvm_blk_ioctl(), HDIO_GETGEO
  84.  *               - enhanced gendisk insert/remove handling
  85.  *    16/02/1999 - changed to dynamic block minor number allocation to
  86.  *                 have as much as 99 volume groups with 256 logical volumes
  87.  *                 as the grand total; this allows having 1 volume group with
  88.  *                 up to 256 logical volumes in it
  89.  *    21/02/1999 - added LV open count information to proc filesystem
  90.  *               - substituted redundant LVM_RESET code by calls
  91.  *                 to lvm_do_vg_remove()
  92.  *    22/02/1999 - used schedule_timeout() to be more responsive
  93.  *                 in case of lvm_do_vg_remove() with lots of logical volumes
  94.  *    19/03/1999 - fixed NULL pointer bug in module_init/lvm_init
  95.  *    17/05/1999 - used DECLARE_WAIT_QUEUE_HEAD macro (>2.3.0)
  96.  *               - enhanced lvm_hd_name support
  97.  *    03/07/1999 - avoided use of KERNEL_VERSION macro based ifdefs and
  98.  *                 memcpy_tofs/memcpy_fromfs macro redefinitions
  99.  *    06/07/1999 - corrected reads/writes statistic counter copy in case
  100.  *                 of striped logical volume
  101.  *    28/07/1999 - implemented snapshot logical volumes
  102.  *                 - lvm_chr_ioctl
  103.  *                   - LV_STATUS_BYINDEX
  104.  *                   - LV_STATUS_BYNAME
  105.  *                 - lvm_do_lv_create
  106.  *                 - lvm_do_lv_remove
  107.  *                 - lvm_map
  108.  *                 - new lvm_snapshot_remap_block
  109.  *                 - new lvm_snapshot_remap_new_block
  110.  *    08/10/1999 - implemented support for multiple snapshots per
  111.  *                 original logical volume
  112.  *    12/10/1999 - support for 2.3.19
  113.  *    11/11/1999 - support for 2.3.28
  114.  *    21/11/1999 - changed lvm_map() interface to buffer_head based
  115.  *    19/12/1999 - support for 2.3.33
  116.  *    01/01/2000 - changed locking concept in lvm_map(),
  117.  *                 lvm_do_vg_create() and lvm_do_lv_remove()
  118.  *    15/01/2000 - fixed PV_FLUSH bug in lvm_chr_ioctl()
  119.  *    24/01/2000 - ported to 2.3.40 including Alan Cox's pointer changes etc.
  120.  *    29/01/2000 - used kmalloc/kfree again for all small structures
  121.  *    20/01/2000 - cleaned up lvm_chr_ioctl by moving code
  122.  *                 to seperated functions
  123.  *               - avoided "/dev/" in proc filesystem output
  124.  *               - avoided inline strings functions lvm_strlen etc.
  125.  *    14/02/2000 - support for 2.3.43
  126.  *               - integrated Andrea Arcagneli's snapshot code
  127.  *    25/06/2000 - james (chip) , IKKHAYD! roffl
  128.  *    26/06/2000 - enhanced lv_extend_reduce for snapshot logical volume support
  129.  *    06/09/2000 - added devfs support
  130.  *    07/09/2000 - changed IOP version to 9
  131.  *               - started to add new char ioctl LV_STATUS_BYDEV_T to support
  132.  *                 getting an lv_t based on the dev_t of the Logical Volume
  133.  *    14/09/2000 - enhanced lvm_do_lv_create to upcall VFS functions
  134.  *                 to sync and lock, activate snapshot and unlock the FS
  135.  *                 (to support journaled filesystems)
  136.  *    18/09/2000 - hardsector size support
  137.  *    27/09/2000 - implemented lvm_do_lv_rename() and lvm_do_vg_rename()
  138.  *    30/10/2000 - added Andi Kleen's LV_BMAP ioctl to support LILO
  139.  *    01/11/2000 - added memory information on hash tables to
  140.  *                 lvm_proc_get_global_info()
  141.  *    02/11/2000 - implemented /proc/lvm/ hierarchy
  142.  *    22/11/2000 - changed lvm_do_create_proc_entry_of_pv () to work
  143.  *                 with devfs
  144.  *    26/11/2000 - corrected #ifdef locations for PROC_FS
  145.  *    28/11/2000 - fixed lvm_do_vg_extend() NULL pointer BUG
  146.  *               - fixed lvm_do_create_proc_entry_of_pv() buffer tampering BUG
  147.  *    08/01/2001 - Removed conditional compiles related to PROC_FS,
  148.  *                 procfs is always supported now. (JT)
  149.  *    12/01/2001 - avoided flushing logical volume in case of shrinking
  150.  *                 because of unnecessary overhead in case of heavy updates
  151.  *    25/01/2001 - Allow RO open of an inactive LV so it can be reactivated.
  152.  *    31/01/2001 - If you try and BMAP a snapshot you now get an -EPERM
  153.  *    01/02/2001 - factored __remap_snapshot out of lvm_map
  154.  *    12/02/2001 - move devfs code to create VG before LVs
  155.  *    14/02/2001 - tidied device defines for blk.h
  156.  *               - tidied debug statements
  157.  *               - more lvm_map tidying
  158.  *    14/02/2001 - bug: vg[] member not set back to NULL if activation fails
  159.  *    28/02/2001 - introduced the P_DEV macro and changed some internel
  160.  *                 functions to be static [AD]
  161.  *    28/02/2001 - factored lvm_get_snapshot_use_rate out of blk_ioctl [AD]
  162.  *               - fixed user address accessing bug in lvm_do_lv_create()
  163.  *                 where the check for an existing LV takes place right at
  164.  *                 the beginning
  165.  *    01/03/2001 - Add VG_CREATE_OLD for IOP 10 compatibility
  166.  *    02/03/2001 - Don't destroy usermode pointers in lv_t structures duing LV_
  167.  *                 STATUS_BYxxx and remove redundant lv_t variables from same.
  168.  *    05/03/2001 - restore copying pe_t array in lvm_do_lv_status_byname. For
  169.  *                 lvdisplay -v (PC)
  170.  *               - restore copying pe_t array in lvm_do_lv_status_byindex (HM)
  171.  *               - added copying pe_t array in lvm_do_lv_status_bydev (HM)
  172.  *               - enhanced lvm_do_lv_status_by{name,index,dev} to be capable
  173.  *                 to copy the lv_block_exception_t array to userspace (HM)
  174.  *    08/03/2001 - factored lvm_do_pv_flush out of lvm_chr_ioctl [HM]
  175.  *    09/03/2001 - Added _lock_open_count to ensure we only drop the lock
  176.  *                 when the locking process closes.
  177.  *    05/04/2001 - lvm_map bugs: don't use b_blocknr/b_dev in lvm_map, it
  178.  *    destroys stacking devices. call b_end_io on failed maps.
  179.  *    (Jens Axboe)
  180.  *               - Defer writes to an extent that is being moved [JT + AD]
  181.  *    28/05/2001 - implemented missing BLKSSZGET ioctl [AD]
  182.  *
  183.  */
  186. #define MAJOR_NR LVM_BLK_MAJOR
  187. #define DEVICE_OFF(device)
  188. #define LOCAL_END_REQUEST
  190. /* lvm_do_lv_create calls fsync_dev_lockfs()/unlockfs() */
  191. /* #define LVM_VFS_ENHANCEMENT */
  193. #include <linux/config.h>
  195. #include <linux/module.h>
  197. #include <linux/kernel.h>
  198. #include <linux/vmalloc.h>
  199. #include <linux/slab.h>
  200. #include <linux/init.h>
  202. #include <linux/hdreg.h>
  203. #include <linux/stat.h>
  204. #include <linux/fs.h>
  205. #include <linux/proc_fs.h>
  206. #include <linux/blkdev.h>
  207. #include <linux/genhd.h>
  208. #include <linux/locks.h>
  209. #include <linux/devfs_fs_kernel.h>
  210. #include <linux/smp_lock.h>
  211. #include <asm/ioctl.h>
  212. #include <asm/segment.h>
  213. #include <asm/uaccess.h>
  215. #ifdef CONFIG_KERNELD
  216. #include <linux/kerneld.h>
  217. #endif
  219. #include <linux/blk.h>
  220. #include <linux/blkpg.h>
  222. #include <linux/errno.h>
  223. #include <linux/lvm.h>
  225. #include "lvm-internal.h"
  227. #define LVM_CORRECT_READ_AHEAD( a) 
  228.    if      ( a < LVM_MIN_READ_AHEAD || 
  229.              a > LVM_MAX_READ_AHEAD) a = LVM_MAX_READ_AHEAD;
  231. #ifndef WRITEA
  232. #  define WRITEA WRITE
  233. #endif
  236. /*
  237.  * External function prototypes
  238.  */
  239. static int lvm_make_request_fn(request_queue_t*, int, struct buffer_head*);
  241. static int lvm_blk_ioctl(struct inode *, struct file *, uint, ulong);
  242. static int lvm_blk_open(struct inode *, struct file *);
  244. static int lvm_blk_close(struct inode *, struct file *);
  245. static int lvm_get_snapshot_use_rate(lv_t *lv_ptr, void *arg);
  246. static int lvm_user_bmap(struct inode *, struct lv_bmap *);
  248. static int lvm_chr_open(struct inode *, struct file *);
  249. static int lvm_chr_close(struct inode *, struct file *);
  250. static int lvm_chr_ioctl(struct inode *, struct file *, uint, ulong);
  253. /* End external function prototypes */
  256. /*
  257.  * Internal function prototypes
  258.  */
  259. static void lvm_cleanup(void);
  260. static void lvm_init_vars(void);
  262. #ifdef LVM_HD_NAME
  263. extern void (*lvm_hd_name_ptr) (char *, int);
  264. #endif
  265. static int lvm_map(struct buffer_head *, int);
  266. static int lvm_do_lock_lvm(void);
  267. static int lvm_do_le_remap(vg_t *, void *);
  269. static int lvm_do_pv_create(pv_t *, vg_t *, ulong);
  270. static int lvm_do_pv_remove(vg_t *, ulong);
  271. static int lvm_do_lv_create(int, char *, lv_t *);
  272. static int lvm_do_lv_extend_reduce(int, char *, lv_t *);
  273. static int lvm_do_lv_remove(int, char *, int);
  274. static int lvm_do_lv_rename(vg_t *, lv_req_t *, lv_t *);
  275. static int lvm_do_lv_status_byname(vg_t *r, void *);
  276. static int lvm_do_lv_status_byindex(vg_t *, void *);
  277. static int lvm_do_lv_status_bydev(vg_t *, void *);
  279. static int lvm_do_pe_lock_unlock(vg_t *r, void *);
  281. static int lvm_do_pv_change(vg_t*, void*);
  282. static int lvm_do_pv_status(vg_t *, void *);
  283. static int lvm_do_pv_flush(void *);
  285. static int lvm_do_vg_create(void *, int minor);
  286. static int lvm_do_vg_extend(vg_t *, void *);
  287. static int lvm_do_vg_reduce(vg_t *, void *);
  288. static int lvm_do_vg_rename(vg_t *, void *);
  289. static int lvm_do_vg_remove(int);
  290. static void lvm_geninit(struct gendisk *);
  291. static void __update_hardsectsize(lv_t *lv);
  294. static void _queue_io(struct buffer_head *bh, int rw);
  295. static struct buffer_head *_dequeue_io(void);
  296. static void _flush_io(struct buffer_head *bh);
  298. static int _open_pv(pv_t *pv);
  299. static void _close_pv(pv_t *pv);
  301. static unsigned long _sectors_to_k(unsigned long sect);
  303. #ifdef LVM_HD_NAME
  304. void lvm_hd_name(char *, int);
  305. #endif
  306. /* END Internal function prototypes */
  309. /* variables */
  310. char *lvm_version = "LVM version "LVM_RELEASE_NAME"("LVM_RELEASE_DATE")";
  311. ushort lvm_iop_version = LVM_DRIVER_IOP_VERSION;
  312. int loadtime = 0;
  313. const char *const lvm_name = LVM_NAME;
  316. /* volume group descriptor area pointers */
  317. vg_t *vg[ABS_MAX_VG];
  319. /* map from block minor number to VG and LV numbers */
  320. typedef struct {
  321. int vg_number;
  322. int lv_number;
  323. } vg_lv_map_t;
  324. static vg_lv_map_t vg_lv_map[ABS_MAX_LV];
  327. /* Request structures (lvm_chr_ioctl()) */
  328. static pv_change_req_t pv_change_req;
  329. static pv_status_req_t pv_status_req;
  330. volatile static pe_lock_req_t pe_lock_req;
  331. static le_remap_req_t le_remap_req;
  332. static lv_req_t lv_req;
  334. #ifdef LVM_TOTAL_RESET
  335. static int lvm_reset_spindown = 0;
  336. #endif
  338. static char pv_name[NAME_LEN];
  339. /* static char rootvg[NAME_LEN] = { 0, }; */
  340. static int lock = 0;
  341. static int _lock_open_count = 0;
  342. static uint vg_count = 0;
  343. static long lvm_chr_open_count = 0;
  344. static DECLARE_WAIT_QUEUE_HEAD(lvm_wait);
  346. static spinlock_t lvm_lock = SPIN_LOCK_UNLOCKED;
  347. static spinlock_t lvm_snapshot_lock = SPIN_LOCK_UNLOCKED;
  349. static struct buffer_head *_pe_requests;
  350. static DECLARE_RWSEM(_pe_lock);
  353. struct file_operations lvm_chr_fops = {
  354. open: lvm_chr_open,
  355. release: lvm_chr_close,
  356. ioctl: lvm_chr_ioctl,
  357. };
  359. /* block device operations structure needed for 2.3.38? and above */
  360. struct block_device_operations lvm_blk_dops =
  361. {
  362. owner: THIS_MODULE,
  363. open:  lvm_blk_open,
  364. release: lvm_blk_close,
  365. ioctl: lvm_blk_ioctl,
  366. };
  369. /* gendisk structures */
  370. static struct hd_struct lvm_hd_struct[MAX_LV];
  371. static int lvm_blocksizes[MAX_LV];
  372. static int lvm_hardsectsizes[MAX_LV];
  373. static int lvm_size[MAX_LV];
  375. static struct gendisk lvm_gendisk =
  376. {
  377. major: MAJOR_NR,
  378. major_name: LVM_NAME,
  379. minor_shift: 0,
  380. max_p: 1,
  381. part: lvm_hd_struct,
  382. sizes: lvm_size,
  383. nr_real: MAX_LV,
  384. };
  386. /*
  387.  * Driver initialization...
  388.  */
  389. int lvm_init(void)
  390. {
  391. if (devfs_register_chrdev(LVM_CHAR_MAJOR,
  392.   lvm_name, &lvm_chr_fops) < 0) {
  393. printk(KERN_ERR "%s -- devfs_register_chrdev failedn",
  394.        lvm_name);
  395. return -EIO;
  396. }
  398. if (devfs_register_blkdev(MAJOR_NR, lvm_name, &lvm_blk_dops) < 0)
  399. {
  400. printk("%s -- devfs_register_blkdev failedn", lvm_name);
  401. if (devfs_unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)
  402. printk(KERN_ERR
  403.        "%s -- devfs_unregister_chrdev failedn",
  404.        lvm_name);
  405. return -EIO;
  406. }
  408. lvm_init_fs();
  409. lvm_init_vars();
  410. lvm_geninit(&lvm_gendisk);
  412. add_gendisk(&lvm_gendisk);
  414. #ifdef LVM_HD_NAME
  415. /* reference from drivers/block/genhd.c */
  416. lvm_hd_name_ptr = lvm_hd_name;
  417. #endif
  419. blk_queue_make_request(BLK_DEFAULT_QUEUE(MAJOR_NR), lvm_make_request_fn);
  422. /* initialise the pe lock */
  423. pe_lock_req.lock = UNLOCK_PE;
  425. /* optional read root VGDA */
  426. /*
  427.    if ( *rootvg != 0) vg_read_with_pv_and_lv ( rootvg, &vg);
  428. */
  430. #ifdef MODULE
  431. printk(KERN_INFO "%s module loadedn", lvm_version);
  432. #else
  433. printk(KERN_INFO "%sn", lvm_version);
  434. #endif
  436. return 0;
  437. } /* lvm_init() */
  440. /*
  441.  * cleanup...
  442.  */
  443. static void lvm_cleanup(void)
  444. {
  445. if (devfs_unregister_chrdev(LVM_CHAR_MAJOR, lvm_name) < 0)
  446. printk(KERN_ERR "%s -- devfs_unregister_chrdev failedn",
  447.        lvm_name);
  448. if (devfs_unregister_blkdev(MAJOR_NR, lvm_name) < 0)
  449. printk(KERN_ERR "%s -- devfs_unregister_blkdev failedn",
  450.        lvm_name);
  452. del_gendisk(&lvm_gendisk);
  454. blk_size[MAJOR_NR] = NULL;
  455. blksize_size[MAJOR_NR] = NULL;
  456. hardsect_size[MAJOR_NR] = NULL;
  458. #ifdef LVM_HD_NAME
  459. /* reference from linux/drivers/block/genhd.c */
  460. lvm_hd_name_ptr = NULL;
  461. #endif
  463. /* unregister with procfs and devfs */
  464. lvm_fin_fs();
  466. #ifdef MODULE
  467. printk(KERN_INFO "%s -- Module successfully deactivatedn", lvm_name);
  468. #endif
  470. return;
  471. } /* lvm_cleanup() */
  473. /*
  474.  * support function to initialize lvm variables
  475.  */
  476. static void __init lvm_init_vars(void)
  477. {
  478. int v;
  480. loadtime = CURRENT_TIME;
  482. lvm_lock = lvm_snapshot_lock = SPIN_LOCK_UNLOCKED;
  484. pe_lock_req.lock = UNLOCK_PE;
  485. pe_lock_req.data.lv_dev = 0;
  486. pe_lock_req.data.pv_dev = 0;
  487. pe_lock_req.data.pv_offset = 0;
  489. /* Initialize VG pointers */
  490. for (v = 0; v < ABS_MAX_VG; v++) vg[v] = NULL;
  492. /* Initialize LV -> VG association */
  493. for (v = 0; v < ABS_MAX_LV; v++) {
  494. /* index ABS_MAX_VG never used for real VG */
  495. vg_lv_map[v].vg_number = ABS_MAX_VG;
  496. vg_lv_map[v].lv_number = -1;
  497. }
  499. return;
  500. } /* lvm_init_vars() */
  503. /********************************************************************
  504.  *
  505.  * Character device functions
  506.  *
  507.  ********************************************************************/
  509. #define MODE_TO_STR(mode) (mode) & FMODE_READ ? "READ" : "", 
  510.   (mode) & FMODE_WRITE ? "WRITE" : ""
  512. /*
  513.  * character device open routine
  514.  */
  515. static int lvm_chr_open(struct inode *inode, struct file *file)
  516. {
  517. unsigned int minor = MINOR(inode->i_rdev);
  519. P_DEV("chr_open MINOR: %d  VG#: %d  mode: %s%s  lock: %dn",
  520.       minor, VG_CHR(minor), MODE_TO_STR(file->f_mode), lock);
  522. /* super user validation */
  523. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  525. /* Group special file open */
  526. if (VG_CHR(minor) > MAX_VG) return -ENXIO;
  528.        spin_lock(&lvm_lock);
  529.        if(lock == current->pid)
  530.                _lock_open_count++;
  531.        spin_unlock(&lvm_lock);
  533. lvm_chr_open_count++;
  535. MOD_INC_USE_COUNT;
  537. return 0;
  538. } /* lvm_chr_open() */
  541. /*
  542.  * character device i/o-control routine
  543.  *
  544.  * Only one changing process can do changing ioctl at one time,
  545.  * others will block.
  546.  *
  547.  */
  548. static int lvm_chr_ioctl(struct inode *inode, struct file *file,
  549.   uint command, ulong a)
  550. {
  551. int minor = MINOR(inode->i_rdev);
  552. uint extendable, l, v;
  553. void *arg = (void *) a;
  554. lv_t lv;
  555. vg_t* vg_ptr = vg[VG_CHR(minor)];
  557. /* otherwise cc will complain about unused variables */
  558. (void) lvm_lock;
  560. P_IOCTL("chr MINOR: %d  command: 0x%X  arg: %p  VG#: %d  mode: %s%sn",
  561. minor, command, arg, VG_CHR(minor), MODE_TO_STR(file->f_mode));
  563. #ifdef LVM_TOTAL_RESET
  564. if (lvm_reset_spindown > 0) return -EACCES;
  565. #endif
  567. /* Main command switch */
  568. switch (command) {
  569. case LVM_LOCK_LVM:
  570. /* lock the LVM */
  571. return lvm_do_lock_lvm();
  573. case LVM_GET_IOP_VERSION:
  574. /* check lvm version to ensure driver/tools+lib
  575.    interoperability */
  576. if (copy_to_user(arg, &lvm_iop_version, sizeof(ushort)) != 0)
  577. return -EFAULT;
  578. return 0;
  580. #ifdef LVM_TOTAL_RESET
  581. case LVM_RESET:
  582. /* lock reset function */
  583. lvm_reset_spindown = 1;
  584. for (v = 0; v < ABS_MAX_VG; v++) {
  585. if (vg[v] != NULL) lvm_do_vg_remove(v);
  586. }
  588. #ifdef MODULE
  589. while (GET_USE_COUNT(&__this_module) < 1)
  590. MOD_INC_USE_COUNT;
  591. while (GET_USE_COUNT(&__this_module) > 1)
  592. MOD_DEC_USE_COUNT;
  593. #endif /* MODULE */
  594. lock = 0; /* release lock */
  595. wake_up_interruptible(&lvm_wait);
  596. return 0;
  597. #endif /* LVM_TOTAL_RESET */
  600. case LE_REMAP:
  601. /* remap a logical extent (after moving the physical extent) */
  602. return lvm_do_le_remap(vg_ptr,arg);
  604. case PE_LOCK_UNLOCK:
  605. /* lock/unlock i/o to a physical extent to move it to another
  606.    physical volume (move's done in user space's pvmove) */
  607. return lvm_do_pe_lock_unlock(vg_ptr,arg);
  609. case VG_CREATE_OLD:
  610. /* create a VGDA */
  611. return lvm_do_vg_create(arg, minor);
  613.        case VG_CREATE:
  614.                /* create a VGDA, assume VG number is filled in */
  615. return lvm_do_vg_create(arg, -1);
  617. case VG_EXTEND:
  618. /* extend a volume group */
  619. return lvm_do_vg_extend(vg_ptr, arg);
  621. case VG_REDUCE:
  622. /* reduce a volume group */
  623. return lvm_do_vg_reduce(vg_ptr, arg);
  625. case VG_RENAME:
  626. /* rename a volume group */
  627. return lvm_do_vg_rename(vg_ptr, arg);
  629. case VG_REMOVE:
  630. /* remove an inactive VGDA */
  631. return lvm_do_vg_remove(minor);
  634. case VG_SET_EXTENDABLE:
  635. /* set/clear extendability flag of volume group */
  636. if (vg_ptr == NULL) return -ENXIO;
  637. if (copy_from_user(&extendable, arg, sizeof(extendable)) != 0)
  638. return -EFAULT;
  640. if (extendable == VG_EXTENDABLE ||
  641.     extendable == ~VG_EXTENDABLE) {
  642. if (extendable == VG_EXTENDABLE)
  643. vg_ptr->vg_status |= VG_EXTENDABLE;
  644. else
  645. vg_ptr->vg_status &= ~VG_EXTENDABLE;
  646. } else return -EINVAL;
  647. return 0;
  650. case VG_STATUS:
  651. /* get volume group data (only the vg_t struct) */
  652. if (vg_ptr == NULL) return -ENXIO;
  653. if (copy_to_user(arg, vg_ptr, sizeof(vg_t)) != 0)
  654. return -EFAULT;
  655. return 0;
  658. case VG_STATUS_GET_COUNT:
  659. /* get volume group count */
  660. if (copy_to_user(arg, &vg_count, sizeof(vg_count)) != 0)
  661. return -EFAULT;
  662. return 0;
  665. case VG_STATUS_GET_NAMELIST:
  666. /* get volume group names */
  667. for (l = v = 0; v < ABS_MAX_VG; v++) {
  668. if (vg[v] != NULL) {
  669. if (copy_to_user(arg + l * NAME_LEN,
  670.  vg[v]->vg_name,
  671.  NAME_LEN) != 0)
  672. return -EFAULT;
  673. l++;
  674. }
  675. }
  676. return 0;
  679. case LV_CREATE:
  680. case LV_EXTEND:
  681. case LV_REDUCE:
  682. case LV_REMOVE:
  683. case LV_RENAME:
  684. /* create, extend, reduce, remove or rename a logical volume */
  685. if (vg_ptr == NULL) return -ENXIO;
  686. if (copy_from_user(&lv_req, arg, sizeof(lv_req)) != 0)
  687. return -EFAULT;
  689. if (command != LV_REMOVE) {
  690. if (copy_from_user(&lv, lv_req.lv, sizeof(lv_t)) != 0)
  691. return -EFAULT;
  692. }
  693. switch (command) {
  694. case LV_CREATE:
  695. return lvm_do_lv_create(minor, lv_req.lv_name, &lv);
  697. case LV_EXTEND:
  698. case LV_REDUCE:
  699. return lvm_do_lv_extend_reduce(minor, lv_req.lv_name, &lv);
  700. case LV_REMOVE:
  701. return lvm_do_lv_remove(minor, lv_req.lv_name, -1);
  703. case LV_RENAME:
  704. return lvm_do_lv_rename(vg_ptr, &lv_req, &lv);
  705. }
  710. case LV_STATUS_BYNAME:
  711. /* get status of a logical volume by name */
  712. return lvm_do_lv_status_byname(vg_ptr, arg);
  715. case LV_STATUS_BYINDEX:
  716. /* get status of a logical volume by index */
  717. return lvm_do_lv_status_byindex(vg_ptr, arg);
  720. case LV_STATUS_BYDEV:
  721. /* get status of a logical volume by device */
  722. return lvm_do_lv_status_bydev(vg_ptr, arg);
  725. case PV_CHANGE:
  726. /* change a physical volume */
  727. return lvm_do_pv_change(vg_ptr,arg);
  730. case PV_STATUS:
  731. /* get physical volume data (pv_t structure only) */
  732. return lvm_do_pv_status(vg_ptr,arg);
  735. case PV_FLUSH:
  736. /* physical volume buffer flush/invalidate */
  737.                return lvm_do_pv_flush(arg);
  740. default:
  741. printk(KERN_WARNING
  742.        "%s -- lvm_chr_ioctl: unknown command 0x%xn",
  743.        lvm_name, command);
  744. return -EINVAL;
  745. }
  747. return 0;
  748. } /* lvm_chr_ioctl */
  751. /*
  752.  * character device close routine
  753.  */
  754. static int lvm_chr_close(struct inode *inode, struct file *file)
  755. {
  756. P_DEV("chr_close MINOR: %d  VG#: %dn",
  757.       MINOR(inode->i_rdev), VG_CHR(MINOR(inode->i_rdev)));
  759. #ifdef LVM_TOTAL_RESET
  760. if (lvm_reset_spindown > 0) {
  761. lvm_reset_spindown = 0;
  762. lvm_chr_open_count = 0;
  763. }
  764. #endif
  766. if (lvm_chr_open_count > 0) lvm_chr_open_count--;
  768.        spin_lock(&lvm_lock);
  769.        if(lock == current->pid) {
  770.                if(!_lock_open_count) {
  771. P_DEV("chr_close: unlocking LVM for pid %dn", lock);
  772.                        lock = 0;
  773.                        wake_up_interruptible(&lvm_wait);
  774.                } else
  775.                        _lock_open_count--;
  776. }
  777.        spin_unlock(&lvm_lock);
  779. MOD_DEC_USE_COUNT;
  781. return 0;
  782. } /* lvm_chr_close() */
  786. /********************************************************************
  787.  *
  788.  * Block device functions
  789.  *
  790.  ********************************************************************/
  792. /*
  793.  * block device open routine
  794.  */
  795. static int lvm_blk_open(struct inode *inode, struct file *file)
  796. {
  797. int minor = MINOR(inode->i_rdev);
  798. lv_t *lv_ptr;
  799. vg_t *vg_ptr = vg[VG_BLK(minor)];
  801. P_DEV("blk_open MINOR: %d  VG#: %d  LV#: %d  mode: %s%sn",
  802.       minor, VG_BLK(minor), LV_BLK(minor), MODE_TO_STR(file->f_mode));
  804. #ifdef LVM_TOTAL_RESET
  805. if (lvm_reset_spindown > 0)
  806. return -EPERM;
  807. #endif
  809. if (vg_ptr != NULL &&
  810.     (vg_ptr->vg_status & VG_ACTIVE) &&
  811.     (lv_ptr = vg_ptr->lv[LV_BLK(minor)]) != NULL &&
  812.     LV_BLK(minor) >= 0 &&
  813.     LV_BLK(minor) < vg_ptr->lv_max) {
  815. /* Check parallel LV spindown (LV remove) */
  816. if (lv_ptr->lv_status & LV_SPINDOWN) return -EPERM;
  818. /* Check inactive LV and open for read/write */
  819. /* We need to be able to "read" an inactive LV
  820.    to re-activate it again */
  821. if ((file->f_mode & FMODE_WRITE) &&
  822.     (!(lv_ptr->lv_status & LV_ACTIVE)))
  823.     return -EPERM;
  825. if (!(lv_ptr->lv_access & LV_WRITE) &&
  826.     (file->f_mode & FMODE_WRITE))
  827. return -EACCES;
  830.                 /* be sure to increment VG counter */
  831. if (lv_ptr->lv_open == 0) vg_ptr->lv_open++;
  832. lv_ptr->lv_open++;
  834. MOD_INC_USE_COUNT;
  836. P_DEV("blk_open OK, LV size %dn", lv_ptr->lv_size);
  838. return 0;
  839. }
  840. return -ENXIO;
  841. } /* lvm_blk_open() */
  844. /*
  845.  * block device i/o-control routine
  846.  */
  847. static int lvm_blk_ioctl(struct inode *inode, struct file *file,
  848.  uint command, ulong a)
  849. {
  850. int minor = MINOR(inode->i_rdev);
  851. vg_t *vg_ptr = vg[VG_BLK(minor)];
  852. lv_t *lv_ptr = vg_ptr->lv[LV_BLK(minor)];
  853. void *arg = (void *) a;
  854. struct hd_geometry *hd = (struct hd_geometry *) a;
  856. P_IOCTL("blk MINOR: %d  command: 0x%X  arg: %p  VG#: %d  LV#: %d  "
  857. "mode: %s%sn", minor, command, arg, VG_BLK(minor),
  858. LV_BLK(minor), MODE_TO_STR(file->f_mode));
  860. switch (command) {
  861. case BLKSSZGET:
  862. /* get block device sector size as needed e.g. by fdisk */
  863. return put_user(get_hardsect_size(inode->i_rdev), (int *) arg);
  865. case BLKGETSIZE:
  866. /* return device size */
  867. P_IOCTL("BLKGETSIZE: %un", lv_ptr->lv_size);
  868. if (put_user(lv_ptr->lv_size, (unsigned long *)arg))
  869. return -EFAULT;
  870. break;
  872. case BLKGETSIZE64:
  873. if (put_user((u64)lv_ptr->lv_size << 9, (u64 *)arg))
  874. return -EFAULT;
  875. break;
  878. case BLKFLSBUF:
  879. /* flush buffer cache */
  880. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  882. P_IOCTL("BLKFLSBUFn");
  884. fsync_dev(inode->i_rdev);
  885. invalidate_buffers(inode->i_rdev);
  886. break;
  889. case BLKRASET:
  890. /* set read ahead for block device */
  891. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  893. P_IOCTL("BLKRASET: %ld sectors for %sn",
  894. (long) arg, kdevname(inode->i_rdev));
  896. if ((long) arg < LVM_MIN_READ_AHEAD ||
  897.     (long) arg > LVM_MAX_READ_AHEAD)
  898. return -EINVAL;
  899. lv_ptr->lv_read_ahead = (long) arg;
  900. break;
  903. case BLKRAGET:
  904. /* get current read ahead setting */
  905. P_IOCTL("BLKRAGET %dn", lv_ptr->lv_read_ahead);
  906. if (put_user(lv_ptr->lv_read_ahead, (long *)arg))
  907. return -EFAULT;
  908. break;
  911. case HDIO_GETGEO:
  912. /* get disk geometry */
  913. P_IOCTL("%s -- lvm_blk_ioctl -- HDIO_GETGEOn", lvm_name);
  914. if (hd == NULL)
  915. return -EINVAL;
  916. {
  917. unsigned char heads = 64;
  918. unsigned char sectors = 32;
  919. long start = 0;
  920. short cylinders = lv_ptr->lv_size / heads / sectors;
  922. if (copy_to_user((char *) &hd->heads, &heads,
  923.  sizeof(heads)) != 0 ||
  924.     copy_to_user((char *) &hd->sectors, &sectors,
  925.  sizeof(sectors)) != 0 ||
  926.     copy_to_user((short *) &hd->cylinders,
  927.    &cylinders, sizeof(cylinders)) != 0 ||
  928.     copy_to_user((long *) &hd->start, &start,
  929.  sizeof(start)) != 0)
  930. return -EFAULT;
  932. P_IOCTL("%s -- lvm_blk_ioctl -- cylinders: %dn",
  933. lvm_name, cylinders);
  934. }
  935. break;
  938. case LV_SET_ACCESS:
  939. /* set access flags of a logical volume */
  940. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  941. lv_ptr->lv_access = (ulong) arg;
  942. if ( lv_ptr->lv_access & LV_WRITE)
  943. set_device_ro(lv_ptr->lv_dev, 0);
  944. else
  945. set_device_ro(lv_ptr->lv_dev, 1);
  946. break;
  949. case LV_SET_STATUS:
  950. /* set status flags of a logical volume */
  951. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  952. if (!((ulong) arg & LV_ACTIVE) && lv_ptr->lv_open > 1)
  953. return -EPERM;
  954. lv_ptr->lv_status = (ulong) arg;
  955. break;
  957. case LV_BMAP:
  958.                 /* turn logical block into (dev_t, block).  non privileged. */
  959.                 /* don't bmap a snapshot, since the mapping can change */
  960. if(lv_ptr->lv_access & LV_SNAPSHOT)
  961. return -EPERM;
  963. return lvm_user_bmap(inode, (struct lv_bmap *) arg);
  965. case LV_SET_ALLOCATION:
  966. /* set allocation flags of a logical volume */
  967. if (!capable(CAP_SYS_ADMIN)) return -EACCES;
  968. lv_ptr->lv_allocation = (ulong) arg;
  969. break;
  971. case LV_SNAPSHOT_USE_RATE:
  972. return lvm_get_snapshot_use_rate(lv_ptr, arg);
  974. default:
  975. printk(KERN_WARNING
  976.        "%s -- lvm_blk_ioctl: unknown command 0x%xn",
  977.        lvm_name, command);
  978. return -EINVAL;
  979. }
  981. return 0;
  982. } /* lvm_blk_ioctl() */
  985. /*
  986.  * block device close routine
  987.  */
  988. static int lvm_blk_close(struct inode *inode, struct file *file)
  989. {
  990. int minor = MINOR(inode->i_rdev);
  991. vg_t *vg_ptr = vg[VG_BLK(minor)];
  992. lv_t *lv_ptr = vg_ptr->lv[LV_BLK(minor)];
  994. P_DEV("blk_close MINOR: %d  VG#: %d  LV#: %dn",
  995.       minor, VG_BLK(minor), LV_BLK(minor));
  997. if (lv_ptr->lv_open == 1) vg_ptr->lv_open--;
  998. lv_ptr->lv_open--;
  1000. MOD_DEC_USE_COUNT;
  1002. return 0;
  1003. } /* lvm_blk_close() */
  1005. static int lvm_get_snapshot_use_rate(lv_t *lv, void *arg)
  1006. {
  1007. lv_snapshot_use_rate_req_t lv_rate_req;
  1009. if (!(lv->lv_access & LV_SNAPSHOT))
  1010. return -EPERM;
  1012. if (copy_from_user(&lv_rate_req, arg, sizeof(lv_rate_req)))
  1013. return -EFAULT;
  1015. if (lv_rate_req.rate < 0 || lv_rate_req.rate > 100)
  1016. return -EINVAL;
  1018. switch (lv_rate_req.block) {
  1019. case 0:
  1020. lv->lv_snapshot_use_rate = lv_rate_req.rate;
  1021. if (lv->lv_remap_ptr * 100 / lv->lv_remap_end <
  1022.     lv->lv_snapshot_use_rate)
  1023. interruptible_sleep_on(&lv->lv_snapshot_wait);
  1024. break;
  1026. case O_NONBLOCK:
  1027. break;
  1029. default:
  1030. return -EINVAL;
  1031. }
  1032. lv_rate_req.rate = lv->lv_remap_ptr * 100 / lv->lv_remap_end;
  1034. return copy_to_user(arg, &lv_rate_req,
  1035.     sizeof(lv_rate_req)) ? -EFAULT : 0;
  1036. }
  1038. static int lvm_user_bmap(struct inode *inode, struct lv_bmap *user_result)
  1039. {
  1040. struct buffer_head bh;
  1041. unsigned long block;
  1042. int err;
  1044. if (get_user(block, &user_result->lv_block))
  1045. return -EFAULT;
  1047. memset(&bh,0,sizeof bh);
  1048. bh.b_blocknr = block;
  1049. bh.b_dev = bh.b_rdev = inode->i_rdev;
  1050. bh.b_size = lvm_get_blksize(bh.b_dev);
  1051.   bh.b_rsector = block * (bh.b_size >> 9);
  1052. if ((err=lvm_map(&bh, READ)) < 0)  {
  1053. printk("lvm map failed: %dn", err);
  1054. return -EINVAL;
  1055. }
  1057. return put_user(kdev_t_to_nr(bh.b_rdev), &user_result->lv_dev) ||
  1058.        put_user(bh.b_rsector/(bh.b_size>>9), &user_result->lv_block) ?
  1059.        -EFAULT : 0;
  1060. }
  1063. /*
  1064.  * block device support function for /usr/src/linux/drivers/block/ll_rw_blk.c
  1065.  * (see init_module/lvm_init)
  1066.  */
  1067. static void __remap_snapshot(kdev_t rdev, ulong rsector,
  1068.      ulong pe_start, lv_t *lv, vg_t *vg) {
  1070. /* copy a chunk from the origin to a snapshot device */
  1071. down_write(&lv->lv_lock);
  1073. /* we must redo lvm_snapshot_remap_block in order to avoid a
  1074.    race condition in the gap where no lock was held */
  1075. if (!lvm_snapshot_remap_block(&rdev, &rsector, pe_start, lv) &&
  1076.     !lvm_snapshot_COW(rdev, rsector, pe_start, rsector, vg, lv))
  1077. lvm_write_COW_table_block(vg, lv);
  1079. up_write(&lv->lv_lock);
  1080. }
  1082. static inline void _remap_snapshot(kdev_t rdev, ulong rsector,
  1083.    ulong pe_start, lv_t *lv, vg_t *vg) {
  1084. int r;
  1086. /* check to see if this chunk is already in the snapshot */
  1087. down_read(&lv->lv_lock);
  1088. r = lvm_snapshot_remap_block(&rdev, &rsector, pe_start, lv);
  1089. up_read(&lv->lv_lock);
  1091. if (!r)
  1092. /* we haven't yet copied this block to the snapshot */
  1093. __remap_snapshot(rdev, rsector, pe_start, lv, vg);
  1094. }
  1097. /*
  1098.  * extents destined for a pe that is on the move should be deferred
  1099.  */
  1100. static inline int _should_defer(kdev_t pv, ulong sector, uint32_t pe_size) {
  1101. return ((pe_lock_req.lock == LOCK_PE) &&
  1102. (pv == pe_lock_req.data.pv_dev) &&
  1103. (sector >= pe_lock_req.data.pv_offset) &&
  1104. (sector < (pe_lock_req.data.pv_offset + pe_size)));
  1105. }
  1107. static inline int _defer_extent(struct buffer_head *bh, int rw,
  1108. kdev_t pv, ulong sector, uint32_t pe_size)
  1109. {
  1110. if (pe_lock_req.lock == LOCK_PE) {
  1111. down_read(&_pe_lock);
  1112. if (_should_defer(pv, sector, pe_size)) {
  1113. up_read(&_pe_lock);
  1114. down_write(&_pe_lock);
  1115. if (_should_defer(pv, sector, pe_size))
  1116. _queue_io(bh, rw);
  1117. up_write(&_pe_lock);
  1118. return 1;
  1119. }
  1120. up_read(&_pe_lock);
  1121. }
  1122. return 0;
  1123. }
  1125. static int lvm_map(struct buffer_head *bh, int rw)
  1126. {
  1127. int minor = MINOR(bh->b_rdev);
  1128. ulong index;
  1129. ulong pe_start;
  1130. ulong size = bh->b_size >> 9;
  1131. ulong rsector_org = bh->b_rsector;
  1132. ulong rsector_map;
  1133. kdev_t rdev_map;
  1134. vg_t *vg_this = vg[VG_BLK(minor)];
  1135. lv_t *lv = vg_this->lv[LV_BLK(minor)];
  1138. down_read(&lv->lv_lock);
  1139. if (!(lv->lv_status & LV_ACTIVE)) {
  1140. printk(KERN_ALERT
  1141.        "%s - lvm_map: ll_rw_blk for inactive LV %sn",
  1142.        lvm_name, lv->lv_name);
  1143. goto bad;
  1144. }
  1146. if ((rw == WRITE || rw == WRITEA) &&
  1147.     !(lv->lv_access & LV_WRITE)) {
  1148. printk(KERN_CRIT
  1149.        "%s - lvm_map: ll_rw_blk write for readonly LV %sn",
  1150.        lvm_name, lv->lv_name);
  1151. goto bad;
  1152. }
  1154. P_MAP("%s - lvm_map minor: %d  *rdev: %s  *rsector: %lu  size:%lun",
  1155.       lvm_name, minor,
  1156.       kdevname(bh->b_rdev),
  1157.       rsector_org, size);
  1159. if (rsector_org + size > lv->lv_size) {
  1160. printk(KERN_ALERT
  1161.        "%s - lvm_map access beyond end of device; *rsector: "
  1162.                        "%lu or size: %lu wrong for minor: %2dn",
  1163.                        lvm_name, rsector_org, size, minor);
  1164. goto bad;
  1165. }
  1168. if (lv->lv_stripes < 2) { /* linear mapping */
  1169. /* get the index */
  1170. index = rsector_org / vg_this->pe_size;
  1171. pe_start = lv->lv_current_pe[index].pe;
  1172. rsector_map = lv->lv_current_pe[index].pe +
  1173. (rsector_org % vg_this->pe_size);
  1174. rdev_map = lv->lv_current_pe[index].dev;
  1176. P_MAP("lv_current_pe[%ld].pe: %d  rdev: %s  rsector:%ldn",
  1177.       index, lv->lv_current_pe[index].pe,
  1178.       kdevname(rdev_map), rsector_map);
  1180. } else { /* striped mapping */
  1181. ulong stripe_index;
  1182. ulong stripe_length;
  1184. stripe_length = vg_this->pe_size * lv->lv_stripes;
  1185. stripe_index = (rsector_org % stripe_length) /
  1186. lv->lv_stripesize;
  1187. index = rsector_org / stripe_length +
  1188. (stripe_index % lv->lv_stripes) *
  1189. (lv->lv_allocated_le / lv->lv_stripes);
  1190. pe_start = lv->lv_current_pe[index].pe;
  1191. rsector_map = lv->lv_current_pe[index].pe +
  1192. (rsector_org % stripe_length) -
  1193. (stripe_index % lv->lv_stripes) * lv->lv_stripesize -
  1194. stripe_index / lv->lv_stripes *
  1195. (lv->lv_stripes - 1) * lv->lv_stripesize;
  1196. rdev_map = lv->lv_current_pe[index].dev;
  1198. P_MAP("lv_current_pe[%ld].pe: %d  rdev: %s  rsector:%ldn"
  1199.       "stripe_length: %ld  stripe_index: %ldn",
  1200.       index, lv->lv_current_pe[index].pe, kdevname(rdev_map),
  1201.       rsector_map, stripe_length, stripe_index);
  1202. }
  1204. /*
  1205.  * Queue writes to physical extents on the move until move completes.
  1206.  * Don't get _pe_lock until there is a reasonable expectation that
  1207.  * we need to queue this request, because this is in the fast path.
  1208.  */
  1209. if (rw == WRITE || rw == WRITEA) {
  1210. if(_defer_extent(bh, rw, rdev_map,
  1211.  rsector_map, vg_this->pe_size)) {
  1213. up_read(&lv->lv_lock);
  1214. return 0;
  1215. }
  1217. lv->lv_current_pe[index].writes++; /* statistic */
  1218. } else
  1219. lv->lv_current_pe[index].reads++; /* statistic */
  1221. /* snapshot volume exception handling on physical device address base */
  1222. if (!(lv->lv_access & (LV_SNAPSHOT|LV_SNAPSHOT_ORG)))
  1223. goto out;
  1225. if (lv->lv_access & LV_SNAPSHOT) { /* remap snapshot */
  1226. if (lv->lv_block_exception)
  1227. lvm_snapshot_remap_block(&rdev_map, &rsector_map,
  1228.  pe_start, lv);
  1229. else
  1230. goto bad;
  1232. } else if (rw == WRITE || rw == WRITEA) { /* snapshot origin */
  1233. lv_t *snap;
  1235. /* start with first snapshot and loop through all of
  1236.    them */
  1237. for (snap = lv->lv_snapshot_next; snap;
  1238.      snap = snap->lv_snapshot_next) {
  1239. /* Check for inactive snapshot */
  1240. if (!(snap->lv_status & LV_ACTIVE))
  1241. continue;
  1243. /* Serializes the COW with the accesses to the
  1244.    snapshot device */
  1245. _remap_snapshot(rdev_map, rsector_map,
  1246.  pe_start, snap, vg_this);
  1247. }
  1248.   }
  1250.  out:
  1251. bh->b_rdev = rdev_map;
  1252. bh->b_rsector = rsector_map;
  1253. up_read(&lv->lv_lock);
  1254. return 1;
  1256.  bad:
  1257. buffer_IO_error(bh);
  1258. up_read(&lv->lv_lock);
  1259. return -1;
  1260. } /* lvm_map() */
  1263. /*
  1264.  * internal support functions
  1265.  */
  1267. #ifdef LVM_HD_NAME
  1268. /*
  1269.  * generate "hard disk" name
  1270.  */
  1271. void lvm_hd_name(char *buf, int minor)
  1272. {
  1273. int len = 0;
  1274. lv_t *lv_ptr;
  1276. if (vg[VG_BLK(minor)] == NULL ||
  1277.     (lv_ptr = vg[VG_BLK(minor)]->lv[LV_BLK(minor)]) == NULL)
  1278. return;
  1279. len = strlen(lv_ptr->lv_name) - 5;
  1280. memcpy(buf, &lv_ptr->lv_name[5], len);
  1281. buf[len] = 0;
  1282. return;
  1283. }
  1284. #endif
  1287. /*
  1288.  * make request function
  1289.  */
  1290. static int lvm_make_request_fn(request_queue_t *q,
  1291.        int rw,
  1292.        struct buffer_head *bh) {
  1293. return (lvm_map(bh, rw) <= 0) ? 0 : 1;
  1294. }
  1297. /********************************************************************
  1298.  *
  1299.  * Character device support functions
  1300.  *
  1301.  ********************************************************************/
  1302. /*
  1303.  * character device support function logical volume manager lock
  1304.  */
  1305. static int lvm_do_lock_lvm(void)
  1306. {
  1307. lock_try_again:
  1308. spin_lock(&lvm_lock);
  1309. if (lock != 0 && lock != current->pid) {
  1310. P_DEV("lvm_do_lock_lvm: locked by pid %d ...n", lock);
  1311. spin_unlock(&lvm_lock);
  1312. interruptible_sleep_on(&lvm_wait);
  1313. if (current->sigpending != 0)
  1314. return -EINTR;
  1315. #ifdef LVM_TOTAL_RESET
  1316. if (lvm_reset_spindown > 0)
  1317. return -EACCES;
  1318. #endif
  1319. goto lock_try_again;
  1320. }
  1321. lock = current->pid;
  1322. P_DEV("lvm_do_lock_lvm: locking LVM for pid %dn", lock);
  1323. spin_unlock(&lvm_lock);
  1324. return 0;
  1325. } /* lvm_do_lock_lvm */
  1328. /*
  1329.  * character device support function lock/unlock physical extend
  1330.  */
  1331. static int lvm_do_pe_lock_unlock(vg_t *vg_ptr, void *arg)
  1332. {
  1333. pe_lock_req_t new_lock;
  1334. struct buffer_head *bh;
  1335. uint p;
  1337. if (vg_ptr == NULL) return -ENXIO;
  1338. if (copy_from_user(&new_lock, arg, sizeof(new_lock)) != 0)
  1339. return -EFAULT;
  1341. switch (new_lock.lock) {
  1342. case LOCK_PE:
  1343. for (p = 0; p < vg_ptr->pv_max; p++) {
  1344. if (vg_ptr->pv[p] != NULL &&
  1345.     new_lock.data.pv_dev == vg_ptr->pv[p]->pv_dev)
  1346. break;
  1347. }
  1348. if (p == vg_ptr->pv_max) return -ENXIO;
  1350. /*
  1351.  * this sync releaves memory pressure to lessen the
  1352.  * likelyhood of pvmove being paged out - resulting in
  1353.  * deadlock.
  1354.  *
  1355.  * This method of doing a pvmove is broken
  1356.  */
  1357. fsync_dev(pe_lock_req.data.lv_dev);
  1359. down_write(&_pe_lock);
  1360. if (pe_lock_req.lock == LOCK_PE) {
  1361. up_write(&_pe_lock);
  1362. return -EBUSY;
  1363. }
  1365. /* Should we do to_kdev_t() on the pv_dev and lv_dev??? */
  1366. pe_lock_req.lock = LOCK_PE;
  1367. pe_lock_req.data.lv_dev = new_lock.data.lv_dev;
  1368. pe_lock_req.data.pv_dev = new_lock.data.pv_dev;
  1369. pe_lock_req.data.pv_offset = new_lock.data.pv_offset;
  1370. up_write(&_pe_lock);
  1372. /* some requests may have got through since the fsync */
  1373. fsync_dev(pe_lock_req.data.pv_dev);
  1374. break;
  1376. case UNLOCK_PE:
  1377. down_write(&_pe_lock);
  1378. pe_lock_req.lock = UNLOCK_PE;
  1379. pe_lock_req.data.lv_dev = 0;
  1380. pe_lock_req.data.pv_dev = 0;
  1381. pe_lock_req.data.pv_offset = 0;
  1382. bh = _dequeue_io();
  1383. up_write(&_pe_lock);
  1385. /* handle all deferred io for this PE */
  1386. _flush_io(bh);
  1387. break;
  1389. default:
  1390. return -EINVAL;
  1391. }
  1392. return 0;
  1393. }
  1396. /*
  1397.  * character device support function logical extend remap
  1398.  */
  1399. static int lvm_do_le_remap(vg_t *vg_ptr, void *arg)
  1400. {
  1401. uint l, le;
  1402. lv_t *lv_ptr;
  1404. if (vg_ptr == NULL) return -ENXIO;
  1405. if (copy_from_user(&le_remap_req, arg,
  1406.    sizeof(le_remap_req_t)) != 0)
  1407. return -EFAULT;
  1409. for (l = 0; l < vg_ptr->lv_max; l++) {
  1410. lv_ptr = vg_ptr->lv[l];
  1411. if (lv_ptr != NULL &&
  1412.     strcmp(lv_ptr->lv_name,
  1413.        le_remap_req.lv_name) == 0) {
  1414. for (le = 0; le < lv_ptr->lv_allocated_le; le++) {
  1415. if (lv_ptr->lv_current_pe[le].dev ==
  1416.     le_remap_req.old_dev &&
  1417.     lv_ptr->lv_current_pe[le].pe ==
  1418.     le_remap_req.old_pe) {
  1419. lv_ptr->lv_current_pe[le].dev =
  1420.     le_remap_req.new_dev;
  1421. lv_ptr->lv_current_pe[le].pe =
  1422.     le_remap_req.new_pe;
  1424. __update_hardsectsize(lv_ptr);
  1425. return 0;
  1426. }
  1427. }
  1428. return -EINVAL;
  1429. }
  1430. }
  1431. return -ENXIO;
  1432. } /* lvm_do_le_remap() */
  1435. /*
  1436.  * character device support function VGDA create
  1437.  */
  1438. static int lvm_do_vg_create(void *arg, int minor)
  1439. {
  1440. int ret = 0;
  1441. ulong l, ls = 0, p, size;
  1442. lv_t lv;
  1443. vg_t *vg_ptr;
  1444. lv_t **snap_lv_ptr;
  1446. if ((vg_ptr = kmalloc(sizeof(vg_t),GFP_KERNEL)) == NULL) {
  1447. printk(KERN_CRIT
  1448.        "%s -- VG_CREATE: kmalloc error VG at line %dn",
  1449.        lvm_name, __LINE__);
  1450. return -ENOMEM;
  1451. }
  1452. /* get the volume group structure */
  1453. if (copy_from_user(vg_ptr, arg, sizeof(vg_t)) != 0) {
  1454. P_IOCTL("lvm_do_vg_create ERROR: copy VG ptr %p (%d bytes)n",
  1455. arg, sizeof(vg_t));
  1456. kfree(vg_ptr);
  1457. return -EFAULT;
  1458. }
  1460.         /* VG_CREATE now uses minor number in VG structure */
  1461.         if (minor == -1) minor = vg_ptr->vg_number;
  1463. /* Validate it */
  1464.         if (vg[VG_CHR(minor)] != NULL) {
  1465. P_IOCTL("lvm_do_vg_create ERROR: VG %d in usen", minor);
  1466. kfree(vg_ptr);
  1467.          return -EPERM;
  1468. }
  1470. /* we are not that active so far... */
  1471. vg_ptr->vg_status &= ~VG_ACTIVE;
  1472. vg_ptr->pe_allocated = 0;
  1474. if (vg_ptr->pv_max > ABS_MAX_PV) {
  1475. printk(KERN_WARNING
  1476.        "%s -- Can't activate VG: ABS_MAX_PV too smalln",
  1477.        lvm_name);
  1478. kfree(vg_ptr);
  1479. return -EPERM;
  1480. }
  1482. if (vg_ptr->lv_max > ABS_MAX_LV) {
  1483. printk(KERN_WARNING
  1484. "%s -- Can't activate VG: ABS_MAX_LV too small for %un",
  1485.        lvm_name, vg_ptr->lv_max);
  1486. kfree(vg_ptr);
  1487. return -EPERM;
  1488. }
  1490. /* create devfs and procfs entries */
  1491. lvm_fs_create_vg(vg_ptr);
  1493. vg[VG_CHR(minor)] = vg_ptr;
  1495. /* get the physical volume structures */
  1496. vg_ptr->pv_act = vg_ptr->pv_cur = 0;
  1497. for (p = 0; p < vg_ptr->pv_max; p++) {
  1498. pv_t *pvp;
  1499. /* user space address */
  1500. if ((pvp = vg_ptr->pv[p]) != NULL) {
  1501. ret = lvm_do_pv_create(pvp, vg_ptr, p);
  1502. if ( ret != 0) {
  1503. lvm_do_vg_remove(minor);
  1504. return ret;
  1505. }
  1506. }
  1507. }
  1509. size = vg_ptr->lv_max * sizeof(lv_t *);
  1510. if ((snap_lv_ptr = vmalloc ( size)) == NULL) {
  1511. printk(KERN_CRIT
  1512.        "%s -- VG_CREATE: vmalloc error snapshot LVs at line %dn",
  1513.        lvm_name, __LINE__);
  1514. lvm_do_vg_remove(minor);
  1515. return -EFAULT;
  1516. }
  1517. memset(snap_lv_ptr, 0, size);
  1519. /* get the logical volume structures */
  1520. vg_ptr->lv_cur = 0;
  1521. for (l = 0; l < vg_ptr->lv_max; l++) {
  1522. lv_t *lvp;
  1523. /* user space address */
  1524. if ((lvp = vg_ptr->lv[l]) != NULL) {
  1525. if (copy_from_user(&lv, lvp, sizeof(lv_t)) != 0) {
  1526. P_IOCTL("ERROR: copying LV ptr %p (%d bytes)n",
  1527. lvp, sizeof(lv_t));
  1528. lvm_do_vg_remove(minor);
  1529. return -EFAULT;
  1530. }
  1531. if ( lv.lv_access & LV_SNAPSHOT) {
  1532. snap_lv_ptr[ls] = lvp;
  1533. vg_ptr->lv[l] = NULL;
  1534. ls++;
  1535. continue;
  1536. }
  1537. vg_ptr->lv[l] = NULL;
  1538. /* only create original logical volumes for now */
  1539. if (lvm_do_lv_create(minor, lv.lv_name, &lv) != 0) {
  1540. lvm_do_vg_remove(minor);
  1541. return -EFAULT;
  1542. }
  1543. }
  1544. }
  1546. /* Second path to correct snapshot logical volumes which are not
  1547.    in place during first path above */
  1548. for (l = 0; l < ls; l++) {
  1549. lv_t *lvp = snap_lv_ptr[l];
  1550. if (copy_from_user(&lv, lvp, sizeof(lv_t)) != 0) {
  1551. lvm_do_vg_remove(minor);
  1552. return -EFAULT;
  1553. }
  1554. if (lvm_do_lv_create(minor, lv.lv_name, &lv) != 0) {
  1555. lvm_do_vg_remove(minor);
  1556. return -EFAULT;
  1557. }
  1558. }
  1560. vfree(snap_lv_ptr);
  1562. vg_count++;
  1565. MOD_INC_USE_COUNT;
  1567. /* let's go active */
  1568. vg_ptr->vg_status |= VG_ACTIVE;
  1570. return 0;
  1571. } /* lvm_do_vg_create() */
  1574. /*
  1575.  * character device support function VGDA extend
  1576.  */
  1577. static int lvm_do_vg_extend(vg_t *vg_ptr, void *arg)
  1578. {
  1579. int ret = 0;
  1580. uint p;
  1581. pv_t *pv_ptr;
  1583. if (vg_ptr == NULL) return -ENXIO;
  1584. if (vg_ptr->pv_cur < vg_ptr->pv_max) {
  1585. for (p = 0; p < vg_ptr->pv_max; p++) {
  1586. if ( ( pv_ptr = vg_ptr->pv[p]) == NULL) {
  1587. ret = lvm_do_pv_create(arg, vg_ptr, p);
  1588. if ( ret != 0) return ret;
  1589. pv_ptr = vg_ptr->pv[p];
  1590. vg_ptr->pe_total += pv_ptr->pe_total;
  1591. return 0;
  1592. }
  1593. }
  1594. }
  1595. return -EPERM;
  1596. } /* lvm_do_vg_extend() */
  1599. /*
  1600.  * character device support function VGDA reduce
  1601.  */
  1602. static int lvm_do_vg_reduce(vg_t *vg_ptr, void *arg) {
  1603. uint p;
  1604. pv_t *pv_ptr;
  1606. if (vg_ptr == NULL) return -ENXIO;
  1607. if (copy_from_user(pv_name, arg, sizeof(pv_name)) != 0)
  1608. return -EFAULT;
  1610. for (p = 0; p < vg_ptr->pv_max; p++) {
  1611. pv_ptr = vg_ptr->pv[p];
  1612. if (pv_ptr != NULL &&
  1613.     strcmp(pv_ptr->pv_name,
  1614.        pv_name) == 0) {
  1615. if (pv_ptr->lv_cur > 0) return -EPERM;
  1616. lvm_do_pv_remove(vg_ptr, p);
  1617. /* Make PV pointer array contiguous */
  1618. for (; p < vg_ptr->pv_max - 1; p++)
  1619. vg_ptr->pv[p] = vg_ptr->pv[p + 1];
  1620. vg_ptr->pv[p + 1] = NULL;
  1621. return 0;
  1622. }
  1623. }
  1624. return -ENXIO;
  1625. } /* lvm_do_vg_reduce */
  1628. /*
  1629.  * character device support function VG rename
  1630.  */
  1631. static int lvm_do_vg_rename(vg_t *vg_ptr, void *arg)
  1632. {
  1633. int l = 0, p = 0, len = 0;
  1634. char vg_name[NAME_LEN] = { 0,};
  1635. char lv_name[NAME_LEN] = { 0,};
  1636. char *ptr = NULL;
  1637. lv_t *lv_ptr = NULL;
  1638. pv_t *pv_ptr = NULL;
  1640. if (vg_ptr == NULL) return -ENXIO;
  1642. if (copy_from_user(vg_name, arg, sizeof(vg_name)) != 0)
  1643. return -EFAULT;
  1645. lvm_fs_remove_vg(vg_ptr);
  1647. strncpy ( vg_ptr->vg_name, vg_name, sizeof ( vg_name)-1);
  1648. for ( l = 0; l < vg_ptr->lv_max; l++)
  1649. {
  1650. if ((lv_ptr = vg_ptr->lv[l]) == NULL) continue;
  1651. strncpy(lv_ptr->vg_name, vg_name, sizeof ( vg_name));
  1652. ptr = strrchr(lv_ptr->lv_name, '/');
  1653. if (ptr == NULL) ptr = lv_ptr->lv_name;
  1654. strncpy(lv_name, ptr, sizeof ( lv_name));
  1655. len = sizeof(LVM_DIR_PREFIX);
  1656. strcpy(lv_ptr->lv_name, LVM_DIR_PREFIX);
  1657. strncat(lv_ptr->lv_name, vg_name, NAME_LEN - len);
  1658. len += strlen ( vg_name);
  1659. strncat(lv_ptr->lv_name, lv_name, NAME_LEN - len);
  1660. }
  1661. for ( p = 0; p < vg_ptr->pv_max; p++)
  1662. {
  1663. if ( (pv_ptr = vg_ptr->pv[p]) == NULL) continue;
  1664. strncpy(pv_ptr->vg_name, vg_name, NAME_LEN);
  1665. }
  1667. lvm_fs_create_vg(vg_ptr);
  1669. return 0;
  1670. } /* lvm_do_vg_rename */
  1673. /*
  1674.  * character device support function VGDA remove
  1675.  */
  1676. static int lvm_do_vg_remove(int minor)
  1677. {
  1678. int i;
  1679. vg_t *vg_ptr = vg[VG_CHR(minor)];
  1680. pv_t *pv_ptr;
  1682. if (vg_ptr == NULL) return -ENXIO;
  1684. #ifdef LVM_TOTAL_RESET
  1685. if (vg_ptr->lv_open > 0 && lvm_reset_spindown == 0)
  1686. #else
  1687. if (vg_ptr->lv_open > 0)
  1688. #endif
  1689. return -EPERM;
  1691. /* let's go inactive */
  1692. vg_ptr->vg_status &= ~VG_ACTIVE;
  1694. /* remove from procfs and devfs */
  1695. lvm_fs_remove_vg(vg_ptr);
  1697. /* free LVs */
  1698. /* first free snapshot logical volumes */
  1699. for (i = 0; i < vg_ptr->lv_max; i++) {
  1700. if (vg_ptr->lv[i] != NULL &&
  1701.     vg_ptr->lv[i]->lv_access & LV_SNAPSHOT) {
  1702. lvm_do_lv_remove(minor, NULL, i);
  1703. current->state = TASK_UNINTERRUPTIBLE;
  1704. schedule_timeout(1);
  1705. }
  1706. }
  1707. /* then free the rest of the LVs */
  1708. for (i = 0; i < vg_ptr->lv_max; i++) {
  1709. if (vg_ptr->lv[i] != NULL) {
  1710. lvm_do_lv_remove(minor, NULL, i);
  1711. current->state = TASK_UNINTERRUPTIBLE;
  1712. schedule_timeout(1);
  1713. }
  1714. }
  1716. /* free PVs */
  1717. for (i = 0; i < vg_ptr->pv_max; i++) {
  1718. if ((pv_ptr = vg_ptr->pv[i]) != NULL) {
  1719. P_KFREE("%s -- kfree %dn", lvm_name, __LINE__);
  1720. lvm_do_pv_remove(vg_ptr, i);
  1721. }
  1722. }
  1724. P_KFREE("%s -- kfree %dn", lvm_name, __LINE__);
  1725. kfree(vg_ptr);
  1726. vg[VG_CHR(minor)] = NULL;
  1728. vg_count--;
  1730. MOD_DEC_USE_COUNT;
  1732. return 0;
  1733. } /* lvm_do_vg_remove() */
  1736. /*
  1737.  * character device support function physical volume create
  1738.  */
  1739. static int lvm_do_pv_create(pv_t *pvp, vg_t *vg_ptr, ulong p) {
  1740. pv_t *pv;
  1741. int err;
  1743. pv = kmalloc(sizeof(pv_t),GFP_KERNEL);
  1744. if (pv == NULL) {
  1745. printk(KERN_CRIT
  1746.        "%s -- PV_CREATE: kmalloc error PV at line %dn",
  1747.        lvm_name, __LINE__);
  1748. return -ENOMEM;
  1749. }
  1751. memset(pv, 0, sizeof(*pv));
  1753. if (copy_from_user(pv, pvp, sizeof(pv_t)) != 0) {
  1754. P_IOCTL("lvm_do_pv_create ERROR: copy PV ptr %p (%d bytes)n",
  1755. pvp, sizeof(pv_t));
  1756. kfree(pv);
  1757. return -EFAULT;
  1758. }
  1760. if ((err = _open_pv(pv))) {
  1761. kfree(pv);
  1762. return err;
  1763. }
  1765. /* We don't need the PE list
  1766.    in kernel space as with LVs pe_t list (see below) */
  1767. pv->pe = NULL;
  1768. pv->pe_allocated = 0;
  1769. pv->pv_status = PV_ACTIVE;
  1770. vg_ptr->pv_act++;
  1771. vg_ptr->pv_cur++;
  1772. lvm_fs_create_pv(vg_ptr, pv);
  1774. vg_ptr->pv[p] = pv;
  1775. return 0;
  1776. } /* lvm_do_pv_create() */
  1779. /*
  1780.  * character device support function physical volume remove
  1781.  */
  1782. static int lvm_do_pv_remove(vg_t *vg_ptr, ulong p) {
  1783. pv_t *pv = vg_ptr->pv[p];
  1785. lvm_fs_remove_pv(vg_ptr, pv);
  1787. vg_ptr->pe_total -= pv->pe_total;
  1788. vg_ptr->pv_cur--;
  1789. vg_ptr->pv_act--;
  1791. _close_pv(pv);
  1792. kfree(pv);
  1794. vg_ptr->pv[p] = NULL;
  1796. return 0;
  1797. }
  1800. static void __update_hardsectsize(lv_t *lv) {
  1801. int le, e;
  1802. int max_hardsectsize = 0, hardsectsize;
  1804. for (le = 0; le < lv->lv_allocated_le; le++) {
  1805. hardsectsize = get_hardsect_size(lv->lv_current_pe[le].dev);
  1806. if (hardsectsize == 0)
  1807. hardsectsize = 512;
  1808. if (hardsectsize > max_hardsectsize)
  1809. max_hardsectsize = hardsectsize;
  1810. }
  1812. /* only perform this operation on active snapshots */
  1813. if ((lv->lv_access & LV_SNAPSHOT) &&
  1814.     (lv->lv_status & LV_ACTIVE)) {
  1815. for (e = 0; e < lv->lv_remap_end; e++) {
  1816. hardsectsize = get_hardsect_size( lv->lv_block_exception[e].rdev_new);
  1817. if (hardsectsize == 0)
  1818. hardsectsize = 512;
  1819. if (hardsectsize > max_hardsectsize)
  1820. max_hardsectsize = hardsectsize;
  1821. }
  1822. }
  1824. lvm_hardsectsizes[MINOR(lv->lv_dev)] = max_hardsectsize;
  1825. }
  1827. /*
  1828.  * character device support function logical volume create
  1829.  */
  1830. static int lvm_do_lv_create(int minor, char *lv_name, lv_t *lv)
  1831. {
  1832. int e, ret, l, le, l_new, p, size, activate = 1;
  1833. ulong lv_status_save;
  1834. lv_block_exception_t *lvbe = lv->lv_block_exception;
  1835. vg_t *vg_ptr = vg[VG_CHR(minor)];
  1836. lv_t *lv_ptr = NULL;
  1837. pe_t *pep;
  1839. if (!(pep = lv->lv_current_pe))
  1840. return -EINVAL;
  1842. if (_sectors_to_k(lv->lv_chunk_size) > LVM_SNAPSHOT_MAX_CHUNK)
  1843. return -EINVAL;
  1845. for (l = 0; l < vg_ptr->lv_cur; l++) {
  1846. if (vg_ptr->lv[l] != NULL &&
  1847.     strcmp(vg_ptr->lv[l]->lv_name, lv_name) == 0)
  1848. return -EEXIST;
  1849. }
  1851. /* in case of lv_remove(), lv_create() pair */
  1852. l_new = -1;
  1853. if (vg_ptr->lv[lv->lv_number] == NULL)
  1854. l_new = lv->lv_number;
  1855. else {
  1856. for (l = 0; l < vg_ptr->lv_max; l++) {
  1857. if (vg_ptr->lv[l] == NULL)
  1858. if (l_new == -1) l_new = l;
  1859. }
  1860. }
  1861. if (l_new == -1) return -EPERM;
  1862. else             l = l_new;
  1864. if ((lv_ptr = kmalloc(sizeof(lv_t),GFP_KERNEL)) == NULL) {;
  1865. printk(KERN_CRIT "%s -- LV_CREATE: kmalloc error LV at line %dn",
  1866.        lvm_name, __LINE__);
  1867. return -ENOMEM;
  1868. }
  1869. /* copy preloaded LV */
  1870. memcpy((char *) lv_ptr, (char *) lv, sizeof(lv_t));
  1872. lv_status_save = lv_ptr->lv_status;
  1873. lv_ptr->lv_status &= ~LV_ACTIVE;
  1874. lv_ptr->lv_snapshot_org = NULL;
  1875. lv_ptr->lv_snapshot_prev = NULL;
  1876. lv_ptr->lv_snapshot_next = NULL;
  1877. lv_ptr->lv_block_exception = NULL;
  1878. lv_ptr->lv_iobuf = NULL;
  1879.        lv_ptr->lv_COW_table_iobuf = NULL;
  1880. lv_ptr->lv_snapshot_hash_table = NULL;
  1881. lv_ptr->lv_snapshot_hash_table_size = 0;
  1882. lv_ptr->lv_snapshot_hash_mask = 0;
  1883. init_rwsem(&lv_ptr->lv_lock);
  1885. lv_ptr->lv_snapshot_use_rate = 0;
  1887. vg_ptr->lv[l] = lv_ptr;
  1889. /* get the PE structures from user space if this
  1890.    is not a snapshot logical volume */
  1891. if (!(lv_ptr->lv_access & LV_SNAPSHOT)) {
  1892. size = lv_ptr->lv_allocated_le * sizeof(pe_t);
  1894. if ((lv_ptr->lv_current_pe = vmalloc(size)) == NULL) {
  1895. printk(KERN_CRIT
  1896.        "%s -- LV_CREATE: vmalloc error LV_CURRENT_PE of %d Byte "
  1897.        "at line %dn",
  1898.        lvm_name, size, __LINE__);
  1899. P_KFREE("%s -- kfree %dn", lvm_name, __LINE__);
  1900. kfree(lv_ptr);
  1901. vg_ptr->lv[l] = NULL;
  1902. return -ENOMEM;
  1903. }
  1904. if (copy_from_user(lv_ptr->lv_current_pe, pep, size)) {
  1905. P_IOCTL("ERROR: copying PE ptr %p (%d bytes)n",
  1906. pep, sizeof(size));
  1907. vfree(lv_ptr->lv_current_pe);
  1908. kfree(lv_ptr);
  1909. vg_ptr->lv[l] = NULL;
  1910. return -EFAULT;
  1911. }
  1912. /* correct the PE count in PVs */
  1913. for (le = 0; le < lv_ptr->lv_allocated_le; le++) {
  1914. vg_ptr->pe_allocated++;
  1915. for (p = 0; p < vg_ptr->pv_cur; p++) {
  1916. if (vg_ptr->pv[p]->pv_dev ==
  1917.     lv_ptr->lv_current_pe[le].dev)
  1918. vg_ptr->pv[p]->pe_allocated++;
  1919. }
  1920. }
  1921. } else {
  1922. /* Get snapshot exception data and block list */
  1923. if (lvbe != NULL) {
  1924. lv_ptr->lv_snapshot_org =
  1925.     vg_ptr->lv[LV_BLK(lv_ptr->lv_snapshot_minor)];
  1926. if (lv_ptr->lv_snapshot_org != NULL) {
  1927. size = lv_ptr->lv_remap_end * sizeof(lv_block_exception_t);
  1929. if(!size) {
  1930. printk(KERN_WARNING
  1931.        "%s -- zero length exception table requestedn",
  1932.        lvm_name);
  1933. kfree(lv_ptr);
  1934. return -EINVAL;
  1935. }
  1937. if ((lv_ptr->lv_block_exception = vmalloc(size)) == NULL) {
  1938. printk(KERN_CRIT
  1939.        "%s -- lvm_do_lv_create: vmalloc error LV_BLOCK_EXCEPTION "
  1940.        "of %d byte at line %dn",
  1941.        lvm_name, size, __LINE__);
  1942. P_KFREE("%s -- kfree %dn", lvm_name,
  1943. __LINE__);
  1944. kfree(lv_ptr);
  1945. vg_ptr->lv[l] = NULL;
  1946. return -ENOMEM;
  1947. }
  1948. if (copy_from_user(lv_ptr->lv_block_exception, lvbe, size)) {
  1949. vfree(lv_ptr->lv_block_exception);
  1950. kfree(lv_ptr);
  1951. vg_ptr->lv[l] = NULL;
  1952. return -EFAULT;
  1953. }
  1955. if(lv_ptr->lv_block_exception[0].rsector_org ==
  1956.    LVM_SNAPSHOT_DROPPED_SECTOR)
  1957. {
  1958. printk(KERN_WARNING
  1959.     "%s -- lvm_do_lv_create: snapshot has been dropped and will not be activatedn",
  1960.        lvm_name);
  1961. activate = 0;
  1962. }
  1965. /* point to the original logical volume */
  1966. lv_ptr = lv_ptr->lv_snapshot_org;
  1968. lv_ptr->lv_snapshot_minor = 0;
  1969. lv_ptr->lv_snapshot_org = lv_ptr;
  1970. /* our new one now back points to the previous last in the chain
  1971.    which can be the original logical volume */
  1972. lv_ptr = vg_ptr->lv[l];
  1973. /* now lv_ptr points to our new last snapshot logical volume */
  1974. lv_ptr->lv_current_pe = lv_ptr->lv_snapshot_org->lv_current_pe;
  1975. lv_ptr->lv_allocated_snapshot_le = lv_ptr->lv_allocated_le;
  1976. lv_ptr->lv_allocated_le = lv_ptr->lv_snapshot_org->lv_allocated_le;
  1977. lv_ptr->lv_current_le = lv_ptr->lv_snapshot_org->lv_current_le;
  1978. lv_ptr->lv_size = lv_ptr->lv_snapshot_org->lv_size;
  1979. lv_ptr->lv_stripes = lv_ptr->lv_snapshot_org->lv_stripes;
  1980. lv_ptr->lv_stripesize = lv_ptr->lv_snapshot_org->lv_stripesize;
  1982. /* Update the VG PE(s) used by snapshot reserve space. */
  1983. vg_ptr->pe_allocated += lv_ptr->lv_allocated_snapshot_le;
  1985. if ((ret = lvm_snapshot_alloc(lv_ptr)) != 0)
  1986. {
  1987. vfree(lv_ptr->lv_block_exception);
  1988. kfree(lv_ptr);
  1989. vg_ptr->lv[l] = NULL;
  1990. return ret;
  1991. }
  1992. for ( e = 0; e < lv_ptr->lv_remap_ptr; e++)
  1993. lvm_hash_link (lv_ptr->lv_block_exception + e,
  1994.        lv_ptr->lv_block_exception[e].rdev_org,
  1995.        lv_ptr->lv_block_exception[e].rsector_org, lv_ptr);
  1996. /* need to fill the COW exception table data
  1997.    into the page for disk i/o */
  1998.                                if(lvm_snapshot_fill_COW_page(vg_ptr, lv_ptr)) {
  1999.                                        kfree(lv_ptr);
  2000.                                        vg_ptr->lv[l] = NULL;
  2001.                                        return -EINVAL;
  2002.                                }
  2003. init_waitqueue_head(&lv_ptr->lv_snapshot_wait);
  2004. } else {
  2005. kfree(lv_ptr);
  2006. vg_ptr->lv[l] = NULL;
  2007. return -EFAULT;
  2008. }
  2009. } else {
  2010. kfree(vg_ptr->lv[l]);
  2011. vg_ptr->lv[l] = NULL;
  2012. return -EINVAL;
  2013. }
  2014. } /* if ( vg[VG_CHR(minor)]->lv[l]->lv_access & LV_SNAPSHOT) */
  2016. lv_ptr = vg_ptr->lv[l];
  2017. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].start_sect = 0;
  2018. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].nr_sects = lv_ptr->lv_size;
  2019. lvm_size[MINOR(lv_ptr->lv_dev)] = lv_ptr->lv_size >> 1;
  2020. vg_lv_map[MINOR(lv_ptr->lv_dev)].vg_number = vg_ptr->vg_number;
  2021. vg_lv_map[MINOR(lv_ptr->lv_dev)].lv_number = lv_ptr->lv_number;
  2022. LVM_CORRECT_READ_AHEAD(lv_ptr->lv_read_ahead);
  2023. vg_ptr->lv_cur++;
  2024. lv_ptr->lv_status = lv_status_save;
  2026. __update_hardsectsize(lv_ptr);
  2028. /* optionally add our new snapshot LV */
  2029. if (lv_ptr->lv_access & LV_SNAPSHOT) {
  2030. lv_t *org = lv_ptr->lv_snapshot_org, *last;
  2032. /* sync the original logical volume */
  2033. fsync_dev(org->lv_dev);
  2034. #ifdef LVM_VFS_ENHANCEMENT
  2035. /* VFS function call to sync and lock the filesystem */
  2036. fsync_dev_lockfs(org->lv_dev);
  2037. #endif
  2039. down_write(&org->lv_lock);
  2040. org->lv_access |= LV_SNAPSHOT_ORG;
  2041. lv_ptr->lv_access &= ~LV_SNAPSHOT_ORG; /* this can only hide an userspace bug */
  2043. /* Link in the list of snapshot volumes */
  2044. for (last = org; last->lv_snapshot_next; last = last->lv_snapshot_next);
  2045. lv_ptr->lv_snapshot_prev = last;
  2046. last->lv_snapshot_next = lv_ptr;
  2047. up_write(&org->lv_lock);
  2048. }
  2050. /* activate the logical volume */
  2051. if(activate)
  2052. lv_ptr->lv_status |= LV_ACTIVE;
  2053. else
  2054. lv_ptr->lv_status &= ~LV_ACTIVE;
  2056. if ( lv_ptr->lv_access & LV_WRITE)
  2057. set_device_ro(lv_ptr->lv_dev, 0);
  2058. else
  2059. set_device_ro(lv_ptr->lv_dev, 1);
  2061. #ifdef LVM_VFS_ENHANCEMENT
  2062. /* VFS function call to unlock the filesystem */
  2063. if (lv_ptr->lv_access & LV_SNAPSHOT)
  2064. unlockfs(lv_ptr->lv_snapshot_org->lv_dev);
  2065. #endif
  2067. lv_ptr->vg = vg_ptr;
  2069. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].de =
  2070. lvm_fs_create_lv(vg_ptr, lv_ptr);
  2072. return 0;
  2073. } /* lvm_do_lv_create() */
  2076. /*
  2077.  * character device support function logical volume remove
  2078.  */
  2079. static int lvm_do_lv_remove(int minor, char *lv_name, int l)
  2080. {
  2081. uint le, p;
  2082. vg_t *vg_ptr = vg[VG_CHR(minor)];
  2083. lv_t *lv_ptr;
  2085. if (l == -1) {
  2086. for (l = 0; l < vg_ptr->lv_max; l++) {
  2087. if (vg_ptr->lv[l] != NULL &&
  2088.     strcmp(vg_ptr->lv[l]->lv_name, lv_name) == 0) {
  2089. break;
  2090. }
  2091. }
  2092. }
  2093. if (l == vg_ptr->lv_max) return -ENXIO;
  2095. lv_ptr = vg_ptr->lv[l];
  2096. #ifdef LVM_TOTAL_RESET
  2097. if (lv_ptr->lv_open > 0 && lvm_reset_spindown == 0)
  2098. #else
  2099. if (lv_ptr->lv_open > 0)
  2100. #endif
  2101. return -EBUSY;
  2103. /* check for deletion of snapshot source while
  2104.    snapshot volume still exists */
  2105. if ((lv_ptr->lv_access & LV_SNAPSHOT_ORG) &&
  2106.     lv_ptr->lv_snapshot_next != NULL)
  2107. return -EPERM;
  2109. lvm_fs_remove_lv(vg_ptr, lv_ptr);
  2111. if (lv_ptr->lv_access & LV_SNAPSHOT) {
  2112. /*
  2113.  * Atomically make the the snapshot invisible
  2114.  * to the original lv before playing with it.
  2115.  */
  2116. lv_t * org = lv_ptr->lv_snapshot_org;
  2117. down_write(&org->lv_lock);
  2119. /* remove this snapshot logical volume from the chain */
  2120. lv_ptr->lv_snapshot_prev->lv_snapshot_next = lv_ptr->lv_snapshot_next;
  2121. if (lv_ptr->lv_snapshot_next != NULL) {
  2122. lv_ptr->lv_snapshot_next->lv_snapshot_prev =
  2123.     lv_ptr->lv_snapshot_prev;
  2124. }
  2126. /* no more snapshots? */
  2127. if (!org->lv_snapshot_next) {
  2128. org->lv_access &= ~LV_SNAPSHOT_ORG;
  2129. }
  2130. up_write(&org->lv_lock);
  2132. lvm_snapshot_release(lv_ptr);
  2134. /* Update the VG PE(s) used by snapshot reserve space. */
  2135. vg_ptr->pe_allocated -= lv_ptr->lv_allocated_snapshot_le;
  2136. }
  2138. lv_ptr->lv_status |= LV_SPINDOWN;
  2140. /* sync the buffers */
  2141. fsync_dev(lv_ptr->lv_dev);
  2143. lv_ptr->lv_status &= ~LV_ACTIVE;
  2145. /* invalidate the buffers */
  2146. invalidate_buffers(lv_ptr->lv_dev);
  2148. /* reset generic hd */
  2149. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].start_sect = -1;
  2150. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].nr_sects = 0;
  2151. lvm_gendisk.part[MINOR(lv_ptr->lv_dev)].de = 0;
  2152. lvm_size[MINOR(lv_ptr->lv_dev)] = 0;
  2154. /* reset VG/LV mapping */
  2155. vg_lv_map[MINOR(lv_ptr->lv_dev)].vg_number = ABS_MAX_VG;
  2156. vg_lv_map[MINOR(lv_ptr->lv_dev)].lv_number = -1;
  2158. /* correct the PE count in PVs if this is not a snapshot
  2159.            logical volume */
  2160. if (!(lv_ptr->lv_access & LV_SNAPSHOT)) {
  2161. /* only if this is no snapshot logical volume because
  2162.    we share the lv_current_pe[] structs with the
  2163.    original logical volume */
  2164. for (le = 0; le < lv_ptr->lv_allocated_le; le++) {
  2165. vg_ptr->pe_allocated--;
  2166. for (p = 0; p < vg_ptr->pv_cur; p++) {
  2167. if (vg_ptr->pv[p]->pv_dev ==
  2168.     lv_ptr->lv_current_pe[le].dev)
  2169. vg_ptr->pv[p]->pe_allocated--;
  2170. }
  2171. }
  2172. vfree(lv_ptr->lv_current_pe);
  2173. }
  2175. P_KFREE("%s -- kfree %dn", lvm_name, __LINE__);
  2176. kfree(lv_ptr);
  2177. vg_ptr->lv[l] = NULL;
  2178. vg_ptr->lv_cur--;
  2179. return 0;
  2180. } /* lvm_do_lv_remove() */
  2183. /*
  2184.  * logical volume extend / reduce
  2185.  */
  2186. static int __extend_reduce_snapshot(vg_t *vg_ptr, lv_t *old_lv, lv_t *new_lv) {
  2187.         ulong size;
  2188.         lv_block_exception_t *lvbe;
  2190.         if (!new_lv->lv_block_exception)
  2191.                 return -ENXIO;
  2193.         size = new_lv->lv_remap_end * sizeof(lv_block_exception_t);
  2194.         if ((lvbe = vmalloc(size)) == NULL) {
  2195.                 printk(KERN_CRIT
  2196.                        "%s -- lvm_do_lv_extend_reduce: vmalloc "
  2197.                        "error LV_BLOCK_EXCEPTION of %lu Byte at line %dn",
  2198.                        lvm_name, size, __LINE__);
  2199.                 return -ENOMEM;
  2200.         }
  2202.         if ((new_lv->lv_remap_end > old_lv->lv_remap_end) &&
  2203.             (copy_from_user(lvbe, new_lv->lv_block_exception, size))) {
  2204.                 vfree(lvbe);
  2205.                 return -EFAULT;
  2206.         }
  2207.         new_lv->lv_block_exception = lvbe;
  2209.         if (lvm_snapshot_alloc_hash_table(new_lv)) {
  2210.                 vfree(new_lv->lv_block_exception);
  2211.                 return -ENOMEM;
  2212.         }
  2214.         return 0;
  2215. }
  2217. static int __extend_reduce(vg_t *vg_ptr, lv_t *old_lv, lv_t *new_lv) {
  2218.         ulong size, l, p, end;
  2219.         pe_t *pe;
  2221.         /* allocate space for new pe structures */
  2222.         size = new_lv->lv_current_le * sizeof(pe_t);
  2223.         if ((pe = vmalloc(size)) == NULL) {
  2224.                 printk(KERN_CRIT
  2225.                        "%s -- lvm_do_lv_extend_reduce: "
  2226.                        "vmalloc error LV_CURRENT_PE of %lu Byte at line %dn",
  2227.                        lvm_name, size, __LINE__);
  2228.                 return -ENOMEM;
  2229.         }
  2231.         /* get the PE structures from user space */
  2232.         if (copy_from_user(pe, new_lv->lv_current_pe, size)) {
  2233.                 if(old_lv->lv_access & LV_SNAPSHOT)
  2234.                         vfree(new_lv->lv_snapshot_hash_table);
  2235.                 vfree(pe);
  2236.                 return -EFAULT;
  2237.         }
  2239.         new_lv->lv_current_pe = pe;
  2241.         /* reduce allocation counters on PV(s) */
  2242.         for (l = 0; l < old_lv->lv_allocated_le; l++) {
  2243.                 vg_ptr->pe_allocated--;
  2244.                 for (p = 0; p < vg_ptr->pv_cur; p++) {
  2245.                         if (vg_ptr->pv[p]->pv_dev ==
  2246.                             old_lv->lv_current_pe[l].dev) {
  2247.                                 vg_ptr->pv[p]->pe_allocated--;
  2248.                                 break;
  2249.                         }
  2250.                 }
  2251.         }
  2253.         /* extend the PE count in PVs */
  2254.         for (l = 0; l < new_lv->lv_allocated_le; l++) {
  2255.                 vg_ptr->pe_allocated++;
  2256.                 for (p = 0; p < vg_ptr->pv_cur; p++) {
  2257.                         if (vg_ptr->pv[p]->pv_dev ==
  2258.                             new_lv->lv_current_pe[l].dev) {
  2259.                                 vg_ptr->pv[p]->pe_allocated++;
  2260.                                 break;
  2261.                         }
  2262.                 }
  2263.         }
  2265.         /* save availiable i/o statistic data */
  2266.         if (old_lv->lv_stripes < 2) {   /* linear logical volume */
  2267.                 end = min(old_lv->lv_current_le, new_lv->lv_current_le);
  2268.                 for (l = 0; l < end; l++) {
  2269.                         new_lv->lv_current_pe[l].reads +=
  2270.                                 old_lv->lv_current_pe[l].reads;
  2272.                         new_lv->lv_current_pe[l].writes +=
  2273.                                 old_lv->lv_current_pe[l].writes;
  2274.                 }
  2276.         } else {                /* striped logical volume */
  2277.                 uint i, j, source, dest, end, old_stripe_size, new_stripe_size;
  2279.                 old_stripe_size = old_lv->lv_allocated_le / old_lv->lv_stripes;
  2280.                 new_stripe_size = new_lv->lv_allocated_le / new_lv->lv_stripes;
  2281.                 end = min(old_stripe_size, new_stripe_size);
  2283.                 for (i = source = dest = 0;
  2284.                      i < new_lv->lv_stripes; i++) {
  2285.                         for (j = 0; j < end; j++) {
  2286.                                 new_lv->lv_current_pe[dest + j].reads +=
  2287.                                     old_lv->lv_current_pe[source + j].reads;
  2288.                                 new_lv->lv_current_pe[dest + j].writes +=
  2289.                                     old_lv->lv_current_pe[source + j].writes;
  2290.                         }
  2291.                         source += old_stripe_size;
  2292.                         dest += new_stripe_size;
  2293.                 }
  2294.         }
  2296.         return 0;
  2297. }
  2299. static int lvm_do_lv_extend_reduce(int minor, char *lv_name, lv_t *new_lv)
  2300. {
  2301.         int r;
  2302.         ulong l, e, size;
  2303.         vg_t *vg_ptr = vg[VG_CHR(minor)];
  2304.         lv_t *old_lv;
  2305.         pe_t *pe;
  2307.         if ((pe = new_lv->lv_current_pe) == NULL)
  2308.                 return -EINVAL;
  2310.         for (l = 0; l < vg_ptr->lv_max; l++)
  2311.                 if (vg_ptr->lv[l] && !strcmp(vg_ptr->lv[l]->lv_name, lv_name))
  2312.                         break;
  2314.         if (l == vg_ptr->lv_max)
  2315.                 return -ENXIO;
  2317.         old_lv = vg_ptr->lv[l];
  2319. if (old_lv->lv_access & LV_SNAPSHOT) {
  2320. /* only perform this operation on active snapshots */
  2321. if (old_lv->lv_status & LV_ACTIVE)
  2322.                 r = __extend_reduce_snapshot(vg_ptr, old_lv, new_lv);
  2323.         else
  2324. r = -EPERM;
  2326. } else
  2327.                 r = __extend_reduce(vg_ptr, old_lv, new_lv);
  2329.         if(r)
  2330.                 return r;
  2332.         /* copy relevent fields */
  2333. down_write(&old_lv->lv_lock);
  2335.         if(new_lv->lv_access & LV_SNAPSHOT) {
  2336.                 size = (new_lv->lv_remap_end > old_lv->lv_remap_end) ?
  2337.                         old_lv->lv_remap_ptr : new_lv->lv_remap_end;
  2338.                 size *= sizeof(lv_block_exception_t);
  2339.                 memcpy(new_lv->lv_block_exception,
  2340.                        old_lv->lv_block_exception, size);
  2342.                 old_lv->lv_remap_end = new_lv->lv_remap_end;
  2343.                 old_lv->lv_block_exception = new_lv->lv_block_exception;
  2344.                 old_lv->lv_snapshot_hash_table =
  2345.                         new_lv->lv_snapshot_hash_table;
  2346.                 old_lv->lv_snapshot_hash_table_size =
  2347.                         new_lv->lv_snapshot_hash_table_size;
  2348.                 old_lv->lv_snapshot_hash_mask =
  2349.                         new_lv->lv_snapshot_hash_mask;
  2351.                 for (e = 0; e < new_lv->lv_remap_ptr; e++)
  2352.                         lvm_hash_link(new_lv->lv_block_exception + e,
  2353.                                       new_lv->lv_block_exception[e].rdev_org,
  2354.                                     new_lv->lv_block_exception[e].rsector_org,
  2355.                                       new_lv);
  2357.         } else {
  2359.                 vfree(old_lv->lv_current_pe);
  2360.                 vfree(old_lv->lv_snapshot_hash_table);
  2362.                 old_lv->lv_size = new_lv->lv_size;
  2363.                 old_lv->lv_allocated_le = new_lv->lv_allocated_le;
  2364.                 old_lv->lv_current_le = new_lv->lv_current_le;
  2365.                 old_lv->lv_current_pe = new_lv->lv_current_pe;
  2366.                 lvm_gendisk.part[MINOR(old_lv->lv_dev)].nr_sects =
  2367.                         old_lv->lv_size;
  2368.                 lvm_size[MINOR(old_lv->lv_dev)] = old_lv->lv_size >> 1;
  2370.                 if (old_lv->lv_access & LV_SNAPSHOT_ORG) {
  2371.                         lv_t *snap;
  2372.                         for(snap = old_lv->lv_snapshot_next; snap;
  2373.                             snap = snap->lv_snapshot_next) {
  2374. down_write(&snap->lv_lock);
  2375.                                 snap->lv_current_pe = old_lv->lv_current_pe;
  2376.                                 snap->lv_allocated_le =
  2377.                                         old_lv->lv_allocated_le;
  2378.                                 snap->lv_current_le = old_lv->lv_current_le;
  2379.                                 snap->lv_size = old_lv->lv_size;
  2381.                                 lvm_gendisk.part[MINOR(snap->lv_dev)].nr_sects
  2382.                                         = old_lv->lv_size;
  2383.                                 lvm_size[MINOR(snap->lv_dev)] =
  2384.                                         old_lv->lv_size >> 1;
  2385.                                 __update_hardsectsize(snap);
  2386. up_write(&snap->lv_lock);
  2387.                         }
  2388.                 }
  2389.         }
  2391.         __update_hardsectsize(old_lv);
  2392. up_write(&old_lv->lv_lock);
  2394.         return 0;
  2395. } /* lvm_do_lv_extend_reduce() */
  2398. /*
  2399.  * character device support function logical volume status by name
  2400.  */
  2401. static int lvm_do_lv_status_byname(vg_t *vg_ptr, void *arg)
  2402. {
  2403. uint l;
  2404. lv_status_byname_req_t lv_status_byname_req;
  2405. void *saved_ptr1;
  2406. void *saved_ptr2;
  2407. lv_t *lv_ptr;
  2409. if (vg_ptr == NULL) return -ENXIO;
  2410. if (copy_from_user(&lv_status_byname_req, arg,
  2411.    sizeof(lv_status_byname_req_t)) != 0)
  2412. return -EFAULT;
  2414. if (lv_status_byname_req.lv == NULL) return -EINVAL;
  2416. for (l = 0; l < vg_ptr->lv_max; l++) {
  2417. if ((lv_ptr = vg_ptr->lv[l]) != NULL &&
  2418.     strcmp(lv_ptr->lv_name,
  2419.    lv_status_byname_req.lv_name) == 0) {
  2420.         /* Save usermode pointers */
  2421.         if (copy_from_user(&saved_ptr1, &lv_status_byname_req.lv->lv_current_pe, sizeof(void*)) != 0)
  2422. return -EFAULT;
  2423. if (copy_from_user(&saved_ptr2, &lv_status_byname_req.lv->lv_block_exception, sizeof(void*)) != 0)
  2424.         return -EFAULT;
  2425.         if (copy_to_user(lv_status_byname_req.lv,
  2426.  lv_ptr,
  2427.  sizeof(lv_t)) != 0)
  2428. return -EFAULT;
  2430. if (saved_ptr1 != NULL) {
  2431. if (copy_to_user(saved_ptr1,
  2432.  lv_ptr->lv_current_pe,
  2433.  lv_ptr->lv_allocated_le *
  2434.          sizeof(pe_t)) != 0)
  2435. return -EFAULT;
  2436. }
  2437. /* Restore usermode pointers */
  2438. if (copy_to_user(&lv_status_byname_req.lv->lv_current_pe, &saved_ptr1, sizeof(void*)) != 0)
  2439.         return -EFAULT;
  2440. return 0;
  2441. }
  2442. }
  2443. return -ENXIO;
  2444. } /* lvm_do_lv_status_byname() */
  2447. /*
  2448.  * character device support function logical volume status by index
  2449.  */
  2450. static int lvm_do_lv_status_byindex(vg_t *vg_ptr,void *arg)
  2451. {
  2452. lv_status_byindex_req_t lv_status_byindex_req;
  2453. void *saved_ptr1;
  2454. void *saved_ptr2;
  2455. lv_t *lv_ptr;
  2457. if (vg_ptr == NULL) return -ENXIO;
  2458. if (copy_from_user(&lv_status_byindex_req, arg,
  2459.    sizeof(lv_status_byindex_req)) != 0)
  2460. return -EFAULT;
  2462. if (lv_status_byindex_req.lv == NULL)
  2463. return -EINVAL;
  2464. if (lv_status_byindex_req.lv_index <0 ||
  2465. lv_status_byindex_req.lv_index >= MAX_LV)
  2466. return -EINVAL;
  2467. if ( ( lv_ptr = vg_ptr->lv[lv_status_byindex_req.lv_index]) == NULL)
  2468. return -ENXIO;
  2470. /* Save usermode pointers */
  2471. if (copy_from_user(&saved_ptr1, &lv_status_byindex_req.lv->lv_current_pe, sizeof(void*)) != 0)
  2472.         return -EFAULT;
  2473. if (copy_from_user(&saved_ptr2, &lv_status_byindex_req.lv->lv_block_exception, sizeof(void*)) != 0)
  2474.         return -EFAULT;
  2476. if (copy_to_user(lv_status_byindex_req.lv, lv_ptr, sizeof(lv_t)) != 0)
  2477. return -EFAULT;
  2478. if (saved_ptr1 != NULL) {
  2479. if (copy_to_user(saved_ptr1,
  2480.  lv_ptr->lv_current_pe,
  2481.  lv_ptr->lv_allocated_le *
  2482.          sizeof(pe_t)) != 0)
  2483. return -EFAULT;
  2484. }
  2486. /* Restore usermode pointers */
  2487. if (copy_to_user(&lv_status_byindex_req.lv->lv_current_pe, &saved_ptr1, sizeof(void *)) != 0)
  2488.         return -EFAULT;
  2490. return 0;
  2491. } /* lvm_do_lv_status_byindex() */
  2494. /*
  2495.  * character device support function logical volume status by device number
  2496.  */
  2497. static int lvm_do_lv_status_bydev(vg_t * vg_ptr, void * arg) {
  2498. int l;
  2499. lv_status_bydev_req_t lv_status_bydev_req;
  2500. void *saved_ptr1;
  2501. void *saved_ptr2;
  2502. lv_t *lv_ptr;
  2504. if (vg_ptr == NULL) return -ENXIO;
  2505. if (copy_from_user(&lv_status_bydev_req, arg,
  2506.    sizeof(lv_status_bydev_req)) != 0)
  2507. return -EFAULT;
  2509. for ( l = 0; l < vg_ptr->lv_max; l++) {
  2510. if ( vg_ptr->lv[l] == NULL) continue;
  2511. if ( vg_ptr->lv[l]->lv_dev == lv_status_bydev_req.dev) break;
  2512. }
  2514. if ( l == vg_ptr->lv_max) return -ENXIO;
  2515. lv_ptr = vg_ptr->lv[l];
  2517. /* Save usermode pointers */
  2518. if (copy_from_user(&saved_ptr1, &lv_status_bydev_req.lv->lv_current_pe, sizeof(void*)) != 0)
  2519.         return -EFAULT;
  2520. if (copy_from_user(&saved_ptr2, &lv_status_bydev_req.lv->lv_block_exception, sizeof(void*)) != 0)
  2521.         return -EFAULT;
  2523. if (copy_to_user(lv_status_bydev_req.lv, lv_ptr, sizeof(lv_t)) != 0)
  2524. return -EFAULT;
  2525. if (saved_ptr1 != NULL) {
  2526. if (copy_to_user(saved_ptr1,
  2527.  lv_ptr->lv_current_pe,
  2528.  lv_ptr->lv_allocated_le *
  2529.          sizeof(pe_t)) != 0)
  2530. return -EFAULT;
  2531. }
  2532. /* Restore usermode pointers */
  2533. if (copy_to_user(&lv_status_bydev_req.lv->lv_current_pe, &saved_ptr1, sizeof(void *)) != 0)
  2534.         return -EFAULT;
  2536. return 0;
  2537. } /* lvm_do_lv_status_bydev() */
  2540. /*
  2541.  * character device support function rename a logical volume
  2542.  */
  2543. static int lvm_do_lv_rename(vg_t *vg_ptr, lv_req_t *lv_req, lv_t *lv)
  2544. {
  2545. int l = 0;
  2546. int ret = 0;
  2547. lv_t *lv_ptr = NULL;
  2549. for (l = 0; l < vg_ptr->lv_max; l++)
  2550. {
  2551. if ( (lv_ptr = vg_ptr->lv[l]) == NULL) continue;
  2552. if (lv_ptr->lv_dev == lv->lv_dev)
  2553. {
  2554. lvm_fs_remove_lv(vg_ptr, lv_ptr);
  2555. strncpy(lv_ptr->lv_name,
  2556. lv_req->lv_name,
  2557. NAME_LEN);
  2558. lvm_fs_create_lv(vg_ptr, lv_ptr);
  2559. break;
  2560. }
  2561. }
  2562. if (l == vg_ptr->lv_max) ret = -ENODEV;
  2564. return ret;
  2565. } /* lvm_do_lv_rename */
  2568. /*
  2569.  * character device support function physical volume change
  2570.  */
  2571. static int lvm_do_pv_change(vg_t *vg_ptr, void *arg)
  2572. {
  2573. uint p;
  2574. pv_t *pv_ptr;
  2575. struct block_device *bd;
  2577. if (vg_ptr == NULL) return -ENXIO;
  2578. if (copy_from_user(&pv_change_req, arg,
  2579.    sizeof(pv_change_req)) != 0)
  2580. return -EFAULT;
  2582. for (p = 0; p < vg_ptr->pv_max; p++) {
  2583. pv_ptr = vg_ptr->pv[p];
  2584. if (pv_ptr != NULL &&
  2585.     strcmp(pv_ptr->pv_name,
  2586.        pv_change_req.pv_name) == 0) {
  2588. bd = pv_ptr->bd;
  2589. if (copy_from_user(pv_ptr,
  2590.    pv_change_req.pv,
  2591.    sizeof(pv_t)) != 0)
  2592. return -EFAULT;
  2593. pv_ptr->bd = bd;
  2595. /* We don't need the PE list
  2596.    in kernel space as with LVs pe_t list */
  2597. pv_ptr->pe = NULL;
  2598. return 0;
  2599. }
  2600. }
  2601. return -ENXIO;
  2602. } /* lvm_do_pv_change() */
  2604. /*
  2605.  * character device support function get physical volume status
  2606.  */
  2607. static int lvm_do_pv_status(vg_t *vg_ptr, void *arg)
  2608. {
  2609. uint p;
  2610. pv_t *pv_ptr;
  2612. if (vg_ptr == NULL) return -ENXIO;
  2613. if (copy_from_user(&pv_status_req, arg,
  2614.    sizeof(pv_status_req)) != 0)
  2615. return -EFAULT;
  2617. for (p = 0; p < vg_ptr->pv_max; p++) {
  2618. pv_ptr = vg_ptr->pv[p];
  2619. if (pv_ptr != NULL &&
  2620.     strcmp(pv_ptr->pv_name,
  2621.        pv_status_req.pv_name) == 0) {
  2622. if (copy_to_user(pv_status_req.pv,
  2623.  pv_ptr,
  2624.          sizeof(pv_t)) != 0)
  2625. return -EFAULT;
  2626. return 0;
  2627. }
  2628. }
  2629. return -ENXIO;
  2630. } /* lvm_do_pv_status() */
  2632. /*
  2633.  * character device support function flush and invalidate all buffers of a PV
  2634.  */
  2635. static int lvm_do_pv_flush(void *arg)
  2636. {
  2637.        pv_flush_req_t pv_flush_req;
  2639.        if (copy_from_user(&pv_flush_req, arg,
  2640.                           sizeof(pv_flush_req)) != 0)
  2641.                return -EFAULT;
  2643.        fsync_dev(pv_flush_req.pv_dev);
  2644.        invalidate_buffers(pv_flush_req.pv_dev);
  2646.        return 0;
  2647. }
  2649. /*
  2650.  * support function initialize gendisk variables
  2651.  */
  2652. static void __init lvm_geninit(struct gendisk *lvm_gdisk)
  2653. {
  2654. int i = 0;
  2656. #ifdef DEBUG_GENDISK
  2657. printk(KERN_DEBUG "%s -- lvm_gendiskn", lvm_name);
  2658. #endif
  2660. for (i = 0; i < MAX_LV; i++) {
  2661. lvm_gendisk.part[i].start_sect = -1; /* avoid partition check */
  2662. lvm_size[i] = lvm_gendisk.part[i].nr_sects = 0;
  2663. lvm_blocksizes[i] = BLOCK_SIZE;
  2664. }
  2666. blk_size[MAJOR_NR] = lvm_size;
  2667. blksize_size[MAJOR_NR] = lvm_blocksizes;
  2668. hardsect_size[MAJOR_NR] = lvm_hardsectsizes;
  2670. return;
  2671. } /* lvm_gen_init() */
  2675. /* Must have down_write(_pe_lock) when we enqueue buffers */
  2676. static void _queue_io(struct buffer_head *bh, int rw) {
  2677. if (bh->b_reqnext) BUG();
  2678. bh->b_reqnext = _pe_requests;
  2679. _pe_requests = bh;
  2680. }
  2682. /* Must have down_write(_pe_lock) when we dequeue buffers */
  2683. static struct buffer_head *_dequeue_io(void)
  2684. {
  2685. struct buffer_head *bh = _pe_requests;
  2686. _pe_requests = NULL;
  2687. return bh;
  2688. }
  2690. /*
  2691.  * We do not need to hold _pe_lock to flush buffers.  bh should be taken from
  2692.  * _pe_requests under down_write(_pe_lock), and then _pe_requests can be set
  2693.  * NULL and we drop _pe_lock.  Any new buffers defered at this time will be
  2694.  * added to a new list, and the old buffers can have their I/O restarted
  2695.  * asynchronously.
  2696.  *
  2697.  * If, for some reason, the same PE is locked again before all of these writes
  2698.  * have finished, then these buffers will just be re-queued (i.e. no danger).
  2699.  */
  2700. static void _flush_io(struct buffer_head *bh)
  2701. {
  2702. while (bh) {
  2703. struct buffer_head *next = bh->b_reqnext;
  2704. bh->b_reqnext = NULL;
  2705. /* resubmit this buffer head */
  2706. generic_make_request(WRITE, bh);
  2707. bh = next;
  2708. }
  2709. }
  2711. /*
  2712.  * we must open the pv's before we use them
  2713.  */
  2714. static int _open_pv(pv_t *pv) {
  2715. int err;
  2716. struct block_device *bd;
  2718. if (!(bd = bdget(kdev_t_to_nr(pv->pv_dev))))
  2719. return -ENOMEM;
  2721. err = blkdev_get(bd, FMODE_READ|FMODE_WRITE, 0, BDEV_FILE);
  2722. if (err)
  2723. return err;
  2725. pv->bd = bd;
  2726. return 0;
  2727. }
  2729. static void _close_pv(pv_t *pv) {
  2730. if (pv) {
  2731. struct block_device *bdev = pv->bd;
  2732. pv->bd = NULL;
  2733. if (bdev)
  2734. blkdev_put(bdev, BDEV_FILE);
  2735. }
  2736. }
  2738. static unsigned long _sectors_to_k(unsigned long sect)
  2739. {
  2740. if(SECTOR_SIZE > 1024) {
  2741. return sect * (SECTOR_SIZE / 1024);
  2742. }
  2744. return sect / (1024 / SECTOR_SIZE);
  2745. }
  2747. module_init(lvm_init);
  2748. module_exit(lvm_cleanup);
  2749. MODULE_LICENSE("GPL");