lvm2/liblvm/lvm_vg.c

/*
 * 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/misc/lib.h"
#include "lib/commands/toolcontext.h"
#include "lib/metadata/metadata.h"
#include "lib/format_text/archiver.h"
#include "lib/locking/locking.h"
#include "lib/cache/lvmcache.h"
#include "lib/cache/lvmetad.h"
#include "lvm_misc.h"
#include "liblvm/lvm2app.h"
#include "lib/display/display.h"
#include "lib/cache/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 if (!lvmcache_vgname_is_locked(vg->name))
		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;
	}

	lvmcache_label_scan((struct cmd_context *)libh);

	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, 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);

	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;
}