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

Author

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

Bugs

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

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.

Description

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

Environment

       None

Files

       None

Name

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

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.

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".

Synopsis

#include<libvslvm.h>

       Support functions

       constchar*libvslvm_get_version(void);

       intlibvslvm_get_access_flags_read_write(void);

       intlibvslvm_get_access_flags_write(void);

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

       intlibvslvm_set_codepage(intcodepage, libvslvm_error_t**error);

       intlibvslvm_check_volume_signature(constchar*filename, libvslvm_error_t**error);

       Available when compiled with wide character string support:

       intlibvslvm_check_volume_signature_wide(constwchar_t*filename, libvslvm_error_t**error);

       Available when compiled with libbfio support:

       intlibvslvm_check_volume_signature_file_io_handle(libbfio_handle_t*file_io_handle,
           libvslvm_error_t**error);

       Notify functions

       voidlibvslvm_notify_set_verbose(intverbose);

       intlibvslvm_notify_set_stream(FILE*stream, libvslvm_error_t**error);

       intlibvslvm_notify_stream_open(constchar*filename, libvslvm_error_t**error);

       intlibvslvm_notify_stream_close(libvslvm_error_t**error);

       Error functions

       voidlibvslvm_error_free(libvslvm_error_t**error);

       intlibvslvm_error_fprint(libvslvm_error_t*error, FILE*stream);

       intlibvslvm_error_sprint(libvslvm_error_t*error, char*string, size_tsize);

       intlibvslvm_error_backtrace_fprint(libvslvm_error_t*error, FILE*stream);

       intlibvslvm_error_backtrace_sprint(libvslvm_error_t*error, char*string, size_tsize);

       Handle functions

       intlibvslvm_handle_initialize(libvslvm_handle_t**handle, libvslvm_error_t**error);

       intlibvslvm_handle_free(libvslvm_handle_t**handle, libvslvm_error_t**error);

       intlibvslvm_handle_signal_abort(libvslvm_handle_t*handle, libvslvm_error_t**error);

       intlibvslvm_handle_open(libvslvm_handle_t*handle,    constchar*filename,    intaccess_flags,
           libvslvm_error_t**error);

       intlibvslvm_handle_open_physical_volume_files(libvslvm_handle_t*handle,   char*constfilenames[],
           intnumber_of_filenames, libvslvm_error_t**error);

       intlibvslvm_handle_close(libvslvm_handle_t*handle, libvslvm_error_t**error);

       intlibvslvm_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:

       intlibvslvm_handle_open_wide(libvslvm_handle_t*handle,   constwchar_t*filename,  intaccess_flags,
           libvslvm_error_t**error);

       intlibvslvm_handle_open_physical_volume_files_wide(libvslvm_handle_t*handle, wchar_t*constfilenames[],
           intnumber_of_filenames, libvslvm_error_t**error);

       Available when compiled with libbfio support:

       intlibvslvm_handle_open_file_io_handle(libvslvm_handle_t*handle,    libbfio_handle_t*file_io_handle,
           intaccess_flags, libvslvm_error_t**error);

       intlibvslvm_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

       intlibvslvm_volume_group_free(libvslvm_volume_group_t**volume_group, libvslvm_error_t**error);

       intlibvslvm_volume_group_get_name_size(libvslvm_volume_group_t*volume_group,     size_t*name_size,
           libvslvm_error_t**error);

       intlibvslvm_volume_group_get_name(libvslvm_volume_group_t*volume_group,  char*name,  size_tname_size,
           libvslvm_error_t**error);

       intlibvslvm_volume_group_get_identifier_size(libvslvm_volume_group_t*volume_group, size_t*identifier_size,
           libvslvm_error_t**error);

       intlibvslvm_volume_group_get_identifier(libvslvm_volume_group_t*volume_group,     char*identifier,
           size_tidentifier_size, libvslvm_error_t**error);

       intlibvslvm_volume_group_get_sequence_number(libvslvm_volume_group_t*volume_group,
           uint32_t*sequence_number, libvslvm_error_t**error);

       intlibvslvm_volume_group_get_extent_size(libvslvm_volume_group_t*volume_group,   size64_t*extent_size,
           libvslvm_error_t**error);

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

       intlibvslvm_volume_group_get_physical_volume(libvslvm_volume_group_t*volume_group,   intvolume_index,
           libvslvm_physical_volume_t**physical_volume, libvslvm_error_t**error);

       intlibvslvm_volume_group_get_physical_volume_by_name(libvslvm_volume_group_t*volume_group,
           constchar*volume_name,  size_tvolume_name_length, libvslvm_physical_volume_t**physical_volume,
           libvslvm_error_t**error);

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

       intlibvslvm_volume_group_get_logical_volume(libvslvm_volume_group_t*volume_group,    intvolume_index,
           libvslvm_logical_volume_t**logical_volume, libvslvm_error_t**error);

       Physical volume functions

       intlibvslvm_physical_volume_free(libvslvm_physical_volume_t**physical_volume, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_name_size(libvslvm_physical_volume_t*physical_volume,  size_t*name_size,
           libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_name(libvslvm_physical_volume_t*physical_volume,      char*name,
           size_tname_size, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_identifier_size(libvslvm_physical_volume_t*physical_volume,
           size_t*identifier_size, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_identifier(libvslvm_physical_volume_t*physical_volume,  char*identifier,
           size_tidentifier_size, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_device_path_size(libvslvm_physical_volume_t*physical_volume,
           size_t*device_path_size, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_device_path(libvslvm_physical_volume_t*physical_volume, char*device_path,
           size_tdevice_path_size, libvslvm_error_t**error);

       intlibvslvm_physical_volume_get_size(libvslvm_physical_volume_t*physical_volume,     size64_t*size,
           libvslvm_error_t**error);

       Logical volume functions

       intlibvslvm_logical_volume_free(libvslvm_logical_volume_t**logical_volume, libvslvm_error_t**error);

       ssize_tlibvslvm_logical_volume_read_buffer(libvslvm_logical_volume_t*logical_volume,     void*buffer,
           size_tbuffer_size, libvslvm_error_t**error);

       ssize_tlibvslvm_logical_volume_read_buffer_at_offset(libvslvm_logical_volume_t*logical_volume,  void*buffer,
           size_tbuffer_size, off64_toffset, libvslvm_error_t**error);

       off64_tlibvslvm_logical_volume_seek_offset(libvslvm_logical_volume_t*logical_volume,     off64_toffset,
           intwhence, libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_offset(libvslvm_logical_volume_t*logical_volume,     off64_t*offset,
           libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_size(libvslvm_logical_volume_t*logical_volume,      size64_t*size,
           libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_name_size(libvslvm_logical_volume_t*logical_volume,   size_t*name_size,
           libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_name(libvslvm_logical_volume_t*logical_volume, char*name, size_tname_size,
           libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_identifier_size(libvslvm_logical_volume_t*logical_volume,
           size_t*identifier_size, libvslvm_error_t**error);

       intlibvslvm_logical_volume_get_identifier(libvslvm_logical_volume_t*logical_volume,   char*identifier,
           size_tidentifier_size, libvslvm_error_t**error);

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

       intlibvslvm_logical_volume_get_segment(libvslvm_logical_volume_t*logical_volume,    intsegment_index,
           libvslvm_segment_t**segment, libvslvm_error_t**error);

       Segment functions

       intlibvslvm_segment_free(libvslvm_segment_t**segment, libvslvm_error_t**error);

       intlibvslvm_segment_get_offset(libvslvm_segment_t*segment, off64_t*offset, libvslvm_error_t**error);

       intlibvslvm_segment_get_size(libvslvm_segment_t*segment, size64_t*size, libvslvm_error_t**error);

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

       intlibvslvm_segment_get_stripe(libvslvm_segment_t*segment, intstripe_index,  libvslvm_stripe_t**stripe,
           libvslvm_error_t**error);

       Stripe functions

       intlibvslvm_stripe_free(libvslvm_stripe_t**stripe, libvslvm_error_t**error);

       intlibvslvm_stripe_get_physical_volume_name_size(libvslvm_stripe_t*stripe,
           size_t*physical_volume_name_size, libvslvm_error_t**error);

       intlibvslvm_stripe_get_physical_volume_name(libvslvm_stripe_t*stripe,    char*physical_volume_name,
           size_tphysical_volume_name_size, libvslvm_error_t**error);

       intlibvslvm_stripe_get_data_area_offset(libvslvm_stripe_t*stripe,      off64_t*data_area_offset,
           libvslvm_error_t**error);