#include <glib.h>

#include <glib-object.h>

#include <blockdev/utils.h>

#ifndef BD_FS_API

#define BD_FS_API

GQuark bd_fs_error_quark (void) {

    return g_quark_from_static_string ("g-bd-fs-error-quark");

}

#define BD_FS_ERROR bd_fs_error_quark ()

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,

    BD_FS_ERROR_TECH_UNAVAIL,

} BDFsError;

#define BD_FS_TYPE_EXT2_INFO (bd_fs_ext2_info_get_type ())

GType bd_fs_ext2_info_get_type();

#define BD_FS_TYPE_EXT3_INFO (bd_fs_ext3_info_get_type ())

GType bd_fs_ext3_info_get_type();

#define BD_FS_TYPE_EXT4_INFO (bd_fs_ext4_info_get_type ())

GType bd_fs_ext4_info_get_type();

/**

 * BDFSExtInfo:

 * @label: label of the filesystem

 * @uuid: uuid of the filesystem

 * @state: state of the filesystem (e.g. "clean")

 * @block_size: block size used by the filesystem

 * @block_count: number of blocks in the filesystem

 * @free_blocks: number of free blocks in the filesystem

 */

typedef struct BDFSExtInfo {

    gchar *label;

    gchar *uuid;

    gchar *state;

    guint64 block_size;

    guint64 block_count;

    guint64 free_blocks;

} BDFSExtInfo;

typedef struct BDFSExtInfo BDFSExt4Info;

typedef struct BDFSExtInfo BDFSExt3Info;

typedef struct BDFSExtInfo BDFSExt2Info;

/**

 * bd_fs_ext2_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSExt2Info* bd_fs_ext2_info_copy (BDFSExt2Info *data) {

    if (data == NULL)

        return NULL;

    BDFSExt2Info *ret = g_new0 (BDFSExt2Info, 1);

    ret->label = g_strdup (data->label);

    ret->uuid = g_strdup (data->uuid);

    ret->state = g_strdup (data->state);

    ret->block_size = data->block_size;

    ret->block_count = data->block_count;

    ret->free_blocks = data->free_blocks;

    return ret;

}

/**

 * bd_fs_ext3_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSExt3Info* bd_fs_ext3_info_copy (BDFSExt3Info *data) {

    return (BDFSExt3Info*) bd_fs_ext2_info_copy (data);

}

/**

 * bd_fs_ext4_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSExt4Info* bd_fs_ext4_info_copy (BDFSExt4Info *data) {

    return (BDFSExt4Info*) bd_fs_ext2_info_copy (data);

};

/**

 * bd_fs_ext2_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_ext2_info_free (BDFSExt2Info *data) {

    if (data == NULL)

        return;

    g_free (data->label);

    g_free (data->uuid);

    g_free (data->state);

    g_free (data);

}

/**

 * bd_fs_ext3_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_ext3_info_free (BDFSExt3Info *data) {

    bd_fs_ext2_info_free ((BDFSExt2Info*) data);

}

/**

 * bd_fs_ext4_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_ext4_info_free (BDFSExt4Info *data) {

    bd_fs_ext2_info_free ((BDFSExt2Info*) data);

}

GType bd_fs_ext2_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSExt2Info",

                                            (GBoxedCopyFunc) bd_fs_ext2_info_copy,

                                            (GBoxedFreeFunc) bd_fs_ext2_info_free);

    }

    return type;

}

GType bd_fs_ext3_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSExt3Info",

                                            (GBoxedCopyFunc) bd_fs_ext3_info_copy,

                                            (GBoxedFreeFunc) bd_fs_ext3_info_free);

    }

    return type;

}

GType bd_fs_ext4_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSExt4Info",

                                            (GBoxedCopyFunc) bd_fs_ext4_info_copy,

                                            (GBoxedFreeFunc) bd_fs_ext4_info_free);

    }

    return type;

}

#define BD_FS_TYPE_XFS_INFO (bd_fs_xfs_info_get_type ())

GType bd_fs_xfs_info_get_type();

/**

 * BDFSXfsInfo:

 * @label: label of the filesystem

 * @uuid: uuid of the filesystem

 * @block_size: block size used by the filesystem

 * @block_count: number of blocks in the filesystem

 */

