shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-10-27 10:25:13 +03:00
Code Releases Activity
b493811968
lvm2/liblvm/lvm_vg.c
David Teigland a7c45ddc59 lvmetad: two phase vg_update 
Previously, a command sent lvmetad new VG metadata in vg_commit().
In vg_commit(), devices are suspended, so any memory allocation
done by the command while sending to lvmetad, or by lvmetad while
updating its cache could deadlock if memory reclaim was triggered.

Now lvmetad is updated in unlock_vg(), after devices are resumed.
The new method for updating VG metadata in lvmetad is in two phases:

1. In vg_write(), before devices are suspended, the command sends
   lvmetad a short message ("set_vg_info") telling it what the new
   VG seqno will be.  lvmetad sees that the seqno is newer than
   the seqno of its cached VG, so it sets the INVALID flag for the
   cached VG.  If sending the message to lvmetad fails, the command
   fails before the metadata is committed and the change is not made.
   If sending the message succeeds, vg_commit() is called.

2. In unlock_vg(), after devices are resumed, the command sends
   lvmetad the standard vg_update message with the new metadata.
   lvmetad sees that the seqno in the new metadata matches the
   seqno it saved from set_vg_info, and knows it has the latest
   copy, so it clears the INVALID flag for the cached VG.

If a command fails between 1 and 2 (after committing the VG on disk,
but before sending lvmetad the new metadata), the cached VG retains
the INVALID flag in lvmetad.  A subsequent command will read the
cached VG from lvmetad, see the INVALID flag, ignore the cached
copy, read the VG from disk instead, update the lvmetad copy
with the latest copy from disk, (this clears the INVALID flag
in lvmetad), and use the correct VG metadata for the command.

(This INVALID mechanism already existed for use by lvmlockd.)
2016-06-28 02:30:31 +01:00

562 lines
12 KiB
C
Raw Blame History

