MD RAID

MD RAID — plugin for basic operations with MD RAID

Synopsis

#include <mdraid.h>

gboolean            bd_md_check_deps                    ();
gboolean            bd_md_init                          ();
void                bd_md_close                         ();
#define             BD_MD_SUPERBLOCK_SIZE
#define             BD_MD_CHUNK_SIZE
GQuark              bd_md_error_quark                   (void);
#define             BD_MD_ERROR
enum                BDMDError;
                    BDMDExamineData;
BDMDExamineData *   bd_md_examine_data_copy             (BDMDExamineData *data);
void                bd_md_examine_data_free             (BDMDExamineData *data);
                    BDMDDetailData;
void                bd_md_detail_data_free              (BDMDDetailData *data);
BDMDDetailData *    bd_md_detail_data_copy              (BDMDDetailData *data);
guint64             bd_md_get_superblock_size           (guint64 member_size,
                                                         const gchar *version,
                                                         GError **error);
gboolean            bd_md_create                        (const gchar *raid_spec,
                                                         const gchar *level,
                                                         const gchar **disks,
                                                         guint64 spares,
                                                         const gchar *version,
                                                         gboolean bitmap,
                                                         guint64 chunk_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_md_destroy                       (const gchar *device,
                                                         GError **error);
gboolean            bd_md_deactivate                    (const gchar *raid_spec,
                                                         GError **error);
gboolean            bd_md_activate                      (const gchar *raid_spec,
                                                         const gchar **members,
                                                         const gchar *uuid,
                                                         gboolean start_degraded,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_md_run                           (const gchar *raid_spec,
                                                         GError **error);
gboolean            bd_md_nominate                      (const gchar *device,
                                                         GError **error);
gboolean            bd_md_denominate                    (const gchar *device,
                                                         GError **error);
gboolean            bd_md_add                           (const gchar *raid_spec,
                                                         const gchar *device,
                                                         guint64 raid_devs,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_md_remove                        (const gchar *raid_spec,
                                                         const gchar *device,
                                                         gboolean fail,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDMDExamineData *   bd_md_examine                       (const gchar *device,
                                                         GError **error);
gchar *             bd_md_canonicalize_uuid             (const gchar *uuid,
                                                         GError **error);
gchar *             bd_md_get_md_uuid                   (const gchar *uuid,
                                                         GError **error);
BDMDDetailData *    bd_md_detail                        (const gchar *raid_spec,
                                                         GError **error);
gchar *             bd_md_node_from_name                (const gchar *name,
                                                         GError **error);
gchar *             bd_md_name_from_node                (const gchar *node,
                                                         GError **error);
gchar *             bd_md_get_status                    (const gchar *raid_spec,
                                                         GError **error);
gboolean            bd_md_set_bitmap_location           (const gchar *raid_spec,
                                                         const gchar *location,
                                                         GError **error);
gchar *             bd_md_get_bitmap_location           (const gchar *raid_spec,
                                                         GError **error);
gboolean            bd_md_request_sync_action           (const gchar *raid_spec,
                                                         const gchar *action,
                                                         GError **error);

Description

A plugin for basic operations with MD RAID. Also sizes are in bytes unless specified otherwise.

Details

bd_md_check_deps ()

gboolean            bd_md_check_deps                    ();

Returns :

whether the plugin's runtime dependencies are satisfied or not Function checking plugin's runtime dependencies.

bd_md_init ()

gboolean            bd_md_init                          ();

Initializes the plugin. **This function is called automatically by the library's initialization functions.**


bd_md_close ()

void                bd_md_close                         ();

Cleans up after the plugin. **This function is called automatically by the library's functions that unload it.**


BD_MD_SUPERBLOCK_SIZE

#define             BD_MD_SUPERBLOCK_SIZE

BD_MD_CHUNK_SIZE

#define             BD_MD_CHUNK_SIZE

bd_md_error_quark ()

GQuark              bd_md_error_quark                   (void);

BD_MD_ERROR

#define             BD_MD_ERROR

enum BDMDError

typedef enum {
    BD_MD_ERROR_PARSE,
    BD_MD_ERROR_BAD_FORMAT,
    BD_MD_ERROR_NO_MATCH,
    BD_MD_ERROR_INVAL,
    BD_MD_ERROR_FAIL,
} BDMDError;

BD_MD_ERROR_PARSE

BD_MD_ERROR_BAD_FORMAT

BD_MD_ERROR_NO_MATCH

BD_MD_ERROR_INVAL

BD_MD_ERROR_FAIL


BDMDExamineData

typedef struct {
    gchar *device;
    gchar *level;
    guint64 num_devices;
    gchar *name;
    guint64 size;
    gchar *uuid;
    guint64 update_time;
    gchar *dev_uuid;
    guint64 events;
    gchar *metadata;
    guint64 chunk_size;
} BDMDExamineData;

gchar *device;

path of the MD device

gchar *level;

RAID level of the device

guint64 num_devices;

number of devices used by the MD device

gchar *name;

name of the MD device

guint64 size;

size of the MD device

gchar *uuid;

array UUID

guint64 update_time;

update time of the MD device

gchar *dev_uuid;

UUID of the member device

guint64 events;

number of events on the MD device

gchar *metadata;

version of the metadata used by the MD device

guint64 chunk_size;

chunk size used by the MD device

bd_md_examine_data_copy ()

BDMDExamineData *   bd_md_examine_data_copy             (BDMDExamineData *data);

Creates a new copy of data.


bd_md_examine_data_free ()

void                bd_md_examine_data_free             (BDMDExamineData *data);

Frees data.


BDMDDetailData

typedef struct {
    gchar *device;
    gchar *metadata;
    gchar *creation_time;
    gchar *level;
    gchar *name;
    guint64 array_size;
    guint64 use_dev_size;
    guint64 raid_devices;
    guint64 total_devices;
    guint64 active_devices;
    guint64 working_devices;
    guint64 failed_devices;
    guint64 spare_devices;
    gboolean clean;
    gchar *uuid;
} BDMDDetailData;

gchar *device;

path of the device

gchar *metadata;

version of the metadata used by the device

gchar *creation_time;

creation time

gchar *level;

level of the MD RAID

gchar *name;

name of the MD device

guint64 array_size;

size of the MD array

guint64 use_dev_size;

size of the used space

guint64 raid_devices;

number of devices in the MD array

guint64 total_devices;

total number of devices in the MD array

guint64 active_devices;

number of active devices in the MD array

guint64 working_devices;

number of working devices in the MD array

guint64 failed_devices;

number of failed devices in the MD array

guint64 spare_devices;

number of spare devices in the MD array

gboolean clean;

whether the MD array is clean or not

gchar *uuid;

uuid of the MD array

bd_md_detail_data_free ()

void                bd_md_detail_data_free              (BDMDDetailData *data);

Frees data.


bd_md_detail_data_copy ()

BDMDDetailData *    bd_md_detail_data_copy              (BDMDDetailData *data);

Creates a new copy of data.


bd_md_get_superblock_size ()

guint64             bd_md_get_superblock_size           (guint64 member_size,
                                                         const gchar *version,
                                                         GError **error);

member_size :

size of an array member

version :

metadata version or NULL to use the current default version. [allow-none]

error :

place to store error (if any). [out]

Returns :

Calculated superblock size for an array with a given member_size and metadata version or default if unsupported version is used.

bd_md_create ()

gboolean            bd_md_create                        (const gchar *raid_spec,
                                                         const gchar *level,
                                                         const gchar **disks,
                                                         guint64 spares,
                                                         const gchar *version,
                                                         gboolean bitmap,
                                                         guint64 chunk_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device_name :

name of the device to create

level :

RAID level (as understood by mdadm, see mdadm(8))

disks :

disks to use for the new RAID (including spares). [array zero-terminated=1]

spares :

number of spare devices

version :

metadata version. [allow-none]

bitmap :

whether to create an internal bitmap on the device or not

chunk_size :

chunk size of the device to create

extra :

extra options for the creation (right now passed to the 'mdadm' utility). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the new MD RAID device device_name was successfully created or not

bd_md_destroy ()

gboolean            bd_md_destroy                       (const gchar *device,
                                                         GError **error);

device :

device to destroy MD RAID metadata on

error :

place to store error (if any). [out]

Returns :

whether the MD RAID metadata was successfully destroyed on device or not

bd_md_deactivate ()

gboolean            bd_md_deactivate                    (const gchar *raid_spec,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path)

error :

place to store error (if any). [out]

Returns :

whether the RAID device raid_spec was successfully deactivated or not

bd_md_activate ()

gboolean            bd_md_activate                      (const gchar *raid_spec,
                                                         const gchar **members,
                                                         const gchar *uuid,
                                                         gboolean start_degraded,
                                                         const BDExtraArg **extra,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to activate (if not given "--scan" is implied and members is ignored). [allow-none]

members :

member devices to be considered for device activation. [allow-none][array zero-terminated=1]

uuid :

UUID (in the MD RAID format!) of the MD RAID to activate. [allow-none]

start_degraded :

whether to start the array even if it's degraded

extra :

extra options for the activation (right now passed to the 'mdadm' utility). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the MD RAID device was successfully activated or not Note: either members or uuid (or both) have to be specified.

bd_md_run ()

gboolean            bd_md_run                           (const gchar *raid_spec,
                                                         GError **error);

raid_spec :

specification of the (possibly degraded) RAID device (name, node or path) to be started

error :

place to store error (if any). [out]

Returns :

whether the raid_spec was successfully started or not

bd_md_nominate ()

gboolean            bd_md_nominate                      (const gchar *device,
                                                         GError **error);

device :

device to nominate (add to its appropriate RAID) as a MD RAID device

error :

place to store error (if any). [out]

Returns :

whether the device was successfully nominated (added to its appropriate RAID) or not Note: may start the MD RAID if it becomes ready by adding device.

bd_md_denominate ()

gboolean            bd_md_denominate                    (const gchar *device,
                                                         GError **error);

device :

device to denominate (remove from its appropriate RAID) as a MD RAID device

error :

place to store error (if any). [out]

Returns :

whether the device was successfully denominated (added to its appropriate RAID) or not Note: may start the MD RAID if it becomes ready by adding device.

bd_md_add ()

gboolean            bd_md_add                           (const gchar *raid_spec,
                                                         const gchar *device,
                                                         guint64 raid_devs,
                                                         const BDExtraArg **extra,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to add device into

device :

name of the device to add to the raid_spec RAID device

raid_devs :

number of devices the raid_spec RAID should actively use or 0 to leave unspecified (see below)

extra :

extra options for the addition (right now passed to the 'mdadm' utility). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the device was successfully added to the raid_spec RAID or not The raid_devs parameter is used when adding devices to a raid array that has no actual redundancy. In this case it is necessary to explicitly grow the array all at once rather than manage it in the sense of adding spares. Whether the new device will be added as a spare or an active member is decided by mdadm.

bd_md_remove ()

gboolean            bd_md_remove                        (const gchar *raid_spec,
                                                         const gchar *device,
                                                         gboolean fail,
                                                         const BDExtraArg **extra,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to remove device from

device :

device to remove from the raid_spec RAID

fail :

whether to mark the device as failed before removing

extra :

extra options for the removal (right now passed to the 'mdadm' utility). [allow-none][array zero-terminated=1]

error :

place to store error (if any). [out]

Returns :

whether the device was successfully removed from the raid_spec RAID or not.

bd_md_examine ()

BDMDExamineData *   bd_md_examine                       (const gchar *device,
                                                         GError **error);

device :

name of the device (a member of an MD RAID) to examine

error :

place to store error (if any). [out]

Returns :

information about the MD RAID extracted from the device

bd_md_canonicalize_uuid ()

gchar *             bd_md_canonicalize_uuid             (const gchar *uuid,
                                                         GError **error);

uuid :

UUID to canonicalize

error :

place to store error (if any). [out]

Returns :

cannonicalized form of uuid This function expects a UUID in the form that mdadm returns. The change is as follows: 3386ff85:f5012621:4a435f06:1eb47236 -> 3386ff85-f501-2621-4a43-5f061eb47236. [transfer full]

bd_md_get_md_uuid ()

gchar *             bd_md_get_md_uuid                   (const gchar *uuid,
                                                         GError **error);

uuid :

UUID to transform into format used by MD RAID

error :

place to store error (if any). [out]

Returns :

transformed form of uuid This function expects a UUID in the canonical (traditional format) and returns a UUID in the format used by MD RAID and is thus reverse to bd_md_canonicalize_uuid(). The change is as follows: 3386ff85-f501-2621-4a43-5f061eb47236 -> 3386ff85:f5012621:4a435f06:1eb47236. [transfer full]

bd_md_detail ()

BDMDDetailData *    bd_md_detail                        (const gchar *raid_spec,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to examine

error :

place to store error (if any). [out]

Returns :

information about the MD RAID raid_spec

bd_md_node_from_name ()

gchar *             bd_md_node_from_name                (const gchar *name,
                                                         GError **error);

name :

name of the MD RAID

error :

place to store error (if any). [out]

Returns :

device node of the name MD RAID or NULL in case of error

bd_md_name_from_node ()

gchar *             bd_md_name_from_node                (const gchar *node,
                                                         GError **error);

node :

path of the MD RAID's device node

error :

place to store error (if any). [out]

Returns :

name of the MD RAID the device node belongs to or NULL in case of error

bd_md_get_status ()

gchar *             bd_md_get_status                    (const gchar *raid_spec,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to get status

error :

place to store error (if any). [out]

Returns :

status of the raid_spec RAID. [transfer full]

bd_md_set_bitmap_location ()

gboolean            bd_md_set_bitmap_location           (const gchar *raid_spec,
                                                         const gchar *location,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to set the bitmap location

location :

bitmap location (none, internal or path)

error :

place to store error (if any). [out]

Returns :

whether location was successfully set for raid_spec

bd_md_get_bitmap_location ()

gchar *             bd_md_get_bitmap_location           (const gchar *raid_spec,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to get the bitmap location

error :

place to store error (if any). [out]

Returns :

bitmap location for raid_spec. [transfer full]

bd_md_request_sync_action ()

gboolean            bd_md_request_sync_action           (const gchar *raid_spec,
                                                         const gchar *action,
                                                         GError **error);

raid_spec :

specification of the RAID device (name, node or path) to request sync action on

action :

requested sync action (resync, recovery, check, repair or idle)

error :

place to store error (if any). [out]

Returns :

whether the action was successfully requested for the raid_spec RAID or not.