lvmetad: remove old thread lockingdev-dct-lvmetad-thread-locking-1

While the thread locking was very fine grained and complex,
there was no apparent concurrency advantage to it.  The
previously added request level locking is vastly simpler
and probably allows much more concurrency.

1 files changed, 3 insertions, 211 deletions

diff --git a/daemons/lvmetad/lvmetad-core.c b/daemons/lvmetad/lvmetad-core.c
index 5ff148bb4..f9d0d4ce5 100644
--- a/daemons/lvmetad/lvmetad-core.c
+++ b/daemons/lvmetad/lvmetad-core.c
@@ -222,13 +222,6 @@ typedef struct {
 	struct dm_hash_table *vgid_to_info;
 	struct dm_hash_table *vgname_to_vgid;
 	struct dm_hash_table *pvid_to_vgid;
-	struct {
-		struct dm_hash_table *vg;
-		pthread_mutex_t vg_lock_map;
-		pthread_mutex_t pvid_to_pvmeta;
-		pthread_mutex_t vgid_to_metadata;
-		pthread_mutex_t pvid_to_vgid;
-	} lock;
 	char token[128];
 	uint32_t flags; /* GLFL_ */
 	pthread_mutex_t token_lock;
@@ -272,21 +265,6 @@ static void create_metadata_hashes(lvmetad_state *s)
 	s->vgname_to_vgid = dm_hash_create(32);
 }
 
-static void lock_pvid_to_pvmeta(lvmetad_state *s) {
-	pthread_mutex_lock(&s->lock.pvid_to_pvmeta); }
-static void unlock_pvid_to_pvmeta(lvmetad_state *s) {
-	pthread_mutex_unlock(&s->lock.pvid_to_pvmeta); }
-
-static void lock_vgid_to_metadata(lvmetad_state *s) {
-	pthread_mutex_lock(&s->lock.vgid_to_metadata); }
-static void unlock_vgid_to_metadata(lvmetad_state *s) {
-	pthread_mutex_unlock(&s->lock.vgid_to_metadata); }
-
-static void lock_pvid_to_vgid(lvmetad_state *s) {
-	pthread_mutex_lock(&s->lock.pvid_to_vgid); }
-static void unlock_pvid_to_vgid(lvmetad_state *s) {
-	pthread_mutex_unlock(&s->lock.pvid_to_vgid); }
-
 static response reply_fail(const char *reason)
 {
 	return daemon_reply_simple("failed", "reason = %s", reason, NULL);
@@ -297,57 +275,6 @@ static response reply_unknown(const char *reason)
 	return daemon_reply_simple("unknown", "reason = %s", reason, NULL);
 }
 
