Debian Codegraph @

modules/lvm2/jobhelpers.c

raw
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 *
3 * Copyright (C) 2017 Red Hat, Inc.
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 * Author: Vratislav Podzimek <[email protected]>
20 *
21 */
22
23 #include <glib.h>
24 #include <blockdev/lvm.h>
25 #include <blockdev/utils.h>
26
27 #include <src/udisksthreadedjob.h>
28 #include <src/udiskslogging.h>
29
30 #include "jobhelpers.h"
31
32
33 gboolean lvcreate_job_func (UDisksThreadedJob *job,
34 GCancellable *cancellable,
35 gpointer user_data,
36 GError **error)
37 {
38 LVJobData *data = user_data;
39 gchar *stripes_string = NULL;
40 gchar *mirrors_string = NULL;
41 BDExtraArg *extra[3] = {NULL, NULL, NULL};
42 int n_extras = 0;
43 gboolean ret;
44
45 if (data->new_lv_stripes > 0)
46 {
47 stripes_string = g_strdup_printf("%u", data->new_lv_stripes);
48 extra[n_extras++] = bd_extra_arg_new ("--stripes", stripes_string);
49 }
50
51 if (data->new_lv_mirrors > 0)
52 {
53 mirrors_string = g_strdup_printf("%u", data->new_lv_mirrors);
54 extra[n_extras++] = bd_extra_arg_new ("--mirrors", mirrors_string);
55 }
56
57
58 ret = bd_lvm_lvcreate (data->vg_name, data->new_lv_name, data->new_lv_size, data->new_lv_layout, data->new_lv_pvs,
59 (const BDExtraArg**) extra, error);
60
61 bd_extra_arg_free (extra[0]);
62 bd_extra_arg_free (extra[1]);
63 g_free (stripes_string);
64 g_free (mirrors_string);
65
66 return ret;
67 }
68
69 gboolean lvcreate_thin_pool_job_func (UDisksThreadedJob *job,
70 GCancellable *cancellable,
71 gpointer user_data,
72 GError **error)
73 {
74 guint64 md_size = 0;
75 LVJobData *data = user_data;
76
77 /* get metadata size */
78 md_size = bd_lvm_get_thpool_meta_size (data->new_lv_size, 0, 100 /* snapshots */, error);
79 if (md_size == 0)
80 /* error is set */
81 return FALSE;
82
83 md_size = bd_lvm_round_size_to_pe (md_size, data->extent_size, TRUE /* round_up */, error);
84 if (md_size == 0)
85 /* error is set */
86 return FALSE;
87
88 /* create a thin pool of given total size (with part of space being used for
89 metadata), but also leave space for the pmspare device (of the same size
90 as metadata space) which need to be created */
91 return bd_lvm_thpoolcreate (data->vg_name, data->new_lv_name, data->new_lv_size - 2*md_size, md_size, 0,
92 NULL /* profile */, NULL /* extra_args */, error);
93 }
94
95 gboolean lvcreate_thin_job_func (UDisksThreadedJob *job,
96 GCancellable *cancellable,
97 gpointer user_data,
98 GError **error)
99 {
100 LVJobData *data = user_data;
101 return bd_lvm_thlvcreate (data->vg_name, data->pool_name, data->new_lv_name, data->new_lv_size, NULL /* extra_args */, error);
102 }
103
104 gboolean lvcreate_vdo_job_func (UDisksThreadedJob *job,
105 GCancellable *cancellable,
106 gpointer user_data,
107 GError **error)
108 {
109 LVJobData *data = user_data;
110 BDLVMVDOWritePolicy policy;
111
112 policy = bd_lvm_get_vdo_write_policy_from_str (data->write_policy, error);
113 if (policy == BD_LVM_VDO_WRITE_POLICY_UNKNOWN)
114 return FALSE;
115
116 return bd_lvm_vdo_pool_create (data->vg_name, data->new_lv_name, data->pool_name, data->new_lv_size,
117 data->virtual_size, data->index_memory, data->compression, data->deduplication,
118 policy, NULL /* extra_args */, error);
119
120 }
121
122 gboolean lvremove_job_func (UDisksThreadedJob *job,
123 GCancellable *cancellable,
124 gpointer user_data,
125 GError **error)
126 {
127 LVJobData *data = user_data;
128 return bd_lvm_lvremove (data->vg_name, data->lv_name, TRUE /* force */, NULL /* extra_args */, error);
129 }
130
131 gboolean lvrename_job_func (UDisksThreadedJob *job,
132 GCancellable *cancellable,
133 gpointer user_data,
134 GError **error)
135 {
136 LVJobData *data = user_data;
137 return bd_lvm_lvrename (data->vg_name, data->lv_name, data->new_lv_name, NULL /* extra_args */, error);
138 }
139
140 gboolean lvresize_job_func (UDisksThreadedJob *job,
141 GCancellable *cancellable,
142 gpointer user_data,
143 GError **error)
144 {
145 LVJobData *data = user_data;
146 BDExtraArg **extra = g_new0 (BDExtraArg *, 4 + (data->new_lv_pvs ? g_strv_length ((gchar **)data->new_lv_pvs) : 0));
147 gint extra_top = -1;
148 gboolean ret = FALSE;
149
150 if (data->force)
151 extra[++extra_top] = bd_extra_arg_new ("-f", "");
152 if (data->resize_fs)
153 {
154 extra[++extra_top] = bd_extra_arg_new ("-r", "");
155 extra[++extra_top] = bd_extra_arg_new ("--yes", "");
156 }
157
158 if (data->new_lv_pvs)
159 {
160 for (int i = 0; data->new_lv_pvs[i]; i++)
161 extra[++extra_top] = bd_extra_arg_new (data->new_lv_pvs[i], "");
162 }
163
164 ret = bd_lvm_lvresize (data->vg_name, data->lv_name, data->new_lv_size, (const BDExtraArg**) extra, error);
165 for (; extra_top >= 0; extra_top--)
166 bd_extra_arg_free (extra[extra_top]);
167 g_free (extra);
168
169 return ret;
170 }
171
172 gboolean lvactivate_job_func (UDisksThreadedJob *job,
173 GCancellable *cancellable,
174 gpointer user_data,
175 GError **error)
176 {
177 LVJobData *data = user_data;
178 return bd_lvm_lvactivate (data->vg_name, data->lv_name, TRUE /* ignore_skip */, FALSE /* shared */, NULL /* extra_args */, error);
179 }
180
181 gboolean lvdeactivate_job_func (UDisksThreadedJob *job,
182 GCancellable *cancellable,
183 gpointer user_data,
184 GError **error)
185 {
186 LVJobData *data = user_data;
187 return bd_lvm_lvdeactivate (data->vg_name, data->lv_name, NULL /* extra_args */, error);
188 }
189
190 gboolean lvsnapshot_create_job_func (UDisksThreadedJob *job,
191 GCancellable *cancellable,
192 gpointer user_data,
193 GError **error)
194 {
195 LVJobData *data = user_data;
196
197 /* create an old or thin snapshot based on the given parameters (size) */
198 if (data->new_lv_size > 0)
199 return bd_lvm_lvsnapshotcreate (data->vg_name, data->lv_name, data->new_lv_name, data->new_lv_size, NULL /* extra_args */, error);
200 else
201 return bd_lvm_thsnapshotcreate (data->vg_name, data->lv_name, data->new_lv_name, NULL /* pool_name */, NULL /* extra_args */, error);
202 }
203
204 gboolean lvcache_attach_job_func (UDisksThreadedJob *job,
205 GCancellable *cancellable,
206 gpointer user_data,
207 GError **error)
208 {
209 LVJobData *data = user_data;
210 return bd_lvm_cache_attach (data->vg_name, data->lv_name, data->pool_name, NULL /* extra_args */, error);
211 }
212
213 gboolean lvcache_detach_job_func (UDisksThreadedJob *job,
214 GCancellable *cancellable,
215 gpointer user_data,
216 GError **error)
217 {
218 LVJobData *data = user_data;
219 return bd_lvm_cache_detach (data->vg_name, data->lv_name, data->destroy, NULL /* extra_args */, error);
220 }
221
222 gboolean lv_vdo_compression_job_func (UDisksThreadedJob *job,
223 GCancellable *cancellable,
224 gpointer user_data,
225 GError **error)
226 {
227 LVJobData *data = user_data;
228 if (data->compression)
229 return bd_lvm_vdo_enable_compression (data->vg_name, data->lv_name, NULL /* extra_args */, error);
230 else
231 return bd_lvm_vdo_disable_compression (data->vg_name, data->lv_name, NULL /* extra_args */, error);
232 }
233
234 gboolean lv_vdo_deduplication_job_func (UDisksThreadedJob *job,
235 GCancellable *cancellable,
236 gpointer user_data,
237 GError **error)
238 {
239 LVJobData *data = user_data;
240 if (data->deduplication)
241 return bd_lvm_vdo_enable_deduplication (data->vg_name, data->lv_name, NULL /* extra_args */, error);
242 else
243 return bd_lvm_vdo_disable_deduplication (data->vg_name, data->lv_name, NULL /* extra_args */, error);
244 }
245
246 gboolean lvrepair_job_func (UDisksThreadedJob *job,
247 GCancellable *cancellable,
248 gpointer user_data,
249 GError **error)
250 {
251 LVJobData *data = user_data;
252 return bd_lvm_lvrepair (data->vg_name, data->lv_name, data->new_lv_pvs, NULL /* extra_args */, error);
253 }
254
255 gboolean vgcreate_job_func (UDisksThreadedJob *job,
256 GCancellable *cancellable,
257 gpointer user_data,
258 GError **error)
259 {
260 VGJobData *data = user_data;
261 return bd_lvm_vgcreate (data->vg_name, data->pvs, 0 /* PE size*/, NULL /* extra_args */, error);
262 }
263
264 gboolean vgremove_job_func (UDisksThreadedJob *job,
265 GCancellable *cancellable,
266 gpointer user_data,
267 GError **error)
268 {
269 VGJobData *data = user_data;
270 return bd_lvm_vgremove (data->vg_name, NULL /* extra_args */, error);
271 }
272
273 gboolean vgrename_job_func (UDisksThreadedJob *job,
274 GCancellable *cancellable,
275 gpointer user_data,
276 GError **error)
277 {
278 VGJobData *data = user_data;
279 return bd_lvm_vgrename (data->vg_name, data->new_vg_name, NULL /* extra_args */, error);
280 }
281
282 gboolean vgextend_job_func (UDisksThreadedJob *job,
283 GCancellable *cancellable,
284 gpointer user_data,
285 GError **error)
286 {
287 VGJobData *data = user_data;
288 return bd_lvm_vgextend (data->vg_name, data->pv_path, NULL /* extra_args */, error);
289 }
290
291 gboolean vgreduce_job_func (UDisksThreadedJob *job,
292 GCancellable *cancellable,
293 gpointer user_data,
294 GError **error)
295 {
296 VGJobData *data = user_data;
297 return bd_lvm_vgreduce (data->vg_name, data->pv_path, NULL /* extra_args */, error);
298 }
299
300 gboolean pvcreate_job_func (UDisksThreadedJob *job,
301 GCancellable *cancellable,
302 gpointer user_data,
303 GError **error)
304 {
305 PVJobData *data = user_data;
306 return bd_lvm_pvcreate (data->path, 0 /* data_alignment */, 0 /* metadata_size */, NULL /* extra_args */, error);
307 }
308
309 gboolean pvremove_job_func (UDisksThreadedJob *job,
310 GCancellable *cancellable,
311 gpointer user_data,
312 GError **error)
313 {
314 VGJobData *data = user_data;
315 gboolean succ = FALSE;
316 succ = bd_lvm_pvremove (data->pv_path, NULL /* extra_args */, error);
317 if (!succ)
318 return FALSE;
319
320 if (bd_lvm_is_tech_avail (BD_LVM_TECH_DEVICES, 0, NULL) &&
321 !bd_lvm_devices_delete (data->pv_path, NULL, NULL, error))
322 {
323 udisks_warning ("Failed to remove %s from LVM devices file: %s", data->pv_path, (*error)->message);
324 g_clear_error (error);
325 }
326 return TRUE;
327 }
328
329 gboolean pvmove_job_func (UDisksThreadedJob *job,
330 GCancellable *cancellable,
331 gpointer user_data,
332 GError **error)
333 {
334 VGJobData *data = user_data;
335 return bd_lvm_pvmove (data->pv_path, NULL /* dest */, NULL /* extra_args */, error);
336 }
337
338
339 void vg_list_free (BDLVMVGdata **vg_list) {
340 if (!vg_list)
341 /* nothing to do */
342 return;
343
344 for (BDLVMVGdata **vg_list_p = vg_list; *vg_list_p; vg_list_p++)
345 bd_lvm_vgdata_free (*vg_list_p);
346 g_free (vg_list);
347 }
348
349 void pv_list_free (BDLVMPVdata **pv_list) {
350 if (!pv_list)
351 /* nothing to do */
352 return;
353
354 for (BDLVMPVdata **pv_list_p = pv_list; *pv_list_p; pv_list_p++)
355 bd_lvm_pvdata_free (*pv_list_p);
356 g_free (pv_list);
357 }
358
359 void lv_list_free (BDLVMLVdata **lv_list) {
360 if (!lv_list)
361 /* nothing to do */
362 return;
363
364 for (BDLVMLVdata **lv_list_p = lv_list; *lv_list_p; lv_list_p++)
365 bd_lvm_lvdata_free (*lv_list_p);
366 g_free (lv_list);
367 }
368
369 void vgs_pvs_data_free (VGsPVsData *data) {
370 if (!data)
371 /* nothing to do */
372 return;
373
374 vg_list_free (data->vgs);
375 pv_list_free (data->pvs);
376 g_free (data);
377 }
378
379 void vgs_task_func (GTask *task,
380 gpointer source_obj,
381 gpointer task_data,
382 GCancellable *cancellable)
383 {
384 GError *error = NULL;
385 VGsPVsData *ret = g_new0 (VGsPVsData, 1);
386
387 ret->vgs = bd_lvm_vgs (&error);
388 if (!ret->vgs) {
389 vgs_pvs_data_free (ret);
390 g_task_return_error (task, error);
391 return;
392 }
393
394 ret->pvs = bd_lvm_pvs (&error);
395 if (!ret->pvs) {
396 vgs_pvs_data_free (ret);
397 g_task_return_error (task, error);
398 }
399 else
400 g_task_return_pointer (task, ret, (GDestroyNotify) vgs_pvs_data_free);
401 }
402
403 void lvs_task_func (GTask *task,
404 gpointer source_obj,
405 gpointer task_data,
406 GCancellable *cancellable)
407 {
408 GError *error = NULL;
409 BDLVMLVdata **ret = NULL;
410 gchar *vg_name = (gchar*) task_data;
411
412 ret = bd_lvm_lvs_tree (vg_name, &error);
413 if (!ret)
414 g_task_return_error (task, error);
415 else
416 g_task_return_pointer (task, ret, (GDestroyNotify) lv_list_free);
417 }