## FS

FS — plugin for operations with file systems

## Functions

gboolean | bd_fs_init ()
void | bd_fs_close ()
GQuark | bd_fs_error_quark ()
gboolean | bd_fs_wipe ()
gboolean | bd_fs_clean ()
gchar * | bd_fs_get_fstype ()
gboolean | bd_fs_freeze ()
gboolean | bd_fs_unfreeze ()
gboolean | bd_fs_mount ()
gboolean | bd_fs_unmount ()
gchar * | bd_fs_get_mountpoint ()
gboolean | bd_fs_is_mountpoint ()
gboolean | bd_fs_resize ()
gboolean | bd_fs_repair ()
gboolean | bd_fs_check ()
gboolean | bd_fs_set_label ()
gboolean | bd_fs_check_label ()
guint64 | bd_fs_get_size ()
guint64 | bd_fs_get_free_space ()
guint64 | bd_fs_get_min_size ()
gboolean | bd_fs_can_resize ()
gboolean | bd_fs_can_check ()
gboolean | bd_fs_can_repair ()
gboolean | bd_fs_can_set_label ()
gboolean | bd_fs_can_get_size ()
gboolean | bd_fs_can_get_free_space ()
gboolean | bd_fs_can_get_min_size ()
gboolean | bd_fs_can_get_info ()
gboolean | bd_fs_can_set_uuid ()
gboolean | bd_fs_set_uuid ()
gboolean | bd_fs_check_uuid ()
const BDFSFeatures * | bd_fs_features ()
BDFSFeatures * | bd_fs_features_copy ()
void | bd_fs_features_free ()
gboolean | bd_fs_can_mkfs ()
gboolean | bd_fs_mkfs ()
BDFSMkfsOptions * | bd_fs_mkfs_options_copy ()
void | bd_fs_mkfs_options_free ()
const gchar ** | bd_fs_supported_filesystems ()
gboolean | bd_fs_ext2_check ()
BDFSExt2Info * | bd_fs_ext2_get_info ()
BDFSExt2Info * | bd_fs_ext2_info_copy ()
void | bd_fs_ext2_info_free ()
gboolean | bd_fs_ext2_mkfs ()
gboolean | bd_fs_ext2_repair ()
gboolean | bd_fs_ext2_resize ()
gboolean | bd_fs_ext2_set_label ()
gboolean | bd_fs_ext2_check_label ()
gboolean | bd_fs_ext2_set_uuid ()
gboolean | bd_fs_ext2_check_uuid ()
guint64 | bd_fs_ext2_get_min_size ()
gboolean | bd_fs_ext3_check ()
BDFSExt3Info * | bd_fs_ext3_get_info ()
BDFSExt3Info * | bd_fs_ext3_info_copy ()
void | bd_fs_ext3_info_free ()
gboolean | bd_fs_ext3_mkfs ()
gboolean | bd_fs_ext3_repair ()
gboolean | bd_fs_ext3_resize ()
gboolean | bd_fs_ext3_set_label ()
gboolean | bd_fs_ext3_check_label ()
gboolean | bd_fs_ext3_set_uuid ()
gboolean | bd_fs_ext3_check_uuid ()
guint64 | bd_fs_ext3_get_min_size ()
gboolean | bd_fs_ext4_check ()
BDFSExt4Info * | bd_fs_ext4_get_info ()
BDFSExt4Info * | bd_fs_ext4_info_copy ()
void | bd_fs_ext4_info_free ()
gboolean | bd_fs_ext4_mkfs ()
gboolean | bd_fs_ext4_repair ()
gboolean | bd_fs_ext4_resize ()
gboolean | bd_fs_ext4_set_label ()
gboolean | bd_fs_ext4_check_label ()
gboolean | bd_fs_ext4_set_uuid ()
gboolean | bd_fs_ext4_check_uuid ()
guint64 | bd_fs_ext4_get_min_size ()
gboolean | bd_fs_xfs_check ()
BDFSXfsInfo * | bd_fs_xfs_get_info ()
BDFSXfsInfo * | bd_fs_xfs_info_copy ()
void | bd_fs_xfs_info_free ()
gboolean | bd_fs_xfs_mkfs ()
gboolean | bd_fs_xfs_repair ()
gboolean | bd_fs_xfs_resize ()
gboolean | bd_fs_xfs_set_label ()
gboolean | bd_fs_xfs_check_label ()
gboolean | bd_fs_xfs_set_uuid ()
gboolean | bd_fs_xfs_check_uuid ()
gboolean | bd_fs_vfat_check ()
BDFSVfatInfo * | bd_fs_vfat_get_info ()
BDFSVfatInfo * | bd_fs_vfat_info_copy ()
void | bd_fs_vfat_info_free ()
gboolean | bd_fs_vfat_mkfs ()
gboolean | bd_fs_vfat_repair ()
gboolean | bd_fs_vfat_resize ()
gboolean | bd_fs_vfat_set_label ()
gboolean | bd_fs_vfat_check_label ()
gboolean | bd_fs_vfat_set_uuid ()
gboolean | bd_fs_vfat_check_uuid ()
gboolean | bd_fs_is_tech_avail ()
gboolean | bd_fs_ntfs_check ()
BDFSNtfsInfo * | bd_fs_ntfs_get_info ()
gboolean | bd_fs_ntfs_mkfs ()
gboolean | bd_fs_ntfs_repair ()
gboolean | bd_fs_ntfs_resize ()
gboolean | bd_fs_ntfs_set_label ()
gboolean | bd_fs_ntfs_check_label ()
BDFSNtfsInfo * | bd_fs_ntfs_info_copy ()
void | bd_fs_ntfs_info_free ()
gboolean | bd_fs_ntfs_set_uuid ()
gboolean | bd_fs_ntfs_check_uuid ()
guint64 | bd_fs_ntfs_get_min_size ()
BDFSF2FSInfo * | bd_fs_f2fs_info_copy ()
void | bd_fs_f2fs_info_free ()
gboolean | bd_fs_f2fs_mkfs ()
gboolean | bd_fs_f2fs_check ()
gboolean | bd_fs_f2fs_repair ()
BDFSF2FSInfo * | bd_fs_f2fs_get_info ()
gboolean | bd_fs_f2fs_resize ()
gboolean | bd_fs_f2fs_check_label ()
BDFSNILFS2Info * | bd_fs_nilfs2_get_info ()
BDFSNILFS2Info * | bd_fs_nilfs2_info_copy ()
void | bd_fs_nilfs2_info_free ()
gboolean | bd_fs_nilfs2_mkfs ()
gboolean | bd_fs_nilfs2_resize ()
gboolean | bd_fs_nilfs2_set_label ()
gboolean | bd_fs_nilfs2_check_label ()
gboolean | bd_fs_nilfs2_set_uuid ()
gboolean | bd_fs_nilfs2_check_uuid ()
gboolean | bd_fs_exfat_check ()
BDFSExfatInfo * | bd_fs_exfat_get_info ()
BDFSExfatInfo * | bd_fs_exfat_info_copy ()
void | bd_fs_exfat_info_free ()
gboolean | bd_fs_exfat_mkfs ()
gboolean | bd_fs_exfat_repair ()
gboolean | bd_fs_exfat_set_label ()
gboolean | bd_fs_exfat_check_label ()
gboolean | bd_fs_exfat_set_uuid ()
gboolean | bd_fs_exfat_check_uuid ()
BDFSBtrfsInfo * | bd_fs_btrfs_get_info ()
BDFSBtrfsInfo * | bd_fs_btrfs_info_copy ()
void | bd_fs_btrfs_info_free ()
gboolean | bd_fs_btrfs_mkfs ()
gboolean | bd_fs_btrfs_check ()
gboolean | bd_fs_btrfs_repair ()
gboolean | bd_fs_btrfs_set_label ()
gboolean | bd_fs_btrfs_check_label ()
gboolean | bd_fs_btrfs_set_uuid ()
gboolean | bd_fs_btrfs_check_uuid ()
gboolean | bd_fs_btrfs_resize ()
BDFSUdfInfo * | bd_fs_udf_get_info ()
BDFSUdfInfo * | bd_fs_udf_info_copy ()
void | bd_fs_udf_info_free ()
gboolean | bd_fs_udf_mkfs ()
gboolean | bd_fs_udf_set_label ()
gboolean | bd_fs_udf_check_label ()
gboolean | bd_fs_udf_set_uuid ()
gboolean | bd_fs_udf_check_uuid ()

