~brightbox/ubuntu/raring/lvm2/fix-for-1076304

/*

 * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.

 * Copyright (C) 2004-2011 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 "lvmcache.h"

#include "toolcontext.h"

#include "dev-cache.h"

#include "locking.h"

#include "metadata.h"

#include "filter.h"

#include "filter-persistent.h"

#include "memlock.h"

#include "str_list.h"

#include "format-text.h"

#include "format_pool.h"

#include "format1.h"

#include "config.h"

#include "lvmetad.h"

#define CACHE_INVALID	0x00000001

#define CACHE_LOCKED	0x00000002

/* One per device */

struct lvmcache_info {

	struct dm_list list;	/* Join VG members together */

	struct dm_list mdas;	/* list head for metadata areas */

	struct dm_list das;	/* list head for data areas */

	struct lvmcache_vginfo *vginfo;	/* NULL == unknown */

	struct label *label;

	const struct format_type *fmt;

	struct device *dev;

	uint64_t device_size;	/* Bytes */

	uint32_t status;

};

/* One per VG */

struct lvmcache_vginfo {

	struct dm_list list;	/* Join these vginfos together */

	struct dm_list infos;	/* List head for lvmcache_infos */

	const struct format_type *fmt;

	char *vgname;		/* "" == orphan */

	uint32_t status;

	char vgid[ID_LEN + 1];

	char _padding[7];

	struct lvmcache_vginfo *next; /* Another VG with same name? */

	char *creation_host;

	size_t vgmetadata_size;

	char *vgmetadata;	/* Copy of VG metadata as format_text string */

	struct dm_config_tree *cft; /* Config tree created from vgmetadata */

				    /* Lifetime is directly tied to vgmetadata */

	struct volume_group *cached_vg;

	unsigned holders;

	unsigned vg_use_count;	/* Counter of vg reusage */

	unsigned precommitted;	/* Is vgmetadata live or precommitted? */

};

static struct dm_hash_table *_pvid_hash = NULL;

static struct dm_hash_table *_vgid_hash = NULL;

static struct dm_hash_table *_vgname_hash = NULL;

static struct dm_hash_table *_lock_hash = NULL;

static DM_LIST_INIT(_vginfos);

static int _scanning_in_progress = 0;

static int _has_scanned = 0;

static int _vgs_locked = 0;

static int _vg_global_lock_held = 0;	/* Global lock held when cache wiped? */

int lvmcache_init(void)

{

	/*

	 * FIXME add a proper lvmcache_locking_reset() that

	 * resets the cache so no previous locks are locked

	 */

	_vgs_locked = 0;

	dm_list_init(&_vginfos);

	if (!(_vgname_hash = dm_hash_create(128)))

		return 0;

	if (!(_vgid_hash = dm_hash_create(128)))

		return 0;

	if (!(_pvid_hash = dm_hash_create(128)))

		return 0;

	if (!(_lock_hash = dm_hash_create(128)))

		return 0;

	/*

	 * Reinitialising the cache clears the internal record of

	 * which locks are held.  The global lock can be held during

	 * this operation so its state must be restored afterwards.

	 */

	if (_vg_global_lock_held) {

		lvmcache_lock_vgname(VG_GLOBAL, 0);

		_vg_global_lock_held = 0;

	}

	lvmetad_init();

	return 1;

}

void lvmcache_seed_infos_from_lvmetad(struct cmd_context *cmd)

{

	if (!lvmetad_active() || _has_scanned)

		return;

	if (!lvmetad_pv_list_to_lvmcache(cmd)) {

		stack;

		return;

	}

	_has_scanned = 1;

};

/* Volume Group metadata cache functions */

static void _free_cached_vgmetadata(struct lvmcache_vginfo *vginfo)

{

	if (!vginfo || !vginfo->vgmetadata)

		return;

	dm_free(vginfo->vgmetadata);

	vginfo->vgmetadata = NULL;

	/* Release also cached config tree */

	if (vginfo->cft) {

		dm_config_destroy(vginfo->cft);

		vginfo->cft = NULL;

	}

	log_debug("Metadata cache: VG %s wiped.", vginfo->vgname);

	release_vg(vginfo->cached_vg);

}

