[mirror_ubuntu-eoan-kernel.git] / fs / dlm / dir.c

/******************************************************************************
*******************************************************************************
**
**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
**
**  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 General Public License v.2.
**
*******************************************************************************
******************************************************************************/

#include "dlm_internal.h"
#include "lockspace.h"
#include "member.h"
#include "lowcomms.h"
#include "rcom.h"
#include "config.h"
#include "memory.h"
#include "recover.h"
#include "util.h"
#include "lock.h"
#include "dir.h"


static void put_free_de(struct dlm_ls *ls, struct dlm_direntry *de)
{
	spin_lock(&ls->ls_recover_list_lock);
	list_add(&de->list, &ls->ls_recover_list);
	spin_unlock(&ls->ls_recover_list_lock);
}

static struct dlm_direntry *get_free_de(struct dlm_ls *ls, int len)
{
	int found = 0;
	struct dlm_direntry *de;

	spin_lock(&ls->ls_recover_list_lock);
	list_for_each_entry(de, &ls->ls_recover_list, list) {
		if (de->length == len) {
			list_del(&de->list);
			de->master_nodeid = 0;
			memset(de->name, 0, len);
			found = 1;
			break;
		}
	}
	spin_unlock(&ls->ls_recover_list_lock);

	if (!found)
		de = kzalloc(sizeof(struct dlm_direntry) + len,
			     ls->ls_allocation);
	return de;
}

void dlm_clear_free_entries(struct dlm_ls *ls)
{
	struct dlm_direntry *de;

	spin_lock(&ls->ls_recover_list_lock);
	while (!list_empty(&ls->ls_recover_list)) {
		de = list_entry(ls->ls_recover_list.next, struct dlm_direntry,
				list);
		list_del(&de->list);
		kfree(de);
	}
	spin_unlock(&ls->ls_recover_list_lock);
}

/*
 * We use the upper 16 bits of the hash value to select the directory node.
 * Low bits are used for distribution of rsb's among hash buckets on each node.
 *
 * To give the exact range wanted (0 to num_nodes-1), we apply a modulus of
 * num_nodes to the hash value.  This value in the desired range is used as an
 * offset into the sorted list of nodeid's to give the particular nodeid.
 */

int dlm_hash2nodeid(struct dlm_ls *ls, uint32_t hash)
{
	struct list_head *tmp;
	struct dlm_member *memb = NULL;
	uint32_t node, n = 0;
	int nodeid;

	if (ls->ls_num_nodes == 1) {
		nodeid = dlm_our_nodeid();
		goto out;
	}

	if (ls->ls_node_array) {
		node = (hash >> 16) % ls->ls_total_weight;
		nodeid = ls->ls_node_array[node];
		goto out;
	}

	/* make_member_array() failed to kmalloc ls_node_array... */

	node = (hash >> 16) % ls->ls_num_nodes;

	list_for_each(tmp, &ls->ls_nodes) {
		if (n++ != node)
			continue;
		memb = list_entry(tmp, struct dlm_member, list);
		break;
	}

	DLM_ASSERT(memb , printk("num_nodes=%u n=%u node=%u\n",
				 ls->ls_num_nodes, n, node););
	nodeid = memb->nodeid;
 out:
	return nodeid;
}

int dlm_dir_nodeid(struct dlm_rsb *r)
{
	return dlm_hash2nodeid(r->res_ls, r->res_hash);
}

static inline uint32_t dir_hash(struct dlm_ls *ls, char *name, int len)
{
	uint32_t val;

	val = jhash(name, len, 0);
	val &= (ls->ls_dirtbl_size - 1);

	return val;
}

static void add_entry_to_hash(struct dlm_ls *ls, struct dlm_direntry *de)
{
	uint32_t bucket;

	bucket = dir_hash(ls, de->name, de->length);
	list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
}

static struct dlm_direntry *search_bucket(struct dlm_ls *ls, char *name,
					  int namelen, uint32_t bucket)
{
	struct dlm_direntry *de;

	list_for_each_entry(de, &ls->ls_dirtbl[bucket].list, list) {
		if (de->length == namelen && !memcmp(name, de->name, namelen))
			goto out;
	}
	de = NULL;
 out:
	return de;
}

