LVM

LVM — plugin for operations with LVM

Synopsis

#include <lvm.h>

gboolean            bd_lvm_check_deps                   ();
void                bd_lvm_close                        ();
gboolean            bd_lvm_init                         ();
#define             BD_LVM_MAX_LV_SIZE
#define             BD_LVM_DEFAULT_PE_SIZE
#define             BD_LVM_DEFAULT_PE_START
#define             BD_LVM_MIN_PE_SIZE
#define             BD_LVM_MAX_PE_SIZE
#define             USE_DEFAULT_PE_SIZE
#define             RESOLVE_PE_SIZE                     (size)
#define             BD_LVM_MIN_THPOOL_MD_SIZE
#define             BD_LVM_MAX_THPOOL_MD_SIZE
#define             BD_LVM_MIN_THPOOL_CHUNK_SIZE
#define             BD_LVM_MAX_THPOOL_CHUNK_SIZE
#define             THPOOL_MD_FACTOR_NEW
#define             THPOOL_MD_FACTOR_EXISTS
#define             BD_LVM_MIN_CACHE_MD_SIZE
GQuark              bd_lvm_error_quark                  (void);
#define             BD_LVM_ERROR
enum                BDLVMError;
                    BDLVMPVdata;
void                bd_lvm_pvdata_free                  (BDLVMPVdata *data);
BDLVMPVdata *       bd_lvm_pvdata_copy                  (BDLVMPVdata *data);
                    BDLVMVGdata;
void                bd_lvm_vgdata_free                  (BDLVMVGdata *data);
BDLVMVGdata *       bd_lvm_vgdata_copy                  (BDLVMVGdata *data);
                    BDLVMLVdata;
void                bd_lvm_lvdata_free                  (BDLVMLVdata *data);
BDLVMLVdata *       bd_lvm_lvdata_copy                  (BDLVMLVdata *data);
enum                BDLVMCacheMode;
enum                BDLVMCachePoolFlags;
                    BDLVMCacheStats;
BDLVMCacheStats *   bd_lvm_cache_stats_copy             (BDLVMCacheStats *data);
void                bd_lvm_cache_stats_free             (BDLVMCacheStats *data);
gboolean            bd_lvm_is_supported_pe_size         (guint64 size,
                                                         GError **error);
guint64 *           bd_lvm_get_supported_pe_sizes       (GError **error);
guint64             bd_lvm_get_max_lv_size              (GError **error);
guint64             bd_lvm_round_size_to_pe             (guint64 size,
                                                         guint64 pe_size,
                                                         gboolean roundup,
                                                         GError **error);
guint64             bd_lvm_get_lv_physical_size         (guint64 lv_size,
                                                         guint64 pe_size,
                                                         GError **error);
guint64             bd_lvm_get_thpool_padding           (guint64 size,
                                                         guint64 pe_size,
                                                         gboolean included,
                                                         GError **error);
gboolean            bd_lvm_is_valid_thpool_md_size      (guint64 size,
                                                         GError **error);
gboolean            bd_lvm_is_valid_thpool_chunk_size   (guint64 size,
                                                         gboolean discard,
                                                         GError **error);
