]>
sourceware.org Git - lvm2.git/blob - liblvm/lvm_vg.c
2 * Copyright (C) 2008,2009 Red Hat, Inc. All rights reserved.
4 * This file is part of LVM2.
6 * This copyrighted material is made available to anyone wishing to use,
7 * modify, copy, or redistribute it subject to the terms and conditions
8 * of the GNU Lesser General Public License v.2.1.
10 * You should have received a copy of the GNU Lesser General Public License
11 * along with this program; if not, write to the Free Software Foundation,
12 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 #include "toolcontext.h"
24 int lvm_vg_add_tag(vg_t vg
, const char *tag
)
26 if (vg_read_error(vg
))
29 if (!vg_check_write_mode(vg
))
32 if (!vg_change_tag(vg
, tag
, 1))
38 int lvm_vg_remove_tag(vg_t vg
, const char *tag
)
40 if (vg_read_error(vg
))
43 if (!vg_check_write_mode(vg
))
46 if (!vg_change_tag(vg
, tag
, 0))
52 vg_t
lvm_vg_create(lvm_t libh
, const char *vg_name
)
54 struct volume_group
*vg
;
56 vg
= vg_create((struct cmd_context
*)libh
, vg_name
);
57 /* FIXME: error handling is still TBD */
58 if (vg_read_error(vg
)) {
66 int lvm_vg_extend(vg_t vg
, const char *device
)
68 struct pvcreate_params pp
;
70 if (vg_read_error(vg
))
73 if (!vg_check_write_mode(vg
))
76 if (!lock_vol(vg
->cmd
, VG_ORPHANS
, LCK_VG_WRITE
)) {
77 log_error("Can't get lock for orphan PVs");
81 pvcreate_params_set_defaults(&pp
);
82 if (!vg_extend(vg
, 1, &device
, &pp
)) {
83 unlock_vg(vg
->cmd
, VG_ORPHANS
);
87 * FIXME: Either commit to disk, or keep holding VG_ORPHANS and
88 * release in lvm_vg_close().
90 unlock_vg(vg
->cmd
, VG_ORPHANS
);
94 int lvm_vg_reduce(vg_t vg
, const char *device
)
96 if (vg_read_error(vg
))
98 if (!vg_check_write_mode(vg
))
101 if (!vg_reduce(vg
, device
))
106 int lvm_vg_set_extent_size(vg_t vg
, uint32_t new_size
)
108 if (vg_read_error(vg
))
110 if (!vg_check_write_mode(vg
))
113 if (!vg_set_extent_size(vg
, new_size
/ SECTOR_SIZE
))
118 int lvm_vg_write(vg_t vg
)
122 if (vg_read_error(vg
))
124 if (!vg_check_write_mode(vg
))
127 if (dm_list_empty(&vg
->pvs
)) {
133 if (! dm_list_empty(&vg
->removed_pvs
)) {
134 if (!lock_vol(vg
->cmd
, VG_ORPHANS
, LCK_VG_WRITE
)) {
135 log_error("Can't get lock for orphan PVs");
143 /* Store VG on disk(s) */
144 if (!vg_write(vg
) || !vg_commit(vg
))
147 if (! dm_list_empty(&vg
->removed_pvs
)) {
148 dm_list_iterate_items(pvl
, &vg
->removed_pvs
) {
149 pv_write_orphan(vg
->cmd
, pvl
->pv
);
150 pv_set_fid(pvl
->pv
, NULL
);
151 /* FIXME: do pvremove / label_remove()? */
153 dm_list_init(&vg
->removed_pvs
);
154 unlock_vg(vg
->cmd
, VG_ORPHANS
);
160 int lvm_vg_close(vg_t vg
)
162 if (vg_read_error(vg
) == FAILED_LOCKING
)
165 unlock_and_release_vg(vg
->cmd
, vg
, vg
->name
);
169 int lvm_vg_remove(vg_t vg
)
171 if (vg_read_error(vg
))
173 if (!vg_check_write_mode(vg
))
176 if (!vg_remove_check(vg
))
184 vg_t
lvm_vg_open(lvm_t libh
, const char *vgname
, const char *mode
,
187 uint32_t internal_flags
= 0;
188 struct volume_group
*vg
;
190 if (!strncmp(mode
, "w", 1))
191 internal_flags
|= READ_FOR_UPDATE
;
192 else if (strncmp(mode
, "r", 1)) {
193 log_errno(EINVAL
, "Invalid VG open mode");
197 vg
= vg_read((struct cmd_context
*)libh
, vgname
, NULL
, internal_flags
);
198 if (vg_read_error(vg
)) {
199 /* FIXME: use log_errno either here in inside vg_read */
203 /* FIXME: combine this with locking ? */
204 vg
->open_mode
= mode
[0];
209 struct dm_list
*lvm_vg_list_pvs(vg_t vg
)
211 struct dm_list
*list
;
215 if (dm_list_empty(&vg
->pvs
))
218 if (!(list
= dm_pool_zalloc(vg
->vgmem
, sizeof(*list
)))) {
219 log_errno(ENOMEM
, "Memory allocation fail for dm_list.");
224 dm_list_iterate_items(pvl
, &vg
->pvs
) {
225 if (!(pvs
= dm_pool_zalloc(vg
->vgmem
, sizeof(*pvs
)))) {
227 "Memory allocation fail for lvm_pv_list.");
231 dm_list_add(list
, &pvs
->list
);
236 struct dm_list
*lvm_vg_list_lvs(vg_t vg
)
238 struct dm_list
*list
;
242 if (dm_list_empty(&vg
->lvs
))
245 if (!(list
= dm_pool_zalloc(vg
->vgmem
, sizeof(*list
)))) {
246 log_errno(ENOMEM
, "Memory allocation fail for dm_list.");
251 dm_list_iterate_items(lvl
, &vg
->lvs
) {
252 if (!(lvs
= dm_pool_zalloc(vg
->vgmem
, sizeof(*lvs
)))) {
254 "Memory allocation fail for lvm_lv_list.");
258 dm_list_add(list
, &lvs
->list
);
263 struct dm_list
*lvm_vg_get_tags(const vg_t vg
)
265 return tag_list_copy(vg
->vgmem
, &vg
->tags
);
268 uint64_t lvm_vg_get_seqno(const vg_t vg
)
273 uint64_t lvm_vg_is_clustered(const vg_t vg
)
275 return vg_is_clustered(vg
);
278 uint64_t lvm_vg_is_exported(const vg_t vg
)
280 return vg_is_exported(vg
);
283 uint64_t lvm_vg_is_partial(const vg_t vg
)
285 return (vg_missing_pv_count(vg
) != 0);
288 /* FIXME: invalid handle? return INTMAX? */
289 uint64_t lvm_vg_get_size(const vg_t vg
)
291 return SECTOR_SIZE
* vg_size(vg
);
294 uint64_t lvm_vg_get_free_size(const vg_t vg
)
296 return SECTOR_SIZE
* vg_free(vg
);
299 uint64_t lvm_vg_get_extent_size(const vg_t vg
)
301 return SECTOR_SIZE
* vg_extent_size(vg
);
304 uint64_t lvm_vg_get_extent_count(const vg_t vg
)
306 return vg_extent_count(vg
);
309 uint64_t lvm_vg_get_free_extent_count(const vg_t vg
)
311 return vg_free_count(vg
);
314 uint64_t lvm_vg_get_pv_count(const vg_t vg
)
316 return vg_pv_count(vg
);
319 uint64_t lvm_vg_get_max_pv(const vg_t vg
)
321 return vg_max_pv(vg
);
324 uint64_t lvm_vg_get_max_lv(const vg_t vg
)
326 return vg_max_lv(vg
);
329 const char *lvm_vg_get_uuid(const vg_t vg
)
331 return vg_uuid_dup(vg
);
334 const char *lvm_vg_get_name(const vg_t vg
)
336 return dm_pool_strndup(vg
->vgmem
, (const char *)vg
->name
, NAME_LEN
+1);
340 struct lvm_property_value
lvm_vg_get_property(const vg_t vg
, const char *name
)
342 return get_property(NULL
, vg
, NULL
, NULL
, NULL
, name
);
345 int lvm_vg_set_property(const vg_t vg
, const char *name
,
346 struct lvm_property_value
*value
)
348 return set_property(NULL
, vg
, NULL
, name
, value
);
351 struct dm_list
*lvm_list_vg_names(lvm_t libh
)
353 return get_vgnames((struct cmd_context
*)libh
, 0);
356 struct dm_list
*lvm_list_vg_uuids(lvm_t libh
)
358 return get_vgids((struct cmd_context
*)libh
, 0);
362 * FIXME: Elaborate on when to use, side-effects, .cache file, etc
364 int lvm_scan(lvm_t libh
)
366 if (!lvmcache_label_scan((struct cmd_context
*)libh
, 2))
This page took 0.04972 seconds and 5 git commands to generate.