/*

 * Cache VG metadata against the vginfo with matching vgid.

 */

static void _store_metadata(struct volume_group *vg, unsigned precommitted)

{

	char uuid[64] __attribute__((aligned(8)));

	struct lvmcache_vginfo *vginfo;

	char *data;

	size_t size;

	if (!(vginfo = lvmcache_vginfo_from_vgid((const char *)&vg->id))) {

		stack;

		return;

	}

	if (!(size = export_vg_to_buffer(vg, &data))) {

		stack;

		_free_cached_vgmetadata(vginfo);

		return;

	}

	/* Avoid reparsing of the same data string */

	if (vginfo->vgmetadata && vginfo->vgmetadata_size == size &&

	    strcmp(vginfo->vgmetadata, data) == 0)

		dm_free(data);

	else {

		_free_cached_vgmetadata(vginfo);

		vginfo->vgmetadata_size = size;

		vginfo->vgmetadata = data;

	}

	vginfo->precommitted = precommitted;

	if (!id_write_format((const struct id *)vginfo->vgid, uuid, sizeof(uuid))) {

		stack;

		return;

	}

	log_debug("Metadata cache: VG %s (%s) stored (%" PRIsize_t " bytes%s).",

		  vginfo->vgname, uuid, size,

		  precommitted ? ", precommitted" : "");

}

static void _update_cache_info_lock_state(struct lvmcache_info *info,

					  int locked,

					  int *cached_vgmetadata_valid)

{

	int was_locked = (info->status & CACHE_LOCKED) ? 1 : 0;

	/*

	 * Cache becomes invalid whenever lock state changes unless

	 * exclusive VG_GLOBAL is held (i.e. while scanning).

	 */

	if (!lvmcache_vgname_is_locked(VG_GLOBAL) && (was_locked != locked)) {

		info->status |= CACHE_INVALID;

		*cached_vgmetadata_valid = 0;

	}

	if (locked)

		info->status |= CACHE_LOCKED;

	else

		info->status &= ~CACHE_LOCKED;

}

static void _update_cache_vginfo_lock_state(struct lvmcache_vginfo *vginfo,

					    int locked)

{

	struct lvmcache_info *info;

	int cached_vgmetadata_valid = 1;

	dm_list_iterate_items(info, &vginfo->infos)

		_update_cache_info_lock_state(info, locked,

					      &cached_vgmetadata_valid);

	if (!cached_vgmetadata_valid)

		_free_cached_vgmetadata(vginfo);

}

static void _update_cache_lock_state(const char *vgname, int locked)

{

	struct lvmcache_vginfo *vginfo;

	if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, NULL)))

		return;

	_update_cache_vginfo_lock_state(vginfo, locked);

}

static void _drop_metadata(const char *vgname, int drop_precommitted)

{

	struct lvmcache_vginfo *vginfo;

	struct lvmcache_info *info;

	if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, NULL)))

		return;

	/*

	 * Invalidate cached PV labels.

	 * If cached precommitted metadata exists that means we

	 * already invalidated the PV labels (before caching it)

	 * and we must not do it again.

	 */

	if (!drop_precommitted && vginfo->precommitted && !vginfo->vgmetadata)

		log_error(INTERNAL_ERROR "metadata commit (or revert) missing before "

			  "dropping metadata from cache.");

	if (drop_precommitted || !vginfo->precommitted)

		dm_list_iterate_items(info, &vginfo->infos)

			info->status |= CACHE_INVALID;

	_free_cached_vgmetadata(vginfo);

	/* VG revert */

	if (drop_precommitted)

		vginfo->precommitted = 0;

}

/*

 * Remote node uses this to upgrade precommited metadata to commited state

 * when receives vg_commit notification.

 * (Note that devices can be suspended here, if so, precommited metadata are already read.)

 */

void lvmcache_commit_metadata(const char *vgname)

{

	struct lvmcache_vginfo *vginfo;

	if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, NULL)))

		return;

	if (vginfo->precommitted) {

		log_debug("Precommitted metadata cache: VG %s upgraded to committed.",

			  vginfo->vgname);

		vginfo->precommitted = 0;

	}

}

