FS

FS — plugin for operations with file systems

Synopsis

#include <fs.h>

gboolean            bd_fs_check_deps                    ();
gboolean            bd_fs_init                          ();
void                bd_fs_close                         ();
typedef             BDFSExt2Info;
typedef             BDFSExt3Info;
typedef             BDFSExt4Info;
enum                BDFsError;
GQuark              bd_fs_error_quark                   (void);
gboolean            bd_fs_wipe                          (const gchar *device,
                                                         gboolean all,
                                                         GError **error);
gboolean            bd_fs_clean                         (const gchar *device,
                                                         GError **error);
gchar *             bd_fs_get_fstype                    (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_mount                         (const gchar *device,
                                                         const gchar *mountpoint,
                                                         const gchar *fstype,
                                                         const gchar *options,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_unmount                       (const gchar *spec,
                                                         gboolean lazy,
                                                         gboolean force,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gchar *             bd_fs_get_mountpoint                (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_resize                        (const gchar *device,
                                                         guint64 new_size,
                                                         GError **error);
gboolean            bd_fs_repair                        (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_check                         (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_set_label                     (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_can_resize                    (const gchar *type,
                                                         BDFsResizeFlags *mode,
                                                         gchar **required_utility,
                                                         GError **error);
gboolean            bd_fs_can_check                     (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);
gboolean            bd_fs_can_repair                    (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);
gboolean            bd_fs_can_set_label                 (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);
gboolean            bd_fs_ext2_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDFSExt2Info *      bd_fs_ext2_get_info                 (const gchar *device,
                                                         GError **error);
BDFSExt2Info *      bd_fs_ext2_info_copy                (BDFSExt2Info *data);
void                bd_fs_ext2_info_free                (BDFSExt2Info *data);
gboolean            bd_fs_ext2_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext2_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext2_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext2_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_ext2_wipe                     (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_ext3_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDFSExt3Info *      bd_fs_ext3_get_info                 (const gchar *device,
                                                         GError **error);
BDFSExt3Info *      bd_fs_ext3_info_copy                (BDFSExt3Info *data);
void                bd_fs_ext3_info_free                (BDFSExt3Info *data);
gboolean            bd_fs_ext3_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext3_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext3_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext3_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_ext3_wipe                     (const gchar *device,
                                                         GError **error);
gboolean            bd_fs_ext4_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDFSExt4Info *      bd_fs_ext4_get_info                 (const gchar *device,
                                                         GError **error);
BDFSExt4Info *      bd_fs_ext4_info_copy                (BDFSExt4Info *data);
void                bd_fs_ext4_info_free                (BDFSExt4Info *data);
gboolean            bd_fs_ext4_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext4_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext4_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_ext4_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_ext4_wipe                     (const gchar *device,
                                                         GError **error);
                    BDFSXfsInfo;
gboolean            bd_fs_xfs_check                     (const gchar *device,
                                                         GError **error);
BDFSXfsInfo *       bd_fs_xfs_get_info                  (const gchar *device,
                                                         GError **error);
BDFSXfsInfo *       bd_fs_xfs_info_copy                 (BDFSXfsInfo *data);
void                bd_fs_xfs_info_free                 (BDFSXfsInfo *data);
gboolean            bd_fs_xfs_mkfs                      (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_xfs_repair                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_xfs_resize                    (const gchar *mpoint,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_xfs_set_label                 (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_xfs_wipe                      (const gchar *device,
                                                         GError **error);
                    BDFSVfatInfo;
gboolean            bd_fs_vfat_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
BDFSVfatInfo *      bd_fs_vfat_get_info                 (const gchar *device,
                                                         GError **error);
BDFSVfatInfo *      bd_fs_vfat_info_copy                (BDFSVfatInfo *data);
void                bd_fs_vfat_info_free                (BDFSVfatInfo *data);
gboolean            bd_fs_vfat_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_vfat_repair                   (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);
gboolean            bd_fs_vfat_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         GError **error);
gboolean            bd_fs_vfat_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);
gboolean            bd_fs_vfat_wipe                     (const gchar *device,
                                                         GError **error);

Description

A plugin for operations with file systems

Details

bd_fs_check_deps ()

gboolean            bd_fs_check_deps                    ();

Returns :

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

bd_fs_init ()

gboolean            bd_fs_init                          ();

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


bd_fs_close ()

void                bd_fs_close                         ();

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


BDFSExt2Info


BDFSExt3Info


BDFSExt4Info


enum BDFsError

typedef enum {
    BD_FS_ERROR_INVAL,
    BD_FS_ERROR_PARSE,
    BD_FS_ERROR_FAIL,
    BD_FS_ERROR_NOFS,
    BD_FS_ERROR_PIPE,
    BD_FS_ERROR_UNMOUNT_FAIL,
    BD_FS_ERROR_NOT_SUPPORTED,
    BD_FS_ERROR_NOT_MOUNTED,
    BD_FS_ERROR_AUTH, // keep this entry last
} BDFsError;

BD_FS_ERROR_INVAL

BD_FS_ERROR_PARSE

BD_FS_ERROR_FAIL

BD_FS_ERROR_NOFS

BD_FS_ERROR_PIPE

BD_FS_ERROR_UNMOUNT_FAIL

BD_FS_ERROR_NOT_SUPPORTED

BD_FS_ERROR_NOT_MOUNTED

BD_FS_ERROR_AUTH


bd_fs_error_quark ()

GQuark              bd_fs_error_quark                   (void);

bd_fs_wipe ()

gboolean            bd_fs_wipe                          (const gchar *device,
                                                         gboolean all,
                                                         GError **error);

device :

the device to wipe signatures from

all :

whether to wipe all (TRUE) signatures or just the first (FALSE) one

error :

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

Returns :

whether signatures were successfully wiped on device or not

bd_fs_clean ()

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

Clean all signatures from device. Difference between this and bd_fs_wipe() is that this function doesn't return error if device is already empty. This will also always remove all signatures from device, not only the first one.

device :

the device to clean

error :

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

Returns :

whether device was successfully cleaned or not

bd_fs_get_fstype ()

gchar *             bd_fs_get_fstype                    (const gchar *device,
                                                         GError **error);

Get first signature on device as a string.

device :

the device to probe

error :

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

Returns :

type of filesystem found on device, NULL in case no signature has been detected or in case of error (error is set in this case). [transfer full]

bd_fs_mount ()

gboolean            bd_fs_mount                         (const gchar *device,
                                                         const gchar *mountpoint,
                                                         const gchar *fstype,
                                                         const gchar *options,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

device to mount, if not specified mountpoint entry from fstab will be used. [allow-none]

mountpoint :

mountpoint for device, if not specified device entry from fstab will be used. [allow-none]

fstype :

filesystem type. [allow-none]

options :

comma delimited options for mount. [allow-none]

extra :

extra options for the unmount currently only 'run_as_uid' and 'run_as_gid' are supported value must be a valid non zero uid (gid). [allow-none][array zero-terminated=1]

error :

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

Returns :

whether device (or mountpoint) was successfully mounted or not

bd_fs_unmount ()

gboolean            bd_fs_unmount                       (const gchar *spec,
                                                         gboolean lazy,
                                                         gboolean force,
                                                         const BDExtraArg **extra,
                                                         GError **error);

spec :

mount point or device to unmount

lazy :

enable/disable lazy unmount

force :

enable/disable force unmount

extra :

extra options for the unmount currently only 'run_as_uid' and 'run_as_gid' are supported value must be a valid non zero uid (gid). [allow-none][array zero-terminated=1]

error :

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

Returns :

whether spec was successfully unmounted or not

bd_fs_get_mountpoint ()

gchar *             bd_fs_get_mountpoint                (const gchar *device,
                                                         GError **error);

Get mountpoint for device. If device is mounted multiple times only one mountpoint will be returned.

device :

device to find mountpoint for

error :

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

Returns :

mountpoint for device, NULL in case device is not mounted or in case of an error (error is set in this case). [transfer full]

bd_fs_resize ()

gboolean            bd_fs_resize                        (const gchar *device,
                                                         guint64 new_size,
                                                         GError **error);

device :

the device the file system of which to resize

new_size :

new requested size for the file system (if 0, the file system is adapted to the underlying block device)

error :

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

Returns :

whether the file system on device was successfully resized or not

bd_fs_repair ()

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

Repair filesystem on device. This calls other fs repair functions from this plugin based on detected filesystem (e.g. bd_fs_xfs_repair for XFS). This function will return an error for unknown/unsupported filesystems.

device :

the device the file system of which to repair

error :

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

Returns :

whether the file system on device was successfully repaired or not

bd_fs_check ()

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

Check filesystem on device. This calls other fs check functions from this plugin based on detected filesystem (e.g. bd_fs_xfs_check for XFS). This function will return an error for unknown/unsupported filesystems.

device :

the device the file system of which to check

error :

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

Returns :

whether the file system on device passed the consistency check or not

bd_fs_set_label ()

gboolean            bd_fs_set_label                     (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

Set label for filesystem on device. This calls other fs label functions from this plugin based on detected filesystem (e.g. bd_fs_xfs_set_label for XFS). This function will return an error for unknown/unsupported filesystems.

device :

the device with file system to set the label for

error :

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

Returns :

whether the file system on device was successfully relabled or not

bd_fs_can_resize ()

gboolean            bd_fs_can_resize                    (const gchar *type,
                                                         BDFsResizeFlags *mode,
                                                         gchar **required_utility,
                                                         GError **error);

Searches for the required utility to resize the given filesystem and returns whether it is installed. The mode flags indicate if growing and/or shrinking resize is available if mounted/unmounted. Unknown filesystems or filesystems which do not support resizing result in errors.

type :

the filesystem type to be tested for installed resize support

mode :

flags for allowed resizing (i.e. growing/shrinking support for online/offline). [out]

required_utility :

the utility binary which is required for resizing (if missing i.e. returns FALSE but no error). [out][transfer full]

error :

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

Returns :

whether filesystem resize is available

bd_fs_can_check ()

gboolean            bd_fs_can_check                     (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);

Searches for the required utility to check the given filesystem and returns whether it is installed. Unknown filesystems or filesystems which do not support checking result in errors.

type :

the filesystem type to be tested for installed consistency check support

required_utility :

the utility binary which is required for checking (if missing i.e. returns FALSE but no error). [out][transfer full]

error :

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

Returns :

whether filesystem check is available

bd_fs_can_repair ()

gboolean            bd_fs_can_repair                    (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);

Searches for the required utility to repair the given filesystem and returns whether it is installed. Unknown filesystems or filesystems which do not support reparing result in errors.

type :

the filesystem type to be tested for installed repair support

required_utility :

the utility binary which is required for repairing (if missing i.e. return FALSE but no error). [out][transfer full]

error :

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

Returns :

whether filesystem repair is available

bd_fs_can_set_label ()

gboolean            bd_fs_can_set_label                 (const gchar *type,
                                                         gchar **required_utility,
                                                         GError **error);

Searches for the required utility to set the label of the given filesystem and returns whether it is installed. Unknown filesystems or filesystems which do not support setting the label result in errors.

type :

the filesystem type to be tested for installed label support

required_utility :

the utility binary which is required for relabeling (if missing i.e. return FALSE but no error). [out][transfer full]

error :

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

Returns :

whether setting filesystem label is available

bd_fs_ext2_check ()

gboolean            bd_fs_ext2_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to check

extra :

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

error :

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

Returns :

whether an ext2 file system on the device is clean or not

bd_fs_ext2_get_info ()

BDFSExt2Info *      bd_fs_ext2_get_info                 (const gchar *device,
                                                         GError **error);

device :

the device the file system of which to get info for

error :

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

Returns :

information about the file system on device or NULL in case of error. [transfer full]

bd_fs_ext2_info_copy ()

BDFSExt2Info *      bd_fs_ext2_info_copy                (BDFSExt2Info *data);

Creates a new copy of data.


bd_fs_ext2_info_free ()

void                bd_fs_ext2_info_free                (BDFSExt2Info *data);

Frees data.


bd_fs_ext2_mkfs ()

gboolean            bd_fs_ext2_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to create a new ext2 fs on

extra :

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

error :

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

Returns :

whether a new ext2 fs was successfully created on device or not

bd_fs_ext2_repair ()

gboolean            bd_fs_ext2_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to repair

unsafe :

whether to do unsafe operations too

extra :

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

error :

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

Returns :

whether an ext2 file system on the device was successfully repaired (if needed) or not (error is set in that case)

bd_fs_ext2_resize ()

gboolean            bd_fs_ext2_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system of which to resize

new_size :

new requested size for the file system (if 0, the file system is adapted to the underlying block device)

extra :

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

error :

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

Returns :

whether the file system on device was successfully resized or not

bd_fs_ext2_set_label ()

gboolean            bd_fs_ext2_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

device :

the device the file system on which to set label for

label :

label to set

error :

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

Returns :

whether the label of ext2 file system on the device was successfully set or not

bd_fs_ext2_wipe ()

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

device :

the device to wipe an ext2 signature from

error :

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

Returns :

whether an ext2 signature was successfully wiped from the device or not

bd_fs_ext3_check ()

gboolean            bd_fs_ext3_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to check

extra :

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

error :

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

Returns :

whether an ext3 file system on the device is clean or not

bd_fs_ext3_get_info ()

BDFSExt3Info *      bd_fs_ext3_get_info                 (const gchar *device,
                                                         GError **error);

device :

the device the file system of which to get info for

error :

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

Returns :

information about the file system on device or NULL in case of error. [transfer full]

bd_fs_ext3_info_copy ()

BDFSExt3Info *      bd_fs_ext3_info_copy                (BDFSExt3Info *data);

Creates a new copy of data.


bd_fs_ext3_info_free ()

void                bd_fs_ext3_info_free                (BDFSExt3Info *data);

Frees data.


bd_fs_ext3_mkfs ()

gboolean            bd_fs_ext3_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to create a new ext3 fs on

extra :

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

error :

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

Returns :

whether a new ext3 fs was successfully created on device or not

bd_fs_ext3_repair ()

gboolean            bd_fs_ext3_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to repair

unsafe :

whether to do unsafe operations too

extra :

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

error :

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

Returns :

whether an ext3 file system on the device was successfully repaired (if needed) or not (error is set in that case)

bd_fs_ext3_resize ()

gboolean            bd_fs_ext3_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system of which to resize

new_size :

new requested size for the file system (if 0, the file system is adapted to the underlying block device)

extra :

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

error :

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

Returns :

whether the file system on device was successfully resized or not

bd_fs_ext3_set_label ()

gboolean            bd_fs_ext3_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

device :

the device the file system on which to set label for

label :

label to set

error :

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

Returns :

whether the label of ext3 file system on the device was successfully set or not

bd_fs_ext3_wipe ()

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

device :

the device to wipe an ext3 signature from

error :

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

Returns :

whether an ext3 signature was successfully wiped from the device or not

bd_fs_ext4_check ()

gboolean            bd_fs_ext4_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to check

extra :

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

error :

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

Returns :

whether an ext4 file system on the device is clean or not

bd_fs_ext4_get_info ()

BDFSExt4Info *      bd_fs_ext4_get_info                 (const gchar *device,
                                                         GError **error);

device :

the device the file system of which to get info for

error :

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

Returns :

information about the file system on device or NULL in case of error. [transfer full]

bd_fs_ext4_info_copy ()

BDFSExt4Info *      bd_fs_ext4_info_copy                (BDFSExt4Info *data);

Creates a new copy of data.


bd_fs_ext4_info_free ()

void                bd_fs_ext4_info_free                (BDFSExt4Info *data);

Frees data.


bd_fs_ext4_mkfs ()

gboolean            bd_fs_ext4_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to create a new ext4 fs on

extra :

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

error :

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

Returns :

whether a new ext4 fs was successfully created on device or not

bd_fs_ext4_repair ()

gboolean            bd_fs_ext4_repair                   (const gchar *device,
                                                         gboolean unsafe,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system on which to repair

unsafe :

whether to do unsafe operations too

extra :

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

error :

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

Returns :

whether an ext4 file system on the device was successfully repaired (if needed) or not (error is set in that case)

bd_fs_ext4_resize ()

gboolean            bd_fs_ext4_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device the file system of which to resize

new_size :

new requested size for the file system (if 0, the file system is adapted to the underlying block device)

extra :

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

error :

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

Returns :

whether the file system on device was successfully resized or not

bd_fs_ext4_set_label ()

gboolean            bd_fs_ext4_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

device :

the device the file system on which to set label for

label :

label to set

error :

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

Returns :

whether the label of ext4 file system on the device was successfully set or not

bd_fs_ext4_wipe ()

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

device :

the device to wipe an ext4 signature from

error :

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

Returns :

whether an ext4 signature was successfully wiped from the device or not

BDFSXfsInfo

typedef struct {
    gchar *label;
    gchar *uuid;
    guint64 block_size;
    guint64 block_count;
} BDFSXfsInfo;

gchar *label;

label of the filesystem

gchar *uuid;

uuid of the filesystem

guint64 block_size;

block size used by the filesystem

guint64 block_count;

number of blocks in the filesystem

bd_fs_xfs_check ()

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

device :

the device containing the file system to check

error :

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

Returns :

whether an xfs file system on the device is clean or not Note: if the file system is mounted it may be reported as unclean even if everything is okay and there are just some pending/in-progress writes

bd_fs_xfs_get_info ()

BDFSXfsInfo *       bd_fs_xfs_get_info                  (const gchar *device,
                                                         GError **error);

device :

the device containing the file system to get info for (device must be mounted, trying to get info for an unmounted device will result in an error)

error :

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

Returns :

information about the file system on device or NULL in case of error. [transfer full]

bd_fs_xfs_info_copy ()

BDFSXfsInfo *       bd_fs_xfs_info_copy                 (BDFSXfsInfo *data);

Creates a new copy of data.


bd_fs_xfs_info_free ()

void                bd_fs_xfs_info_free                 (BDFSXfsInfo *data);

Frees data.


bd_fs_xfs_mkfs ()

gboolean            bd_fs_xfs_mkfs                      (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to create a new xfs fs on

extra :

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

error :

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

Returns :

whether a new xfs fs was successfully created on device or not

bd_fs_xfs_repair ()

gboolean            bd_fs_xfs_repair                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device containing the file system to repair

extra :

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

error :

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

Returns :

whether an xfs file system on the device was successfully repaired (if needed) or not (error is set in that case)

bd_fs_xfs_resize ()

gboolean            bd_fs_xfs_resize                    (const gchar *mpoint,
                                                         guint64 new_size,
                                                         const BDExtraArg **extra,
                                                         GError **error);

mpoint :

the mount point of the file system to resize

new_size :

new requested size for the file system *in file system blocks* (see bd_fs_xfs_get_info()) (if 0, the file system is adapted to the underlying block device)

extra :

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

error :

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

Returns :

whether the file system mounted on mpoint was successfully resized or not

bd_fs_xfs_set_label ()

gboolean            bd_fs_xfs_set_label                 (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

device :

the device containing the file system to set label for

label :

label to set

error :

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

Returns :

whether the label of xfs file system on the device was successfully set or not

bd_fs_xfs_wipe ()

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

device :

the device to wipe an xfs signature from

error :

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

Returns :

whether an xfs signature was successfully wiped from the device or not

BDFSVfatInfo

typedef struct {
    gchar *label;
    gchar *uuid;
    guint64 cluster_size;
    guint64 cluster_count;
    guint64 free_cluster_count;
} BDFSVfatInfo;

gchar *label;

label of the filesystem

gchar *uuid;

uuid of the filesystem

guint64 cluster_size;

cluster size used by the filesystem

guint64 cluster_count;

number of clusters in the filesystem

guint64 free_cluster_count;

number of free clusters in the filesystem

bd_fs_vfat_check ()

gboolean            bd_fs_vfat_check                    (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device containing the file system to check

extra :

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

error :

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

Returns :

whether an vfat file system on the device is clean or not

bd_fs_vfat_get_info ()

BDFSVfatInfo *      bd_fs_vfat_get_info                 (const gchar *device,
                                                         GError **error);

device :

the device containing the file system to get info for

error :

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

Returns :

information about the file system on device or NULL in case of error. [transfer full]

bd_fs_vfat_info_copy ()

BDFSVfatInfo *      bd_fs_vfat_info_copy                (BDFSVfatInfo *data);

Creates a new copy of data.


bd_fs_vfat_info_free ()

void                bd_fs_vfat_info_free                (BDFSVfatInfo *data);

Frees data.


bd_fs_vfat_mkfs ()

gboolean            bd_fs_vfat_mkfs                     (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device to create a new vfat fs on

extra :

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

error :

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

Returns :

whether a new vfat fs was successfully created on device or not

bd_fs_vfat_repair ()

gboolean            bd_fs_vfat_repair                   (const gchar *device,
                                                         const BDExtraArg **extra,
                                                         GError **error);

device :

the device containing the file system to repair

extra :

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

error :

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

Returns :

whether an vfat file system on the device was successfully repaired (if needed) or not (error is set in that case)

bd_fs_vfat_resize ()

gboolean            bd_fs_vfat_resize                   (const gchar *device,
                                                         guint64 new_size,
                                                         GError **error);

device :

the device the file system of which to resize

new_size :

new requested size for the file system (if 0, the file system is adapted to the underlying block device)

error :

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

Returns :

whether the file system on device was successfully resized or not

bd_fs_vfat_set_label ()

gboolean            bd_fs_vfat_set_label                (const gchar *device,
                                                         const gchar *label,
                                                         GError **error);

device :

the device containing the file system to set label for

label :

label to set

error :

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

Returns :

whether the label of vfat file system on the device was successfully set or not

bd_fs_vfat_wipe ()

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

device :

the device to wipe an vfat signature from

error :

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

Returns :

whether an vfat signature was successfully wiped from the device or not