## Types and Values

typedef | BDFSExt2Info
typedef | BDFSExt3Info
typedef | BDFSExt4Info
enum | BDFSError
#define | BD_FS_ERROR
enum | BDFSConfigureFlags
enum | BDFSFeatureFlags
| BDFSFeatures
enum | BDFSFsckFlags
| BDFSMkfsOptions
enum | BDFSMkfsOptionsFlags
| BDFSXfsInfo
| BDFSVfatInfo
enum | BDFSTech
enum | BDFSTechMode
enum | BDFSResizeFlags
| BDFSNtfsInfo
| BDFSF2FSInfo
enum | BDFSF2FSFeature
| BDFSNILFS2Info
| BDFSExfatInfo
| BDFSBtrfsInfo
| BDFSUdfInfo

## Includes

    #include <fs.h>

## Description

A plugin for operations with file systems

## Functions

### bd_fs_init ()

    gboolean
    bd_fs_init (void);

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

### bd_fs_close ()

    void
    bd_fs_close (void);

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

### bd_fs_error_quark ()

    GQuark
    bd_fs_error_quark (void);

[skip]

### bd_fs_wipe ()

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

#### Parameters

device | the device to wipe signatures from |
all | whether to wipe all (`TRUE`) signatures or just the first (`FALSE`) one |
force | whether to wipe signatures on a mounted `device` |
error | place to store error (if any). | [out][optional]

#### Returns

whether signatures were successfully wiped on `device` or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_WIPE`

### bd_fs_clean ()

    gboolean
    bd_fs_clean (const gchar *device,
                 gboolean force,
                 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.

#### Parameters

device | the device to clean |
force | whether to wipe signatures on a mounted `device` |
error | place to store error (if any). | [out][optional]

#### Returns

whether `device` was successfully cleaned or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_WIPE`

### bd_fs_get_fstype ()

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

Get first signature on `device` as a string.

#### Parameters

device | the device to probe |
error | place to store error (if any). | [out][optional]

#### 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)

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_freeze ()

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

Freezes filesystem mounted on `mountpoint` . The filesystem must support freezing.

#### Parameters

mountpoint | mountpoint of the device (filesystem) to freeze |
error | place to store error (if any). | [out][optional]

#### Returns

whether `mountpoint` was successfully freezed or not

### bd_fs_unfreeze ()

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

Un-freezes filesystem mounted on `mountpoint` . The filesystem must support freezing.

#### Parameters

mountpoint | mountpoint of the device (filesystem) to un-freeze |
error | place to store error (if any). | [out][optional]

#### Returns

whether `mountpoint` was successfully unfreezed or not

### bd_fs_mount ()

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

#### Parameters

device | device to mount, if not specified `mountpoint` entry from fstab will be used. | [nullable]
mountpoint | mountpoint for `device` , if not specified `device` entry from fstab will be used. | [nullable]
fstype | filesystem type. | [nullable]
options | comma delimited options for mount. | [nullable]
extra | extra options for the mount; currently only 'run_as_uid' and 'run_as_gid' are supported; value must be a valid non zero uid (gid), if you specify one of these, the function will run in a child process with real user. | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether `device` (or `mountpoint` ) was successfully mounted or not

Tech category: `BD_FS_TECH_MOUNT` (no mode, ignored)

### bd_fs_unmount ()

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

#### Parameters

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), if you specify one of these, the function will run in a child process with real user. | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether `spec` was successfully unmounted or not

Tech category: `BD_FS_TECH_MOUNT` (no mode, ignored)

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

#### Parameters

device | device to find mountpoint for |
error | place to store error (if any). | [out][optional]

#### Returns

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

[transfer full]

### bd_fs_is_mountpoint ()

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

#### Parameters

path | path (folder) to check |
error | place to store error (if any). | [out][optional]

#### Returns

whether `path` is a mountpoint or not

Tech category: `BD_FS_TECH_MOUNT` (no mode, ignored)

### bd_fs_resize ()

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

Resize filesystem on `device` . This calls other fs resize functions from this plugin based on provides or detected filesystem (e.g. bd_fs_xfs_resize for XFS). This function will return an error for unknown/unsupported filesystems.

Note: This function will mount `device` for filesystems that can be resized only when mounted (like XFS or Btrfs).

