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

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.

bd_fs_get_fstype ()

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

Get first signature on device as a string.

bd_fs_freeze ()

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

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

bd_fs_unfreeze ()

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

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

bd_fs_mount ()

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

bd_fs_unmount ()

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

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.

bd_fs_is_mountpoint ()

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

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

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.

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.

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

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

bd_fs_features_copy ()

BDFSFeatures *
bd_fs_features_copy (BDFSFeatures *data);

Creates a new copy of data .

[skip]

bd_fs_features_free ()

void
bd_fs_features_free (BDFSFeatures *data);

Frees data .

[skip]

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.

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.

bd_fs_mkfs_options_copy ()

BDFSMkfsOptions *
bd_fs_mkfs_options_copy (BDFSMkfsOptions *data);

Creates a new copy of data .

[skip]

bd_fs_mkfs_options_free ()

void
bd_fs_mkfs_options_free (BDFSMkfsOptions *data);

Frees data .

[skip]

bd_fs_supported_filesystems ()

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

bd_fs_ext2_check ()

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

bd_fs_ext2_get_info ()

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

bd_fs_ext2_info_copy ()

BDFSExt2Info *
bd_fs_ext2_info_copy (BDFSExt2Info *data);

Creates a new copy of data .

[skip]

bd_fs_ext2_info_free ()

void
bd_fs_ext2_info_free (BDFSExt2Info *data);

Frees data .

[skip]

bd_fs_ext2_mkfs ()

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

bd_fs_ext2_repair ()

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

bd_fs_ext2_resize ()

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

bd_fs_ext2_set_label ()

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

bd_fs_ext2_check_label ()

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

bd_fs_ext2_set_uuid ()

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

bd_fs_ext2_check_uuid ()

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

bd_fs_ext2_get_min_size ()

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

bd_fs_ext3_check ()

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

bd_fs_ext3_get_info ()

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

bd_fs_ext3_info_copy ()

BDFSExt3Info *
bd_fs_ext3_info_copy (BDFSExt3Info *data);

Creates a new copy of data .

[skip]

bd_fs_ext3_info_free ()

void
bd_fs_ext3_info_free (BDFSExt3Info *data);

Frees data .

[skip]

bd_fs_ext3_mkfs ()

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

bd_fs_ext3_repair ()

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

bd_fs_ext3_resize ()

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

bd_fs_ext3_set_label ()

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

bd_fs_ext3_check_label ()

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

bd_fs_ext3_set_uuid ()

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

bd_fs_ext3_check_uuid ()

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

bd_fs_ext3_get_min_size ()

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

bd_fs_ext4_check ()

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

bd_fs_ext4_get_info ()

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

bd_fs_ext4_info_copy ()

BDFSExt4Info *
bd_fs_ext4_info_copy (BDFSExt4Info *data);

Creates a new copy of data .

[skip]

bd_fs_ext4_info_free ()

void
bd_fs_ext4_info_free (BDFSExt4Info *data);

Frees data .

[skip]

bd_fs_ext4_mkfs ()

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

bd_fs_ext4_repair ()

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

bd_fs_ext4_resize ()

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

bd_fs_ext4_set_label ()

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

bd_fs_ext4_check_label ()

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

bd_fs_ext4_set_uuid ()

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

bd_fs_ext4_check_uuid ()

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

bd_fs_ext4_get_min_size ()

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

bd_fs_xfs_check ()

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

bd_fs_xfs_get_info ()

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

bd_fs_xfs_info_copy ()

BDFSXfsInfo *
bd_fs_xfs_info_copy (BDFSXfsInfo *data);

Creates a new copy of data .

[skip]

bd_fs_xfs_info_free ()

void
bd_fs_xfs_info_free (BDFSXfsInfo *data);

Frees data .

[skip]

bd_fs_xfs_mkfs ()

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

bd_fs_xfs_repair ()

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

bd_fs_xfs_resize ()

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

bd_fs_xfs_set_label ()

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

bd_fs_xfs_check_label ()

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

bd_fs_xfs_set_uuid ()

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

bd_fs_xfs_check_uuid ()

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

bd_fs_vfat_check ()

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

bd_fs_vfat_get_info ()

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

bd_fs_vfat_info_copy ()

BDFSVfatInfo *
bd_fs_vfat_info_copy (BDFSVfatInfo *data);

Creates a new copy of data .

[skip]

bd_fs_vfat_info_free ()

void
bd_fs_vfat_info_free (BDFSVfatInfo *data);

Frees data .

[skip]

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.

bd_fs_vfat_repair ()

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

bd_fs_vfat_resize ()

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

bd_fs_vfat_set_label ()

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

bd_fs_vfat_check_label ()

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

bd_fs_vfat_set_uuid ()

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

bd_fs_vfat_check_uuid ()

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

bd_fs_is_tech_avail ()

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

bd_fs_ntfs_check ()

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

bd_fs_ntfs_get_info ()

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

bd_fs_ntfs_mkfs ()

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

bd_fs_ntfs_repair ()

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

bd_fs_ntfs_resize ()

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

bd_fs_ntfs_set_label ()

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

bd_fs_ntfs_check_label ()

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

bd_fs_ntfs_info_copy ()

BDFSNtfsInfo *
bd_fs_ntfs_info_copy (BDFSNtfsInfo *data);

Creates a new copy of data .

[skip]

bd_fs_ntfs_info_free ()

void
bd_fs_ntfs_info_free (BDFSNtfsInfo *data);

Frees data .

[skip]

bd_fs_ntfs_set_uuid ()

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

bd_fs_ntfs_check_uuid ()

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

bd_fs_ntfs_get_min_size ()

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

bd_fs_f2fs_info_copy ()

BDFSF2FSInfo *
bd_fs_f2fs_info_copy (BDFSF2FSInfo *data);

Creates a new copy of data .

[skip]

bd_fs_f2fs_info_free ()

void
bd_fs_f2fs_info_free (BDFSF2FSInfo *data);

Frees data .

[skip]

bd_fs_f2fs_mkfs ()

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

bd_fs_f2fs_check ()

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

bd_fs_f2fs_repair ()

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

bd_fs_f2fs_get_info ()

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

bd_fs_f2fs_resize ()

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

bd_fs_f2fs_check_label ()

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

bd_fs_nilfs2_get_info ()

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

bd_fs_nilfs2_info_copy ()

BDFSNILFS2Info *
bd_fs_nilfs2_info_copy (BDFSNILFS2Info *data);

Creates a new copy of data .

[skip]