typedef struct BDFSXfsInfo {

    gchar *label;

    gchar *uuid;

    guint64 block_size;

    guint64 block_count;

} BDFSXfsInfo;

/**

 * bd_fs_xfs_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSXfsInfo* bd_fs_xfs_info_copy (BDFSXfsInfo *data) {

    if (data == NULL)

        return NULL;

    BDFSXfsInfo *ret = g_new0 (BDFSXfsInfo, 1);

    ret->label = g_strdup (data->label);

    ret->uuid = g_strdup (data->uuid);

    ret->block_size = data->block_size;

    ret->block_count = data->block_count;

    return ret;

}

/**

 * bd_fs_xfs_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_xfs_info_free (BDFSXfsInfo *data) {

    if (data == NULL)

        return;

    g_free (data->label);

    g_free (data->uuid);

    g_free (data);

}

GType bd_fs_xfs_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSXfsInfo",

                                            (GBoxedCopyFunc) bd_fs_xfs_info_copy,

                                            (GBoxedFreeFunc) bd_fs_xfs_info_free);

    }

    return type;

}

#define BD_FS_TYPE_VFAT_INFO (bd_fs_vfat_info_get_type ())

GType bd_fs_vfat_info_get_type();

/**

 * BDFSVfatInfo:

 * @label: label of the filesystem

 * @uuid: uuid of the filesystem

 * @cluster_size: cluster size used by the filesystem

 * @cluster_count: number of clusters in the filesystem

 * @free_cluster_count: number of free clusters in the filesystem

 */

typedef struct BDFSVfatInfo {

    gchar *label;

    gchar *uuid;

    guint64 cluster_size;

    guint64 cluster_count;

    guint64 free_cluster_count;

} BDFSVfatInfo;

/**

 * bd_fs_vfat_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSVfatInfo* bd_fs_vfat_info_copy (BDFSVfatInfo *data) {

    if (data == NULL)

        return NULL;

    BDFSVfatInfo *ret = g_new0 (BDFSVfatInfo, 1);

    ret->label = g_strdup (data->label);

    ret->uuid = g_strdup (data->uuid);

    ret->cluster_size = data->cluster_size;

    ret->cluster_count = data->cluster_count;

    return ret;

}

/**

 * bd_fs_vfat_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_vfat_info_free (BDFSVfatInfo *data) {

    if (data == NULL)

        return;

    g_free (data->label);

    g_free (data->uuid);

    g_free (data);

}

GType bd_fs_vfat_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSVfatInfo",

                                            (GBoxedCopyFunc) bd_fs_vfat_info_copy,

                                            (GBoxedFreeFunc) bd_fs_vfat_info_free);

    }

    return type;

}

/**

 * BDFSNtfsInfo:

 * @size: size of the filesystem in bytes

 * @free_space: number of free space in the filesystem in bytes

 */

typedef struct BDFSNtfsInfo {

    guint64 size;

    guint64 free_space;

} BDFSNtfsInfo;

/**

 * bd_fs_ntfs_info_copy: (skip)

 *

 * Creates a new copy of @data.

 */

BDFSNtfsInfo* bd_fs_ntfs_info_copy (BDFSNtfsInfo *data) {

    if (data == NULL)

        return NULL;

    BDFSNtfsInfo *ret = g_new0 (BDFSNtfsInfo, 1);

    ret->size = data->size;

    ret->free_space = data->free_space;

    return ret;

}

/**

 * bd_fs_ntfs_info_free: (skip)

 *

 * Frees @data.

 */

void bd_fs_ntfs_info_free (BDFSNtfsInfo *data) {

    g_free (data);

}

GType bd_fs_ntfs_info_get_type () {

    static GType type = 0;

    if (G_UNLIKELY(type == 0)) {

        type = g_boxed_type_register_static("BDFSNtfsInfo",

                                            (GBoxedCopyFunc) bd_fs_ntfs_info_copy,

                                            (GBoxedFreeFunc) bd_fs_ntfs_info_free);

    }

    return type;

}

