Debian Codegraph @

modules/lsm/lsm_linux_drive.c

raw
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 *
3 * Copyright (C) 2015 Gris Ge <[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 <sys/types.h>
24
25 #include <pwd.h>
26 #include <grp.h>
27 #include <string.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <glib.h>
31 #include <libstoragemgmt/libstoragemgmt.h>
32
33 #include <src/udiskslogging.h>
34 #include <src/udiskslinuxdriveobject.h>
35 #include <src/udiskslinuxblockobject.h>
36 #include <src/udisksdaemon.h>
37 #include <src/udisksdaemonutil.h>
38 #include <src/udisksbasejob.h>
39 #include <src/udiskssimplejob.h>
40 #include <src/udisksthreadedjob.h>
41 #include <src/udiskslinuxdevice.h>
42 #include <src/udisksmodule.h>
43 #include <src/udisksmoduleobject.h>
44
45 #include "lsm_linux_drive.h"
46 #include "lsm_data.h"
47 #include "lsm_types.h"
48
49 typedef struct _UDisksLinuxDriveLSMClass UDisksLinuxDriveLSMClass;
50
51 struct _UDisksLinuxDriveLSM
52 {
53 UDisksDriveLSMSkeleton parent_instance;
54
55 UDisksLinuxModuleLSM *module;
56 UDisksLinuxDriveObject *drive_object;
57 struct StdLsmVolData *old_lsm_data;
58 gchar *vpd83;
59 guint timeout_id;
60 };
61
62 struct _UDisksLinuxDriveLSMClass
63 {
64 UDisksDriveLSMSkeletonClass parent_class;
65 };
66
67 static void udisks_linux_drive_lsm_iface_init (UDisksDriveLSMIface *iface);
68 static void udisks_linux_drive_lsm_module_object_iface_init (UDisksModuleObjectIface *iface);
69
70 G_DEFINE_TYPE_WITH_CODE (UDisksLinuxDriveLSM, udisks_linux_drive_lsm, UDISKS_TYPE_DRIVE_LSM_SKELETON,
71 G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE_LSM, udisks_linux_drive_lsm_iface_init)
72 G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MODULE_OBJECT, udisks_linux_drive_lsm_module_object_iface_init));
73
74 enum
75 {
76 PROP_0,
77 PROP_MODULE,
78 PROP_DRIVE_OBJECT,
79 N_PROPERTIES
80 };
81
82
83 static void
84 udisks_linux_drive_lsm_get_property (GObject *object,
85 guint property_id,
86 GValue *value,
87 GParamSpec *pspec)
88 {
89 UDisksLinuxDriveLSM *drive_lsm = UDISKS_LINUX_DRIVE_LSM (object);
90
91 switch (property_id)
92 {
93 case PROP_MODULE:
94 g_value_set_object (value, UDISKS_MODULE (drive_lsm->module));
95 break;
96
97 case PROP_DRIVE_OBJECT:
98 g_value_set_object (value, drive_lsm->drive_object);
99 break;
100
101 default:
102 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
103 break;
104 }
105 }
106
107 static void
108 udisks_linux_drive_lsm_set_property (GObject *object,
109 guint property_id,
110 const GValue *value,
111 GParamSpec *pspec)
112 {
113 UDisksLinuxDriveLSM *drive_lsm = UDISKS_LINUX_DRIVE_LSM (object);
114
115 switch (property_id)
116 {
117 case PROP_MODULE:
118 g_assert (drive_lsm->module == NULL);
119 drive_lsm->module = UDISKS_LINUX_MODULE_LSM (g_value_dup_object (value));
120 break;
121
122 case PROP_DRIVE_OBJECT:
123 g_assert (drive_lsm->drive_object == NULL);
124 /* we don't take reference to drive_object */
125 drive_lsm->drive_object = g_value_get_object (value);
126 break;
127
128 default:
129 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
130 break;
131 }
132 }
133
134 static void
135 udisks_linux_drive_lsm_finalize (GObject *object)
136 {
137 UDisksLinuxDriveLSM *drive_lsm = UDISKS_LINUX_DRIVE_LSM (object);
138
139 udisks_debug ("LSM: udisks_linux_drive_lsm_finalize ()");
140
141 if (drive_lsm->timeout_id)
142 g_source_remove (drive_lsm->timeout_id);
143
144 /* we don't take reference to drive_object */
145 g_object_unref (drive_lsm->module);
146 g_free (drive_lsm->vpd83);
147
148 std_lsm_vol_data_free (drive_lsm->old_lsm_data);
149
150 if (G_OBJECT_CLASS (udisks_linux_drive_lsm_parent_class)->finalize != NULL)
151 G_OBJECT_CLASS (udisks_linux_drive_lsm_parent_class)->finalize (object);
152 }
153
154
155 static void
156 udisks_linux_drive_lsm_init (UDisksLinuxDriveLSM *drive_lsm)
157 {
158 g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (drive_lsm),
159 G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);
160 }
161
162 static void
163 udisks_linux_drive_lsm_class_init (UDisksLinuxDriveLSMClass *class)
164 {
165 GObjectClass *gobject_class;
166
167 gobject_class = G_OBJECT_CLASS (class);
168 gobject_class->get_property = udisks_linux_drive_lsm_get_property;
169 gobject_class->set_property = udisks_linux_drive_lsm_set_property;
170 gobject_class->finalize = udisks_linux_drive_lsm_finalize;
171
172 /**
173 * UDisksLinuxDriveLSM:module:
174 *
175 * The #UDisksModule for the object.
176 */
177 g_object_class_install_property (gobject_class,
178 PROP_MODULE,
179 g_param_spec_object ("module",
180 "Module",
181 "The module for the object",
182 UDISKS_TYPE_MODULE,
183 G_PARAM_READABLE |
184 G_PARAM_WRITABLE |
185 G_PARAM_CONSTRUCT_ONLY |
186 G_PARAM_STATIC_STRINGS));
187 /**
188 * UDisksLinuxDriveLSM:driveobject:
189 *
190 * The #UDisksLinuxDriveObject for the object.
191 */
192 g_object_class_install_property (gobject_class,
193 PROP_DRIVE_OBJECT,
194 g_param_spec_object ("driveobject",
195 "Drive object",
196 "The drive object for the interface",
197 UDISKS_TYPE_LINUX_DRIVE_OBJECT,
198 G_PARAM_READABLE |
199 G_PARAM_WRITABLE |
200 G_PARAM_CONSTRUCT_ONLY |
201 G_PARAM_STATIC_STRINGS));
202 }
203
204 static void
205 _fill_drive_lsm (UDisksLinuxDriveLSM *drive_lsm,
206 struct StdLsmVolData *lsm_vol_data)
207 {
208 UDisksDriveLSM *std_drv_lsm = UDISKS_DRIVE_LSM (drive_lsm);
209
210 if (lsm_vol_data == NULL)
211 return;
212
213 udisks_drive_lsm_set_status_info (std_drv_lsm, lsm_vol_data->status_info);
214 udisks_drive_lsm_set_raid_type (std_drv_lsm, lsm_vol_data->raid_type);
215 udisks_drive_lsm_set_is_ok (std_drv_lsm, lsm_vol_data->is_ok);
216 udisks_drive_lsm_set_is_raid_degraded (std_drv_lsm, lsm_vol_data->is_raid_degraded);
217 udisks_drive_lsm_set_is_raid_error (std_drv_lsm, lsm_vol_data->is_raid_error);
218 udisks_drive_lsm_set_is_raid_verifying (std_drv_lsm, lsm_vol_data->is_raid_verifying);
219 udisks_drive_lsm_set_is_raid_reconstructing (std_drv_lsm, lsm_vol_data->is_raid_reconstructing);
220 udisks_drive_lsm_set_min_io_size (std_drv_lsm, lsm_vol_data->min_io_size);
221 udisks_drive_lsm_set_opt_io_size (std_drv_lsm, lsm_vol_data->opt_io_size);
222 udisks_drive_lsm_set_raid_disk_count (std_drv_lsm, lsm_vol_data->raid_disk_count);
223
224 g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (std_drv_lsm));
225 }
226
227
228 /*
229 * Compare old data and new data. Return TRUE if changed.
230 */
231 static gboolean
232 _is_std_lsm_vol_data_changed (struct StdLsmVolData *old_lsm_data,
233 struct StdLsmVolData *new_lsm_data)
234 {
235 if (old_lsm_data == NULL || new_lsm_data == NULL)
236 return TRUE;
237
238 if (strcmp (old_lsm_data->status_info, new_lsm_data->status_info) != 0 ||
239 strcmp (old_lsm_data->raid_type, new_lsm_data->raid_type) != 0 ||
240 old_lsm_data->is_ok != new_lsm_data->is_ok ||
241 old_lsm_data->is_raid_degraded != new_lsm_data->is_raid_degraded ||
242 old_lsm_data->is_raid_error != new_lsm_data->is_raid_error ||
243 old_lsm_data->is_raid_verifying != new_lsm_data->is_raid_verifying ||
244 old_lsm_data->is_raid_reconstructing != new_lsm_data->is_raid_reconstructing ||
245 old_lsm_data->min_io_size != new_lsm_data->min_io_size ||
246 old_lsm_data->opt_io_size != new_lsm_data->opt_io_size ||
247 old_lsm_data->raid_disk_count != new_lsm_data->raid_disk_count)
248 return TRUE;
249
250 return FALSE;
251 }
252
253 static gboolean
254 _on_refresh_data (UDisksLinuxDriveLSM *drive_lsm)
255 {
256 struct StdLsmVolData *new_lsm_data;
257
258 g_return_val_if_fail (UDISKS_IS_LINUX_DRIVE_LSM (drive_lsm), G_SOURCE_REMOVE);
259
260 udisks_debug ("LSM: Refreshing LSM RAID info for VPD83/WWN %s", drive_lsm->vpd83);
261
262 new_lsm_data = std_lsm_vol_data_get (drive_lsm->vpd83);
263 if (new_lsm_data == NULL)
264 {
265 udisks_debug ("LSM: Disk drive VPD83/WWN %s is not LSM managed any more", drive_lsm->vpd83);
266 return G_SOURCE_REMOVE;
267 }
268
269 if (_is_std_lsm_vol_data_changed (drive_lsm->old_lsm_data, new_lsm_data))
270 {
271 _fill_drive_lsm (drive_lsm, new_lsm_data);
272 std_lsm_vol_data_free (drive_lsm->old_lsm_data);
273 drive_lsm->old_lsm_data = new_lsm_data;
274 }
275 else
276 std_lsm_vol_data_free (new_lsm_data);
277
278 return G_SOURCE_CONTINUE;
279 }
280
281 /**
282 * udisks_linux_drive_lsm_new:
283 * @module: A #UDisksLinuxModuleLSM.
284 * @drive_object: A #UDisksLinuxDriveObject.
285 *
286 * Creates a new #UDisksLinuxDriveLSM instance.
287 *
288 * Returns: A new #UDisksLinuxDriveLSM. Free with g_object_unref().
289 */
290 UDisksLinuxDriveLSM *
291 udisks_linux_drive_lsm_new (UDisksLinuxModuleLSM *module,
292 UDisksLinuxDriveObject *drive_object)
293 {
294 g_return_val_if_fail (UDISKS_IS_LINUX_MODULE_LSM (module), NULL);
295 g_return_val_if_fail (UDISKS_IS_LINUX_DRIVE_OBJECT (drive_object), NULL);
296
297 udisks_debug ("LSM: udisks_linux_drive_lsm_new");
298
299 return g_object_new (UDISKS_TYPE_LINUX_DRIVE_LSM,
300 "module", UDISKS_MODULE (module),
301 "driveobject", drive_object,
302 NULL);
303 }
304
305 gboolean
306 udisks_linux_drive_lsm_update (UDisksLinuxDriveLSM *drive_lsm,
307 UDisksLinuxDriveObject *drive_object)
308 {
309 UDisksLinuxDevice *device;
310 const gchar *wwn = NULL;
311 gboolean rc = FALSE;
312
313 udisks_debug ("LSM: udisks_linux_drive_lsm_update");
314
315 device = udisks_linux_drive_object_get_device (drive_object, TRUE);
316 if (device == NULL)
317 {
318 udisks_debug ("LSM: udisks_linux_drive_lsm_update (): Got NULL udisks_linux_drive_object_get_device () return");
319 goto out;
320 }
321
322 wwn = g_udev_device_get_property (device->udev_device, "ID_WWN_WITH_EXTENSION");
323 if (! wwn || strlen (wwn) < 2)
324 {
325 udisks_debug ("LSM: udisks_linux_drive_lsm_update (): Got empty ID_WWN_WITH_EXTENSION dbus property");
326 goto out;
327 }
328
329 g_free (drive_lsm->vpd83);
330 drive_lsm->vpd83 = g_strdup (wwn + 2);
331
332 _on_refresh_data (drive_lsm);
333
334 /* Start polling */
335 if (drive_lsm->timeout_id == 0)
336 {
337 drive_lsm->timeout_id = g_timeout_add_seconds (std_lsm_refresh_time_get (),
338 (GSourceFunc) _on_refresh_data,
339 drive_lsm);
340 udisks_debug ("LSM: VPD83 %s added to refresh event loop", wwn + 2);
341 }
342
343 rc = TRUE;
344
345 out:
346 g_clear_object (&device);
347
348 return rc;
349 }
350
351 static void
352 udisks_linux_drive_lsm_iface_init (UDisksDriveLSMIface *iface)
353 {
354 udisks_debug ("LSM: udisks_linux_drive_lsm_iface_init");
355 }
356
357 /* -------------------------------------------------------------------------- */
358
359 static gboolean
360 udisks_linux_drive_lsm_module_object_process_uevent (UDisksModuleObject *module_object,
361 const gchar *action,
362 UDisksLinuxDevice *device,
363 gboolean *keep)
364 {
365 UDisksLinuxDriveLSM *drive_lsm = UDISKS_LINUX_DRIVE_LSM (module_object);
366
367 g_return_val_if_fail (UDISKS_IS_LINUX_DRIVE_LSM (module_object), FALSE);
368
369 *keep = udisks_linux_module_lsm_drive_check (drive_lsm->module, drive_lsm->drive_object);
370 if (*keep)
371 {
372 udisks_linux_drive_lsm_update (drive_lsm, drive_lsm->drive_object);
373 }
374 else
375 {
376 /* Stop polling */
377 if (drive_lsm->timeout_id)
378 {
379 g_source_remove (drive_lsm->timeout_id);
380 drive_lsm->timeout_id = 0;
381 }
382 }
383
384 return TRUE;
385 }
386
387 static void
388 udisks_linux_drive_lsm_module_object_iface_init (UDisksModuleObjectIface *iface)
389 {
390 iface->process_uevent = udisks_linux_drive_lsm_module_object_process_uevent;
391 }