/*
* Copyright (C) 2008-2013 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "lib.h"
#include "toolcontext.h"
#include "metadata.h"
#include "archiver.h"
#include "locking.h"
#include "lvmcache.h"
#include "lvmetad.h"
#include "lvm_misc.h"
#include "lvm2app.h"
#include "display.h"
#include "lvmetad.h"
int lvm_vg_add_tag(vg_t vg, const char *tag)
{
int rc = -1;
struct saved_env e = store_user_env(vg->cmd);
if (!vg_read_error(vg) && vg_check_write_mode(vg) &&
vg_change_tag(vg, tag, 1))
rc = 0;
restore_user_env(&e);
return rc;
}
int lvm_vg_remove_tag(vg_t vg, const char *tag)
{
int rc = -1;
struct saved_env e = store_user_env(vg->cmd);
if (!vg_read_error(vg) && vg_check_write_mode(vg) &&
vg_change_tag(vg, tag, 0))
rc = 0;
restore_user_env(&e);
return rc;
}
vg_t lvm_vg_create(lvm_t libh, const char *vg_name)
{
struct volume_group *vg = NULL;
struct saved_env e = store_user_env((struct cmd_context *)libh);
vg = vg_lock_and_create((struct cmd_context *)libh, vg_name);
/* FIXME: error handling is still TBD */
if (vg_read_error(vg)) {
release_vg(vg);
vg = NULL;
} else {
vg->open_mode = 'w';
}
restore_user_env(&e);
return (vg_t) vg;
}
static int _lvm_vg_extend(vg_t vg, const char *device)
{
struct pvcreate_params pp;
if (vg_read_error(vg))
return -1;
if (!vg_check_write_mode(vg))
return -1;
if (!lock_vol(vg->cmd, VG_ORPHANS, LCK_VG_WRITE, NULL)) {
log_error("Can't get lock for orphan PVs");
return -1;
}
pvcreate_params_set_defaults(&pp);
if (!vg_extend(vg, 1, &device, &pp)) {
unlock_vg(vg->cmd, NULL, VG_ORPHANS);
return -1;
}
/*
* FIXME: Either commit to disk, or keep holding VG_ORPHANS and
* release in lvm_vg_close().
*/
unlock_vg(vg->cmd, NULL, VG_ORPHANS);
return 0;
}
int lvm_vg_extend(vg_t vg, const char *device)
{
int rc = 0;
struct saved_env e = store_user_env(vg->cmd);
rc = _lvm_vg_extend(vg, device);
restore_user_env(&e);
return rc;
}
int lvm_vg_reduce(vg_t vg, const char *device)
{
int rc = -1;
struct saved_env e = store_user_env(vg->cmd);
if (!vg_read_error(vg) && vg_check_write_mode(vg) && vg_reduce(vg, device))
rc = 0;
restore_user_env(&e);
return rc;
}
int lvm_vg_set_extent_size(vg_t vg, uint32_t new_size)
{
int rc = -1;
struct saved_env e = store_user_env(vg->cmd);
if (!vg_read_error(vg) && vg_check_write_mode(vg) &&
vg_set_extent_size(vg, new_size / SECTOR_SIZE))
rc = 0;
restore_user_env(&e);
return rc;
}
static int _lvm_vg_write(vg_t vg)
{
struct pv_list *pvl;
if (vg_read_error(vg))
return -1;
if (!vg_check_write_mode(vg))
return -1;
if (dm_list_empty(&vg->pvs)) {
if (!vg_remove(vg))
return -1;
return 0;
}
if (! dm_list_empty(&vg->removed_pvs)) {
if (!lock_vol(vg->cmd, VG_ORPHANS, LCK_VG_WRITE, NULL)) {
log_error("Can't get lock for orphan PVs");
return 0;
}
}
if (!archive(vg))
return -1;
/* Store VG on disk(s) */
if (!vg_write(vg) || !vg_commit(vg))
return -1;
if (! dm_list_empty(&vg->removed_pvs)) {
dm_list_iterate_items(pvl, &vg->removed_pvs) {
pv_write_orphan(vg->cmd, pvl->pv);
pv_set_fid(pvl->pv, NULL);
/* FIXME: do pvremove / label_remove()? */
}
dm_list_init(&vg->removed_pvs);
unlock_vg(vg->cmd, NULL, VG_ORPHANS);
}
return 0;
}
int lvm_vg_write(vg_t vg)
{
int rc;
struct saved_env e = store_user_env(vg->cmd);
rc = _lvm_vg_write(vg);
restore_user_env(&e);
return rc;
}
int lvm_vg_close(vg_t vg)
{
struct saved_env e = store_user_env(vg->cmd);
if (vg_read_error(vg) == FAILED_LOCKING)
release_vg(vg);
else
unlock_and_release_vg(vg->cmd, vg, vg->name);
restore_user_env(&e);
return 0;
}
int lvm_vg_remove(vg_t vg)
{
int rc = -1;
struct saved_env e = store_user_env(vg->cmd);
if (!vg_read_error(vg) && vg_check_write_mode(vg) && vg_remove_check(vg)) {
vg_remove_pvs(vg);
rc = 0;
}
restore_user_env(&e);
return rc;
}
static vg_t _lvm_vg_open(lvm_t libh, const char *vgname, const char *mode,
uint32_t flags)
{
uint32_t internal_flags = 0;
struct volume_group *vg;
if (!strncmp(mode, "w", 1))
internal_flags |= READ_FOR_UPDATE;
else if (strncmp(mode, "r", 1)) {
log_errno(EINVAL, "Invalid VG open mode");
return NULL;
}
vg = vg_read((struct cmd_context *)libh, vgname, NULL, internal_flags, 0);
if (vg_read_error(vg)) {
/* FIXME: use log_errno either here in inside vg_read */
release_vg(vg);
return NULL;
}
/* FIXME: combine this with locking ? */
vg->open_mode = mode[0];
return (vg_t) vg;
}
vg_t lvm_vg_open(lvm_t libh, const char *vgname, const char *mode,
uint32_t flags)
{
vg_t rc;
struct saved_env e = store_user_env((struct cmd_context*)libh);
rc = _lvm_vg_open(libh, vgname, mode, flags);
restore_user_env(&e);
return rc;
}
static struct dm_list *_lvm_vg_list_pvs(vg_t vg)
{
struct dm_list *list;
pv_list_t *pvs;
struct pv_list *pvl;
if (dm_list_empty(&vg->pvs))
return NULL;
if (!(list = dm_pool_zalloc(vg->vgmem, sizeof(*list)))) {
log_errno(ENOMEM, "Memory allocation fail for dm_list.");
return NULL;
}
dm_list_init(list);
dm_list_iterate_items(pvl, &vg->pvs) {
if (!(pvs = dm_pool_zalloc(vg->vgmem, sizeof(*pvs)))) {
log_errno(ENOMEM,
"Memory allocation fail for lvm_pv_list.");
return NULL;
}
pvs->pv = pvl->pv;
dm_list_add(list, &pvs->list);
}
return list;
}
struct dm_list *lvm_vg_list_pvs(vg_t vg)
{
struct dm_list *rc;
struct saved_env e = store_user_env(vg->cmd);
rc = _lvm_vg_list_pvs(vg);
restore_user_env(&e);
return rc;
}
static struct dm_list *_lvm_vg_list_lvs(vg_t vg)
{
struct dm_list *list;
lv_list_t *lvs;
struct lv_list *lvl;
if (dm_list_empty(&vg->lvs))
return NULL;
if (!(list = dm_pool_zalloc(vg->vgmem, sizeof(*list)))) {
log_errno(ENOMEM, "Memory allocation fail for dm_list.");
return NULL;
}
dm_list_init(list);
dm_list_iterate_items(lvl, &vg->lvs) {
if (!(lvs = dm_pool_zalloc(vg->vgmem, sizeof(*lvs)))) {
log_errno(ENOMEM,
"Memory allocation fail for lvm_lv_list.");
return NULL;
}
lvs->lv = lvl->lv;
dm_list_add(list, &lvs->list);
}
return list;
}
struct dm_list *lvm_vg_list_lvs(vg_t vg)
{
struct dm_list *rc;
struct saved_env e = store_user_env(vg->cmd);
rc = _lvm_vg_list_lvs(vg);
restore_user_env(&e);
return rc;
}
struct dm_list *lvm_vg_get_tags(const vg_t vg)
{
struct dm_list *rc;
struct saved_env e = store_user_env(vg->cmd);
rc = tag_list_copy(vg->vgmem, &vg->tags);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_seqno(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_seqno(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_is_clustered(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_is_clustered(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_is_exported(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_is_exported(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_is_partial(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = (vg_missing_pv_count(vg) != 0);
restore_user_env(&e);
return rc;
}
/* FIXME: invalid handle? return INTMAX? */
uint64_t lvm_vg_get_size(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = SECTOR_SIZE * vg_size(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_free_size(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = SECTOR_SIZE * vg_free(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_extent_size(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = SECTOR_SIZE * vg_extent_size(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_extent_count(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_extent_count(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_free_extent_count(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_free_count(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_pv_count(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_pv_count(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_max_pv(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_max_pv(vg);
restore_user_env(&e);
return rc;
}
uint64_t lvm_vg_get_max_lv(const vg_t vg)
{
uint64_t rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_max_lv(vg);
restore_user_env(&e);
return rc;
}
const char *lvm_vg_get_uuid(const vg_t vg)
{
const char *rc;
struct saved_env e = store_user_env(vg->cmd);
rc = vg_uuid_dup(vg);
restore_user_env(&e);
return rc;
}
const char *lvm_vg_get_name(const vg_t vg)
{
const char *rc;
struct saved_env e = store_user_env(vg->cmd);
rc = dm_pool_strndup(vg->vgmem, (const char *)vg->name, NAME_LEN+1);
restore_user_env(&e);
return rc;
}
struct lvm_property_value lvm_vg_get_property(const vg_t vg, const char *name)
{
struct lvm_property_value rc;
struct saved_env e = store_user_env(vg->cmd);
rc = get_property(NULL, vg, NULL, NULL, NULL, NULL, NULL, name);
restore_user_env(&e);
return rc;
}
int lvm_vg_set_property(const vg_t vg, const char *name,
struct lvm_property_value *value)
{
/* At this point it is unknown if all property set paths make the
* appropriate copy of the string. We will allocate a copy on the vg so
* that worst case we have two copies which will get freed when the vg gets
* released.
*/
int rc;
struct saved_env e = store_user_env(vg->cmd);
if (value->is_valid && value->is_string && value->value.string) {
value->value.string = dm_pool_strndup(vg->vgmem, value->value.string,
strlen(value->value.string) + 1);
}
rc = set_property(NULL, vg, NULL, NULL, NULL, name, value);
restore_user_env(&e);
return rc;
}
struct dm_list *lvm_list_vg_names(lvm_t libh)
{
struct dm_list *rc = NULL;
struct saved_env e = store_user_env((struct cmd_context *)libh);
if (lvmetad_vg_list_to_lvmcache((struct cmd_context *)libh)) {
rc = get_vgnames((struct cmd_context *)libh, 0);
}
restore_user_env(&e);
return rc;
}
struct dm_list *lvm_list_vg_uuids(lvm_t libh)
{
struct dm_list *rc = NULL;
struct saved_env e = store_user_env((struct cmd_context *)libh);
if (lvmetad_vg_list_to_lvmcache((struct cmd_context *)libh)) {
rc = get_vgids((struct cmd_context *)libh, 0);
}
restore_user_env(&e);
return rc;
}
/*
* FIXME: Elaborate on when to use, side-effects, .cache file, etc
*/
int lvm_scan(lvm_t libh)
{
int rc = 0;
struct saved_env e = store_user_env((struct cmd_context *)libh);
lvmcache_force_next_label_scan();
if (!lvmcache_label_scan((struct cmd_context *)libh))
rc = -1;
restore_user_env(&e);
return rc;
}
int lvm_lv_name_validate(const vg_t vg, const char *name)
{
int rc = -1;
name_error_t name_error;
int historical;
struct saved_env e = store_user_env(vg->cmd);
name_error = validate_name_detailed(name);
if (NAME_VALID == name_error) {
if (apply_lvname_restrictions(name)) {
if (!lv_name_is_used_in_vg(vg, name, &historical)) {
rc = 0;
} else {
log_errno(EINVAL, "%sLV name exists in VG",
historical ? "historical " : "");
}
}
} else {
display_name_error(name_error);
}
restore_user_env(&e);
return rc;
}
int lvm_vg_name_validate(lvm_t libh, const char *name)
{
int rc = -1;
struct cmd_context *cmd = (struct cmd_context *)libh;
struct saved_env e = store_user_env(cmd);
if (validate_new_vg_name(cmd, name))
rc = 0;
restore_user_env(&e);
return rc;
}
View Git Blame Copy Permalink