void lvmcache_drop_metadata(const char *vgname, int drop_precommitted)

{

	/* For VG_ORPHANS, we need to invalidate all labels on orphan PVs. */

	if (!strcmp(vgname, VG_ORPHANS)) {

		_drop_metadata(FMT_TEXT_ORPHAN_VG_NAME, 0);

		_drop_metadata(FMT_LVM1_ORPHAN_VG_NAME, 0);

		_drop_metadata(FMT_POOL_ORPHAN_VG_NAME, 0);

		/* Indicate that PVs could now be missing from the cache */

		init_full_scan_done(0);

	} else if (!lvmcache_vgname_is_locked(VG_GLOBAL))

		_drop_metadata(vgname, drop_precommitted);

}

/*

 * Ensure vgname2 comes after vgname1 alphabetically.

 * Orphan locks come last.

 * VG_GLOBAL comes first.

 */

static int _vgname_order_correct(const char *vgname1, const char *vgname2)

{

	if (is_global_vg(vgname1))

		return 1;

	if (is_global_vg(vgname2))

		return 0;

	if (is_orphan_vg(vgname1))

		return 0;

	if (is_orphan_vg(vgname2))

		return 1;

	if (strcmp(vgname1, vgname2) < 0)

		return 1;

	return 0;

}

/*

 * Ensure VG locks are acquired in alphabetical order.

 */

int lvmcache_verify_lock_order(const char *vgname)

{

	struct dm_hash_node *n;

	const char *vgname2;

	if (!_lock_hash)

		return_0;

	dm_hash_iterate(n, _lock_hash) {

		if (!dm_hash_get_data(_lock_hash, n))

			return_0;

		if (!(vgname2 = dm_hash_get_key(_lock_hash, n))) {

			log_error(INTERNAL_ERROR "VG lock %s hits NULL.",

				 vgname);

			return 0;

		}

		if (!_vgname_order_correct(vgname2, vgname)) {

			log_errno(EDEADLK, INTERNAL_ERROR "VG lock %s must "

				  "be requested before %s, not after.",

				  vgname, vgname2);

			return 0;

		}

	}

	return 1;

}

void lvmcache_lock_vgname(const char *vgname, int read_only __attribute__((unused)))

{

	if (!_lock_hash && !lvmcache_init()) {

		log_error("Internal cache initialisation failed");

		return;

	}

	if (dm_hash_lookup(_lock_hash, vgname))

		log_error(INTERNAL_ERROR "Nested locking attempted on VG %s.",

			  vgname);

	if (!dm_hash_insert(_lock_hash, vgname, (void *) 1))

		log_error("Cache locking failure for %s", vgname);

	_update_cache_lock_state(vgname, 1);

	if (strcmp(vgname, VG_GLOBAL))

		_vgs_locked++;

}

int lvmcache_vgname_is_locked(const char *vgname)

{

	if (!_lock_hash)

		return 0;

	return dm_hash_lookup(_lock_hash, is_orphan_vg(vgname) ? VG_ORPHANS : vgname) ? 1 : 0;

}

void lvmcache_unlock_vgname(const char *vgname)

{

	if (!dm_hash_lookup(_lock_hash, vgname))

		log_error(INTERNAL_ERROR "Attempt to unlock unlocked VG %s.",

			  vgname);

	_update_cache_lock_state(vgname, 0);

	dm_hash_remove(_lock_hash, vgname);

	/* FIXME Do this per-VG */

	if (strcmp(vgname, VG_GLOBAL) && !--_vgs_locked)

		dev_close_all();

}

int lvmcache_vgs_locked(void)

{

	return _vgs_locked;

}

static void _vginfo_attach_info(struct lvmcache_vginfo *vginfo,

				struct lvmcache_info *info)

{

	if (!vginfo)

		return;

	info->vginfo = vginfo;

	dm_list_add(&vginfo->infos, &info->list);

}

static void _vginfo_detach_info(struct lvmcache_info *info)

{

	if (!dm_list_empty(&info->list)) {

		dm_list_del(&info->list);

		dm_list_init(&info->list);

	}

	info->vginfo = NULL;

}

