1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
* Copyright (C) 2010 Red Hat, Inc. All rights reserved.
*
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU Lesser General Public License v.2.1.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "lib.h"
#include "metadata.h"
#include "lvmcache.h"
/*
* FIXME: Check for valid handle before dereferencing field or log error?
*/
#define pv_field(handle, field) ((handle)->field)
/*
* Gets/Sets for external LVM library
*/
struct id pv_id(const struct physical_volume *pv)
{
return pv_field(pv, id);
}
const struct format_type *pv_format_type(const struct physical_volume *pv)
{
return pv_field(pv, fmt);
}
struct id pv_vgid(const struct physical_volume *pv)
{
return pv_field(pv, vgid);
}
struct device *pv_dev(const struct physical_volume *pv)
{
return pv_field(pv, dev);
}
const char *pv_vg_name(const struct physical_volume *pv)
{
return pv_field(pv, vg_name);
}
const char *pv_dev_name(const struct physical_volume *pv)
{
return dev_name(pv_dev(pv));
}
uint64_t pv_size(const struct physical_volume *pv)
{
return pv_field(pv, size);
}
uint64_t pv_dev_size(const struct physical_volume *pv)
{
uint64_t size;
if (!dev_get_size(pv->dev, &size))
size = 0;
return size;
}
uint64_t pv_size_field(const struct physical_volume *pv)
{
uint64_t size;
if (!pv->pe_count)
size = pv->size;
else
size = (uint64_t) pv->pe_count * pv->pe_size;
return size;
}
uint64_t pv_free(const struct physical_volume *pv)
{
uint64_t freespace;
if (!pv->pe_count)
freespace = pv->size;
else
freespace = (uint64_t)
(pv->pe_count - pv->pe_alloc_count) * pv->pe_size;
return freespace;
}
uint64_t pv_status(const struct physical_volume *pv)
{
return pv_field(pv, status);
}
uint32_t pv_pe_size(const struct physical_volume *pv)
{
return pv_field(pv, pe_size);
}
uint64_t pv_pe_start(const struct physical_volume *pv)
{
return pv_field(pv, pe_start);
}
uint32_t pv_pe_count(const struct physical_volume *pv)
{
return pv_field(pv, pe_count);
}
uint32_t pv_pe_alloc_count(const struct physical_volume *pv)
{
return pv_field(pv, pe_alloc_count);
}
uint32_t pv_mda_count(const struct physical_volume *pv)
{
struct lvmcache_info *info;
info = info_from_pvid((const char *)&pv->id.uuid, 0);
return info ? dm_list_size(&info->mdas) : UINT64_C(0);
}
uint32_t pv_mda_used_count(const struct physical_volume *pv)
{
struct lvmcache_info *info;
struct metadata_area *mda;
uint32_t used_count=0;
info = info_from_pvid((const char *)&pv->id.uuid, 0);
if (!info)
return 0;
dm_list_iterate_items(mda, &info->mdas) {
if (!mda_is_ignored(mda))
used_count++;
}
return used_count;
}
/**
* is_orphan - Determine whether a pv is an orphan based on its vg_name
* @pv: handle to the physical volume
*/
int is_orphan(const struct physical_volume *pv)
{
return is_orphan_vg(pv_field(pv, vg_name));
}
/**
* is_pv - Determine whether a pv is a real pv or dummy one
* @pv: handle to device
*/
int is_pv(const struct physical_volume *pv)
{
return (pv_field(pv, vg_name) ? 1 : 0);
}
int is_missing_pv(const struct physical_volume *pv)
{
return pv_field(pv, status) & MISSING_PV ? 1 : 0;
}
char *pv_attr_dup(struct dm_pool *mem, const struct physical_volume *pv)
{
char *repstr;
if (!(repstr = dm_pool_zalloc(mem, 3))) {
log_error("dm_pool_alloc failed");
return NULL;
}
repstr[0] = (pv->status & ALLOCATABLE_PV) ? 'a' : '-';
repstr[1] = (pv->status & EXPORTED_VG) ? 'x' : '-';
return repstr;
}
unsigned pv_mda_set_ignored(const struct physical_volume *pv, unsigned mda_ignored)
{
struct lvmcache_info *info;
struct metadata_area *mda, *vg_mda, *tmda;
struct dm_list *vg_mdas_in_use, *vg_mdas_ignored;
if (!(info = info_from_pvid((const char *)&pv->id.uuid, 0)))
return_0;
if (is_orphan(pv)) {
dm_list_iterate_items(mda, &info->mdas)
mda_set_ignored(mda, mda_ignored);
return 1;
}
/*
* Do not allow disabling of the the last PV in a VG.
*/
if (pv_mda_used_count(pv) == vg_mda_used_count(pv->vg)) {
log_error("Cannot disable all metadata areas in volume group %s.",
pv->vg->name);
return 0;
}
/*
* Non-orphan case is more complex.
* If the PV's mdas are ignored, and we wish to un-ignore,
* we clear the bit and move them from the ignored mda list to the
* in_use list, ensuring the new state will get written to disk
* in the vg_write() path.
* If the PV's mdas are not ignored, and we are setting
* them to ignored, we set the bit but leave them on the in_use
* list, ensuring the new state will get written to disk in the
* vg_write() path.
*/
vg_mdas_in_use = &pv->vg->fid->metadata_areas_in_use;
vg_mdas_ignored = &pv->vg->fid->metadata_areas_ignored;
dm_list_iterate_items(mda, &info->mdas) {
if (mda_is_ignored(mda) && !mda_ignored)
/* Changing an ignored mda to one in_use requires moving it */
dm_list_iterate_items_safe(vg_mda, tmda, vg_mdas_ignored)
if (mda_locns_match(mda, vg_mda)) {
mda_set_ignored(vg_mda, mda_ignored);
dm_list_move(vg_mdas_in_use, &vg_mda->list);
}
dm_list_iterate_items_safe(vg_mda, tmda, vg_mdas_in_use)
if (mda_locns_match(mda, vg_mda))
/* Don't move mda: needs writing to disk. */
mda_set_ignored(vg_mda, mda_ignored);
mda_set_ignored(mda, mda_ignored);
}
return 1;
}
|
