NAME

       libvslvm.h — Library to access the Linux Logical Volume Manager (LVM) volume system

SYNOPSIS

       #include <libvslvm.h>

       Support functions

       const char *
       libvslvm_get_version(void);

       int
       libvslvm_get_access_flags_read_write(void);

       int
       libvslvm_get_access_flags_write(void);

       int
       libvslvm_get_codepage(int *codepage, libvslvm_error_t **error);

       int
       libvslvm_set_codepage(int codepage, libvslvm_error_t **error);

       int
       libvslvm_check_volume_signature(const char *filename, libvslvm_error_t **error);

       Available when compiled with wide character string support:

       int
       libvslvm_check_volume_signature_wide(const wchar_t *filename, libvslvm_error_t **error);

       Available when compiled with libbfio support:

       int
       libvslvm_check_volume_signature_file_io_handle(libbfio_handle_t                          *file_io_handle,
           libvslvm_error_t **error);

       Notify functions

       void
       libvslvm_notify_set_verbose(int verbose);

       int
       libvslvm_notify_set_stream(FILE *stream, libvslvm_error_t **error);

       int
       libvslvm_notify_stream_open(const char *filename, libvslvm_error_t **error);

       int
       libvslvm_notify_stream_close(libvslvm_error_t **error);

       Error functions

       void
       libvslvm_error_free(libvslvm_error_t **error);

       int
       libvslvm_error_fprint(libvslvm_error_t *error, FILE *stream);

       int
       libvslvm_error_sprint(libvslvm_error_t *error, char *string, size_t size);

       int
       libvslvm_error_backtrace_fprint(libvslvm_error_t *error, FILE *stream);

       int
       libvslvm_error_backtrace_sprint(libvslvm_error_t *error, char *string, size_t size);

       Handle functions

       int
       libvslvm_handle_initialize(libvslvm_handle_t **handle, libvslvm_error_t **error);

       int
       libvslvm_handle_free(libvslvm_handle_t **handle, libvslvm_error_t **error);

       int
       libvslvm_handle_signal_abort(libvslvm_handle_t *handle, libvslvm_error_t **error);

       int
       libvslvm_handle_open(libvslvm_handle_t    *handle,    const    char    *filename,    int    access_flags,
           libvslvm_error_t **error);

       int
       libvslvm_handle_open_physical_volume_files(libvslvm_handle_t   *handle,   char   *   const   filenames[],
           int number_of_filenames, libvslvm_error_t **error);

       int
       libvslvm_handle_close(libvslvm_handle_t *handle, libvslvm_error_t **error);

       int
       libvslvm_handle_get_volume_group(libvslvm_handle_t   *handle,   libvslvm_volume_group_t   **volume_group,
           libvslvm_error_t **error);

       Available when compiled with wide character string support:

       int
       libvslvm_handle_open_wide(libvslvm_handle_t   *handle,   const   wchar_t   *filename,  int  access_flags,
           libvslvm_error_t **error);

       int
       libvslvm_handle_open_physical_volume_files_wide(libvslvm_handle_t *handle, wchar_t *  const  filenames[],
           int number_of_filenames, libvslvm_error_t **error);

       Available when compiled with libbfio support:

       int
       libvslvm_handle_open_file_io_handle(libvslvm_handle_t    *handle,    libbfio_handle_t    *file_io_handle,
           int access_flags, libvslvm_error_t **error);

       int
       libvslvm_handle_open_physical_volume_files_file_io_pool(libvslvm_handle_t                        *handle,
           libbfio_pool_t *file_io_pool, libvslvm_error_t **error);

       Volume group functions

       int
       libvslvm_volume_group_free(libvslvm_volume_group_t **volume_group, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_name_size(libvslvm_volume_group_t     *volume_group,     size_t     *name_size,
           libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_name(libvslvm_volume_group_t  *volume_group,  char  *name,  size_t   name_size,
           libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_identifier_size(libvslvm_volume_group_t *volume_group, size_t *identifier_size,
           libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_identifier(libvslvm_volume_group_t     *volume_group,     char     *identifier,
           size_t identifier_size, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_sequence_number(libvslvm_volume_group_t                          *volume_group,
           uint32_t *sequence_number, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_extent_size(libvslvm_volume_group_t   *volume_group,   size64_t   *extent_size,
           libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_number_of_physical_volumes(libvslvm_volume_group_t               *volume_group,
           int *number_of_physical_volumes, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_physical_volume(libvslvm_volume_group_t    *volume_group,   int   volume_index,
           libvslvm_physical_volume_t **physical_volume, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_physical_volume_by_name(libvslvm_volume_group_t                  *volume_group,
           const  char  *volume_name,  size_t  volume_name_length, libvslvm_physical_volume_t **physical_volume,
           libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_number_of_logical_volumes(libvslvm_volume_group_t                *volume_group,
           int *number_of_logical_volumes, libvslvm_error_t **error);

       int
       libvslvm_volume_group_get_logical_volume(libvslvm_volume_group_t    *volume_group,    int   volume_index,
           libvslvm_logical_volume_t **logical_volume, libvslvm_error_t **error);

       Physical volume functions

       int
       libvslvm_physical_volume_free(libvslvm_physical_volume_t **physical_volume, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_name_size(libvslvm_physical_volume_t  *physical_volume,  size_t  *name_size,
           libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_name(libvslvm_physical_volume_t      *physical_volume,      char      *name,
           size_t name_size, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_identifier_size(libvslvm_physical_volume_t                 *physical_volume,
           size_t *identifier_size, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_identifier(libvslvm_physical_volume_t  *physical_volume,  char  *identifier,
           size_t identifier_size, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_device_path_size(libvslvm_physical_volume_t                *physical_volume,
           size_t *device_path_size, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_device_path(libvslvm_physical_volume_t  *physical_volume, char *device_path,
           size_t device_path_size, libvslvm_error_t **error);

       int
       libvslvm_physical_volume_get_size(libvslvm_physical_volume_t    *physical_volume,     size64_t     *size,
           libvslvm_error_t **error);

       Logical volume functions

       int
       libvslvm_logical_volume_free(libvslvm_logical_volume_t **logical_volume, libvslvm_error_t **error);

       ssize_t
       libvslvm_logical_volume_read_buffer(libvslvm_logical_volume_t      *logical_volume,     void     *buffer,
           size_t buffer_size, libvslvm_error_t **error);

       ssize_t
       libvslvm_logical_volume_read_buffer_at_offset(libvslvm_logical_volume_t  *logical_volume,  void  *buffer,
           size_t buffer_size, off64_t offset, libvslvm_error_t **error);

       off64_t
       libvslvm_logical_volume_seek_offset(libvslvm_logical_volume_t     *logical_volume,     off64_t    offset,
           int whence, libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_offset(libvslvm_logical_volume_t    *logical_volume,     off64_t     *offset,
           libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_size(libvslvm_logical_volume_t      *logical_volume,      size64_t     *size,
           libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_name_size(libvslvm_logical_volume_t   *logical_volume,   size_t   *name_size,
           libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_name(libvslvm_logical_volume_t *logical_volume, char *name, size_t name_size,
           libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_identifier_size(libvslvm_logical_volume_t                    *logical_volume,
           size_t *identifier_size, libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_identifier(libvslvm_logical_volume_t   *logical_volume,   char   *identifier,
           size_t identifier_size, libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_number_of_segments(libvslvm_logical_volume_t                 *logical_volume,
           int *number_of_segments, libvslvm_error_t **error);

       int
       libvslvm_logical_volume_get_segment(libvslvm_logical_volume_t   *logical_volume,    int    segment_index,
           libvslvm_segment_t **segment, libvslvm_error_t **error);

       Segment functions

       int
       libvslvm_segment_free(libvslvm_segment_t **segment, libvslvm_error_t **error);

       int
       libvslvm_segment_get_offset(libvslvm_segment_t *segment, off64_t *offset, libvslvm_error_t **error);

       int
       libvslvm_segment_get_size(libvslvm_segment_t *segment, size64_t *size, libvslvm_error_t **error);

       int
       libvslvm_segment_get_number_of_stripes(libvslvm_segment_t      *segment,      int     *number_of_stripes,
           libvslvm_error_t **error);

       int
       libvslvm_segment_get_stripe(libvslvm_segment_t *segment, int  stripe_index,  libvslvm_stripe_t  **stripe,
           libvslvm_error_t **error);

       Stripe functions

       int
       libvslvm_stripe_free(libvslvm_stripe_t **stripe, libvslvm_error_t **error);

       int
       libvslvm_stripe_get_physical_volume_name_size(libvslvm_stripe_t                                  *stripe,
           size_t *physical_volume_name_size, libvslvm_error_t **error);

       int
       libvslvm_stripe_get_physical_volume_name(libvslvm_stripe_t    *stripe,    char     *physical_volume_name,
           size_t physical_volume_name_size, libvslvm_error_t **error);

       int
       libvslvm_stripe_get_data_area_offset(libvslvm_stripe_t      *stripe,      off64_t      *data_area_offset,
           libvslvm_error_t **error);

DESCRIPTION

       The libvslvm_get_version() function is used to retrieve the library version.

RETURN VALUES

       Most of the functions return NULL or -1 on error, dependent on the return type.  For  the  actual  return
       values see "libvslvm.h".

ENVIRONMENT

       None

FILES

       None

NOTES

       libvslvm can be compiled with wide character support (wchar_t).

       To compile libvslvm with wide character support use: ./configure --enable-wide-character-type=yes
        or define: _UNICODE
        or UNICODE
        during compilation.

       LIBVSLVM_WIDE_CHARACTER_TYPE
        in libvslvm/features.h can be used to determine if libvslvm was compiled with wide character support.

BUGS

       Please report bugs of any kind on the project issue tracker: https://github.com/libyal/libvslvm/issues

AUTHOR

       These man pages are generated from "libvslvm.h".

COPYRIGHT

       Copyright (C) 2014-2024, Joachim Metz <joachim.metz@gmail.com>.

       This  is  free  software;  see  the  source  for  copying conditions.  There is NO warranty; not even for
       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

SEE ALSO

       the libvslvm.h include file

libvslvm                                          March 6, 2019                                      libvslvm(3)