-/*
- * TODO: It may be beneficial to clean up the vg lock hash from time to time,
- * since if we have many "rogue" requests for nonexistent things, we will keep
- * allocating memory that we never release. Not good.
- */
-static struct dm_config_tree *lock_vg(lvmetad_state *s, const char *id) {
-	pthread_mutex_t *vg;
-	struct dm_config_tree *cft;
-	pthread_mutexattr_t rec;
-
-	pthread_mutex_lock(&s->lock.vg_lock_map);
-	if (!(vg = dm_hash_lookup(s->lock.vg, id))) {
-		if (!(vg = malloc(sizeof(pthread_mutex_t))) ||
-		    pthread_mutexattr_init(&rec) ||
-		    pthread_mutexattr_settype(&rec, PTHREAD_MUTEX_RECURSIVE_NP) ||
-		    pthread_mutex_init(vg, &rec))
-			goto bad;
-		if (!dm_hash_insert(s->lock.vg, id, vg)) {
-			pthread_mutex_destroy(vg);
-			goto bad;
-		}
-	}
-	/* We never remove items from s->lock.vg => the pointer remains valid. */
-	pthread_mutex_unlock(&s->lock.vg_lock_map);
-
-	/* DEBUGLOG(s, "locking VG %s", id); */
-	pthread_mutex_lock(vg);
-
-	/* Protect against structure changes of the vgid_to_metadata hash. */
-	lock_vgid_to_metadata(s);
-	cft = dm_hash_lookup(s->vgid_to_metadata, id);
-	unlock_vgid_to_metadata(s);
-	return cft;
-bad:
-	pthread_mutex_unlock(&s->lock.vg_lock_map);
-	free(vg);
-	ERROR(s, "Out of memory");
-	return NULL;
-}
-
-static void unlock_vg(lvmetad_state *s, const char *id) {
-	pthread_mutex_t *vg;
-
-	/* DEBUGLOG(s, "unlocking VG %s", id); */
-	/* Protect the s->lock.vg structure from concurrent access. */
-	pthread_mutex_lock(&s->lock.vg_lock_map);
-	if ((vg = dm_hash_lookup(s->lock.vg, id)))
-		pthread_mutex_unlock(vg);
-	pthread_mutex_unlock(&s->lock.vg_lock_map);
-}
-
 static struct dm_config_node *pvs(struct dm_config_node *vg)
 {
 	struct dm_config_node *pv = dm_config_find_node(vg, "metadata/physical_volumes");
@@ -409,8 +336,6 @@ static int update_pv_status(lvmetad_state *s,
 	struct dm_config_node *pvmeta_cn;
 	int ret = 1;
 
-	lock_pvid_to_pvmeta(s);
-
 	for (pv = pvs(vg); pv; pv = pv->sib) {
 		if (!(uuid = dm_config_find_str(pv->child, "id", NULL))) {
 			ERROR(s, "update_pv_status found no uuid for PV");
@@ -432,7 +357,6 @@ static int update_pv_status(lvmetad_state *s,
 		}
 	}
 out:
-	unlock_pvid_to_pvmeta(s);
 	return ret;
 }
 
@@ -474,9 +398,7 @@ static struct dm_config_node *make_pv_node(lvmetad_state *s, const char *pvid,
 		return NULL;
 
 	if (vgid) {
-		lock_vgid_to_metadata(s); // XXX
 		vgname = dm_hash_lookup(s->vgid_to_vgname, vgid);
-		unlock_vgid_to_metadata(s);
 	}
 
 	/* Nick the pvmeta config tree. */
@@ -520,8 +442,6 @@ static response pv_list(lvmetad_state *s, request r)
 
 	cn_pvs = make_config_node(res.cft, "physical_volumes", NULL, res.cft->root);
 
-	lock_pvid_to_pvmeta(s);
-
 	dm_hash_iterate(n, s->pvid_to_pvmeta) {
 		id = dm_hash_get_key(s->pvid_to_pvmeta, n);
 		cn = make_pv_node(s, id, res.cft, cn_pvs, cn);
@@ -530,8 +450,6 @@ static response pv_list(lvmetad_state *s, request r)
 	if (s->flags & GLFL_INVALID)
 		add_last_node(res.cft, "global_invalid");
 
-	unlock_pvid_to_pvmeta(s);
-
 	return res;
 }
 
@@ -555,12 +473,10 @@ static response pv_lookup(lvmetad_state *s, request r)
 	if (!(res.cft->root = make_text_node(res.cft, "response", "OK", NULL, NULL)))
 		return reply_fail("out of memory");
 
-	lock_pvid_to_pvmeta(s);
 	if (!pvid && devt)
 		pvid = dm_hash_lookup_binary(s->device_to_pvid, &devt, sizeof(devt));
 
 	if (!pvid) {
-		unlock_pvid_to_pvmeta(s);
 		WARN(s, "pv_lookup: could not find device %" PRIu64, devt);
 		dm_config_destroy(res.cft);
 		return reply_unknown("device not found");
@@ -568,13 +484,11 @@ static response pv_lookup(lvmetad_state *s, request r)
 
 	pv = make_pv_node(s, pvid, res.cft, NULL, res.cft->root);
 	if (!pv) {
-		unlock_pvid_to_pvmeta(s);
 		dm_config_destroy(res.cft);
 		return reply_unknown("PV not found");
 	}
 
 	pv->key = "physical_volume";
-	unlock_pvid_to_pvmeta(s);
 
 	if (s->flags & GLFL_INVALID)
 		add_last_node(res.cft, "global_invalid");
@@ -616,8 +530,6 @@ static response vg_list(lvmetad_state *s, request r)
 	cn->v = NULL;
 	cn->child = NULL;
 
-	lock_vgid_to_metadata(s);
-
 	dm_hash_iterate(n, s->vgid_to_vgname) {
 		id = dm_hash_get_key(s->vgid_to_vgname, n),
 		name = dm_hash_get_data(s->vgid_to_vgname, n);
@@ -648,8 +560,6 @@ static response vg_list(lvmetad_state *s, request r)
 		cn_last = cn;
 	}
 
-	unlock_vgid_to_metadata(s);
-
 	if (s->flags & GLFL_INVALID)
 		add_last_node(res.cft, "global_invalid");
 bad:
@@ -662,9 +572,7 @@ static void mark_outdated_pv(lvmetad_state *s, const char *vgid, const char *pvi
 	struct dm_config_node *list, *cft_vgid;
 	struct dm_config_value *v;
 
-	lock_pvid_to_pvmeta(s);
 	pvmeta = dm_hash_lookup(s->pvid_to_pvmeta, pvid);
-	unlock_pvid_to_pvmeta(s);
 
 	/* if the MDA exists and is used, it will have ignore=0 set */
 	if (!pvmeta ||
@@ -745,12 +653,10 @@ static response vg_lookup(lvmetad_state *s, request r)
 		DEBUGLOG(s, "vg_lookup vgid %s name %s needs lookup",
 			 uuid ?: "none", name ?: "none");
 
-		lock_vgid_to_metadata(s);
 		if (name && !uuid)
 			uuid = dm_hash_lookup_with_count(s->vgname_to_vgid, name, &count);
 		else if (uuid && !name)
 			name = dm_hash_lookup(s->vgid_to_vgname, uuid);
-		unlock_vgid_to_metadata(s);
 
 		if (name && uuid && (count > 1)) {
 			DEBUGLOG(s, "vg_lookup name %s vgid %s found %d vgids",
@@ -780,9 +686,8 @@ static response vg_lookup(lvmetad_state *s, request r)
 
 	DEBUGLOG(s, "vg_lookup vgid %s name %s", uuid ?: "none", name ?: "none");
 
-	cft = lock_vg(s, uuid);
+	cft = dm_hash_lookup(s->vgid_to_metadata, uuid);
 	if (!cft || !cft->root) {
-		unlock_vg(s, uuid);
 		return reply_unknown("UUID not found");
 	}
 
@@ -815,7 +720,6 @@ static response vg_lookup(lvmetad_state *s, request r)
 	if (!(n = n->sib = dm_config_clone_node(res.cft, metadata, 1)))
 		goto nomem_un;
 	n->parent = res.cft->root;
-	unlock_vg(s, uuid);
 
 	if (!update_pv_status(s, res.cft, n))
 		goto nomem;
@@ -833,7 +737,6 @@ static response vg_lookup(lvmetad_state *s, request r)
 	return res;
 
 nomem_un:
-	unlock_vg(s, uuid);
 nomem:
 	reply_fail("out of memory");
 	ERROR(s, "vg_lookup vgid %s name %s out of memory.", uuid ?: "none", name ?: "none");
@@ -901,9 +804,7 @@ static int _update_pvid_to_vgid(lvmetad_state *s, struct dm_config_tree *vg,
 
 	dm_hash_iterate(n, to_check) {
 		check_vgid = dm_hash_get_key(to_check, n);
-		lock_vg(s, check_vgid);
 		vg_remove_if_missing(s, check_vgid, 0);
-		unlock_vg(s, check_vgid);
 	}
 
 	r = 1;
@@ -925,8 +826,6 @@ static int remove_metadata(lvmetad_state *s, const char *vgid, int update_pvids)
 	char *name_lookup = NULL;
 	char *vgid_lookup = NULL;
 
-	lock_vgid_to_metadata(s);
-
 	/* get data pointers from hash table so they can be freed */
 
 	info_lookup = dm_hash_lookup(s->vgid_to_info, vgid);
@@ -945,8 +844,6 @@ static int remove_metadata(lvmetad_state *s, const char *vgid, int update_pvids)
 	if (name_lookup)
 		dm_hash_remove_with_val(s->vgname_to_vgid, name_lookup, vgid, strlen(vgid) + 1);
 
-	unlock_vgid_to_metadata(s);
-
 	/* update_pvid_to_vgid will clear/free the pvid_to_vgid hash */
 	if (update_pvids && meta_lookup)
 		_update_pvid_to_vgid(s, meta_lookup, "#orphan", 0);
@@ -981,7 +878,6 @@ static int vg_remove_if_missing(lvmetad_state *s, const char *vgid, int update_p
 	if (!(vg = dm_hash_lookup(s->vgid_to_metadata, vgid)))
 		return 1;
 
-	lock_pvid_to_pvmeta(s);
 	for (pv = pvs(vg->root); pv; pv = pv->sib) {
 		if (!(pvid = dm_config_find_str(pv->child, "id", NULL)))
 			continue;
@@ -997,8 +893,6 @@ static int vg_remove_if_missing(lvmetad_state *s, const char *vgid, int update_p
 		remove_metadata(s, vgid, update_pvids);
 	}
 
-	unlock_pvid_to_pvmeta(s);
-
 	return 1;
 }
 
@@ -1020,14 +914,12 @@ static void _purge_metadata(lvmetad_state *s, const char *arg_name, const char *
 {
 	char *rem_vgid;
 
-	lock_pvid_to_vgid(s);
 	remove_metadata(s, arg_vgid, 1);
 
 	if ((rem_vgid = dm_hash_lookup_with_val(s->vgname_to_vgid, arg_name, arg_vgid, strlen(arg_vgid) + 1))) {
 		dm_hash_remove_with_val(s->vgname_to_vgid, arg_name, arg_vgid, strlen(arg_vgid) + 1);
 		dm_free(rem_vgid);
 	}
-	unlock_pvid_to_vgid(s);
 }
 
 /*
@@ -1060,10 +952,6 @@ static int _update_metadata_new_vgid(lvmetad_state *s,
 	if (!(arg_name_dup = dm_strdup(arg_name)))
 		goto ret;
 
-	lock_vg(s, new_vgid);
-	lock_pvid_to_vgid(s);
-	lock_vgid_to_metadata(s);
-
 	/*
 	 * Temporarily orphan the PVs in the old metadata.
 	 */
@@ -1130,9 +1018,6 @@ static int _update_metadata_new_vgid(lvmetad_state *s,
 	DEBUGLOG(s, "update_metadata_new_vgid is done for %s %s", arg_name, new_vgid);
 	retval = 1;
 out:
-	unlock_vgid_to_metadata(s);
-	unlock_pvid_to_vgid(s);
-	unlock_vg(s, new_vgid);
 ret:
 	if (!new_vgid_dup || !arg_name_dup || abort_daemon) {
 		ERROR(s, "lvmetad could not be updated and is aborting.");
@@ -1174,10 +1059,6 @@ static int _update_metadata_new_name(lvmetad_state *s,
 	if (!(arg_vgid_dup = dm_strdup(arg_vgid)))
 		goto ret;
 
-	lock_vg(s, arg_vgid);
-	lock_pvid_to_vgid(s);
-	lock_vgid_to_metadata(s);
-
 	/*
 	 * Temporarily orphan the PVs in the old metadata.
 	 */
@@ -1244,9 +1125,6 @@ static int _update_metadata_new_name(lvmetad_state *s,
 	DEBUGLOG(s, "update_metadata_new_name is done for %s %s", new_name, arg_vgid);
 	retval = 1;
 out:
-	unlock_vgid_to_metadata(s);
-	unlock_pvid_to_vgid(s);
-	unlock_vg(s, arg_vgid);
 ret:
 	if (!new_name_dup || !arg_vgid_dup || abort_daemon) {
 		ERROR(s, "lvmetad could not be updated and is aborting.");
@@ -1279,10 +1157,6 @@ static int _update_metadata_add_new(lvmetad_state *s, const char *new_name, cons
 	if (!(new_vgid_dup = dm_strdup(new_vgid)))
 		goto out_free;
 
-	lock_vg(s, new_vgid);
-	lock_pvid_to_vgid(s);
-	lock_vgid_to_metadata(s);
-
 	if (!dm_hash_insert(s->vgid_to_metadata, new_vgid, new_meta)) {
 		ERROR(s, "update_metadata_add_new out of memory for meta hash insert for %s %s", new_name, new_vgid);
 		abort_daemon = 1;
@@ -1310,10 +1184,6 @@ static int _update_metadata_add_new(lvmetad_state *s, const char *new_name, cons
 	DEBUGLOG(s, "update_metadata_add_new is done for %s %s", new_name, new_vgid);
 	retval = 1;
 out:
-	unlock_vgid_to_metadata(s);
-	unlock_pvid_to_vgid(s);
-	unlock_vg(s, new_vgid);
-
 out_free:
 	if (!new_name_dup || !new_vgid_dup || abort_daemon) {
 		ERROR(s, "lvmetad could not be updated and is aborting.");
@@ -1381,7 +1251,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 	 * . the VG could have unchanged vgid and name - found existing record of both.
 	 */
 
-	lock_vgid_to_metadata(s);
 	arg_name_lookup = dm_hash_lookup(s->vgid_to_vgname, arg_vgid);
 	arg_vgid_lookup = dm_hash_lookup_with_val(s->vgname_to_vgid, arg_name, arg_vgid, strlen(arg_vgid) + 1);
 
@@ -1538,8 +1407,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 	}
 
  update:
-	unlock_vgid_to_metadata(s);
-
 	filter_metadata(new_metadata); /* sanitize */
 
 	/*
@@ -1682,9 +1549,7 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 		      pvid, new_seq, arg_vgid, arg_name, old_seq);
 		DEBUGLOG_cft(s, "OLD: ", old_meta->root);
 		DEBUGLOG_cft(s, "NEW: ", new_metadata);
-		lock_pvid_to_vgid(s);
 		_update_pvid_to_vgid(s, old_meta, arg_vgid, MARK_OUTDATED);
-		unlock_pvid_to_vgid(s);
 	}
 
 	/*
@@ -1800,10 +1665,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 	 */
 	DEBUGLOG(s, "update_metadata for %s %s from %d to %d", arg_name, arg_vgid, old_seq, new_seq);
 
-	lock_vg(s, arg_vgid);
-	lock_pvid_to_vgid(s);
-	lock_vgid_to_metadata(s);
-
 	/*
 	 * The PVs in the VG may have changed in the new metadata, so
 	 * temporarily orphan all of the PVs in the existing VG.
@@ -1812,9 +1673,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 	 */
 	if (!_update_pvid_to_vgid(s, old_meta, "#orphan", 0)) {
 		ERROR(s, "update_metadata failed to move PVs for %s %s", arg_name, arg_vgid);
-		unlock_vgid_to_metadata(s);
-		unlock_pvid_to_vgid(s);
-		unlock_vg(s, arg_vgid);
 		abort_daemon = 1;
 		retval = 0;
 		goto out;
@@ -1832,9 +1690,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 
 	if (!dm_hash_insert(s->vgid_to_metadata, arg_vgid, new_meta)) {
 		ERROR(s, "update_metadata out of memory for hash insert for %s %s", arg_name, arg_vgid);
-		unlock_vgid_to_metadata(s);
-		unlock_pvid_to_vgid(s);
-		unlock_vg(s, arg_vgid);
 		abort_daemon = 1;
 		retval = 0;
 		goto out;
@@ -1857,10 +1712,6 @@ static int _update_metadata(lvmetad_state *s, const char *arg_name, const char *
 		retval = 1;
 	}
 
-	unlock_vgid_to_metadata(s);
-	unlock_pvid_to_vgid(s);
-	unlock_vg(s, arg_vgid);
-
 out:
 	if (abort_daemon) {
 		ERROR(s, "lvmetad could not be updated is aborting.");
@@ -1884,12 +1735,10 @@ static response pv_gone(lvmetad_state *s, request r)
 	arg_pvid = daemon_request_str(r, "uuid", NULL);
 	device = daemon_request_int(r, "device", 0);
 
-	lock_pvid_to_pvmeta(s);
 	if (!arg_pvid && device > 0)
 		old_pvid = dm_hash_lookup_binary(s->device_to_pvid, &device, sizeof(device));
 
 	if (!arg_pvid && !old_pvid) {
-		unlock_pvid_to_pvmeta(s);
 		DEBUGLOG(s, "pv_gone device %" PRIu64 " not found", device);
 		return reply_unknown("device not in cache");
 	}
@@ -1909,8 +1758,6 @@ static response pv_gone(lvmetad_state *s, request r)
 	dm_hash_remove_binary(s->device_to_pvid, &device, sizeof(device));
 	dm_hash_remove(s->pvid_to_pvmeta, pvid);
 
-	unlock_pvid_to_pvmeta(s);
-
 	if (vgid) {
 		char *vgid_dup;
 		/*
@@ -1921,9 +1768,7 @@ static response pv_gone(lvmetad_state *s, request r)
 		if (!(vgid_dup = dm_strdup(vgid)))
 			return reply_fail("out of memory");
 
-		lock_vg(s, vgid_dup);
 		vg_remove_if_missing(s, vgid_dup, 1);
-		unlock_vg(s, vgid_dup);
 		dm_free(vgid_dup);
 		vgid_dup = NULL;
 		vgid = NULL;
@@ -1940,17 +1785,9 @@ static response pv_clear_all(lvmetad_state *s, request r)
 {
 	DEBUGLOG(s, "pv_clear_all");
 
-	lock_pvid_to_pvmeta(s);
-	lock_pvid_to_vgid(s);
-	lock_vgid_to_metadata(s);
-
 	destroy_metadata_hashes(s);
 	create_metadata_hashes(s);
 
-	unlock_pvid_to_vgid(s);
-	unlock_vgid_to_metadata(s);
-	unlock_pvid_to_pvmeta(s);
-
 	return daemon_reply_simple("OK", NULL);
 }
 
@@ -1964,8 +1801,6 @@ static int _vg_is_complete(lvmetad_state *s, struct dm_config_tree *vgmeta)
 	int complete = 1;
 	const char *pvid;
 
-	lock_pvid_to_pvmeta(s);
-
 	for (pv = pvs(vg); pv; pv = pv->sib) {
 		if (!(pvid = dm_config_find_str(pv->child, "id", NULL)))
 			continue;
@@ -1975,7 +1810,6 @@ static int _vg_is_complete(lvmetad_state *s, struct dm_config_tree *vgmeta)
 			break;
 		}
 	}
-	unlock_pvid_to_pvmeta(s);
 
 	return complete;
 }
@@ -2116,8 +1950,6 @@ static response pv_found(lvmetad_state *s, request r)
 	 * Existing (old) cache values.
 	 */
 
-	lock_pvid_to_pvmeta(s);
-
 	old_pvmeta = dm_hash_lookup(s->pvid_to_pvmeta, arg_pvid);
 	if (old_pvmeta)
 		dm_config_get_uint64(old_pvmeta->root, "pvmeta/device", &arg_device_lookup);
@@ -2188,7 +2020,6 @@ static response pv_found(lvmetad_state *s, request r)
 		      arg_pvid_lookup ?: "none",
 		      arg_vgid_lookup ?: "none",
 		      arg_device_lookup);
-		unlock_pvid_to_pvmeta(s);
 		return reply_fail("Ignore PV for unknown state");
 	}
 
@@ -2256,7 +2087,6 @@ static response pv_found(lvmetad_state *s, request r)
 			if (dm_hash_lookup(s->pvid_to_pvmeta, new_pvid)) {
 				DEBUGLOG(s, "pv_found ignore duplicate device %" PRIu64 " of existing PV for pvid %s",
 				         arg_device, arg_pvid);
-				unlock_pvid_to_pvmeta(s);
 				dm_config_destroy(new_pvmeta);
 				s->flags |= GLFL_DISABLE;
 				s->flags |= GLFL_DISABLE_REASON_DUPLICATES;
@@ -2281,15 +2111,12 @@ static response pv_found(lvmetad_state *s, request r)
 		 */
 		DEBUGLOG(s, "pv_found ignore duplicate device %" PRIu64 " of existing device %" PRIu64 " for pvid %s",
 			 new_device, old_device, arg_pvid);
-		unlock_pvid_to_pvmeta(s);
 		dm_config_destroy(new_pvmeta);
 		s->flags |= GLFL_DISABLE;
 		s->flags |= GLFL_DISABLE_REASON_DUPLICATES;
 		return reply_fail("Ignore duplicate PV");
 	}
 
-	unlock_pvid_to_pvmeta(s);
-
 	if (old_pvmeta)
 		dm_config_destroy(old_pvmeta);
 
@@ -2308,21 +2135,17 @@ static response pv_found(lvmetad_state *s, request r)
 
 		changed |= (old_seqno != arg_seqno);
 	} else {
-		lock_pvid_to_vgid(s);
 		arg_vgid = dm_hash_lookup(s->pvid_to_vgid, arg_pvid);
-		unlock_pvid_to_vgid(s);
 
 		if (arg_vgid) {
-			lock_vgid_to_metadata(s);
 			arg_name = dm_hash_lookup(s->vgid_to_vgname, arg_vgid);
-			unlock_vgid_to_metadata(s);
 		}
 	}
 
 	/*
 	 * Check if the VG is complete (all PVs have been found) because
 	 * the reply indicates if the the VG is complete or partial.
-	 * The "vgmeta" from lock_vg will be a copy of arg_vgmeta that
+	 * The "vgmeta" from dm_hash_lookup will be a copy of arg_vgmeta that
 	 * was cloned and added to the cache by update_metadata.
 	 */
 	if (!arg_vgid || !strcmp(arg_vgid, "#orphan")) {
@@ -2332,14 +2155,13 @@ static response pv_found(lvmetad_state *s, request r)
 		goto prev_vals;
 	}
 
-	if (!(vgmeta = lock_vg(s, arg_vgid))) {
+	if (!(vgmeta = dm_hash_lookup(s->vgid_to_metadata, arg_vgid))) {
 		ERROR(s, "pv_found %s on %" PRIu64 " vgid %s no VG metadata found",
 		      arg_pvid, arg_device, arg_vgid);
 	} else {
 		vg_status = _vg_is_complete(s, vgmeta) ? "complete" : "partial";
 		vg_status_seqno = dm_config_find_int(vgmeta->root, "metadata/seqno", -1);
 	}
-	unlock_vg(s, arg_vgid);
 
  prev_vals:
 	/*
@@ -2364,9 +2186,7 @@ static response pv_found(lvmetad_state *s, request r)
 			tmp_vgid = dm_strdup(prev_vgid_on_dev);
 			/* vg_remove_if_missing will clear and free
 			   the string pointed to by prev_vgid_on_dev. */
-			lock_vg(s, tmp_vgid);
 			vg_remove_if_missing(s, tmp_vgid, 1);
-			unlock_vg(s, tmp_vgid);
 			dm_free(tmp_vgid);
 		}
 
@@ -2484,9 +2304,7 @@ static response vg_remove(lvmetad_state *s, request r)
 
 	DEBUGLOG(s, "vg_remove: %s", vgid);
 
-	lock_pvid_to_vgid(s);
 	remove_metadata(s, vgid, 1);
-	unlock_pvid_to_vgid(s);
 
 	return daemon_reply_simple("OK", NULL);
 }
@@ -2745,10 +2563,6 @@ static response dump(lvmetad_state *s)
 
 	/* Lock everything so that we get a consistent dump. */
 
-	lock_vgid_to_metadata(s);
-	lock_pvid_to_pvmeta(s);
-	lock_pvid_to_vgid(s);
-
 	buffer_append(b, "# VG METADATA\n\n");
 	_dump_cft(b, s->vgid_to_metadata, "metadata/id");
 
@@ -2776,10 +2590,6 @@ static response dump(lvmetad_state *s)
 	buffer_append(b, "\n# VGID to INFO flags mapping\n\n");
 	_dump_info_flags(b, s->vgid_to_info, "vgid_to_info", 0);
 
-	unlock_pvid_to_vgid(s);
-	unlock_pvid_to_pvmeta(s);
-	unlock_vgid_to_metadata(s);
-
 	return res;
 }
 
@@ -2905,22 +2715,14 @@ static response handler(daemon_state s, client_handle h, request r)
 
 static int init(daemon_state *s)
 {
-	pthread_mutexattr_t rec;
 	lvmetad_state *ls = s->private;
 	ls->log = s->log;
 
-	pthread_mutexattr_init(&rec);
-	pthread_mutexattr_settype(&rec, PTHREAD_MUTEX_RECURSIVE_NP);
-	pthread_mutex_init(&ls->lock.pvid_to_pvmeta, &rec);
-	pthread_mutex_init(&ls->lock.vgid_to_metadata, &rec);
-	pthread_mutex_init(&ls->lock.pvid_to_vgid, NULL);
-	pthread_mutex_init(&ls->lock.vg_lock_map, NULL);
 	pthread_mutex_init(&ls->token_lock, NULL);
 	pthread_mutex_init(&ls->info_lock, NULL);
 	pthread_rwlock_init(&ls->cache_lock, NULL);
 	create_metadata_hashes(ls);
 
-	ls->lock.vg = dm_hash_create(32);
 	ls->token[0] = 0;
 
 	/* Set up stderr logging depending on the -l option. */
@@ -2943,19 +2745,9 @@ static int init(daemon_state *s)
 static int fini(daemon_state *s)
 {
 	lvmetad_state *ls = s->private;
-	struct dm_hash_node *n;
 
 	DEBUGLOG(s, "fini");
-
 	destroy_metadata_hashes(ls);
-
-	/* Destroy the lock hashes now. */
-	dm_hash_iterate(n, ls->lock.vg) {
-		pthread_mutex_destroy(dm_hash_get_data(ls->lock.vg, n));
-		free(dm_hash_get_data(ls->lock.vg, n));
-	}
-
-	dm_hash_destroy(ls->lock.vg);
 	return 1;
 }