GduDevicePrivate

typedef struct _GduDevicePrivate GduDevicePrivate;

GduDevice

typedef struct _GduDevice GduDevice;

gdu_device_get_object_path ()

const char *        gdu_device_get_object_path          (GduDevice *device);

gdu_device_find_parent ()

GduDevice *         gdu_device_find_parent              (GduDevice *device);

Finds a parent device for the given device. Note that this is only useful for presentation purposes; the device tree may be a lot more complex.

gdu_device_get_pool ()

GduPool *           gdu_device_get_pool                 (GduDevice *device);

gdu_device_get_dev ()

dev_t               gdu_device_get_dev                  (GduDevice *device);

gdu_device_get_detection_time ()

guint64             gdu_device_get_detection_time       (GduDevice *device);

gdu_device_get_media_detection_time ()

guint64             gdu_device_get_media_detection_time (GduDevice *device);

gdu_device_get_device_file ()

const char *        gdu_device_get_device_file          (GduDevice *device);

gdu_device_get_size ()

guint64             gdu_device_get_size                 (GduDevice *device);

gdu_device_get_block_size ()

guint64             gdu_device_get_block_size           (GduDevice *device);

gdu_device_is_removable ()

gboolean            gdu_device_is_removable             (GduDevice *device);

gdu_device_is_media_available ()

gboolean            gdu_device_is_media_available       (GduDevice *device);

gdu_device_is_media_change_detected ()

gboolean            gdu_device_is_media_change_detected (GduDevice *device);

gdu_device_is_media_change_detection_polling ()

gboolean            gdu_device_is_media_change_detection_polling
                                                        (GduDevice *device);

gdu_device_is_media_change_detection_inhibitable ()

gboolean            gdu_device_is_media_change_detection_inhibitable
                                                        (GduDevice *device);

gdu_device_is_media_change_detection_inhibited ()

gboolean            gdu_device_is_media_change_detection_inhibited
                                                        (GduDevice *device);

gdu_device_is_read_only ()

gboolean            gdu_device_is_read_only             (GduDevice *device);

gdu_device_is_system_internal ()

gboolean            gdu_device_is_system_internal       (GduDevice *device);

gdu_device_is_partition ()

gboolean            gdu_device_is_partition             (GduDevice *device);

gdu_device_is_partition_table ()

gboolean            gdu_device_is_partition_table       (GduDevice *device);

gdu_device_is_drive ()

gboolean            gdu_device_is_drive                 (GduDevice *device);

gdu_device_is_optical_disc ()

gboolean            gdu_device_is_optical_disc          (GduDevice *device);

gdu_device_is_luks ()

gboolean            gdu_device_is_luks                  (GduDevice *device);

gdu_device_is_luks_cleartext ()

gboolean            gdu_device_is_luks_cleartext        (GduDevice *device);

gdu_device_is_linux_md_component ()

gboolean            gdu_device_is_linux_md_component    (GduDevice *device);

gdu_device_is_linux_md ()

gboolean            gdu_device_is_linux_md              (GduDevice *device);

gdu_device_is_mounted ()

gboolean            gdu_device_is_mounted               (GduDevice *device);

gdu_device_get_mount_path ()

const char *        gdu_device_get_mount_path           (GduDevice *device);

gdu_device_get_mount_paths ()

char **             gdu_device_get_mount_paths          (GduDevice *device);

gdu_device_get_mounted_by_uid ()

uid_t               gdu_device_get_mounted_by_uid       (GduDevice *device);

gdu_device_get_presentation_hide ()

gboolean            gdu_device_get_presentation_hide    (GduDevice *device);

gdu_device_get_presentation_nopolicy ()

gboolean            gdu_device_get_presentation_nopolicy
                                                        (GduDevice *device);

gdu_device_get_presentation_name ()

const char *        gdu_device_get_presentation_name    (GduDevice *device);

gdu_device_get_presentation_icon_name ()

const char *        gdu_device_get_presentation_icon_name
                                                        (GduDevice *device);

gdu_device_job_in_progress ()

gboolean            gdu_device_job_in_progress          (GduDevice *device);

gdu_device_job_get_id ()

const char *        gdu_device_job_get_id               (GduDevice *device);

gdu_device_job_get_initiated_by_uid ()

uid_t               gdu_device_job_get_initiated_by_uid (GduDevice *device);

