libvslvm(3)

📦
this version · 2 versions
, in debian trixie, opensuse-leap 16.0, ubuntu questing, ubuntu resolute, ubuntu stonking

💖 libvslvm — bestie edition 💖

okay so. hi. welcome to libvslvm(3), the manual page for the library that gets you into the Linux Logical Volume Manager (LVM) volume system. It's a C library, it lives in <libvslvm.h>, and honestly it's giving ✨main character energy✨ for anyone who's ever needed to poke at LVM internals without crying.

This is a Library Functions Manual page, k? So every entry down there is a function you can call. Buckle up, there's like a hundred of them, and we're going through all of them. No skipping. periodt. 💅

🌸 NAME 🌸

libvslvm.h — the library that gives you access to the Linux Logical Volume Manager (LVM) volume system. that's it, that's the whole vibe 🫶

✨ SYNOPSIS ✨

First things first, you gotta include the header, no cap:

#include <libvslvm.h>

Everything else is grouped up nice and cute below. Let's go group by group, bestie, don't scroll too fast 💖

📚 Support functions 📚

the little basics. the starter pack. the "who dis" 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 🔔

for when you wanna know what's happening in there. verbose mode is lowkey the move 🗣️

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 😭

the "something went wrong and we need to TALK about it" department 💀

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 👑

the main character of this library, fr fr. everything starts with a handle 🌈

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 🌈

the VG. the whole squad. getting its name, its identifier, its sequence number, its extent size, and counting up all the physical + logical volumes inside it 🫶

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 🍓

the actual disks, basically. name, identifier, device path, size — the whole little dossier 💜

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 💅

ok this one ATE. this is where you actually read bytes out of a logical volume, seek around in it, and inspect its segments. read_buffer, read_buffer_at_offset, seek_offset — chef's kiss, bestie ✨

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 🧚

a logical volume is made of segments, and every segment is a little chunk with an offset, a size, and some stripes ✨

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 ⭐

and a segment has stripes, and a stripe knows which physical volume and offset it's chillin' on. that's the bottom of the stack, babe 🫶

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 🦋

so the literal one sentence the original gives us here?

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

that's it. that's the description. the rest of this page is just waves hands at the SYNOPSIS 😭 iconic honestly.

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

so like… if something goes wrong, expect NULL or -1. which one? depends on the return type, bestie. go read "libvslvm.h" if you want the exact deets 💖

✨ 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

not me asking you to file an issue 💅 do it though, they wanna hear it

👑 AUTHOR 👑

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

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.

ok that part is serious. NO warranty, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. read it, internalize it, respect it fr fr 🙏

🫶 SEE ALSO 🫶

  • the libvslvm.h include file

and that's the whole page, bestie!! this beautiful thing is libvslvm from the Library Functions Manual, and it's dated March 6, 2019 🎂 — so yeah, go forth, read your stripes, free your handles, and remember: NULL or -1, choose wisely 💖✨👑

📦 where this page comes from