gboolean            bd_lvm_pvcreate                     (const gchar *device,
                                                         guint64 data_alignment,
                                                         guint64 metadata_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_pvresize                     (const gchar *device,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_pvremove                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_pvmove                       (const gchar *src,
                                                         const gchar *dest,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_pvscan                       (const gchar *device,
                                                         gboolean update_cache,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDLVMPVdata *       bd_lvm_pvinfo                       (const gchar *device,
                                                         GError **error);
BDLVMPVdata **      bd_lvm_pvs                          (GError **error);
gboolean            bd_lvm_vgcreate                     (const gchar *name,
                                                         const gchar **pv_list,
                                                         guint64 pe_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgremove                     (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgrename                     (const gchar *old_vg_name,
                                                         const gchar *new_vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgactivate                   (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgdeactivate                 (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgextend                     (const gchar *vg_name,
                                                         const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_vgreduce                     (const gchar *vg_name,
                                                         const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDLVMVGdata *       bd_lvm_vginfo                       (const gchar *vg_name,
                                                         GError **error);
BDLVMVGdata **      bd_lvm_vgs                          (GError **error);
gchar *             bd_lvm_lvorigin                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);
gboolean            bd_lvm_lvcreate                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const gchar *type,
                                                         const gchar **pv_list,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvremove                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         gboolean force,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvrename                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         const gchar *new_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvresize                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvactivate                   (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         gboolean ignore_skip,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvdeactivate                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvsnapshotcreate             (const gchar *vg_name,
                                                         const gchar *origin_name,
                                                         const gchar *snapshot_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_lvsnapshotmerge              (const gchar *vg_name,
                                                         const gchar *snapshot_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDLVMLVdata *       bd_lvm_lvinfo                       (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);
BDLVMLVdata **      bd_lvm_lvs                          (const gchar *vg_name,
                                                         GError **error);
gboolean            bd_lvm_thpoolcreate                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         guint64 md_size,
                                                         guint64 chunk_size,
                                                         const gchar *profile,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_thpool_convert               (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *metadata_lv,
                                                         const gchar *name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_thlvcreate                   (const gchar *vg_name,
                                                         const gchar *pool_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gchar *             bd_lvm_thlvpoolname                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);
gboolean            bd_lvm_thsnapshotcreate             (const gchar *vg_name,
                                                         const gchar *origin_name,
                                                         const gchar *snapshot_name,
                                                         const gchar *pool_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_set_global_config            (const gchar *new_config,
                                                         GError **error);
gchar *             bd_lvm_get_global_config            (GError **error);
gboolean            bd_lvm_cache_attach                 (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *cache_pool_lv,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_cache_create_cached_lv       (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 data_size,
                                                         guint64 cache_size,
                                                         guint64 md_size,
                                                         BDLVMCacheMode mode,
                                                         BDLVMCachePoolFlags flags,
                                                         const gchar **slow_pvs,
                                                         const gchar **fast_pvs,
                                                         GError **error);
gboolean            bd_lvm_cache_create_pool            (const gchar *vg_name,
                                                         const gchar *pool_name,
                                                         guint64 pool_size,
                                                         guint64 md_size,
                                                         BDLVMCacheMode mode,
                                                         BDLVMCachePoolFlags flags,
                                                         const gchar **fast_pvs,
                                                         GError **error);
gboolean            bd_lvm_cache_pool_convert           (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *metadata_lv,
                                                         const gchar *name,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_lvm_cache_detach                 (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         gboolean destroy,
                                                         const BDExtraArg **extra,
                                                         GError **error);
guint64             bd_lvm_cache_get_default_md_size    (guint64 cache_size,
                                                         GError **error);
BDLVMCacheMode      bd_lvm_cache_get_mode_from_str      (const gchar *mode_str,
                                                         GError **error);
const gchar *       bd_lvm_cache_get_mode_str           (BDLVMCacheMode mode,
                                                         GError **error);
gchar *             bd_lvm_cache_pool_name              (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         GError **error);
BDLVMCacheStats *   bd_lvm_cache_stats                  (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         GError **error);
gchar *             bd_lvm_data_lv_name                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);
gchar *             bd_lvm_metadata_lv_name             (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

Description

A plugin for operations with LVM. All sizes passed in/out to/from the functions are in bytes.

Details

bd_lvm_check_deps ()

gboolean            bd_lvm_check_deps                   ();

Returns :

whether the plugin's runtime dependencies are satisfied or not Function checking plugin's runtime dependencies.

bd_lvm_close ()

void                bd_lvm_close                        ();

Cleans up after the plugin. **This function is called automatically by the library's functions that unload it.**


bd_lvm_init ()

gboolean            bd_lvm_init                         ();

Initializes the plugin. **This function is called automatically by the library's initialization functions.**


BD_LVM_MAX_LV_SIZE

#define             BD_LVM_MAX_LV_SIZE

BD_LVM_DEFAULT_PE_SIZE

#define             BD_LVM_DEFAULT_PE_SIZE

BD_LVM_DEFAULT_PE_START

#define             BD_LVM_DEFAULT_PE_START

BD_LVM_MIN_PE_SIZE

#define             BD_LVM_MIN_PE_SIZE

BD_LVM_MAX_PE_SIZE

#define             BD_LVM_MAX_PE_SIZE

USE_DEFAULT_PE_SIZE

#define USE_DEFAULT_PE_SIZE 0

RESOLVE_PE_SIZE()

#define RESOLVE_PE_SIZE(size) ((size) == USE_DEFAULT_PE_SIZE ? BD_LVM_DEFAULT_PE_SIZE : (size))

BD_LVM_MIN_THPOOL_MD_SIZE

#define             BD_LVM_MIN_THPOOL_MD_SIZE

BD_LVM_MAX_THPOOL_MD_SIZE

#define             BD_LVM_MAX_THPOOL_MD_SIZE

BD_LVM_MIN_THPOOL_CHUNK_SIZE

#define             BD_LVM_MIN_THPOOL_CHUNK_SIZE

BD_LVM_MAX_THPOOL_CHUNK_SIZE

#define             BD_LVM_MAX_THPOOL_CHUNK_SIZE

THPOOL_MD_FACTOR_NEW

#define THPOOL_MD_FACTOR_NEW (0.2)

THPOOL_MD_FACTOR_EXISTS

#define THPOOL_MD_FACTOR_EXISTS (1 / 6.0)

BD_LVM_MIN_CACHE_MD_SIZE

#define             BD_LVM_MIN_CACHE_MD_SIZE

bd_lvm_error_quark ()

GQuark              bd_lvm_error_quark                  (void);

BD_LVM_ERROR

#define             BD_LVM_ERROR

enum BDLVMError

typedef enum {
    BD_LVM_ERROR_PARSE,
    BD_LVM_ERROR_NOEXIST,
    BD_LVM_ERROR_DM_ERROR,
    BD_LVM_ERROR_NOT_ROOT,
    BD_LVM_ERROR_CACHE_INVAL,
    BD_LVM_ERROR_CACHE_NOCACHE,
} BDLVMError;

BD_LVM_ERROR_PARSE

BD_LVM_ERROR_NOEXIST

BD_LVM_ERROR_DM_ERROR

BD_LVM_ERROR_NOT_ROOT

BD_LVM_ERROR_CACHE_INVAL

BD_LVM_ERROR_CACHE_NOCACHE


BDLVMPVdata

typedef struct {
    gchar *pv_name;
    gchar *pv_uuid;
    guint64 pv_free;
    guint64 pv_size;
    guint64 pe_start;
    gchar *vg_name;
    gchar *vg_uuid;
    guint64 vg_size;
    guint64 vg_free;
    guint64 vg_extent_size;
    guint64 vg_extent_count;
    guint64 vg_free_count;
    guint64 vg_pv_count;
} BDLVMPVdata;

gchar *pv_name;

name of the PV

gchar *pv_uuid;

UUID of the PV

guint64 pv_free;

size of the free space in the PV

guint64 pv_size;

size of the PV

guint64 pe_start;

start of the physical extents area (i.e. offset of the first PE)

gchar *vg_name;

name of the VG the PV belongs to

gchar *vg_uuid;

UUID of the VG the PV belongs to

guint64 vg_size;

size of the VG the PV belongs to

guint64 vg_free;

size of the free space in the PV's VG

guint64 vg_extent_size;

extent size used by the PV's VG

guint64 vg_extent_count;

number of extents in the PV's VG

guint64 vg_free_count;

number of free extents in the PV's VG

guint64 vg_pv_count;

number of PVs that belong to this PV's VG

bd_lvm_pvdata_free ()

void                bd_lvm_pvdata_free                  (BDLVMPVdata *data);

Frees data.


bd_lvm_pvdata_copy ()

BDLVMPVdata *       bd_lvm_pvdata_copy                  (BDLVMPVdata *data);

Creates a new copy of data.


BDLVMVGdata

typedef struct {
    gchar *name;
    gchar *uuid;
    guint64 size;
    guint64 free;
    guint64 extent_size;
    guint64 extent_count;
    guint64 free_count;
    guint64 pv_count;
} BDLVMVGdata;

gchar *name;

name of the VG

gchar *uuid;

UUID of the VG

guint64 size;

size of the VG

guint64 free;

size of the free space in the VG

guint64 extent_size;

extent size used by the VG

guint64 extent_count;

number of extents in the VG

guint64 free_count;

number of free extents in the VG

guint64 pv_count;

number of PVs that belong to the VG

bd_lvm_vgdata_free ()

void                bd_lvm_vgdata_free                  (BDLVMVGdata *data);

Frees data.


bd_lvm_vgdata_copy ()

BDLVMVGdata *       bd_lvm_vgdata_copy                  (BDLVMVGdata *data);

Creates a new copy of data.


BDLVMLVdata

typedef struct {
    gchar *lv_name;
    gchar *vg_name;
    gchar *uuid;
    guint64 size;
    gchar *attr;
    gchar *segtype;
    gchar *origin;
    gchar *pool_lv;
    gchar *data_lv;
    gchar *metadata_lv;
    gchar *roles;
    gchar *move_pv;
    guint64 data_percent;
    guint64 metadata_percent;
    guint64 copy_percent;
} BDLVMLVdata;

gchar *lv_name;

name of the LV

gchar *vg_name;

name of the VG the LV belongs to

gchar *uuid;

UUID of the LV

guint64 size;

size of the LV

gchar *attr;

attributes of the LV

gchar *segtype;

segment type of the LV

gchar *origin;

origin of the LV (for snapshots, etc.)

gchar *pool_lv;

pool LV of the LV (for thin and cached LVs)

gchar *data_lv;

data LV of the LV (for thin and cache pools)

gchar *metadata_lv;

metadata LV of the LV (for thin and cache pools)

gchar *roles;

gchar *move_pv;

guint64 data_percent;

guint64 metadata_percent;

guint64 copy_percent;


bd_lvm_lvdata_free ()

void                bd_lvm_lvdata_free                  (BDLVMLVdata *data);

Frees data.


bd_lvm_lvdata_copy ()

BDLVMLVdata *       bd_lvm_lvdata_copy                  (BDLVMLVdata *data);

Creates a new copy of data.


enum BDLVMCacheMode

typedef enum {
    BD_LVM_CACHE_MODE_WRITETHROUGH,
    BD_LVM_CACHE_MODE_WRITEBACK,
    BD_LVM_CACHE_MODE_UNKNOWN,
} BDLVMCacheMode;

BD_LVM_CACHE_MODE_WRITETHROUGH

BD_LVM_CACHE_MODE_WRITEBACK

BD_LVM_CACHE_MODE_UNKNOWN


enum BDLVMCachePoolFlags

typedef enum {
    BD_LVM_CACHE_POOL_STRIPED = 1 << 0,
    BD_LVM_CACHE_POOL_RAID1 =    1 << 1,
    BD_LVM_CACHE_POOL_RAID5 =    1 << 2,
    BD_LVM_CACHE_POOL_RAID6 =    1 << 3,
    BD_LVM_CACHE_POOL_RAID10 =   1 << 4,

    BD_LVM_CACHE_POOL_META_STRIPED = 1 << 10,
    BD_LVM_CACHE_POOL_META_RAID1 =    1 << 11,
    BD_LVM_CACHE_POOL_META_RAID5 =    1 << 12,
    BD_LVM_CACHE_POOL_META_RAID6 =    1 << 13,
    BD_LVM_CACHE_POOL_META_RAID10 =   1 << 14,
} BDLVMCachePoolFlags;

BD_LVM_CACHE_POOL_STRIPED

BD_LVM_CACHE_POOL_RAID1

BD_LVM_CACHE_POOL_RAID5

BD_LVM_CACHE_POOL_RAID6

BD_LVM_CACHE_POOL_RAID10

BD_LVM_CACHE_POOL_META_STRIPED

BD_LVM_CACHE_POOL_META_RAID1

BD_LVM_CACHE_POOL_META_RAID5

BD_LVM_CACHE_POOL_META_RAID6

BD_LVM_CACHE_POOL_META_RAID10


BDLVMCacheStats

typedef struct {
    guint64 block_size;
    guint64 cache_size;
    guint64 cache_used;
    guint64 md_block_size;
    guint64 md_size;
    guint64 md_used;
    guint64 read_hits;
    guint64 read_misses;
    guint64 write_hits;
    guint64 write_misses;
    BDLVMCacheMode mode;
} BDLVMCacheStats;

guint64 block_size;

block size used by the cache

guint64 cache_size;

size of the cache

guint64 cache_used;

size of the used space in the cache

guint64 md_block_size;

block size used for cache metadata

guint64 md_size;

size of the metadata space of the cache

guint64 md_used;

size of the used metadata space in the cache

guint64 read_hits;

number of read hits

guint64 read_misses;

number of read misses

guint64 write_hits;

number of write hits

guint64 write_misses;

number of write misses

BDLVMCacheMode mode;

mode the cache is operating in

bd_lvm_cache_stats_copy ()

BDLVMCacheStats *   bd_lvm_cache_stats_copy             (BDLVMCacheStats *data);

Creates a new copy of data.


bd_lvm_cache_stats_free ()

void                bd_lvm_cache_stats_free             (BDLVMCacheStats *data);

Frees data.


bd_lvm_is_supported_pe_size ()

gboolean            bd_lvm_is_supported_pe_size         (guint64 size,
                                                         GError **error);

size :

size (in bytes) to test

error :

place to store error (if any). [out]

Returns :

whether the given size is supported physical extent size or not

bd_lvm_get_supported_pe_sizes ()

guint64 *           bd_lvm_get_supported_pe_sizes       (GError **error);

error :

place to store error (if any). [out]

Returns :

list of supported PE sizes. [transfer full][array zero-terminated=1]

bd_lvm_get_max_lv_size ()

guint64             bd_lvm_get_max_lv_size              (GError **error);

error :

place to store error (if any). [out]

Returns :

maximum LV size in bytes

bd_lvm_round_size_to_pe ()

guint64             bd_lvm_round_size_to_pe             (guint64 size,
                                                         guint64 pe_size,
                                                         gboolean roundup,
                                                         GError **error);

size :

size to be rounded

pe_size :

physical extent (PE) size or 0 to use the default

roundup :

whether to round up or down (ceil or floor)

error :

place to store error (if any). [out]

Returns :

size rounded to pe_size according to the roundup Rounds given size up/down to a multiple of pe_size according to the value of the roundup parameter. If the rounded value is too big to fit in the return type, the result is rounded down (floored) regardless of the roundup parameter.

bd_lvm_get_lv_physical_size ()

guint64             bd_lvm_get_lv_physical_size         (guint64 lv_size,
                                                         guint64 pe_size,
                                                         GError **error);

lv_size :

LV size

pe_size :

PE size

error :

place to store error (if any). [out]

Returns :

space taken on disk(s) by the LV with given size Gives number of bytes needed for an LV with the size lv_size on an LVM stack using given pe_size.

bd_lvm_get_thpool_padding ()

guint64             bd_lvm_get_thpool_padding           (guint64 size,
                                                         guint64 pe_size,
                                                         gboolean included,
                                                         GError **error);

size :

size of the thin pool

pe_size :

PE size or 0 if the default value should be used

included :

if padding is already included in the size

error :

place to store error (if any). [out]

Returns :

size of the padding needed for a thin pool with the given size according to the pe_size and included

bd_lvm_is_valid_thpool_md_size ()

gboolean            bd_lvm_is_valid_thpool_md_size      (guint64 size,
                                                         GError **error);

size :

the size to be tested

error :

place to store error (if any). [out]

Returns :

whether the given size is a valid thin pool metadata size or not

bd_lvm_is_valid_thpool_chunk_size ()

gboolean            bd_lvm_is_valid_thpool_chunk_size   (guint64 size,
                                                         gboolean discard,
                                                         GError **error);

size :

the size to be tested

discard :

whether discard/TRIM is required to be supported or not

error :

place to store error (if any). [out]

Returns :

whether the given size is a valid thin pool chunk size or not

bd_lvm_pvcreate ()

gboolean            bd_lvm_pvcreate                     (const gchar *device,
                                                         guint64 data_alignment,
                                                         guint64 metadata_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to make PV from

data_alignment :

data (first PE) alignment or 0 to use the default

metadata_size :

size of the area reserved for metadata or 0 to use the default

extra :

extra options for the PV creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the PV was successfully created or not

bd_lvm_pvresize ()

gboolean            bd_lvm_pvresize                     (const gchar *device,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to resize

size :

the new requested size of the PV or 0 if it should be adjusted to device's size

extra :

extra options for the PV resize (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the PV's size was successfully changed or not If given size different from 0, sets the PV's size to the given value (see pvresize(8)). If given size 0, adjusts the PV's size to the underlaying block device's size.

bd_lvm_pvremove ()

gboolean            bd_lvm_pvremove                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the PV device to be removed/destroyed

extra :

extra options for the PV removal (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the PV was successfully removed/destroyed or not

bd_lvm_pvmove ()

gboolean            bd_lvm_pvmove                       (const gchar *src,
                                                         const gchar *dest,
                                                         const BDExtraArg **extra,
                                                         GError **error);

src :

the PV device to move extents off of

dest :

the PV device to move extents onto or NULL. [allow-none]

extra :

extra options for the PV move (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the extents from the src PV where successfully moved or not If dest is NULL, VG allocation rules are used for the extents from the src PV (see pvmove(8)).

bd_lvm_pvscan ()

gboolean            bd_lvm_pvscan                       (const gchar *device,
                                                         gboolean update_cache,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to scan for PVs or NULL. [allow-none]

update_cache :

whether to update the lvmetad cache or not

extra :

extra options for the PV scan (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the system or device was successfully scanned for PVs or not The device argument is used only if update_cache is TRUE. Otherwise the whole system is scanned for PVs.

bd_lvm_pvinfo ()

BDLVMPVdata *       bd_lvm_pvinfo                       (const gchar *device,
                                                         GError **error);

device :

a PV to get information about or NULL

error :

place to store error (if any). [out]

Returns :

information about the PV on the given device or NULL in case of error (the error) gets populated in those cases). [transfer full]

bd_lvm_pvs ()

BDLVMPVdata **      bd_lvm_pvs                          (GError **error);

error :

place to store error (if any). [out]

Returns :

information about PVs found in the system. [array zero-terminated=1]

bd_lvm_vgcreate ()

gboolean            bd_lvm_vgcreate                     (const gchar *name,
                                                         const gchar **pv_list,
                                                         guint64 pe_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

name :

name of the newly created VG

pv_list :

list of PVs the newly created VG should use. [array zero-terminated=1]

pe_size :

PE size or 0 if the default value should be used

extra :

extra options for the VG creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG name was successfully created or not

bd_lvm_vgremove ()

gboolean            bd_lvm_vgremove                     (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the to be removed VG

extra :

extra options for the VG removal (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG was successfully removed or not

bd_lvm_vgrename ()

gboolean            bd_lvm_vgrename                     (const gchar *old_vg_name,
                                                         const gchar *new_vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

old_vg_name :

old name of the VG to rename

new_vg_name :

new name for the old_vg_name VG

extra :

extra options for the VG rename (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG was successfully renamed or not

bd_lvm_vgactivate ()

gboolean            bd_lvm_vgactivate                   (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the to be activated VG

extra :

extra options for the VG activation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG was successfully activated or not

bd_lvm_vgdeactivate ()

gboolean            bd_lvm_vgdeactivate                 (const gchar *vg_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the to be deactivated VG

extra :

extra options for the VG deactivation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG was successfully deactivated or not

bd_lvm_vgextend ()

gboolean            bd_lvm_vgextend                     (const gchar *vg_name,
                                                         const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the to be extended VG

device :

PV device to extend the vg_name VG with

extra :

extra options for the VG extension (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG vg_name was successfully extended with the given device or not.

bd_lvm_vgreduce ()

gboolean            bd_lvm_vgreduce                     (const gchar *vg_name,
                                                         const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the to be reduced VG

device :

PV device the vg_name VG should be reduced of or NULL if the VG should be reduced of the missing PVs. [allow-none]

extra :

extra options for the VG reduction (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the VG vg_name was successfully reduced of the given device or not Note: This function does not move extents off of the PV before removing it from the VG. You must do that first by calling bd_lvm_pvmove.

bd_lvm_vginfo ()

BDLVMVGdata *       bd_lvm_vginfo                       (const gchar *vg_name,
                                                         GError **error);

vg_name :

a VG to get information about

error :

place to store error (if any). [out]

Returns :

information about the vg_name VG or NULL in case of error (the error) gets populated in those cases). [transfer full]

bd_lvm_vgs ()

BDLVMVGdata **      bd_lvm_vgs                          (GError **error);

error :

place to store error (if any). [out]

Returns :

information about VGs found in the system. [array zero-terminated=1]

bd_lvm_lvorigin ()

gchar *             bd_lvm_lvorigin                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

vg_name :

name of the VG containing the queried LV

lv_name :

name of the queried LV

error :

place to store error (if any). [out]

Returns :

the origin volume for the vg_name/lv_name LV or NULL if failed to determine (error) is set in those cases). [transfer full]

bd_lvm_lvcreate ()

gboolean            bd_lvm_lvcreate                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const gchar *type,
                                                         const gchar **pv_list,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG to create a new LV in

lv_name :

name of the to-be-created LV

size :

requested size of the new LV

type :

type of the new LV ("striped", "raid1",..., see lvcreate (8)). [allow-none]

pv_list :

list of PVs the newly created LV should use or NULL if not specified. [allow-none][array zero-terminated=1]

extra :

extra options for the LV creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the given vg_name/lv_name LV was successfully created or not

bd_lvm_lvremove ()

gboolean            bd_lvm_lvremove                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         gboolean force,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-removed LV

lv_name :

name of the to-be-removed LV

force :

whether to force removal or not

extra :

extra options for the LV removal (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name LV was successfully removed or not

bd_lvm_lvrename ()

gboolean            bd_lvm_lvrename                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         const gchar *new_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-renamed LV

lv_name :

name of the to-be-renamed LV

new_name :

new name for the vg_name/lv_name LV

extra :

extra options for the LV rename (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name LV was successfully renamed to vg_name/new_name or not

bd_lvm_lvresize ()

gboolean            bd_lvm_lvresize                     (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-resized LV

lv_name :

name of the to-be-resized LV

size :

the requested new size of the LV

extra :

extra options for the LV resize (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name LV was successfully resized or not

bd_lvm_lvactivate ()

gboolean            bd_lvm_lvactivate                   (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         gboolean ignore_skip,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-activated LV

lv_name :

name of the to-be-activated LV

ignore_skip :

whether to ignore the skip flag or not

extra :

extra options for the LV activation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name LV was successfully activated or not

bd_lvm_lvdeactivate ()

gboolean            bd_lvm_lvdeactivate                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-deactivated LV

lv_name :

name of the to-be-deactivated LV

extra :

extra options for the LV deactivation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name LV was successfully deactivated or not

bd_lvm_lvsnapshotcreate ()

gboolean            bd_lvm_lvsnapshotcreate             (const gchar *vg_name,
                                                         const gchar *origin_name,
                                                         const gchar *snapshot_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the LV a new snapshot should be created of

origin_name :

name of the LV a new snapshot should be created of

snapshot_name :

name fo the to-be-created snapshot

size :

requested size for the snapshot

extra :

extra options for the LV snapshot creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the snapshot_name snapshot of the vg_name/origin_name LV was successfully created or not.

bd_lvm_lvsnapshotmerge ()

gboolean            bd_lvm_lvsnapshotmerge              (const gchar *vg_name,
                                                         const gchar *snapshot_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the to-be-merged LV snapshot

snapshot_name :

name of the to-be-merged LV snapshot

extra :

extra options for the LV snapshot merge (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/snapshot_name LV snapshot was successfully merged or not

bd_lvm_lvinfo ()

BDLVMLVdata *       bd_lvm_lvinfo                       (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

vg_name :

name of the VG that contains the LV to get information about

lv_name :

name of the LV to get information about

error :

place to store error (if any). [out]

Returns :

information about the vg_name/lv_name LV or NULL in case of error (the error) gets populated in those cases). [transfer full]

bd_lvm_lvs ()

BDLVMLVdata **      bd_lvm_lvs                          (const gchar *vg_name,
                                                         GError **error);

vg_name :

name of the VG to get information about LVs from. [allow-none]

error :

place to store error (if any). [out]

Returns :

information about LVs found in the given vg_name VG or in system if vg_name is NULL. [array zero-terminated=1]

bd_lvm_thpoolcreate ()

gboolean            bd_lvm_thpoolcreate                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         guint64 md_size,
                                                         guint64 chunk_size,
                                                         const gchar *profile,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG to create a thin pool in

lv_name :

name of the to-be-created pool LV

size :

requested size of the to-be-created pool

md_size :

requested metadata size or 0 to use the default

chunk_size :

requested chunk size or 0 to use the default

profile :

profile to use (see lvm(8) for more information) or NULL to use the default. [allow-none]

extra :

extra options for the thin pool creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name thin pool was successfully created or not

bd_lvm_thpool_convert ()

gboolean            bd_lvm_thpool_convert               (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *metadata_lv,
                                                         const gchar *name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

Converts the data_lv and metadata_lv into a new thin pool in the vg_name VG.

vg_name :

name of the VG to create the new thin pool in

data_lv :

name of the LV that should become the data part of the new pool

metadata_lv :

name of the LV that should become the metadata part of the new pool

name :

name for the thin pool (if NULL, the name data_lv is inherited). [allow-none]

extra :

extra options for the thin pool creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the new thin pool was successfully created from data_lv and metadata_lv or not

bd_lvm_thlvcreate ()

gboolean            bd_lvm_thlvcreate                   (const gchar *vg_name,
                                                         const gchar *pool_name,
                                                         const gchar *lv_name,
                                                         guint64 size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the thin pool providing extents for the to-be-created thin LV

pool_name :

name of the pool LV providing extents for the to-be-created thin LV

lv_name :

name of the to-be-created thin LV

size :

requested virtual size of the to-be-created thin LV

extra :

extra options for the thin LV creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the vg_name/lv_name thin LV was successfully created or not

bd_lvm_thlvpoolname ()

gchar *             bd_lvm_thlvpoolname                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

vg_name :

name of the VG containing the queried thin LV

lv_name :

name of the queried thin LV

error :

place to store error (if any). [out]

Returns :

the name of the pool volume for the vg_name/lv_name thin LV or NULL if failed to determine (error) is set in those cases). [transfer full]

bd_lvm_thsnapshotcreate ()

gboolean            bd_lvm_thsnapshotcreate             (const gchar *vg_name,
                                                         const gchar *origin_name,
                                                         const gchar *snapshot_name,
                                                         const gchar *pool_name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the thin LV a new snapshot should be created of

origin_name :

name of the thin LV a new snapshot should be created of

snapshot_name :

name fo the to-be-created snapshot

pool_name :

name of the thin pool to create the snapshot in or NULL if not specified. [allow-none]

extra :

extra options for the thin LV snapshot creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the snapshot_name snapshot of the vg_name/origin_name thin LV was successfully created or not.

bd_lvm_set_global_config ()

gboolean            bd_lvm_set_global_config            (const gchar *new_config,
                                                         GError **error);

new_config :

string representation of the new global LVM configuration to set or NULL to reset to default. [allow-none]

error :

place to store error (if any). [out]

Returns :

whether the new requested global config new_config was successfully set or not

bd_lvm_get_global_config ()

gchar *             bd_lvm_get_global_config            (GError **error);

error :

place to store error (if any). [out]

Returns :

a copy of a string representation of the currently set LVM global configuration

bd_lvm_cache_attach ()

gboolean            bd_lvm_cache_attach                 (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *cache_pool_lv,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the data_lv and the cache_pool_lv LVs

data_lv :

data LV to attache the cache_pool_lv to

cache_pool_lv :

cache pool LV to attach to the data_lv

extra :

extra options for the cache attachment (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the cache_pool_lv was successfully attached to the data_lv or not

bd_lvm_cache_create_cached_lv ()

gboolean            bd_lvm_cache_create_cached_lv       (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         guint64 data_size,
                                                         guint64 cache_size,
                                                         guint64 md_size,
                                                         BDLVMCacheMode mode,
                                                         BDLVMCachePoolFlags flags,
                                                         const gchar **slow_pvs,
                                                         const gchar **fast_pvs,
                                                         GError **error);

vg_name :

name of the VG to create a cached LV in

lv_name :

name of the cached LV to create

data_size :

size of the data LV

cache_size :

size of the cache (or cached LV more precisely)

md_size :

size of the cache metadata LV or 0 to use the default

mode :

cache mode for the cached LV

flags :

a combination of (ORed) BDLVMCachePoolFlags

slow_pvs :

list of slow PVs (used for the data LV). [array zero-terminated=1]

fast_pvs :

list of fast PVs (used for the cache LV). [array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the cached LV lv_name was successfully created or not

bd_lvm_cache_create_pool ()

gboolean            bd_lvm_cache_create_pool            (const gchar *vg_name,
                                                         const gchar *pool_name,
                                                         guint64 pool_size,
                                                         guint64 md_size,
                                                         BDLVMCacheMode mode,
                                                         BDLVMCachePoolFlags flags,
                                                         const gchar **fast_pvs,
                                                         GError **error);

vg_name :

name of the VG to create pool_name in

pool_name :

name of the cache pool LV to create

pool_size :

desired size of the cache pool pool_name

md_size :

desired size of the pool_name cache pool's metadata LV or 0 to use the default

mode :

cache mode of the pool_name cache pool

flags :

a combination of (ORed) BDLVMCachePoolFlags

fast_pvs :

list of (fast) PVs to create the pool_name cache pool (and the metadata LV). [array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the cache pool vg_name/pool_name was successfully created or not

bd_lvm_cache_pool_convert ()

gboolean            bd_lvm_cache_pool_convert           (const gchar *vg_name,
                                                         const gchar *data_lv,
                                                         const gchar *metadata_lv,
                                                         const gchar *name,
                                                         const BDExtraArg **extra,
                                                         GError **error);

Converts the data_lv and metadata_lv into a new cache pool in the vg_name VG.

vg_name :

name of the VG to create the new thin pool in

data_lv :

name of the LV that should become the data part of the new pool

metadata_lv :

name of the LV that should become the metadata part of the new pool

name :

name for the thin pool (if NULL, the name data_lv is inherited). [allow-none]

extra :

extra options for the thin pool creation (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the new cache pool was successfully created from data_lv and metadata_lv or not

bd_lvm_cache_detach ()

gboolean            bd_lvm_cache_detach                 (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         gboolean destroy,
                                                         const BDExtraArg **extra,
                                                         GError **error);

vg_name :

name of the VG containing the cached_lv

cached_lv :

name of the cached LV to detach its cache from

destroy :

whether to destroy the cache after detach or not

extra :

extra options for the cache detachment (just passed to LVM as is). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the cache was successfully detached from the cached_lv or not Note: synces the cache first

bd_lvm_cache_get_default_md_size ()

guint64             bd_lvm_cache_get_default_md_size    (guint64 cache_size,
                                                         GError **error);

cache_size :

size of the cache to determine MD size for

error :

place to store error (if any). [out]

Returns :

recommended default size of the cache metadata LV or 0 in case of error

bd_lvm_cache_get_mode_from_str ()

BDLVMCacheMode      bd_lvm_cache_get_mode_from_str      (const gchar *mode_str,
                                                         GError **error);

mode_str :

string representation of a cache mode

error :

place to store error (if any). [out]

Returns :

cache mode for the mode_str or BD_LVM_CACHE_MODE_UNKNOWN if failed to determine

bd_lvm_cache_get_mode_str ()

const gchar *       bd_lvm_cache_get_mode_str           (BDLVMCacheMode mode,
                                                         GError **error);

mode :

mode to get the string representation for

error :

place to store error (if any). [out]

Returns :

string representation of mode or NULL in case of error

bd_lvm_cache_pool_name ()

gchar *             bd_lvm_cache_pool_name              (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         GError **error);

vg_name :

name of the VG containing the cached_lv

cached_lv :

cached LV to get the name of the its pool LV for

error :

place to store error (if any). [out]

Returns :

name of the cache pool LV used by the cached_lv or NULL in case of error

bd_lvm_cache_stats ()

BDLVMCacheStats *   bd_lvm_cache_stats                  (const gchar *vg_name,
                                                         const gchar *cached_lv,
                                                         GError **error);

vg_name :

name of the VG containing the cached_lv

cached_lv :

cached LV to get stats for

error :

place to store error (if any). [out]

Returns :

stats for the cached_lv or NULL in case of error

bd_lvm_data_lv_name ()

gchar *             bd_lvm_data_lv_name                 (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

vg_name :

name of the VG containing the queried LV

lv_name :

name of the queried LV

error :

place to store error (if any). [out]

Returns :

the name of the (internal) data LV of the vg_name/lv_name LV. [transfer full]

bd_lvm_metadata_lv_name ()

gchar *             bd_lvm_metadata_lv_name             (const gchar *vg_name,
                                                         const gchar *lv_name,
                                                         GError **error);

vg_name :

name of the VG containing the queried LV

lv_name :

name of the queried LV

error :

place to store error (if any). [out]

Returns :

the name of the (internal) metadata LV of the vg_name/lv_name LV. [transfer full]