gdu_device_job_is_cancellable ()

gboolean            gdu_device_job_is_cancellable       (GduDevice *device);

gdu_device_job_get_percentage ()

double              gdu_device_job_get_percentage       (GduDevice *device);

gdu_device_id_get_usage ()

const char *        gdu_device_id_get_usage             (GduDevice *device);

gdu_device_id_get_type ()

const char *        gdu_device_id_get_type              (GduDevice *device);

gdu_device_id_get_version ()

const char *        gdu_device_id_get_version           (GduDevice *device);

gdu_device_id_get_label ()

const char *        gdu_device_id_get_label             (GduDevice *device);

gdu_device_id_get_uuid ()

const char *        gdu_device_id_get_uuid              (GduDevice *device);

gdu_device_partition_get_slave ()

const char *        gdu_device_partition_get_slave      (GduDevice *device);

gdu_device_partition_get_scheme ()

const char *        gdu_device_partition_get_scheme     (GduDevice *device);

gdu_device_partition_get_type ()

const char *        gdu_device_partition_get_type       (GduDevice *device);

gdu_device_partition_get_label ()

const char *        gdu_device_partition_get_label      (GduDevice *device);

gdu_device_partition_get_uuid ()

const char *        gdu_device_partition_get_uuid       (GduDevice *device);

gdu_device_partition_get_flags ()

char **             gdu_device_partition_get_flags      (GduDevice *device);

gdu_device_partition_get_number ()

int                 gdu_device_partition_get_number     (GduDevice *device);

gdu_device_partition_get_offset ()

guint64             gdu_device_partition_get_offset     (GduDevice *device);

gdu_device_partition_get_size ()

guint64             gdu_device_partition_get_size       (GduDevice *device);

gdu_device_partition_table_get_scheme ()

const char *        gdu_device_partition_table_get_scheme
                                                        (GduDevice *device);

gdu_device_partition_table_get_count ()

int                 gdu_device_partition_table_get_count
                                                        (GduDevice *device);

gdu_device_luks_get_holder ()

const char *        gdu_device_luks_get_holder          (GduDevice *device);

gdu_device_luks_cleartext_get_slave ()

const char *        gdu_device_luks_cleartext_get_slave (GduDevice *device);

gdu_device_luks_cleartext_unlocked_by_uid ()

uid_t               gdu_device_luks_cleartext_unlocked_by_uid
                                                        (GduDevice *device);

gdu_device_drive_get_vendor ()

const char *        gdu_device_drive_get_vendor         (GduDevice *device);

gdu_device_drive_get_model ()

const char *        gdu_device_drive_get_model          (GduDevice *device);

gdu_device_drive_get_revision ()

const char *        gdu_device_drive_get_revision       (GduDevice *device);

gdu_device_drive_get_serial ()

const char *        gdu_device_drive_get_serial         (GduDevice *device);

gdu_device_drive_get_connection_interface ()

const char *        gdu_device_drive_get_connection_interface
                                                        (GduDevice *device);

gdu_device_drive_get_connection_speed ()

guint64             gdu_device_drive_get_connection_speed
                                                        (GduDevice *device);

gdu_device_drive_get_media_compatibility ()

char **             gdu_device_drive_get_media_compatibility
                                                        (GduDevice *device);

gdu_device_drive_get_media ()

const char *        gdu_device_drive_get_media          (GduDevice *device);

gdu_device_drive_get_is_media_ejectable ()

gboolean            gdu_device_drive_get_is_media_ejectable
                                                        (GduDevice *device);

gdu_device_drive_get_requires_eject ()

gboolean            gdu_device_drive_get_requires_eject (GduDevice *device);

gdu_device_drive_get_can_detach ()

gboolean            gdu_device_drive_get_can_detach     (GduDevice *device);

gdu_device_drive_get_can_spindown ()

gboolean            gdu_device_drive_get_can_spindown   (GduDevice *device);

gdu_device_drive_get_is_rotational ()

gboolean            gdu_device_drive_get_is_rotational  (GduDevice *device);

gdu_device_optical_disc_get_is_blank ()

gboolean            gdu_device_optical_disc_get_is_blank
                                                        (GduDevice *device);

gdu_device_optical_disc_get_is_appendable ()

