<title>Linux-specific types</title>
<xi:include href="xml/udiskslinuxmanager.xml"/>
<xi:include href="xml/udiskslinuxprovider.xml"/>
+ <xi:include href="xml/udiskslinuxdevice.xml"/>
</chapter>
<chapter id="ref-daemon-drives">
<title>Drives on Linux</title>
</SECTION>
<SECTION>
+<FILE>udiskslinuxdevice</FILE>
+<TITLE>UDisksLinuxDevice</TITLE>
+UDisksLinuxDevice
+udisks_linux_device_new_sync
+<SUBSECTION Standard>
+UDISKS_TYPE_LINUX_DEVICE
+UDISKS_LINUX_DEVICE
+UDISKS_IS_LINUX_DEVICE
+<SUBSECTION Private>
+udisks_linux_device_get_type
+</SECTION>
+
+<SECTION>
<FILE>udisksdaemonutil</FILE>
udisks_decode_udev_string
udisks_safe_append_to_object_path
udisks_partition_type_info_flags_get_type
udisks_daemon_get_type
+udisks_linux_device_get_type
udisks_linux_block_object_get_type
udisks_linux_block_get_type
udisks_linux_drive_object_get_type
udisksfstabmonitor.h udisksfstabmonitor.c \
udiskscrypttabentry.h udiskscrypttabentry.c \
udiskscrypttabmonitor.h udiskscrypttabmonitor.c \
+ udiskslinuxdevice.h udiskslinuxdevice.c \
udisksata.h udisksata.c \
$(BUILT_SOURCES) \
$(NULL)
#include "udiskscrypttabmonitor.h"
#include "udiskscrypttabentry.h"
#include "udiskslinuxblockobject.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udisksdaemon
for (l = objects; l != NULL; l = l->next)
{
UDisksObject *object = UDISKS_OBJECT (l->data);
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (object))
continue;
if (device == NULL)
continue;
- if (g_strcmp0 (g_udev_device_get_sysfs_path (device), sysfs_path) == 0)
+ if (g_strcmp0 (g_udev_device_get_sysfs_path (device->udev_device), sysfs_path) == 0)
{
g_object_unref (device);
ret = g_object_ref (object);
UDISKS_ATA_COMMAND_PROTOCOL_HOST_TO_DRIVE
} UDisksAtaCommandProtocol;
+struct _UDisksLinuxDevice;
+typedef struct _UDisksLinuxDevice UDisksLinuxDevice;
+
#endif /* __UDISKS_DAEMON_TYPES_H__ */
#include "udiskssimplejob.h"
#include "udiskslinuxdriveata.h"
#include "udiskslinuxmdraidobject.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxblock
for (l = objects; l != NULL; l = l->next)
{
GDBusObjectSkeleton *object = G_DBUS_OBJECT_SKELETON (l->data);
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (object))
continue;
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (object));
- if (g_strcmp0 (sysfs_path, g_udev_device_get_sysfs_path (device)) == 0)
+ if (g_strcmp0 (sysfs_path, g_udev_device_get_sysfs_path (device->udev_device)) == 0)
{
ret = g_strdup (g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
g_object_unref (device);
drive_devices = udisks_linux_drive_object_get_devices (UDISKS_LINUX_DRIVE_OBJECT (object));
for (j = drive_devices; j != NULL; j = j->next)
{
- GUdevDevice *drive_device = G_UDEV_DEVICE (j->data);
+ UDisksLinuxDevice *drive_device = UDISKS_LINUX_DEVICE (j->data);
const gchar *drive_sysfs_path;
- drive_sysfs_path = g_udev_device_get_sysfs_path (drive_device);
+ drive_sysfs_path = g_udev_device_get_sysfs_path (drive_device->udev_device);
if (g_strcmp0 (whole_disk_block_device_sysfs_path, drive_sysfs_path) == 0)
{
if (out_drive != NULL)
static void
update_mdraid (UDisksLinuxBlock *block,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
UDisksDrive *drive,
GDBusObjectManagerServer *object_manager)
{
const gchar *objpath_mdraid_member = "/";
UDisksLinuxMDRaidObject *object = NULL;
- uuid = g_udev_device_get_property (device, "MD_UUID");
+ uuid = g_udev_device_get_property (device->udev_device, "MD_UUID");
if (uuid != NULL && strlen (uuid) > 0)
{
object = find_mdraid (object_manager, uuid);
}
}
- uuid = g_udev_device_get_property (device, "MD_MEMBER_UUID");
+ uuid = g_udev_device_get_property (device->udev_device, "MD_MEMBER_UUID");
if (uuid != NULL && strlen (uuid) > 0)
{
object = find_mdraid (object_manager, uuid);
static void
update_hints (UDisksLinuxBlock *block,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
UDisksDrive *drive)
{
UDisksBlock *iface = UDISKS_BLOCK (block);
hint_name = NULL;
hint_icon_name = NULL;
- device_file = g_udev_device_get_device_file (device);
+ device_file = g_udev_device_get_device_file (device->udev_device);
/* Provide easy access to _only_ the following devices
*
}
/* CD-ROM media / drives are not partitionable, at least not here on Linux */
- if (g_udev_device_get_property_as_boolean (device, "ID_CDROM"))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, "ID_CDROM"))
hint_partitionable = FALSE;
/* device-mapper devices are not partitionable (TODO: for multipath, they are via kpartx(8) hacks) */
- if (g_str_has_prefix (g_udev_device_get_name (device), "dm-"))
+ if (g_str_has_prefix (g_udev_device_get_name (device->udev_device), "dm-"))
hint_partitionable = FALSE;
/* TODO: set ignore to TRUE for physical paths belonging to a drive with multiple paths */
/* override from udev properties */
- if (g_udev_device_has_property (device, "UDISKS_SYSTEM"))
- hint_system = g_udev_device_get_property_as_boolean (device, "UDISKS_SYSTEM");
- if (g_udev_device_has_property (device, "UDISKS_IGNORE"))
- hint_ignore = g_udev_device_get_property_as_boolean (device, "UDISKS_IGNORE");
- if (g_udev_device_has_property (device, "UDISKS_AUTO"))
- hint_auto = g_udev_device_get_property_as_boolean (device, "UDISKS_AUTO");
- if (g_udev_device_has_property (device, "UDISKS_NAME"))
- hint_name = g_udev_device_get_property (device, "UDISKS_NAME");
- if (g_udev_device_has_property (device, "UDISKS_ICON_NAME"))
- hint_icon_name = g_udev_device_get_property (device, "UDISKS_ICON_NAME");
+ if (g_udev_device_has_property (device->udev_device, "UDISKS_SYSTEM"))
+ hint_system = g_udev_device_get_property_as_boolean (device->udev_device, "UDISKS_SYSTEM");
+ if (g_udev_device_has_property (device->udev_device, "UDISKS_IGNORE"))
+ hint_ignore = g_udev_device_get_property_as_boolean (device->udev_device, "UDISKS_IGNORE");
+ if (g_udev_device_has_property (device->udev_device, "UDISKS_AUTO"))
+ hint_auto = g_udev_device_get_property_as_boolean (device->udev_device, "UDISKS_AUTO");
+ if (g_udev_device_has_property (device->udev_device, "UDISKS_NAME"))
+ hint_name = g_udev_device_get_property (device->udev_device, "UDISKS_NAME");
+ if (g_udev_device_has_property (device->udev_device, "UDISKS_ICON_NAME"))
+ hint_icon_name = g_udev_device_get_property (device->udev_device, "UDISKS_ICON_NAME");
/* ... and scene! */
udisks_block_set_hint_partitionable (iface, hint_partitionable);
UDisksBlock *iface = UDISKS_BLOCK (block);
UDisksDaemon *daemon;
GDBusObjectManagerServer *object_manager;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
GUdevDeviceNumber dev;
gchar *drive_object_path;
UDisksDrive *drive;
daemon = udisks_linux_block_object_get_daemon (object);
object_manager = udisks_daemon_get_object_manager (daemon);
- dev = g_udev_device_get_device_number (device);
- device_file = g_udev_device_get_device_file (device);
- symlinks = g_udev_device_get_device_file_symlinks (device);
+ dev = g_udev_device_get_device_number (device->udev_device);
+ device_file = g_udev_device_get_device_file (device->udev_device);
+ symlinks = g_udev_device_get_device_file_symlinks (device->udev_device);
udisks_block_set_device (iface, device_file);
udisks_block_set_symlinks (iface, symlinks);
udisks_block_set_device_number (iface, dev);
- size = udisks_daemon_util_block_get_size (device,
+ size = udisks_daemon_util_block_get_size (device->udev_device,
&media_available,
&media_change_detected);
udisks_block_set_size (iface, size);
- read_only = g_udev_device_get_sysfs_attr_as_boolean (device, "ro");
- if (!read_only && g_str_has_prefix (g_udev_device_get_name (device), "sr"))
+ read_only = g_udev_device_get_sysfs_attr_as_boolean (device->udev_device, "ro");
+ if (!read_only && g_str_has_prefix (g_udev_device_get_name (device->udev_device), "sr"))
read_only = TRUE;
udisks_block_set_read_only (iface, read_only);
* in user-space and wants you to use libdevmapper to obtain it...
*/
udisks_block_set_crypto_backing_device (iface, "/");
- if (g_str_has_prefix (g_udev_device_get_name (device), "dm-"))
+ if (g_str_has_prefix (g_udev_device_get_name (device->udev_device), "dm-"))
{
gchar *dm_uuid;
- dm_uuid = get_sysfs_attr (device, "dm/uuid");
+ dm_uuid = get_sysfs_attr (device->udev_device, "dm/uuid");
if (dm_uuid != NULL && g_str_has_prefix (dm_uuid, "CRYPT-LUKS1"))
{
gchar **slaves;
- slaves = udisks_daemon_util_resolve_links (g_udev_device_get_sysfs_path (device),
+ slaves = udisks_daemon_util_resolve_links (g_udev_device_get_sysfs_path (device->udev_device),
"slaves");
if (g_strv_length (slaves) == 1)
{
gchar *dm_name_dev_file = NULL;
const gchar *dm_name_dev_file_as_symlink = NULL;
- dm_name = g_udev_device_get_property (device, "DM_NAME");
+ dm_name = g_udev_device_get_property (device->udev_device, "DM_NAME");
if (dm_name != NULL)
dm_name_dev_file = g_strdup_printf ("/dev/mapper/%s", dm_name);
for (n = 0; symlinks != NULL && symlinks[n] != NULL; n++)
{
const gchar *md_name;
- md_name = g_udev_device_get_property (device, "MD_NAME");
+ md_name = g_udev_device_get_property (device->udev_device, "MD_NAME");
if (md_name != NULL)
{
guint n;
}
/* fallback to the device name */
if (preferred_device_file == NULL)
- preferred_device_file = g_udev_device_get_device_file (device);
+ preferred_device_file = g_udev_device_get_device_file (device->udev_device);
udisks_block_set_preferred_device (iface, preferred_device_file);
/* Determine the drive this block device belongs to
* TODO: if this is slow we could have a cache or ensure that we
* only do this once or something else
*/
- drive_object_path = find_drive (object_manager, device, &drive);
+ drive_object_path = find_drive (object_manager, device->udev_device, &drive);
if (drive_object_path != NULL)
{
udisks_block_set_drive (iface, drive_object_path);
udisks_block_set_drive (iface, "/");
}
- udisks_block_set_id_usage (iface, g_udev_device_get_property (device, "ID_FS_USAGE"));
- udisks_block_set_id_type (iface, g_udev_device_get_property (device, "ID_FS_TYPE"));
- s = udisks_decode_udev_string (g_udev_device_get_property (device, "ID_FS_VERSION"));
+ udisks_block_set_id_usage (iface, g_udev_device_get_property (device->udev_device, "ID_FS_USAGE"));
+ udisks_block_set_id_type (iface, g_udev_device_get_property (device->udev_device, "ID_FS_TYPE"));
+ s = udisks_decode_udev_string (g_udev_device_get_property (device->udev_device, "ID_FS_VERSION"));
udisks_block_set_id_version (iface, s);
g_free (s);
- s = udisks_decode_udev_string (g_udev_device_get_property (device, "ID_FS_LABEL_ENC"));
+ s = udisks_decode_udev_string (g_udev_device_get_property (device->udev_device, "ID_FS_LABEL_ENC"));
udisks_block_set_id_label (iface, s);
g_free (s);
- s = udisks_decode_udev_string (g_udev_device_get_property (device, "ID_FS_UUID_ENC"));
+ s = udisks_decode_udev_string (g_udev_device_get_property (device->udev_device, "ID_FS_UUID_ENC"));
udisks_block_set_id_uuid (iface, s);
g_free (s);
UDisksObject *object;
UDisksObject *cleartext_object = NULL;
UDisksBlock *cleartext_block = NULL;
- GUdevDevice *udev_cleartext_device = NULL;
+ UDisksLinuxDevice *udev_cleartext_device = NULL;
UDisksBlock *block_to_mkfs = NULL;
UDisksObject *object_to_mkfs = NULL;
UDisksDaemon *daemon;
udisks_cleanup_add_unlocked_luks (cleanup,
udisks_block_get_device_number (cleartext_block),
udisks_block_get_device_number (block),
- g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
+ g_udev_device_get_sysfs_attr (udev_cleartext_device->udev_device, "dm/uuid"),
caller_uid);
object_to_mkfs = cleartext_object;
GVariant *options)
{
UDisksObject *object = NULL;
- GUdevDevice *udev_device = NULL;
+ UDisksLinuxDevice *device = NULL;
UDisksDaemon *daemon;
const gchar *action_id;
const gchar *message;
invocation))
goto out;
- udev_device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (object));
+ device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (object));
udisks_linux_block_object_trigger_uevent (UDISKS_LINUX_BLOCK_OBJECT (object));
- if (g_strcmp0 (g_udev_device_get_devtype (udev_device), "disk") == 0)
+ if (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0)
udisks_linux_block_object_reread_partition_table (UDISKS_LINUX_BLOCK_OBJECT (object));
udisks_block_complete_rescan (block, invocation);
out:
- g_clear_object (&udev_device);
+ g_clear_object (&device);
g_clear_object (&object);
return TRUE; /* returning true means that we handled the method invocation */
}
#include "udisksfstabentry.h"
#include "udiskscrypttabmonitor.h"
#include "udiskscrypttabentry.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxblockobject
UDisksDaemon *daemon;
UDisksMountMonitor *mount_monitor;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
/* interface */
UDisksBlock *iface_block_device;
/* compute the object path */
str = g_string_new ("/org/freedesktop/UDisks2/block_devices/");
- udisks_safe_append_to_object_path (str, g_udev_device_get_name (object->device));
+ udisks_safe_append_to_object_path (str, g_udev_device_get_name (object->device->udev_device));
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), str->str);
g_string_free (str, TRUE);
/**
* UDisksLinuxBlockObject:device:
*
- * The #GUdevDevice for the object. Connect to the #GObject::notify
+ * The #UDisksLinuxDevice for the object. Connect to the #GObject::notify
* signal to get notified whenever this is updated.
*/
g_object_class_install_property (gobject_class,
g_param_spec_object ("device",
"Device",
"The device for the object",
- G_UDEV_TYPE_DEVICE,
+ UDISKS_TYPE_LINUX_DEVICE,
G_PARAM_READABLE |
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY |
/**
* udisks_linux_block_object_new:
* @daemon: A #UDisksDaemon.
- * @device: The #GUdevDevice for the sysfs block device.
+ * @device: The #UDisksLinuxDevice for the device.
*
* Create a new block object.
*
* Returns: A #UDisksLinuxBlockObject object. Free with g_object_unref().
*/
UDisksLinuxBlockObject *
-udisks_linux_block_object_new (UDisksDaemon *daemon,
- GUdevDevice *device)
+udisks_linux_block_object_new (UDisksDaemon *daemon,
+ UDisksLinuxDevice *device)
{
g_return_val_if_fail (UDISKS_IS_DAEMON (daemon), NULL);
return UDISKS_LINUX_BLOCK_OBJECT (g_object_new (UDISKS_TYPE_LINUX_BLOCK_OBJECT,
* udisks_linux_block_object_get_device:
* @object: A #UDisksLinuxBlockObject.
*
- * Gets the current #GUdevDevice for @object. Connect to
+ * Gets the current #UDisksLinuxDevice for @object. Connect to
* #GObject::notify to track changes to the #UDisksLinuxBlockObject:device
* property.
*
- * Returns: A #GUdevDevice. Free with g_object_unref().
+ * Returns: A #UDisksLinuxDevice. Free with g_object_unref().
*/
-GUdevDevice *
+UDisksLinuxDevice *
udisks_linux_block_object_get_device (UDisksLinuxBlockObject *object)
{
g_return_val_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object), NULL);
gboolean ret = FALSE;
/* only consider whole disks, never partitions */
- if (g_strcmp0 (g_udev_device_get_devtype (object->device), "disk") != 0)
+ if (g_strcmp0 (g_udev_device_get_devtype (object->device->udev_device), "disk") != 0)
goto out;
/* if blkid(8) already identified the device as a partition table, it's all good */
- if (g_udev_device_has_property (object->device, "ID_PART_TABLE_TYPE"))
+ if (g_udev_device_has_property (object->device->udev_device, "ID_PART_TABLE_TYPE"))
{
/* however, if blkid(8) also think that we're a filesystem... then don't
* mark us as a partition table ... except if we are partitioned by the
* (see filesystem_check() for the similar case where we don't pretend
* to be a filesystem)
*/
- if (g_strcmp0 (g_udev_device_get_property (object->device, "ID_FS_USAGE"), "filesystem") == 0)
+ if (g_strcmp0 (g_udev_device_get_property (object->device->udev_device, "ID_FS_USAGE"), "filesystem") == 0)
{
- if (!disk_is_partitioned_by_kernel (object->device))
+ if (!disk_is_partitioned_by_kernel (object->device->udev_device))
{
goto out;
}
* children... then it must be partitioned by the kernel, hence it
* must contain a partition table.
*/
- if (disk_is_partitioned_by_kernel (object->device))
+ if (disk_is_partitioned_by_kernel (object->device->udev_device))
{
ret = TRUE;
goto out;
gboolean ret = FALSE;
/* could be partitioned by the kernel */
- if (g_strcmp0 (g_udev_device_get_devtype (object->device), "partition") == 0)
+ if (g_strcmp0 (g_udev_device_get_devtype (object->device->udev_device), "partition") == 0)
{
ret = TRUE;
goto out;
}
/* if blkid(8) already identified the device as a partition, it's all good */
- if (g_udev_device_has_property (object->device, "ID_PART_ENTRY_SCHEME"))
+ if (g_udev_device_has_property (object->device->udev_device, "ID_PART_ENTRY_SCHEME"))
{
ret = TRUE;
goto out;
* (see partition_table_check() above for the similar case where we don't pretend
* to be a partition table)
*/
- if (g_strcmp0 (g_udev_device_get_devtype (object->device), "disk") == 0 &&
- disk_is_partitioned_by_kernel (object->device))
+ if (g_strcmp0 (g_udev_device_get_devtype (object->device->udev_device), "disk") == 0 &&
+ disk_is_partitioned_by_kernel (object->device->udev_device))
{
detected_as_filesystem = FALSE;
}
if (drive_does_not_detect_media_change (object) ||
detected_as_filesystem ||
(udisks_mount_monitor_is_dev_in_use (object->mount_monitor,
- g_udev_device_get_device_number (object->device),
+ g_udev_device_get_device_number (object->device->udev_device),
&mount_type) &&
mount_type == UDISKS_MOUNT_TYPE_FILESYSTEM))
ret = TRUE;
if ((g_strcmp0 (udisks_block_get_id_usage (object->iface_block_device), "other") == 0 &&
g_strcmp0 (udisks_block_get_id_type (object->iface_block_device), "swap") == 0)
|| (udisks_mount_monitor_is_dev_in_use (object->mount_monitor,
- g_udev_device_get_device_number (object->device),
+ g_udev_device_get_device_number (object->device->udev_device),
&mount_type)
&& mount_type == UDISKS_MOUNT_TYPE_SWAP))
ret = TRUE;
gboolean ret;
ret = FALSE;
- if (g_str_has_prefix (g_udev_device_get_name (object->device), "loop") &&
- g_strcmp0 (g_udev_device_get_devtype (object->device), "disk") == 0)
+ if (g_str_has_prefix (g_udev_device_get_name (object->device->udev_device), "loop") &&
+ g_strcmp0 (g_udev_device_get_devtype (object->device->udev_device), "disk") == 0)
ret = TRUE;
return ret;
* udisks_linux_block_object_uevent:
* @object: A #UDisksLinuxBlockObject.
* @action: Uevent action or %NULL
- * @device: A new #GUdevDevice device object or %NULL if the device hasn't changed.
+ * @device: A new #UDisksLinuxDevice device object or %NULL if the device hasn't changed.
*
* Updates all information on interfaces on @object.
*/
void
udisks_linux_block_object_uevent (UDisksLinuxBlockObject *object,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
g_return_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object));
- g_return_if_fail (device == NULL || G_UDEV_IS_DEVICE (device));
+ g_return_if_fail (device == NULL || UDISKS_IS_LINUX_DEVICE (device));
if (device != NULL)
{
gpointer user_data)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (user_data);
- if (udisks_mount_get_dev (mount) == g_udev_device_get_device_number (object->device))
+ if (udisks_mount_get_dev (mount) == g_udev_device_get_device_number (object->device->udev_device))
udisks_linux_block_object_uevent (object, NULL, NULL);
}
gpointer user_data)
{
UDisksLinuxBlockObject *object = UDISKS_LINUX_BLOCK_OBJECT (user_data);
- if (udisks_mount_get_dev (mount) == g_udev_device_get_device_number (object->device))
+ if (udisks_mount_get_dev (mount) == g_udev_device_get_device_number (object->device->udev_device))
udisks_linux_block_object_uevent (object, NULL, NULL);
}
/* TODO: would be nice with a variant to wait until the request uevent has been received by ourselves */
- path = g_strconcat (g_udev_device_get_sysfs_path (object->device), "/uevent", NULL);
+ path = g_strconcat (g_udev_device_get_sysfs_path (object->device->udev_device), "/uevent", NULL);
fd = open (path, O_WRONLY);
if (fd < 0)
{
g_return_if_fail (UDISKS_IS_LINUX_BLOCK_OBJECT (object));
- device_file = g_udev_device_get_device_file (object->device);
+ device_file = g_udev_device_get_device_file (object->device->udev_device);
fd = open (device_file, O_RDONLY);
if (fd == -1)
{
GType udisks_linux_block_object_get_type (void) G_GNUC_CONST;
UDisksLinuxBlockObject *udisks_linux_block_object_new (UDisksDaemon *daemon,
- GUdevDevice *device);
+ UDisksLinuxDevice *device);
void udisks_linux_block_object_uevent (UDisksLinuxBlockObject *object,
const gchar *action,
- GUdevDevice *device);
+ UDisksLinuxDevice *device);
UDisksDaemon *udisks_linux_block_object_get_daemon (UDisksLinuxBlockObject *object);
-GUdevDevice *udisks_linux_block_object_get_device (UDisksLinuxBlockObject *object);
+UDisksLinuxDevice *udisks_linux_block_object_get_device (UDisksLinuxBlockObject *object);
void udisks_linux_block_object_trigger_uevent (UDisksLinuxBlockObject *object);
void udisks_linux_block_object_reread_partition_table (UDisksLinuxBlockObject *object);
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
+ *
+ * Copyright (C) 2008 David Zeuthen <zeuthen@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <linux/cdrom.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "udiskslinuxdevice.h"
+#include "udisksprivate.h"
+#include "udiskslogging.h"
+#include "udisksata.h"
+#include "udisksdaemonutil.h"
+
+/**
+ * SECTION:udiskslinuxdevice
+ * @title: UDisksLinuxDevice
+ * @short_description: Low-level devices on Linux
+ *
+ * Types and functions used to record information obtained from the
+ * udev database as well as by probing the device.
+ */
+
+
+typedef struct _UDisksLinuxDeviceClass UDisksLinuxDeviceClass;
+
+struct _UDisksLinuxDeviceClass
+{
+ GObjectClass parent_class;
+};
+
+
+G_DEFINE_TYPE (UDisksLinuxDevice, udisks_linux_device, G_TYPE_OBJECT);
+
+static void
+udisks_linux_device_init (UDisksLinuxDevice *device)
+{
+}
+
+static void
+udisks_linux_device_finalize (GObject *object)
+{
+ UDisksLinuxDevice *device = UDISKS_LINUX_DEVICE (object);
+
+ g_clear_object (&device->udev_device);
+ g_free (device->ata_identify_device_data);
+ g_free (device->ata_identify_packet_device_data);
+
+ G_OBJECT_CLASS (udisks_linux_device_parent_class)->finalize (object);
+}
+
+static void
+udisks_linux_device_class_init (UDisksLinuxDeviceClass *klass)
+{
+ GObjectClass *gobject_class;
+
+ gobject_class = G_OBJECT_CLASS (klass);
+ gobject_class->finalize = udisks_linux_device_finalize;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+static gboolean probe_ata (UDisksLinuxDevice *device,
+ GError **error);
+
+/**
+ * udisks_linux_device_new_sync:
+ * @udev_device: A #GUdevDevice.
+ *
+ * Creates a new #UDisksLinuxDevice from @udev_device which includes
+ * probing the device for more information, if applicable.
+ *
+ * The calling thread may be blocked for a non-trivial amount of time
+ * while the probing is underway.
+ *
+ * Returns: A #UDisksLinuxDevice.
+ */
+UDisksLinuxDevice *
+udisks_linux_device_new_sync (GUdevDevice *udev_device)
+{
+ UDisksLinuxDevice *device;
+ GError *error = NULL;
+
+ g_return_val_if_fail (G_UDEV_IS_DEVICE (udev_device), NULL);
+
+ device = g_object_new (UDISKS_TYPE_LINUX_DEVICE, NULL);
+ device->udev_device = g_object_ref (udev_device);
+
+ /* No point in probing on remove events */
+ if (!(g_strcmp0 (g_udev_device_get_action (udev_device), "remove") == 0))
+ {
+ /* Get IDENTIFY DEVICE / IDENTIFY PACKET DEVICE data for ATA devices */
+ if (g_strcmp0 (g_udev_device_get_subsystem (device->udev_device), "block") == 0 &&
+ g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0 &&
+ g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA"))
+ {
+ if (!probe_ata (device, &error))
+ goto out;
+ }
+ }
+
+ out:
+ if (error != NULL)
+ {
+ udisks_error ("Error probing device: %s (%s, %d)",
+ error->message, g_quark_to_string (error->domain), error->code);
+ g_clear_error (&error);
+ }
+
+ return device;
+}
+
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+static gboolean
+probe_ata (UDisksLinuxDevice *device,
+ GError **error)
+{
+ const gchar *device_file;
+ gboolean ret = FALSE;
+ gint fd = -1;
+ UDisksAtaCommandInput input = {0};
+ UDisksAtaCommandOutput output = {0};
+
+ device_file = g_udev_device_get_device_file (device->udev_device);
+ fd = open (device_file, O_RDONLY|O_NONBLOCK);
+ if (fd == -1)
+ {
+ g_set_error (error, UDISKS_ERROR, UDISKS_ERROR_FAILED,
+ "Error opening device file %s: %m",
+ device_file);
+ goto out;
+ }
+
+
+ if (ioctl (fd, CDROM_GET_CAPABILITY, NULL) == -1)
+ {
+ /* ATA8: 7.16 IDENTIFY DEVICE - ECh, PIO Data-In */
+ device->ata_identify_device_data = g_new0 (guchar, 512);
+ input.command = 0xec;
+ output.buffer = device->ata_identify_device_data;
+ output.buffer_size = 512;
+ if (!udisks_ata_send_command_sync (fd,
+ -1,
+ UDISKS_ATA_COMMAND_PROTOCOL_DRIVE_TO_HOST,
+ &input,
+ &output,
+ error))
+ {
+ g_prefix_error (error, "Error sending ATA command IDENTIFY DEVICE to %s: ",
+ device_file);
+ goto out;
+ }
+ /* udisks_daemon_util_hexdump_debug (device->ata_identify_device_data, 512); */
+ }
+ else
+ {
+ /* ATA8: 7.17 IDENTIFY PACKET DEVICE - A1h, PIO Data-In */
+ device->ata_identify_packet_device_data = g_new0 (guchar, 512);
+ input.command = 0xa1;
+ output.buffer = device->ata_identify_packet_device_data;
+ output.buffer_size = 512;
+ if (!udisks_ata_send_command_sync (fd,
+ -1,
+ UDISKS_ATA_COMMAND_PROTOCOL_DRIVE_TO_HOST,
+ &input,
+ &output,
+ error))
+ {
+ g_prefix_error (error, "Error sending ATA command IDENTIFY PACKET DEVICE to %s: ",
+ device_file);
+ goto out;
+ }
+ /* udisks_daemon_util_hexdump_debug (device->ata_identify_packet_device_data, 512); */
+ }
+
+ ret = TRUE;
+
+ out:
+ if (fd != -1)
+ {
+ if (close (fd) != 0)
+ {
+ udisks_warning ("Error closing fd %d for device %s: %m",
+ fd, device_file);
+ }
+ }
+ return ret;
+}
--- /dev/null
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
+ *
+ * Copyright (C) 2008-2010 David Zeuthen <zeuthen@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __UDISKS_LINUX_DEVICE_H__
+#define __UDISKS_LINUX_DEVICE_H__
+
+#include "udisksdaemontypes.h"
+
+G_BEGIN_DECLS
+
+#define UDISKS_TYPE_LINUX_DEVICE (udisks_linux_device_get_type ())
+#define UDISKS_LINUX_DEVICE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), UDISKS_TYPE_LINUX_DEVICE, UDisksLinuxDevice))
+#define UDISKS_IS_LINUX_DEVICE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), UDISKS_TYPE_LINUX_DEVICE))
+
+/**
+ * UDisksLinuxDevice:
+ * @parent_instance: The parent instance.
+ * @udev_device: A #GUdevDevice.
+ * @ata_identify_device_data: 512-byte array containing the result of the IDENTIY DEVICE command or %NULL.
+ * @ata_identify_packet_device_data: 512-byte array containing the result of the IDENTIY PACKET DEVICE command or %NULL.
+ *
+ * Object containing information about a device on Linux. This is
+ * essentially an instance of #GUdevDevice plus additional data - such
+ * as ATA IDENTIFY data - obtained via probing the device at discovery
+ * and uevent "change" time.
+ */
+struct _UDisksLinuxDevice
+{
+ /*< public >*/
+ GObject parent_instance;
+ GUdevDevice *udev_device;
+ guchar *ata_identify_device_data;
+ guchar *ata_identify_packet_device_data;
+};
+
+GType udisks_linux_device_get_type (void) G_GNUC_CONST;
+UDisksLinuxDevice *udisks_linux_device_new_sync (GUdevDevice *udev_device);
+
+G_END_DECLS
+
+#endif /* __UDISKS_LINUX_DEVICE_H__ */
#include "udisksdaemon.h"
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxdrive
}
static void
-set_media (UDisksDrive *iface,
- GUdevDevice *device,
- gboolean is_pc_floppy_drive)
+set_media (UDisksDrive *iface,
+ UDisksLinuxDevice *device,
+ gboolean is_pc_floppy_drive)
{
guint n;
GPtrArray *media_compat_array;
media_compat_array = g_ptr_array_new ();
for (n = 0; drive_media_mapping[n].udev_property != NULL; n++)
{
- if (g_udev_device_get_property_as_boolean (device, drive_media_mapping[n].udev_property))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, drive_media_mapping[n].udev_property))
{
g_ptr_array_add (media_compat_array, (gpointer) drive_media_mapping[n].media_name);
if (drive_media_mapping[n].force_non_removable)
g_ptr_array_sort (media_compat_array, (GCompareFunc) ptr_str_array_compare);
g_ptr_array_add (media_compat_array, NULL);
- removable = ejectable = g_udev_device_get_sysfs_attr_as_boolean (device, "removable");
+ removable = ejectable = g_udev_device_get_sysfs_attr_as_boolean (device->udev_device, "removable");
if (force_non_removable)
removable = FALSE;
if (force_removable)
{
for (n = 0; media_mapping[n].udev_property != NULL; n++)
{
- if (g_udev_device_get_property_as_boolean (device, media_mapping[n].udev_property))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, media_mapping[n].udev_property))
{
media_in_drive = media_mapping[n].media_name;
break;
udisks_drive_set_media (iface, media_in_drive);
g_ptr_array_free (media_compat_array, TRUE);
- if (g_udev_device_get_property_as_boolean (device, "ID_CDROM_MEDIA"))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, "ID_CDROM_MEDIA"))
{
const gchar *state;
is_disc = TRUE;
- state = g_udev_device_get_property (device, "ID_CDROM_MEDIA_STATE");
+ state = g_udev_device_get_property (device->udev_device, "ID_CDROM_MEDIA_STATE");
if (g_strcmp0 (state, "blank") == 0)
disc_is_blank = TRUE;
- disc_session_count = g_udev_device_get_property_as_int (device, "ID_CDROM_MEDIA_SESSION_COUNT");
- disc_track_count = g_udev_device_get_property_as_int (device, "ID_CDROM_MEDIA_TRACK_COUNT");
- disc_track_count_audio = g_udev_device_get_property_as_int (device, "ID_CDROM_MEDIA_TRACK_COUNT_AUDIO");
- disc_track_count_data = g_udev_device_get_property_as_int (device, "ID_CDROM_MEDIA_TRACK_COUNT_DATA");
+ disc_session_count = g_udev_device_get_property_as_int (device->udev_device, "ID_CDROM_MEDIA_SESSION_COUNT");
+ disc_track_count = g_udev_device_get_property_as_int (device->udev_device, "ID_CDROM_MEDIA_TRACK_COUNT");
+ disc_track_count_audio = g_udev_device_get_property_as_int (device->udev_device, "ID_CDROM_MEDIA_TRACK_COUNT_AUDIO");
+ disc_track_count_data = g_udev_device_get_property_as_int (device->udev_device, "ID_CDROM_MEDIA_TRACK_COUNT_DATA");
}
udisks_drive_set_optical (iface, is_disc);
udisks_drive_set_optical_blank (iface, disc_is_blank);
}
static void
-set_rotation_rate (UDisksDrive *iface,
- GUdevDevice *device)
+set_rotation_rate (UDisksDrive *iface,
+ UDisksLinuxDevice *device)
{
gint rate;
- if (!g_udev_device_get_sysfs_attr_as_boolean (device, "queue/rotational"))
+ if (!g_udev_device_get_sysfs_attr_as_boolean (device->udev_device, "queue/rotational"))
{
rate = 0;
}
else
{
rate = -1;
- if (g_udev_device_has_property (device, "ID_ATA_ROTATION_RATE_RPM"))
- rate = g_udev_device_get_property_as_int (device, "ID_ATA_ROTATION_RATE_RPM");
+ if (g_udev_device_has_property (device->udev_device, "ID_ATA_ROTATION_RATE_RPM"))
+ rate = g_udev_device_get_property_as_int (device->udev_device, "ID_ATA_ROTATION_RATE_RPM");
}
udisks_drive_set_rotation_rate (iface, rate);
}
static void
-set_connection_bus (UDisksDrive *iface,
- GUdevDevice *device)
+set_connection_bus (UDisksDrive *iface,
+ UDisksLinuxDevice *device)
{
GUdevDevice *parent;
/* note: @device may vary - it can be any path for drive */
udisks_drive_set_connection_bus (iface, "");
- parent = g_udev_device_get_parent_with_subsystem (device, "usb", "usb_interface");
+ parent = g_udev_device_get_parent_with_subsystem (device->udev_device, "usb", "usb_interface");
if (parent != NULL)
{
/* TODO: should probably check that it's a storage interface */
goto out;
}
- parent = g_udev_device_get_parent_with_subsystem (device, "firewire", NULL);
+ parent = g_udev_device_get_parent_with_subsystem (device->udev_device, "firewire", NULL);
if (parent != NULL)
{
/* TODO: should probably check that it's a storage interface */
goto out;
}
- if (g_str_has_prefix (g_udev_device_get_name (device), "mmcblk"))
+ if (g_str_has_prefix (g_udev_device_get_name (device->udev_device), "mmcblk"))
{
udisks_drive_set_connection_bus (iface, "sdio");
goto out;
}
static void
-set_media_time_detected (UDisksLinuxDrive *drive,
- GUdevDevice *device,
- gboolean is_pc_floppy_drive,
- gboolean coldplug)
+set_media_time_detected (UDisksLinuxDrive *drive,
+ UDisksLinuxDevice *device,
+ gboolean is_pc_floppy_drive,
+ gboolean coldplug)
{
UDisksDrive *iface = UDISKS_DRIVE (drive);
gint64 now;
{
if (coldplug)
{
- drive->time_detected = now - g_udev_device_get_usec_since_initialized (device);
+ drive->time_detected = now - g_udev_device_get_usec_since_initialized (device->udev_device);
}
else
{
}
}
- if (!g_udev_device_get_sysfs_attr_as_boolean (device, "removable") || is_pc_floppy_drive)
+ if (!g_udev_device_get_sysfs_attr_as_boolean (device->udev_device, "removable") || is_pc_floppy_drive)
{
drive->time_media_detected = drive->time_detected;
}
{
gboolean ret = FALSE;
UDisksDrive *iface = UDISKS_DRIVE (drive);
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
guint64 size;
gboolean media_available;
gboolean media_change_detected;
coldplug = udisks_linux_provider_get_coldplug (provider);
}
- if (g_udev_device_get_property_as_boolean (device, "ID_DRIVE_FLOPPY") ||
- g_str_has_prefix (g_udev_device_get_name (device), "fd"))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, "ID_DRIVE_FLOPPY") ||
+ g_str_has_prefix (g_udev_device_get_name (device->udev_device), "fd"))
is_pc_floppy_drive = TRUE;
/* this is the _almost_ the same for both ATA and SCSI devices (cf. udev's ata_id and scsi_id)
* but we special case since there are subtle differences...
*/
- if (g_udev_device_get_property_as_boolean (device, "ID_ATA"))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA"))
{
const gchar *model;
- model = g_udev_device_get_property (device, "ID_MODEL_ENC");
+ model = g_udev_device_get_property (device->udev_device, "ID_MODEL_ENC");
if (model != NULL)
{
gchar *s;
g_free (s);
}
- udisks_drive_set_vendor (iface, g_udev_device_get_property (device, ""));
- udisks_drive_set_revision (iface, g_udev_device_get_property (device, "ID_REVISION"));
- udisks_drive_set_serial (iface, g_udev_device_get_property (device, "ID_SERIAL_SHORT"));
- udisks_drive_set_wwn (iface, g_udev_device_get_property (device, "ID_WWN_WITH_EXTENSION"));
+ udisks_drive_set_vendor (iface, "");
+ udisks_drive_set_revision (iface, g_udev_device_get_property (device->udev_device, "ID_REVISION"));
+ udisks_drive_set_serial (iface, g_udev_device_get_property (device->udev_device, "ID_SERIAL_SHORT"));
+ udisks_drive_set_wwn (iface, g_udev_device_get_property (device->udev_device, "ID_WWN_WITH_EXTENSION"));
}
- else if (g_udev_device_get_property_as_boolean (device, "ID_SCSI"))
+ else if (g_udev_device_get_property_as_boolean (device->udev_device, "ID_SCSI"))
{
const gchar *vendor;
const gchar *model;
- vendor = g_udev_device_get_property (device, "ID_VENDOR_ENC");
+ vendor = g_udev_device_get_property (device->udev_device, "ID_VENDOR_ENC");
if (vendor != NULL)
{
gchar *s;
g_free (s);
}
- model = g_udev_device_get_property (device, "ID_MODEL_ENC");
+ model = g_udev_device_get_property (device->udev_device, "ID_MODEL_ENC");
if (model != NULL)
{
gchar *s;
g_free (s);
}
- udisks_drive_set_revision (iface, g_udev_device_get_property (device, "ID_REVISION"));
- udisks_drive_set_serial (iface, g_udev_device_get_property (device, "ID_SCSI_SERIAL"));
- udisks_drive_set_wwn (iface, g_udev_device_get_property (device, "ID_WWN_WITH_EXTENSION"));
+ udisks_drive_set_revision (iface, g_udev_device_get_property (device->udev_device, "ID_REVISION"));
+ udisks_drive_set_serial (iface, g_udev_device_get_property (device->udev_device, "ID_SCSI_SERIAL"));
+ udisks_drive_set_wwn (iface, g_udev_device_get_property (device->udev_device, "ID_WWN_WITH_EXTENSION"));
}
- else if (g_str_has_prefix (g_udev_device_get_name (device), "mmcblk"))
+ else if (g_str_has_prefix (g_udev_device_get_name (device->udev_device), "mmcblk"))
{
/* sigh, mmc is non-standard and using ID_NAME instead of ID_MODEL.. */
- udisks_drive_set_model (iface, g_udev_device_get_property (device, "ID_NAME"));
- udisks_drive_set_serial (iface, g_udev_device_get_property (device, "ID_SERIAL"));
+ udisks_drive_set_model (iface, g_udev_device_get_property (device->udev_device, "ID_NAME"));
+ udisks_drive_set_serial (iface, g_udev_device_get_property (device->udev_device, "ID_SERIAL"));
/* TODO:
* - lookup Vendor from manfid and oemid in sysfs
* - lookup Revision from fwrev and hwrev in sysfs
const gchar *model;
const gchar *name;
- name = g_udev_device_get_name (device);
+ name = g_udev_device_get_name (device->udev_device);
/* generic fallback... */
- vendor = g_udev_device_get_property (device, "ID_VENDOR_ENC");
+ vendor = g_udev_device_get_property (device->udev_device, "ID_VENDOR_ENC");
if (vendor != NULL)
{
gchar *s;
}
else
{
- vendor = g_udev_device_get_property (device, "ID_VENDOR");
+ vendor = g_udev_device_get_property (device->udev_device, "ID_VENDOR");
if (vendor != NULL)
{
udisks_drive_set_vendor (iface, vendor);
}
}
- model = g_udev_device_get_property (device, "ID_MODEL_ENC");
+ model = g_udev_device_get_property (device->udev_device, "ID_MODEL_ENC");
if (model != NULL)
{
gchar *s;
}
else
{
- model = g_udev_device_get_property (device, "ID_MODEL");
+ model = g_udev_device_get_property (device->udev_device, "ID_MODEL");
if (model != NULL)
{
udisks_drive_set_model (iface, model);
}
}
- udisks_drive_set_revision (iface, g_udev_device_get_property (device, "ID_REVISION"));
- udisks_drive_set_serial (iface, g_udev_device_get_property (device, "ID_SERIAL_SHORT"));
- if (g_udev_device_has_property (device, "ID_WWN_WITH_EXTENSION"))
- udisks_drive_set_wwn (iface, g_udev_device_get_property (device, "ID_WWN_WITH_EXTENSION"));
+ udisks_drive_set_revision (iface, g_udev_device_get_property (device->udev_device, "ID_REVISION"));
+ udisks_drive_set_serial (iface, g_udev_device_get_property (device->udev_device, "ID_SERIAL_SHORT"));
+ if (g_udev_device_has_property (device->udev_device, "ID_WWN_WITH_EXTENSION"))
+ udisks_drive_set_wwn (iface, g_udev_device_get_property (device->udev_device, "ID_WWN_WITH_EXTENSION"));
else
- udisks_drive_set_wwn (iface, g_udev_device_get_property (device, "ID_WWN"));
+ udisks_drive_set_wwn (iface, g_udev_device_get_property (device->udev_device, "ID_WWN"));
}
/* common bits go here */
- size = udisks_daemon_util_block_get_size (device,
+ size = udisks_daemon_util_block_get_size (device->udev_device,
&media_available,
&media_change_detected);
udisks_drive_set_size (iface, size);
removable_hint = TRUE;
udisks_drive_set_removable (iface, removable_hint);
- seat = g_udev_device_get_property (device, "ID_SEAT");
+ seat = g_udev_device_get_property (device->udev_device, "ID_SEAT");
/* assume seat0 if not set */
if (seat == NULL || strlen (seat) == 0)
seat = "seat0";
{
const gchar *device_name;
/* TODO: adjust device_name for better sort order (so e.g. sdaa comes after sdz) */
- device_name = g_udev_device_get_name (device);
+ device_name = g_udev_device_get_name (device->udev_device);
if (udisks_drive_get_removable (iface))
{
/* make sure fd* BEFORE sr* BEFORE sd* */
ret = update_configuration (drive, object);
out:
- if (device != NULL)
- g_object_unref (device);
+ g_clear_object (&device);
return ret;
}
#include "udiskssimplejob.h"
#include "udisksthreadedjob.h"
#include "udisksata.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxdriveata
/* may be called from *any* thread when the SMART data has been updated */
static void
update_smart (UDisksLinuxDriveAta *drive,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
gboolean supported = FALSE;
gboolean enabled = FALSE;
gint num_attributes_failed_in_the_past = -1;
gint64 num_bad_sectors = 1;
- supported = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_SMART");
- enabled = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_SMART_ENABLED");
+ supported = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_SMART");
+ enabled = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_SMART_ENABLED");
G_LOCK (object_lock);
if (drive->smart_updated > 0)
static void
update_pm (UDisksLinuxDriveAta *drive,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
gboolean supported = FALSE;
gboolean enabled = FALSE;
gboolean aam_enabled = FALSE;
gint aam_vendor_recommended_value = 0;
- supported = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_PM");
- enabled = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_PM_ENABLED");
- apm_supported = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_APM");
- apm_enabled = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_APM_ENABLED");
- aam_supported = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_AAM");
- aam_enabled = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_AAM_ENABLED");
- aam_vendor_recommended_value = g_udev_device_get_property_as_int (device, "ID_ATA_FEATURE_SET_AAM_VENDOR_RECOMMENDED_VALUE");
+ supported = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_PM");
+ enabled = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_PM_ENABLED");
+ apm_supported = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_APM");
+ apm_enabled = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_APM_ENABLED");
+ aam_supported = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_AAM");
+ aam_enabled = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_AAM_ENABLED");
+ aam_vendor_recommended_value = g_udev_device_get_property_as_int (device->udev_device, "ID_ATA_FEATURE_SET_AAM_VENDOR_RECOMMENDED_VALUE");
g_object_freeze_notify (G_OBJECT (drive));
udisks_drive_ata_set_pm_supported (UDISKS_DRIVE_ATA (drive), supported);
static void
update_security (UDisksLinuxDriveAta *drive,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
gint erase_unit = 0;
gint enhanced_erase_unit = 0;
gboolean frozen = FALSE;
- erase_unit = g_udev_device_get_property_as_int (device, "ID_ATA_FEATURE_SET_SECURITY_ERASE_UNIT_MIN");
- enhanced_erase_unit = g_udev_device_get_property_as_int (device, "ID_ATA_FEATURE_SET_SECURITY_ENHANCED_ERASE_UNIT_MIN");
- frozen = g_udev_device_get_property_as_boolean (device, "ID_ATA_FEATURE_SET_SECURITY_FROZEN");
+ erase_unit = g_udev_device_get_property_as_int (device->udev_device, "ID_ATA_FEATURE_SET_SECURITY_ERASE_UNIT_MIN");
+ enhanced_erase_unit = g_udev_device_get_property_as_int (device->udev_device, "ID_ATA_FEATURE_SET_SECURITY_ENHANCED_ERASE_UNIT_MIN");
+ frozen = g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA_FEATURE_SET_SECURITY_FROZEN");
g_object_freeze_notify (G_OBJECT (drive));
udisks_drive_ata_set_security_erase_unit_minutes (UDISKS_DRIVE_ATA (drive), erase_unit);
udisks_linux_drive_ata_update (UDisksLinuxDriveAta *drive,
UDisksLinuxDriveObject *object)
{
- GUdevDevice *device;
+ UDisksLinuxDevice *device
+;
device = udisks_linux_drive_object_get_device (object, TRUE /* get_hw */);
if (device == NULL)
goto out;
GError **error)
{
UDisksLinuxDriveObject *object;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
gboolean ret = FALSE;
SkDisk *d = NULL;
SkBool awake;
}
else
{
- if (sk_disk_open (g_udev_device_get_device_file (device), &d) != 0)
+ if (sk_disk_open (g_udev_device_get_device_file (device->udev_device), &d) != 0)
{
g_set_error (error,
UDISKS_ERROR,
GError **error)
{
UDisksLinuxDriveObject *object;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
SkDisk *d = NULL;
gboolean ret = FALSE;
SkSmartSelfTest test;
goto out;
}
- if (sk_disk_open (g_udev_device_get_device_file (device), &d) != 0)
+ if (sk_disk_open (g_udev_device_get_device_file (device->udev_device), &d) != 0)
{
g_set_error (error,
UDISKS_ERROR,
UDisksLinuxDriveAta *drive = UDISKS_LINUX_DRIVE_ATA (_drive);
UDisksLinuxDriveObject *object = NULL;
UDisksDaemon *daemon;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
gint fd = -1;
GError *error = NULL;
const gchar *message;
goto out;
}
- fd = open (g_udev_device_get_device_file (device), O_RDONLY|O_NONBLOCK);
+ fd = open (g_udev_device_get_device_file (device->udev_device), O_RDONLY|O_NONBLOCK);
if (fd == -1)
{
g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED,
"Error opening device file %s: %m",
- g_udev_device_get_device_file (device));
+ g_udev_device_get_device_file (device->udev_device));
goto out;
}
UDisksLinuxBlockObject *block_object = NULL;
UDisksBlock *block = NULL;
UDisksDaemon *daemon;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
gint fd = -1;
GError *error = NULL;
const gchar *message;
goto out;
}
- fd = open (g_udev_device_get_device_file (device), O_RDONLY|O_NONBLOCK);
+ fd = open (g_udev_device_get_device_file (device->udev_device), O_RDONLY|O_NONBLOCK);
if (fd == -1)
{
g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED,
"Error opening device file %s: %m",
- g_udev_device_get_device_file (device));
+ g_udev_device_get_device_file (device->udev_device));
goto out;
}
UDisksLinuxBlockObject *block_object = NULL;
UDisksBlock *block = NULL;
UDisksDaemon *daemon;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
gint fd = -1;
GError *error = NULL;
const gchar *message;
goto out;
}
- fd = open (g_udev_device_get_device_file (device), O_RDONLY);
+ fd = open (g_udev_device_get_device_file (device->udev_device), O_RDONLY);
if (fd == -1)
{
g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED,
"Error opening device file %s: %m",
- g_udev_device_get_device_file (device));
+ g_udev_device_get_device_file (device->udev_device));
goto out;
}
g_dbus_method_invocation_return_error (invocation, UDISKS_ERROR, UDISKS_ERROR_FAILED,
"Error reading %d bytes from %s: %m",
(gint) sizeof (buf),
- g_udev_device_get_device_file (device));
+ g_udev_device_get_device_file (device->udev_device));
goto out;
}
gint ata_apm_level;
gint ata_aam_level;
UDisksLinuxDriveAta *ata;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
GVariant *configuration;
UDisksDrive *drive;
UDisksLinuxDriveObject *object;
gint fd = -1;
GError *error = NULL;
- device_file = g_udev_device_get_device_file (data->device);
+ device_file = g_udev_device_get_device_file (data->device->udev_device);
udisks_notice ("Applying configuration from %s/udisks2/%s.conf to %s",
PACKAGE_SYSCONF_DIR, udisks_drive_get_id (data->drive), device_file);
/**
* udisks_linux_drive_ata_apply_configuration:
* @drive: A #UDisksLinuxDriveAta.
- * @device: A #GUdevDevice
+ * @device: A #UDisksLinuxDevice
* @configuration: The configuration to apply.
*
* Spawns a thread to apply @configuration to @drive, if any. Does not
*/
void
udisks_linux_drive_ata_apply_configuration (UDisksLinuxDriveAta *drive,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
GVariant *configuration)
{
gboolean has_conf = FALSE;
UDisksLinuxDriveObject *object = NULL;
UDisksLinuxBlockObject *block_object = NULL;
UDisksDaemon *daemon;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
const gchar *device_file = NULL;
gint fd = -1;
union
}
/* Use O_EXCL so it fails if mounted or in use */
- device_file = g_udev_device_get_device_file (device);
- fd = open (g_udev_device_get_device_file (device), O_RDONLY | O_EXCL);
+ device_file = g_udev_device_get_device_file (device->udev_device);
+ fd = open (g_udev_device_get_device_file (device->udev_device), O_RDONLY | O_EXCL);
if (fd == -1)
{
g_set_error (&local_error, UDISKS_ERROR, UDISKS_ERROR_FAILED,
GError **error);
void udisks_linux_drive_ata_apply_configuration (UDisksLinuxDriveAta *drive,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
GVariant *configuration);
G_END_DECLS
#include "udiskslinuxdrive.h"
#include "udiskslinuxdriveata.h"
#include "udiskslinuxblockobject.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxdriveobject
UDisksDaemon *daemon;
- /* list of GUdevDevice objects for block objects */
+ /* list of UDisksLinuxDevice objects for block objects */
GList *devices;
/* interfaces */
GObjectConstructParam *cp;
UDisksDaemon *daemon;
GUdevClient *client;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
cp = find_construct_property (n_construct_properties, construct_properties, "daemon");
g_assert (cp != NULL);
cp = find_construct_property (n_construct_properties, construct_properties, "device");
g_assert (cp != NULL);
- device = G_UDEV_DEVICE (g_value_get_object (cp->value));
+ device = g_value_get_object (cp->value);
g_assert (device != NULL);
if (!udisks_linux_drive_object_should_include_device (client, device, NULL))
/**
* UDisksLinuxDriveObject:device:
*
- * The #GUdevDevice for the object. Connect to the #GObject::notify
+ * The #UDisksLinuxDevice for the object. Connect to the #GObject::notify
* signal to get notified whenever this is updated.
*/
g_object_class_install_property (gobject_class,
g_param_spec_object ("device",
"Device",
"The device for the object",
- G_UDEV_TYPE_DEVICE,
+ UDISKS_TYPE_LINUX_DEVICE,
G_PARAM_WRITABLE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS));
/**
* udisks_linux_drive_object_new:
* @daemon: A #UDisksDaemon.
- * @device: The #GUdevDevice for the sysfs block device.
+ * @device: The #UDisksLinuxDevice for the sysfs block device.
*
* Create a new drive object.
*
* Returns: A #UDisksLinuxDriveObject object or %NULL if @device does not represent a drive. Free with g_object_unref().
*/
UDisksLinuxDriveObject *
-udisks_linux_drive_object_new (UDisksDaemon *daemon,
- GUdevDevice *device)
+udisks_linux_drive_object_new (UDisksDaemon *daemon,
+ UDisksLinuxDevice *device)
{
GObject *object;
g_return_val_if_fail (UDISKS_IS_DAEMON (daemon), NULL);
- g_return_val_if_fail (G_UDEV_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (UDISKS_IS_LINUX_DEVICE (device), NULL);
object = g_object_new (UDISKS_TYPE_LINUX_DRIVE_OBJECT,
"daemon", daemon,
* udisks_linux_drive_object_get_devices:
* @object: A #UDisksLinuxDriveObject.
*
- * Gets the current #GUdevDevice objects associated with @object.
+ * Gets the current #UDisksLinuxDevice objects associated with @object.
*
- * Returns: A list of #GUdevDevice objects. Free each element with
+ * Returns: A list of #UDisksLinuxDevice objects. Free each element with
* g_object_unref(), then free the list with g_list_free().
*/
GList *
* @object: A #UDisksLinuxDriveObject.
* @get_hw: If the drive is multipath, set to %TRUE to get a path device instead of the multipath device.
*
- * Gets one of the #GUdevDevice object associated with @object.
+ * Gets one of the #UDisksLinuxDevice object associated with @object.
*
* If @get_hw is %TRUE and @object represents a multipath device then
* one of the paths is returned rather than the multipath device. This
* is useful if you e.g. need to configure the physical hardware.
*
- * Returns: A #GUdevDevice or %NULL. The returned object must be freed
+ * Returns: A #UDisksLinuxDevice or %NULL. The returned object must be freed
* with g_object_unref().
*/
-GUdevDevice *
+UDisksLinuxDevice *
udisks_linux_drive_object_get_device (UDisksLinuxDriveObject *object,
gboolean get_hw)
{
- GUdevDevice *ret = NULL;
+ UDisksLinuxDevice *ret = NULL;
/* TODO: actually look at @get_hw */
if (object->devices != NULL)
{
{
GDBusObjectSkeleton *iter_object = G_DBUS_OBJECT_SKELETON (l->data);
UDisksBlock *block;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
gboolean is_disk;
if (!UDISKS_IS_LINUX_BLOCK_OBJECT (iter_object))
continue;
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (iter_object));
- is_disk = (g_strcmp0 (g_udev_device_get_devtype (device), "disk") == 0);
+ is_disk = (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") == 0);
g_object_unref (device);
if (!is_disk)
drive_ata_check (UDisksLinuxDriveObject *object)
{
gboolean ret;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
ret = FALSE;
if (object->devices == NULL)
goto out;
- device = G_UDEV_DEVICE (object->devices->data);
- if (!g_udev_device_get_property_as_boolean (device, "ID_ATA"))
+ device = object->devices->data;
+ if (!g_udev_device_get_property_as_boolean (device->udev_device, "ID_ATA"))
goto out;
ret = TRUE;
ret = NULL;
for (l = object->devices; l != NULL; l = l->next)
{
- GUdevDevice *device = G_UDEV_DEVICE (l->data);
- if (g_strcmp0 (g_udev_device_get_sysfs_path (device), sysfs_path) == 0)
+ UDisksLinuxDevice *device = l->data;
+ if (g_strcmp0 (g_udev_device_get_sysfs_path (device->udev_device), sysfs_path) == 0)
{
ret = l;
goto out;
* udisks_linux_drive_object_uevent:
* @object: A #UDisksLinuxDriveObject.
* @action: Uevent action or %NULL
- * @device: A #GUdevDevice device object or %NULL if the device hasn't changed.
+ * @device: A #UDisksLinuxDevice device object or %NULL if the device hasn't changed.
*
* Updates all information on interfaces on @drive.
*/
void
udisks_linux_drive_object_uevent (UDisksLinuxDriveObject *object,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
GList *link;
gboolean conf_changed;
g_return_if_fail (UDISKS_IS_LINUX_DRIVE_OBJECT (object));
- g_return_if_fail (device == NULL || G_UDEV_IS_DEVICE (device));
+ g_return_if_fail (device == NULL || UDISKS_IS_LINUX_DEVICE (device));
link = NULL;
if (device != NULL)
- link = find_link_for_sysfs_path (object, g_udev_device_get_sysfs_path (device));
+ link = find_link_for_sysfs_path (object, g_udev_device_get_sysfs_path (device->udev_device));
if (g_strcmp0 (action, "remove") == 0)
{
if (link != NULL)
{
- g_object_unref (G_UDEV_DEVICE (link->data));
+ g_object_unref (UDISKS_LINUX_DEVICE (link->data));
object->devices = g_list_delete_link (object->devices, link);
}
else
{
udisks_warning ("Drive doesn't have device with sysfs path %s on remove event",
- g_udev_device_get_sysfs_path (device));
+ g_udev_device_get_sysfs_path (device->udev_device));
}
}
else
{
if (link != NULL)
{
- g_object_unref (G_UDEV_DEVICE (link->data));
+ g_object_unref (UDISKS_LINUX_DEVICE (link->data));
link->data = g_object_ref (device);
}
else
apply_configuration (UDisksLinuxDriveObject *object)
{
GVariant *configuration = NULL;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
if (object->iface_drive == NULL)
goto out;
/* <internal>
* udisks_linux_drive_object_should_include_device:
* @client: A #GUdevClient.
- * @device: A #GUdevDevice.
+ * @device: A #UDisksLinuxDevice.
* @out_vpd: Return location for unique ID or %NULL.
*
* Checks if we should even construct a #UDisksLinuxDriveObject for @device.
*/
gboolean
udisks_linux_drive_object_should_include_device (GUdevClient *client,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
gchar **out_vpd)
{
gboolean ret;
*
* and we are only interested in the first.
*/
- if (g_strcmp0 (g_udev_device_get_devtype (device), "disk") != 0)
+ if (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") != 0)
goto out;
- vpd = check_for_vpd (device);
+ vpd = check_for_vpd (device->udev_device);
if (vpd == NULL)
{
const gchar *dm_name;
GUdevDevice *parent;
- name = g_udev_device_get_name (device);
+ name = g_udev_device_get_name (device->udev_device);
/* workaround for floppy devices */
if (g_str_has_prefix (name, "fd"))
}
/* workaround for missing serial/wwn on VMware */
- vendor = g_udev_device_get_property (device, "ID_VENDOR");
- model = g_udev_device_get_property (device, "ID_MODEL");
+ vendor = g_udev_device_get_property (device->udev_device, "ID_VENDOR");
+ model = g_udev_device_get_property (device->udev_device, "ID_MODEL");
if (g_str_has_prefix (name, "sd") &&
vendor != NULL && g_strcmp0 (vendor, "VMware") == 0 &&
model != NULL && g_str_has_prefix (model, "Virtual"))
}
/* workaround for missing serial/wwn on firewire devices */
- parent = g_udev_device_get_parent_with_subsystem (device, "firewire", NULL);
+ parent = g_udev_device_get_parent_with_subsystem (device->udev_device, "firewire", NULL);
if (parent != NULL)
{
vpd = g_strdup (name);
}
/* dm-multipath */
- dm_name = g_udev_device_get_sysfs_attr (device, "dm/name");
+ dm_name = g_udev_device_get_sysfs_attr (device->udev_device, "dm/name");
if (dm_name != NULL && g_str_has_prefix (dm_name, "mpath"))
{
gchar **slaves;
guint n;
- slaves = udisks_daemon_util_resolve_links (g_udev_device_get_sysfs_path (device), "slaves");
+ slaves = udisks_daemon_util_resolve_links (g_udev_device_get_sysfs_path (device->udev_device), "slaves");
for (n = 0; slaves[n] != NULL; n++)
{
GUdevDevice *slave;
GType udisks_linux_drive_object_get_type (void) G_GNUC_CONST;
UDisksLinuxDriveObject *udisks_linux_drive_object_new (UDisksDaemon *daemon,
- GUdevDevice *device);
+ UDisksLinuxDevice *device);
void udisks_linux_drive_object_uevent (UDisksLinuxDriveObject *object,
const gchar *action,
- GUdevDevice *device);
+ UDisksLinuxDevice *device);
UDisksDaemon *udisks_linux_drive_object_get_daemon (UDisksLinuxDriveObject *object);
GList *udisks_linux_drive_object_get_devices (UDisksLinuxDriveObject *object);
-GUdevDevice *udisks_linux_drive_object_get_device (UDisksLinuxDriveObject *object,
+UDisksLinuxDevice *udisks_linux_drive_object_get_device (UDisksLinuxDriveObject *object,
gboolean get_hw);
UDisksLinuxBlockObject *udisks_linux_drive_object_get_block (UDisksLinuxDriveObject *object,
gboolean get_hw);
GCancellable *cancellable,
GError **error);
-gboolean udisks_linux_drive_object_should_include_device (GUdevClient *client,
- GUdevDevice *device,
- gchar **out_vpd);
+gboolean udisks_linux_drive_object_should_include_device (GUdevClient *client,
+ UDisksLinuxDevice *device,
+ gchar **out_vpd);
G_END_DECLS
#include "udiskspersistentstore.h"
#include "udisksdaemonutil.h"
#include "udiskscleanup.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxencrypted
gchar *escaped_name = NULL;
UDisksObject *cleartext_object = NULL;
UDisksBlock *cleartext_block;
- GUdevDevice *udev_cleartext_device = NULL;
+ UDisksLinuxDevice *cleartext_device = NULL;
GError *error = NULL;
uid_t caller_uid;
pid_t caller_pid;
udisks_block_get_device (block),
udisks_block_get_device (cleartext_block));
- udev_cleartext_device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (cleartext_object));
+ cleartext_device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (cleartext_object));
/* update the unlocked-luks file */
udisks_cleanup_add_unlocked_luks (cleanup,
udisks_block_get_device_number (cleartext_block),
udisks_block_get_device_number (block),
- g_udev_device_get_sysfs_attr (udev_cleartext_device, "dm/uuid"),
+ g_udev_device_get_sysfs_attr (cleartext_device->udev_device, "dm/uuid"),
caller_uid);
udisks_encrypted_complete_unlock (encrypted,
g_free (escaped_name);
g_free (name);
g_free (error_message);
- if (udev_cleartext_device != NULL)
- g_object_unref (udev_cleartext_device);
- if (cleartext_object != NULL)
- g_object_unref (cleartext_object);
+ g_clear_object (&cleartext_device);
+ g_clear_object (&cleartext_object);
g_clear_object (&object);
return TRUE; /* returning TRUE means that we handled the method invocation */
gchar *escaped_name;
UDisksObject *cleartext_object;
UDisksBlock *cleartext_block;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
uid_t unlocked_by_uid;
dev_t cleartext_device_from_file;
GError *error;
}
device = udisks_linux_block_object_get_device (UDISKS_LINUX_BLOCK_OBJECT (cleartext_object));
- escaped_name = udisks_daemon_util_escape_and_quote (g_udev_device_get_sysfs_attr (device, "dm/name"));
+ escaped_name = udisks_daemon_util_escape_and_quote (g_udev_device_get_sysfs_attr (device->udev_device, "dm/name"));
if (!udisks_daemon_launch_spawned_job_sync (daemon,
object,
#include "udisksdaemonutil.h"
#include "udisksmountmonitor.h"
#include "udisksmount.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxfilesystem
UDisksLinuxBlockObject *object)
{
UDisksMountMonitor *mount_monitor;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
GPtrArray *p;
GList *mounts;
GList *l;
device = udisks_linux_block_object_get_device (object);
p = g_ptr_array_new ();
- mounts = udisks_mount_monitor_get_mounts_for_dev (mount_monitor, g_udev_device_get_device_number (device));
+ mounts = udisks_mount_monitor_get_mounts_for_dev (mount_monitor, g_udev_device_get_device_number (device->udev_device));
/* we are guaranteed that the list is sorted so if there are
* multiple mounts we'll always get the same order
*/
#include "udisksdaemon.h"
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxloop
{
UDisksDaemon *daemon;
UDisksCleanup *cleanup;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
uid_t setup_by_uid;
daemon = udisks_linux_block_object_get_daemon (UDISKS_LINUX_BLOCK_OBJECT (object));
cleanup = udisks_daemon_get_cleanup (daemon);
device = udisks_linux_block_object_get_device (object);
- if (g_str_has_prefix (g_udev_device_get_name (device), "loop"))
+ if (g_str_has_prefix (g_udev_device_get_name (device->udev_device), "loop"))
{
gchar *filename;
gchar *backing_file;
GError *error;
- filename = g_strconcat (g_udev_device_get_sysfs_path (device), "/loop/backing_file", NULL);
+ filename = g_strconcat (g_udev_device_get_sysfs_path (device->udev_device), "/loop/backing_file", NULL);
error = NULL;
if (!g_file_get_contents (filename,
&backing_file,
udisks_loop_set_backing_file (UDISKS_LOOP (loop), "");
}
udisks_loop_set_autoclear (UDISKS_LOOP (loop),
- g_udev_device_get_sysfs_attr_as_boolean (device, "loop/autoclear"));
+ g_udev_device_get_sysfs_attr_as_boolean (device->udev_device, "loop/autoclear"));
setup_by_uid = 0;
if (cleanup != NULL)
{
udisks_cleanup_has_loop (cleanup,
- g_udev_device_get_device_file (device),
+ g_udev_device_get_device_file (device->udev_device),
&setup_by_uid);
}
udisks_loop_set_setup_by_uid (UDISKS_LOOP (loop), setup_by_uid);
/* ---------------------------------------------------------------------------------------------------- */
static gboolean
-loop_set_autoclear (GUdevDevice *device,
- gboolean value,
- GError **error)
+loop_set_autoclear (UDisksLinuxDevice *device,
+ gboolean value,
+ GError **error)
{
gboolean ret = FALSE;
struct loop_info64 li64;
gint sysfs_autoclear_fd;
gchar *sysfs_autoclear_path = NULL;
- g_return_val_if_fail (G_UDEV_IS_DEVICE (device), FALSE);
+ g_return_val_if_fail (UDISKS_IS_LINUX_DEVICE (device), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* try writing to the loop/autoclear sysfs file - this may not work
* since it currently (May 2012) depends on a patch not yet applied
* upstream (it'll fail in open(2))
*/
- sysfs_autoclear_path = g_strconcat (g_udev_device_get_sysfs_path (device), "/loop/autoclear", NULL);
+ sysfs_autoclear_path = g_strconcat (g_udev_device_get_sysfs_path (device->udev_device), "/loop/autoclear", NULL);
sysfs_autoclear_fd = open (sysfs_autoclear_path, O_WRONLY);
if (sysfs_autoclear_fd > 0)
{
g_free (sysfs_autoclear_path);
/* if that didn't work, do LO_GET_STATUS, then LO_SET_STATUS */
- device_file = g_udev_device_get_device_file (device);
+ device_file = g_udev_device_get_device_file (device->udev_device);
fd = open (device_file, O_RDWR);
if (fd == -1)
{
{
UDisksObject *object = NULL;
UDisksDaemon *daemon = NULL;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
GError *error = NULL;
uid_t caller_uid = -1;
#include "udisksdaemonutil.h"
#include "udiskscleanup.h"
#include "udiskslinuxblockobject.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxmanager
UDisksObject *object = NULL;
UDisksBlock *block;
UDisksLoop *loop;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
GDir *dir;
/* First see if we have the right loop object */
if (device == NULL)
goto out;
- dir = g_dir_open (g_udev_device_get_sysfs_path (device), 0 /* flags */, NULL /* GError */);
+ dir = g_dir_open (g_udev_device_get_sysfs_path (device->udev_device), 0 /* flags */, NULL /* GError */);
if (dir != NULL)
{
const gchar *name;
const gchar *device_name;
- device_name = g_udev_device_get_name (device);
+ device_name = g_udev_device_get_name (device->udev_device);
while ((name = g_dir_read_name (dir)) != NULL)
{
if (g_str_has_prefix (name, device_name))
{
gchar *sysfs_path;
UDisksObject *partition_object;
- sysfs_path = g_strconcat (g_udev_device_get_sysfs_path (device), "/", name, NULL);
+ sysfs_path = g_strconcat (g_udev_device_get_sysfs_path (device->udev_device), "/", name, NULL);
partition_object = udisks_daemon_find_block_by_sysfs_path (daemon, sysfs_path);
if (partition_object == NULL)
{
#include "udisksdaemon.h"
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxmdraid
{
UDisksLinuxMDRaid *mdraid = UDISKS_LINUX_MDRAID (user_data);
UDisksLinuxMDRaidObject *object = NULL;
- GUdevDevice *raid_device;
+ UDisksLinuxDevice *raid_device;
/* udisks_debug ("polling timeout"); */
guint num_devices = 0;
guint num_members = 0;
guint64 size = 0;
- GUdevDevice *raid_device = NULL;
+ UDisksLinuxDevice *raid_device = NULL;
GList *member_devices = NULL;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
const gchar *level = NULL;
const gchar *uuid = NULL;
const gchar *name = NULL;
*/
if (member_devices != NULL)
{
- device = G_UDEV_DEVICE (member_devices->data);
- num_devices = g_udev_device_get_property_as_int (device, "MD_MEMBER_DEVICES");
- level = g_udev_device_get_property (device, "MD_MEMBER_LEVEL");
- uuid = g_udev_device_get_property (device, "MD_MEMBER_UUID");
- name = g_udev_device_get_property (device, "MD_MEMBER_NAME");
+ device = UDISKS_LINUX_DEVICE (member_devices->data);
+ num_devices = g_udev_device_get_property_as_int (device->udev_device, "MD_MEMBER_DEVICES");
+ level = g_udev_device_get_property (device->udev_device, "MD_MEMBER_LEVEL");
+ uuid = g_udev_device_get_property (device->udev_device, "MD_MEMBER_UUID");
+ name = g_udev_device_get_property (device->udev_device, "MD_MEMBER_NAME");
}
else
{
- device = G_UDEV_DEVICE (raid_device);
- num_devices = g_udev_device_get_property_as_int (device, "MD_DEVICES");
- level = g_udev_device_get_property (device, "MD_LEVEL");
- uuid = g_udev_device_get_property (device, "MD_UUID");
- name = g_udev_device_get_property (device, "MD_NAME");
+ device = UDISKS_LINUX_DEVICE (raid_device);
+ num_devices = g_udev_device_get_property_as_int (device->udev_device, "MD_DEVICES");
+ level = g_udev_device_get_property (device->udev_device, "MD_LEVEL");
+ uuid = g_udev_device_get_property (device->udev_device, "MD_UUID");
+ name = g_udev_device_get_property (device->udev_device, "MD_NAME");
}
/* figure out size */
if (raid_device != NULL)
{
- size = 512 * g_udev_device_get_sysfs_attr_as_uint64 (raid_device, "size");
+ size = 512 * g_udev_device_get_sysfs_attr_as_uint64 (raid_device->udev_device, "size");
}
else
{
if (has_redundancy)
{
/* Can't use GUdevDevice methods as they cache the result and these variables vary */
- degraded = read_sysfs_attr_as_int (raid_device, "md/degraded");
- sync_action = read_sysfs_attr (raid_device, "md/sync_action");
+ degraded = read_sysfs_attr_as_int (raid_device->udev_device, "md/degraded");
+ sync_action = read_sysfs_attr (raid_device->udev_device, "md/sync_action");
if (sync_action != NULL)
g_strstrip (sync_action);
- sync_completed = read_sysfs_attr (raid_device, "md/sync_completed");
+ sync_completed = read_sysfs_attr (raid_device->udev_device, "md/sync_completed");
if (sync_completed != NULL)
g_strstrip (sync_completed);
- bitmap_location = read_sysfs_attr (raid_device, "md/bitmap/location");
+ bitmap_location = read_sysfs_attr (raid_device->udev_device, "md/bitmap/location");
if (bitmap_location != NULL)
g_strstrip (bitmap_location);
}
if (has_stripes)
{
- chunk_size = read_sysfs_attr_as_uint64 (raid_device, "md/chunk_size");
+ chunk_size = read_sysfs_attr_as_uint64 (raid_device->udev_device, "md/chunk_size");
}
}
udisks_mdraid_set_degraded (iface, degraded);
* spurious property changes on MDRaid:ActiveDevices
*/
p = g_ptr_array_new ();
- md_dir_name = g_strdup_printf ("%s/md", g_udev_device_get_sysfs_path (raid_device));
+ md_dir_name = g_strdup_printf ("%s/md", g_udev_device_get_sysfs_path (raid_device->udev_device));
md_dir = g_dir_open (md_dir_name, 0, NULL);
if (md_dir != NULL)
{
}
snprintf (buf, sizeof (buf), "md/%s/state", file_name);
- member_state = read_sysfs_attr (raid_device, buf);
+ member_state = read_sysfs_attr (raid_device->udev_device, buf);
if (member_state != NULL)
{
g_strstrip (member_state);
}
snprintf (buf, sizeof (buf), "md/%s/slot", file_name);
- member_slot = read_sysfs_attr (raid_device, buf);
+ member_slot = read_sysfs_attr (raid_device->udev_device, buf);
if (member_slot != NULL)
{
g_strstrip (member_slot);
}
snprintf (buf, sizeof (buf), "md/%s/errors", file_name);
- member_errors = read_sysfs_attr_as_uint64 (raid_device, buf);
+ member_errors = read_sysfs_attr_as_uint64 (raid_device->udev_device, buf);
g_ptr_array_add (p,
g_variant_new ("(oi^asta{sv})",
const gchar *message;
uid_t caller_uid;
gid_t caller_gid;
- GUdevDevice *raid_device = NULL;
+ UDisksLinuxDevice *raid_device = NULL;
GString *str = NULL;
gchar *raid_device_file = NULL;
gchar *escaped_devices = NULL;
str = g_string_new (NULL);
for (l = member_devices; l != NULL; l = l->next)
{
- GUdevDevice *device = G_UDEV_DEVICE (l->data);
+ UDisksLinuxDevice *device = UDISKS_LINUX_DEVICE (l->data);
gchar *escaped_device_file;
if (str->len > 0)
g_string_append_c (str, ' ');
- escaped_device_file = udisks_daemon_util_escape_and_quote (g_udev_device_get_device_file (device));
+ escaped_device_file = udisks_daemon_util_escape_and_quote (g_udev_device_get_device_file (device->udev_device));
g_string_append (str, escaped_device_file);
g_free (escaped_device_file);
}
const gchar *message;
uid_t caller_uid;
gid_t caller_gid;
- GUdevDevice *raid_device = NULL;
+ UDisksLinuxDevice *raid_device = NULL;
const gchar *device_file = NULL;
gchar *escaped_device_file = NULL;
GError *error = NULL;
invocation))
goto out;
- device_file = g_udev_device_get_device_file (raid_device);
- escaped_device_file = udisks_daemon_util_escape_and_quote (g_udev_device_get_device_file (raid_device));
+ device_file = g_udev_device_get_device_file (raid_device->udev_device);
+ escaped_device_file = udisks_daemon_util_escape_and_quote (g_udev_device_get_device_file (raid_device->udev_device));
if (!udisks_daemon_launch_spawned_job_sync (daemon,
UDISKS_OBJECT (object),
const gchar *message;
uid_t caller_uid;
gid_t caller_gid;
- GUdevDevice *raid_device = NULL;
+ UDisksLinuxDevice *raid_device = NULL;
const gchar *device_file = NULL;
gchar *escaped_device_file = NULL;
const gchar *member_device_file = NULL;
invocation))
goto out;
- device_file = g_udev_device_get_device_file (raid_device);
+ device_file = g_udev_device_get_device_file (raid_device->udev_device);
escaped_device_file = udisks_daemon_util_escape_and_quote (device_file);
member_device_file = udisks_block_get_device (member_device);
#include "udiskslinuxmdraidobject.h"
#include "udiskslinuxmdraid.h"
#include "udiskslinuxblockobject.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxmdraidobject
/* The UUID for the object */
gchar *uuid;
- /* The GUdevDevice for the RAID device (e.g. /dev/md0), if any */
- GUdevDevice *raid_device;
+ /* The UDisksLinuxDevice for the RAID device (e.g. /dev/md0), if any */
+ UDisksLinuxDevice *raid_device;
- /* list of GUdevDevice objects for detected member devices */
+ /* list of UDisksLinuxDevice objects for detected member devices */
GList *member_devices;
/* interfaces */
* udisks_linux_mdraid_object_get_members:
* @object: A #UDisksLinuxMDRaidObject.
*
- * Gets the current #GUdevDevice objects for the RAID members associated with @object.
+ * Gets the current #UDisksLinuxDevice objects for the RAID members associated with @object.
*
- * Returns: A list of #GUdevDevice objects. Free each element with
+ * Returns: A list of #UDisksLinuxDevice objects. Free each element with
* g_object_unref(), then free the list with g_list_free().
*/
GList *
* udisks_linux_mdraid_object_get_device:
* @object: A #UDisksLinuxMDRaidObject.
*
- * Gets the current #GUdevDevice object for the RAID device
+ * Gets the current #UDisksLinuxDevice object for the RAID device
* (e.g. /dev/md0) associated with @object, if any.
*
- * Returns: (transfer full): A #GUdevDevice or %NULL. Free with g_object_unref().
+ * Returns: (transfer full): A #UDisksLinuxDevice or %NULL. Free with g_object_unref().
*/
-GUdevDevice *
+UDisksLinuxDevice *
udisks_linux_mdraid_object_get_device (UDisksLinuxMDRaidObject *object)
{
- GUdevDevice *ret = NULL;
+ UDisksLinuxDevice *ret = NULL;
g_return_val_if_fail (UDISKS_IS_LINUX_MDRAID_OBJECT (object), NULL);
for (l = object->member_devices; l != NULL; l = l->next)
{
- GUdevDevice *device = G_UDEV_DEVICE (l->data);
- if (g_strcmp0 (g_udev_device_get_sysfs_path (device), sysfs_path) == 0)
+ UDisksLinuxDevice *device = UDISKS_LINUX_DEVICE (l->data);
+ if (g_strcmp0 (g_udev_device_get_sysfs_path (device->udev_device), sysfs_path) == 0)
{
ret = l;
goto out;
/* ---------------------------------------------------------------------------------------------------- */
static GSource *
-watch_attr (GUdevDevice *device,
- const gchar *attr,
- GSourceFunc callback,
- gpointer user_data)
+watch_attr (UDisksLinuxDevice *device,
+ const gchar *attr,
+ GSourceFunc callback,
+ gpointer user_data)
{
GError *error = NULL;
gchar *path = NULL;
GIOChannel *channel = NULL;
GSource *ret = NULL;;
- g_return_val_if_fail (G_UDEV_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (UDISKS_IS_LINUX_DEVICE (device), NULL);
- path = g_strdup_printf ("%s/%s", g_udev_device_get_sysfs_path (device), attr);
+ path = g_strdup_printf ("%s/%s", g_udev_device_get_sysfs_path (device->udev_device), attr);
channel = g_io_channel_new_file (path, "r", &error);
if (channel != NULL)
{
static void
raid_device_added (UDisksLinuxMDRaidObject *object,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
g_assert (object->sync_action_source == NULL);
g_assert (object->degraded_source == NULL);
- /* udisks_debug ("start watching %s", g_udev_device_get_sysfs_path (device)); */
+ /* udisks_debug ("start watching %s", g_udev_device_get_sysfs_path (device->udev_device)); */
object->sync_action_source = watch_attr (device,
"md/sync_action",
(GSourceFunc) attr_changed,
static void
raid_device_removed (UDisksLinuxMDRaidObject *object,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
- /* udisks_debug ("stop watching %s", g_udev_device_get_sysfs_path (device)); */
+ /* udisks_debug ("stop watching %s", g_udev_device_get_sysfs_path (device->udev_device)); */
remove_watches (object);
}
* udisks_linux_mdraid_object_uevent:
* @object: A #UDisksLinuxMDRaidObject.
* @action: Uevent action or %NULL
- * @device: A #GUdevDevice device object or %NULL if the device hasn't changed.
+ * @device: A #UDisksLinuxDevice device object or %NULL if the device hasn't changed.
* @is_member: %TRUE if @device is a member, %FALSE if it's the raid device.
*
* Updates all information on interfaces on @mdraid.
void
udisks_linux_mdraid_object_uevent (UDisksLinuxMDRaidObject *object,
const gchar *action,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
gboolean is_member)
{
gboolean conf_changed = FALSE;
g_return_if_fail (UDISKS_IS_LINUX_MDRAID_OBJECT (object));
- g_return_if_fail (G_UDEV_IS_DEVICE (device));
+ g_return_if_fail (UDISKS_IS_LINUX_DEVICE (device));
- /* udisks_debug ("is_member=%d for uuid %s and device %s", is_member, object->uuid, g_udev_device_get_device_file (device)); */
+ /* udisks_debug ("is_member=%d for uuid %s and device %s", is_member, object->uuid, g_udev_device_get_device_file (device->udev_device)); */
if (is_member)
{
GList *link = NULL;
link = NULL;
if (device != NULL)
- link = find_link_for_sysfs_path_for_member (object, g_udev_device_get_sysfs_path (device));
+ link = find_link_for_sysfs_path_for_member (object, g_udev_device_get_sysfs_path (device->udev_device));
if (g_strcmp0 (action, "remove") == 0)
{
if (link != NULL)
{
- g_object_unref (G_UDEV_DEVICE (link->data));
+ g_object_unref (UDISKS_LINUX_DEVICE (link->data));
object->member_devices = g_list_delete_link (object->member_devices, link);
}
else
{
udisks_warning ("MDRaid with UUID %s doesn't have member device with sysfs path %s on remove event",
object->uuid,
- g_udev_device_get_sysfs_path (device));
+ g_udev_device_get_sysfs_path (device->udev_device));
}
}
else
{
if (device != link->data)
{
- g_object_unref (G_UDEV_DEVICE (link->data));
+ g_object_unref (UDISKS_LINUX_DEVICE (link->data));
link->data = g_object_ref (device);
}
}
else
{
/* Skip partitions of raid devices */
- if (g_strcmp0 (g_udev_device_get_devtype (device), "disk") != 0)
+ if (g_strcmp0 (g_udev_device_get_devtype (device->udev_device), "disk") != 0)
goto out;
if (g_strcmp0 (action, "remove") == 0)
{
if (object->raid_device != NULL)
- if (g_strcmp0 (g_udev_device_get_sysfs_path (object->raid_device),
- g_udev_device_get_sysfs_path (device)) == 0)
+ if (g_strcmp0 (g_udev_device_get_sysfs_path (object->raid_device->udev_device),
+ g_udev_device_get_sysfs_path (device->udev_device)) == 0)
{
g_clear_object (&object->raid_device);
raid_device_removed (object, object->raid_device);
{
udisks_warning ("MDRaid with UUID %s doesn't have raid device with sysfs path %s on remove event (it has %s)",
object->uuid,
- g_udev_device_get_sysfs_path (device),
- g_udev_device_get_sysfs_path (object->raid_device));
+ g_udev_device_get_sysfs_path (device->udev_device),
+ g_udev_device_get_sysfs_path (object->raid_device->udev_device));
}
else
{
udisks_warning ("MDRaid with UUID %s doesn't have raid device with sysfs path %s on remove event",
object->uuid,
- g_udev_device_get_sysfs_path (device));
+ g_udev_device_get_sysfs_path (device->udev_device));
}
}
else
const gchar *uuid);
void udisks_linux_mdraid_object_uevent (UDisksLinuxMDRaidObject *object,
const gchar *action,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
gboolean is_member);
const gchar *udisks_linux_mdraid_object_get_uuid (UDisksLinuxMDRaidObject *object);
UDisksDaemon *udisks_linux_mdraid_object_get_daemon (UDisksLinuxMDRaidObject *object);
GList *udisks_linux_mdraid_object_get_members (UDisksLinuxMDRaidObject *object);
-GUdevDevice *udisks_linux_mdraid_object_get_device (UDisksLinuxMDRaidObject *object);
+UDisksLinuxDevice *udisks_linux_mdraid_object_get_device (UDisksLinuxMDRaidObject *object);
gboolean udisks_linux_mdraid_object_have_devices (UDisksLinuxMDRaidObject *object);
#include "udisksdaemon.h"
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxpartition
UDisksLinuxBlockObject *object)
{
UDisksObject *disk_block_object = NULL;
- GUdevDevice *device = NULL;
+ UDisksLinuxDevice *device = NULL;
guint number = 0;
const gchar *type = NULL;
gchar type_buf[16];
gboolean is_contained = FALSE;
device = udisks_linux_block_object_get_device (object);
- if (g_udev_device_has_property (device, "ID_PART_ENTRY_TYPE"))
+ if (g_udev_device_has_property (device->udev_device, "ID_PART_ENTRY_TYPE"))
{
const gchar *disk_string;
- number = g_udev_device_get_property_as_int (device, "ID_PART_ENTRY_NUMBER");
- type = g_udev_device_get_property (device, "ID_PART_ENTRY_TYPE");
- offset = g_udev_device_get_property_as_uint64 (device, "ID_PART_ENTRY_OFFSET") * G_GUINT64_CONSTANT (512);
- size = g_udev_device_get_property_as_uint64 (device, "ID_PART_ENTRY_SIZE") * G_GUINT64_CONSTANT (512);
- name = udisks_decode_udev_string (g_udev_device_get_property (device, "ID_PART_ENTRY_NAME"));
- uuid = g_udev_device_get_property (device, "ID_PART_ENTRY_UUID");
- flags = g_udev_device_get_property_as_uint64 (device, "ID_PART_ENTRY_FLAGS");
-
- disk_string = g_udev_device_get_property (device, "ID_PART_ENTRY_DISK");
+ number = g_udev_device_get_property_as_int (device->udev_device, "ID_PART_ENTRY_NUMBER");
+ type = g_udev_device_get_property (device->udev_device, "ID_PART_ENTRY_TYPE");
+ offset = g_udev_device_get_property_as_uint64 (device->udev_device, "ID_PART_ENTRY_OFFSET") * G_GUINT64_CONSTANT (512);
+ size = g_udev_device_get_property_as_uint64 (device->udev_device, "ID_PART_ENTRY_SIZE") * G_GUINT64_CONSTANT (512);
+ name = udisks_decode_udev_string (g_udev_device_get_property (device->udev_device, "ID_PART_ENTRY_NAME"));
+ uuid = g_udev_device_get_property (device->udev_device, "ID_PART_ENTRY_UUID");
+ flags = g_udev_device_get_property_as_uint64 (device->udev_device, "ID_PART_ENTRY_FLAGS");
+
+ disk_string = g_udev_device_get_property (device->udev_device, "ID_PART_ENTRY_DISK");
if (disk_string != NULL)
{
gint disk_major, disk_minor;
}
}
- if (g_strcmp0 (g_udev_device_get_property (device, "ID_PART_ENTRY_SCHEME"), "dos") == 0)
+ if (g_strcmp0 (g_udev_device_get_property (device->udev_device, "ID_PART_ENTRY_SCHEME"), "dos") == 0)
{
char *endp;
gint type_as_int = strtol (type, &endp, 0);
else
{
GUdevDevice *parent_device;
- number = g_udev_device_get_sysfs_attr_as_int (device, "partition");
- offset = g_udev_device_get_sysfs_attr_as_uint64 (device, "start") * G_GUINT64_CONSTANT (512);
- size = g_udev_device_get_sysfs_attr_as_uint64 (device, "size") * G_GUINT64_CONSTANT (512);
- parent_device = g_udev_device_get_parent_with_subsystem (device, "block", "disk");
+ number = g_udev_device_get_sysfs_attr_as_int (device->udev_device, "partition");
+ offset = g_udev_device_get_sysfs_attr_as_uint64 (device->udev_device, "start") * G_GUINT64_CONSTANT (512);
+ size = g_udev_device_get_sysfs_attr_as_uint64 (device->udev_device, "size") * G_GUINT64_CONSTANT (512);
+ parent_device = g_udev_device_get_parent_with_subsystem (device->udev_device, "block", "disk");
if (parent_device != NULL)
{
disk_block_object = udisks_daemon_find_block (udisks_linux_block_object_get_daemon (object),
#include "udisksdaemon.h"
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxpartitiontable
UDisksLinuxBlockObject *object)
{
const gchar *type = NULL;
- GUdevDevice *device = NULL;;
+ UDisksLinuxDevice *device = NULL;;
device = udisks_linux_block_object_get_device (object);
if (device != NULL)
- type = g_udev_device_get_property (device, "ID_PART_TABLE_TYPE");
+ type = g_udev_device_get_property (device->udev_device, "ID_PART_TABLE_TYPE");
udisks_partition_table_set_type_ (UDISKS_PARTITION_TABLE (table), type);
#include "udiskslinuxmdraidobject.h"
#include "udiskslinuxmanager.h"
#include "udiskscleanup.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxprovider
UDisksProvider parent_instance;
GUdevClient *gudev_client;
+ GAsyncQueue *probe_request_queue;
+ GThread *probe_request_thread;
UDisksObjectSkeleton *manager_object;
static void udisks_linux_provider_handle_uevent (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device);
+ UDisksLinuxDevice *device);
static gboolean on_housekeeping_timeout (gpointer user_data);
GFileMonitorEvent event_type,
gpointer user_data);
+gpointer probe_request_thread_func (gpointer user_data);
+
G_DEFINE_TYPE (UDisksLinuxProvider, udisks_linux_provider, UDISKS_TYPE_PROVIDER);
static void
UDisksLinuxProvider *provider = UDISKS_LINUX_PROVIDER (object);
UDisksDaemon *daemon;
+ /* stop the request thread and wait for it */
+ g_async_queue_push (provider->probe_request_queue, (gpointer) 0xdeadbeef);
+ g_thread_join (provider->probe_request_thread);
+ g_async_queue_unref (provider->probe_request_queue);
+
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
if (provider->etc_udisks2_dir_monitor != NULL)
G_OBJECT_CLASS (udisks_linux_provider_parent_class)->finalize (object);
}
+/* ---------------------------------------------------------------------------------------------------- */
+
+typedef struct
+{
+ UDisksLinuxProvider *provider;
+ GUdevDevice *udev_device;
+ UDisksLinuxDevice *udisks_device;
+} ProbeRequest;
+
+static void
+probe_request_free (ProbeRequest *request)
+{
+ g_clear_object (&request->provider);
+ g_clear_object (&request->udev_device);
+ g_clear_object (&request->udisks_device);
+ g_slice_free (ProbeRequest, request);
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+/* called in main thread with a processed ProbeRequest struct - see probe_request_thread_func() */
+static gboolean
+on_idle_with_probed_uevent (gpointer user_data)
+{
+ ProbeRequest *request = user_data;
+ udisks_linux_provider_handle_uevent (request->provider,
+ g_udev_device_get_action (request->udev_device),
+ request->udisks_device);
+ request->udisks_device = NULL; /* adopted */
+ probe_request_free (request);
+ return FALSE; /* remove source */
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
+gpointer
+probe_request_thread_func (gpointer user_data)
+{
+ UDisksLinuxProvider *provider = UDISKS_LINUX_PROVIDER (user_data);
+ ProbeRequest *request;
+
+ do
+ {
+ request = g_async_queue_pop (provider->probe_request_queue);
+
+ /* used by _finalize() above to stop this thread - if received, we can
+ * no longer use @provider
+ */
+ if (request == (gpointer) 0xdeadbeef)
+ goto out;
+
+ /* probe the device - this may take a while */
+ request->udisks_device = udisks_linux_device_new_sync (request->udev_device);
+
+ /* now that we've probed the device, post the request back to the main thread */
+ g_idle_add (on_idle_with_probed_uevent, request);
+ }
+ while (TRUE);
+
+ out:
+ return NULL;
+}
+
+/* ---------------------------------------------------------------------------------------------------- */
+
static void
on_uevent (GUdevClient *client,
const gchar *action,
gpointer user_data)
{
UDisksLinuxProvider *provider = UDISKS_LINUX_PROVIDER (user_data);
- //g_print ("%s:%s: entering\n", G_STRLOC, G_STRFUNC);
- udisks_linux_provider_handle_uevent (provider, action, device);
+ ProbeRequest *request;
+
+ request = g_slice_new0 (ProbeRequest);
+ request->provider = g_object_ref (provider);
+ request->udev_device = g_object_ref (device);
+
+ /* process uevent in "probing-thread" */
+ g_async_queue_push (provider->probe_request_queue, request);
}
+/* ---------------------------------------------------------------------------------------------------- */
+
static void
udisks_linux_provider_init (UDisksLinuxProvider *provider)
{
/* get ourselves an udev client */
provider->gudev_client = g_udev_client_new (subsystems);
+
g_signal_connect (provider->gudev_client,
"uevent",
G_CALLBACK (on_uevent),
provider);
+ provider->probe_request_queue = g_async_queue_new ();
+ provider->probe_request_thread = g_thread_new ("probing-thread",
+ probe_request_thread_func,
+ provider);
+
file = g_file_new_for_path (PACKAGE_SYSCONF_DIR "/udisks2");
provider->etc_udisks2_dir_monitor = g_file_monitor_directory (file,
G_FILE_MONITOR_NONE,
UDisksDaemon *daemon;
UDisksManager *manager;
GList *devices;
+ GList *udisks_devices;
GList *l;
+ guint n;
provider->coldplug = TRUE;
NULL);
devices = g_udev_client_query_by_subsystem (provider->gudev_client, "block");
+
/* make sure we process sda before sdz and sdz before sdaa */
devices = g_list_sort (devices, (GCompareFunc) udev_device_name_cmp);
+ /* probe for extra data we don't get from udev */
+ udisks_devices = NULL;
for (l = devices; l != NULL; l = l->next)
- udisks_linux_provider_handle_uevent (provider, "add", G_UDEV_DEVICE (l->data));
- for (l = devices; l != NULL; l = l->next)
- udisks_linux_provider_handle_uevent (provider, "add", G_UDEV_DEVICE (l->data));
- g_list_foreach (devices, (GFunc) g_object_unref, NULL);
- g_list_free (devices);
+ {
+ GUdevDevice *device = G_UDEV_DEVICE (l->data);
+ udisks_devices = g_list_prepend (udisks_devices, udisks_linux_device_new_sync (device));
+ }
+ udisks_devices = g_list_reverse (udisks_devices);
+ /* do two coldplug runs to handle dependencies between devices */
+ for (n = 0; n < 2; n++)
+ {
+ for (l = udisks_devices; l != NULL; l = l->next)
+ {
+ UDisksLinuxDevice *device = l->data;
+ udisks_linux_provider_handle_uevent (provider, "add", device);
+ }
+ }
+ g_list_free_full (devices, g_object_unref);
+ g_list_free_full (udisks_devices, g_object_unref);
/* schedule housekeeping for every 10 minutes */
provider->housekeeping_timeout = g_timeout_add_seconds (10*60,
provider);
}
-
static void
udisks_linux_provider_class_init (UDisksLinuxProviderClass *klass)
{
static void
handle_block_uevent_for_mdraid_with_uuid (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device,
+ UDisksLinuxDevice *device,
const gchar *uuid,
gboolean is_member)
{
const gchar *sysfs_path;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
- sysfs_path = g_udev_device_get_sysfs_path (device);
+ sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
/* if uuid is NULL or bogus, consider it a remove event */
if (uuid == NULL || g_strcmp0 (uuid, "00000000:00000000:00000000:00000000") == 0)
static void
handle_block_uevent_for_mdraid (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
const gchar *uuid;
const gchar *member_uuid;
* For removal, we also need to consider the case where there is no
* UUID.
*/
- uuid = g_udev_device_get_property (device, "MD_UUID");
- member_uuid = g_udev_device_get_property (device, "MD_MEMBER_UUID");
+ uuid = g_udev_device_get_property (device->udev_device, "MD_UUID");
+ member_uuid = g_udev_device_get_property (device->udev_device, "MD_MEMBER_UUID");
if (uuid != NULL)
handle_block_uevent_for_mdraid_with_uuid (provider, action, device, uuid, FALSE);
static void
handle_block_uevent_for_drive (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
UDisksLinuxDriveObject *object;
UDisksDaemon *daemon;
vpd = NULL;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
- sysfs_path = g_udev_device_get_sysfs_path (device);
+ sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
if (g_strcmp0 (action, "remove") == 0)
{
if (vpd == NULL)
{
udisks_debug ("Ignoring block device %s with no serial or WWN",
- g_udev_device_get_sysfs_path (device));
+ g_udev_device_get_sysfs_path (device->udev_device));
goto out;
}
object = g_hash_table_lookup (provider->vpd_to_drive, vpd);
static void
handle_block_uevent_for_block (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
const gchar *sysfs_path;
UDisksLinuxBlockObject *object;
UDisksDaemon *daemon;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
- sysfs_path = g_udev_device_get_sysfs_path (device);
+ sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
if (g_strcmp0 (action, "remove") == 0)
{
static void
handle_block_uevent (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
/* We use the sysfs block device for all of
*
}
else
{
- if (g_udev_device_get_property_as_boolean (device, "DM_UDEV_DISABLE_OTHER_RULES_FLAG"))
+ if (g_udev_device_get_property_as_boolean (device->udev_device, "DM_UDEV_DISABLE_OTHER_RULES_FLAG"))
{
/* Ignore the uevent if the device-mapper layer requests
* that other rules ignore this uevent
static void
udisks_linux_provider_handle_uevent (UDisksLinuxProvider *provider,
const gchar *action,
- GUdevDevice *device)
+ UDisksLinuxDevice *device)
{
const gchar *subsystem;
udisks_debug ("uevent %s %s",
action,
- g_udev_device_get_sysfs_path (device));
+ g_udev_device_get_sysfs_path (device->udev_device));
- subsystem = g_udev_device_get_subsystem (device);
+ subsystem = g_udev_device_get_subsystem (device->udev_device);
if (g_strcmp0 (subsystem, "block") == 0)
{
handle_block_uevent (provider, action, device);
#include "udiskscleanup.h"
#include "udisksdaemonutil.h"
#include "udisksmountmonitor.h"
+#include "udiskslinuxdevice.h"
/**
* SECTION:udiskslinuxswapspace
UDisksLinuxBlockObject *object)
{
UDisksMountMonitor *mount_monitor;
- GUdevDevice *device;
+ UDisksLinuxDevice *device;
UDisksMountType mount_type;
gboolean active;
device = udisks_linux_block_object_get_device (object);
active = FALSE;
- if (udisks_mount_monitor_is_dev_in_use (mount_monitor, g_udev_device_get_device_number (device), &mount_type) &&
+ if (udisks_mount_monitor_is_dev_in_use (mount_monitor, g_udev_device_get_device_number (device->udev_device), &mount_type) &&
mount_type == UDISKS_MOUNT_TYPE_SWAP)
active = TRUE;
udisks_swapspace_set_active (UDISKS_SWAPSPACE (swapspace), active);
projects / platform / upstream / udisks2.git / commitdiff