Debian Codegraph @

modules/lvm2/udiskslinuxmodulelvm2.c

raw
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 *
3 * Copyright (C) 2020 Tomas Bzatek <[email protected]>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 */
20
21 #include "config.h"
22
23 #include <blockdev/blockdev.h>
24 #include <blockdev/lvm.h>
25
26 #include <src/udisksdaemon.h>
27 #include <src/udiskslogging.h>
28 #include <src/udiskslinuxdevice.h>
29 #include <src/udisksmodulemanager.h>
30 #include <src/udisksmodule.h>
31 #include <src/udisksmoduleobject.h>
32
33 #include "udiskslvm2types.h"
34 #include "udiskslinuxmodulelvm2.h"
35 #include "udiskslinuxmanagerlvm2.h"
36 #include "udiskslinuxvolumegroup.h"
37 #include "udiskslinuxvolumegroupobject.h"
38 #include "jobhelpers.h"
39
40 /**
41 * SECTION:udiskslinuxmodulelvm2
42 * @title: UDisksLinuxModuleLVM2
43 * @short_description: LVM2 module.
44 *
45 * The LVM2 module.
46 */
47
48 /**
49 * UDisksLinuxModuleLVM2:
50 *
51 * The #UDisksLinuxModuleLVM2 structure contains only private data
52 * and should only be accessed using the provided API.
53 */
54 struct _UDisksLinuxModuleLVM2 {
55 UDisksModule parent_instance;
56
57 /* maps from volume group name to UDisksLinuxVolumeGroupObject instances. */
58 GHashTable *name_to_volume_group;
59
60 gint delayed_update_id;
61 gboolean coldplug_done;
62
63 guint32 update_epoch;
64 };
65
66 typedef struct _UDisksLinuxModuleLVM2Class UDisksLinuxModuleLVM2Class;
67
68 struct _UDisksLinuxModuleLVM2Class {
69 UDisksModuleClass parent_class;
70 };
71
72 static void initable_iface_init (GInitableIface *initable_iface);
73
74 G_DEFINE_TYPE_WITH_CODE (UDisksLinuxModuleLVM2, udisks_linux_module_lvm2, UDISKS_TYPE_MODULE,
75 G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, initable_iface_init));
76
77
78 static void
79 udisks_linux_module_lvm2_init (UDisksLinuxModuleLVM2 *module)
80 {
81 g_return_if_fail (UDISKS_IS_LINUX_MODULE_LVM2 (module));
82 }
83
84 static void
85 udisks_linux_module_lvm2_constructed (GObject *object)
86 {
87 UDisksLinuxModuleLVM2 *module = UDISKS_LINUX_MODULE_LVM2 (object);
88
89 module->name_to_volume_group = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);
90 module->coldplug_done = FALSE;
91 module->update_epoch = 0;
92
93 if (G_OBJECT_CLASS (udisks_linux_module_lvm2_parent_class)->constructed)
94 G_OBJECT_CLASS (udisks_linux_module_lvm2_parent_class)->constructed (object);
95 }
96
97 static void
98 udisks_linux_module_lvm2_finalize (GObject *object)
99 {
100 UDisksLinuxModuleLVM2 *module = UDISKS_LINUX_MODULE_LVM2 (object);
101
102 g_hash_table_unref (module->name_to_volume_group);
103
104 if (G_OBJECT_CLASS (udisks_linux_module_lvm2_parent_class)->finalize)
105 G_OBJECT_CLASS (udisks_linux_module_lvm2_parent_class)->finalize (object);
106 }
107
108 gchar *
109 udisks_module_id (void)
110 {
111 return g_strdup (LVM2_MODULE_NAME);
112 }
113
114 /**
115 * udisks_module_lvm2_new:
116 * @daemon: A #UDisksDaemon.
117 * @cancellable: (nullable): A #GCancellable or %NULL
118 * @error: Return location for error or %NULL.
119 *
120 * Creates new #UDisksLinuxModuleLVM2 object.
121 *
122 * Returns: (transfer full) (type UDisksLinuxModuleLVM2): A
123 * #UDisksLinuxModuleLVM2 object or %NULL if @error is set. Free
124 * with g_object_unref().
125 */
126 UDisksModule *
127 udisks_module_lvm2_new (UDisksDaemon *daemon,
128 GCancellable *cancellable,
129 GError **error)
130 {
131 GInitable *initable;
132
133 g_return_val_if_fail (UDISKS_IS_DAEMON (daemon), NULL);
134 g_return_val_if_fail (error == NULL || *error == NULL, NULL);
135
136 initable = g_initable_new (UDISKS_TYPE_LINUX_MODULE_LVM2,
137 cancellable,
138 error,
139 "daemon", daemon,
140 "name", LVM2_MODULE_NAME,
141 NULL);
142
143 if (initable == NULL)
144 return NULL;
145 else
146 return UDISKS_MODULE (initable);
147 }
148
149 /* ---------------------------------------------------------------------------------------------------- */
150
151 static gboolean
152 initable_init (GInitable *initable,
153 GCancellable *cancellable,
154 GError **error)
155 {
156 BDPluginSpec lvm_plugin = { BD_PLUGIN_LVM, "libbd_lvm.so.3" };
157 BDPluginSpec *plugins[] = { &lvm_plugin, NULL };
158
159 if (! bd_is_plugin_available (BD_PLUGIN_LVM))
160 {
161 if (! bd_reinit (plugins, FALSE, NULL, error))
162 return FALSE;
163 }
164
165 return TRUE;
166 }
167
168 static void
169 initable_iface_init (GInitableIface *initable_iface)
170 {
171 initable_iface->init = initable_init;
172 }
173
174 /* ---------------------------------------------------------------------------------------------------- */
175
176 GHashTable *
177 udisks_linux_module_lvm2_get_name_to_volume_group (UDisksLinuxModuleLVM2 *module)
178 {
179 g_return_val_if_fail (UDISKS_IS_LINUX_MODULE_LVM2 (module), NULL);
180
181 return module->name_to_volume_group;
182 }
183
184 /* transfer-none */
185 UDisksLinuxVolumeGroupObject *
186 udisks_linux_module_lvm2_find_volume_group_object (UDisksLinuxModuleLVM2 *module,
187 const gchar *name)
188 {
189 g_return_val_if_fail (UDISKS_IS_LINUX_MODULE_LVM2 (module), FALSE);
190
191 return g_hash_table_lookup (module->name_to_volume_group, name);
192 }
193
194 /* ---------------------------------------------------------------------------------------------------- */
195
196 static GDBusInterfaceSkeleton *
197 udisks_linux_module_lvm2_new_manager (UDisksModule *module)
198 {
199 UDisksLinuxManagerLVM2 *manager;
200
201 manager = udisks_linux_manager_lvm2_new (UDISKS_LINUX_MODULE_LVM2 (module));
202
203 return G_DBUS_INTERFACE_SKELETON (manager);
204 }
205
206 /* ---------------------------------------------------------------------------------------------------- */
207
208 static void
209 lvm_update_vgs (GObject *source_obj,
210 GAsyncResult *result,
211 gpointer user_data)
212 {
213 UDisksLinuxModuleLVM2 *module = UDISKS_LINUX_MODULE_LVM2 (source_obj);
214 UDisksDaemon *daemon;
215 GDBusObjectManagerServer *manager;
216
217 GTask *task = G_TASK (result);
218 GError *error = NULL;
219 VGsPVsData *data = g_task_propagate_pointer (task, &error);
220 BDLVMVGdata **vgs, **vgs_p;
221 BDLVMPVdata **pvs, **pvs_p;
222
223 GHashTableIter vg_name_iter;
224 gpointer key, value;
225 const gchar *vg_name;
226
227 if (GPOINTER_TO_UINT (user_data) != module->update_epoch)
228 {
229 vgs_pvs_data_free (data);
230 return;
231 }
232
233 if (! data)
234 {
235 if (error)
236 {
237 udisks_warning ("LVM2 plugin: %s", error->message);
238 g_clear_error (&error);
239 }
240 else
241 {
242 /* this should never happen */
243 udisks_warning ("LVM2 plugin: failure but no error when getting VGs!");
244 }
245 return;
246 }
247 vgs = data->vgs;
248 pvs = data->pvs;
249
250 /* free the data container (but not 'vgs' and 'pvs') */
251 g_free (data);
252
253 daemon = udisks_module_get_daemon (UDISKS_MODULE (module));
254 manager = udisks_daemon_get_object_manager (daemon);
255
256 /* Remove obsolete groups */
257 g_hash_table_iter_init (&vg_name_iter, module->name_to_volume_group);
258 while (g_hash_table_iter_next (&vg_name_iter, &key, &value))
259 {
260 UDisksLinuxVolumeGroupObject *group;
261 gboolean found = FALSE;
262
263 vg_name = key;
264 group = value;
265
266 for (vgs_p = vgs; !found && *vgs_p; vgs_p++)
267 found = g_strcmp0 ((*vgs_p)->name, vg_name) == 0;
268
269 if (! found)
270 {
271 udisks_linux_volume_group_object_destroy (group);
272 g_dbus_object_manager_server_unexport (manager, g_dbus_object_get_object_path (G_DBUS_OBJECT (group)));
273 g_hash_table_iter_remove (&vg_name_iter);
274 }
275 }
276
277 /* Add new groups and update existing groups */
278 for (vgs_p = vgs; *vgs_p; vgs_p++)
279 {
280 UDisksLinuxVolumeGroupObject *group;
281 GSList *vg_pvs = NULL;
282
283 vg_name = (*vgs_p)->name;
284 group = g_hash_table_lookup (module->name_to_volume_group, vg_name);
285 if (group == NULL)
286 {
287 group = udisks_linux_volume_group_object_new (module, vg_name);
288 g_hash_table_insert (module->name_to_volume_group, g_strdup (vg_name), group);
289 }
290
291 for (pvs_p = pvs; *pvs_p; pvs_p++)
292 if (g_strcmp0 ((*pvs_p)->vg_name, vg_name) == 0)
293 vg_pvs = g_slist_prepend (vg_pvs, bd_lvm_pvdata_copy (*pvs_p));
294
295 udisks_linux_volume_group_object_update (group, *vgs_p, vg_pvs);
296 }
297
298 /* UDisksLinuxVolumeGroupObject carries copies of BDLVMPVdata that belong to the VG.
299 * The rest of the PVs, either not assigned to any VG or assigned to a non-existing VG,
300 * are basically unused and freed here anyway.
301 */
302 for (pvs_p = pvs; *pvs_p; pvs_p++)
303 bd_lvm_pvdata_free (*pvs_p);
304
305 /* only free the containers, the contents were passed further */
306 g_free (vgs);
307 g_free (pvs);
308 }
309
310 static void
311 lvm_update (UDisksLinuxModuleLVM2 *module)
312 {
313 GTask *task;
314
315 module->update_epoch++;
316
317 /* the callback (lvm_update_vgs) is called in the default main loop (context) */
318 task = g_task_new (module,
319 NULL /* cancellable */,
320 lvm_update_vgs,
321 GUINT_TO_POINTER (module->update_epoch));
322
323 /* holds a reference to 'task' until it is finished */
324 g_task_run_in_thread (task, (GTaskThreadFunc) vgs_task_func);
325 g_object_unref (task);
326 }
327
328 static gboolean
329 delayed_lvm_update (gpointer user_data)
330 {
331 UDisksLinuxModuleLVM2 *module = UDISKS_LINUX_MODULE_LVM2 (user_data);
332
333 lvm_update (module);
334 module->delayed_update_id = 0;
335
336 return FALSE;
337 }
338
339 static void
340 trigger_delayed_lvm_update (UDisksLinuxModuleLVM2 *module)
341 {
342 if (module->delayed_update_id > 0)
343 return;
344
345 if (! module->coldplug_done)
346 {
347 /* Update immediately when doing coldplug, i.e. when lvm2 module has just
348 * been activated. This is not 100% effective as this affects only the
349 * first request but from the plugin nature we don't know whether
350 * coldplugging has been finished or not. Might be subject to change in
351 * the future. */
352 module->coldplug_done = TRUE;
353 lvm_update (module);
354 }
355 else
356 {
357 module->delayed_update_id = g_timeout_add (100, delayed_lvm_update, module);
358 }
359 }
360
361 static gboolean
362 is_logical_volume (UDisksLinuxDevice *device)
363 {
364 const gchar *dm_vg_name;
365
366 dm_vg_name = g_udev_device_get_property (device->udev_device, "DM_VG_NAME");
367 return dm_vg_name && *dm_vg_name;
368 }
369
370 static gboolean
371 has_physical_volume_label (UDisksLinuxDevice *device)
372 {
373 const gchar *id_fs_type;
374
375 id_fs_type = g_udev_device_get_property (device->udev_device, "ID_FS_TYPE");
376 return g_strcmp0 (id_fs_type, "LVM2_member") == 0;
377 }
378
379 static gboolean
380 is_recorded_as_physical_volume (UDisksLinuxModuleLVM2 *module,
381 UDisksLinuxDevice *device)
382 {
383 UDisksDaemon *daemon;
384 UDisksObject *object;
385 gboolean ret;
386
387 daemon = udisks_module_get_daemon (UDISKS_MODULE (module));
388 object = udisks_daemon_find_block (daemon, g_udev_device_get_device_number (device->udev_device));
389 ret = object && udisks_object_peek_physical_volume (object) != NULL;
390
391 g_clear_object (&object);
392 return ret;
393 }
394
395 static void
396 udisks_linux_module_lvm2_handle_uevent (UDisksModule *module,
397 UDisksLinuxDevice *device)
398 {
399 g_return_if_fail (UDISKS_IS_LINUX_MODULE_LVM2 (module));
400
401 if (is_logical_volume (device)
402 || has_physical_volume_label (device)
403 || is_recorded_as_physical_volume (UDISKS_LINUX_MODULE_LVM2 (module), device))
404 trigger_delayed_lvm_update (UDISKS_LINUX_MODULE_LVM2 (module));
405 }
406
407 /* ---------------------------------------------------------------------------------------------------- */
408
409 static gchar *
410 udisks_linux_module_lvm2_track_parent (UDisksModule *module,
411 const gchar *path,
412 gchar **uuid)
413 {
414 UDisksDaemon *daemon;
415 UDisksObject *object;
416 UDisksObject *lvol_object = NULL;
417 UDisksBlockLVM2 *block_lvm2;
418 UDisksLogicalVolume *lvol;
419 const gchar *parent_path = NULL;
420 const gchar *parent_uuid = NULL;
421
422 g_return_val_if_fail (UDISKS_IS_LINUX_MODULE_LVM2 (module), NULL);
423
424 daemon = udisks_module_get_daemon (module);
425 object = udisks_daemon_find_object (daemon, path);
426 if (object == NULL)
427 goto out;
428
429 block_lvm2 = udisks_object_peek_block_lvm2 (object);
430 if (block_lvm2)
431 {
432 lvol_object = udisks_daemon_find_object (daemon, udisks_block_lvm2_get_logical_volume (block_lvm2));
433 if (lvol_object)
434 {
435 lvol = udisks_object_peek_logical_volume (lvol_object);
436 if (lvol)
437 {
438 parent_uuid = udisks_logical_volume_get_uuid (lvol);
439 parent_path = udisks_block_lvm2_get_logical_volume (block_lvm2);
440 goto out;
441 }
442 }
443 }
444
445 out:
446 g_clear_object (&lvol_object);
447 g_clear_object (&object);
448 if (uuid)
449 *uuid = g_strdup (parent_uuid);
450 return g_strdup (parent_path);
451 }
452
453 /* ---------------------------------------------------------------------------------------------------- */
454
455 static void
456 udisks_linux_module_lvm2_class_init (UDisksLinuxModuleLVM2Class *klass)
457 {
458 GObjectClass *gobject_class;
459 UDisksModuleClass *module_class;
460
461 gobject_class = G_OBJECT_CLASS (klass);
462 gobject_class->constructed = udisks_linux_module_lvm2_constructed;
463 gobject_class->finalize = udisks_linux_module_lvm2_finalize;
464
465 module_class = UDISKS_MODULE_CLASS (klass);
466 module_class->new_manager = udisks_linux_module_lvm2_new_manager;
467 module_class->handle_uevent = udisks_linux_module_lvm2_handle_uevent;
468 module_class->track_parent = udisks_linux_module_lvm2_track_parent;
469 }