void dlm_dir_remove_entry(struct dlm_ls *ls, int nodeid, char *name, int namelen)
{
	struct dlm_direntry *de;
	uint32_t bucket;

	bucket = dir_hash(ls, name, namelen);

	spin_lock(&ls->ls_dirtbl[bucket].lock);

	de = search_bucket(ls, name, namelen, bucket);

	if (!de) {
		log_error(ls, "remove fr %u none", nodeid);
		goto out;
	}

	if (de->master_nodeid != nodeid) {
		log_error(ls, "remove fr %u ID %u", nodeid, de->master_nodeid);
		goto out;
	}

	list_del(&de->list);
	kfree(de);
 out:
	spin_unlock(&ls->ls_dirtbl[bucket].lock);
}

void dlm_dir_clear(struct dlm_ls *ls)
{
	struct list_head *head;
	struct dlm_direntry *de;
	int i;

	DLM_ASSERT(list_empty(&ls->ls_recover_list), );

	for (i = 0; i < ls->ls_dirtbl_size; i++) {
		spin_lock(&ls->ls_dirtbl[i].lock);
		head = &ls->ls_dirtbl[i].list;
		while (!list_empty(head)) {
			de = list_entry(head->next, struct dlm_direntry, list);
			list_del(&de->list);
			put_free_de(ls, de);
		}
		spin_unlock(&ls->ls_dirtbl[i].lock);
	}
}

int dlm_recover_directory(struct dlm_ls *ls)
{
	struct dlm_member *memb;
	struct dlm_direntry *de;
	char *b, *last_name = NULL;
	int error = -ENOMEM, last_len, count = 0;
	uint16_t namelen;

	log_debug(ls, "dlm_recover_directory");

	if (dlm_no_directory(ls))
		goto out_status;

	dlm_dir_clear(ls);

	last_name = kmalloc(DLM_RESNAME_MAXLEN, ls->ls_allocation);
	if (!last_name)
		goto out;

	list_for_each_entry(memb, &ls->ls_nodes, list) {
		memset(last_name, 0, DLM_RESNAME_MAXLEN);
		last_len = 0;

		for (;;) {
			int left;
			error = dlm_recovery_stopped(ls);
			if (error)
				goto out_free;

			error = dlm_rcom_names(ls, memb->nodeid,
					       last_name, last_len);
			if (error)
				goto out_free;

			schedule();

			/*
			 * pick namelen/name pairs out of received buffer
			 */

			b = ls->ls_recover_buf->rc_buf;
			left = ls->ls_recover_buf->rc_header.h_length;
			left -= sizeof(struct dlm_rcom);

			for (;;) {
				__be16 v;

				error = -EINVAL;
				if (left < sizeof(__be16))
					goto out_free;

				memcpy(&v, b, sizeof(__be16));
				namelen = be16_to_cpu(v);
				b += sizeof(__be16);
				left -= sizeof(__be16);

				/* namelen of 0xFFFFF marks end of names for
				   this node; namelen of 0 marks end of the
				   buffer */

				if (namelen == 0xFFFF)
					goto done;
				if (!namelen)
					break;

				if (namelen > left)
					goto out_free;

				if (namelen > DLM_RESNAME_MAXLEN)
					goto out_free;

				error = -ENOMEM;
				de = get_free_de(ls, namelen);
				if (!de)
					goto out_free;

				de->master_nodeid = memb->nodeid;
				de->length = namelen;
				last_len = namelen;
				memcpy(de->name, b, namelen);
				memcpy(last_name, b, namelen);
				b += namelen;
				left -= namelen;

				add_entry_to_hash(ls, de);
				count++;
			}
		}
         done:
		;
	}

 out_status:
	error = 0;
	dlm_set_recover_status(ls, DLM_RS_DIR);
	log_debug(ls, "dlm_recover_directory %d entries", count);
 out_free:
	kfree(last_name);
 out:
	dlm_clear_free_entries(ls);
	return error;
}