typedef enum {

    BD_FS_TECH_GENERIC = 0,

    BD_FS_TECH_MOUNT,

    BD_FS_TECH_EXT2,

    BD_FS_TECH_EXT3,

    BD_FS_TECH_EXT4,

    BD_FS_TECH_XFS,

    BD_FS_TECH_VFAT,

    BD_FS_TECH_NTFS

} BDFSTech;

typedef enum {

    BD_FS_TECH_MODE_MKFS      = 1 << 0,

    BD_FS_TECH_MODE_WIPE      = 1 << 1,

    BD_FS_TECH_MODE_CHECK     = 1 << 2,

    BD_FS_TECH_MODE_REPAIR    = 1 << 3,

    BD_FS_TECH_MODE_SET_LABEL = 1 << 4,

    BD_FS_TECH_MODE_QUERY     = 1 << 5,

    BD_FS_TECH_MODE_RESIZE    = 1 << 6,

} BDFSTechMode;

/**

 * bd_fs_is_tech_avail:

 * @tech: the queried tech

 * @mode: a bit mask of queried modes of operation (#BDFSTechMode) for @tech

 * @error: (out): place to store error (details about why the @tech-@mode combination is not available)

 *

 * Returns: whether the @tech-@mode combination is available -- supported by the

 *          plugin implementation and having all the runtime dependencies available

 */

gboolean bd_fs_is_tech_avail (BDFSTech tech, guint64 mode, GError **error);

/**

 * bd_fs_wipe:

 * @device: the device to wipe signatures from

 * @all: whether to wipe all (%TRUE) signatures or just the first (%FALSE) one

 * @error: (out): place to store error (if any)

 *

 * Note: This function will wipe signatures on a mounted @device without

 *       asking. Use %bd_fs_wipe_force if you want to control this

 *       behaviour manually.

 *

 * Returns: whether signatures were successfully wiped on @device or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_wipe_force:

 * @device: the device to wipe signatures from

 * @all: whether to wipe all (%TRUE) signatures or just the first (%FALSE) one

 * @force: whether to force wipe even if the filesystem is mounted

 * @error: (out): place to store error (if any)

 *

 * Returns: whether signatures were successfully wiped on @device or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_clean:

 * @device: the device to clean

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether @device was successfully cleaned or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_get_fstype:

 * @device: the device to probe

 * @error: (out): place to store error (if any)

 *

 * Get first signature on @device as a string.

 *

 * Returns: (transfer full): 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)

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_freeze:

 * @mountpoint: mountpoint of the device (filesystem) to freeze

 * @error: (out): place to store error (if any)

 *

 * Freezes filesystem mounted on @mountpoint. The filesystem must

 * support freezing.

 *

 * Returns: whether @mountpoint was successfully freezed or not

 *

 */

gboolean bd_fs_freeze (const gchar *mountpoint, GError **error);

/**

 * bd_fs_unfreeze:

 * @mountpoint: mountpoint of the device (filesystem) to un-freeze

 * @error: (out): place to store error (if any)

 *

 * Un-freezes filesystem mounted on @mountpoint. The filesystem must

 * support freezing.

 *

 * Returns: whether @mountpoint was successfully unfreezed or not

 *

 */

gboolean bd_fs_unfreeze (const gchar *mountpoint, GError **error);

/**

 * bd_fs_unmount:

 * @spec: mount point or device to unmount

 * @lazy: enable/disable lazy unmount

 * @force: enable/disable force unmount

 * @extra: (allow-none) (array zero-terminated=1): 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)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether @spec was successfully unmounted or not

 *

 * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)

 */

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

/**

 * bd_fs_mount:

 * @device: (allow-none): device to mount, if not specified @mountpoint entry

 *                        from fstab will be used

 * @mountpoint: (allow-none): mountpoint for @device, if not specified @device

 *                            entry from fstab will be used

 * @fstype: (allow-none): filesystem type

 * @options: (allow-none): comma delimited options for mount

 * @extra: (allow-none) (array zero-terminated=1): 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)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether @device (or @mountpoint) was successfully mounted or not

 *

 * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)

 */

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