#### Parameters

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) |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_repair ()

    gboolean
    bd_fs_repair (const gchar *device,
                  const gchar *fstype,
                  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.

Most filesystem tools typically require the filesystem not to be mounted.

#### Parameters

device | the device the file system of which to repair |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully repaired or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_check ()

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

Check filesystem on `device` avoiding any modifications or repairs. 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.

Note that depending on a corresponding filesystem type and configured features running this function on a mounted filesystem may result in false errors reported.

#### Parameters

device | the device the file system of which to check |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_set_label ()

    gboolean
    bd_fs_set_label (const gchar *device,
                     const gchar *label,
                     const gchar *fstype,
                     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.

Note: This function will mount `device` for filesystems that need to be mounted to set label (like btrfs).

#### Parameters

device | the device with file system to set the label for |
label | label to set |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully relabeled or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_check_label ()

    gboolean
    bd_fs_check_label (const gchar *fstype,
                       const gchar *label,
                       GError **error);

This calls other fs check label functions from this plugin based on the provided filesystem (e.g. bd_fs_xfs_check_label for XFS). This function will return an error for unknown/unsupported filesystems.

#### Parameters

fstype | the filesystem type to check `label` for |
label | label to check |
error | place to store error (if any). | [out][optional]

#### Returns

whether `label` is a valid label for the `fstype` file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_get_size ()

    guint64
    bd_fs_get_size (const gchar *device,
                    const gchar *fstype,
                    GError **error);

Get size for filesystem on `device` . This calls other fs info functions from this plugin based on detected filesystem (e.g. bd_fs_xfs_get_info for XFS). This function will return an error for unknown/unsupported filesystems.

Note: This function will mount `device` for filesystems that need to be mounted to gather information (like btrfs).

#### Parameters

device | the device with file system to get size for |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

size of filesystem on `device` , 0 in case of error.

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_get_free_space ()

    guint64
    bd_fs_get_free_space (const gchar *device,
                          const gchar *fstype,
                          GError **error);

Get free space for filesystem on `device` . This calls other fs info functions from this plugin based on detected filesystem (e.g. bd_fs_ext4_get_info for ext4). This function will return an error for unknown/unsupported filesystems.

#### Parameters

device | the device with file system to get free space for |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

free space of filesystem on `device` , 0 in case of error.

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_get_min_size ()

    guint64
    bd_fs_get_min_size (const gchar *device,
                        const gchar *fstype,
                        GError **error);

Get minimum size for filesystem on `device` . This calls other fs info functions from this plugin based on detected filesystem (e.g. bd_fs_ext4_get_min_size for ext4). This function will return an error for unknown/unsupported filesystems.

#### Parameters

device | the device with file system to get minimum size for |
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

minimum size of filesystem on `device` , 0 in case of error.

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_RESIZE`

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

#### Parameters

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][optional]

#### Returns

whether filesystem resize is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

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

#### Parameters

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][optional]

#### Returns

whether filesystem check is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

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

#### Parameters

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][optional]

#### Returns

whether filesystem repair is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

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

#### Parameters

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][optional]

#### Returns

whether setting filesystem label is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_can_get_size ()

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

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

#### Parameters

type | the filesystem type to be tested for installed size querying support |
required_utility | the utility binary which is required for size querying (if missing i.e. return FALSE but no error). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether getting filesystem size is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_can_get_free_space ()

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

Searches for the required utility to get free space of the given filesystem and returns whether it is installed. Unknown filesystems or filesystems which do not support free space querying result in errors.

#### Parameters

type | the filesystem type to be tested for installed free space querying support |
required_utility | the utility binary which is required for free space querying (if missing i.e. return FALSE but no error). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether getting filesystem free space is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_can_get_min_size ()

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

Searches for the required utility to get minimum size of the given filesystem and returns whether it is installed. Unknown filesystems or filesystems which do not support minimum size querying result in errors.

#### Parameters

type | the filesystem type to be tested for installed minimum size querying support |
required_utility | the utility binary which is required for size querying (if missing i.e. return FALSE but no error). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether getting filesystem size is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_can_get_info ()

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

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

#### Parameters

type | the filesystem type to be tested for info querying support |
required_utility | the utility binary which is required for info querying (if missing i.e. return FALSE but no error). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether getting filesystem info is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_can_set_uuid ()

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

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

#### Parameters

type | the filesystem type to be tested for installed UUID support |
required_utility | the utility binary which is required for setting UUID (if missing i.e. return FALSE but no error). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether setting filesystem UUID is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_set_uuid ()

    gboolean
    bd_fs_set_uuid (const gchar *device,
                    const gchar *uuid,
                    const gchar *fstype,
                    GError **error);

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

#### Parameters

device | the device with file system to set the UUID for |
uuid | UUID to set or `NULL` to generate a new one. | [nullable]
fstype | the filesystem type on `device` or `NULL` to detect. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the UUID on the file system on `device` was successfully changed or not

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_check_uuid ()

    gboolean
    bd_fs_check_uuid (const gchar *fstype,
                      const gchar *uuid,
                      GError **error);

This calls other fs check uuid functions from this plugin based on the provided filesystem (e.g. bd_fs_xfs_check_uuid for XFS). This function will return an error for unknown/unsupported filesystems.

#### Parameters

fstype | the filesystem type to check `uuid` for |
uuid | uuid to check |
error | place to store error (if any). | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the `fstype` file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_features ()

    const BDFSFeatures *
    bd_fs_features (const gchar *fstype,
                    GError **error);

Returns (transfer-none): features supported by `fstype` , see `BDFSFeatures` for more information.

Tech category: always available

#### Parameters

fstype | name of the filesystem to get features for (e.g. "ext4") |
error | (out): place to store error (if any). | [allow-none]

### bd_fs_features_copy ()

    BDFSFeatures *
    bd_fs_features_copy (BDFSFeatures *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSFeatures` to copy. | [allow-none]

### bd_fs_features_free ()

    void
    bd_fs_features_free (BDFSFeatures *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSFeatures` to free. | [allow-none]

### bd_fs_can_mkfs ()

    gboolean
    bd_fs_can_mkfs (const gchar *type,
                    BDFSMkfsOptionsFlags *options,
                    gchar **required_utility,
                    GError **error);

Searches for the required utility to create the given filesystem and returns whether it is installed. The options flags indicate what additional options can be specified for `type` . Unknown filesystems result in errors.

#### Parameters

type | the filesystem type to be tested for installed mkfs support |
options | flags for allowed mkfs options (i.e. support for setting label or UUID when creating the filesystem). | [out]
required_utility | the utility binary which is required for creating (if missing returns `FALSE` but no `error` ). | [out][transfer full]
error | place to store error (if any). | [out][optional]

#### Returns

whether filesystem mkfs tool is available

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_QUERY`

### bd_fs_mkfs ()

    gboolean
    bd_fs_mkfs (const gchar *device,
                const gchar *fstype,
                BDFSMkfsOptions *options,
                const BDExtraArg **extra,
                GError **error);

This is a helper function for creating filesystems with extra options. This is the same as running a filesystem-specific function like `bd_fs_ext4_mkfs` and manually specifying the extra command line options. `BDFSMkfsOptions` removes the need to specify supported options for selected filesystems, make sure to check whether `fstype` supports these options (see `bd_fs_can_mkfs`) for details.

When specifying additional mkfs options using `extra` , it's caller's responsibility to make sure these options do not conflict with options specified using `options` . Extra options are added after the `options` and there are no additional checks for duplicate and/or conflicting options.

#### Parameters

device | the device to create the new filesystem on |
fstype | name of the filesystem to create (e.g. "ext4") |
options | additional options like label or UUID for the filesystem |
extra | extra mkfs options not provided in `options` . | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether `fstype` was successfully created on `device` or not.

Tech category: `BD_FS_TECH_GENERIC`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_mkfs_options_copy ()

    BDFSMkfsOptions *
    bd_fs_mkfs_options_copy (BDFSMkfsOptions *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSMkfsOptions` to copy. | [nullable]

### bd_fs_mkfs_options_free ()

    void
    bd_fs_mkfs_options_free (BDFSMkfsOptions *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSMkfsOptions` to free. | [nullable]

### bd_fs_supported_filesystems ()

    const gchar **
    bd_fs_supported_filesystems (GError **error);

#### Parameters

error | currently unused. | [out][optional]

#### Returns

list of filesystems supported by this plugin

Note: This returns filesystems supported by libblockdev, but not necessarily by the systems this is running on, for this information you need to run one of the `bd_fs_can_` functions.

Tech category: always available.

[transfer container][array zero-terminated=1]

### bd_fs_ext2_check ()

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

#### Parameters

device | the device the file system on which to check |
extra | extra options for the check (right now passed to the 'e2fsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_ext2_get_info ()

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

#### Parameters

device | the device the file system of which to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_ext2_info_copy ()

    BDFSExt2Info *
    bd_fs_ext2_info_copy (BDFSExt2Info *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSExt2Info` to copy. | [nullable]

### bd_fs_ext2_info_free ()

    void
    bd_fs_ext2_info_free (BDFSExt2Info *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSExt2Info` to free. | [nullable]

### bd_fs_ext2_mkfs ()

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

#### Parameters

device | the device to create a new ext2 fs on |
extra | extra options for the creation (right now passed to the 'mke2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_ext2_repair ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext2_resize ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ext2_set_label ()

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

#### Parameters

device | the device the file system on which to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext2_check_label ()

    gboolean
    bd_fs_ext2_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the ext2 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext2_set_uuid ()

    gboolean
    bd_fs_ext2_set_uuid (const gchar *device,
                         const gchar *uuid,
                         GError **error);

#### Parameters

device | the device the file system on which to set UUID for |
uuid | UUID to set `NULL` to generate a new one UUID can also be one of "clear", "random" and "time" to clear, generate a new random/time-based UUID. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_ext2_check_uuid ()

    gboolean
    bd_fs_ext2_check_uuid (const gchar *uuid,
                           GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the ext2 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext2_get_min_size ()

    guint64
    bd_fs_ext2_get_min_size (const gchar *device,
                             GError **error);

#### Parameters

device | the device containing the file system to get min size for |
error | place to store error (if any). | [out][optional]

#### Returns

smallest shrunken filesystem size as reported by resize2fs in case of error 0 is returned and `error` is set

Tech category: `BD_FS_TECH_EXT2`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ext3_check ()

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

#### Parameters

device | the device the file system on which to check |
extra | extra options for the check (right now passed to the 'e2fsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_ext3_get_info ()

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

#### Parameters

device | the device the file system of which to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_ext3_info_copy ()

    BDFSExt3Info *
    bd_fs_ext3_info_copy (BDFSExt3Info *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSExt3Info` to copy. | [nullable]

### bd_fs_ext3_info_free ()

    void
    bd_fs_ext3_info_free (BDFSExt3Info *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSExt3Info` to free. | [nullable]

### bd_fs_ext3_mkfs ()

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

#### Parameters

device | the device to create a new ext3 fs on |
extra | extra options for the creation (right now passed to the 'mke2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_ext3_repair ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext3_resize ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ext3_set_label ()

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

#### Parameters

device | the device the file system on which to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext3_check_label ()

    gboolean
    bd_fs_ext3_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error (if any). | [out][optional]

#### Returns

whether `label` is a valid label for the ext3 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext3_set_uuid ()

    gboolean
    bd_fs_ext3_set_uuid (const gchar *device,
                         const gchar *uuid,
                         GError **error);

#### Parameters

device | the device the file system on which to set UUID for |
uuid | UUID to set `NULL` to generate a new one UUID can also be one of "clear", "random" and "time" to clear, generate a new random/time-based UUID. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_ext3_check_uuid ()

    gboolean
    bd_fs_ext3_check_uuid (const gchar *uuid,
                           GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the ext3 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext3_get_min_size ()

    guint64
    bd_fs_ext3_get_min_size (const gchar *device,
                             GError **error);

#### Parameters

device | the device containing the file system to get min size for |
error | place to store error (if any). | [out][optional]

#### Returns

smallest shrunken filesystem size as reported by resize2fs in case of error 0 is returned and `error` is set

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ext4_check ()

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

#### Parameters

device | the device the file system on which to check |
extra | extra options for the check (right now passed to the 'e2fsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT4`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_ext4_get_info ()

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

#### Parameters

device | the device the file system of which to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_EXT3`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_ext4_info_copy ()

    BDFSExt4Info *
    bd_fs_ext4_info_copy (BDFSExt4Info *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSExt4Info` to copy. | [nullable]

### bd_fs_ext4_info_free ()

    void
    bd_fs_ext4_info_free (BDFSExt4Info *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSExt4Info` to free. | [nullable]

### bd_fs_ext4_mkfs ()

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

#### Parameters

device | the device to create a new ext4 fs on |
extra | extra options for the creation (right now passed to the 'mkfs.ext4' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT4`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_ext4_repair ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext4_resize ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_EXT4`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ext4_set_label ()

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

#### Parameters

device | the device the file system on which to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### 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`

### bd_fs_ext4_check_label ()

    gboolean
    bd_fs_ext4_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error (if any). | [out][optional]

#### Returns

whether `label` is a valid label for the ext4 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext4_set_uuid ()

    gboolean
    bd_fs_ext4_set_uuid (const gchar *device,
                         const gchar *uuid,
                         GError **error);

#### Parameters

device | the device the file system on which to set UUID for |
uuid | UUID to set `NULL` to generate a new one UUID can also be one of "clear", "random" and "time" to clear, generate a new random/time-based UUID. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXT4`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_ext4_check_uuid ()

    gboolean
    bd_fs_ext4_check_uuid (const gchar *uuid,
                           GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the ext4 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ext4_get_min_size ()

    guint64
    bd_fs_ext4_get_min_size (const gchar *device,
                             GError **error);

#### Parameters

device | the device containing the file system to get min size for |
error | place to store error (if any). | [out][optional]

#### Returns

smallest shrunken filesystem size as reported by resize2fs in case of error 0 is returned and `error` is set

Tech category: `BD_FS_TECH_EXT4`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_xfs_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the repair (right now passed to the 'xfs_repair' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether an xfs file system on the `device` is clean or not

Note: If the file system is mounted RW, it will always be reported as not clean!

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_xfs_get_info ()

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

#### Parameters

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][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_xfs_info_copy ()

    BDFSXfsInfo *
    bd_fs_xfs_info_copy (BDFSXfsInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSXfsInfo` to copy. | [nullable]

### bd_fs_xfs_info_free ()

    void
    bd_fs_xfs_info_free (BDFSXfsInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSXfsInfo` to free. | [nullable]

### bd_fs_xfs_mkfs ()

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

#### Parameters

device | the device to create a new xfs fs on |
extra | extra options for the creation (right now passed to the 'mkfs.xfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_xfs_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'xfs_repair' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_xfs_resize ()

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

#### Parameters

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). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_xfs_set_label ()

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

#### Parameters

device | the device containing the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_xfs_check_label ()

    gboolean
    bd_fs_xfs_check_label (const gchar *label,
                           GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the xfs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_xfs_set_uuid ()

    gboolean
    bd_fs_xfs_set_uuid (const gchar *device,
                        const gchar *uuid,
                        GError **error);

#### Parameters

device | the device containing the file system to set uuid for |
uuid | UUID to set `NULL` to generate a new one UUID can also be one of "nil" and "generate" to clear or generate a new UUID. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_XFS`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_xfs_check_uuid ()

    gboolean
    bd_fs_xfs_check_uuid (const gchar *uuid,
                          GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the xfs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_vfat_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the repair (right now passed to the 'fsck.vfat' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_vfat_get_info ()

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

#### Parameters

device | the device containing the file system to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_vfat_info_copy ()

    BDFSVfatInfo *
    bd_fs_vfat_info_copy (BDFSVfatInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSVfatInfo` to copy. | [nullable]

### bd_fs_vfat_info_free ()

    void
    bd_fs_vfat_info_free (BDFSVfatInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSVfatInfo` to free. | [nullable]

### bd_fs_vfat_mkfs ()

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

Please remember that FAT labels should always be uppercase.

#### Parameters

device | the device to create a new vfat fs on |
extra | extra options for the creation (right now passed to the 'mkfs.vfat' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_vfat_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'fsck.vfat' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_vfat_resize ()

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

#### Parameters

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][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_vfat_set_label ()

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

#### Parameters

device | the device containing the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_vfat_check_label ()

    gboolean
    bd_fs_vfat_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the vfat file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_vfat_set_uuid ()

    gboolean
    bd_fs_vfat_set_uuid (const gchar *device,
                         const gchar *uuid,
                         GError **error);

#### Parameters

device | the device containing the file system to set uuid for |
uuid | volume ID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the volume ID of vfat file system on the `device` was successfully set or not

Tech category: `BD_FS_TECH_VFAT`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_vfat_check_uuid ()

    gboolean
    bd_fs_vfat_check_uuid (const gchar *uuid,
                           GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the vfat file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_is_tech_avail ()

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

#### Parameters

tech | the queried tech |
mode | a bit mask of queried modes of operation (BDFSTechMode) for `tech` |
error | place to store error (details about why the `tech` -`mode` combination is not available). | [out][optional]

#### Returns

whether the `tech` -`mode` combination is available -- supported by the plugin implementation and having all the runtime dependencies available

### bd_fs_ntfs_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the repair (right now passed to the 'ntfsfix' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether an ntfs file system on the `device` is clean or not

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_ntfs_get_info ()

    BDFSNtfsInfo *
    bd_fs_ntfs_get_info (const gchar *device,
                         GError **error);

#### Parameters

device | the device containing the file system to get info for (device must not be mounted, trying to get info for a mounted device will result in an error) |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_ntfs_mkfs ()

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

#### Parameters

device | the device to create a new ntfs fs on |
extra | extra options for the creation (right now passed to the 'mkntfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new NTFS fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_ntfs_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'ntfsfix' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_ntfs_resize ()

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

#### Parameters

device | the device the file system of which to resize |
new_size | new requested size for the file system in bytes (if 0, the file system is adapted to the underlying block device) |
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_ntfs_set_label ()

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

#### Parameters

device | the device containing the file system to set the label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_ntfs_check_label ()

    gboolean
    bd_fs_ntfs_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the ntfs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ntfs_info_copy ()

    BDFSNtfsInfo *
    bd_fs_ntfs_info_copy (BDFSNtfsInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSNtfsInfo` to copy. | [nullable]

### bd_fs_ntfs_info_free ()

    void
    bd_fs_ntfs_info_free (BDFSNtfsInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSNtfsInfo` to free. | [nullable]

### bd_fs_ntfs_set_uuid ()

    gboolean
    bd_fs_ntfs_set_uuid (const gchar *device,
                         const gchar *uuid,
                         GError **error);

#### Parameters

device | the device containing the file system to set the UUID (serial number) for |
uuid | UUID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the UUID of the NTFS file system on the `device` was successfully set or not

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_ntfs_check_uuid ()

    gboolean
    bd_fs_ntfs_check_uuid (const gchar *uuid,
                           GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the ntfs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_ntfs_get_min_size ()

    guint64
    bd_fs_ntfs_get_min_size (const gchar *device,
                             GError **error);

#### Parameters

device | the device containing the file system to get min size for |
error | place to store error (if any). | [out][optional]

#### Returns

smallest shrunken filesystem size as reported by ntfsresize in case of error 0 is returned and `error` is set

Tech category: `BD_FS_TECH_NTFS`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_f2fs_info_copy ()

    BDFSF2FSInfo *
    bd_fs_f2fs_info_copy (BDFSF2FSInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSF2FSInfo` to copy. | [nullable]

### bd_fs_f2fs_info_free ()

    void
    bd_fs_f2fs_info_free (BDFSF2FSInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSF2FSInfo` to free. | [nullable]

### bd_fs_f2fs_mkfs ()

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

#### Parameters

device | the device to create a new f2fs fs on |
extra | extra options for the creation (right now passed to the 'mkfs.f2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new f2fs fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_F2FS`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_f2fs_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the repair (right now passed to the 'fsck.f2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether an f2fs file system on the `device` is clean or not

Tech category: `BD_FS_TECH_F2FS`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_f2fs_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'fsck.f2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_F2FS`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_f2fs_get_info ()

    BDFSF2FSInfo *
    bd_fs_f2fs_get_info (const gchar *device,
                         GError **error);

#### Parameters

device | the device containing the file system to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_F2FS`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_f2fs_resize ()

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

#### Parameters

device | the device containing the file system to resize |
new_size | new requested size for the file system *in file system sectors* (see `bd_fs_f2fs_get_info()`) (if 0, the file system is adapted to the underlying block device) |
safe | whether to perform safe resize or not (does not resize metadata) |
extra | extra options for the resize (right now passed to the 'resize.f2fs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_F2FS`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_f2fs_check_label ()

    gboolean
    bd_fs_f2fs_check_label (const gchar *label,
                            GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the f2fs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_nilfs2_get_info ()

    BDFSNILFS2Info *
    bd_fs_nilfs2_get_info (const gchar *device,
                           GError **error);

#### Parameters

device | the device containing the file system to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_NILFS2`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_nilfs2_info_copy ()

    BDFSNILFS2Info *
    bd_fs_nilfs2_info_copy (BDFSNILFS2Info *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSNILFS2Info` to copy. | [nullable]

### bd_fs_nilfs2_info_free ()

    void
    bd_fs_nilfs2_info_free (BDFSNILFS2Info *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSNILFS2Info` to free. | [nullable]

### bd_fs_nilfs2_mkfs ()

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

#### Parameters

device | the device to create a new nilfs fs on |
extra | extra options for the creation (right now passed to the 'mkfs.nilfs2' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new nilfs fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_NILFS2`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_nilfs2_resize ()

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

#### Parameters

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][optional]

#### Returns

whether the file system on `device` was successfully resized or not

Tech category: `BD_FS_TECH_NILFS2`-`BD_FS_TECH_MODE_RESIZE`

### bd_fs_nilfs2_set_label ()

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

#### Parameters

device | the device containing the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_NILFS2`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_nilfs2_check_label ()

    gboolean
    bd_fs_nilfs2_check_label (const gchar *label,
                              GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the nilfs2 file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_nilfs2_set_uuid ()

    gboolean
    bd_fs_nilfs2_set_uuid (const gchar *device,
                           const gchar *uuid,
                           GError **error);

#### Parameters

device | the device containing the file system to set UUID for |
uuid | UUID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the uuid of nilfs file system on the `device` was successfully set or not

Tech category: `BD_FS_TECH_NILFS2`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_nilfs2_check_uuid ()

    gboolean
    bd_fs_nilfs2_check_uuid (const gchar *uuid,
                             GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the nilfs file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_exfat_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the repair (right now passed to the 'exfatfsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the exfat file system on the `device` is clean or not

Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_exfat_get_info ()

    BDFSExfatInfo *
    bd_fs_exfat_get_info (const gchar *device,
                          GError **error);

#### Parameters

device | the device containing the file system to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_exfat_info_copy ()

    BDFSExfatInfo *
    bd_fs_exfat_info_copy (BDFSExfatInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSExfatInfo` to copy. | [nullable]

### bd_fs_exfat_info_free ()

    void
    bd_fs_exfat_info_free (BDFSExfatInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSExfatInfo` to free. | [nullable]

### bd_fs_exfat_mkfs ()

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

#### Parameters

device | the device to create a new exfat fs on |
extra | extra options for the creation (right now passed to the 'mkexfatfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new exfat fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_exfat_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'exfatfsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_exfat_set_label ()

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

#### Parameters

device | the device containing the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_exfat_check_label ()

    gboolean
    bd_fs_exfat_check_label (const gchar *label,
                             GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the exfat file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_exfat_set_uuid ()

    gboolean
    bd_fs_exfat_set_uuid (const gchar *device,
                          const gchar *uuid,
                          GError **error);

#### Parameters

device | the device containing the file system to set uuid for |
uuid | volume ID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the volume ID of exFAT file system on the `device` was successfully set or not

Tech category: `BD_FS_TECH_EXFAT`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_exfat_check_uuid ()

    gboolean
    bd_fs_exfat_check_uuid (const gchar *uuid,
                            GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the exFAT file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_btrfs_get_info ()

    BDFSBtrfsInfo *
    bd_fs_btrfs_get_info (const gchar *mpoint,
                          GError **error);

#### Parameters

mpoint | a mountpoint of the btrfs filesystem to get information about |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Note: This function WON'T WORK for multi device btrfs filesystems, for more complicated setups use the btrfs plugin instead.

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_btrfs_info_copy ()

    BDFSBtrfsInfo *
    bd_fs_btrfs_info_copy (BDFSBtrfsInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSBtrfsInfo` to copy. | [nullable]

### bd_fs_btrfs_info_free ()

    void
    bd_fs_btrfs_info_free (BDFSBtrfsInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSBtrfsInfo` to free. | [nullable]

### bd_fs_btrfs_mkfs ()

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

#### Parameters

device | the device to create a new btrfs fs on |
extra | extra options for the creation (right now passed to the 'mkfs.btrfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new btrfs fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_btrfs_check ()

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

#### Parameters

device | the device containing the file system to check |
extra | extra options for the check (right now passed to the 'btrfsck' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the filesystem was successfully checked or not

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_CHECK`

### bd_fs_btrfs_repair ()

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

#### Parameters

device | the device containing the file system to repair |
extra | extra options for the repair (right now passed to the 'btrfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the filesystem was successfully checked and repaired or not

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_REPAIR`

### bd_fs_btrfs_set_label ()

    gboolean
    bd_fs_btrfs_set_label (const gchar *mpoint,
                           const gchar *label,
                           GError **error);

#### Parameters

mpoint | the mount point of the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

whether the label of Btrfs file system on the `mpoint` was successfully set or not

Note: This function is intended to be used for btrfs filesystem on a single device, for more complicated setups use the btrfs plugin instead.

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_btrfs_check_label ()

    gboolean
    bd_fs_btrfs_check_label (const gchar *label,
                             GError **error);

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the Btrfs file system or not (reason is provided in `error` )

Note: This function is intended to be used for btrfs filesystem on a single device, for more complicated setups use the btrfs plugin instead.

Tech category: always available

### bd_fs_btrfs_set_uuid ()

    gboolean
    bd_fs_btrfs_set_uuid (const gchar *device,
                          const gchar *uuid,
                          GError **error);

#### Parameters

device | the device containing the file system to set the UUID (serial number) for |
uuid | UUID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the UUID of the Btrfs file system on the `device` was successfully set or not

Note: This function is intended to be used for btrfs filesystem on a single device, for more complicated setups use the btrfs plugin instead.

Tech category: `BD_FS_TECH_BTRFS`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_btrfs_check_uuid ()

    gboolean
    bd_fs_btrfs_check_uuid (const gchar *uuid,
                            GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the Btrfs file system or not (reason is provided in `error` )

Note: This function is intended to be used for btrfs filesystem on a single device, for more complicated setups use the btrfs plugin instead.

Tech category: always available

### bd_fs_btrfs_resize ()

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

#### Parameters

mpoint | a mountpoint of the to be resized btrfs filesystem |
new_size | requested new size |
extra | extra options for the volume resize (right now passed to the 'btrfs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether the `mpoint` filesystem was successfully resized to `new_size` or not

Note: This function WON'T WORK for multi device btrfs filesystems, for more complicated setups use the btrfs plugin instead.

Tech category: `BD_BTRFS_TECH_FS`-`BD_BTRFS_TECH_MODE_MODIFY`

### bd_fs_udf_get_info ()

    BDFSUdfInfo *
    bd_fs_udf_get_info (const gchar *device,
                        GError **error);

#### Parameters

device | the device containing the file system to get info for |
error | place to store error (if any). | [out][optional]

#### Returns

information about the file system on `device` or `NULL` in case of error

Tech category: `BD_FS_TECH_UDF`-`BD_FS_TECH_MODE_QUERY`.

[transfer full]

### bd_fs_udf_info_copy ()

    BDFSUdfInfo *
    bd_fs_udf_info_copy (BDFSUdfInfo *data);

Creates a new copy of `data` .

[skip]

#### Parameters

data | `BDFSUdfInfo` to copy. | [nullable]

### bd_fs_udf_info_free ()

    void
    bd_fs_udf_info_free (BDFSUdfInfo *data);

Frees `data` .

[skip]

#### Parameters

data | `BDFSUdfInfo` to free. | [nullable]

### bd_fs_udf_mkfs ()

    gboolean
    bd_fs_udf_mkfs (const gchar *device,
                    const gchar *media_type,
                    gchar *revision,
                    guint64 block_size,
                    const BDExtraArg **extra,
                    GError **error);

#### Parameters

device | the device to create a new UDF fs on |
media_type | specify the media type or `NULL` for default ('hd'). | [nullable]
revision | UDF revision to use or `NULL` for default ('2.01'). | [nullable]
block_size | block size in bytes or 0 for auto detection (device logical block size) |
extra | extra options for the creation (right now passed to the 'mkudffs' utility). | [nullable][array zero-terminated=1]
error | place to store error (if any). | [out][optional]

#### Returns

whether a new UDF fs was successfully created on `device` or not

Tech category: `BD_FS_TECH_UDF`-`BD_FS_TECH_MODE_MKFS`

### bd_fs_udf_set_label ()

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

Note: This sets both Volume Identifier and Logical Volume Identifier. Volume Identifier is truncated to 30 or 15 characters to accommodate to the different length limits of these labels.

#### Parameters

device | the device containing the file system to set label for |
label | label to set |
error | place to store error (if any). | [out][optional]

#### Returns

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

Tech category: `BD_FS_TECH_UDF`-`BD_FS_TECH_MODE_SET_LABEL`

### bd_fs_udf_check_label ()

    gboolean
    bd_fs_udf_check_label (const gchar *label,
                           GError **error);

Note: This checks only whether `label` adheres the length limits for Logical Volume Identifier, not the stricter limits for Volume Identifier.

#### Parameters

label | label to check |
error | place to store error. | [out][optional]

#### Returns

whether `label` is a valid label for the UDF file system or not (reason is provided in `error` )

Tech category: always available

### bd_fs_udf_set_uuid ()

    gboolean
    bd_fs_udf_set_uuid (const gchar *device,
                        const gchar *uuid,
                        GError **error);

#### Parameters

device | the device containing the file system to set the UUID (serial number) for |
uuid | UUID to set or `NULL` to generate a new one. | [nullable]
error | place to store error (if any). | [out][optional]

#### Returns

whether the UUID of the UDF file system on the `device` was successfully set or not

Tech category: `BD_FS_TECH_UDF`-`BD_FS_TECH_MODE_SET_UUID`

### bd_fs_udf_check_uuid ()

    gboolean
    bd_fs_udf_check_uuid (const gchar *uuid,
                          GError **error);

#### Parameters

uuid | UUID to check |
error | place to store error. | [out][optional]

#### Returns

whether `uuid` is a valid UUID for the UDF file system or not (reason is provided in `error` )

Tech category: always available

## Types and Values

### BDFSExt2Info

### BDFSExt3Info

### BDFSExt4Info

### enum BDFSError

#### Members

BD_FS_ERROR_TECH_UNAVAIL |  |
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_LABEL_INVALID |  |
BD_FS_ERROR_UUID_INVALID |  |
BD_FS_ERROR_UNKNOWN_FS |  |

### BD_FS_ERROR

    #define             BD_FS_ERROR

### enum BDFSConfigureFlags

#### Members

BD_FS_SUPPORT_SET_LABEL |  |
BD_FS_SUPPORT_SET_UUID |  |

### enum BDFSFeatureFlags

#### Members

BD_FS_FEATURE_OWNERS |  |
BD_FS_FEATURE_PARTITION_TABLE |  |

### BDFSFeatures

    typedef struct {
        BDFSResizeFlags resize;
        BDFSMkfsOptionsFlags mkfs;
        BDFSFsckFlags fsck;
        BDFSConfigureFlags configure;
        BDFSFeatureFlags features;
        const gchar *partition_id;
        const gchar *partition_type;
        guint64 min_size;
        guint64 max_size;
    } BDFSFeatures;

#### Members

BDFSResizeFlags `resize`; | supported resizes modes |
BDFSMkfsOptionsFlags `mkfs`; | supported options for mkfs |
BDFSFsckFlags `fsck`; | support for fsck operations (check and repair) |
BDFSConfigureFlags `configure`; | support for changing properties of an existing filesystem |
BDFSFeatureFlags `features`; | other supported features |
const gchar *`partition_id`; | partition ID used for this filesystem on MSDOS partitions |
const gchar *`partition_type`; | partition type/GUID used for this filesystem GPT partitions |
guint64 `min_size`; | minimum size when creating this filesystem |
guint64 `max_size`; | maximum size when creating this filesystem |

### enum BDFSFsckFlags

#### Members

BD_FS_FSCK_CHECK |  |
BD_FS_FSCK_REPAIR |  |

### BDFSMkfsOptions

    typedef struct {
        const gchar *label;
        const gchar *uuid;
        gboolean dry_run;
        gboolean no_discard;
        gboolean force;
        gboolean no_pt;
        guint8 reserve[32];
    } BDFSMkfsOptions;

#### Members

const gchar *`label`; | label of the filesystem |
const gchar *`uuid`; | uuid of the filesystem |
gboolean `dry_run`; | whether to run mkfs in dry run mode (no changes written to the device) |
gboolean `no_discard`; | whether to avoid discarding blocks at mkfs time |
gboolean `force`; | whether to run mkfs with the `--force` (or similar) option, the behaviour of this option depends on the filesystem, but in general it allows overwriting other preexisting formats detected on the device |
gboolean `no_pt`; | whether to disable (protective) partition table creation during mkfs |
guint8 `reserve`[32]; | reserve for future expansion |

### enum BDFSMkfsOptionsFlags

#### Members

BD_FS_MKFS_LABEL |  |
BD_FS_MKFS_UUID |  |
BD_FS_MKFS_DRY_RUN |  |
BD_FS_MKFS_NODISCARD |  |
BD_FS_MKFS_FORCE |  |
BD_FS_MKFS_NOPT |  |

### BDFSXfsInfo

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

#### Members

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 |

### BDFSVfatInfo

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

#### Members

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 |

### enum BDFSTech

#### Members

BD_FS_TECH_GENERIC |  |
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 |  |
BD_FS_TECH_F2FS |  |
BD_FS_TECH_NILFS2 |  |
BD_FS_TECH_EXFAT |  |
BD_FS_TECH_BTRFS |  |
BD_FS_TECH_UDF |  |

### enum BDFSTechMode

#### Members

BD_FS_TECH_MODE_MKFS |  |
BD_FS_TECH_MODE_WIPE |  |
BD_FS_TECH_MODE_CHECK |  |
BD_FS_TECH_MODE_REPAIR |  |
BD_FS_TECH_MODE_SET_LABEL |  |
BD_FS_TECH_MODE_QUERY |  |
BD_FS_TECH_MODE_RESIZE |  |
BD_FS_TECH_MODE_SET_UUID |  |

### enum BDFSResizeFlags

#### Members

BD_FS_OFFLINE_SHRINK |  |
BD_FS_OFFLINE_GROW |  |
BD_FS_ONLINE_SHRINK |  |
BD_FS_ONLINE_GROW |  |

### BDFSNtfsInfo

    typedef struct {
        gchar *label;
        gchar *uuid;
        guint64 size;
        guint64 free_space;
    } BDFSNtfsInfo;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
guint64 `size`; | size of the filesystem in bytes |
guint64 `free_space`; | number of free space in the filesystem in bytes |

### BDFSF2FSInfo

    typedef struct {
        gchar *label;
        gchar *uuid;
        guint64 sector_size;
        guint64 sector_count;
        guint64 features;
    } BDFSF2FSInfo;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
guint64 `sector_size`; | sector size used by the filesystem |
guint64 `sector_count`; | number of sectors in the filesystem |
guint64 `features`; | features enabled for this filesystem, see BDFSF2FSFeature |

### enum BDFSF2FSFeature

#### Members

BD_FS_F2FS_FEATURE_ENCRYPT |  |
BD_FS_F2FS_FEATURE_BLKZONED |  |
BD_FS_F2FS_FEATURE_ATOMIC_WRITE |  |
BD_FS_F2FS_FEATURE_EXTRA_ATTR |  |
BD_FS_F2FS_FEATURE_PRJQUOTA |  |
BD_FS_F2FS_FEATURE_INODE_CHKSUM |  |
BD_FS_F2FS_FEATURE_FLEXIBLE_INLINE_XATTR |  |
BD_FS_F2FS_FEATURE_QUOTA_INO |  |
BD_FS_F2FS_FEATURE_INODE_CRTIME |  |
BD_FS_F2FS_FEATURE_LOST_FOUND |  |
BD_FS_F2FS_FEATURE_VERITY |  |
BD_FS_F2FS_FEATURE_SB_CHKSUM |  |

### BDFSNILFS2Info

    typedef struct {
        gchar *label;
        gchar *uuid;
        guint64 size;
        guint64 block_size;
        guint64 free_blocks;
    } BDFSNILFS2Info;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
guint64 `size`; | size of the filesystem |
guint64 `block_size`; | block size used by the filesystem |
guint64 `free_blocks`; | number of free blocks in the filesystem |

### BDFSExfatInfo

    typedef struct {
        gchar *label;
        gchar *uuid;
        guint64 sector_size;
        guint64 sector_count;
        guint64 cluster_count;
    } BDFSExfatInfo;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
guint64 `sector_size`; | sector size used by the filesystem |
guint64 `sector_count`; | number of sectors in the filesystem |
guint64 `cluster_count`; | number of clusters in the filesystem |

### BDFSBtrfsInfo

    typedef struct {
        gchar *label;
        gchar *uuid;
        guint64 size;
        guint64 free_space;
    } BDFSBtrfsInfo;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
guint64 `size`; | size of the filesystem in bytes |
guint64 `free_space`; | free space on the filesystem in bytes |

### BDFSUdfInfo

    typedef struct {
        gchar *label;
        gchar *uuid;
        gchar *revision;
        gchar *lvid;
        gchar *vid;
        guint64 block_size;
        guint64 block_count;
        guint64 free_blocks;
    } BDFSUdfInfo;

#### Members

gchar *`label`; | label of the filesystem |
gchar *`uuid`; | uuid of the filesystem |
gchar *`revision`; | UDF revision |
gchar *`lvid`; | Logical Volume Identifier (most UDF implementations use this identifier as a disk label) |
gchar *`vid`; | Volume Identifier |
guint64 `block_size`; | block size used by the filesystem |
guint64 `block_count`; | number of blocks in the filesystem |
guint64 `free_blocks`; | number of free blocks in the filesystem |