static int get_entry(struct dlm_ls *ls, int nodeid, char *name,
		     int namelen, int *r_nodeid)
{
	struct dlm_direntry *de, *tmp;
	uint32_t bucket;

	bucket = dir_hash(ls, name, namelen);

	spin_lock(&ls->ls_dirtbl[bucket].lock);
	de = search_bucket(ls, name, namelen, bucket);
	if (de) {
		*r_nodeid = de->master_nodeid;
		spin_unlock(&ls->ls_dirtbl[bucket].lock);
		if (*r_nodeid == nodeid)
			return -EEXIST;
		return 0;
	}

	spin_unlock(&ls->ls_dirtbl[bucket].lock);

	if (namelen > DLM_RESNAME_MAXLEN)
		return -EINVAL;

	de = kzalloc(sizeof(struct dlm_direntry) + namelen, ls->ls_allocation);
	if (!de)
		return -ENOMEM;

	de->master_nodeid = nodeid;
	de->length = namelen;
	memcpy(de->name, name, namelen);

	spin_lock(&ls->ls_dirtbl[bucket].lock);
	tmp = search_bucket(ls, name, namelen, bucket);
	if (tmp) {
		kfree(de);
		de = tmp;
	} else {
		list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
	}
	*r_nodeid = de->master_nodeid;
	spin_unlock(&ls->ls_dirtbl[bucket].lock);
	return 0;
}

int dlm_dir_lookup(struct dlm_ls *ls, int nodeid, char *name, int namelen,
		   int *r_nodeid)
{
	return get_entry(ls, nodeid, name, namelen, r_nodeid);
}

static struct dlm_rsb *find_rsb_root(struct dlm_ls *ls, char *name, int len)
{
	struct dlm_rsb *r;

	down_read(&ls->ls_root_sem);
	list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
		if (len == r->res_length && !memcmp(name, r->res_name, len)) {
			up_read(&ls->ls_root_sem);
			return r;
		}
	}
	up_read(&ls->ls_root_sem);
	return NULL;
}

/* Find the rsb where we left off (or start again), then send rsb names
   for rsb's we're master of and whose directory node matches the requesting
   node.  inbuf is the rsb name last sent, inlen is the name's length */

