shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-21 13:34:40 +03:00
Code Releases Activity
c9729022bf
lvm2/liblvm/lvm2app.h

1984 lines
51 KiB
C
Raw Blame History

/*
* 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>
#ifndef _BUILDING_LVM
#warning "liblvm2app is deprecated, use D-Bus API instead."
#endif
#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 */
View Git Blame Copy Permalink