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