/* If vgid supplied, require a match. */

struct lvmcache_vginfo *lvmcache_vginfo_from_vgname(const char *vgname, const char *vgid)

{

	struct lvmcache_vginfo *vginfo;

	if (!vgname)

		return lvmcache_vginfo_from_vgid(vgid);

	if (!_vgname_hash)

		return NULL;

	if (!(vginfo = dm_hash_lookup(_vgname_hash, vgname)))

		return NULL;

	if (vgid)

		do

			if (!strncmp(vgid, vginfo->vgid, ID_LEN))

				return vginfo;

		while ((vginfo = vginfo->next));

	return vginfo;

}

const struct format_type *lvmcache_fmt_from_vgname(struct cmd_context *cmd,

						   const char *vgname, const char *vgid,

						   unsigned revalidate_labels)

{

	struct lvmcache_vginfo *vginfo;

	struct lvmcache_info *info;

	struct label *label;

	struct dm_list *devh, *tmp;

	struct dm_list devs;

	struct device_list *devl;

	struct volume_group *vg;

	const struct format_type *fmt;

	char vgid_found[ID_LEN + 1] __attribute__((aligned(8)));

	if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, vgid))) {

		if (!lvmetad_active())

			return NULL; /* too bad */

		/* If we don't have the info but we have lvmetad, we can ask

		 * there before failing. */

		if ((vg = lvmetad_vg_lookup(cmd, vgname, vgid))) {

			fmt = vg->fid->fmt;

			release_vg(vg);

			return fmt;

		}

		return NULL;

	}

	/*

	 * If this function is called repeatedly, only the first one needs to revalidate.

	 */

	if (!revalidate_labels)

		goto out;

	/*

	 * This function is normally called before reading metadata so

 	 * we check cached labels here. Unfortunately vginfo is volatile.

 	 */

	dm_list_init(&devs);

	dm_list_iterate_items(info, &vginfo->infos) {

		if (!(devl = dm_malloc(sizeof(*devl)))) {

			log_error("device_list element allocation failed");

			return NULL;

		}

		devl->dev = info->dev;

		dm_list_add(&devs, &devl->list);

	}

	memcpy(vgid_found, vginfo->vgid, sizeof(vgid_found));

	dm_list_iterate_safe(devh, tmp, &devs) {

		devl = dm_list_item(devh, struct device_list);

		(void) label_read(devl->dev, &label, UINT64_C(0));

		dm_list_del(&devl->list);

		dm_free(devl);

	}

	/* If vginfo changed, caller needs to rescan */

	if (!(vginfo = lvmcache_vginfo_from_vgname(vgname, vgid_found)) ||

	    strncmp(vginfo->vgid, vgid_found, ID_LEN))

		return NULL;

out:

	return vginfo->fmt;

}

struct lvmcache_vginfo *lvmcache_vginfo_from_vgid(const char *vgid)

{

	struct lvmcache_vginfo *vginfo;

	char id[ID_LEN + 1] __attribute__((aligned(8)));

	if (!_vgid_hash || !vgid)

		return NULL;

	/* vgid not necessarily NULL-terminated */

	strncpy(&id[0], vgid, ID_LEN);

	id[ID_LEN] = '\0';

	if (!(vginfo = dm_hash_lookup(_vgid_hash, id)))

		return NULL;

	return vginfo;

}

const char *lvmcache_vgname_from_vgid(struct dm_pool *mem, const char *vgid)

{

	struct lvmcache_vginfo *vginfo;

	const char *vgname = NULL;

	if ((vginfo = lvmcache_vginfo_from_vgid(vgid)))

		vgname = vginfo->vgname;

	if (mem && vgname)

		return dm_pool_strdup(mem, vgname);

	return vgname;

}

static int _info_is_valid(struct lvmcache_info *info)