/**

 * bd_fs_get_mountpoint:

 * @device: device to find mountpoint for

 * @error: (out): place to store error (if any)

 *

 * Get mountpoint for @device. If @device is mounted multiple times only

 * one mountpoint will be returned.

 *

 * Returns: (transfer full): mountpoint for @device, %NULL in case device is

 *                           not mounted or in case of an error (@error is set

 *                           in this case)

 *

 * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)

 */

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

/**

 * bd_fs_is_mountpoint:

 * @path: path (folder) to check

 * @error: (out): place to store error (if any)

 *

 * Returns: whether @path is a mountpoint or not

 *

 * Tech category: %BD_FS_TECH_MOUNT (no mode, ignored)

 */

gboolean bd_fs_is_mountpoint (const gchar *path, GError **error);

/**

 * bd_fs_resize:

 * @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: (out): place to store error (if any)

 *

 * Returns: whether the file system on @device was successfully resized or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_RESIZE

 */

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

 /**

 * bd_fs_repair:

 * @device: the device the file system of which to repair

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether the file system on @device was successfully repaired or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_REPAIR

 */

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

/**

 * bd_fs_check:

 * @device: the device the file system of which to check

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether the file system on @device passed the consistency check or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_CHECK

 */

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

/**

 * bd_fs_set_label:

 * @device: the device with file system to set the label for

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether the file system on @device was successfully relabled or not

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_SET_LABEL

 */

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

/**

 * BDFsResizeFlags:

 * Flags indicating whether a filesystem resize action supports growing and/or

 * shrinking if mounted or unmounted.

 */

typedef enum {

    BD_FS_OFFLINE_SHRINK = 1 << 1,

    BD_FS_OFFLINE_GROW = 1 << 2,

    BD_FS_ONLINE_SHRINK = 1 << 3,

    BD_FS_ONLINE_GROW = 1 << 4

} BDFsResizeFlags;

/**

 * bd_fs_can_resize:

 * @type: the filesystem type to be tested for installed resize support

 * @mode: (out): flags for allowed resizing (i.e. growing/shrinking support for online/offline)

 * @required_utility: (out) (transfer full): the utility binary which is required for resizing (if missing i.e. returns FALSE but no error)

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether filesystem resize is available

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_can_check:

 * @type: the filesystem type to be tested for installed consistency check support

 * @required_utility: (out) (transfer full): the utility binary which is required for checking (if missing i.e. returns FALSE but no error)

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether filesystem check is available

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_can_repair:

 * @type: the filesystem type to be tested for installed repair support

 * @required_utility: (out) (transfer full): the utility binary which is required for repairing (if missing i.e. return FALSE but no error)

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether filesystem repair is available

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_can_set_label:

 * @type: the filesystem type to be tested for installed label support

 * @required_utility: (out) (transfer full): the utility binary which is required for relabeling (if missing i.e. return FALSE but no error)

 * @error: (out): place to store error (if any)

 *

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

 *

 * Returns: whether setting filesystem label is available

 *

 * Tech category: %BD_FS_TECH_GENERIC-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_ext2_mkfs:

 * @device: the device to create a new ext2 fs on

 * @extra: (allow-none) (array zero-terminated=1): extra options for the creation (right now

 *                                                 passed to the 'mke2fs' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether a new ext2 fs was successfully created on @device or not

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_MKFS

 */

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

/**

 * bd_fs_ext3_mkfs:

 * @device: the device to create a new ext3 fs on

 * @extra: (allow-none) (array zero-terminated=1): extra options for the creation (right now

 *                                                 passed to the 'mke2fs' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether a new ext3 fs was successfully created on @device or not

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_MKFS

 */

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

/**

 * bd_fs_ext4_mkfs:

 * @device: the device to create a new ext4 fs on

 * @extra: (allow-none) (array zero-terminated=1): extra options for the creation (right now

 *                                                 passed to the 'mkfs.ext4' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether a new ext4 fs was successfully created on @device or not

 *

 * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_MKFS

 */

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

