void storage_block_update_pv (StorageBlock *self, StorageVolumeGroup *group, GVariant *pv_info) { StorageDaemon *daemon; g_return_if_fail (STORAGE_IS_BLOCK (self)); daemon = storage_daemon_get (); if (group) { if (self->iface_physical_volume == NULL) { self->iface_physical_volume = storage_physical_volume_new (); storage_physical_volume_update (self->iface_physical_volume, group, pv_info); storage_daemon_publish (daemon, storage_block_get_object_path (self), FALSE, self->iface_physical_volume); } else { storage_physical_volume_update (self->iface_physical_volume, group, pv_info); } } else { if (self->iface_physical_volume != NULL) { storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_physical_volume); g_object_unref (self->iface_physical_volume); self->iface_physical_volume = NULL; } } }
static void on_manager_ready (GObject *source, GAsyncResult *res, gpointer user_data) { StorageDaemon *self = user_data; self->manager = storage_manager_new_finish (source, res); storage_daemon_publish (self, "/org/freedesktop/UDisks2/Manager", FALSE, self->manager); self->name_owner_id = g_bus_own_name_on_connection (self->connection, "com.redhat.storaged", self->name_flags, on_name_acquired, on_name_lost, self, NULL); }
void storage_block_update_lv (StorageBlock *self, StorageLogicalVolume *lv) { const gchar *logical_volume_path; StorageDaemon *daemon; g_return_if_fail (STORAGE_IS_BLOCK (self)); daemon = storage_daemon_get (); if (lv == NULL) { if (self->iface_logical_volume) { storage_daemon_unpublish (daemon, storage_block_get_object_path (self), self->iface_logical_volume); g_object_unref (self->iface_logical_volume); self->iface_logical_volume = NULL; } } else { logical_volume_path = storage_logical_volume_get_object_path (lv); if (self->iface_logical_volume) { lvm_logical_volume_block_set_logical_volume (self->iface_logical_volume, logical_volume_path); } else { self->iface_logical_volume = lvm_logical_volume_block_skeleton_new (); lvm_logical_volume_block_set_logical_volume (self->iface_logical_volume, logical_volume_path); storage_daemon_publish (daemon, storage_block_get_object_path (self), FALSE, self->iface_logical_volume); } } }
static void update_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { struct UpdateData *data = user_data; StorageVolumeGroup *self = data->self; GVariantIter *iter; GHashTableIter volume_iter; gpointer key, value; GHashTable *new_lvs; gboolean needs_polling = FALSE; StorageDaemon *daemon; gchar *path; daemon = storage_daemon_get (); if (!error) volume_group_update_props (self, info, &needs_polling); /* After basic props, publish group, if not already done */ if (self->need_publish) { self->need_publish = FALSE; path = storage_util_build_object_path ("/org/freedesktop/UDisks2/lvm", storage_volume_group_get_name (self), NULL); storage_daemon_publish (daemon, path, FALSE, self); g_free (path); } if (error) { g_message ("Failed to update LVM volume group %s: %s", storage_volume_group_get_name (self), error->message); g_object_unref (self); return; } if (self->info && g_variant_equal (self->info, info)) { g_debug ("%s updated without changes", self->name); g_object_unref (self); return; } if (self->info) g_variant_unref (self->info); self->info = g_variant_ref (info); new_lvs = g_hash_table_new (g_str_hash, g_str_equal); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StorageLogicalVolume *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (name, lv_info, &needs_polling); if (lv_is_pvmove_volume (name)) needs_polling = TRUE; if (!lv_is_visible (name)) continue; volume = g_hash_table_lookup (self->logical_volumes, name); if (volume == NULL) { volume = storage_logical_volume_new (self, name); storage_logical_volume_update (volume, self, lv_info, &needs_polling); g_hash_table_insert (self->logical_volumes, g_strdup (name), g_object_ref (volume)); } else storage_logical_volume_update (volume, self, lv_info, &needs_polling); g_hash_table_insert (new_lvs, (gchar *)name, volume); } g_variant_iter_free (iter); } g_hash_table_iter_init (&volume_iter, self->logical_volumes); while (g_hash_table_iter_next (&volume_iter, &key, &value)) { const gchar *name = key; StorageLogicalVolume *volume = value; if (!g_hash_table_contains (new_lvs, name)) { /* Volume unpublishes itself */ g_object_run_dispose (G_OBJECT (volume)); g_hash_table_iter_remove (&volume_iter); } } lvm_volume_group_set_needs_polling (LVM_VOLUME_GROUP (self), needs_polling); /* Update physical volumes. */ g_hash_table_remove_all (self->physical_volumes); if (g_variant_lookup (info, "pvs", "aa{sv}", &iter)) { const gchar *name; GVariant *pv_info; while (g_variant_iter_next (iter, "@a{sv}", &pv_info)) { if (g_variant_lookup (pv_info, "device", "&s", &name)) g_hash_table_insert (self->physical_volumes, g_strdup (name), pv_info); else g_variant_unref (pv_info); } } /* Make sure above is published before updating blocks to point at volume group */ update_all_blocks (self); if (data->done) data->done (self, data->done_user_data); g_hash_table_destroy (new_lvs); g_object_unref (self); g_free (data); }