void dlm_copy_master_names(struct dlm_ls *ls, char *inbuf, int inlen,
 			   char *outbuf, int outlen, int nodeid)
{
	struct list_head *list;
	struct dlm_rsb *r;
	int offset = 0, dir_nodeid;
	__be16 be_namelen;

	down_read(&ls->ls_root_sem);

	if (inlen > 1) {
		r = find_rsb_root(ls, inbuf, inlen);
		if (!r) {
			inbuf[inlen - 1] = '\0';
			log_error(ls, "copy_master_names from %d start %d %s",
				  nodeid, inlen, inbuf);
			goto out;
		}
		list = r->res_root_list.next;
	} else {
		list = ls->ls_root_list.next;
	}

	for (offset = 0; list != &ls->ls_root_list; list = list->next) {
		r = list_entry(list, struct dlm_rsb, res_root_list);
		if (r->res_nodeid)
			continue;

		dir_nodeid = dlm_dir_nodeid(r);
		if (dir_nodeid != nodeid)
			continue;

		/*
		 * The block ends when we can't fit the following in the
		 * remaining buffer space:
		 * namelen (uint16_t) +
		 * name (r->res_length) +
		 * end-of-block record 0x0000 (uint16_t)
		 */

		if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
			/* Write end-of-block record */
			be_namelen = cpu_to_be16(0);
			memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
			offset += sizeof(__be16);
			goto out;
		}

		be_namelen = cpu_to_be16(r->res_length);
		memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
		offset += sizeof(__be16);
		memcpy(outbuf + offset, r->res_name, r->res_length);
		offset += r->res_length;
	}

	/*
	 * If we've reached the end of the list (and there's room) write a
	 * terminating record.
	 */

	if ((list == &ls->ls_root_list) &&
	    (offset + sizeof(uint16_t) <= outlen)) {
		be_namelen = cpu_to_be16(0xFFFF);
		memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
		offset += sizeof(__be16);
	}

 out:
	up_read(&ls->ls_root_sem);
}
Commit	Line	Data
e7fd4179 DT	1	/******************************************************************************
	2	*******************************************************************************
	3	**
	4	** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
	5	** Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
	6	**
	7	** This copyrighted material is made available to anyone wishing to use,
	8	** modify, copy, or redistribute it subject to the terms and conditions
	9	** of the GNU General Public License v.2.
	10	**
	11	*******************************************************************************
	12	******************************************************************************/
	13
	14	#include "dlm_internal.h"
	15	#include "lockspace.h"
	16	#include "member.h"
	17	#include "lowcomms.h"
	18	#include "rcom.h"
	19	#include "config.h"
	20	#include "memory.h"
	21	#include "recover.h"
	22	#include "util.h"
	23	#include "lock.h"
	24	#include "dir.h"
	25
	26
	27	static void put_free_de(struct dlm_ls ls, struct dlm_direntry de)
	28	{
	29	spin_lock(&ls->ls_recover_list_lock);
	30	list_add(&de->list, &ls->ls_recover_list);
	31	spin_unlock(&ls->ls_recover_list_lock);
	32	}
	33
	34	static struct dlm_direntry get_free_de(struct dlm_ls ls, int len)
	35	{
90135925	36	int found = 0;
e7fd4179 DT	37	struct dlm_direntry *de;
	38
	39	spin_lock(&ls->ls_recover_list_lock);
	40	list_for_each_entry(de, &ls->ls_recover_list, list) {
	41	if (de->length == len) {
	42	list_del(&de->list);
	43	de->master_nodeid = 0;
	44	memset(de->name, 0, len);
90135925	45	found = 1;
e7fd4179 DT	46	break;
	47	}
	48	}
	49	spin_unlock(&ls->ls_recover_list_lock);
	50
	51	if (!found)
748285cc DT	52	de = kzalloc(sizeof(struct dlm_direntry) + len,
748285cc DT	53	ls->ls_allocation);
e7fd4179 DT	54	return de;
	55	}
	56
	57	void dlm_clear_free_entries(struct dlm_ls *ls)
	58	{
	59	struct dlm_direntry *de;
	60
	61	spin_lock(&ls->ls_recover_list_lock);
	62	while (!list_empty(&ls->ls_recover_list)) {
	63	de = list_entry(ls->ls_recover_list.next, struct dlm_direntry,
	64	list);
	65	list_del(&de->list);
52bda2b5	66	kfree(de);
e7fd4179 DT	67	}
	68	spin_unlock(&ls->ls_recover_list_lock);
	69	}
	70
	71	/*
	72	* We use the upper 16 bits of the hash value to select the directory node.
	73	* Low bits are used for distribution of rsb's among hash buckets on each node.
	74	*
	75	* To give the exact range wanted (0 to num_nodes-1), we apply a modulus of
	76	* num_nodes to the hash value. This value in the desired range is used as an
	77	* offset into the sorted list of nodeid's to give the particular nodeid.
	78	*/
	79
	80	int dlm_hash2nodeid(struct dlm_ls *ls, uint32_t hash)
	81	{
	82	struct list_head *tmp;
	83	struct dlm_member *memb = NULL;
	84	uint32_t node, n = 0;
	85	int nodeid;
	86
	87	if (ls->ls_num_nodes == 1) {
	88	nodeid = dlm_our_nodeid();
	89	goto out;
	90	}
	91
	92	if (ls->ls_node_array) {
	93	node = (hash >> 16) % ls->ls_total_weight;
	94	nodeid = ls->ls_node_array[node];
	95	goto out;
	96	}
	97
	98	/* make_member_array() failed to kmalloc ls_node_array... */
	99
	100	node = (hash >> 16) % ls->ls_num_nodes;
	101
	102	list_for_each(tmp, &ls->ls_nodes) {
	103	if (n++ != node)
	104	continue;
	105	memb = list_entry(tmp, struct dlm_member, list);
	106	break;
	107	}
	108
	109	DLM_ASSERT(memb , printk("num_nodes=%u n=%u node=%u\n",
	110	ls->ls_num_nodes, n, node););
	111	nodeid = memb->nodeid;
	112	out:
	113	return nodeid;
	114	}
	115
	116	int dlm_dir_nodeid(struct dlm_rsb *r)
	117	{
	118	return dlm_hash2nodeid(r->res_ls, r->res_hash);
	119	}
	120
	121	static inline uint32_t dir_hash(struct dlm_ls ls, char name, int len)
	122	{
	123	uint32_t val;
	124
	125	val = jhash(name, len, 0);
	126	val &= (ls->ls_dirtbl_size - 1);
	127
	128	return val;
	129	}
	130