/**

 * bd_fs_ext2_wipe:

 * @device: the device to wipe an ext2 signature from

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext2 signature was successfully wiped from the @device or

 *          not

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_ext3_wipe:

 * @device: the device to wipe an ext3 signature from

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext3 signature was successfully wiped from the @device or

 *          not

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_ext4_wipe:

 * @device: the device to wipe an ext4 signature from

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext4 signature was successfully wiped from the @device or

 *          not

 *

 * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_WIPE

 */

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

/**

 * bd_fs_ext2_check:

 * @device: the device the file system on which to check

 * @extra: (allow-none) (array zero-terminated=1): extra options for the check (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext2 file system on the @device is clean or not

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_CHECK

 */

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

/**

 * bd_fs_ext3_check:

 * @device: the device the file system on which to check

 * @extra: (allow-none) (array zero-terminated=1): extra options for the check (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext3 file system on the @device is clean or not

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_CHECK

 */

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

/**

 * bd_fs_ext4_check:

 * @device: the device the file system on which to check

 * @extra: (allow-none) (array zero-terminated=1): extra options for the check (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext4 file system on the @device is clean or not

 *

 * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_CHECK

 */

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

/**

 * bd_fs_ext2_repair:

 * @device: the device the file system on which to repair

 * @unsafe: whether to do unsafe operations too

 * @extra: (allow-none) (array zero-terminated=1): extra options for the repair (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext2 file system on the @device was successfully repaired

 *          (if needed) or not (error is set in that case)

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_REPAIR

 */

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

/**

 * bd_fs_ext3_repair:

 * @device: the device the file system on which to repair

 * @unsafe: whether to do unsafe operations too

 * @extra: (allow-none) (array zero-terminated=1): extra options for the repair (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext3 file system on the @device was successfully repaired

 *          (if needed) or not (error is set in that case)

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_REPAIR

 */

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

/**

 * bd_fs_ext4_repair:

 * @device: the device the file system on which to repair

 * @unsafe: whether to do unsafe operations too

 * @extra: (allow-none) (array zero-terminated=1): extra options for the repair (right now

 *                                                 passed to the 'e2fsck' utility)

 * @error: (out): place to store error (if any)

 *

 * Returns: whether an ext4 file system on the @device was successfully repaired

 *          (if needed) or not (error is set in that case)

 *

 * Tech category: %BD_FS_TECH_EXT4-%BD_FS_TECH_MODE_REPAIR

 */

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

/**

 * bd_fs_ext2_set_label:

 * @device: the device the file system on which to set label for

 * @label: label to set

 * @error: (out): place to store error (if any)

 *

 * Returns: whether the label of ext2 file system on the @device was

 *          successfully set or not

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_SET_LABEL

 */

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

/**

 * bd_fs_ext3_set_label:

 * @device: the device the file system on which to set label for

 * @label: label to set

 * @error: (out): place to store error (if any)

 *

 * Returns: whether the label of ext3 file system on the @device was

 *          successfully set or not

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_SET_LABEL

 */

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

/**

 * bd_fs_ext4_set_label:

 * @device: the device the file system on which to set label for

 * @label: label to set

 * @error: (out): place to store error (if any)

 *

 * Returns: whether the label of ext4 file system on the @device was

 *          successfully set or not

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_SET_LABEL

 */

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

/**

 * bd_fs_ext2_get_info:

 * @device: the device the file system of which to get info for

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): information about the file system on @device or

 *                           %NULL in case of error

 *

 * Tech category: %BD_FS_TECH_EXT2-%BD_FS_TECH_MODE_QUERY

 */

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

/**

 * bd_fs_ext3_get_info:

 * @device: the device the file system of which to get info for

 * @error: (out): place to store error (if any)

 *

 * Returns: (transfer full): information about the file system on @device or

 *                           %NULL in case of error

 *

 * Tech category: %BD_FS_TECH_EXT3-%BD_FS_TECH_MODE_QUERY

 */

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

/**