gboolean            gdu_device_optical_disc_get_is_appendable
                                                        (GduDevice *device);

gdu_device_optical_disc_get_is_closed ()

gboolean            gdu_device_optical_disc_get_is_closed
                                                        (GduDevice *device);

gdu_device_optical_disc_get_num_tracks ()

guint               gdu_device_optical_disc_get_num_tracks
                                                        (GduDevice *device);

gdu_device_optical_disc_get_num_audio_tracks ()

guint               gdu_device_optical_disc_get_num_audio_tracks
                                                        (GduDevice *device);

gdu_device_optical_disc_get_num_sessions ()

guint               gdu_device_optical_disc_get_num_sessions
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_level ()

const char *        gdu_device_linux_md_component_get_level
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_num_raid_devices ()

int                 gdu_device_linux_md_component_get_num_raid_devices
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_uuid ()

const char *        gdu_device_linux_md_component_get_uuid
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_home_host ()

const char *        gdu_device_linux_md_component_get_home_host
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_name ()

const char *        gdu_device_linux_md_component_get_name
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_version ()

const char *        gdu_device_linux_md_component_get_version
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_holder ()

const char *        gdu_device_linux_md_component_get_holder
                                                        (GduDevice *device);

gdu_device_linux_md_component_get_state ()

char **             gdu_device_linux_md_component_get_state
                                                        (GduDevice *device);

gdu_device_linux_md_get_state ()

const char *        gdu_device_linux_md_get_state       (GduDevice *device);

gdu_device_linux_md_get_level ()

const char *        gdu_device_linux_md_get_level       (GduDevice *device);

gdu_device_linux_md_get_num_raid_devices ()

int                 gdu_device_linux_md_get_num_raid_devices
                                                        (GduDevice *device);

gdu_device_linux_md_get_uuid ()

const char *        gdu_device_linux_md_get_uuid        (GduDevice *device);

gdu_device_linux_md_get_home_host ()

const char *        gdu_device_linux_md_get_home_host   (GduDevice *device);

gdu_device_linux_md_get_name ()

const char *        gdu_device_linux_md_get_name        (GduDevice *device);

gdu_device_linux_md_get_version ()

const char *        gdu_device_linux_md_get_version     (GduDevice *device);

gdu_device_linux_md_get_slaves ()

char **             gdu_device_linux_md_get_slaves      (GduDevice *device);

gdu_device_linux_md_is_degraded ()

gboolean            gdu_device_linux_md_is_degraded     (GduDevice *device);

gdu_device_linux_md_get_sync_action ()

const char *        gdu_device_linux_md_get_sync_action (GduDevice *device);

gdu_device_linux_md_get_sync_percentage ()

double              gdu_device_linux_md_get_sync_percentage
                                                        (GduDevice *device);

gdu_device_linux_md_get_sync_speed ()

guint64             gdu_device_linux_md_get_sync_speed  (GduDevice *device);

gdu_device_drive_ata_smart_get_is_available ()

gboolean            gdu_device_drive_ata_smart_get_is_available
                                                        (GduDevice *device);

gdu_device_drive_ata_smart_get_time_collected ()

guint64             gdu_device_drive_ata_smart_get_time_collected
                                                        (GduDevice *device);

gdu_device_drive_ata_smart_get_status ()

const gchar *       gdu_device_drive_ata_smart_get_status
                                                        (GduDevice *device);

gdu_device_drive_ata_smart_get_blob ()

gconstpointer       gdu_device_drive_ata_smart_get_blob (GduDevice *device,
                                                         gsize *out_size);

gdu_device_op_filesystem_mount ()