131	static void add_entry_to_hash(struct dlm_ls ls, struct dlm_direntry de)
132	{
133	uint32_t bucket;
134
135	bucket = dir_hash(ls, de->name, de->length);
136	list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
137	}
138
139	static struct dlm_direntry search_bucket(struct dlm_ls ls, char *name,
140	int namelen, uint32_t bucket)
141	{
142	struct dlm_direntry *de;
143
144	list_for_each_entry(de, &ls->ls_dirtbl[bucket].list, list) {
145	if (de->length == namelen && !memcmp(name, de->name, namelen))
146	goto out;
147	}
148	de = NULL;
149	out:
150	return de;
151	}
152
153	void dlm_dir_remove_entry(struct dlm_ls ls, int nodeid, char name, int namelen)
154	{
155	struct dlm_direntry *de;
156	uint32_t bucket;
157
158	bucket = dir_hash(ls, name, namelen);
159
305a47b1	160	spin_lock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	161
	162	de = search_bucket(ls, name, namelen, bucket);
	163
	164	if (!de) {
	165	log_error(ls, "remove fr %u none", nodeid);
	166	goto out;
	167	}
	168
	169	if (de->master_nodeid != nodeid) {
	170	log_error(ls, "remove fr %u ID %u", nodeid, de->master_nodeid);
	171	goto out;
	172	}
	173
	174	list_del(&de->list);
52bda2b5	175	kfree(de);
e7fd4179	176	out:
305a47b1	177	spin_unlock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	178	}
	179
	180	void dlm_dir_clear(struct dlm_ls *ls)
	181	{
	182	struct list_head *head;
	183	struct dlm_direntry *de;
	184	int i;
	185
	186	DLM_ASSERT(list_empty(&ls->ls_recover_list), );
	187
	188	for (i = 0; i < ls->ls_dirtbl_size; i++) {
305a47b1	189	spin_lock(&ls->ls_dirtbl[i].lock);
e7fd4179 DT	190	head = &ls->ls_dirtbl[i].list;
	191	while (!list_empty(head)) {
	192	de = list_entry(head->next, struct dlm_direntry, list);
	193	list_del(&de->list);
	194	put_free_de(ls, de);
	195	}
305a47b1	196	spin_unlock(&ls->ls_dirtbl[i].lock);
e7fd4179 DT	197	}
	198	}
	199
	200	int dlm_recover_directory(struct dlm_ls *ls)
	201	{
	202	struct dlm_member *memb;
	203	struct dlm_direntry *de;
	204	char b, last_name = NULL;
	205	int error = -ENOMEM, last_len, count = 0;
	206	uint16_t namelen;
	207
	208	log_debug(ls, "dlm_recover_directory");
	209
	210	if (dlm_no_directory(ls))
	211	goto out_status;
	212
	213	dlm_dir_clear(ls);
	214
748285cc	215	last_name = kmalloc(DLM_RESNAME_MAXLEN, ls->ls_allocation);
e7fd4179 DT	216	if (!last_name)
	217	goto out;
	218
	219	list_for_each_entry(memb, &ls->ls_nodes, list) {
	220	memset(last_name, 0, DLM_RESNAME_MAXLEN);
	221	last_len = 0;
	222
	223	for (;;) {
cd9df1aa	224	int left;
e7fd4179 DT	225	error = dlm_recovery_stopped(ls);
	226	if (error)
	227	goto out_free;
	228
	229	error = dlm_rcom_names(ls, memb->nodeid,
	230	last_name, last_len);
	231	if (error)
	232	goto out_free;
	233
	234	schedule();
	235
	236	/*
	237	* pick namelen/name pairs out of received buffer
	238	*/
	239
4007685c	240	b = ls->ls_recover_buf->rc_buf;
cd9df1aa AV	241	left = ls->ls_recover_buf->rc_header.h_length;
cd9df1aa AV	242	left -= sizeof(struct dlm_rcom);
e7fd4179 DT	243
e7fd4179 DT	244	for (;;) {
cd9df1aa AV	245	__be16 v;
	246
	247	error = -EINVAL;
	248	if (left < sizeof(__be16))
	249	goto out_free;
	250
	251	memcpy(&v, b, sizeof(__be16));
	252	namelen = be16_to_cpu(v);
	253	b += sizeof(__be16);
	254	left -= sizeof(__be16);
e7fd4179 DT	255
	256	/* namelen of 0xFFFFF marks end of names for
	257	this node; namelen of 0 marks end of the
	258	buffer */
	259
	260	if (namelen == 0xFFFF)
	261	goto done;
	262	if (!namelen)
	263	break;
	264
cd9df1aa AV	265	if (namelen > left)
	266	goto out_free;
	267
	268	if (namelen > DLM_RESNAME_MAXLEN)
	269	goto out_free;
	270
e7fd4179 DT	271	error = -ENOMEM;
	272	de = get_free_de(ls, namelen);
	273	if (!de)
	274	goto out_free;
	275
	276	de->master_nodeid = memb->nodeid;
	277	de->length = namelen;
	278	last_len = namelen;
	279	memcpy(de->name, b, namelen);
	280	memcpy(last_name, b, namelen);
	281	b += namelen;
cd9df1aa	282	left -= namelen;
e7fd4179 DT	283
	284	add_entry_to_hash(ls, de);
	285	count++;
	286	}
	287	}
	288	done:
	289	;
	290	}
	291
	292	out_status:
	293	error = 0;
	294	dlm_set_recover_status(ls, DLM_RS_DIR);
	295	log_debug(ls, "dlm_recover_directory %d entries", count);
	296	out_free:
	297	kfree(last_name);
	298	out:
	299	dlm_clear_free_entries(ls);
	300	return error;
	301	}
	302
	303	static int get_entry(struct dlm_ls ls, int nodeid, char name,
	304	int namelen, int *r_nodeid)
	305	{
	306	struct dlm_direntry de, tmp;
	307	uint32_t bucket;
	308
	309	bucket = dir_hash(ls, name, namelen);
	310
305a47b1	311	spin_lock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	312	de = search_bucket(ls, name, namelen, bucket);
	313	if (de) {
	314	*r_nodeid = de->master_nodeid;
305a47b1	315	spin_unlock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	316	if (*r_nodeid == nodeid)
	317	return -EEXIST;
	318	return 0;
	319	}
	320
305a47b1	321	spin_unlock(&ls->ls_dirtbl[bucket].lock);
e7fd4179	322
043b19cd AV	323	if (namelen > DLM_RESNAME_MAXLEN)
	324	return -EINVAL;
	325
748285cc	326	de = kzalloc(sizeof(struct dlm_direntry) + namelen, ls->ls_allocation);
e7fd4179 DT	327	if (!de)
	328	return -ENOMEM;
	329
	330	de->master_nodeid = nodeid;
	331	de->length = namelen;
	332	memcpy(de->name, name, namelen);
	333
305a47b1	334	spin_lock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	335	tmp = search_bucket(ls, name, namelen, bucket);
e7fd4179 DT	336	if (tmp) {
52bda2b5	337	kfree(de);
e7fd4179 DT	338	de = tmp;
	339	} else {
	340	list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
	341	}
	342	*r_nodeid = de->master_nodeid;
305a47b1	343	spin_unlock(&ls->ls_dirtbl[bucket].lock);
e7fd4179 DT	344	return 0;
	345	}
	346
	347	int dlm_dir_lookup(struct dlm_ls ls, int nodeid, char name, int namelen,
	348	int *r_nodeid)
	349	{
	350	return get_entry(ls, nodeid, name, namelen, r_nodeid);
	351	}
	352
