2001-10-09 18:26:45 +04:00
/*
* Copyright ( C ) 2001 Sistina Software ( UK ) Limited .
*
2001-10-31 20:59:52 +03:00
* Translates between disk and in - core formats .
*
2001-10-31 15:47:01 +03:00
* This file is released under the LGPL .
2001-10-09 18:26:45 +04:00
*/
# include "disk-rep.h"
# include "dbg_malloc.h"
# include "pool.h"
# include "hash.h"
# include "list.h"
# include "log.h"
2002-01-29 20:23:33 +03:00
# include "lvm-string.h"
2001-10-09 18:26:45 +04:00
2001-10-11 17:22:51 +04:00
# include <time.h>
# include <sys/utsname.h>
2001-10-10 13:25:04 +04:00
2001-10-09 18:26:45 +04:00
static int _check_vg_name ( const char * name )
{
return strlen ( name ) < NAME_LEN ;
}
/*
* Extracts the last part of a path .
*/
static char * _create_lv_name ( struct pool * mem , const char * full_name )
{
2001-10-11 14:08:44 +04:00
const char * ptr = strrchr ( full_name , ' / ' ) ;
if ( ! ptr )
ptr = full_name ;
else
ptr + + ;
2001-10-09 18:26:45 +04:00
return pool_strdup ( mem , ptr ) ;
}
int import_pv ( struct pool * mem , struct device * dev ,
2002-01-29 20:23:33 +03:00
struct volume_group * vg ,
2001-10-09 18:26:45 +04:00
struct physical_volume * pv , struct pv_disk * pvd )
{
memset ( pv , 0 , sizeof ( * pv ) ) ;
2001-10-11 14:08:44 +04:00
memcpy ( & pv - > id , pvd - > pv_uuid , ID_LEN ) ;
2001-10-09 18:26:45 +04:00
pv - > dev = dev ;
if ( ! ( pv - > vg_name = pool_strdup ( mem , pvd - > vg_name ) ) ) {
stack ;
return 0 ;
}
2002-01-29 20:23:33 +03:00
/* Store system_id if PV belongs to a VG */
if ( vg & & ! vg - > system_id & &
! ( vg - > system_id = pool_strdup ( mem , pvd - > system_id ) ) ) {
stack ;
return 0 ;
}
if ( vg & & vg - > system_id & &
strncmp ( vg - > system_id , pvd - > system_id , sizeof ( pvd - > system_id ) ) )
log_very_verbose ( " System ID %s on %s differs from %s for "
" volume group " , pvd - > system_id ,
dev_name ( pv - > dev ) , vg - > system_id ) ;
/*
* If exported , we still need to flag in pv - > status too because
* we don ' t always have a struct volume_group when we need this .
*/
if ( pvd - > pv_status & VG_EXPORTED )
pv - > status | = EXPORTED_VG ;
2001-10-09 18:26:45 +04:00
if ( pvd - > pv_allocatable )
2002-01-10 18:09:51 +03:00
pv - > status | = ALLOCATABLE_PV ;
2001-10-09 18:26:45 +04:00
pv - > size = pvd - > pv_size ;
pv - > pe_size = pvd - > pe_size ;
pv - > pe_start = pvd - > pe_start ;
pv - > pe_count = pvd - > pe_total ;
pv - > pe_allocated = pvd - > pe_allocated ;
2001-11-27 19:37:33 +03:00
2001-10-09 18:26:45 +04:00
return 1 ;
}
2002-01-29 20:23:33 +03:00
int _system_id ( char * s , const char * prefix )
2001-10-11 17:22:51 +04:00
{
struct utsname uts ;
if ( uname ( & uts ) ! = 0 ) {
log_sys_error ( " uname " , " _system_id " ) ;
return 0 ;
}
2002-01-29 20:23:33 +03:00
if ( lvm_snprintf ( s , NAME_LEN , " %s%s%lu " ,
prefix , uts . nodename , time ( NULL ) ) < 0 ) {
log_error ( " Generated system_id too long " ) ;
return 0 ;
}
2001-10-11 17:22:51 +04:00
return 1 ;
}
2002-01-29 20:23:33 +03:00
int export_pv ( struct pool * mem , struct volume_group * vg ,
struct pv_disk * pvd , struct physical_volume * pv )
2001-10-09 18:26:45 +04:00
{
memset ( pvd , 0 , sizeof ( * pvd ) ) ;
pvd - > id [ 0 ] = ' H ' ;
pvd - > id [ 1 ] = ' M ' ;
pvd - > version = 1 ;
2001-10-11 14:08:44 +04:00
memcpy ( pvd - > pv_uuid , pv - > id . uuid , ID_LEN ) ;
2001-10-09 18:26:45 +04:00
if ( ! _check_vg_name ( pv - > vg_name ) ) {
stack ;
return 0 ;
}
2001-10-10 14:05:29 +04:00
memset ( pvd - > vg_name , 0 , sizeof ( pvd - > vg_name ) ) ;
if ( pv - > vg_name )
2001-10-10 17:09:40 +04:00
strncpy ( pvd - > vg_name , pv - > vg_name , sizeof ( pvd - > vg_name ) ) ;
2001-10-09 18:26:45 +04:00
2002-01-29 20:23:33 +03:00
/* Preserve existing system_id if it exists */
if ( vg & & vg - > system_id )
strncpy ( pvd - > system_id , vg - > system_id , sizeof ( pvd - > system_id ) ) ;
/* Is VG already exported or being exported? */
if ( vg & & ( vg - > status & EXPORTED_VG ) ) {
/* Does system_id need setting? */
if ( ! vg - > system_id | |
strncmp ( vg - > system_id , EXPORTED_TAG ,
2002-01-29 22:19:37 +03:00
sizeof ( EXPORTED_TAG ) - 1 ) ) {
2002-01-29 20:23:33 +03:00
if ( ! _system_id ( pvd - > system_id , EXPORTED_TAG ) ) {
stack ;
return 0 ;
}
}
if ( strlen ( pvd - > vg_name ) + sizeof ( EXPORTED_TAG ) >
sizeof ( pvd - > vg_name ) ) {
log_error ( " Volume group name %s too long to export " ,
pvd - > vg_name ) ;
return 0 ;
}
strcat ( pvd - > vg_name , EXPORTED_TAG ) ;
}
/* Is VG being imported? */
if ( vg & & ! ( vg - > status & EXPORTED_VG ) & & vg - > system_id & &
2002-01-29 22:19:37 +03:00
! strncmp ( vg - > system_id , EXPORTED_TAG , sizeof ( EXPORTED_TAG ) - 1 ) ) {
2002-01-29 20:23:33 +03:00
if ( ! _system_id ( pvd - > system_id , IMPORTED_TAG ) ) {
stack ;
return 0 ;
}
}
/* Generate system_id if PV is in VG */
if ( ! pvd - > system_id | | ! * pvd - > system_id )
if ( ! _system_id ( pvd - > system_id , " " ) ) {
stack ;
return 0 ;
}
/* Update internal system_id if we changed it */
if ( vg & &
( ! vg - > system_id | |
2002-01-29 22:19:37 +03:00
strncmp ( vg - > system_id , pvd - > system_id ,
sizeof ( pvd - > system_id ) ) ) ) {
2002-01-29 20:23:33 +03:00
if ( ! ( vg - > system_id = pool_strdup ( mem , pvd - > system_id ) ) )
log_error ( " System ID update failed " ) ;
}
2001-10-09 18:26:45 +04:00
//pvd->pv_major = MAJOR(pv->dev);
2002-01-10 18:09:51 +03:00
if ( pv - > status & ALLOCATABLE_PV )
2001-10-11 17:34:17 +04:00
pvd - > pv_allocatable = PV_ALLOCATABLE ;
2001-10-09 18:26:45 +04:00
pvd - > pv_size = pv - > size ;
pvd - > lv_cur = 0 ; /* this is set when exporting the lv list */
pvd - > pe_size = pv - > pe_size ;
pvd - > pe_total = pv - > pe_count ;
pvd - > pe_allocated = pv - > pe_allocated ;
pvd - > pe_start = pv - > pe_start ;
2001-10-11 17:22:51 +04:00
2001-10-09 18:26:45 +04:00
return 1 ;
}
int import_vg ( struct pool * mem ,
2002-01-29 20:23:33 +03:00
struct volume_group * vg , struct disk_list * dl ,
int partial )
2001-10-09 18:26:45 +04:00
{
2001-10-31 20:59:52 +03:00
struct vg_disk * vgd = & dl - > vgd ;
2001-10-11 14:08:44 +04:00
memcpy ( vg - > id . uuid , vgd - > vg_uuid , ID_LEN ) ;
2001-10-09 18:26:45 +04:00
2001-10-31 20:59:52 +03:00
if ( ! _check_vg_name ( dl - > pvd . vg_name ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return 0 ;
}
2001-10-31 20:59:52 +03:00
if ( ! ( vg - > name = pool_strdup ( mem , dl - > pvd . vg_name ) ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return 0 ;
}
if ( vgd - > vg_status & VG_EXPORTED )
vg - > status | = EXPORTED_VG ;
if ( vgd - > vg_status & VG_EXTENDABLE )
2002-01-10 18:09:51 +03:00
vg - > status | = RESIZEABLE_VG ;
2001-10-09 18:26:45 +04:00
2002-01-29 20:23:33 +03:00
if ( partial | | ( vgd - > vg_access & VG_READ ) )
2001-10-09 18:26:45 +04:00
vg - > status | = LVM_READ ;
2002-01-29 20:23:33 +03:00
if ( ! partial & & ( vgd - > vg_access & VG_WRITE ) )
2001-10-09 18:26:45 +04:00
vg - > status | = LVM_WRITE ;
if ( vgd - > vg_access & VG_CLUSTERED )
vg - > status | = CLUSTERED ;
if ( vgd - > vg_access & VG_SHARED )
vg - > status | = SHARED ;
vg - > extent_size = vgd - > pe_size ;
vg - > extent_count = vgd - > pe_total ;
vg - > free_count = vgd - > pe_total - vgd - > pe_allocated ;
vg - > max_lv = vgd - > lv_max ;
vg - > max_pv = vgd - > pv_max ;
2002-01-29 20:23:33 +03:00
if ( partial )
vg - > status | = PARTIAL_VG ;
2001-10-09 18:26:45 +04:00
return 1 ;
}
int export_vg ( struct vg_disk * vgd , struct volume_group * vg )
{
memset ( vgd , 0 , sizeof ( * vgd ) ) ;
2001-10-11 14:08:44 +04:00
memcpy ( vgd - > vg_uuid , vg - > id . uuid , ID_LEN ) ;
2001-10-09 18:26:45 +04:00
2001-10-11 19:09:31 +04:00
if ( vg - > status & LVM_READ )
2001-10-09 18:26:45 +04:00
vgd - > vg_access | = VG_READ ;
if ( vg - > status & LVM_WRITE )
vgd - > vg_access | = VG_WRITE ;
if ( vg - > status & CLUSTERED )
vgd - > vg_access | = VG_CLUSTERED ;
if ( vg - > status & SHARED )
vgd - > vg_access | = VG_SHARED ;
if ( vg - > status & EXPORTED_VG )
vgd - > vg_status | = VG_EXPORTED ;
2002-01-10 18:09:51 +03:00
if ( vg - > status & RESIZEABLE_VG )
2001-10-09 18:26:45 +04:00
vgd - > vg_status | = VG_EXTENDABLE ;
vgd - > lv_max = vg - > max_lv ;
vgd - > lv_cur = vg - > lv_count ;
vgd - > pv_max = vg - > max_pv ;
vgd - > pv_cur = vg - > pv_count ;
vgd - > pe_size = vg - > extent_size ;
vgd - > pe_total = vg - > extent_count ;
vgd - > pe_allocated = vg - > extent_count - vg - > free_count ;
2001-10-11 17:22:51 +04:00
2001-10-09 18:26:45 +04:00
return 1 ;
}
int import_lv ( struct pool * mem , struct logical_volume * lv , struct lv_disk * lvd )
{
2001-10-11 14:08:44 +04:00
memset ( & lv - > id , 0 , sizeof ( lv - > id ) ) ;
2001-10-09 18:26:45 +04:00
if ( ! ( lv - > name = _create_lv_name ( mem , lvd - > lv_name ) ) ) {
stack ;
return 0 ;
}
if ( lvd - > lv_status & LV_SPINDOWN )
lv - > status | = SPINDOWN_LV ;
if ( lvd - > lv_access & LV_READ )
lv - > status | = LVM_READ ;
if ( lvd - > lv_access & LV_WRITE )
lv - > status | = LVM_WRITE ;
if ( lvd - > lv_access & LV_SNAPSHOT )
lv - > status | = SNAPSHOT ;
if ( lvd - > lv_access & LV_SNAPSHOT_ORG )
lv - > status | = SNAPSHOT_ORG ;
if ( lvd - > lv_badblock )
lv - > status | = BADBLOCK_ON ;
2001-11-12 20:55:05 +03:00
if ( lvd - > lv_allocation & LV_STRICT )
2001-10-09 18:26:45 +04:00
lv - > status | = ALLOC_STRICT ;
2001-11-12 20:55:05 +03:00
if ( lvd - > lv_allocation & LV_CONTIGUOUS )
2001-10-09 18:26:45 +04:00
lv - > status | = ALLOC_CONTIGUOUS ;
2001-11-12 20:55:05 +03:00
else
lv - > status | = ALLOC_SIMPLE ;
2001-10-09 18:26:45 +04:00
2001-10-29 18:34:56 +03:00
lv - > read_ahead = lvd - > lv_read_ahead ;
2001-10-09 18:26:45 +04:00
lv - > size = lvd - > lv_size ;
lv - > le_count = lvd - > lv_allocated_le ;
2001-11-27 19:37:33 +03:00
list_init ( & lv - > segments ) ;
2001-10-09 18:26:45 +04:00
return 1 ;
}
void export_lv ( struct lv_disk * lvd , struct volume_group * vg ,
2001-11-14 16:52:38 +03:00
struct logical_volume * lv , const char * dev_dir )
2001-10-09 18:26:45 +04:00
{
memset ( lvd , 0 , sizeof ( * lvd ) ) ;
2001-10-29 18:28:00 +03:00
snprintf ( lvd - > lv_name , sizeof ( lvd - > lv_name ) , " %s%s/%s " ,
2001-11-14 16:52:38 +03:00
dev_dir , vg - > name , lv - > name ) ;
2001-10-09 18:26:45 +04:00
2001-10-29 18:28:00 +03:00
/* FIXME: Add 'if' test */
2001-10-09 18:26:45 +04:00
_check_vg_name ( vg - > name ) ;
strcpy ( lvd - > vg_name , vg - > name ) ;
if ( lv - > status & LVM_READ )
lvd - > lv_access | = LV_READ ;
if ( lv - > status & LVM_WRITE )
lvd - > lv_access | = LV_WRITE ;
if ( lv - > status & SNAPSHOT )
lvd - > lv_access | = LV_SNAPSHOT ;
if ( lv - > status & SNAPSHOT_ORG )
lvd - > lv_access | = LV_SNAPSHOT_ORG ;
if ( lv - > status & SPINDOWN_LV )
lvd - > lv_status | = LV_SPINDOWN ;
2001-10-29 18:34:56 +03:00
lvd - > lv_read_ahead = lv - > read_ahead ;
2001-11-27 20:29:56 +03:00
lvd - > lv_stripes = list_item ( lv - > segments . n ,
struct stripe_segment ) - > stripes ;
2001-12-08 00:17:12 +03:00
lvd - > lv_stripesize = list_item ( lv - > segments . n ,
struct stripe_segment ) - > stripe_size ;
2001-10-29 18:34:56 +03:00
2001-10-09 18:26:45 +04:00
lvd - > lv_size = lv - > size ;
lvd - > lv_allocated_le = lv - > le_count ;
if ( lv - > status & BADBLOCK_ON )
lvd - > lv_badblock = LV_BADBLOCK_ON ;
if ( lv - > status & ALLOC_STRICT )
2001-11-12 20:55:05 +03:00
lvd - > lv_allocation | = LV_STRICT ;
if ( lv - > status & ALLOC_CONTIGUOUS )
lvd - > lv_allocation | = LV_CONTIGUOUS ;
2001-10-09 18:26:45 +04:00
}
2001-11-27 19:37:33 +03:00
int export_extents ( struct disk_list * dl , int lv_num ,
struct logical_volume * lv ,
struct physical_volume * pv )
2001-10-09 18:26:45 +04:00
{
2001-11-27 19:37:33 +03:00
struct list * segh ;
struct pe_disk * ped ;
struct stripe_segment * seg ;
2001-11-27 20:29:56 +03:00
uint32_t pe , s ;
2001-10-09 18:26:45 +04:00
2001-11-27 19:37:33 +03:00
list_iterate ( segh , & lv - > segments ) {
seg = list_item ( segh , struct stripe_segment ) ;
2001-10-09 18:26:45 +04:00
2001-11-27 20:29:56 +03:00
for ( s = 0 ; s < seg - > stripes ; s + + ) {
if ( seg - > area [ s ] . pv ! = pv )
2001-11-27 19:37:33 +03:00
continue ; /* not our pv */
2001-10-09 18:26:45 +04:00
2001-11-29 17:13:43 +03:00
for ( pe = 0 ; pe < ( seg - > len / seg - > stripes ) ; pe + + ) {
2001-11-27 20:29:56 +03:00
ped = & dl - > extents [ pe + seg - > area [ s ] . pe ] ;
2001-11-27 19:37:33 +03:00
ped - > lv_num = lv_num ;
2002-01-25 23:24:14 +03:00
ped - > le_num = ( seg - > le / seg - > stripes ) + pe +
s * ( lv - > le_count / seg - > stripes ) ;
2001-10-09 18:26:45 +04:00
}
}
}
return 1 ;
}
2002-01-29 20:23:33 +03:00
int import_pvs ( struct pool * mem , struct volume_group * vg ,
struct list * pvds , struct list * results , int * count )
2001-10-09 18:26:45 +04:00
{
2001-11-14 16:52:38 +03:00
struct list * pvdh ;
2001-10-09 18:26:45 +04:00
struct disk_list * dl ;
struct pv_list * pvl ;
* count = 0 ;
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
2002-01-21 19:05:23 +03:00
2001-11-14 16:52:38 +03:00
dl = list_item ( pvdh , struct disk_list ) ;
2001-10-09 18:26:45 +04:00
2002-01-21 19:05:23 +03:00
if ( ! ( pvl = pool_alloc ( mem , sizeof ( * pvl ) ) ) | |
! ( pvl - > pv = pool_alloc ( mem , sizeof ( * pvl - > pv ) ) ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return 0 ;
}
2002-01-29 20:23:33 +03:00
if ( ! import_pv ( mem , dl - > dev , vg , pvl - > pv , & dl - > pvd ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return 0 ;
}
2001-10-31 15:47:01 +03:00
list_add ( results , & pvl - > list ) ;
2001-10-09 18:26:45 +04:00
( * count ) + + ;
}
return 1 ;
}
static struct logical_volume * _add_lv ( struct pool * mem ,
struct volume_group * vg ,
struct lv_disk * lvd )
{
2002-01-21 19:49:32 +03:00
struct lv_list * ll ;
2001-10-09 18:26:45 +04:00
struct logical_volume * lv ;
2002-01-21 19:49:32 +03:00
if ( ! ( ll = pool_zalloc ( mem , sizeof ( * ll ) ) ) | |
! ( ll - > lv = pool_zalloc ( mem , sizeof ( * ll - > lv ) ) ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return NULL ;
}
2002-01-21 19:49:32 +03:00
lv = ll - > lv ;
2001-10-09 18:26:45 +04:00
2002-01-21 19:49:32 +03:00
if ( ! import_lv ( mem , lv , lvd ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return NULL ;
}
2001-10-31 15:47:01 +03:00
list_add ( & vg - > lvs , & ll - > list ) ;
2001-10-31 20:59:52 +03:00
lv - > vg = vg ;
2001-10-09 18:26:45 +04:00
vg - > lv_count + + ;
return lv ;
}
int import_lvs ( struct pool * mem , struct volume_group * vg ,
2001-11-14 16:52:38 +03:00
struct list * pvds )
2001-10-09 18:26:45 +04:00
{
struct disk_list * dl ;
struct lvd_list * ll ;
struct lv_disk * lvd ;
2001-11-14 16:52:38 +03:00
struct list * pvdh , * lvdh ;
2001-10-09 18:26:45 +04:00
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
dl = list_item ( pvdh , struct disk_list ) ;
list_iterate ( lvdh , & dl - > lvds ) {
ll = list_item ( lvdh , struct lvd_list ) ;
2001-10-31 20:59:52 +03:00
lvd = & ll - > lvd ;
2001-10-09 18:26:45 +04:00
2001-10-29 16:52:23 +03:00
if ( ! find_lv ( vg , lvd - > lv_name ) & &
2001-10-09 18:26:45 +04:00
! _add_lv ( mem , vg , lvd ) ) {
stack ;
return 0 ;
}
}
}
return 1 ;
}
int export_lvs ( struct disk_list * dl , struct volume_group * vg ,
2001-11-14 16:52:38 +03:00
struct physical_volume * pv , const char * dev_dir )
2001-10-09 18:26:45 +04:00
{
2001-10-31 15:47:01 +03:00
struct list * lvh ;
2001-10-09 18:26:45 +04:00
struct lv_list * ll ;
struct lvd_list * lvdl ;
2001-11-13 21:52:52 +03:00
int lv_num = 0 , len ;
2001-10-10 18:56:53 +04:00
/*
* setup the pv ' s extents array
*/
2001-10-31 20:59:52 +03:00
len = sizeof ( struct pe_disk ) * dl - > pvd . pe_total ;
2001-10-10 18:56:53 +04:00
if ( ! ( dl - > extents = pool_alloc ( dl - > mem , len ) ) ) {
stack ;
return 0 ;
}
2001-10-11 14:08:44 +04:00
memset ( dl - > extents , 0 , len ) ;
2001-10-10 18:56:53 +04:00
2001-10-09 18:26:45 +04:00
2001-10-31 15:47:01 +03:00
list_iterate ( lvh , & vg - > lvs ) {
ll = list_item ( lvh , struct lv_list ) ;
2001-10-09 18:26:45 +04:00
if ( ! ( lvdl = pool_alloc ( dl - > mem , sizeof ( * lvdl ) ) ) ) {
stack ;
return 0 ;
}
2002-01-21 19:49:32 +03:00
export_lv ( & lvdl - > lvd , vg , ll - > lv , dev_dir ) ;
2001-11-10 01:01:04 +03:00
lvdl - > lvd . lv_number = lv_num ;
2002-01-21 19:49:32 +03:00
if ( ! export_extents ( dl , lv_num + 1 , ll - > lv , pv ) ) {
2001-10-09 18:26:45 +04:00
stack ;
return 0 ;
}
2001-10-31 20:59:52 +03:00
list_add ( & dl - > lvds , & lvdl - > list ) ;
dl - > pvd . lv_cur + + ;
2001-11-13 21:52:52 +03:00
lv_num + + ;
2001-10-09 18:26:45 +04:00
}
return 1 ;
}
int export_uuids ( struct disk_list * dl , struct volume_group * vg )
{
struct uuid_list * ul ;
struct pv_list * pvl ;
2001-10-31 15:47:01 +03:00
struct list * pvh ;
2001-10-09 18:26:45 +04:00
2001-10-31 15:47:01 +03:00
list_iterate ( pvh , & vg - > pvs ) {
pvl = list_item ( pvh , struct pv_list ) ;
2001-10-09 18:26:45 +04:00
if ( ! ( ul = pool_alloc ( dl - > mem , sizeof ( * ul ) ) ) ) {
stack ;
return 0 ;
}
2001-10-11 14:08:44 +04:00
memset ( ul - > uuid , 0 , sizeof ( ul - > uuid ) ) ;
2002-01-21 19:05:23 +03:00
memcpy ( ul - > uuid , pvl - > pv - > id . uuid , ID_LEN ) ;
2001-10-09 18:26:45 +04:00
2001-10-31 15:47:01 +03:00
list_add ( & dl - > uuids , & ul - > list ) ;
2001-10-09 18:26:45 +04:00
}
return 1 ;
}
2001-10-11 14:55:19 +04:00
/*
* This calculates the nasty pv_number and
* lv_number fields used by LVM1 . Very
* inefficient code .
*/
2001-11-14 16:52:38 +03:00
void export_numbers ( struct list * pvds , struct volume_group * vg )
2001-10-11 14:55:19 +04:00
{
2001-11-14 16:52:38 +03:00
struct list * pvdh ;
2001-10-11 14:55:19 +04:00
struct disk_list * dl ;
2001-10-11 20:31:09 +04:00
int pv_num = 1 ;
2001-10-11 14:55:19 +04:00
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
dl = list_item ( pvdh , struct disk_list ) ;
2001-10-31 20:59:52 +03:00
dl - > pvd . pv_number = pv_num + + ;
2001-10-11 14:55:19 +04:00
}
}
2001-10-11 17:05:55 +04:00
/*
* Calculate vg_disk - > pv_act .
*/
2001-11-14 16:52:38 +03:00
void export_pv_act ( struct list * pvds )
2001-10-11 17:05:55 +04:00
{
2001-11-14 16:52:38 +03:00
struct list * pvdh ;
2001-10-11 17:05:55 +04:00
struct disk_list * dl ;
int act = 0 ;
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
dl = list_item ( pvdh , struct disk_list ) ;
2001-10-31 20:59:52 +03:00
if ( dl - > pvd . pv_status & PV_ACTIVE )
2001-10-11 17:05:55 +04:00
act + + ;
}
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
dl = list_item ( pvdh , struct disk_list ) ;
2001-10-31 20:59:52 +03:00
dl - > vgd . pv_act = act ;
2001-10-11 17:05:55 +04:00
}
}
2001-10-11 18:10:18 +04:00
2001-11-14 16:52:38 +03:00
int export_vg_number ( struct list * pvds , const char * vg_name ,
2001-10-11 18:10:18 +04:00
struct dev_filter * filter )
{
2001-11-14 16:52:38 +03:00
struct list * pvdh ;
2001-10-11 18:10:18 +04:00
struct disk_list * dl ;
int vg_num ;
if ( ! get_free_vg_number ( filter , vg_name , & vg_num ) ) {
stack ;
return 0 ;
}
2001-11-14 16:52:38 +03:00
list_iterate ( pvdh , pvds ) {
dl = list_item ( pvdh , struct disk_list ) ;
2001-10-31 20:59:52 +03:00
dl - > vgd . vg_number = vg_num ;
2001-10-11 18:10:18 +04:00
}
return 1 ;
}