static gboolean
cleanup_logical_volume_walker (GDBusObjectManager *objman,
LvmLogicalVolume *logical_volume,
gpointer user_data,
GError **error)
{
StorageProvider *provider = user_data;
UDisksBlock *block = lvm_util_peek_block_for_logical_volume (storage_provider_get_lvm_object_manager (provider),
storage_provider_get_udisks_client (provider),
logical_volume);
if (block)
{
/* The logical volume is active, let's clean it up by walking
the tree of block devices hanging off of it.
*/
return cleanup_block (provider, block, error);
}
else
{
/* The logical volume is inactive, let's clean it up by removing
the remembered configs from its children.
*/
LvmObject *object = LVM_OBJECT (g_dbus_interface_get_object (G_DBUS_INTERFACE (logical_volume)));
GList *remembered_configs = storage_provider_get_and_forget_remembered_configs
(provider, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
for (GList *l = remembered_configs; l; l = l->next)
{
GVariant *config = l->data;
storage_remove_config (provider, NULL, config);
}
g_list_free_full (remembered_configs, (GDestroyNotify)g_variant_unref);
return TRUE;
}
}
static gboolean
walk_block_parents (UDisksClient *client,
GDBusObjectManager *objman,
UDisksBlock *block,
ObjectWalker *walker,
gpointer user_data,
GError **error)
{
/* Parents are
- of a block that is a logical volume, the logical volume object
- of a clear text device, the encrypted device.
XXX - support the whole tree.
*/
while (block)
{
const gchar *path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (block));
LvmLogicalVolumeBlock *lvm_block =
LVM_LOGICAL_VOLUME_BLOCK (g_dbus_object_manager_get_interface (objman, path,
"com.redhat.lvm2.LogicalVolumeBlock"));
const gchar *logical_volume_path =
(lvm_block ? lvm_logical_volume_block_get_logical_volume (lvm_block) : "/");
const gchar *crypto_path = udisks_block_get_crypto_backing_device (block);
if (g_strcmp0 (logical_volume_path, "/") != 0)
{
gs_unref_object LvmObject *logical_volume_object =
LVM_OBJECT (g_dbus_object_manager_get_object (objman, logical_volume_path));
if (logical_volume_object)
{
if (!walker (client, G_DBUS_OBJECT (logical_volume_object), user_data, error))
return FALSE;
}
block = NULL;
}
else if (g_strcmp0 (crypto_path, "/") != 0)
{
UDisksObject *crypto_object = udisks_client_peek_object (client, crypto_path);
if (crypto_object)
{
if (!walker (client, G_DBUS_OBJECT (crypto_object), user_data, error))
return FALSE;
}
block = udisks_object_peek_block (crypto_object);
}
else
block = NULL;
}
return TRUE;
}
const gchar *
storage_provider_translate_path (StorageProvider *provider,
const gchar *udisks_or_lvm_path)
{
StorageObject *object = NULL;
if (udisks_or_lvm_path == NULL)
udisks_or_lvm_path = "/";
gs_unref_object UDisksObject *udisks_object = udisks_client_get_object (provider->udisks_client,
udisks_or_lvm_path);
if (udisks_object != NULL)
{
UDisksDrive *udisks_drive = udisks_object_peek_drive (udisks_object);
if (udisks_drive != NULL)
object = storage_provider_lookup_for_udisks_drive (provider, udisks_drive);
UDisksBlock *udisks_block = udisks_object_peek_block (udisks_object);
if (udisks_block != NULL)
object = storage_provider_lookup_for_udisks_block (provider, udisks_block);
UDisksMDRaid *udisks_raid = udisks_object_peek_mdraid (udisks_object);
if (udisks_raid != NULL)
object = storage_provider_lookup_for_udisks_mdraid (provider, udisks_raid);
}
gs_unref_object LvmObject *lvm_object = LVM_OBJECT (g_dbus_object_manager_get_object (provider->lvm_objman,
udisks_or_lvm_path));
if (lvm_object)
{
LvmVolumeGroup *lvm_volume_group = lvm_object_peek_volume_group (lvm_object);
if (lvm_volume_group != NULL)
object = storage_provider_lookup_for_lvm_volume_group (provider, lvm_volume_group);
LvmLogicalVolume *lvm_logical_volume = lvm_object_peek_logical_volume (lvm_object);
if (lvm_logical_volume != NULL)
object = storage_provider_lookup_for_lvm_logical_volume (provider, lvm_logical_volume);
}
if (object != NULL)
{
// g_debug ("%s -> %s", udisks_or_lvm_path, g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
return g_dbus_object_get_object_path (G_DBUS_OBJECT (object));
}
else
{
// g_debug ("%s -> nothing", udisks_or_lvm_path);
return "/";
}
}
void
storage_block_update (StorageBlock *block)
{
CockpitStorageBlock *iface = COCKPIT_STORAGE_BLOCK (block);
StorageProvider *provider;
UDisksClient *udisks_client;
UDisksObject *udisks_object;
UDisksBlock *udisks_block;
UDisksPartition *udisks_partition = NULL;
UDisksPartitionTable *udisks_partition_table = NULL;
UDisksFilesystem *udisks_filesystem = NULL;
provider = storage_object_get_provider (block->object);
udisks_client = storage_provider_get_udisks_client (provider);
udisks_block = block->udisks_block;
udisks_object = (UDisksObject *)g_dbus_interface_get_object (G_DBUS_INTERFACE (udisks_block));
if (udisks_object != NULL)
{
udisks_partition = udisks_object_peek_partition (udisks_object);
udisks_partition_table = udisks_object_peek_partition_table (udisks_object);
udisks_filesystem = udisks_object_peek_filesystem (udisks_object);
}
{
gs_free gchar *d =
g_filename_display_name (udisks_block_get_preferred_device (udisks_block));
cockpit_storage_block_set_device (iface, d);
}
cockpit_storage_block_set_size (iface, udisks_block_get_size (udisks_block));
cockpit_storage_block_set_id_usage (iface, udisks_block_get_id_usage (udisks_block));
cockpit_storage_block_set_id_type (iface, udisks_block_get_id_type (udisks_block));
cockpit_storage_block_set_id_version (iface, udisks_block_get_id_version (udisks_block));
cockpit_storage_block_set_id_label (iface, udisks_block_get_id_label (udisks_block));
cockpit_storage_block_set_id_uuid (iface, udisks_block_get_id_uuid (udisks_block));
cockpit_storage_block_set_hint_ignore (iface, udisks_block_get_hint_ignore (udisks_block));
if (udisks_partition == NULL)
{
cockpit_storage_block_set_partition_number (iface, 0);
cockpit_storage_block_set_partition_table (iface, "/");
}
else
{
UDisksPartitionTable *table_for_partition;
const gchar *objpath = "/";
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
table_for_partition = udisks_client_get_partition_table (udisks_client, udisks_partition);
if (table_for_partition != NULL)
{
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (table_for_partition));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
objpath = g_dbus_object_get_object_path (G_DBUS_OBJECT (so));
}
}
}
}
cockpit_storage_block_set_partition_table (iface, objpath);
cockpit_storage_block_set_partition_number (iface, udisks_partition_get_number (udisks_partition));
}
GVariantBuilder partitions;
g_variant_builder_init (&partitions, G_VARIANT_TYPE ("a(otts)"));
if (udisks_partition_table != NULL)
{
GList *ps, *l;
ps = udisks_client_get_partitions (udisks_client, udisks_partition_table);
for (l = ps; l != NULL; l = l->next)
{
UDisksPartition *p = UDISKS_PARTITION (l->data);
GDBusObject *o;
UDisksBlock *b;
StorageObject *so;
o = g_dbus_interface_get_object (G_DBUS_INTERFACE (p));
if (o != NULL)
{
b = udisks_object_peek_block (UDISKS_OBJECT (o));
if (b != NULL)
{
so = storage_provider_lookup_for_udisks_block (provider, b);
if (so != NULL)
{
const gchar *type = "p";
if (udisks_partition_get_is_container (p))
type = "x";
else if (udisks_partition_get_is_contained (p))
type = "l";
g_variant_builder_add (&partitions, "(otts)",
g_dbus_object_get_object_path (G_DBUS_OBJECT (so)),
udisks_partition_get_offset (p),
udisks_partition_get_size (p),
type);
}
}
}
}
g_list_free_full (ps, g_object_unref);
const gchar *type = udisks_partition_table_get_type_ (udisks_partition_table);
if (type == NULL || type[0] == '\0')
type = "unknown";
cockpit_storage_block_set_partition_table_type (iface, type);
}
else
cockpit_storage_block_set_partition_table_type (iface, "");
cockpit_storage_block_set_partitions (iface, g_variant_builder_end (&partitions));
cockpit_storage_block_set_drive
(iface, storage_provider_translate_path (provider, udisks_block_get_drive (udisks_block)));
cockpit_storage_block_set_crypto_backing_device
(iface, storage_provider_translate_path (provider, udisks_block_get_crypto_backing_device (udisks_block)));
cockpit_storage_block_set_mdraid
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid (udisks_block)));
cockpit_storage_block_set_mdraid_member
(iface, storage_provider_translate_path (provider, udisks_block_get_mdraid_member (udisks_block)));
if (udisks_filesystem)
{
const gchar *const *p = udisks_filesystem_get_mount_points (udisks_filesystem);
gchar *u[g_strv_length ((gchar **)p) + 1];
int i;
for (i = 0; p[i]; i++)
u[i] = g_filename_display_name (p[i]);
u[i] = NULL;
cockpit_storage_block_set_mounted_at (iface, (const gchar *const *)u);
for (i = 0; u[i]; i++)
g_free (u[i]);
}
GVariantIter iter;
g_variant_iter_init (&iter, udisks_block_get_configuration (udisks_block));
const gchar *type;
GVariant *details;
gboolean got_fstab = FALSE, got_crypttab = FALSE;
while (g_variant_iter_next (&iter, "(&s*)", &type, &details))
{
if (strcmp (type, "fstab") == 0 && !got_fstab)
{
got_fstab = TRUE;
const gchar *dir = variant_lookup (details, "dir");
if (dir)
{
gs_free gchar *dir_display = g_filename_display_name (dir);
cockpit_storage_block_set_mount_point (iface, dir_display);
}
const gchar *opts = variant_lookup (details, "opts");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_mount_options (iface, opts_locale);
else
g_warning ("Can't convert fstab options into UTF8");
}
}
else if (strcmp (type, "crypttab") == 0 && !got_crypttab)
{
got_crypttab = TRUE;
const gchar *opts = variant_lookup (details, "options");
if (opts)
{
gs_free gchar *opts_locale = g_locale_to_utf8 (opts, -1, NULL, NULL, NULL);
if (opts_locale)
cockpit_storage_block_set_crypto_options (iface, opts_locale);
else
g_warning ("Can't convert crypttab options into UTF8");
}
}
g_variant_unref (details);
}
/* Now the com.redhat.lvm2 overlays. The StorageProvider makes sure
that we are called whenever something changes about them.
*/
LvmLogicalVolumeBlock *lv = NULL;
LvmPhysicalVolumeBlock *pv = NULL;
GDBusObjectManager *objman = storage_provider_get_lvm_object_manager (provider);
GDBusObject *lvm_object =
g_dbus_object_manager_get_object (objman,
g_dbus_object_get_object_path (G_DBUS_OBJECT (udisks_object)));
if (lvm_object)
{
lv = lvm_object_peek_logical_volume_block (LVM_OBJECT (lvm_object));
pv = lvm_object_peek_physical_volume_block (LVM_OBJECT (lvm_object));
}
if (lv)
{
cockpit_storage_block_set_logical_volume
(iface,
storage_provider_translate_path
(provider,
lvm_logical_volume_block_get_logical_volume (lv)));
}
else
cockpit_storage_block_set_logical_volume (iface, "/");
if (pv)
{
cockpit_storage_block_set_pv_group
(iface,
storage_provider_translate_path (provider,
lvm_physical_volume_block_get_volume_group (pv)));
cockpit_storage_block_set_pv_size (iface,
lvm_physical_volume_block_get_size (pv));
cockpit_storage_block_set_pv_free_size (iface,
lvm_physical_volume_block_get_free_size (pv));
}
else
{
cockpit_storage_block_set_pv_group (iface, "/");
cockpit_storage_block_set_pv_size (iface, 0);
cockpit_storage_block_set_pv_free_size (iface, 0);
}
}
static void
provider_update_objects (StorageProvider *provider)
{
GDBusObjectManagerServer *object_manager;
GList *udisks_objects;
GList *lvm_objects;
GList *wanted;
GList *added, *removed;
GList *l;
object_manager = G_DBUS_OBJECT_MANAGER_SERVER (daemon_get_object_manager (provider->daemon));
udisks_objects = g_dbus_object_manager_get_objects (udisks_client_get_object_manager (provider->udisks_client));
lvm_objects = g_dbus_object_manager_get_objects (provider->lvm_objman);
wanted = NULL;
for (l = udisks_objects; l != NULL; l = l->next)
{
GDBusInterface *iface = get_udisk_iface (UDISKS_OBJECT (l->data));
if (iface == NULL)
continue;
wanted = g_list_prepend (wanted, g_object_ref (iface));
}
for (l = lvm_objects; l != NULL; l = l->next)
{
if (!LVM_IS_OBJECT (l->data))
continue;
GDBusInterface *iface = get_lvm_iface (LVM_OBJECT (l->data));
if (iface == NULL)
continue;
wanted = g_list_prepend (wanted, g_object_ref (iface));
}
wanted = g_list_sort (wanted, (GCompareFunc)udisks_iface_compare_func);
provider->ifaces = g_list_sort (provider->ifaces, (GCompareFunc)udisks_iface_compare_func);
diff_sorted_lists (provider->ifaces, wanted, (GCompareFunc)udisks_iface_compare_func,
&added, &removed, NULL);
for (l = removed; l != NULL; l = l->next)
{
GDBusInterface *iface = G_DBUS_INTERFACE (l->data);
StorageObject *object;
object = g_hash_table_lookup (provider->hash_interface_to_storage_object, iface);
g_warn_if_fail (object != NULL);
if (object)
{
g_warn_if_fail (g_dbus_object_manager_server_unexport (object_manager,
g_dbus_object_get_object_path (G_DBUS_OBJECT (object))));
}
g_hash_table_remove (provider->hash_interface_to_storage_object, iface);
provider->ifaces = g_list_remove (provider->ifaces, iface);
g_object_unref (iface);
}
for (l = added; l != NULL; l = l->next)
{
GDBusInterface *iface = G_DBUS_INTERFACE (l->data);
StorageObject *object = make_storage_object (provider, iface);
g_warn_if_fail (g_hash_table_lookup (provider->hash_interface_to_storage_object, iface) == NULL);
g_hash_table_insert (provider->hash_interface_to_storage_object,
g_object_ref (iface),
object);
gs_free gchar *object_path = storage_object_make_object_path (object);
g_dbus_object_skeleton_set_object_path (G_DBUS_OBJECT_SKELETON (object), object_path);
g_dbus_object_manager_server_export_uniquely (object_manager, G_DBUS_OBJECT_SKELETON (object));
provider->ifaces = g_list_prepend (provider->ifaces, g_object_ref (iface));
}
g_list_free (added);
g_list_free (removed);
g_list_free_full (udisks_objects, g_object_unref);
g_list_free_full (lvm_objects, g_object_unref);
g_list_free_full (wanted, g_object_unref);
}