void                gdu_device_op_filesystem_mount      (GduDevice *device,
                                                         gchar **options,
                                                         GduDeviceFilesystemMountCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_filesystem_unmount ()

void                gdu_device_op_filesystem_unmount    (GduDevice *device,
                                                         GduDeviceFilesystemUnmountCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_filesystem_check ()

void                gdu_device_op_filesystem_check      (GduDevice *device,
                                                         GduDeviceFilesystemCheckCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_partition_delete ()

void                gdu_device_op_partition_delete      (GduDevice *device,
                                                         GduDevicePartitionDeleteCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_partition_modify ()

void                gdu_device_op_partition_modify      (GduDevice *device,
                                                         const char *type,
                                                         const char *label,
                                                         char **flags,
                                                         GduDevicePartitionModifyCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_partition_table_create ()

void                gdu_device_op_partition_table_create
                                                        (GduDevice *device,
                                                         const char *scheme,
                                                         GduDevicePartitionTableCreateCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_luks_unlock ()

void                gdu_device_op_luks_unlock           (GduDevice *device,
                                                         const char *secret,
                                                         GduDeviceLuksUnlockCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_luks_lock ()

void                gdu_device_op_luks_lock             (GduDevice *device,
                                                         GduDeviceLuksLockCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_luks_change_passphrase ()

void                gdu_device_op_luks_change_passphrase
                                                        (GduDevice *device,
                                                         const char *old_secret,
                                                         const char *new_secret,
                                                         GduDeviceLuksChangePassphraseCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_filesystem_set_label ()

void                gdu_device_op_filesystem_set_label  (GduDevice *device,
                                                         const char *new_label,
                                                         GduDeviceFilesystemSetLabelCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_drive_ata_smart_initiate_selftest ()

void                gdu_device_op_drive_ata_smart_initiate_selftest
                                                        (GduDevice *device,
                                                         const char *test,
                                                         GduDeviceDriveAtaSmartInitiateSelftestCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_drive_ata_smart_refresh_data ()

void                gdu_device_drive_ata_smart_refresh_data
                                                        (GduDevice *device,
                                                         GduDeviceDriveAtaSmartRefreshDataCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_linux_md_stop ()

void                gdu_device_op_linux_md_stop         (GduDevice *device,
                                                         GduDeviceLinuxMdStopCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_linux_md_check ()

void                gdu_device_op_linux_md_check        (GduDevice *device,
                                                         gchar **options,
                                                         GduDeviceLinuxMdCheckCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_linux_md_add_component ()

void                gdu_device_op_linux_md_add_component
                                                        (GduDevice *device,
                                                         const char *component_objpath,
                                                         GduDeviceLinuxMdAddComponentCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_linux_md_remove_component ()

void                gdu_device_op_linux_md_remove_component
                                                        (GduDevice *device,
                                                         const char *component_objpath,
                                                         GduDeviceLinuxMdRemoveComponentCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_filesystem_create ()

void                gdu_device_op_filesystem_create     (GduDevice *device,
                                                         const char *fstype,
                                                         const char *fslabel,
                                                         const char *encrypt_passphrase,
                                                         gboolean fs_take_ownership,
                                                         GduDeviceFilesystemCreateCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_partition_create ()

void                gdu_device_op_partition_create      (GduDevice *device,
                                                         guint64 offset,
                                                         guint64 size,
                                                         const char *type,
                                                         const char *label,
                                                         char **flags,
                                                         const char *fstype,
                                                         const char *fslabel,
                                                         const char *encrypt_passphrase,
                                                         gboolean fs_take_ownership,
                                                         GduDevicePartitionCreateCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_cancel_job ()

void                gdu_device_op_cancel_job            (GduDevice *device,
                                                         GduDeviceCancelJobCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_filesystem_list_open_files ()

void                gdu_device_filesystem_list_open_files
                                                        (GduDevice *device,
                                                         GduDeviceFilesystemListOpenFilesCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_filesystem_list_open_files_sync ()

GList *             gdu_device_filesystem_list_open_files_sync
                                                        (GduDevice *device,
                                                         GError **error);

gdu_device_op_drive_eject ()

void                gdu_device_op_drive_eject           (GduDevice *device,
                                                         GduDeviceDriveEjectCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_drive_detach ()

void                gdu_device_op_drive_detach          (GduDevice *device,
                                                         GduDeviceDriveDetachCompletedFunc callback,
                                                         gpointer user_data);

gdu_device_op_drive_poll_media ()

void                gdu_device_op_drive_poll_media      (GduDevice *device,
                                                         GduDeviceDrivePollMediaCompletedFunc callback,
                                                         gpointer user_data);

The "changed" signal

void                user_function                      (GduDevice *gdudevice,
                                                        gpointer   user_data)      : Run Last

The "job-changed" signal

void                user_function                      (GduDevice *gdudevice,
                                                        gpointer   user_data)      : Run Last

The "removed" signal

void                user_function                      (GduDevice *gdudevice,
                                                        gpointer   user_data)      : Run Last