mirror of
git://sourceware.org/git/lvm2.git
synced 2024-10-30 06:26:11 +03:00
fcbef05aae
Hmm rpmlint suggest fsf is using a different address these days, so lets keep it up-to-date
1980 lines
51 KiB
C
1980 lines
51 KiB
C
/*
|
|
* Copyright (C) 2008-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#ifndef _LIB_LVM2APP_H
|
|
#define _LIB_LVM2APP_H
|
|
|
|
#include <libdevmapper.h>
|
|
|
|
#include <stdint.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/******************************** WARNING ***********************************
|
|
*
|
|
* NOTE: This API is under development and subject to change at any time.
|
|
*
|
|
* Please send feedback to lvm-devel@redhat.com
|
|
*
|
|
*********************************** WARNING ********************************/
|
|
|
|
/*************************** Design Overview ********************************/
|
|
|
|
/**
|
|
* \mainpage LVM library API
|
|
*
|
|
* The API is designed around the following basic LVM objects:
|
|
* 1) Physical Volume (pv_t) 2) Volume Group (vg_t) 3) Logical Volume (lv_t).
|
|
*
|
|
* The library provides functions to list the objects in a system,
|
|
* get and set object properties (such as names, UUIDs, and sizes), as well
|
|
* as create/remove objects and perform more complex operations and
|
|
* transformations. Each object instance is represented by a handle, and
|
|
* handles are passed to and from the functions to perform the operations.
|
|
*
|
|
* A central object in the library is the Volume Group, represented by the
|
|
* VG handle, vg_t. Performing an operation on a PV or LV object first
|
|
* requires obtaining a VG handle. Once the vg_t has been obtained, it can
|
|
* be used to enumerate the pv_t and lv_t objects within that vg_t. Attributes
|
|
* of these objects can then be queried or changed.
|
|
*
|
|
* A volume group handle may be obtained with read or write permission.
|
|
* Any attempt to change a property of a pv_t, vg_t, or lv_t without
|
|
* obtaining write permission on the vg_t will fail with EPERM.
|
|
*
|
|
* An application first opening a VG read-only, then later wanting to change
|
|
* a property of an object must first close the VG and re-open with write
|
|
* permission. Currently liblvm provides no mechanism to determine whether
|
|
* the VG has changed on-disk in between these operations - this is the
|
|
* application's responsiblity. One way the application can ensure the VG
|
|
* has not changed is to save the "vg_seqno" field after opening the VG with
|
|
* READ permission. If the application later needs to modify the VG, it can
|
|
* close the VG and re-open with WRITE permission. It should then check
|
|
* whether the original "vg_seqno" obtained with READ permission matches
|
|
* the new one obtained with WRITE permission.
|
|
*/
|
|
|
|
/**
|
|
* Retrieve the library version.
|
|
*
|
|
* The library version is the same format as the full LVM version.
|
|
* The format is as follows:
|
|
* LVM_MAJOR.LVM_MINOR.LVM_PATCHLEVEL(LVM_LIBAPI)[-LVM_RELEASE]
|
|
* An application wishing to determine compatibility with a particular version
|
|
* of the library should check at least the LVM_MAJOR, LVM_MINOR, and
|
|
* LVM_LIBAPI numbers. For example, assume the full LVM version is
|
|
* 2.02.50(1)-1. The application should verify the "2.02" and the "(1)".
|
|
*
|
|
* \return A string describing the library version.
|
|
*/
|
|
const char *lvm_library_get_version(void);
|
|
|
|
/******************************** structures ********************************/
|
|
|
|
/**
|
|
* Opaque C pointers - Internal structures may change without notice between
|
|
* releases, whereas this API will be changed much less frequently. Backwards
|
|
* compatibility will normally be preserved in future releases. On any occasion
|
|
* when the developers do decide to break backwards compatibility in any
|
|
* significant way, the LVM_LIBAPI number (included in the library's soname)
|
|
* will be incremented.
|
|
*/
|
|
|
|
/**
|
|
* \class lvm_t
|
|
*
|
|
* This is the base handle that is needed to open and create objects such as
|
|
* volume groups and logical volumes. In addition, this handle provides a
|
|
* context for error handling information, saving any error number (see
|
|
* lvm_errno()) and error message (see lvm_errmsg()) that any function may
|
|
* generate.
|
|
*/
|
|
typedef struct lvm *lvm_t;
|
|
|
|
/**
|
|
* \class vg_t
|
|
*
|
|
* The volume group object is a central object in the library, and can be
|
|
* either a read-only object or a read-write object depending on the function
|
|
* used to obtain the object handle. For example, lvm_vg_create() always
|
|
* returns a read/write handle, while lvm_vg_open() has a "mode" argument
|
|
* to define the read/write mode of the handle.
|
|
*/
|
|
typedef struct volume_group *vg_t;
|
|
|
|
/**
|
|
* \class lv_t
|
|
*
|
|
* This logical volume object is bound to a vg_t and has the same
|
|
* read/write mode as the vg_t. Changes will be written to disk
|
|
* when the vg_t gets committed to disk by calling lvm_vg_write().
|
|
*/
|
|
typedef struct logical_volume *lv_t;
|
|
|
|
/**
|
|
* \class pv_t
|
|
*
|
|
* This physical volume object is bound to a vg_t and has the same
|
|
* read/write mode as the vg_t. Changes will be written to disk
|
|
* when the vg_t gets committed to disk by calling lvm_vg_write().
|
|
*/
|
|
typedef struct physical_volume *pv_t;
|
|
|
|
/**
|
|
* \class lvseg_t
|
|
*
|
|
* This lv segment object is bound to a lv_t.
|
|
*/
|
|
typedef struct lv_segment *lvseg_t;
|
|
|
|
/**
|
|
* \class pvseg_t
|
|
*
|
|
* This pv segment object is bound to a pv_t.
|
|
*/
|
|
typedef struct pv_segment *pvseg_t;
|
|
|
|
/**
|
|
* \class lv_create_params
|
|
*
|
|
* This lv_create_params represents the plethora of available options when
|
|
* creating a logical volume
|
|
*/
|
|
typedef struct lvm_lv_create_params *lv_create_params_t;
|
|
|
|
/**
|
|
* \class pv_create_params
|
|
*
|
|
* This pv_create_params represents the plethora of available options when
|
|
* creating a physical volume
|
|
*/
|
|
typedef struct lvm_pv_create_params *pv_create_params_t;
|
|
|
|
/**
|
|
* Logical Volume object list.
|
|
*
|
|
* Lists of these structures are returned by lvm_vg_list_lvs().
|
|
*/
|
|
typedef struct lvm_lv_list {
|
|
struct dm_list list;
|
|
lv_t lv;
|
|
} lv_list_t;
|
|
|
|
/**
|
|
* Logical Volume Segment object list.
|
|
*
|
|
* Lists of these structures are returned by lvm_lv_list_lvsegs().
|
|
*/
|
|
typedef struct lvm_lvseg_list {
|
|
struct dm_list list;
|
|
lvseg_t lvseg;
|
|
} lvseg_list_t;
|
|
|
|
/**
|
|
* Physical volume object list.
|
|
*
|
|
* Lists of these structures are returned by lvm_vg_list_pvs().
|
|
*/
|
|
typedef struct lvm_pv_list {
|
|
struct dm_list list;
|
|
pv_t pv;
|
|
} pv_list_t;
|
|
|
|
/**
|
|
* Physical Volume Segment object list.
|
|
*
|
|
* Lists of these structures are returned by lvm_pv_list_pvsegs().
|
|
*/
|
|
typedef struct lvm_pvseg_list {
|
|
struct dm_list list;
|
|
pvseg_t pvseg;
|
|
} pvseg_list_t;
|
|
|
|
/**
|
|
* String list.
|
|
*
|
|
* This string list contains read-only strings.
|
|
* Lists of these structures are returned by functions such as
|
|
* lvm_list_vg_names() and lvm_list_vg_uuids().
|
|
*/
|
|
typedef struct lvm_str_list {
|
|
struct dm_list list;
|
|
const char *str;
|
|
} lvm_str_list_t;
|
|
|
|
/**
|
|
* Property Value
|
|
*
|
|
* This structure defines a single LVM property value for an LVM object.
|
|
* The structures are returned by functions such as
|
|
* lvm_vg_get_property().
|
|
*
|
|
* is_settable: indicates whether a 'set' function exists for this property
|
|
* is_string: indicates whether this property is a string (1) or not (0)
|
|
* is_integer: indicates whether this property is an integer (1) or not (0)
|
|
* is_valid: indicates whether 'value' is valid (1) or not (0)
|
|
*/
|
|
typedef struct lvm_property_value {
|
|
uint32_t is_settable:1;
|
|
uint32_t is_string:1;
|
|
uint32_t is_integer:1;
|
|
uint32_t is_valid:1;
|
|
uint32_t is_signed:1;
|
|
uint32_t padding:27;
|
|
union {
|
|
const char *string;
|
|
uint64_t integer;
|
|
int64_t signed_integer;
|
|
} value;
|
|
} lvm_property_value_t;
|
|
|
|
/*************************** generic lvm handling ***************************/
|
|
/**
|
|
* Create a LVM handle.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* Once all LVM operations have been completed, use lvm_quit() to release
|
|
* the handle and any associated resources.
|
|
*
|
|
* \param system_dir
|
|
* Set an alternative LVM system directory. Use NULL to use the
|
|
* default value. If the environment variable LVM_SYSTEM_DIR is set,
|
|
* it will override any system_dir setting.
|
|
*
|
|
* \return
|
|
* A valid LVM handle is returned or NULL if there has been a
|
|
* memory allocation problem. You have to check if an error occured
|
|
* with the lvm_error() function.
|
|
*/
|
|
lvm_t lvm_init(const char *system_dir);
|
|
|
|
/**
|
|
* Destroy a LVM handle allocated with lvm_init().
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function should be used after all LVM operations are complete or after
|
|
* an unrecoverable error. Destroying the LVM handle frees the memory and
|
|
* other resources associated with the handle. Once destroyed, the handle
|
|
* cannot be used subsequently.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*/
|
|
void lvm_quit(lvm_t libh);
|
|
|
|
/**
|
|
* Reload the original configuration from the system directory.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function should be used when any LVM configuration changes in the LVM
|
|
* system_dir or by another lvm_config* function, and the change is needed by
|
|
* the application.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_config_reload(lvm_t libh);
|
|
|
|
/**
|
|
* Override the LVM configuration with a configuration string.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function is equivalent to the --config option on lvm commands.
|
|
* Once this API has been used to over-ride the configuration,
|
|
* use lvm_config_reload() to apply the new settings.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \param config_string
|
|
* LVM configuration string to apply. See the lvm.conf file man page
|
|
* for the format of the config string.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_config_override(lvm_t libh, const char *config_string);
|
|
|
|
/**
|
|
* Find a boolean value in the LVM configuration.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function finds a boolean value associated with a path
|
|
* in current LVM configuration.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \param config_path
|
|
* A path in LVM configuration
|
|
*
|
|
* \param fail
|
|
* Value to return if the path is not found.
|
|
*
|
|
* \return
|
|
* boolean value for 'config_path' (success) or the value of 'fail' (error)
|
|
*/
|
|
int lvm_config_find_bool(lvm_t libh, const char *config_path, int fail);
|
|
|
|
/**
|
|
* Return stored error no describing last LVM API error.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* Users of liblvm should use lvm_errno to determine the details of a any
|
|
* failure of the last call. A basic success or fail is always returned by
|
|
* every function, either by returning a 0 or -1, or a non-NULL / NULL.
|
|
* If a function has failed, lvm_errno may be used to get a more specific
|
|
* error code describing the failure. In this way, lvm_errno may be used
|
|
* after every function call, even after a 'get' function call that simply
|
|
* returns a value.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* An errno value describing the last LVM error.
|
|
*/
|
|
int lvm_errno(lvm_t libh);
|
|
|
|
/**
|
|
* Return stored error message describing last LVM error.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function may be used in conjunction with lvm_errno() to obtain more
|
|
* specific error information for a function that is known to have failed.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* An error string describing the last LVM error.
|
|
*/
|
|
const char *lvm_errmsg(lvm_t libh);
|
|
|
|
/**
|
|
* Scan all devices on the system for VGs and LVM metadata.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_scan(lvm_t libh);
|
|
|
|
/**
|
|
* Return the list of volume group names.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* The memory allocated for the list is tied to the lvm_t handle and will be
|
|
* released when lvm_quit() is called.
|
|
*
|
|
* NOTE: This function normally does not scan devices in the system for LVM
|
|
* metadata. To scan the system, use lvm_scan().
|
|
*
|
|
* To process the list, use the dm_list iterator functions. For example:
|
|
* vg_t vg;
|
|
* struct dm_list *vgnames;
|
|
* struct lvm_str_list *strl;
|
|
*
|
|
* vgnames = lvm_list_vg_names(libh);
|
|
* dm_list_iterate_items(strl, vgnames) {
|
|
* vgname = strl->str;
|
|
* vg = lvm_vg_open(libh, vgname, "r");
|
|
* // do something with vg
|
|
* lvm_vg_close(vg);
|
|
* }
|
|
*
|
|
*
|
|
* \return
|
|
* A list with entries of type struct lvm_str_list, containing the
|
|
* VG name strings of the Volume Groups known to the system.
|
|
* NULL is returned if unable to allocate memory.
|
|
* An empty list (verify with dm_list_empty) is returned if no VGs
|
|
* exist on the system.
|
|
*/
|
|
struct dm_list *lvm_list_vg_names(lvm_t libh);
|
|
|
|
/**
|
|
* Return the list of volume group uuids.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* The memory allocated for the list is tied to the lvm_t handle and will be
|
|
* released when lvm_quit() is called.
|
|
*
|
|
* NOTE: This function normally does not scan devices in the system for LVM
|
|
* metadata. To scan the system, use lvm_scan().
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* A list with entries of type struct lvm_str_list, containing the
|
|
* VG UUID strings of the Volume Groups known to the system.
|
|
* NULL is returned if unable to allocate memory.
|
|
* An empty list (verify with dm_list_empty) is returned if no VGs
|
|
* exist on the system.
|
|
*/
|
|
struct dm_list *lvm_list_vg_uuids(lvm_t libh);
|
|
|
|
/**
|
|
* Return the volume group name given a PV UUID
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* The memory allocated for the name is tied to the lvm_t handle and will be
|
|
* released when lvm_quit() is called.
|
|
*
|
|
* NOTE: This function may scan devices in the system for LVM metadata.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* The volume group name for the given PV UUID.
|
|
* NULL is returned if the PV UUID is not associated with a volume group.
|
|
*/
|
|
const char *lvm_vgname_from_pvid(lvm_t libh, const char *pvid);
|
|
|
|
/**
|
|
* Return the volume group name given a device name
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* The memory allocated for the name is tied to the lvm_t handle and will be
|
|
* released when lvm_quit() is called.
|
|
*
|
|
* NOTE: This function may scan devices in the system for LVM metadata.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \return
|
|
* The volume group name for the given device name.
|
|
* NULL is returned if the device is not an LVM device.
|
|
*
|
|
*/
|
|
const char *lvm_vgname_from_device(lvm_t libh, const char *device);
|
|
|
|
/**
|
|
* Open an existing VG.
|
|
*
|
|
* Open a VG for reading or writing.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \param vgname
|
|
* Name of the VG to open.
|
|
*
|
|
* \param mode
|
|
* Open mode - either "r" (read) or "w" (read/write).
|
|
* Any other character results in an error with EINVAL set.
|
|
*
|
|
* \param flags
|
|
* Open flags - currently ignored.
|
|
*
|
|
* \return non-NULL VG handle (success) or NULL (failure).
|
|
*/
|
|
vg_t lvm_vg_open(lvm_t libh, const char *vgname, const char *mode,
|
|
uint32_t flags);
|
|
|
|
/**
|
|
* Validate a name to be used for new VG construction.
|
|
*
|
|
* This function checks that the name has no invalid characters,
|
|
* the length doesn't exceed maximum and that the VG name isn't already in use
|
|
* and that the name adheres to any other limitations.
|
|
*
|
|
* \param libh
|
|
* Valid library handle
|
|
*
|
|
* \param name
|
|
* Name to validate for new VG create.
|
|
*/
|
|
int lvm_vg_name_validate(lvm_t libh, const char *vg_name);
|
|
|
|
/**
|
|
* Create a VG with default parameters.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* This function creates a Volume Group object in memory.
|
|
* Upon success, other APIs may be used to set non-default parameters.
|
|
* For example, to set a non-default extent size, use lvm_vg_set_extent_size().
|
|
* Next, to add physical storage devices to the volume group, use
|
|
* lvm_vg_extend() for each device.
|
|
* Once all parameters are set appropriately and all devices are added to the
|
|
* VG, use lvm_vg_write() to commit the new VG to disk, and lvm_vg_close() to
|
|
* release the VG handle.
|
|
*
|
|
* \param libh
|
|
* Handle obtained from lvm_init().
|
|
*
|
|
* \param vg_name
|
|
* Name of the VG to open.
|
|
*
|
|
* \return
|
|
* non-NULL vg handle (success) or NULL (failure)
|
|
*/
|
|
vg_t lvm_vg_create(lvm_t libh, const char *vg_name);
|
|
|
|
/*************************** volume group handling **************************/
|
|
|
|
/**
|
|
* Return a list of LV handles for a given VG handle.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* A list of lvm_lv_list structures containing lv handles for this vg.
|
|
* If no LVs exist on the given VG, NULL is returned.
|
|
*/
|
|
struct dm_list *lvm_vg_list_lvs(vg_t vg);
|
|
|
|
/**
|
|
* Return a list of PV handles for all.
|
|
*
|
|
* \memberof lvm_t
|
|
*
|
|
* \param libh
|
|
* Library handle retrieved from lvm_init
|
|
*
|
|
* \return
|
|
* A list of lvm_pv_list structures containing pv handles for all physical
|
|
* volumes. If no PVs exist or a global lock was unable to be obtained a
|
|
* NULL is returned. Do not attempt to remove one of the PVs until after the
|
|
* call to lvm_list_pvs_free has been made.
|
|
*/
|
|
struct dm_list *lvm_list_pvs(lvm_t libh);
|
|
|
|
/**
|
|
* Free the resources used by acquiring the pvlist. This should be called as
|
|
* soon as possible after processing the needed information from the pv list as
|
|
* a global lock is held.
|
|
*
|
|
* \param pvlist
|
|
* PV list to be freed
|
|
*
|
|
* \return
|
|
* 0 on success, else -1 with library errno and text set.
|
|
*/
|
|
int lvm_list_pvs_free(struct dm_list *pvlist);
|
|
|
|
/**
|
|
* Create a physical volume.
|
|
* \param libh Library handle
|
|
* \param pv_name The physical volume name
|
|
* \param size Size of physical volume, 0 = use all available.
|
|
* \return
|
|
* 0 on success, else -1 with library errno and text set.
|
|
*/
|
|
int lvm_pv_create(lvm_t libh, const char *pv_name, uint64_t size);
|
|
|
|
/**
|
|
* Create a physical volume parameter object for PV creation.
|
|
*
|
|
* \param libh Library handle
|
|
* \param pv_name Device name
|
|
*
|
|
* \return
|
|
* NULL on error, else valid parameter object to use.
|
|
*/
|
|
pv_create_params_t lvm_pv_params_create(lvm_t libh, const char *pv_name);
|
|
|
|
/**
|
|
* Create a parameter object to use in function lvm_pv_create_adv
|
|
*
|
|
* \param params The params object to get property value from
|
|
* \param name The name of the property to retrieve
|
|
*
|
|
* Available properties:
|
|
*
|
|
* size zero indicates use detected size of device
|
|
* (recommended and default)
|
|
* pvmetadatacopies Number of metadata copies (0,1,2)
|
|
* pvmetadatasize The approx. size to be to be set aside for metadata
|
|
* data_alignment Align the start of the data to a multiple of
|
|
* this number
|
|
* data_alignment_offset Shift the start of the data area by this addl.
|
|
* offset
|
|
* zero Set to 1 to zero out first 2048 bytes of
|
|
* device, 0 to not (default is 1)
|
|
*
|
|
* \return
|
|
* lvm_property_value
|
|
*/
|
|
struct lvm_property_value lvm_pv_params_get_property(
|
|
const pv_create_params_t params,
|
|
const char *name);
|
|
|
|
/**
|
|
* Sets a property of a PV parameter create object.
|
|
*
|
|
* \param params The parameter object
|
|
* \param name The name of the property to set (see get prop list)
|
|
* \param prop The property to set the value on.
|
|
*/
|
|
int lvm_pv_params_set_property(pv_create_params_t params, const char *name,
|
|
struct lvm_property_value *prop);
|
|
/**
|
|
* Creates a physical volume using the supplied params object.
|
|
*
|
|
* \param params The parameters to use for physical volume creation
|
|
*
|
|
* \return
|
|
* -1 on error, 0 on success.
|
|
*/
|
|
int lvm_pv_create_adv(pv_create_params_t params);
|
|
|
|
/**
|
|
* Remove a physical volume.
|
|
* Note: You cannot remove a PV while iterating through the list of PVs as
|
|
* locks are held for the PV list.
|
|
* \param libh Library handle
|
|
* \param pv_name The physical volume name
|
|
* \return
|
|
* 0 on success, else -1 with library errno and text set.
|
|
*/
|
|
int lvm_pv_remove(lvm_t libh, const char *pv_name);
|
|
|
|
/**
|
|
* Return a list of PV handles for a given VG handle.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* A list of lvm_pv_list structures containing pv handles for this vg.
|
|
* If no PVs exist on the given VG, NULL is returned.
|
|
*/
|
|
struct dm_list *lvm_vg_list_pvs(vg_t vg);
|
|
|
|
/**
|
|
* Write a VG to disk.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function commits the Volume Group object referenced by the VG handle
|
|
* to disk. Upon failure, retry the operation and/or release the VG handle
|
|
* with lvm_vg_close().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_write(vg_t vg);
|
|
|
|
/**
|
|
* Remove a VG from the system.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function removes a Volume Group object in memory, and requires
|
|
* calling lvm_vg_write() to commit the removal to disk.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_remove(vg_t vg);
|
|
|
|
/**
|
|
* Close a VG opened with lvm_vg_create or lvm_vg_open().
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function releases a VG handle and any resources associated with the
|
|
* handle.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_close(vg_t vg);
|
|
|
|
/**
|
|
* Extend a VG by adding a device.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully adding a device, use lvm_vg_write() to commit the new VG
|
|
* to disk. Upon failure, retry the operation or release the VG handle with
|
|
* lvm_vg_close().
|
|
* If the device is not initialized for LVM use, it will be initialized
|
|
* before adding to the VG. Although some internal checks are done,
|
|
* the caller should be sure the device is not in use by other subsystems
|
|
* before calling lvm_vg_extend().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param device
|
|
* Absolute pathname of device to add to VG.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_extend(vg_t vg, const char *device);
|
|
|
|
/**
|
|
* Reduce a VG by removing an unused device.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully removing a device, use lvm_vg_write() to commit the new VG
|
|
* to disk. Upon failure, retry the operation or release the VG handle with
|
|
* lvm_vg_close().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param device
|
|
* Name of device to remove from VG.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_reduce(vg_t vg, const char *device);
|
|
|
|
/**
|
|
* Add a tag to a VG.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully adding a tag, use lvm_vg_write() to commit the
|
|
* new VG to disk. Upon failure, retry the operation or release the VG handle
|
|
* with lvm_vg_close().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param tag
|
|
* Tag to add to the VG.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_add_tag(vg_t vg, const char *tag);
|
|
|
|
/**
|
|
* Remove a tag from a VG.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully removing a tag, use lvm_vg_write() to commit the
|
|
* new VG to disk. Upon failure, retry the operation or release the VG handle
|
|
* with lvm_vg_close().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param tag
|
|
* Tag to remove from VG.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_remove_tag(vg_t vg, const char *tag);
|
|
|
|
/**
|
|
* Set the extent size of a VG.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully setting a new extent size, use lvm_vg_write() to commit
|
|
* the new VG to disk. Upon failure, retry the operation or release the VG
|
|
* handle with lvm_vg_close().
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param new_size
|
|
* New extent size in bytes.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_set_extent_size(vg_t vg, uint32_t new_size);
|
|
|
|
/**
|
|
* Get whether or not a volume group is clustered.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 1 if the VG is clustered, 0 if not
|
|
*/
|
|
uint64_t lvm_vg_is_clustered(vg_t vg);
|
|
|
|
/**
|
|
* Get whether or not a volume group is exported.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 1 if the VG is exported, 0 if not
|
|
*/
|
|
uint64_t lvm_vg_is_exported(vg_t vg);
|
|
|
|
/**
|
|
* Get whether or not a volume group is a partial volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* When one or more physical volumes belonging to the volume group
|
|
* are missing from the system the volume group is a partial volume
|
|
* group.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* 1 if the VG is PVs, 0 if not
|
|
*/
|
|
uint64_t lvm_vg_is_partial(vg_t vg);
|
|
|
|
/**
|
|
* Get the current metadata sequence number of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* The metadata sequence number is incrented for each metadata change.
|
|
* Applications may use the sequence number to determine if any LVM objects
|
|
* have changed from a prior query.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Metadata sequence number.
|
|
*/
|
|
uint64_t lvm_vg_get_seqno(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current uuid of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* The memory allocated for the uuid is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Copy of the uuid string.
|
|
*/
|
|
const char *lvm_vg_get_uuid(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current name of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* The memory allocated for the name is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Copy of the name.
|
|
*/
|
|
const char *lvm_vg_get_name(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current size in bytes of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Size in bytes.
|
|
*/
|
|
uint64_t lvm_vg_get_size(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current unallocated space in bytes of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Free size in bytes.
|
|
*/
|
|
uint64_t lvm_vg_get_free_size(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current extent size in bytes of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Extent size in bytes.
|
|
*/
|
|
uint64_t lvm_vg_get_extent_size(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current number of total extents of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Extent count.
|
|
*/
|
|
uint64_t lvm_vg_get_extent_count(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current number of free extents of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Free extent count.
|
|
*/
|
|
uint64_t lvm_vg_get_free_extent_count(const vg_t vg);
|
|
|
|
/**
|
|
* Get the current number of physical volumes of a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Physical volume count.
|
|
*/
|
|
uint64_t lvm_vg_get_pv_count(const vg_t vg);
|
|
|
|
/**
|
|
* Get the maximum number of physical volumes allowed in a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Maximum number of physical volumes allowed in a volume group.
|
|
*/
|
|
uint64_t lvm_vg_get_max_pv(const vg_t vg);
|
|
|
|
/**
|
|
* Get the maximum number of logical volumes allowed in a volume group.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \return
|
|
* Maximum number of logical volumes allowed in a volume group.
|
|
*/
|
|
uint64_t lvm_vg_get_max_lv(const vg_t vg);
|
|
|
|
/**
|
|
* Return the list of volume group tags.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* The memory allocated for the list is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* To process the list, use the dm_list iterator functions. For example:
|
|
* vg_t vg;
|
|
* struct dm_list *tags;
|
|
* struct lvm_str_list *strl;
|
|
*
|
|
* tags = lvm_vg_get_tags(vg);
|
|
* dm_list_iterate_items(strl, tags) {
|
|
* tag = strl->str;
|
|
* // do something with tag
|
|
* }
|
|
*
|
|
*
|
|
* \return
|
|
* A list with entries of type struct lvm_str_list, containing the
|
|
* tag strings attached to volume group.
|
|
* If no tags are attached to the given VG, an empty list is returned
|
|
* (check with dm_list_empty()).
|
|
* If there is a problem obtaining the list of tags, NULL is returned.
|
|
*/
|
|
struct dm_list *lvm_vg_get_tags(const vg_t vg);
|
|
|
|
/**
|
|
* Get the value of a VG property
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param name
|
|
* Name of property to query. See vgs man page for full list of properties
|
|
* that may be queried.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle and will be released when lvm_vg_close() is called.
|
|
*
|
|
* Example:
|
|
* lvm_property_value v;
|
|
* char *prop_name = "vg_mda_count";
|
|
*
|
|
* v = lvm_vg_get_property(vg, prop_name);
|
|
* if (!v.is_valid) {
|
|
* printf("Invalid property name or unable to query"
|
|
* "'%s', errno = %d.\n", prop_name, lvm_errno(libh));
|
|
* return;
|
|
* }
|
|
* if (v.is_string)
|
|
* printf(", value = %s\n", v.value.string);
|
|
* if (v.is_integer)
|
|
* printf(", value = %"PRIu64"\n", v.value.integer);
|
|
*
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check 'is_valid' flag before using
|
|
* the value. If 'is_valid' is not set, caller should check lvm_errno()
|
|
* for specific error.
|
|
*/
|
|
struct lvm_property_value lvm_vg_get_property(const vg_t vg, const char *name);
|
|
|
|
/**
|
|
* Set the value of a VG property. Note that the property must be
|
|
* a 'settable' property, as evidenced by the 'is_settable' flag
|
|
* when querying the property.
|
|
*
|
|
* \memberof vg_t
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle and will be released when lvm_vg_close() is called.
|
|
*
|
|
* Example (integer):
|
|
* lvm_property_value copies;
|
|
*
|
|
* if (lvm_vg_get_property(vg, "vg_mda_copies", &copies) < 0) {
|
|
* // Error - unable to query property
|
|
* }
|
|
* if (!copies.is_settable) {
|
|
* // Error - property not settable
|
|
* }
|
|
* copies.value.integer = 2;
|
|
* if (lvm_vg_set_property(vg, "vg_mda_copies", &copies) < 0) {
|
|
* // handle error
|
|
* }
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_set_property(const vg_t vg, const char *name,
|
|
struct lvm_property_value *value);
|
|
|
|
/************************** logical volume handling *************************/
|
|
|
|
/**
|
|
* Create a linear logical volume.
|
|
* This function commits the change to disk and does _not_ require calling
|
|
* lvm_vg_write().
|
|
* NOTE: The commit behavior of this function is subject to change
|
|
* as the API is developed.
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param name
|
|
* Name of logical volume to create.
|
|
*
|
|
* \param size
|
|
* Size of logical volume in extents.
|
|
*
|
|
* \return
|
|
* non-NULL handle to an LV object created, or NULL if creation fails.
|
|
*
|
|
*/
|
|
lv_t lvm_vg_create_lv_linear(vg_t vg, const char *name, uint64_t size);
|
|
|
|
/**
|
|
* Return a list of lvseg handles for a given LV handle.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* A list of lvm_lvseg_list structures containing lvseg handles for this lv.
|
|
*/
|
|
struct dm_list *lvm_lv_list_lvsegs(lv_t lv);
|
|
|
|
/**
|
|
* Lookup an LV handle in a VG by the LV name.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param name
|
|
* Name of LV to lookup.
|
|
*
|
|
* \return
|
|
* non-NULL handle to the LV 'name' attached to the VG.
|
|
* NULL is returned if the LV name is not associated with the VG handle.
|
|
*/
|
|
lv_t lvm_lv_from_name(vg_t vg, const char *name);
|
|
|
|
/**
|
|
* Lookup an LV handle in a VG by the LV uuid.
|
|
* The form of the uuid may be either the formatted, human-readable form,
|
|
* or the non-formatted form.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param uuid
|
|
* UUID of LV to lookup.
|
|
*
|
|
* \return
|
|
* non-NULL handle to the LV with 'uuid' attached to the VG.
|
|
* NULL is returned if the LV uuid is not associated with the VG handle.
|
|
*/
|
|
lv_t lvm_lv_from_uuid(vg_t vg, const char *uuid);
|
|
|
|
/**
|
|
* Activate a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* This function is the equivalent of the lvm command "lvchange -ay".
|
|
*
|
|
* NOTE: This function cannot currently handle LVs with an in-progress pvmove or
|
|
* lvconvert.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_lv_activate(lv_t lv);
|
|
|
|
/**
|
|
* Deactivate a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* This function is the equivalent of the lvm command "lvchange -an".
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_lv_deactivate(lv_t lv);
|
|
|
|
/**
|
|
* Remove a logical volume from a volume group.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* This function commits the change to disk and does _not_ require calling
|
|
* lvm_vg_write().
|
|
* NOTE: The commit behavior of this function is subject to change
|
|
* as the API is developed.
|
|
* Currently only removing linear LVs are possible.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_vg_remove_lv(lv_t lv);
|
|
|
|
/**
|
|
* Get the current name of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* The memory allocated for the uuid is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* Copy of the uuid string.
|
|
*/
|
|
const char *lvm_lv_get_uuid(const lv_t lv);
|
|
|
|
/**
|
|
* Get the current uuid of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* The memory allocated for the name is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* Copy of the name.
|
|
*/
|
|
const char *lvm_lv_get_name(const lv_t lv);
|
|
|
|
/**
|
|
* Get the attributes of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* The memory allocated for the name is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* Copy of the attributes for the logical volume
|
|
*/
|
|
const char *lvm_lv_get_attr(const lv_t lv);
|
|
|
|
/**
|
|
* Get the origin of a snapshot.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* The memory allocated for the name is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* Null if the logical volume is not a snapshot, else origin name.
|
|
*/
|
|
const char *lvm_lv_get_origin(const lv_t lv);
|
|
|
|
/**
|
|
* Get the current size in bytes of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* Size in bytes.
|
|
*/
|
|
uint64_t lvm_lv_get_size(const lv_t lv);
|
|
|
|
/**
|
|
* Get the value of a LV property
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param name
|
|
* Name of property to query. See lvs man page for full list of properties
|
|
* that may be queried.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle and will be released when lvm_vg_close() is called.
|
|
*
|
|
* Example:
|
|
* lvm_property_value v;
|
|
* char *prop_name = "seg_count";
|
|
*
|
|
* v = lvm_lv_get_property(lv, prop_name);
|
|
* if (!v.is_valid) {
|
|
* printf("Invalid property name or unable to query"
|
|
* "'%s', errno = %d.\n", prop_name, lvm_errno(libh));
|
|
* return;
|
|
* }
|
|
* if (v.is_string)
|
|
* printf(", value = %s\n", v.value.string);
|
|
* if (v.is_integer)
|
|
* printf(", value = %"PRIu64"\n", v.value.integer);
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check 'is_valid' flag before using
|
|
* the value. If 'is_valid' is not set, caller should check lvm_errno()
|
|
* for specific error.
|
|
*/
|
|
struct lvm_property_value lvm_lv_get_property(const lv_t lv, const char *name);
|
|
|
|
/**
|
|
* Get the value of a LV segment property
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lvseg
|
|
* Logical volume segment handle.
|
|
*
|
|
* \param name
|
|
* Name of property to query. See lvs man page for full list of properties
|
|
* that may be queried.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle and will be released when lvm_vg_close() is called.
|
|
*
|
|
* Example:
|
|
* lvm_property_value v;
|
|
* char *prop_name = "seg_start_pe";
|
|
*
|
|
* v = lvm_lvseg_get_property(lvseg, prop_name);
|
|
* if (lvm_errno(libh) || !v.is_valid) {
|
|
* // handle error
|
|
* printf("Invalid property name or unable to query"
|
|
* "'%s'.\n", prop_name);
|
|
* return;
|
|
* }
|
|
* if (v.is_string)
|
|
* printf(", value = %s\n", v.value.string);
|
|
* else
|
|
* printf(", value = %"PRIu64"\n", v.value.integer);
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check lvm_errno() as well
|
|
* as 'is_valid' flag before using the value.
|
|
*/
|
|
struct lvm_property_value lvm_lvseg_get_property(const lvseg_t lvseg,
|
|
const char *name);
|
|
|
|
/**
|
|
* Get the current activation state of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* 1 if the LV is active in the kernel, 0 if not
|
|
*/
|
|
uint64_t lvm_lv_is_active(const lv_t lv);
|
|
|
|
/**
|
|
* Get the current suspended state of a logical volume.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \return
|
|
* 1 if the LV is suspended in the kernel, 0 if not
|
|
*/
|
|
uint64_t lvm_lv_is_suspended(const lv_t lv);
|
|
|
|
/**
|
|
* Add a tag to an LV.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully adding a tag, use lvm_vg_write() to commit the
|
|
* new VG to disk. Upon failure, retry the operation or release the VG handle
|
|
* with lvm_vg_close().
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param tag
|
|
* Tag to add to an LV.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_lv_add_tag(lv_t lv, const char *tag);
|
|
|
|
/**
|
|
* Remove a tag from an LV.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* This function requires calling lvm_vg_write() to commit the change to disk.
|
|
* After successfully removing a tag, use lvm_vg_write() to commit the
|
|
* new VG to disk. Upon failure, retry the operation or release the VG handle
|
|
* with lvm_vg_close().
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param tag
|
|
* Tag to remove from LV.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_lv_remove_tag(lv_t lv, const char *tag);
|
|
|
|
/**
|
|
* Return the list of logical volume tags.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* The memory allocated for the list is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* To process the list, use the dm_list iterator functions. For example:
|
|
* lv_t lv;
|
|
* struct dm_list *tags;
|
|
* struct lvm_str_list *strl;
|
|
*
|
|
* tags = lvm_lv_get_tags(lv);
|
|
* dm_list_iterate_items(strl, tags) {
|
|
* tag = strl->str;
|
|
* // do something with tag
|
|
* }
|
|
*
|
|
*
|
|
* \return
|
|
* A list with entries of type struct lvm_str_list, containing the
|
|
* tag strings attached to volume group.
|
|
* If no tags are attached to the LV, an empty list is returned
|
|
* (check with dm_list_empty()).
|
|
* If there is a problem obtaining the list of tags, NULL is returned.
|
|
*/
|
|
struct dm_list *lvm_lv_get_tags(const lv_t lv);
|
|
|
|
/**
|
|
* Rename logical volume to new_name.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param new_name
|
|
* New name of logical volume.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*
|
|
*/
|
|
int lvm_lv_rename(lv_t lv, const char *new_name);
|
|
|
|
/**
|
|
* Resize logical volume to new_size bytes.
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param new_size
|
|
* New size in bytes.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*
|
|
*/
|
|
int lvm_lv_resize(const lv_t lv, uint64_t new_size);
|
|
|
|
/**
|
|
* Create a snapshot of a logical volume
|
|
*
|
|
* \memberof lv_t
|
|
*
|
|
* \param lv
|
|
* Logical volume handle.
|
|
*
|
|
* \param snap_name
|
|
* Name of the snapshot.
|
|
*
|
|
* \param max_snap_size
|
|
* Max snapshot space to use. If you pass zero the same amount of space as
|
|
* the origin will be used.
|
|
*
|
|
* \return
|
|
* Valid lv pointer on success, else NULL on error.
|
|
*
|
|
*/
|
|
lv_t lvm_lv_snapshot(const lv_t lv, const char *snap_name, uint64_t max_snap_size);
|
|
|
|
/**
|
|
* Validate a name to be used for LV creation.
|
|
*
|
|
* Validates that the name does not contain any invalid characters, max length
|
|
* and that the LV name doesn't already exist for this VG.
|
|
*
|
|
* Note: You can have the same LV name in different VGs, thus the reason this
|
|
* function requires that you specify a VG to check against.
|
|
*
|
|
* \param lv
|
|
* Volume group handle.
|
|
*
|
|
* \param name
|
|
* Name to validate
|
|
*/
|
|
int lvm_lv_name_validate(const vg_t vg, const char *lv_name);
|
|
|
|
/**
|
|
* Thin provisioning discard policies
|
|
*/
|
|
typedef enum {
|
|
LVM_THIN_DISCARDS_IGNORE,
|
|
LVM_THIN_DISCARDS_NO_PASSDOWN,
|
|
LVM_THIN_DISCARDS_PASSDOWN,
|
|
} lvm_thin_discards_t;
|
|
|
|
/**
|
|
* Create a thinpool parameter passing object for the specified VG
|
|
*
|
|
* \param vg
|
|
* Volume Group handle.
|
|
*
|
|
* \param pool_name
|
|
* Name of the pool.
|
|
*
|
|
* \param size
|
|
* size of the pool
|
|
*
|
|
* \param chunk_size
|
|
* data block size of the pool
|
|
* Default value is DEFAULT_THIN_POOL_CHUNK_SIZE * 2 when 0 passed as chunk_size
|
|
* DM_THIN_MIN_DATA_BLOCK_SIZE < chunk_size < DM_THIN_MAX_DATA_BLOCK_SIZE
|
|
*
|
|
* \param meta_size
|
|
* Size of thin pool's metadata logical volume. Allowed range is 2MB-16GB.
|
|
* Default value (ie if 0) pool size / pool chunk size * 64
|
|
*
|
|
* \param discard
|
|
* Thin discard policy
|
|
* Note: THIN_DISCARDS_PASSDOWN is the default.
|
|
*
|
|
* \return
|
|
* Valid lv_create_params pointer on success, else NULL on error.
|
|
* Note: Memory is associated with the vg, it will get reclaimed when vg is
|
|
* closed.
|
|
*
|
|
*/
|
|
lv_create_params_t lvm_lv_params_create_thin_pool(vg_t vg,
|
|
const char *pool_name, uint64_t size, uint32_t chunk_size,
|
|
uint64_t meta_size, lvm_thin_discards_t discard);
|
|
|
|
#define lvm_lv_params_create_thin_pool_default(vg, pool_name, size) \
|
|
lvm_lv_params_create_thin_pool((vg), (pool_name), (size), 0, 0, \
|
|
LVM_THIN_DISCARDS_PASSDOWN)
|
|
|
|
/**
|
|
* Creates the snapshot parameter passing object for the specified lv.
|
|
*
|
|
* \param lv
|
|
* The logical volume to snapshot
|
|
*
|
|
* \param snap_name
|
|
* Name of snapshot
|
|
*
|
|
* \param max_snap_size
|
|
* Used for old snap shots max size, set to zero for thinp
|
|
*
|
|
* \return
|
|
* Valid lv_create_params pointer on success, else NULL on error.
|
|
* Note: Memory is associated with the vg, it will get reclaimed when vg is
|
|
* closed.
|
|
*/
|
|
lv_create_params_t lvm_lv_params_create_snapshot(const lv_t lv,
|
|
const char *snap_name,
|
|
uint64_t max_snap_size);
|
|
/**
|
|
* Get the specific value of a lv create parameter by name
|
|
*
|
|
* \param params lv create parameters
|
|
*
|
|
* \param name name of parameter
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check 'is_valid' flag before using
|
|
* the value. If 'is_valid' is not set, caller should check lvm_errno()
|
|
* for specific error.
|
|
*/
|
|
struct lvm_property_value lvm_lv_params_get_property(
|
|
const lv_create_params_t params,
|
|
const char *name);
|
|
|
|
|
|
/**
|
|
* Set the specific value of a lv create parameter by name
|
|
*
|
|
* Note that the property must be a 'settable' property, as evidenced '
|
|
* by the 'is_settable' flag when querying the property.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle associated with the lv_create_params_t and will be released when
|
|
* lvm_vg_close() is called.
|
|
*
|
|
* \param params lv create parameters
|
|
*
|
|
* \param name name of parameter
|
|
*
|
|
* \param prop Property value to use for setting
|
|
*
|
|
* \return
|
|
* 0 on success, -1 on error.
|
|
*/
|
|
int lvm_lv_params_set_property(lv_create_params_t params,
|
|
const char *name,
|
|
struct lvm_property_value *prop);
|
|
|
|
/**
|
|
* Create a thin LV creation parameters in a given VG & thin pool
|
|
*
|
|
* \param vg
|
|
* Volume Group handle.
|
|
*
|
|
* \param pool_name
|
|
* Name of the pool.
|
|
*
|
|
* \param lvname
|
|
* Name of the LV to create
|
|
*
|
|
* \param size
|
|
* Size of logical volume
|
|
*
|
|
* \return
|
|
* Valid lv_create_params pointer on success, else NULL on error.
|
|
* Note: Memory is associated with the vg, it will get reclaimed when vg is
|
|
* closed.
|
|
*
|
|
*/
|
|
lv_create_params_t lvm_lv_params_create_thin(const vg_t vg, const char *pool_name,
|
|
const char *lvname, uint64_t size);
|
|
/**
|
|
* Create the actual logical volume.
|
|
*
|
|
* \param params The parameters object for lv creation
|
|
*
|
|
* \return
|
|
* Valid lv pointer on success, else NULL on error.
|
|
*/
|
|
lv_t lvm_lv_create(lv_create_params_t params);
|
|
|
|
/************************** physical volume handling ************************/
|
|
|
|
/**
|
|
* Physical volume handling should not be needed anymore. Only physical volumes
|
|
* bound to a vg contain useful information. Therefore the creation,
|
|
* modification and the removal of orphan physical volumes is not suported.
|
|
*/
|
|
|
|
/**
|
|
* Get the current uuid of a physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* The memory allocated for the uuid is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Copy of the uuid string.
|
|
*/
|
|
const char *lvm_pv_get_uuid(const pv_t pv);
|
|
|
|
/**
|
|
* Get the current name of a physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* The memory allocated for the name is tied to the vg_t handle and will be
|
|
* released when lvm_vg_close() is called.
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Copy of the name.
|
|
*/
|
|
const char *lvm_pv_get_name(const pv_t pv);
|
|
|
|
/**
|
|
* Get the current number of metadata areas in the physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Number of metadata areas in the PV.
|
|
*/
|
|
uint64_t lvm_pv_get_mda_count(const pv_t pv);
|
|
|
|
/**
|
|
* Get the current size in bytes of a device underlying a
|
|
* physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Size in bytes.
|
|
*/
|
|
uint64_t lvm_pv_get_dev_size(const pv_t pv);
|
|
|
|
/**
|
|
* Get the current size in bytes of a physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Size in bytes.
|
|
*/
|
|
uint64_t lvm_pv_get_size(const pv_t pv);
|
|
|
|
/**
|
|
* Get the current unallocated space in bytes of a physical volume.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* Free size in bytes.
|
|
*/
|
|
uint64_t lvm_pv_get_free(const pv_t pv);
|
|
|
|
/**
|
|
* Get the value of a PV property
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \param name
|
|
* Name of property to query. See pvs man page for full list of properties
|
|
* that may be queried.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t handle
|
|
* and will be released when lvm_vg_close() is called. For "percent" values
|
|
* (those obtained for copy_percent and snap_percent properties), please see
|
|
* dm_percent_range_t and lvm_percent_to_float().
|
|
*
|
|
* Example:
|
|
* lvm_property_value value;
|
|
* char *prop_name = "pv_mda_count";
|
|
*
|
|
* v = lvm_pv_get_property(pv, prop_name);
|
|
* if (!v.is_valid) {
|
|
* printf("Invalid property name or unable to query"
|
|
* "'%s', errno = %d.\n", prop_name, lvm_errno(libh));
|
|
* return;
|
|
* }
|
|
* if (v.is_string)
|
|
* printf(", value = %s\n", v.value.string);
|
|
* if (v.is_integer)
|
|
* printf(", value = %"PRIu64"\n", v.value.integer);
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check 'is_valid' flag before using
|
|
* the value. If 'is_valid' is not set, caller should check lvm_errno()
|
|
* for specific error.
|
|
*/
|
|
struct lvm_property_value lvm_pv_get_property(const pv_t pv, const char *name);
|
|
|
|
/**
|
|
* Get the value of a PV segment property
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pvseg
|
|
* Physical volume segment handle.
|
|
*
|
|
* \param name
|
|
* Name of property to query. See pvs man page for full list of properties
|
|
* that may be queried.
|
|
*
|
|
* The memory allocated for a string property value is tied to the vg_t
|
|
* handle and will be released when lvm_vg_close() is called.
|
|
*
|
|
* Example:
|
|
* lvm_property_value v;
|
|
* char *prop_name = "pvseg_start";
|
|
*
|
|
* v = lvm_pvseg_get_property(pvseg, prop_name);
|
|
* if (lvm_errno(libh) || !v.is_valid) {
|
|
* // handle error
|
|
* printf("Invalid property name or unable to query"
|
|
* "'%s'.\n", prop_name);
|
|
* return;
|
|
* }
|
|
* if (v.is_string)
|
|
* printf(", value = %s\n", v.value.string);
|
|
* else
|
|
* printf(", value = %"PRIu64"\n", v.value.integer);
|
|
*
|
|
* \return
|
|
* lvm_property_value structure that will contain the current
|
|
* value of the property. Caller should check lvm_errno() as well
|
|
* as 'is_valid' flag before using the value.
|
|
*/
|
|
struct lvm_property_value lvm_pvseg_get_property(const pvseg_t pvseg,
|
|
const char *name);
|
|
|
|
/**
|
|
* Return a list of pvseg handles for a given PV handle.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \return
|
|
* A list of lvm_pvseg_list structures containing pvseg handles for this pv.
|
|
*/
|
|
struct dm_list *lvm_pv_list_pvsegs(pv_t pv);
|
|
|
|
/**
|
|
* Lookup an PV handle in a VG by the PV name.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param name
|
|
* Name of PV to lookup.
|
|
*
|
|
* \return
|
|
* non-NULL handle to the PV 'name' attached to the VG.
|
|
* NULL is returned if the PV name is not associated with the VG handle.
|
|
*/
|
|
pv_t lvm_pv_from_name(vg_t vg, const char *name);
|
|
|
|
/**
|
|
* Lookup an PV handle in a VG by the PV uuid.
|
|
* The form of the uuid may be either the formatted, human-readable form,
|
|
* or the non-formatted form.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param vg
|
|
* VG handle obtained from lvm_vg_create() or lvm_vg_open().
|
|
*
|
|
* \param uuid
|
|
* UUID of PV to lookup.
|
|
*
|
|
* \return
|
|
* non-NULL handle to the PV with 'uuid' attached to the VG.
|
|
* NULL is returned if the PV uuid is not associated with the VG handle.
|
|
*/
|
|
pv_t lvm_pv_from_uuid(vg_t vg, const char *uuid);
|
|
|
|
/**
|
|
* Resize physical volume to new_size bytes.
|
|
*
|
|
* \memberof pv_t
|
|
*
|
|
* \param pv
|
|
* Physical volume handle.
|
|
*
|
|
* \param new_size
|
|
* New size in bytes.
|
|
*
|
|
* \return
|
|
* 0 (success) or -1 (failure).
|
|
*/
|
|
int lvm_pv_resize(const pv_t pv, uint64_t new_size);
|
|
|
|
#define PERCENT_0 DM_PERCENT_0
|
|
#define PERCENT_1 DM_PERCENT_1
|
|
#define PERCENT_100 DM_PERCENT_100
|
|
#define PERCENT_INVALID DM_PERCENT_INVALID
|
|
#define PERCENT_MERGE_FAILED DM_PERCENT_FAILED
|
|
|
|
typedef dm_percent_t percent_t;
|
|
|
|
/**
|
|
* Convert a (fixed-point) value obtained from the percent-denominated
|
|
* *_get_property functions into a floating-point value.
|
|
*/
|
|
float lvm_percent_to_float(percent_t v);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* _LIB_LVM2APP_H */
|