diff -urN 2.4.1pre8/Documentation/Configure.help 2.4.1pre8-0.9.1-and-lvremove/Documentation/Configure.help --- 2.4.1pre8/Documentation/Configure.help Wed Jan 17 04:02:38 2001 +++ 2.4.1pre8-0.9.1-and-lvremove/Documentation/Configure.help Wed Jan 17 17:57:19 2001 @@ -1450,15 +1450,6 @@ want), say M here and read Documentation/modules.txt. The module will be called lvm-mod.o. -Logical Volume Manager /proc file system information -CONFIG_LVM_PROC_FS - If you say Y here, you are able to access overall Logical Volume - Manager, Volume Group, Logical and Physical Volume information in - /proc/lvm. - - To use this option, you have to check, that the "/proc file system - support" (CONFIG_PROC_FS) is enabled too. - Multiple devices driver support CONFIG_BLK_DEV_MD This driver lets you combine several hard disk partitions into one diff -urN 2.4.1pre8/drivers/md/Config.in 2.4.1pre8-0.9.1-and-lvremove/drivers/md/Config.in --- 2.4.1pre8/drivers/md/Config.in Thu Nov 16 15:37:28 2000 +++ 2.4.1pre8-0.9.1-and-lvremove/drivers/md/Config.in Wed Jan 17 17:57:32 2001 @@ -17,6 +17,5 @@ fi dep_tristate ' Logical volume manager (LVM) support' CONFIG_BLK_DEV_LVM $CONFIG_MD -dep_mbool ' LVM information in proc filesystem' CONFIG_LVM_PROC_FS $CONFIG_BLK_DEV_LVM endmenu diff -urN 2.4.1pre8/drivers/md/lvm-snap.c 2.4.1pre8-0.9.1-and-lvremove/drivers/md/lvm-snap.c --- 2.4.1pre8/drivers/md/lvm-snap.c Tue Jan 2 17:41:16 2001 +++ 2.4.1pre8-0.9.1-and-lvremove/drivers/md/lvm-snap.c Wed Jan 17 17:57:19 2001 @@ -214,10 +214,10 @@ memset(lv_COW_table, 0, blksize_snap); for ( ; is < lv_snap->lv_remap_ptr; is++, id++) { /* store new COW_table entry */ - lv_COW_table[id].pv_org_number = LVM_TO_DISK64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[is].rdev_org)); - lv_COW_table[id].pv_org_rsector = LVM_TO_DISK64(lv_snap->lv_block_exception[is].rsector_org); - lv_COW_table[id].pv_snap_number = LVM_TO_DISK64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[is].rdev_new)); - lv_COW_table[id].pv_snap_rsector = LVM_TO_DISK64(lv_snap->lv_block_exception[is].rsector_new); + lv_COW_table[id].pv_org_number = cpu_to_le64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[is].rdev_org)); + lv_COW_table[id].pv_org_rsector = cpu_to_le64(lv_snap->lv_block_exception[is].rsector_org); + lv_COW_table[id].pv_snap_number = cpu_to_le64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[is].rdev_new)); + lv_COW_table[id].pv_snap_rsector = cpu_to_le64(lv_snap->lv_block_exception[is].rsector_new); } } @@ -268,10 +268,10 @@ blocks[0] = (snap_pe_start + COW_table_sector_offset) >> (blksize_snap >> 10); /* store new COW_table entry */ - lv_COW_table[idx_COW_table].pv_org_number = LVM_TO_DISK64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[idx].rdev_org)); - lv_COW_table[idx_COW_table].pv_org_rsector = LVM_TO_DISK64(lv_snap->lv_block_exception[idx].rsector_org); - lv_COW_table[idx_COW_table].pv_snap_number = LVM_TO_DISK64(lvm_pv_get_number(vg, snap_phys_dev)); - lv_COW_table[idx_COW_table].pv_snap_rsector = LVM_TO_DISK64(lv_snap->lv_block_exception[idx].rsector_new); + lv_COW_table[idx_COW_table].pv_org_number = cpu_to_le64(lvm_pv_get_number(vg, lv_snap->lv_block_exception[idx].rdev_org)); + lv_COW_table[idx_COW_table].pv_org_rsector = cpu_to_le64(lv_snap->lv_block_exception[idx].rsector_org); + lv_COW_table[idx_COW_table].pv_snap_number = cpu_to_le64(lvm_pv_get_number(vg, snap_phys_dev)); + lv_COW_table[idx_COW_table].pv_snap_rsector = cpu_to_le64(lv_snap->lv_block_exception[idx].rsector_new); length_tmp = iobuf->length; iobuf->length = blksize_snap; diff -urN 2.4.1pre8/drivers/md/lvm.c 2.4.1pre8-0.9.1-and-lvremove/drivers/md/lvm.c --- 2.4.1pre8/drivers/md/lvm.c Tue Jan 2 17:41:16 2001 +++ 2.4.1pre8-0.9.1-and-lvremove/drivers/md/lvm.c Wed Jan 17 17:58:56 2001 @@ -139,6 +139,7 @@ * lvm_proc_get_global_info() * 02/11/2000 - implemented /proc/lvm/ hierarchy * 07/12/2000 - make sure lvm_make_request_fn returns correct value - 0 or 1 - NeilBrown + * 25/12/2000 - fix procfs #defines - Christoph Hellwig * */ @@ -224,22 +225,19 @@ static int lvm_chr_ioctl(struct inode *, struct file *, uint, ulong); -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS int lvm_proc_read_vg_info(char *, char **, off_t, int, int *, void *); int lvm_proc_read_lv_info(char *, char **, off_t, int, int *, void *); int lvm_proc_read_pv_info(char *, char **, off_t, int, int *, void *); static int lvm_proc_get_global_info(char *, char **, off_t, int, int *, void *); void lvm_do_create_proc_entry_of_vg ( vg_t *); -inline void lvm_do_remove_proc_entry_of_vg ( vg_t *); -inline void lvm_do_create_proc_entry_of_lv ( vg_t *, lv_t *); -inline void lvm_do_remove_proc_entry_of_lv ( vg_t *, lv_t *); -inline void lvm_do_create_proc_entry_of_pv ( vg_t *, pv_t *); -inline void lvm_do_remove_proc_entry_of_pv ( vg_t *, pv_t *); +void lvm_do_remove_proc_entry_of_vg ( vg_t *); +void lvm_do_create_proc_entry_of_lv ( vg_t *, lv_t *); +void lvm_do_remove_proc_entry_of_lv ( vg_t *, lv_t *); +void lvm_do_create_proc_entry_of_pv ( vg_t *, pv_t *); +void lvm_do_remove_proc_entry_of_pv ( vg_t *, pv_t *); #endif -#ifdef LVM_HD_NAME -void lvm_hd_name(char *, int); -#endif /* End external function prototypes */ @@ -288,9 +286,9 @@ static int lvm_do_vg_rename(vg_t *, void *); static int lvm_do_vg_remove(int); static void lvm_geninit(struct gendisk *); -#ifdef LVM_GET_INODE -static struct inode *lvm_get_inode(int); -void lvm_clear_inode(struct inode *); +static char *lvm_show_uuid ( char *); +#ifdef LVM_HD_NAME +void lvm_hd_name(char *, int); #endif /* END Internal function prototypes */ @@ -347,7 +345,7 @@ static spinlock_t lvm_lock = SPIN_LOCK_UNLOCKED; static spinlock_t lvm_snapshot_lock = SPIN_LOCK_UNLOCKED; -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS static struct proc_dir_entry *lvm_proc_dir = NULL; static struct proc_dir_entry *lvm_proc_vg_subdir = NULL; struct proc_dir_entry *pde = NULL; @@ -433,7 +431,7 @@ &lvm_chr_fops, NULL); #endif -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_proc_dir = create_proc_entry (LVM_DIR, S_IFDIR, &proc_root); if (lvm_proc_dir != NULL) { lvm_proc_vg_subdir = create_proc_entry (LVM_VG_SUBDIR, S_IFDIR, lvm_proc_dir); @@ -521,7 +519,7 @@ blksize_size[MAJOR_NR] = NULL; hardsect_size[MAJOR_NR] = NULL; -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS remove_proc_entry(LVM_GLOBAL, lvm_proc_dir); remove_proc_entry(LVM_VG_SUBDIR, lvm_proc_dir); remove_proc_entry(LVM_DIR, &proc_root); @@ -890,10 +888,11 @@ if (lv_ptr->lv_status & LV_SPINDOWN) return -EPERM; /* Check inactive LV and open for read/write */ - if (file->f_mode & O_RDWR) { - if (!(lv_ptr->lv_status & LV_ACTIVE)) return -EPERM; - if (!(lv_ptr->lv_access & LV_WRITE)) return -EACCES; - } + if (!(lv_ptr->lv_status & LV_ACTIVE)) + return -EPERM; + if (!(lv_ptr->lv_access & LV_WRITE) && + (file->f_mode & FMODE_WRITE)) + return -EACCES; #ifndef BLOCK_DEVICE_OPERATIONS file->f_op = &lvm_blk_fops; @@ -1263,7 +1262,7 @@ } -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS /* * Support functions /proc-Filesystem */ @@ -1452,8 +1451,6 @@ else return count; } /* lvm_proc_get_global_info() */ -#endif /* #if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS */ - /* * provide VG information @@ -1478,7 +1475,7 @@ sz += sprintf ( page+sz, "PE size: %u\n", vg->pe_size / 2); sz += sprintf ( page+sz, "PE total: %u\n", vg->pe_total); sz += sprintf ( page+sz, "PE allocated: %u\n", vg->pe_allocated); - sz += sprintf ( page+sz, "uuid: %s\n", vg->vg_uuid); + sz += sprintf ( page+sz, "uuid: %s\n", lvm_show_uuid(vg->vg_uuid)); return sz; } @@ -1525,12 +1522,12 @@ sz += sprintf ( page+sz, "PE allocated: %u\n", pv->pe_allocated); sz += sprintf ( page+sz, "device: %02u:%02u\n", MAJOR(pv->pv_dev), MINOR(pv->pv_dev)); - sz += sprintf ( page+sz, "uuid: %s\n", pv->pv_uuid); + sz += sprintf ( page+sz, "uuid: %s\n", lvm_show_uuid(pv->pv_uuid)); return sz; } - +#endif /* CONFIG_PROC_FS */ /* * block device support function for /usr/src/linux/drivers/block/ll_rw_blk.c @@ -1659,6 +1656,8 @@ if (lv->lv_access & (LV_SNAPSHOT|LV_SNAPSHOT_ORG)) { /* original logical volume */ if (lv->lv_access & LV_SNAPSHOT_ORG) { + /* Serializes the access to the lv_snapshot_next list */ + down(&lv->lv_snapshot_sem); if (rw == WRITE || rw == WRITEA) { lv_t *lv_ptr; @@ -1669,7 +1668,8 @@ lv_ptr = lv_ptr->lv_snapshot_next) { /* Check for inactive snapshot */ if (!(lv_ptr->lv_status & LV_ACTIVE)) continue; - down(&lv->lv_snapshot_org->lv_snapshot_sem); + /* Serializes the COW with the accesses to the snapshot device */ + down(&lv_ptr->lv_snapshot_sem); /* do we still have exception storage for this snapshot free? */ if (lv_ptr->lv_block_exception != NULL) { rdev_sav = rdev_tmp; @@ -1690,9 +1690,10 @@ rdev_tmp = rdev_sav; rsector_tmp = rsector_sav; } - up(&lv->lv_snapshot_org->lv_snapshot_sem); + up(&lv_ptr->lv_snapshot_sem); } } + up(&lv->lv_snapshot_sem); } else { /* remap snapshot logical volume */ down(&lv->lv_snapshot_sem); @@ -1989,7 +1990,7 @@ &lvm_chr_fops, NULL); #endif -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_create_proc_entry_of_vg ( vg_ptr); #endif @@ -2021,19 +2022,11 @@ for (p = 0; p < vg_ptr->pv_max; p++) { if ( ( pv_ptr = vg_ptr->pv[p]) == NULL) { ret = lvm_do_pv_create(arg, vg_ptr, p); - lvm_do_create_proc_entry_of_pv ( vg_ptr, pv_ptr); if ( ret != 0) return ret; - - /* We don't need the PE list - in kernel space like LVs pe_t list */ - pv_ptr->pe = NULL; - vg_ptr->pv_cur++; - vg_ptr->pv_act++; - vg_ptr->pe_total += - pv_ptr->pe_total; -#ifdef LVM_GET_INODE - /* insert a dummy inode for fs_may_mount */ - pv_ptr->inode = lvm_get_inode(pv_ptr->pv_dev); + pv_ptr = vg_ptr->pv[p] ; + vg_ptr->pe_total += pv_ptr->pe_total; +#ifdef CONFIG_PROC_FS + lvm_do_create_proc_entry_of_pv ( vg_ptr, pv_ptr); #endif return 0; } @@ -2060,10 +2053,6 @@ strcmp(pv_ptr->pv_name, pv_name) == 0) { if (pv_ptr->lv_cur > 0) return -EPERM; - vg_ptr->pe_total -= - pv_ptr->pe_total; - vg_ptr->pv_cur--; - vg_ptr->pv_act--; lvm_do_pv_remove(vg_ptr, p); /* Make PV pointer array contiguous */ for (; p < vg_ptr->pv_max - 1; p++) @@ -2091,7 +2080,7 @@ if (copy_from_user(vg_name, arg, sizeof(vg_name)) != 0) return -EFAULT; -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_remove_proc_entry_of_vg ( vg_ptr); #endif @@ -2115,7 +2104,7 @@ strncpy(pv_ptr->vg_name, vg_name, NAME_LEN); } -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_create_proc_entry_of_vg ( vg_ptr); #endif @@ -2179,7 +2168,7 @@ devfs_unregister (vg_devfs_handle[vg_ptr->vg_number]); #endif -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_remove_proc_entry_of_vg ( vg_ptr); #endif @@ -2222,11 +2211,6 @@ vg_ptr->pv_act++; vg_ptr->pv_cur++; -#ifdef LVM_GET_INODE - /* insert a dummy inode for fs_may_mount */ - pv_ptr->inode = lvm_get_inode(pv_ptr->pv_dev); -#endif - return 0; } /* lvm_do_pv_create() */ @@ -2237,16 +2221,13 @@ static int lvm_do_pv_remove(vg_t *vg_ptr, ulong p) { pv_t *pv_ptr = vg_ptr->pv[p]; -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_remove_proc_entry_of_pv ( vg_ptr, pv_ptr); #endif vg_ptr->pe_total -= pv_ptr->pe_total; vg_ptr->pv_cur--; vg_ptr->pv_act--; -#ifdef LVM_GET_INODE - lvm_clear_inode(pv_ptr->inode); -#endif kfree(pv_ptr); vg_ptr->pv[p] = NULL; @@ -2385,11 +2366,16 @@ lv_ptr->lv_snapshot_org = lv_ptr->lv_snapshot_prev->lv_snapshot_org; lv_ptr->lv_snapshot_next = NULL; 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[VG_CHR(minor)]->pe_allocated += lv_ptr->lv_allocated_snapshot_le; + if ((ret = lvm_snapshot_alloc(lv_ptr)) != 0) { vfree(lv_ptr->lv_block_exception); @@ -2442,22 +2428,27 @@ } #endif -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_create_proc_entry_of_lv ( vg_ptr, lv_ptr); #endif /* optionally add our new snapshot LV */ if (lv_ptr->lv_access & LV_SNAPSHOT) { + lv_t * org = lv_ptr->lv_snapshot_org, * last; /* sync the original logical volume */ - fsync_dev(lv_ptr->lv_snapshot_org->lv_dev); + fsync_dev(org->lv_dev); #ifdef LVM_VFS_ENHANCEMENT /* VFS function call to sync and lock the filesystem */ - fsync_dev_lockfs(lv_ptr->lv_snapshot_org->lv_dev); + fsync_dev_lockfs(org->lv_dev); #endif - lv_ptr->lv_snapshot_org->lv_access |= LV_SNAPSHOT_ORG; - lv_ptr->lv_access &= ~LV_SNAPSHOT_ORG; - /* put ourselve into the chain */ - lv_ptr->lv_snapshot_prev->lv_snapshot_next = lv_ptr; + down(&org->lv_snapshot_sem); + org->lv_access |= LV_SNAPSHOT_ORG; + 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); + lv_ptr->lv_snapshot_prev = last; + last->lv_snapshot_next = lv_ptr; + up(&org->lv_snapshot_sem); } /* activate the logical volume */ @@ -2513,6 +2504,31 @@ lv_ptr->lv_snapshot_next != NULL) return -EPERM; + if (lv_ptr->lv_access & LV_SNAPSHOT) { + /* + * Atomically make the the snapshot invisible + * to the original lv before playing with it. + */ + lv_t * org = lv_ptr->lv_snapshot_org; + down(&org->lv_snapshot_sem); + + /* remove this snapshot logical volume from the chain */ + 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; + } + up(&org->lv_snapshot_sem); + + /* no more snapshots? */ + if (!org->lv_snapshot_next) + org->lv_access &= ~LV_SNAPSHOT_ORG; + lvm_snapshot_release(lv_ptr); + + /* Update the VG PE(s) used by snapshot reserve space. */ + vg_ptr->pe_allocated -= lv_ptr->lv_allocated_snapshot_le; + } + lv_ptr->lv_status |= LV_SPINDOWN; /* sync the buffers */ @@ -2547,24 +2563,13 @@ } vfree(lv_ptr->lv_current_pe); /* LV_SNAPSHOT */ - } else { - /* remove this snapshot logical volume from the chain */ - 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; - } - /* no more snapshots? */ - if (lv_ptr->lv_snapshot_org->lv_snapshot_next == NULL) - lv_ptr->lv_snapshot_org->lv_access &= ~LV_SNAPSHOT_ORG; - lvm_snapshot_release(lv_ptr); } #ifdef CONFIG_DEVFS_FS devfs_unregister(lv_devfs_handle[lv_ptr->lv_number]); #endif -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_remove_proc_entry_of_lv ( vg_ptr, lv_ptr); #endif @@ -2648,7 +2653,7 @@ up(&lv_ptr->lv_snapshot_org->lv_snapshot_sem); vfree(lvbe_old); vfree(lvs_hash_table_old); - return 1; + return -ENOMEM; } for (e = 0; e < lv_ptr->lv_remap_ptr; e++) @@ -2714,9 +2719,6 @@ /* save # of old allocated logical extents */ old_allocated_le = lv_ptr->lv_allocated_le; - /* in case of shrinking -> let's flush */ - if ( end > lv->lv_current_le) fsync_dev(lv_ptr->lv_dev); - /* copy preloaded LV */ memcpy((char *) lv_ptr, (char *) lv, sizeof(lv_t)); @@ -2914,13 +2916,13 @@ if ( (lv_ptr = vg_ptr->lv[l]) == NULL) continue; if (lv_ptr->lv_dev == lv->lv_dev) { -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_remove_proc_entry_of_lv ( vg_ptr, lv_ptr); #endif strncpy(lv_ptr->lv_name, lv_req->lv_name, NAME_LEN); -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS +#ifdef CONFIG_PROC_FS lvm_do_create_proc_entry_of_lv ( vg_ptr, lv_ptr); #endif break; @@ -2939,9 +2941,6 @@ { uint p; pv_t *pv_ptr; -#ifdef LVM_GET_INODE - struct inode *inode_sav; -#endif if (vg_ptr == NULL) return -ENXIO; if (copy_from_user(&pv_change_req, arg, @@ -2953,9 +2952,6 @@ if (pv_ptr != NULL && strcmp(pv_ptr->pv_name, pv_change_req.pv_name) == 0) { -#ifdef LVM_GET_INODE - inode_sav = pv_ptr->inode; -#endif if (copy_from_user(pv_ptr, pv_change_req.pv, sizeof(pv_t)) != 0) @@ -2964,9 +2960,6 @@ /* We don't need the PE list in kernel space as with LVs pe_t list */ pv_ptr->pe = NULL; -#ifdef LVM_GET_INODE - pv_ptr->inode = inode_sav; -#endif return 0; } } @@ -3002,11 +2995,11 @@ } /* lvm_do_pv_status() */ - +#ifdef CONFIG_PROC_FS /* * create a /proc entry for a logical volume */ -inline void lvm_do_create_proc_entry_of_lv ( vg_t *vg_ptr, lv_t *lv_ptr) { +void lvm_do_create_proc_entry_of_lv ( vg_t *vg_ptr, lv_t *lv_ptr) { char *basename; if ( vg_ptr->lv_subdir_pde != NULL) { @@ -3021,12 +3014,10 @@ } } } - - /* * remove a /proc entry for a logical volume */ -inline void lvm_do_remove_proc_entry_of_lv ( vg_t *vg_ptr, lv_t *lv_ptr) { +void lvm_do_remove_proc_entry_of_lv ( vg_t *vg_ptr, lv_t *lv_ptr) { char *basename; if ( vg_ptr->lv_subdir_pde != NULL) { @@ -3038,16 +3029,21 @@ } + /* * create a /proc entry for a physical volume */ -inline void lvm_do_create_proc_entry_of_pv ( vg_t *vg_ptr, pv_t *pv_ptr) { +void lvm_do_create_proc_entry_of_pv ( vg_t *vg_ptr, pv_t *pv_ptr) { + int offset = 0; char *basename; + char buffer[NAME_LEN]; - basename = strrchr(pv_ptr->pv_name, '/'); - if (basename == NULL) basename = pv_ptr->pv_name; - else basename++; - pde = create_proc_entry(basename, S_IFREG, vg_ptr->pv_subdir_pde); + basename = pv_ptr->pv_name; + if (strncmp(basename, "/dev/", 5) == 0) offset = 5; + strncpy(buffer, basename + offset, sizeof(buffer)); + basename = buffer; + while ( ( basename = strchr ( basename, '/')) != NULL) *basename = '_'; + pde = create_proc_entry(buffer, S_IFREG, vg_ptr->pv_subdir_pde); if ( pde != NULL) { pde->read_proc = lvm_proc_read_pv_info; pde->data = pv_ptr; @@ -3058,7 +3054,7 @@ /* * remove a /proc entry for a physical volume */ -inline void lvm_do_remove_proc_entry_of_pv ( vg_t *vg_ptr, pv_t *pv_ptr) { +void lvm_do_remove_proc_entry_of_pv ( vg_t *vg_ptr, pv_t *pv_ptr) { char *basename; basename = strrchr(pv_ptr->pv_name, '/'); @@ -3074,7 +3070,6 @@ /* * create a /proc entry for a volume group */ -#if defined CONFIG_LVM_PROC_FS && defined CONFIG_PROC_FS void lvm_do_create_proc_entry_of_vg ( vg_t *vg_ptr) { int l, p; pv_t *pv_ptr; @@ -3090,23 +3085,24 @@ pde->read_proc = lvm_proc_read_vg_info; pde->data = vg_ptr; } - vg_ptr->lv_subdir_pde = - create_proc_entry(LVM_LV_SUBDIR, S_IFDIR, - vg_ptr->vg_dir_pde); - vg_ptr->pv_subdir_pde = - create_proc_entry(LVM_PV_SUBDIR, S_IFDIR, - vg_ptr->vg_dir_pde); - } - - if ( vg_ptr->pv_subdir_pde != NULL) { - for ( l = 0; l < vg_ptr->lv_max; l++) { - if ( ( lv_ptr = vg_ptr->lv[l]) == NULL) continue; - lvm_do_create_proc_entry_of_lv ( vg_ptr, lv_ptr); - } - for ( p = 0; p < vg_ptr->pv_max; p++) { - if ( ( pv_ptr = vg_ptr->pv[p]) == NULL) continue; - lvm_do_create_proc_entry_of_pv ( vg_ptr, pv_ptr); + pde = create_proc_entry(LVM_LV_SUBDIR, S_IFDIR, + vg_ptr->vg_dir_pde); + if ( pde != NULL) { + vg_ptr->lv_subdir_pde = pde; + for ( l = 0; l < vg_ptr->lv_max; l++) { + if ( ( lv_ptr = vg_ptr->lv[l]) == NULL) continue; + lvm_do_create_proc_entry_of_lv ( vg_ptr, lv_ptr); + } } + pde = create_proc_entry(LVM_PV_SUBDIR, S_IFDIR, + vg_ptr->vg_dir_pde); + if ( pde != NULL) { + vg_ptr->pv_subdir_pde = pde; + for ( p = 0; p < vg_ptr->pv_max; p++) { + if ( ( pv_ptr = vg_ptr->pv[p]) == NULL) continue; + lvm_do_create_proc_entry_of_pv ( vg_ptr, pv_ptr); + } + } } } @@ -3133,8 +3129,7 @@ remove_proc_entry(vg_ptr->vg_name, lvm_proc_vg_subdir); } } -#endif - +#endif /* CONFIG_PROC_FS */ /* * support function initialize gendisk variables @@ -3166,39 +3161,24 @@ } /* lvm_gen_init() */ -#ifdef LVM_GET_INODE -/* - * support function to get an empty inode - * - * Gets an empty inode to be inserted into the inode hash, - * so that a physical volume can't be mounted. - * This is analog to drivers/block/md.c - * - * Is this the real thing? - * - */ -struct inode *lvm_get_inode(int dev) -{ - struct inode *inode_this = NULL; +static char *lvm_show_uuid ( char *uuidstr) { + int i, j; + static char uuid[NAME_LEN] = { 0, }; - /* Lock the device by inserting a dummy inode. */ - inode_this = get_empty_inode(); - inode_this->i_dev = dev; - insert_inode_hash(inode_this); - return inode_this; -} + memset ( uuid, 0, NAME_LEN); + i = 6; + memcpy ( uuid, uuidstr, i); + uuidstr += i; -/* - * support function to clear an inode - * - */ -void lvm_clear_inode(struct inode *inode) -{ -#ifdef I_FREEING - inode->i_state |= I_FREEING; -#endif - clear_inode(inode); - return; + for ( j = 0; j < 6; j++) { + uuid[i++] = '-'; + memcpy ( &uuid[i], uuidstr, 4); + uuidstr += 4; + i += 4; + } + + memcpy ( &uuid[i], uuidstr, 2 ); + + return uuid; } -#endif /* #ifdef LVM_GET_INODE */ diff -urN 2.4.1pre8/include/linux/lvm.h 2.4.1pre8-0.9.1-and-lvremove/include/linux/lvm.h --- 2.4.1pre8/include/linux/lvm.h Tue Jan 16 18:07:05 2001 +++ 2.4.1pre8-0.9.1-and-lvremove/include/linux/lvm.h Wed Jan 17 17:58:56 2001 @@ -57,6 +57,8 @@ * 26/06/2000 - implemented snapshot persistency and resizing support * 02/11/2000 - added hash table size member to lv structure * 12/11/2000 - removed unneeded timestamp definitions + * 24/12/2000 - removed LVM_TO_{CORE,DISK}*, use cpu_{from, to}_le* + * instead - Christoph Hellwig * */ @@ -68,7 +70,6 @@ #include #include -#include /* * preprocessor definitions @@ -77,7 +78,6 @@ #define LVM_TOTAL_RESET #ifdef __KERNEL__ -#define LVM_GET_INODE #undef LVM_HD_NAME /* display nice names in /proc/partitions */ /* lots of debugging output (see driver source) @@ -326,51 +326,6 @@ COW_table_entries_per_PE - COW_table_chunks_per_PE;}) -/* to disk and to core data conversion macros */ -#if __BYTE_ORDER == __BIG_ENDIAN - -#define LVM_TO_CORE16(x) ( \ - ((uint16_t)((((uint16_t)(x) & 0x00FFU) << 8) | \ - (((uint16_t)(x) & 0xFF00U) >> 8)))) - -#define LVM_TO_DISK16(x) LVM_TO_CORE16(x) - -#define LVM_TO_CORE32(x) ( \ - ((uint32_t)((((uint32_t)(x) & 0x000000FFU) << 24) | \ - (((uint32_t)(x) & 0x0000FF00U) << 8))) \ - (((uint32_t)(x) & 0x00FF0000U) >> 8))) \ - (((uint32_t)(x) & 0xFF000000U) >> 24)))) - -#define LVM_TO_DISK32(x) LVM_TO_CORE32(x) - -#define LVM_TO_CORE64(x) \ - ((uint64_t)((((uint64_t)(x) & 0x00000000000000FFULL) << 56) | \ - (((uint64_t)(x) & 0x000000000000FF00ULL) << 40) | \ - (((uint64_t)(x) & 0x0000000000FF0000ULL) << 24) | \ - (((uint64_t)(x) & 0x00000000FF000000ULL) << 8) | \ - (((uint64_t)(x) & 0x000000FF00000000ULL) >> 8) | \ - (((uint64_t)(x) & 0x0000FF0000000000ULL) >> 24) | \ - (((uint64_t)(x) & 0x00FF000000000000ULL) >> 40) | \ - (((uint64_t)(x) & 0xFF00000000000000ULL) >> 56))) - -#define LVM_TO_DISK64(x) LVM_TO_CORE64(x) - -#elif __BYTE_ORDER == __LITTLE_ENDIAN - -#define LVM_TO_CORE16(x) x -#define LVM_TO_DISK16(x) x -#define LVM_TO_CORE32(x) x -#define LVM_TO_DISK32(x) x -#define LVM_TO_CORE64(x) x -#define LVM_TO_DISK64(x) x - -#else - -#error "__BYTE_ORDER must be defined as __LITTLE_ENDIAN or __BIG_ENDIAN" - -#endif /* #if __BYTE_ORDER == __BIG_ENDIAN */ - - /* * ioctls */ @@ -687,6 +642,8 @@ wait_queue_head_t lv_snapshot_wait; int lv_snapshot_use_rate; void *vg; + + uint lv_allocated_snapshot_le; #else char dummy[200]; #endif