85f0379a DT	353	static struct dlm_rsb find_rsb_root(struct dlm_ls ls, char *name, int len)
	354	{
	355	struct dlm_rsb *r;
	356
	357	down_read(&ls->ls_root_sem);
	358	list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
	359	if (len == r->res_length && !memcmp(name, r->res_name, len)) {
	360	up_read(&ls->ls_root_sem);
	361	return r;
	362	}
	363	}
	364	up_read(&ls->ls_root_sem);
	365	return NULL;
	366	}
	367
	368	/* Find the rsb where we left off (or start again), then send rsb names
	369	for rsb's we're master of and whose directory node matches the requesting
	370	node. inbuf is the rsb name last sent, inlen is the name's length */
e7fd4179 DT	371
	372	void dlm_copy_master_names(struct dlm_ls ls, char inbuf, int inlen,
	373	char *outbuf, int outlen, int nodeid)
	374	{
	375	struct list_head *list;
85f0379a DT	376	struct dlm_rsb *r;
85f0379a DT	377	int offset = 0, dir_nodeid;
cd8e4679	378	__be16 be_namelen;
e7fd4179	379
e7fd4179	380	down_read(&ls->ls_root_sem);
85f0379a DT	381
	382	if (inlen > 1) {
	383	r = find_rsb_root(ls, inbuf, inlen);
	384	if (!r) {
	385	inbuf[inlen - 1] = '\0';
	386	log_error(ls, "copy_master_names from %d start %d %s",
	387	nodeid, inlen, inbuf);
	388	goto out;
	389	}
	390	list = r->res_root_list.next;
	391	} else {
e7fd4179	392	list = ls->ls_root_list.next;
85f0379a	393	}
e7fd4179 DT	394
	395	for (offset = 0; list != &ls->ls_root_list; list = list->next) {
	396	r = list_entry(list, struct dlm_rsb, res_root_list);
	397	if (r->res_nodeid)
	398	continue;
	399
	400	dir_nodeid = dlm_dir_nodeid(r);
	401	if (dir_nodeid != nodeid)
	402	continue;
	403
	404	/*
	405	* The block ends when we can't fit the following in the
	406	* remaining buffer space:
	407	* namelen (uint16_t) +
	408	* name (r->res_length) +
	409	* end-of-block record 0x0000 (uint16_t)
	410	*/
	411
	412	if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
	413	/* Write end-of-block record */
cd8e4679 HH	414	be_namelen = cpu_to_be16(0);
	415	memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
	416	offset += sizeof(__be16);
e7fd4179 DT	417	goto out;
	418	}
	419
	420	be_namelen = cpu_to_be16(r->res_length);
cd8e4679 HH	421	memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
cd8e4679 HH	422	offset += sizeof(__be16);
e7fd4179 DT	423	memcpy(outbuf + offset, r->res_name, r->res_length);
	424	offset += r->res_length;
	425	}
	426
	427	/*
	428	* If we've reached the end of the list (and there's room) write a
	429	* terminating record.
	430	*/
	431
	432	if ((list == &ls->ls_root_list) &&
	433	(offset + sizeof(uint16_t) <= outlen)) {
cd8e4679 HH	434	be_namelen = cpu_to_be16(0xFFFF);
	435	memcpy(outbuf + offset, &be_namelen, sizeof(__be16));
	436	offset += sizeof(__be16);
e7fd4179 DT	437	}
	438
	439	out:
	440	up_read(&ls->ls_root_sem);
	441	}
	442