{

	if (info->status & CACHE_INVALID)

		return 0;

	/*

	 * The caller must hold the VG lock to manipulate metadata.

	 * In a cluster, remote nodes sometimes read metadata in the

	 * knowledge that the controlling node is holding the lock.

	 * So if the VG appears to be unlocked here, it should be safe

	 * to use the cached value.

	 */

	if (info->vginfo && !lvmcache_vgname_is_locked(info->vginfo->vgname))

		return 1;

	if (!(info->status & CACHE_LOCKED))

		return 0;

	return 1;

}

static int _vginfo_is_valid(struct lvmcache_vginfo *vginfo)

{

	struct lvmcache_info *info;

	/* Invalid if any info is invalid */

	dm_list_iterate_items(info, &vginfo->infos)

		if (!_info_is_valid(info))

			return 0;

	return 1;

}

/* vginfo is invalid if it does not contain at least one valid info */

static int _vginfo_is_invalid(struct lvmcache_vginfo *vginfo)

{

	struct lvmcache_info *info;

	dm_list_iterate_items(info, &vginfo->infos)

		if (_info_is_valid(info))

			return 0;

	return 1;

}

/*

 * If valid_only is set, data will only be returned if the cached data is

 * known still to be valid.

 */

struct lvmcache_info *lvmcache_info_from_pvid(const char *pvid, int valid_only)

{

	struct lvmcache_info *info;

	char id[ID_LEN + 1] __attribute__((aligned(8)));

	if (!_pvid_hash || !pvid)

		return NULL;

	strncpy(&id[0], pvid, ID_LEN);

	id[ID_LEN] = '\0';

	if (!(info = dm_hash_lookup(_pvid_hash, id)))

		return NULL;

	if (valid_only && !_info_is_valid(info))

		return NULL;

	return info;

}

const char *lvmcache_vgname_from_info(struct lvmcache_info *info)

{

	if (info->vginfo)

		return info->vginfo->vgname;

	return NULL;

}

char *lvmcache_vgname_from_pvid(struct cmd_context *cmd, const char *pvid)

{

	struct lvmcache_info *info;

	char *vgname;

	if (!lvmcache_device_from_pvid(cmd, (const struct id *)pvid, NULL, NULL)) {

		log_error("Couldn't find device with uuid %s.", pvid);

		return NULL;

	}

	info = lvmcache_info_from_pvid(pvid, 0);

	if (!info)

		return_NULL;

	if (!(vgname = dm_pool_strdup(cmd->mem, info->vginfo->vgname))) {

		log_errno(ENOMEM, "vgname allocation failed");

		return NULL;

	}

	return vgname;

}

static void _rescan_entry(struct lvmcache_info *info)

{

	struct label *label;

	if (info->status & CACHE_INVALID)

		(void) label_read(info->dev, &label, UINT64_C(0));

}

static int _scan_invalid(void)

{

	dm_hash_iter(_pvid_hash, (dm_hash_iterate_fn) _rescan_entry);

	return 1;

}

int lvmcache_label_scan(struct cmd_context *cmd, int full_scan)

{

	struct label *label;

	struct dev_iter *iter;

	struct device *dev;

	struct format_type *fmt;

	int r = 0;

	if (lvmetad_active())

		return 1;

	/* Avoid recursion when a PVID can't be found! */

	if (_scanning_in_progress)

		return 0;

	_scanning_in_progress = 1;

	if (!_vgname_hash && !lvmcache_init()) {

		log_error("Internal cache initialisation failed");

		goto out;

	}

	if (_has_scanned && !full_scan) {

		r = _scan_invalid();

		goto out;

	}

	if (full_scan == 2 && (cmd->filter && !cmd->filter->use_count) && !refresh_filters(cmd))

		goto_out;

	if (!cmd->filter || !(iter = dev_iter_create(cmd->filter, (full_scan == 2) ? 1 : 0))) {

		log_error("dev_iter creation failed");

		goto out;

	}

	while ((dev = dev_iter_get(iter)))

		(void) label_read(dev, &label, UINT64_C(0));

	dev_iter_destroy(iter);

	_has_scanned = 1;

	/* Perform any format-specific scanning e.g. text files */

	if (cmd->independent_metadata_areas)

		dm_list_iterate_items(fmt, &cmd->formats)

			if (fmt->ops->scan && !fmt->ops->scan(fmt, NULL))

				goto out;