2009-07-24 03:40:05 +04:00
/*
* Copyright ( C ) 2008 , 2009 Red Hat , Inc . All rights reserved .
*
* This file is part of LVM2 .
*
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v .2 .1 .
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
2013-03-20 01:37:04 +04:00
# include <stddef.h>
2009-07-24 03:40:05 +04:00
# include "lib.h"
2010-09-30 18:07:47 +04:00
# include "metadata.h"
2009-07-24 03:40:05 +04:00
# include "lvm-string.h"
2010-10-25 18:08:55 +04:00
# include "lvm_misc.h"
2010-12-15 02:20:58 +03:00
# include "lvm2app.h"
2013-03-20 01:37:04 +04:00
# include "locking.h"
# include "toolcontext.h"
2009-07-24 03:40:05 +04:00
2010-04-19 19:22:24 +04:00
const char * lvm_pv_get_uuid ( const pv_t pv )
2009-07-24 03:40:05 +04:00
{
2010-09-30 18:07:47 +04:00
return pv_uuid_dup ( pv ) ;
2009-07-24 03:40:05 +04:00
}
2010-04-19 19:22:24 +04:00
const char * lvm_pv_get_name ( const pv_t pv )
2009-07-24 03:40:05 +04:00
{
2010-04-19 19:22:24 +04:00
return dm_pool_strndup ( pv - > vg - > vgmem ,
( const char * ) pv_dev_name ( pv ) , NAME_LEN + 1 ) ;
2009-07-24 03:40:05 +04:00
}
2009-08-13 16:18:15 +04:00
uint64_t lvm_pv_get_mda_count ( const pv_t pv )
2009-07-26 17:06:59 +04:00
{
return ( uint64_t ) pv_mda_count ( pv ) ;
}
2009-07-28 01:00:50 +04:00
2010-02-14 06:21:37 +03:00
uint64_t lvm_pv_get_dev_size ( const pv_t pv )
{
2010-02-16 03:27:01 +03:00
return ( uint64_t ) SECTOR_SIZE * pv_dev_size ( pv ) ;
2010-02-14 06:21:37 +03:00
}
uint64_t lvm_pv_get_size ( const pv_t pv )
{
2010-02-16 03:27:01 +03:00
return ( uint64_t ) SECTOR_SIZE * pv_size_field ( pv ) ;
2010-02-14 06:21:37 +03:00
}
uint64_t lvm_pv_get_free ( const pv_t pv )
{
2010-02-16 03:27:01 +03:00
return ( uint64_t ) SECTOR_SIZE * pv_free ( pv ) ;
2010-02-14 06:21:37 +03:00
}
2010-10-25 18:08:55 +04:00
struct lvm_property_value lvm_pv_get_property ( const pv_t pv , const char * name )
{
2013-04-17 10:29:21 +04:00
return get_property ( pv , NULL , NULL , NULL , NULL , NULL , name ) ;
2010-11-17 23:12:39 +03:00
}
struct lvm_property_value lvm_pvseg_get_property ( const pvseg_t pvseg ,
const char * name )
{
2013-04-17 10:29:21 +04:00
return get_property ( NULL , NULL , NULL , NULL , pvseg , NULL , name ) ;
2010-10-25 18:08:55 +04:00
}
2013-03-20 01:37:04 +04:00
# define address_of(p, t, m) ({ \
const typeof ( ( ( t * ) 0 ) - > m ) * __mptr = ( p ) ; \
( t * ) ( ( char * ) __mptr - offsetof ( t , m ) ) ; } )
struct lvm_list_wrapper
{
unsigned long magic ;
struct dm_list pvslist ;
struct dm_list vgslist ;
} ;
2013-04-03 00:10:18 +04:00
int lvm_pv_remove ( lvm_t libh , const char * pv_name )
{
struct cmd_context * cmd = ( struct cmd_context * ) libh ;
if ( 1 ! = pvremove_single ( cmd , pv_name , NULL , 0 , 0 ) ) {
return - 1 ;
}
return 0 ;
}
2013-03-20 01:37:04 +04:00
struct dm_list * lvm_list_pvs ( lvm_t libh )
{
struct lvm_list_wrapper * rc = NULL ;
struct cmd_context * cmd = ( struct cmd_context * ) libh ;
rc = dm_pool_zalloc ( cmd - > mem , sizeof ( * rc ) ) ;
if ( ! rc ) {
log_errno ( ENOMEM , " Memory allocation fail for pv list. " ) ;
return NULL ;
}
if ( ! lock_vol ( cmd , VG_GLOBAL , LCK_VG_WRITE , NULL ) ) {
log_errno ( ENOLCK , " Unable to obtain global lock. " ) ;
} else {
dm_list_init ( & rc - > pvslist ) ;
dm_list_init ( & rc - > vgslist ) ;
if ( ! get_pvs_perserve_vg ( cmd , & rc - > pvslist , & rc - > vgslist ) ) {
dm_pool_free ( cmd - > mem , rc ) ;
return NULL ;
}
rc - > magic = 0xF005BA11 ;
}
return & rc - > pvslist ;
}
int lvm_list_pvs_free ( struct dm_list * pvlist )
{
int rc = 0 ;
struct lvm_list_wrapper * to_delete = NULL ;
struct vg_list * vgl = NULL ;
struct pv_list * pvl = NULL ;
struct cmd_context * cmd = NULL ;
if ( pvlist ) {
to_delete = address_of ( pvlist , struct lvm_list_wrapper , pvslist ) ;
if ( to_delete - > magic = = 0xF005BA11 ) {
dm_list_iterate_items ( vgl , & to_delete - > vgslist ) {
cmd = vgl - > vg - > cmd ;
release_vg ( vgl - > vg ) ;
}
dm_list_iterate_items ( pvl , & to_delete - > pvslist ) {
free_pv_fid ( pvl - > pv ) ;
}
unlock_vg ( cmd , VG_GLOBAL ) ;
} else {
log_errno ( EINVAL , " Not a correct pvlist structure " ) ;
rc = - 1 ;
}
to_delete - > magic = 0xA5A5A5A5 ;
dm_pool_free ( cmd - > mem , to_delete ) ;
}
return rc ;
}
2010-11-17 23:10:42 +03:00
struct dm_list * lvm_pv_list_pvsegs ( pv_t pv )
{
struct dm_list * list ;
pvseg_list_t * pvseg ;
struct pv_segment * pvl ;
if ( dm_list_empty ( & pv - > segments ) )
return NULL ;
if ( ! ( list = dm_pool_zalloc ( pv - > vg - > vgmem , sizeof ( * list ) ) ) ) {
log_errno ( ENOMEM , " Memory allocation fail for dm_list. " ) ;
return NULL ;
}
dm_list_init ( list ) ;
dm_list_iterate_items ( pvl , & pv - > segments ) {
if ( ! ( pvseg = dm_pool_zalloc ( pv - > vg - > vgmem , sizeof ( * pvseg ) ) ) ) {
log_errno ( ENOMEM ,
" Memory allocation fail for lvm_pvseg_list. " ) ;
return NULL ;
}
pvseg - > pvseg = pvl ;
dm_list_add ( list , & pvseg - > list ) ;
}
return list ;
}
2010-11-25 17:33:44 +03:00
pv_t lvm_pv_from_name ( vg_t vg , const char * name )
{
struct pv_list * pvl ;
dm_list_iterate_items ( pvl , & vg - > pvs ) {
if ( ! strcmp ( name , pv_dev_name ( pvl - > pv ) ) )
return pvl - > pv ;
}
return NULL ;
}
2010-11-25 17:34:51 +03:00
pv_t lvm_pv_from_uuid ( vg_t vg , const char * uuid )
{
struct pv_list * pvl ;
struct id id ;
if ( strlen ( uuid ) < ID_LEN ) {
log_errno ( EINVAL , " Invalid UUID string length " ) ;
return NULL ;
}
2012-02-08 15:41:18 +04:00
if ( ! id_read_format ( & id , uuid ) ) {
log_errno ( EINVAL , " Invalid UUID format. " ) ;
return NULL ;
2010-11-25 17:34:51 +03:00
}
2012-02-08 15:41:18 +04:00
2010-11-25 17:34:51 +03:00
dm_list_iterate_items ( pvl , & vg - > pvs ) {
if ( id_equal ( & id , & pvl - > pv - > id ) )
return pvl - > pv ;
}
return NULL ;
}
2010-11-25 17:33:44 +03:00
2009-08-13 16:18:15 +04:00
int lvm_pv_resize ( const pv_t pv , uint64_t new_size )
2009-07-28 01:00:50 +04:00
{
2013-03-13 23:39:56 +04:00
uint64_t size = new_size > > SECTOR_SHIFT ;
if ( new_size % SECTOR_SIZE ) {
log_errno ( EINVAL , " Size not a multiple of 512 " ) ;
return - 1 ;
}
if ( ! vg_check_write_mode ( pv - > vg ) ) {
return - 1 ;
}
if ( ! pv_resize ( pv , pv - > vg , size ) ) {
log_error ( " PV re-size failed! " ) ;
return - 1 ;
} else {
return 0 ;
}
2009-07-28 01:00:50 +04:00
}