1*86d7f5d3SJohn Marino /* $NetBSD: activate.c,v 1.1.1.3 2009/12/02 00:26:22 haad Exp $ */
2*86d7f5d3SJohn Marino
3*86d7f5d3SJohn Marino /*
4*86d7f5d3SJohn Marino * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
5*86d7f5d3SJohn Marino * Copyright (C) 2004-2009 Red Hat, Inc. All rights reserved.
6*86d7f5d3SJohn Marino *
7*86d7f5d3SJohn Marino * This file is part of LVM2.
8*86d7f5d3SJohn Marino *
9*86d7f5d3SJohn Marino * This copyrighted material is made available to anyone wishing to use,
10*86d7f5d3SJohn Marino * modify, copy, or redistribute it subject to the terms and conditions
11*86d7f5d3SJohn Marino * of the GNU Lesser General Public License v.2.1.
12*86d7f5d3SJohn Marino *
13*86d7f5d3SJohn Marino * You should have received a copy of the GNU Lesser General Public License
14*86d7f5d3SJohn Marino * along with this program; if not, write to the Free Software Foundation,
15*86d7f5d3SJohn Marino * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16*86d7f5d3SJohn Marino */
17*86d7f5d3SJohn Marino
18*86d7f5d3SJohn Marino #include "lib.h"
19*86d7f5d3SJohn Marino #include "metadata.h"
20*86d7f5d3SJohn Marino #include "activate.h"
21*86d7f5d3SJohn Marino #include "memlock.h"
22*86d7f5d3SJohn Marino #include "display.h"
23*86d7f5d3SJohn Marino #include "fs.h"
24*86d7f5d3SJohn Marino #include "lvm-exec.h"
25*86d7f5d3SJohn Marino #include "lvm-file.h"
26*86d7f5d3SJohn Marino #include "lvm-string.h"
27*86d7f5d3SJohn Marino #include "toolcontext.h"
28*86d7f5d3SJohn Marino #include "dev_manager.h"
29*86d7f5d3SJohn Marino #include "str_list.h"
30*86d7f5d3SJohn Marino #include "config.h"
31*86d7f5d3SJohn Marino #include "filter.h"
32*86d7f5d3SJohn Marino #include "segtype.h"
33*86d7f5d3SJohn Marino
34*86d7f5d3SJohn Marino #include <limits.h>
35*86d7f5d3SJohn Marino #include <fcntl.h>
36*86d7f5d3SJohn Marino #include <unistd.h>
37*86d7f5d3SJohn Marino
38*86d7f5d3SJohn Marino #define _skip(fmt, args...) log_very_verbose("Skipping: " fmt , ## args)
39*86d7f5d3SJohn Marino
lvm1_present(struct cmd_context * cmd)40*86d7f5d3SJohn Marino int lvm1_present(struct cmd_context *cmd)
41*86d7f5d3SJohn Marino {
42*86d7f5d3SJohn Marino char path[PATH_MAX];
43*86d7f5d3SJohn Marino
44*86d7f5d3SJohn Marino if (dm_snprintf(path, sizeof(path), "%s/lvm/global", cmd->proc_dir)
45*86d7f5d3SJohn Marino < 0) {
46*86d7f5d3SJohn Marino log_error("LVM1 proc global snprintf failed");
47*86d7f5d3SJohn Marino return 0;
48*86d7f5d3SJohn Marino }
49*86d7f5d3SJohn Marino
50*86d7f5d3SJohn Marino if (path_exists(path))
51*86d7f5d3SJohn Marino return 1;
52*86d7f5d3SJohn Marino else
53*86d7f5d3SJohn Marino return 0;
54*86d7f5d3SJohn Marino }
55*86d7f5d3SJohn Marino
list_segment_modules(struct dm_pool * mem,const struct lv_segment * seg,struct dm_list * modules)56*86d7f5d3SJohn Marino int list_segment_modules(struct dm_pool *mem, const struct lv_segment *seg,
57*86d7f5d3SJohn Marino struct dm_list *modules)
58*86d7f5d3SJohn Marino {
59*86d7f5d3SJohn Marino unsigned int s;
60*86d7f5d3SJohn Marino struct lv_segment *seg2, *snap_seg;
61*86d7f5d3SJohn Marino struct dm_list *snh;
62*86d7f5d3SJohn Marino
63*86d7f5d3SJohn Marino if (seg->segtype->ops->modules_needed &&
64*86d7f5d3SJohn Marino !seg->segtype->ops->modules_needed(mem, seg, modules)) {
65*86d7f5d3SJohn Marino log_error("module string allocation failed");
66*86d7f5d3SJohn Marino return 0;
67*86d7f5d3SJohn Marino }
68*86d7f5d3SJohn Marino
69*86d7f5d3SJohn Marino if (lv_is_origin(seg->lv))
70*86d7f5d3SJohn Marino dm_list_iterate(snh, &seg->lv->snapshot_segs)
71*86d7f5d3SJohn Marino if (!list_lv_modules(mem,
72*86d7f5d3SJohn Marino dm_list_struct_base(snh,
73*86d7f5d3SJohn Marino struct lv_segment,
74*86d7f5d3SJohn Marino origin_list)->cow,
75*86d7f5d3SJohn Marino modules))
76*86d7f5d3SJohn Marino return_0;
77*86d7f5d3SJohn Marino
78*86d7f5d3SJohn Marino if (lv_is_cow(seg->lv)) {
79*86d7f5d3SJohn Marino snap_seg = find_cow(seg->lv);
80*86d7f5d3SJohn Marino if (snap_seg->segtype->ops->modules_needed &&
81*86d7f5d3SJohn Marino !snap_seg->segtype->ops->modules_needed(mem, snap_seg,
82*86d7f5d3SJohn Marino modules)) {
83*86d7f5d3SJohn Marino log_error("snap_seg module string allocation failed");
84*86d7f5d3SJohn Marino return 0;
85*86d7f5d3SJohn Marino }
86*86d7f5d3SJohn Marino }
87*86d7f5d3SJohn Marino
88*86d7f5d3SJohn Marino for (s = 0; s < seg->area_count; s++) {
89*86d7f5d3SJohn Marino switch (seg_type(seg, s)) {
90*86d7f5d3SJohn Marino case AREA_LV:
91*86d7f5d3SJohn Marino seg2 = find_seg_by_le(seg_lv(seg, s), seg_le(seg, s));
92*86d7f5d3SJohn Marino if (seg2 && !list_segment_modules(mem, seg2, modules))
93*86d7f5d3SJohn Marino return_0;
94*86d7f5d3SJohn Marino break;
95*86d7f5d3SJohn Marino case AREA_PV:
96*86d7f5d3SJohn Marino case AREA_UNASSIGNED:
97*86d7f5d3SJohn Marino ;
98*86d7f5d3SJohn Marino }
99*86d7f5d3SJohn Marino }
100*86d7f5d3SJohn Marino
101*86d7f5d3SJohn Marino return 1;
102*86d7f5d3SJohn Marino }
103*86d7f5d3SJohn Marino
list_lv_modules(struct dm_pool * mem,const struct logical_volume * lv,struct dm_list * modules)104*86d7f5d3SJohn Marino int list_lv_modules(struct dm_pool *mem, const struct logical_volume *lv,
105*86d7f5d3SJohn Marino struct dm_list *modules)
106*86d7f5d3SJohn Marino {
107*86d7f5d3SJohn Marino struct lv_segment *seg;
108*86d7f5d3SJohn Marino
109*86d7f5d3SJohn Marino dm_list_iterate_items(seg, &lv->segments)
110*86d7f5d3SJohn Marino if (!list_segment_modules(mem, seg, modules))
111*86d7f5d3SJohn Marino return_0;
112*86d7f5d3SJohn Marino
113*86d7f5d3SJohn Marino return 1;
114*86d7f5d3SJohn Marino }
115*86d7f5d3SJohn Marino
116*86d7f5d3SJohn Marino #ifndef DEVMAPPER_SUPPORT
set_activation(int act)117*86d7f5d3SJohn Marino void set_activation(int act)
118*86d7f5d3SJohn Marino {
119*86d7f5d3SJohn Marino static int warned = 0;
120*86d7f5d3SJohn Marino
121*86d7f5d3SJohn Marino if (warned || !act)
122*86d7f5d3SJohn Marino return;
123*86d7f5d3SJohn Marino
124*86d7f5d3SJohn Marino log_error("Compiled without libdevmapper support. "
125*86d7f5d3SJohn Marino "Can't enable activation.");
126*86d7f5d3SJohn Marino
127*86d7f5d3SJohn Marino warned = 1;
128*86d7f5d3SJohn Marino }
activation(void)129*86d7f5d3SJohn Marino int activation(void)
130*86d7f5d3SJohn Marino {
131*86d7f5d3SJohn Marino return 0;
132*86d7f5d3SJohn Marino }
library_version(char * version,size_t size)133*86d7f5d3SJohn Marino int library_version(char *version, size_t size)
134*86d7f5d3SJohn Marino {
135*86d7f5d3SJohn Marino return 0;
136*86d7f5d3SJohn Marino }
driver_version(char * version,size_t size)137*86d7f5d3SJohn Marino int driver_version(char *version, size_t size)
138*86d7f5d3SJohn Marino {
139*86d7f5d3SJohn Marino return 0;
140*86d7f5d3SJohn Marino }
target_version(const char * target_name,uint32_t * maj,uint32_t * min,uint32_t * patchlevel)141*86d7f5d3SJohn Marino int target_version(const char *target_name, uint32_t *maj,
142*86d7f5d3SJohn Marino uint32_t *min, uint32_t *patchlevel)
143*86d7f5d3SJohn Marino {
144*86d7f5d3SJohn Marino return 0;
145*86d7f5d3SJohn Marino }
target_present(struct cmd_context * cmd,const char * target_name,int use_modprobe)146*86d7f5d3SJohn Marino int target_present(struct cmd_context *cmd, const char *target_name,
147*86d7f5d3SJohn Marino int use_modprobe)
148*86d7f5d3SJohn Marino {
149*86d7f5d3SJohn Marino return 0;
150*86d7f5d3SJohn Marino }
lv_info(struct cmd_context * cmd,const struct logical_volume * lv,struct lvinfo * info,int with_open_count,int with_read_ahead)151*86d7f5d3SJohn Marino int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info,
152*86d7f5d3SJohn Marino int with_open_count, int with_read_ahead)
153*86d7f5d3SJohn Marino {
154*86d7f5d3SJohn Marino return 0;
155*86d7f5d3SJohn Marino }
lv_info_by_lvid(struct cmd_context * cmd,const char * lvid_s,struct lvinfo * info,int with_open_count,int with_read_ahead)156*86d7f5d3SJohn Marino int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
157*86d7f5d3SJohn Marino struct lvinfo *info, int with_open_count, int with_read_ahead)
158*86d7f5d3SJohn Marino {
159*86d7f5d3SJohn Marino return 0;
160*86d7f5d3SJohn Marino }
lv_snapshot_percent(const struct logical_volume * lv,float * percent,percent_range_t * percent_range)161*86d7f5d3SJohn Marino int lv_snapshot_percent(const struct logical_volume *lv, float *percent,
162*86d7f5d3SJohn Marino percent_range_t *percent_range)
163*86d7f5d3SJohn Marino {
164*86d7f5d3SJohn Marino return 0;
165*86d7f5d3SJohn Marino }
lv_mirror_percent(struct cmd_context * cmd,struct logical_volume * lv,int wait,float * percent,percent_range_t * percent_range,uint32_t * event_nr)166*86d7f5d3SJohn Marino int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
167*86d7f5d3SJohn Marino int wait, float *percent, percent_range_t *percent_range,
168*86d7f5d3SJohn Marino uint32_t *event_nr)
169*86d7f5d3SJohn Marino {
170*86d7f5d3SJohn Marino return 0;
171*86d7f5d3SJohn Marino }
lvs_in_vg_activated(struct volume_group * vg)172*86d7f5d3SJohn Marino int lvs_in_vg_activated(struct volume_group *vg)
173*86d7f5d3SJohn Marino {
174*86d7f5d3SJohn Marino return 0;
175*86d7f5d3SJohn Marino }
lvs_in_vg_activated_by_uuid_only(struct volume_group * vg)176*86d7f5d3SJohn Marino int lvs_in_vg_activated_by_uuid_only(struct volume_group *vg)
177*86d7f5d3SJohn Marino {
178*86d7f5d3SJohn Marino return 0;
179*86d7f5d3SJohn Marino }
lvs_in_vg_opened(struct volume_group * vg)180*86d7f5d3SJohn Marino int lvs_in_vg_opened(struct volume_group *vg)
181*86d7f5d3SJohn Marino {
182*86d7f5d3SJohn Marino return 0;
183*86d7f5d3SJohn Marino }
lv_suspend(struct cmd_context * cmd,const char * lvid_s)184*86d7f5d3SJohn Marino int lv_suspend(struct cmd_context *cmd, const char *lvid_s)
185*86d7f5d3SJohn Marino {
186*86d7f5d3SJohn Marino return 1;
187*86d7f5d3SJohn Marino }
lv_suspend_if_active(struct cmd_context * cmd,const char * lvid_s)188*86d7f5d3SJohn Marino int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s)
189*86d7f5d3SJohn Marino {
190*86d7f5d3SJohn Marino return 1;
191*86d7f5d3SJohn Marino }
lv_resume(struct cmd_context * cmd,const char * lvid_s)192*86d7f5d3SJohn Marino int lv_resume(struct cmd_context *cmd, const char *lvid_s)
193*86d7f5d3SJohn Marino {
194*86d7f5d3SJohn Marino return 1;
195*86d7f5d3SJohn Marino }
lv_resume_if_active(struct cmd_context * cmd,const char * lvid_s)196*86d7f5d3SJohn Marino int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s)
197*86d7f5d3SJohn Marino {
198*86d7f5d3SJohn Marino return 1;
199*86d7f5d3SJohn Marino }
lv_deactivate(struct cmd_context * cmd,const char * lvid_s)200*86d7f5d3SJohn Marino int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
201*86d7f5d3SJohn Marino {
202*86d7f5d3SJohn Marino return 1;
203*86d7f5d3SJohn Marino }
lv_activation_filter(struct cmd_context * cmd,const char * lvid_s,int * activate_lv)204*86d7f5d3SJohn Marino int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
205*86d7f5d3SJohn Marino int *activate_lv)
206*86d7f5d3SJohn Marino {
207*86d7f5d3SJohn Marino return 1;
208*86d7f5d3SJohn Marino }
lv_activate(struct cmd_context * cmd,const char * lvid_s,int exclusive)209*86d7f5d3SJohn Marino int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
210*86d7f5d3SJohn Marino {
211*86d7f5d3SJohn Marino return 1;
212*86d7f5d3SJohn Marino }
lv_activate_with_filter(struct cmd_context * cmd,const char * lvid_s,int exclusive)213*86d7f5d3SJohn Marino int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
214*86d7f5d3SJohn Marino {
215*86d7f5d3SJohn Marino return 1;
216*86d7f5d3SJohn Marino }
217*86d7f5d3SJohn Marino
lv_mknodes(struct cmd_context * cmd,const struct logical_volume * lv)218*86d7f5d3SJohn Marino int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
219*86d7f5d3SJohn Marino {
220*86d7f5d3SJohn Marino return 1;
221*86d7f5d3SJohn Marino }
222*86d7f5d3SJohn Marino
pv_uses_vg(struct physical_volume * pv,struct volume_group * vg)223*86d7f5d3SJohn Marino int pv_uses_vg(struct physical_volume *pv,
224*86d7f5d3SJohn Marino struct volume_group *vg)
225*86d7f5d3SJohn Marino {
226*86d7f5d3SJohn Marino return 0;
227*86d7f5d3SJohn Marino }
228*86d7f5d3SJohn Marino
activation_release(void)229*86d7f5d3SJohn Marino void activation_release(void)
230*86d7f5d3SJohn Marino {
231*86d7f5d3SJohn Marino return;
232*86d7f5d3SJohn Marino }
233*86d7f5d3SJohn Marino
activation_exit(void)234*86d7f5d3SJohn Marino void activation_exit(void)
235*86d7f5d3SJohn Marino {
236*86d7f5d3SJohn Marino return;
237*86d7f5d3SJohn Marino }
238*86d7f5d3SJohn Marino
239*86d7f5d3SJohn Marino #else /* DEVMAPPER_SUPPORT */
240*86d7f5d3SJohn Marino
241*86d7f5d3SJohn Marino static int _activation = 1;
242*86d7f5d3SJohn Marino
set_activation(int act)243*86d7f5d3SJohn Marino void set_activation(int act)
244*86d7f5d3SJohn Marino {
245*86d7f5d3SJohn Marino if (act == _activation)
246*86d7f5d3SJohn Marino return;
247*86d7f5d3SJohn Marino
248*86d7f5d3SJohn Marino _activation = act;
249*86d7f5d3SJohn Marino if (_activation)
250*86d7f5d3SJohn Marino log_verbose("Activation enabled. Device-mapper kernel "
251*86d7f5d3SJohn Marino "driver will be used.");
252*86d7f5d3SJohn Marino else
253*86d7f5d3SJohn Marino log_warn("WARNING: Activation disabled. No device-mapper "
254*86d7f5d3SJohn Marino "interaction will be attempted.");
255*86d7f5d3SJohn Marino }
256*86d7f5d3SJohn Marino
activation(void)257*86d7f5d3SJohn Marino int activation(void)
258*86d7f5d3SJohn Marino {
259*86d7f5d3SJohn Marino return _activation;
260*86d7f5d3SJohn Marino }
261*86d7f5d3SJohn Marino
_passes_activation_filter(struct cmd_context * cmd,struct logical_volume * lv)262*86d7f5d3SJohn Marino static int _passes_activation_filter(struct cmd_context *cmd,
263*86d7f5d3SJohn Marino struct logical_volume *lv)
264*86d7f5d3SJohn Marino {
265*86d7f5d3SJohn Marino const struct config_node *cn;
266*86d7f5d3SJohn Marino struct config_value *cv;
267*86d7f5d3SJohn Marino char *str;
268*86d7f5d3SJohn Marino char path[PATH_MAX];
269*86d7f5d3SJohn Marino
270*86d7f5d3SJohn Marino if (!(cn = find_config_tree_node(cmd, "activation/volume_list"))) {
271*86d7f5d3SJohn Marino /* If no host tags defined, activate */
272*86d7f5d3SJohn Marino if (dm_list_empty(&cmd->tags))
273*86d7f5d3SJohn Marino return 1;
274*86d7f5d3SJohn Marino
275*86d7f5d3SJohn Marino /* If any host tag matches any LV or VG tag, activate */
276*86d7f5d3SJohn Marino if (str_list_match_list(&cmd->tags, &lv->tags) ||
277*86d7f5d3SJohn Marino str_list_match_list(&cmd->tags, &lv->vg->tags))
278*86d7f5d3SJohn Marino return 1;
279*86d7f5d3SJohn Marino
280*86d7f5d3SJohn Marino /* Don't activate */
281*86d7f5d3SJohn Marino return 0;
282*86d7f5d3SJohn Marino }
283*86d7f5d3SJohn Marino
284*86d7f5d3SJohn Marino for (cv = cn->v; cv; cv = cv->next) {
285*86d7f5d3SJohn Marino if (cv->type != CFG_STRING) {
286*86d7f5d3SJohn Marino log_error("Ignoring invalid string in config file "
287*86d7f5d3SJohn Marino "activation/volume_list");
288*86d7f5d3SJohn Marino continue;
289*86d7f5d3SJohn Marino }
290*86d7f5d3SJohn Marino str = cv->v.str;
291*86d7f5d3SJohn Marino if (!*str) {
292*86d7f5d3SJohn Marino log_error("Ignoring empty string in config file "
293*86d7f5d3SJohn Marino "activation/volume_list");
294*86d7f5d3SJohn Marino continue;
295*86d7f5d3SJohn Marino }
296*86d7f5d3SJohn Marino
297*86d7f5d3SJohn Marino /* Tag? */
298*86d7f5d3SJohn Marino if (*str == '@') {
299*86d7f5d3SJohn Marino str++;
300*86d7f5d3SJohn Marino if (!*str) {
301*86d7f5d3SJohn Marino log_error("Ignoring empty tag in config file "
302*86d7f5d3SJohn Marino "activation/volume_list");
303*86d7f5d3SJohn Marino continue;
304*86d7f5d3SJohn Marino }
305*86d7f5d3SJohn Marino /* If any host tag matches any LV or VG tag, activate */
306*86d7f5d3SJohn Marino if (!strcmp(str, "*")) {
307*86d7f5d3SJohn Marino if (str_list_match_list(&cmd->tags, &lv->tags)
308*86d7f5d3SJohn Marino || str_list_match_list(&cmd->tags,
309*86d7f5d3SJohn Marino &lv->vg->tags))
310*86d7f5d3SJohn Marino return 1;
311*86d7f5d3SJohn Marino else
312*86d7f5d3SJohn Marino continue;
313*86d7f5d3SJohn Marino }
314*86d7f5d3SJohn Marino /* If supplied tag matches LV or VG tag, activate */
315*86d7f5d3SJohn Marino if (str_list_match_item(&lv->tags, str) ||
316*86d7f5d3SJohn Marino str_list_match_item(&lv->vg->tags, str))
317*86d7f5d3SJohn Marino return 1;
318*86d7f5d3SJohn Marino else
319*86d7f5d3SJohn Marino continue;
320*86d7f5d3SJohn Marino }
321*86d7f5d3SJohn Marino if (!strchr(str, '/')) {
322*86d7f5d3SJohn Marino /* vgname supplied */
323*86d7f5d3SJohn Marino if (!strcmp(str, lv->vg->name))
324*86d7f5d3SJohn Marino return 1;
325*86d7f5d3SJohn Marino else
326*86d7f5d3SJohn Marino continue;
327*86d7f5d3SJohn Marino }
328*86d7f5d3SJohn Marino /* vgname/lvname */
329*86d7f5d3SJohn Marino if (dm_snprintf(path, sizeof(path), "%s/%s", lv->vg->name,
330*86d7f5d3SJohn Marino lv->name) < 0) {
331*86d7f5d3SJohn Marino log_error("dm_snprintf error from %s/%s", lv->vg->name,
332*86d7f5d3SJohn Marino lv->name);
333*86d7f5d3SJohn Marino continue;
334*86d7f5d3SJohn Marino }
335*86d7f5d3SJohn Marino if (!strcmp(path, str))
336*86d7f5d3SJohn Marino return 1;
337*86d7f5d3SJohn Marino }
338*86d7f5d3SJohn Marino
339*86d7f5d3SJohn Marino return 0;
340*86d7f5d3SJohn Marino }
341*86d7f5d3SJohn Marino
library_version(char * version,size_t size)342*86d7f5d3SJohn Marino int library_version(char *version, size_t size)
343*86d7f5d3SJohn Marino {
344*86d7f5d3SJohn Marino if (!activation())
345*86d7f5d3SJohn Marino return 0;
346*86d7f5d3SJohn Marino
347*86d7f5d3SJohn Marino return dm_get_library_version(version, size);
348*86d7f5d3SJohn Marino }
349*86d7f5d3SJohn Marino
driver_version(char * version,size_t size)350*86d7f5d3SJohn Marino int driver_version(char *version, size_t size)
351*86d7f5d3SJohn Marino {
352*86d7f5d3SJohn Marino if (!activation())
353*86d7f5d3SJohn Marino return 0;
354*86d7f5d3SJohn Marino
355*86d7f5d3SJohn Marino log_very_verbose("Getting driver version");
356*86d7f5d3SJohn Marino
357*86d7f5d3SJohn Marino return dm_driver_version(version, size);
358*86d7f5d3SJohn Marino }
359*86d7f5d3SJohn Marino
target_version(const char * target_name,uint32_t * maj,uint32_t * min,uint32_t * patchlevel)360*86d7f5d3SJohn Marino int target_version(const char *target_name, uint32_t *maj,
361*86d7f5d3SJohn Marino uint32_t *min, uint32_t *patchlevel)
362*86d7f5d3SJohn Marino {
363*86d7f5d3SJohn Marino int r = 0;
364*86d7f5d3SJohn Marino struct dm_task *dmt;
365*86d7f5d3SJohn Marino struct dm_versions *target, *last_target;
366*86d7f5d3SJohn Marino
367*86d7f5d3SJohn Marino log_very_verbose("Getting target version for %s", target_name);
368*86d7f5d3SJohn Marino if (!(dmt = dm_task_create(DM_DEVICE_LIST_VERSIONS)))
369*86d7f5d3SJohn Marino return_0;
370*86d7f5d3SJohn Marino
371*86d7f5d3SJohn Marino if (!dm_task_run(dmt)) {
372*86d7f5d3SJohn Marino log_debug("Failed to get %s target version", target_name);
373*86d7f5d3SJohn Marino /* Assume this was because LIST_VERSIONS isn't supported */
374*86d7f5d3SJohn Marino return 1;
375*86d7f5d3SJohn Marino }
376*86d7f5d3SJohn Marino
377*86d7f5d3SJohn Marino target = dm_task_get_versions(dmt);
378*86d7f5d3SJohn Marino
379*86d7f5d3SJohn Marino do {
380*86d7f5d3SJohn Marino last_target = target;
381*86d7f5d3SJohn Marino
382*86d7f5d3SJohn Marino if (!strcmp(target_name, target->name)) {
383*86d7f5d3SJohn Marino r = 1;
384*86d7f5d3SJohn Marino *maj = target->version[0];
385*86d7f5d3SJohn Marino *min = target->version[1];
386*86d7f5d3SJohn Marino *patchlevel = target->version[2];
387*86d7f5d3SJohn Marino goto out;
388*86d7f5d3SJohn Marino }
389*86d7f5d3SJohn Marino
390*86d7f5d3SJohn Marino target = (void *) target + target->next;
391*86d7f5d3SJohn Marino } while (last_target != target);
392*86d7f5d3SJohn Marino
393*86d7f5d3SJohn Marino out:
394*86d7f5d3SJohn Marino dm_task_destroy(dmt);
395*86d7f5d3SJohn Marino
396*86d7f5d3SJohn Marino return r;
397*86d7f5d3SJohn Marino }
398*86d7f5d3SJohn Marino
module_present(struct cmd_context * cmd,const char * target_name)399*86d7f5d3SJohn Marino int module_present(struct cmd_context *cmd, const char *target_name)
400*86d7f5d3SJohn Marino {
401*86d7f5d3SJohn Marino int ret = 0;
402*86d7f5d3SJohn Marino #ifdef MODPROBE_CMD
403*86d7f5d3SJohn Marino char module[128];
404*86d7f5d3SJohn Marino const char *argv[3];
405*86d7f5d3SJohn Marino
406*86d7f5d3SJohn Marino if (dm_snprintf(module, sizeof(module), "dm-%s", target_name) < 0) {
407*86d7f5d3SJohn Marino log_error("module_present module name too long: %s",
408*86d7f5d3SJohn Marino target_name);
409*86d7f5d3SJohn Marino return 0;
410*86d7f5d3SJohn Marino }
411*86d7f5d3SJohn Marino
412*86d7f5d3SJohn Marino argv[0] = MODPROBE_CMD;
413*86d7f5d3SJohn Marino argv[1] = module;
414*86d7f5d3SJohn Marino argv[2] = NULL;
415*86d7f5d3SJohn Marino
416*86d7f5d3SJohn Marino ret = exec_cmd(cmd, argv);
417*86d7f5d3SJohn Marino #endif
418*86d7f5d3SJohn Marino return ret;
419*86d7f5d3SJohn Marino }
420*86d7f5d3SJohn Marino
target_present(struct cmd_context * cmd,const char * target_name,int use_modprobe)421*86d7f5d3SJohn Marino int target_present(struct cmd_context *cmd, const char *target_name,
422*86d7f5d3SJohn Marino int use_modprobe)
423*86d7f5d3SJohn Marino {
424*86d7f5d3SJohn Marino uint32_t maj, min, patchlevel;
425*86d7f5d3SJohn Marino
426*86d7f5d3SJohn Marino if (!activation())
427*86d7f5d3SJohn Marino return 0;
428*86d7f5d3SJohn Marino
429*86d7f5d3SJohn Marino #ifdef MODPROBE_CMD
430*86d7f5d3SJohn Marino if (use_modprobe) {
431*86d7f5d3SJohn Marino if (target_version(target_name, &maj, &min, &patchlevel))
432*86d7f5d3SJohn Marino return 1;
433*86d7f5d3SJohn Marino
434*86d7f5d3SJohn Marino if (!module_present(cmd, target_name))
435*86d7f5d3SJohn Marino return_0;
436*86d7f5d3SJohn Marino }
437*86d7f5d3SJohn Marino #endif
438*86d7f5d3SJohn Marino
439*86d7f5d3SJohn Marino return target_version(target_name, &maj, &min, &patchlevel);
440*86d7f5d3SJohn Marino }
441*86d7f5d3SJohn Marino
442*86d7f5d3SJohn Marino /*
443*86d7f5d3SJohn Marino * Returns 1 if info structure populated, else 0 on failure.
444*86d7f5d3SJohn Marino */
_lv_info(struct cmd_context * cmd,const struct logical_volume * lv,int with_mknodes,struct lvinfo * info,int with_open_count,int with_read_ahead,unsigned by_uuid_only)445*86d7f5d3SJohn Marino static int _lv_info(struct cmd_context *cmd, const struct logical_volume *lv, int with_mknodes,
446*86d7f5d3SJohn Marino struct lvinfo *info, int with_open_count, int with_read_ahead, unsigned by_uuid_only)
447*86d7f5d3SJohn Marino {
448*86d7f5d3SJohn Marino struct dm_info dminfo;
449*86d7f5d3SJohn Marino char *name = NULL;
450*86d7f5d3SJohn Marino
451*86d7f5d3SJohn Marino if (!activation())
452*86d7f5d3SJohn Marino return 0;
453*86d7f5d3SJohn Marino
454*86d7f5d3SJohn Marino if (!by_uuid_only &&
455*86d7f5d3SJohn Marino !(name = build_dm_name(cmd->mem, lv->vg->name, lv->name, NULL)))
456*86d7f5d3SJohn Marino return_0;
457*86d7f5d3SJohn Marino
458*86d7f5d3SJohn Marino log_debug("Getting device info for %s", name);
459*86d7f5d3SJohn Marino if (!dev_manager_info(lv->vg->cmd->mem, name, lv, with_mknodes,
460*86d7f5d3SJohn Marino with_open_count, with_read_ahead, &dminfo,
461*86d7f5d3SJohn Marino &info->read_ahead)) {
462*86d7f5d3SJohn Marino if (name)
463*86d7f5d3SJohn Marino dm_pool_free(cmd->mem, name);
464*86d7f5d3SJohn Marino return_0;
465*86d7f5d3SJohn Marino }
466*86d7f5d3SJohn Marino
467*86d7f5d3SJohn Marino info->exists = dminfo.exists;
468*86d7f5d3SJohn Marino info->suspended = dminfo.suspended;
469*86d7f5d3SJohn Marino info->open_count = dminfo.open_count;
470*86d7f5d3SJohn Marino info->major = dminfo.major;
471*86d7f5d3SJohn Marino info->minor = dminfo.minor;
472*86d7f5d3SJohn Marino info->read_only = dminfo.read_only;
473*86d7f5d3SJohn Marino info->live_table = dminfo.live_table;
474*86d7f5d3SJohn Marino info->inactive_table = dminfo.inactive_table;
475*86d7f5d3SJohn Marino
476*86d7f5d3SJohn Marino if (name)
477*86d7f5d3SJohn Marino dm_pool_free(cmd->mem, name);
478*86d7f5d3SJohn Marino
479*86d7f5d3SJohn Marino return 1;
480*86d7f5d3SJohn Marino }
481*86d7f5d3SJohn Marino
lv_info(struct cmd_context * cmd,const struct logical_volume * lv,struct lvinfo * info,int with_open_count,int with_read_ahead)482*86d7f5d3SJohn Marino int lv_info(struct cmd_context *cmd, const struct logical_volume *lv, struct lvinfo *info,
483*86d7f5d3SJohn Marino int with_open_count, int with_read_ahead)
484*86d7f5d3SJohn Marino {
485*86d7f5d3SJohn Marino return _lv_info(cmd, lv, 0, info, with_open_count, with_read_ahead, 0);
486*86d7f5d3SJohn Marino }
487*86d7f5d3SJohn Marino
lv_info_by_lvid(struct cmd_context * cmd,const char * lvid_s,struct lvinfo * info,int with_open_count,int with_read_ahead)488*86d7f5d3SJohn Marino int lv_info_by_lvid(struct cmd_context *cmd, const char *lvid_s,
489*86d7f5d3SJohn Marino struct lvinfo *info, int with_open_count, int with_read_ahead)
490*86d7f5d3SJohn Marino {
491*86d7f5d3SJohn Marino struct logical_volume *lv;
492*86d7f5d3SJohn Marino
493*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
494*86d7f5d3SJohn Marino return 0;
495*86d7f5d3SJohn Marino
496*86d7f5d3SJohn Marino return _lv_info(cmd, lv, 0, info, with_open_count, with_read_ahead, 0);
497*86d7f5d3SJohn Marino }
498*86d7f5d3SJohn Marino
499*86d7f5d3SJohn Marino /*
500*86d7f5d3SJohn Marino * Returns 1 if percent set, else 0 on failure.
501*86d7f5d3SJohn Marino */
lv_snapshot_percent(const struct logical_volume * lv,float * percent,percent_range_t * percent_range)502*86d7f5d3SJohn Marino int lv_snapshot_percent(const struct logical_volume *lv, float *percent,
503*86d7f5d3SJohn Marino percent_range_t *percent_range)
504*86d7f5d3SJohn Marino {
505*86d7f5d3SJohn Marino int r;
506*86d7f5d3SJohn Marino struct dev_manager *dm;
507*86d7f5d3SJohn Marino
508*86d7f5d3SJohn Marino if (!activation())
509*86d7f5d3SJohn Marino return 0;
510*86d7f5d3SJohn Marino
511*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
512*86d7f5d3SJohn Marino return_0;
513*86d7f5d3SJohn Marino
514*86d7f5d3SJohn Marino if (!(r = dev_manager_snapshot_percent(dm, lv, percent, percent_range)))
515*86d7f5d3SJohn Marino stack;
516*86d7f5d3SJohn Marino
517*86d7f5d3SJohn Marino dev_manager_destroy(dm);
518*86d7f5d3SJohn Marino
519*86d7f5d3SJohn Marino return r;
520*86d7f5d3SJohn Marino }
521*86d7f5d3SJohn Marino
522*86d7f5d3SJohn Marino /* FIXME Merge with snapshot_percent */
lv_mirror_percent(struct cmd_context * cmd,struct logical_volume * lv,int wait,float * percent,percent_range_t * percent_range,uint32_t * event_nr)523*86d7f5d3SJohn Marino int lv_mirror_percent(struct cmd_context *cmd, struct logical_volume *lv,
524*86d7f5d3SJohn Marino int wait, float *percent, percent_range_t *percent_range,
525*86d7f5d3SJohn Marino uint32_t *event_nr)
526*86d7f5d3SJohn Marino {
527*86d7f5d3SJohn Marino int r;
528*86d7f5d3SJohn Marino struct dev_manager *dm;
529*86d7f5d3SJohn Marino struct lvinfo info;
530*86d7f5d3SJohn Marino
531*86d7f5d3SJohn Marino /* If mirrored LV is temporarily shrinked to 1 area (= linear),
532*86d7f5d3SJohn Marino * it should be considered in-sync. */
533*86d7f5d3SJohn Marino if (dm_list_size(&lv->segments) == 1 && first_seg(lv)->area_count == 1) {
534*86d7f5d3SJohn Marino *percent = 100.0;
535*86d7f5d3SJohn Marino return 1;
536*86d7f5d3SJohn Marino }
537*86d7f5d3SJohn Marino
538*86d7f5d3SJohn Marino if (!activation())
539*86d7f5d3SJohn Marino return 0;
540*86d7f5d3SJohn Marino
541*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 0, 0))
542*86d7f5d3SJohn Marino return_0;
543*86d7f5d3SJohn Marino
544*86d7f5d3SJohn Marino if (!info.exists)
545*86d7f5d3SJohn Marino return 0;
546*86d7f5d3SJohn Marino
547*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
548*86d7f5d3SJohn Marino return_0;
549*86d7f5d3SJohn Marino
550*86d7f5d3SJohn Marino if (!(r = dev_manager_mirror_percent(dm, lv, wait, percent,
551*86d7f5d3SJohn Marino percent_range, event_nr)))
552*86d7f5d3SJohn Marino stack;
553*86d7f5d3SJohn Marino
554*86d7f5d3SJohn Marino dev_manager_destroy(dm);
555*86d7f5d3SJohn Marino
556*86d7f5d3SJohn Marino return r;
557*86d7f5d3SJohn Marino }
558*86d7f5d3SJohn Marino
_lv_active(struct cmd_context * cmd,struct logical_volume * lv,unsigned by_uuid_only)559*86d7f5d3SJohn Marino static int _lv_active(struct cmd_context *cmd, struct logical_volume *lv,
560*86d7f5d3SJohn Marino unsigned by_uuid_only)
561*86d7f5d3SJohn Marino {
562*86d7f5d3SJohn Marino struct lvinfo info;
563*86d7f5d3SJohn Marino
564*86d7f5d3SJohn Marino if (!_lv_info(cmd, lv, 0, &info, 0, 0, by_uuid_only)) {
565*86d7f5d3SJohn Marino stack;
566*86d7f5d3SJohn Marino return -1;
567*86d7f5d3SJohn Marino }
568*86d7f5d3SJohn Marino
569*86d7f5d3SJohn Marino return info.exists;
570*86d7f5d3SJohn Marino }
571*86d7f5d3SJohn Marino
_lv_open_count(struct cmd_context * cmd,struct logical_volume * lv)572*86d7f5d3SJohn Marino static int _lv_open_count(struct cmd_context *cmd, struct logical_volume *lv)
573*86d7f5d3SJohn Marino {
574*86d7f5d3SJohn Marino struct lvinfo info;
575*86d7f5d3SJohn Marino
576*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 1, 0)) {
577*86d7f5d3SJohn Marino stack;
578*86d7f5d3SJohn Marino return -1;
579*86d7f5d3SJohn Marino }
580*86d7f5d3SJohn Marino
581*86d7f5d3SJohn Marino return info.open_count;
582*86d7f5d3SJohn Marino }
583*86d7f5d3SJohn Marino
_lv_activate_lv(struct logical_volume * lv)584*86d7f5d3SJohn Marino static int _lv_activate_lv(struct logical_volume *lv)
585*86d7f5d3SJohn Marino {
586*86d7f5d3SJohn Marino int r;
587*86d7f5d3SJohn Marino struct dev_manager *dm;
588*86d7f5d3SJohn Marino
589*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
590*86d7f5d3SJohn Marino return_0;
591*86d7f5d3SJohn Marino
592*86d7f5d3SJohn Marino if (!(r = dev_manager_activate(dm, lv)))
593*86d7f5d3SJohn Marino stack;
594*86d7f5d3SJohn Marino
595*86d7f5d3SJohn Marino dev_manager_destroy(dm);
596*86d7f5d3SJohn Marino return r;
597*86d7f5d3SJohn Marino }
598*86d7f5d3SJohn Marino
_lv_preload(struct logical_volume * lv,int * flush_required)599*86d7f5d3SJohn Marino static int _lv_preload(struct logical_volume *lv, int *flush_required)
600*86d7f5d3SJohn Marino {
601*86d7f5d3SJohn Marino int r;
602*86d7f5d3SJohn Marino struct dev_manager *dm;
603*86d7f5d3SJohn Marino
604*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
605*86d7f5d3SJohn Marino return_0;
606*86d7f5d3SJohn Marino
607*86d7f5d3SJohn Marino if (!(r = dev_manager_preload(dm, lv, flush_required)))
608*86d7f5d3SJohn Marino stack;
609*86d7f5d3SJohn Marino
610*86d7f5d3SJohn Marino dev_manager_destroy(dm);
611*86d7f5d3SJohn Marino return r;
612*86d7f5d3SJohn Marino }
613*86d7f5d3SJohn Marino
_lv_deactivate(struct logical_volume * lv)614*86d7f5d3SJohn Marino static int _lv_deactivate(struct logical_volume *lv)
615*86d7f5d3SJohn Marino {
616*86d7f5d3SJohn Marino int r;
617*86d7f5d3SJohn Marino struct dev_manager *dm;
618*86d7f5d3SJohn Marino
619*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
620*86d7f5d3SJohn Marino return_0;
621*86d7f5d3SJohn Marino
622*86d7f5d3SJohn Marino if (!(r = dev_manager_deactivate(dm, lv)))
623*86d7f5d3SJohn Marino stack;
624*86d7f5d3SJohn Marino
625*86d7f5d3SJohn Marino dev_manager_destroy(dm);
626*86d7f5d3SJohn Marino return r;
627*86d7f5d3SJohn Marino }
628*86d7f5d3SJohn Marino
_lv_suspend_lv(struct logical_volume * lv,int lockfs,int flush_required)629*86d7f5d3SJohn Marino static int _lv_suspend_lv(struct logical_volume *lv, int lockfs, int flush_required)
630*86d7f5d3SJohn Marino {
631*86d7f5d3SJohn Marino int r;
632*86d7f5d3SJohn Marino struct dev_manager *dm;
633*86d7f5d3SJohn Marino
634*86d7f5d3SJohn Marino if (!(dm = dev_manager_create(lv->vg->cmd, lv->vg->name)))
635*86d7f5d3SJohn Marino return_0;
636*86d7f5d3SJohn Marino
637*86d7f5d3SJohn Marino if (!(r = dev_manager_suspend(dm, lv, lockfs, flush_required)))
638*86d7f5d3SJohn Marino stack;
639*86d7f5d3SJohn Marino
640*86d7f5d3SJohn Marino dev_manager_destroy(dm);
641*86d7f5d3SJohn Marino return r;
642*86d7f5d3SJohn Marino }
643*86d7f5d3SJohn Marino
644*86d7f5d3SJohn Marino /*
645*86d7f5d3SJohn Marino * These two functions return the number of visible LVs in the state,
646*86d7f5d3SJohn Marino * or -1 on error.
647*86d7f5d3SJohn Marino */
_lvs_in_vg_activated(struct volume_group * vg,unsigned by_uuid_only)648*86d7f5d3SJohn Marino static int _lvs_in_vg_activated(struct volume_group *vg, unsigned by_uuid_only)
649*86d7f5d3SJohn Marino {
650*86d7f5d3SJohn Marino struct lv_list *lvl;
651*86d7f5d3SJohn Marino int count = 0;
652*86d7f5d3SJohn Marino
653*86d7f5d3SJohn Marino if (!activation())
654*86d7f5d3SJohn Marino return 0;
655*86d7f5d3SJohn Marino
656*86d7f5d3SJohn Marino dm_list_iterate_items(lvl, &vg->lvs) {
657*86d7f5d3SJohn Marino if (lv_is_visible(lvl->lv))
658*86d7f5d3SJohn Marino count += (_lv_active(vg->cmd, lvl->lv, by_uuid_only) == 1);
659*86d7f5d3SJohn Marino }
660*86d7f5d3SJohn Marino
661*86d7f5d3SJohn Marino return count;
662*86d7f5d3SJohn Marino }
663*86d7f5d3SJohn Marino
lvs_in_vg_activated_by_uuid_only(struct volume_group * vg)664*86d7f5d3SJohn Marino int lvs_in_vg_activated_by_uuid_only(struct volume_group *vg)
665*86d7f5d3SJohn Marino {
666*86d7f5d3SJohn Marino return _lvs_in_vg_activated(vg, 1);
667*86d7f5d3SJohn Marino }
668*86d7f5d3SJohn Marino
lvs_in_vg_activated(struct volume_group * vg)669*86d7f5d3SJohn Marino int lvs_in_vg_activated(struct volume_group *vg)
670*86d7f5d3SJohn Marino {
671*86d7f5d3SJohn Marino return _lvs_in_vg_activated(vg, 0);
672*86d7f5d3SJohn Marino }
673*86d7f5d3SJohn Marino
lvs_in_vg_opened(const struct volume_group * vg)674*86d7f5d3SJohn Marino int lvs_in_vg_opened(const struct volume_group *vg)
675*86d7f5d3SJohn Marino {
676*86d7f5d3SJohn Marino const struct lv_list *lvl;
677*86d7f5d3SJohn Marino int count = 0;
678*86d7f5d3SJohn Marino
679*86d7f5d3SJohn Marino if (!activation())
680*86d7f5d3SJohn Marino return 0;
681*86d7f5d3SJohn Marino
682*86d7f5d3SJohn Marino dm_list_iterate_items(lvl, &vg->lvs) {
683*86d7f5d3SJohn Marino if (lv_is_visible(lvl->lv))
684*86d7f5d3SJohn Marino count += (_lv_open_count(vg->cmd, lvl->lv) > 0);
685*86d7f5d3SJohn Marino }
686*86d7f5d3SJohn Marino
687*86d7f5d3SJohn Marino return count;
688*86d7f5d3SJohn Marino }
689*86d7f5d3SJohn Marino
690*86d7f5d3SJohn Marino /*
691*86d7f5d3SJohn Marino * Determine whether an LV is active locally or in a cluster.
692*86d7f5d3SJohn Marino * Assumes vg lock held.
693*86d7f5d3SJohn Marino * Returns:
694*86d7f5d3SJohn Marino * 0 - not active locally or on any node in cluster
695*86d7f5d3SJohn Marino * 1 - active either locally or some node in the cluster
696*86d7f5d3SJohn Marino */
lv_is_active(struct logical_volume * lv)697*86d7f5d3SJohn Marino int lv_is_active(struct logical_volume *lv)
698*86d7f5d3SJohn Marino {
699*86d7f5d3SJohn Marino int ret;
700*86d7f5d3SJohn Marino
701*86d7f5d3SJohn Marino if (_lv_active(lv->vg->cmd, lv, 0))
702*86d7f5d3SJohn Marino return 1;
703*86d7f5d3SJohn Marino
704*86d7f5d3SJohn Marino if (!vg_is_clustered(lv->vg))
705*86d7f5d3SJohn Marino return 0;
706*86d7f5d3SJohn Marino
707*86d7f5d3SJohn Marino if ((ret = remote_lock_held(lv->lvid.s)) >= 0)
708*86d7f5d3SJohn Marino return ret;
709*86d7f5d3SJohn Marino
710*86d7f5d3SJohn Marino /*
711*86d7f5d3SJohn Marino * Old compatibility code if locking doesn't support lock query
712*86d7f5d3SJohn Marino * FIXME: check status to not deactivate already activate device
713*86d7f5d3SJohn Marino */
714*86d7f5d3SJohn Marino if (activate_lv_excl(lv->vg->cmd, lv)) {
715*86d7f5d3SJohn Marino deactivate_lv(lv->vg->cmd, lv);
716*86d7f5d3SJohn Marino return 0;
717*86d7f5d3SJohn Marino }
718*86d7f5d3SJohn Marino
719*86d7f5d3SJohn Marino /*
720*86d7f5d3SJohn Marino * Exclusive local activation failed so assume it is active elsewhere.
721*86d7f5d3SJohn Marino */
722*86d7f5d3SJohn Marino return 1;
723*86d7f5d3SJohn Marino }
724*86d7f5d3SJohn Marino
725*86d7f5d3SJohn Marino /*
726*86d7f5d3SJohn Marino * Returns 0 if an attempt to (un)monitor the device failed.
727*86d7f5d3SJohn Marino * Returns 1 otherwise.
728*86d7f5d3SJohn Marino */
monitor_dev_for_events(struct cmd_context * cmd,struct logical_volume * lv,int monitor)729*86d7f5d3SJohn Marino int monitor_dev_for_events(struct cmd_context *cmd,
730*86d7f5d3SJohn Marino struct logical_volume *lv, int monitor)
731*86d7f5d3SJohn Marino {
732*86d7f5d3SJohn Marino #ifdef DMEVENTD
733*86d7f5d3SJohn Marino int i, pending = 0, monitored;
734*86d7f5d3SJohn Marino int r = 1;
735*86d7f5d3SJohn Marino struct dm_list *tmp, *snh, *snht;
736*86d7f5d3SJohn Marino struct lv_segment *seg;
737*86d7f5d3SJohn Marino int (*monitor_fn) (struct lv_segment *s, int e);
738*86d7f5d3SJohn Marino uint32_t s;
739*86d7f5d3SJohn Marino
740*86d7f5d3SJohn Marino /* skip dmeventd code altogether */
741*86d7f5d3SJohn Marino if (dmeventd_monitor_mode() == DMEVENTD_MONITOR_IGNORE)
742*86d7f5d3SJohn Marino return 1;
743*86d7f5d3SJohn Marino
744*86d7f5d3SJohn Marino /*
745*86d7f5d3SJohn Marino * Nothing to do if dmeventd configured not to be used.
746*86d7f5d3SJohn Marino */
747*86d7f5d3SJohn Marino if (monitor && !dmeventd_monitor_mode())
748*86d7f5d3SJohn Marino return 1;
749*86d7f5d3SJohn Marino
750*86d7f5d3SJohn Marino /*
751*86d7f5d3SJohn Marino * In case of a snapshot device, we monitor lv->snapshot->lv,
752*86d7f5d3SJohn Marino * not the actual LV itself.
753*86d7f5d3SJohn Marino */
754*86d7f5d3SJohn Marino if (lv_is_cow(lv))
755*86d7f5d3SJohn Marino return monitor_dev_for_events(cmd, lv->snapshot->lv, monitor);
756*86d7f5d3SJohn Marino
757*86d7f5d3SJohn Marino /*
758*86d7f5d3SJohn Marino * In case this LV is a snapshot origin, we instead monitor
759*86d7f5d3SJohn Marino * each of its respective snapshots (the origin itself does
760*86d7f5d3SJohn Marino * not need to be monitored).
761*86d7f5d3SJohn Marino *
762*86d7f5d3SJohn Marino * TODO: This may change when snapshots of mirrors are allowed.
763*86d7f5d3SJohn Marino */
764*86d7f5d3SJohn Marino if (lv_is_origin(lv)) {
765*86d7f5d3SJohn Marino dm_list_iterate_safe(snh, snht, &lv->snapshot_segs)
766*86d7f5d3SJohn Marino if (!monitor_dev_for_events(cmd, dm_list_struct_base(snh,
767*86d7f5d3SJohn Marino struct lv_segment, origin_list)->cow, monitor))
768*86d7f5d3SJohn Marino r = 0;
769*86d7f5d3SJohn Marino return r;
770*86d7f5d3SJohn Marino }
771*86d7f5d3SJohn Marino
772*86d7f5d3SJohn Marino dm_list_iterate(tmp, &lv->segments) {
773*86d7f5d3SJohn Marino seg = dm_list_item(tmp, struct lv_segment);
774*86d7f5d3SJohn Marino
775*86d7f5d3SJohn Marino /* Recurse for AREA_LV */
776*86d7f5d3SJohn Marino for (s = 0; s < seg->area_count; s++) {
777*86d7f5d3SJohn Marino if (seg_type(seg, s) != AREA_LV)
778*86d7f5d3SJohn Marino continue;
779*86d7f5d3SJohn Marino if (!monitor_dev_for_events(cmd, seg_lv(seg, s),
780*86d7f5d3SJohn Marino monitor)) {
781*86d7f5d3SJohn Marino log_error("Failed to %smonitor %s",
782*86d7f5d3SJohn Marino monitor ? "" : "un",
783*86d7f5d3SJohn Marino seg_lv(seg, s)->name);
784*86d7f5d3SJohn Marino r = 0;
785*86d7f5d3SJohn Marino }
786*86d7f5d3SJohn Marino }
787*86d7f5d3SJohn Marino
788*86d7f5d3SJohn Marino if (!seg_monitored(seg) || (seg->status & PVMOVE))
789*86d7f5d3SJohn Marino continue;
790*86d7f5d3SJohn Marino
791*86d7f5d3SJohn Marino monitor_fn = NULL;
792*86d7f5d3SJohn Marino
793*86d7f5d3SJohn Marino /* Check monitoring status */
794*86d7f5d3SJohn Marino if (seg->segtype->ops->target_monitored)
795*86d7f5d3SJohn Marino monitored = seg->segtype->ops->target_monitored(seg, &pending);
796*86d7f5d3SJohn Marino else
797*86d7f5d3SJohn Marino continue; /* segtype doesn't support registration */
798*86d7f5d3SJohn Marino
799*86d7f5d3SJohn Marino /*
800*86d7f5d3SJohn Marino * FIXME: We should really try again if pending
801*86d7f5d3SJohn Marino */
802*86d7f5d3SJohn Marino monitored = (pending) ? 0 : monitored;
803*86d7f5d3SJohn Marino
804*86d7f5d3SJohn Marino if (monitor) {
805*86d7f5d3SJohn Marino if (monitored)
806*86d7f5d3SJohn Marino log_verbose("%s/%s already monitored.", lv->vg->name, lv->name);
807*86d7f5d3SJohn Marino else if (seg->segtype->ops->target_monitor_events)
808*86d7f5d3SJohn Marino monitor_fn = seg->segtype->ops->target_monitor_events;
809*86d7f5d3SJohn Marino } else {
810*86d7f5d3SJohn Marino if (!monitored)
811*86d7f5d3SJohn Marino log_verbose("%s/%s already not monitored.", lv->vg->name, lv->name);
812*86d7f5d3SJohn Marino else if (seg->segtype->ops->target_unmonitor_events)
813*86d7f5d3SJohn Marino monitor_fn = seg->segtype->ops->target_unmonitor_events;
814*86d7f5d3SJohn Marino }
815*86d7f5d3SJohn Marino
816*86d7f5d3SJohn Marino /* Do [un]monitor */
817*86d7f5d3SJohn Marino if (!monitor_fn)
818*86d7f5d3SJohn Marino continue;
819*86d7f5d3SJohn Marino
820*86d7f5d3SJohn Marino log_verbose("%sonitoring %s/%s", monitor ? "M" : "Not m", lv->vg->name, lv->name);
821*86d7f5d3SJohn Marino
822*86d7f5d3SJohn Marino /* FIXME specify events */
823*86d7f5d3SJohn Marino if (!monitor_fn(seg, 0)) {
824*86d7f5d3SJohn Marino log_error("%s/%s: %s segment monitoring function failed.",
825*86d7f5d3SJohn Marino lv->vg->name, lv->name, seg->segtype->name);
826*86d7f5d3SJohn Marino return 0;
827*86d7f5d3SJohn Marino }
828*86d7f5d3SJohn Marino
829*86d7f5d3SJohn Marino /* Check [un]monitor results */
830*86d7f5d3SJohn Marino /* Try a couple times if pending, but not forever... */
831*86d7f5d3SJohn Marino for (i = 0; i < 10; i++) {
832*86d7f5d3SJohn Marino pending = 0;
833*86d7f5d3SJohn Marino monitored = seg->segtype->ops->target_monitored(seg, &pending);
834*86d7f5d3SJohn Marino if (pending ||
835*86d7f5d3SJohn Marino (!monitored && monitor) ||
836*86d7f5d3SJohn Marino (monitored && !monitor))
837*86d7f5d3SJohn Marino log_very_verbose("%s/%s %smonitoring still pending: waiting...",
838*86d7f5d3SJohn Marino lv->vg->name, lv->name, monitor ? "" : "un");
839*86d7f5d3SJohn Marino else
840*86d7f5d3SJohn Marino break;
841*86d7f5d3SJohn Marino sleep(1);
842*86d7f5d3SJohn Marino }
843*86d7f5d3SJohn Marino
844*86d7f5d3SJohn Marino r = (monitored && monitor) || (!monitored && !monitor);
845*86d7f5d3SJohn Marino }
846*86d7f5d3SJohn Marino
847*86d7f5d3SJohn Marino return r;
848*86d7f5d3SJohn Marino #else
849*86d7f5d3SJohn Marino return 1;
850*86d7f5d3SJohn Marino #endif
851*86d7f5d3SJohn Marino }
852*86d7f5d3SJohn Marino
_lv_suspend(struct cmd_context * cmd,const char * lvid_s,int error_if_not_suspended)853*86d7f5d3SJohn Marino static int _lv_suspend(struct cmd_context *cmd, const char *lvid_s,
854*86d7f5d3SJohn Marino int error_if_not_suspended)
855*86d7f5d3SJohn Marino {
856*86d7f5d3SJohn Marino struct logical_volume *lv = NULL, *lv_pre = NULL;
857*86d7f5d3SJohn Marino struct lvinfo info;
858*86d7f5d3SJohn Marino int r = 0, lockfs = 0, flush_required = 0;
859*86d7f5d3SJohn Marino
860*86d7f5d3SJohn Marino if (!activation())
861*86d7f5d3SJohn Marino return 1;
862*86d7f5d3SJohn Marino
863*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
864*86d7f5d3SJohn Marino goto_out;
865*86d7f5d3SJohn Marino
866*86d7f5d3SJohn Marino /* Use precommitted metadata if present */
867*86d7f5d3SJohn Marino if (!(lv_pre = lv_from_lvid(cmd, lvid_s, 1)))
868*86d7f5d3SJohn Marino goto_out;
869*86d7f5d3SJohn Marino
870*86d7f5d3SJohn Marino if (test_mode()) {
871*86d7f5d3SJohn Marino _skip("Suspending '%s'.", lv->name);
872*86d7f5d3SJohn Marino r = 1;
873*86d7f5d3SJohn Marino goto out;
874*86d7f5d3SJohn Marino }
875*86d7f5d3SJohn Marino
876*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 0, 0))
877*86d7f5d3SJohn Marino goto_out;
878*86d7f5d3SJohn Marino
879*86d7f5d3SJohn Marino if (!info.exists || info.suspended) {
880*86d7f5d3SJohn Marino r = error_if_not_suspended ? 0 : 1;
881*86d7f5d3SJohn Marino goto out;
882*86d7f5d3SJohn Marino }
883*86d7f5d3SJohn Marino
884*86d7f5d3SJohn Marino lv_calculate_readahead(lv, NULL);
885*86d7f5d3SJohn Marino
886*86d7f5d3SJohn Marino /* If VG was precommitted, preload devices for the LV */
887*86d7f5d3SJohn Marino if ((lv_pre->vg->status & PRECOMMITTED)) {
888*86d7f5d3SJohn Marino if (!_lv_preload(lv_pre, &flush_required)) {
889*86d7f5d3SJohn Marino /* FIXME Revert preloading */
890*86d7f5d3SJohn Marino goto_out;
891*86d7f5d3SJohn Marino }
892*86d7f5d3SJohn Marino }
893*86d7f5d3SJohn Marino
894*86d7f5d3SJohn Marino if (!monitor_dev_for_events(cmd, lv, 0))
895*86d7f5d3SJohn Marino /* FIXME Consider aborting here */
896*86d7f5d3SJohn Marino stack;
897*86d7f5d3SJohn Marino
898*86d7f5d3SJohn Marino memlock_inc();
899*86d7f5d3SJohn Marino
900*86d7f5d3SJohn Marino if (lv_is_origin(lv_pre) || lv_is_cow(lv_pre))
901*86d7f5d3SJohn Marino lockfs = 1;
902*86d7f5d3SJohn Marino
903*86d7f5d3SJohn Marino if (!_lv_suspend_lv(lv, lockfs, flush_required)) {
904*86d7f5d3SJohn Marino memlock_dec();
905*86d7f5d3SJohn Marino fs_unlock();
906*86d7f5d3SJohn Marino goto out;
907*86d7f5d3SJohn Marino }
908*86d7f5d3SJohn Marino
909*86d7f5d3SJohn Marino r = 1;
910*86d7f5d3SJohn Marino out:
911*86d7f5d3SJohn Marino if (lv_pre)
912*86d7f5d3SJohn Marino vg_release(lv_pre->vg);
913*86d7f5d3SJohn Marino if (lv)
914*86d7f5d3SJohn Marino vg_release(lv->vg);
915*86d7f5d3SJohn Marino
916*86d7f5d3SJohn Marino return r;
917*86d7f5d3SJohn Marino }
918*86d7f5d3SJohn Marino
919*86d7f5d3SJohn Marino /* Returns success if the device is not active */
lv_suspend_if_active(struct cmd_context * cmd,const char * lvid_s)920*86d7f5d3SJohn Marino int lv_suspend_if_active(struct cmd_context *cmd, const char *lvid_s)
921*86d7f5d3SJohn Marino {
922*86d7f5d3SJohn Marino return _lv_suspend(cmd, lvid_s, 0);
923*86d7f5d3SJohn Marino }
924*86d7f5d3SJohn Marino
lv_suspend(struct cmd_context * cmd,const char * lvid_s)925*86d7f5d3SJohn Marino int lv_suspend(struct cmd_context *cmd, const char *lvid_s)
926*86d7f5d3SJohn Marino {
927*86d7f5d3SJohn Marino return _lv_suspend(cmd, lvid_s, 1);
928*86d7f5d3SJohn Marino }
929*86d7f5d3SJohn Marino
_lv_resume(struct cmd_context * cmd,const char * lvid_s,int error_if_not_active)930*86d7f5d3SJohn Marino static int _lv_resume(struct cmd_context *cmd, const char *lvid_s,
931*86d7f5d3SJohn Marino int error_if_not_active)
932*86d7f5d3SJohn Marino {
933*86d7f5d3SJohn Marino struct logical_volume *lv;
934*86d7f5d3SJohn Marino struct lvinfo info;
935*86d7f5d3SJohn Marino int r = 0;
936*86d7f5d3SJohn Marino
937*86d7f5d3SJohn Marino if (!activation())
938*86d7f5d3SJohn Marino return 1;
939*86d7f5d3SJohn Marino
940*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
941*86d7f5d3SJohn Marino goto_out;
942*86d7f5d3SJohn Marino
943*86d7f5d3SJohn Marino if (test_mode()) {
944*86d7f5d3SJohn Marino _skip("Resuming '%s'.", lv->name);
945*86d7f5d3SJohn Marino r = 1;
946*86d7f5d3SJohn Marino goto out;
947*86d7f5d3SJohn Marino }
948*86d7f5d3SJohn Marino
949*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 0, 0))
950*86d7f5d3SJohn Marino goto_out;
951*86d7f5d3SJohn Marino
952*86d7f5d3SJohn Marino if (!info.exists || !info.suspended) {
953*86d7f5d3SJohn Marino r = error_if_not_active ? 0 : 1;
954*86d7f5d3SJohn Marino goto_out;
955*86d7f5d3SJohn Marino }
956*86d7f5d3SJohn Marino
957*86d7f5d3SJohn Marino if (!_lv_activate_lv(lv))
958*86d7f5d3SJohn Marino goto_out;
959*86d7f5d3SJohn Marino
960*86d7f5d3SJohn Marino memlock_dec();
961*86d7f5d3SJohn Marino fs_unlock();
962*86d7f5d3SJohn Marino
963*86d7f5d3SJohn Marino if (!monitor_dev_for_events(cmd, lv, 1))
964*86d7f5d3SJohn Marino stack;
965*86d7f5d3SJohn Marino
966*86d7f5d3SJohn Marino r = 1;
967*86d7f5d3SJohn Marino out:
968*86d7f5d3SJohn Marino if (lv)
969*86d7f5d3SJohn Marino vg_release(lv->vg);
970*86d7f5d3SJohn Marino
971*86d7f5d3SJohn Marino return r;
972*86d7f5d3SJohn Marino }
973*86d7f5d3SJohn Marino
974*86d7f5d3SJohn Marino /* Returns success if the device is not active */
lv_resume_if_active(struct cmd_context * cmd,const char * lvid_s)975*86d7f5d3SJohn Marino int lv_resume_if_active(struct cmd_context *cmd, const char *lvid_s)
976*86d7f5d3SJohn Marino {
977*86d7f5d3SJohn Marino return _lv_resume(cmd, lvid_s, 0);
978*86d7f5d3SJohn Marino }
979*86d7f5d3SJohn Marino
lv_resume(struct cmd_context * cmd,const char * lvid_s)980*86d7f5d3SJohn Marino int lv_resume(struct cmd_context *cmd, const char *lvid_s)
981*86d7f5d3SJohn Marino {
982*86d7f5d3SJohn Marino return _lv_resume(cmd, lvid_s, 1);
983*86d7f5d3SJohn Marino }
984*86d7f5d3SJohn Marino
_lv_has_open_snapshots(struct logical_volume * lv)985*86d7f5d3SJohn Marino static int _lv_has_open_snapshots(struct logical_volume *lv)
986*86d7f5d3SJohn Marino {
987*86d7f5d3SJohn Marino struct lv_segment *snap_seg;
988*86d7f5d3SJohn Marino struct lvinfo info;
989*86d7f5d3SJohn Marino int r = 0;
990*86d7f5d3SJohn Marino
991*86d7f5d3SJohn Marino dm_list_iterate_items_gen(snap_seg, &lv->snapshot_segs, origin_list) {
992*86d7f5d3SJohn Marino if (!lv_info(lv->vg->cmd, snap_seg->cow, &info, 1, 0)) {
993*86d7f5d3SJohn Marino r = 1;
994*86d7f5d3SJohn Marino continue;
995*86d7f5d3SJohn Marino }
996*86d7f5d3SJohn Marino
997*86d7f5d3SJohn Marino if (info.exists && info.open_count) {
998*86d7f5d3SJohn Marino log_error("LV %s/%s has open snapshot %s: "
999*86d7f5d3SJohn Marino "not deactivating", lv->vg->name, lv->name,
1000*86d7f5d3SJohn Marino snap_seg->cow->name);
1001*86d7f5d3SJohn Marino r = 1;
1002*86d7f5d3SJohn Marino }
1003*86d7f5d3SJohn Marino }
1004*86d7f5d3SJohn Marino
1005*86d7f5d3SJohn Marino return r;
1006*86d7f5d3SJohn Marino }
1007*86d7f5d3SJohn Marino
lv_deactivate(struct cmd_context * cmd,const char * lvid_s)1008*86d7f5d3SJohn Marino int lv_deactivate(struct cmd_context *cmd, const char *lvid_s)
1009*86d7f5d3SJohn Marino {
1010*86d7f5d3SJohn Marino struct logical_volume *lv;
1011*86d7f5d3SJohn Marino struct lvinfo info;
1012*86d7f5d3SJohn Marino int r = 0;
1013*86d7f5d3SJohn Marino
1014*86d7f5d3SJohn Marino if (!activation())
1015*86d7f5d3SJohn Marino return 1;
1016*86d7f5d3SJohn Marino
1017*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
1018*86d7f5d3SJohn Marino goto out;
1019*86d7f5d3SJohn Marino
1020*86d7f5d3SJohn Marino if (test_mode()) {
1021*86d7f5d3SJohn Marino _skip("Deactivating '%s'.", lv->name);
1022*86d7f5d3SJohn Marino r = 1;
1023*86d7f5d3SJohn Marino goto out;
1024*86d7f5d3SJohn Marino }
1025*86d7f5d3SJohn Marino
1026*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 1, 0))
1027*86d7f5d3SJohn Marino goto_out;
1028*86d7f5d3SJohn Marino
1029*86d7f5d3SJohn Marino if (!info.exists) {
1030*86d7f5d3SJohn Marino r = 1;
1031*86d7f5d3SJohn Marino goto out;
1032*86d7f5d3SJohn Marino }
1033*86d7f5d3SJohn Marino
1034*86d7f5d3SJohn Marino if (lv_is_visible(lv)) {
1035*86d7f5d3SJohn Marino if (info.open_count) {
1036*86d7f5d3SJohn Marino log_error("LV %s/%s in use: not deactivating",
1037*86d7f5d3SJohn Marino lv->vg->name, lv->name);
1038*86d7f5d3SJohn Marino goto out;
1039*86d7f5d3SJohn Marino }
1040*86d7f5d3SJohn Marino if (lv_is_origin(lv) && _lv_has_open_snapshots(lv))
1041*86d7f5d3SJohn Marino goto_out;
1042*86d7f5d3SJohn Marino }
1043*86d7f5d3SJohn Marino
1044*86d7f5d3SJohn Marino lv_calculate_readahead(lv, NULL);
1045*86d7f5d3SJohn Marino
1046*86d7f5d3SJohn Marino if (!monitor_dev_for_events(cmd, lv, 0))
1047*86d7f5d3SJohn Marino stack;
1048*86d7f5d3SJohn Marino
1049*86d7f5d3SJohn Marino memlock_inc();
1050*86d7f5d3SJohn Marino r = _lv_deactivate(lv);
1051*86d7f5d3SJohn Marino memlock_dec();
1052*86d7f5d3SJohn Marino fs_unlock();
1053*86d7f5d3SJohn Marino
1054*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 1, 0) || info.exists)
1055*86d7f5d3SJohn Marino r = 0;
1056*86d7f5d3SJohn Marino out:
1057*86d7f5d3SJohn Marino if (lv)
1058*86d7f5d3SJohn Marino vg_release(lv->vg);
1059*86d7f5d3SJohn Marino
1060*86d7f5d3SJohn Marino return r;
1061*86d7f5d3SJohn Marino }
1062*86d7f5d3SJohn Marino
1063*86d7f5d3SJohn Marino /* Test if LV passes filter */
lv_activation_filter(struct cmd_context * cmd,const char * lvid_s,int * activate_lv)1064*86d7f5d3SJohn Marino int lv_activation_filter(struct cmd_context *cmd, const char *lvid_s,
1065*86d7f5d3SJohn Marino int *activate_lv)
1066*86d7f5d3SJohn Marino {
1067*86d7f5d3SJohn Marino struct logical_volume *lv;
1068*86d7f5d3SJohn Marino int r = 0;
1069*86d7f5d3SJohn Marino
1070*86d7f5d3SJohn Marino if (!activation()) {
1071*86d7f5d3SJohn Marino *activate_lv = 1;
1072*86d7f5d3SJohn Marino return 1;
1073*86d7f5d3SJohn Marino }
1074*86d7f5d3SJohn Marino
1075*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
1076*86d7f5d3SJohn Marino goto out;
1077*86d7f5d3SJohn Marino
1078*86d7f5d3SJohn Marino if (!_passes_activation_filter(cmd, lv)) {
1079*86d7f5d3SJohn Marino log_verbose("Not activating %s/%s due to config file settings",
1080*86d7f5d3SJohn Marino lv->vg->name, lv->name);
1081*86d7f5d3SJohn Marino *activate_lv = 0;
1082*86d7f5d3SJohn Marino } else
1083*86d7f5d3SJohn Marino *activate_lv = 1;
1084*86d7f5d3SJohn Marino r = 1;
1085*86d7f5d3SJohn Marino out:
1086*86d7f5d3SJohn Marino if (lv)
1087*86d7f5d3SJohn Marino vg_release(lv->vg);
1088*86d7f5d3SJohn Marino
1089*86d7f5d3SJohn Marino return r;
1090*86d7f5d3SJohn Marino }
1091*86d7f5d3SJohn Marino
_lv_activate(struct cmd_context * cmd,const char * lvid_s,int exclusive,int filter)1092*86d7f5d3SJohn Marino static int _lv_activate(struct cmd_context *cmd, const char *lvid_s,
1093*86d7f5d3SJohn Marino int exclusive, int filter)
1094*86d7f5d3SJohn Marino {
1095*86d7f5d3SJohn Marino struct logical_volume *lv;
1096*86d7f5d3SJohn Marino struct lvinfo info;
1097*86d7f5d3SJohn Marino int r = 0;
1098*86d7f5d3SJohn Marino
1099*86d7f5d3SJohn Marino if (!activation())
1100*86d7f5d3SJohn Marino return 1;
1101*86d7f5d3SJohn Marino
1102*86d7f5d3SJohn Marino if (!(lv = lv_from_lvid(cmd, lvid_s, 0)))
1103*86d7f5d3SJohn Marino goto out;
1104*86d7f5d3SJohn Marino
1105*86d7f5d3SJohn Marino if (filter && !_passes_activation_filter(cmd, lv)) {
1106*86d7f5d3SJohn Marino log_verbose("Not activating %s/%s due to config file settings",
1107*86d7f5d3SJohn Marino lv->vg->name, lv->name);
1108*86d7f5d3SJohn Marino goto out;
1109*86d7f5d3SJohn Marino }
1110*86d7f5d3SJohn Marino
1111*86d7f5d3SJohn Marino if ((!lv->vg->cmd->partial_activation) && (lv->status & PARTIAL_LV)) {
1112*86d7f5d3SJohn Marino log_error("Refusing activation of partial LV %s. Use --partial to override.",
1113*86d7f5d3SJohn Marino lv->name);
1114*86d7f5d3SJohn Marino goto_out;
1115*86d7f5d3SJohn Marino }
1116*86d7f5d3SJohn Marino
1117*86d7f5d3SJohn Marino if (lv_has_unknown_segments(lv)) {
1118*86d7f5d3SJohn Marino log_error("Refusing activation of LV %s containing "
1119*86d7f5d3SJohn Marino "an unrecognised segment.", lv->name);
1120*86d7f5d3SJohn Marino goto_out;
1121*86d7f5d3SJohn Marino }
1122*86d7f5d3SJohn Marino
1123*86d7f5d3SJohn Marino if (test_mode()) {
1124*86d7f5d3SJohn Marino _skip("Activating '%s'.", lv->name);
1125*86d7f5d3SJohn Marino r = 1;
1126*86d7f5d3SJohn Marino goto out;
1127*86d7f5d3SJohn Marino }
1128*86d7f5d3SJohn Marino
1129*86d7f5d3SJohn Marino if (!lv_info(cmd, lv, &info, 0, 0))
1130*86d7f5d3SJohn Marino goto_out;
1131*86d7f5d3SJohn Marino
1132*86d7f5d3SJohn Marino if (info.exists && !info.suspended && info.live_table) {
1133*86d7f5d3SJohn Marino r = 1;
1134*86d7f5d3SJohn Marino goto out;
1135*86d7f5d3SJohn Marino }
1136*86d7f5d3SJohn Marino
1137*86d7f5d3SJohn Marino lv_calculate_readahead(lv, NULL);
1138*86d7f5d3SJohn Marino
1139*86d7f5d3SJohn Marino if (exclusive)
1140*86d7f5d3SJohn Marino lv->status |= ACTIVATE_EXCL;
1141*86d7f5d3SJohn Marino
1142*86d7f5d3SJohn Marino memlock_inc();
1143*86d7f5d3SJohn Marino if (!(r = _lv_activate_lv(lv)))
1144*86d7f5d3SJohn Marino stack;
1145*86d7f5d3SJohn Marino memlock_dec();
1146*86d7f5d3SJohn Marino fs_unlock();
1147*86d7f5d3SJohn Marino
1148*86d7f5d3SJohn Marino if (r && !monitor_dev_for_events(cmd, lv, 1))
1149*86d7f5d3SJohn Marino stack;
1150*86d7f5d3SJohn Marino
1151*86d7f5d3SJohn Marino out:
1152*86d7f5d3SJohn Marino if (lv)
1153*86d7f5d3SJohn Marino vg_release(lv->vg);
1154*86d7f5d3SJohn Marino
1155*86d7f5d3SJohn Marino return r;
1156*86d7f5d3SJohn Marino }
1157*86d7f5d3SJohn Marino
1158*86d7f5d3SJohn Marino /* Activate LV */
lv_activate(struct cmd_context * cmd,const char * lvid_s,int exclusive)1159*86d7f5d3SJohn Marino int lv_activate(struct cmd_context *cmd, const char *lvid_s, int exclusive)
1160*86d7f5d3SJohn Marino {
1161*86d7f5d3SJohn Marino if (!_lv_activate(cmd, lvid_s, exclusive, 0))
1162*86d7f5d3SJohn Marino return_0;
1163*86d7f5d3SJohn Marino
1164*86d7f5d3SJohn Marino return 1;
1165*86d7f5d3SJohn Marino }
1166*86d7f5d3SJohn Marino
1167*86d7f5d3SJohn Marino /* Activate LV only if it passes filter */
lv_activate_with_filter(struct cmd_context * cmd,const char * lvid_s,int exclusive)1168*86d7f5d3SJohn Marino int lv_activate_with_filter(struct cmd_context *cmd, const char *lvid_s, int exclusive)
1169*86d7f5d3SJohn Marino {
1170*86d7f5d3SJohn Marino if (!_lv_activate(cmd, lvid_s, exclusive, 1))
1171*86d7f5d3SJohn Marino return_0;
1172*86d7f5d3SJohn Marino
1173*86d7f5d3SJohn Marino return 1;
1174*86d7f5d3SJohn Marino }
1175*86d7f5d3SJohn Marino
lv_mknodes(struct cmd_context * cmd,const struct logical_volume * lv)1176*86d7f5d3SJohn Marino int lv_mknodes(struct cmd_context *cmd, const struct logical_volume *lv)
1177*86d7f5d3SJohn Marino {
1178*86d7f5d3SJohn Marino struct lvinfo info;
1179*86d7f5d3SJohn Marino int r = 1;
1180*86d7f5d3SJohn Marino
1181*86d7f5d3SJohn Marino if (!lv) {
1182*86d7f5d3SJohn Marino r = dm_mknodes(NULL);
1183*86d7f5d3SJohn Marino fs_unlock();
1184*86d7f5d3SJohn Marino return r;
1185*86d7f5d3SJohn Marino }
1186*86d7f5d3SJohn Marino
1187*86d7f5d3SJohn Marino if (!_lv_info(cmd, lv, 1, &info, 0, 0, 0))
1188*86d7f5d3SJohn Marino return_0;
1189*86d7f5d3SJohn Marino
1190*86d7f5d3SJohn Marino if (info.exists) {
1191*86d7f5d3SJohn Marino if (lv_is_visible(lv))
1192*86d7f5d3SJohn Marino r = dev_manager_lv_mknodes(lv);
1193*86d7f5d3SJohn Marino } else
1194*86d7f5d3SJohn Marino r = dev_manager_lv_rmnodes(lv);
1195*86d7f5d3SJohn Marino
1196*86d7f5d3SJohn Marino fs_unlock();
1197*86d7f5d3SJohn Marino
1198*86d7f5d3SJohn Marino return r;
1199*86d7f5d3SJohn Marino }
1200*86d7f5d3SJohn Marino
1201*86d7f5d3SJohn Marino /*
1202*86d7f5d3SJohn Marino * Does PV use VG somewhere in its construction?
1203*86d7f5d3SJohn Marino * Returns 1 on failure.
1204*86d7f5d3SJohn Marino */
pv_uses_vg(struct physical_volume * pv,struct volume_group * vg)1205*86d7f5d3SJohn Marino int pv_uses_vg(struct physical_volume *pv,
1206*86d7f5d3SJohn Marino struct volume_group *vg)
1207*86d7f5d3SJohn Marino {
1208*86d7f5d3SJohn Marino if (!activation())
1209*86d7f5d3SJohn Marino return 0;
1210*86d7f5d3SJohn Marino
1211*86d7f5d3SJohn Marino if (!dm_is_dm_major(MAJOR(pv->dev->dev)))
1212*86d7f5d3SJohn Marino return 0;
1213*86d7f5d3SJohn Marino
1214*86d7f5d3SJohn Marino return dev_manager_device_uses_vg(pv->dev, vg);
1215*86d7f5d3SJohn Marino }
1216*86d7f5d3SJohn Marino
activation_release(void)1217*86d7f5d3SJohn Marino void activation_release(void)
1218*86d7f5d3SJohn Marino {
1219*86d7f5d3SJohn Marino dev_manager_release();
1220*86d7f5d3SJohn Marino }
1221*86d7f5d3SJohn Marino
activation_exit(void)1222*86d7f5d3SJohn Marino void activation_exit(void)
1223*86d7f5d3SJohn Marino {
1224*86d7f5d3SJohn Marino dev_manager_exit();
1225*86d7f5d3SJohn Marino }
1226*86d7f5d3SJohn Marino #endif
1227