[deliverable/linux.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 = allocate_direntry(ls, len);
	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);
		free_direntry(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);

	write_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);
	free_direntry(de);
 out:
	write_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++) {
		write_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);
		}
		write_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_KERNEL);
	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 (;;) {
			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 + sizeof(struct dlm_rcom);

			for (;;) {
				memcpy(&namelen, b, sizeof(uint16_t));
				namelen = be16_to_cpu(namelen);
				b += sizeof(uint16_t);

				/* 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;

				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;

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

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

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

	de = allocate_direntry(ls, namelen);
	if (!de)
		return -ENOMEM;

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

	write_lock(&ls->ls_dirtbl[bucket].lock);
	tmp = search_bucket(ls, name, namelen, bucket);
	if (tmp) {
		free_direntry(de);
		de = tmp;
	} else {
		list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
	}
	*r_nodeid = de->master_nodeid;
	write_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);
}

/* Copy the names of master rsb's into the buffer provided.
   Only select names whose dir node is the given nodeid. */

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 *start_r = NULL, *r = NULL;
	int offset = 0, start_namelen, error, dir_nodeid;
	char *start_name;
	uint16_t be_namelen;

	/*
	 * Find the rsb where we left off (or start again)
	 */

	start_namelen = inlen;
	start_name = inbuf;

	if (start_namelen > 1) {
		/*
		 * We could also use a find_rsb_root() function here that
		 * searched the ls_root_list.
		 */
		error = dlm_find_rsb(ls, start_name, start_namelen, R_MASTER,
				     &start_r);
		DLM_ASSERT(!error && start_r,
			   printk("error %d\n", error););
		DLM_ASSERT(!list_empty(&start_r->res_root_list),
			   dlm_print_rsb(start_r););
		dlm_put_rsb(start_r);
	}

	/*
	 * Send rsb names for rsb's we're master of and whose directory node
	 * matches the requesting node.
	 */

	down_read(&ls->ls_root_sem);
	if (start_r)
		list = start_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 = 0;
			memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
			offset += sizeof(uint16_t);
			goto out;
		}

		be_namelen = cpu_to_be16(r->res_length);
		memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
		offset += sizeof(uint16_t);
		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 = 0xFFFF;
		memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
		offset += sizeof(uint16_t);
	}

 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)
	52	de = allocate_direntry(ls, len);
	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);
	65	free_direntry(de);
	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
159	write_lock(&ls->ls_dirtbl[bucket].lock);
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);
174	free_direntry(de);
175	out:
176	write_unlock(&ls->ls_dirtbl[bucket].lock);
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++) {
188	write_lock(&ls->ls_dirtbl[i].lock);
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	}
195	write_unlock(&ls->ls_dirtbl[i].lock);
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
214	last_name = kmalloc(DLM_RESNAME_MAXLEN, GFP_KERNEL);
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 (;;) {
223	error = dlm_recovery_stopped(ls);
224	if (error)
225	goto out_free;
226
227	error = dlm_rcom_names(ls, memb->nodeid,
228	last_name, last_len);
229	if (error)
230	goto out_free;
231
232	schedule();
233
234	/*
235	* pick namelen/name pairs out of received buffer
236	*/
237
238	b = ls->ls_recover_buf + sizeof(struct dlm_rcom);
239
240	for (;;) {
241	memcpy(&namelen, b, sizeof(uint16_t));
242	namelen = be16_to_cpu(namelen);
243	b += sizeof(uint16_t);
244
245	/* namelen of 0xFFFFF marks end of names for
246	this node; namelen of 0 marks end of the
247	buffer */
248
249	if (namelen == 0xFFFF)
250	goto done;
251	if (!namelen)
252	break;
253
254	error = -ENOMEM;
255	de = get_free_de(ls, namelen);
256	if (!de)
257	goto out_free;
258
259	de->master_nodeid = memb->nodeid;
260	de->length = namelen;
261	last_len = namelen;
262	memcpy(de->name, b, namelen);
263	memcpy(last_name, b, namelen);
264	b += namelen;
265
266	add_entry_to_hash(ls, de);
267	count++;
268	}
269	}
270	done:
271	;
272	}
273
274	out_status:
275	error = 0;
276	dlm_set_recover_status(ls, DLM_RS_DIR);
277	log_debug(ls, "dlm_recover_directory %d entries", count);
278	out_free:
279	kfree(last_name);
280	out:
281	dlm_clear_free_entries(ls);
282	return error;
283	}
284
285	static int get_entry(struct dlm_ls ls, int nodeid, char name,
286	int namelen, int *r_nodeid)
287	{
288	struct dlm_direntry de, tmp;
289	uint32_t bucket;
290
291	bucket = dir_hash(ls, name, namelen);
292
293	write_lock(&ls->ls_dirtbl[bucket].lock);
294	de = search_bucket(ls, name, namelen, bucket);
295	if (de) {
296	*r_nodeid = de->master_nodeid;
297	write_unlock(&ls->ls_dirtbl[bucket].lock);
298	if (*r_nodeid == nodeid)
299	return -EEXIST;
300	return 0;
301	}
302
303	write_unlock(&ls->ls_dirtbl[bucket].lock);
304
305	de = allocate_direntry(ls, namelen);
306	if (!de)
307	return -ENOMEM;
308
309	de->master_nodeid = nodeid;
310	de->length = namelen;
311	memcpy(de->name, name, namelen);
312
313	write_lock(&ls->ls_dirtbl[bucket].lock);
314	tmp = search_bucket(ls, name, namelen, bucket);
315	if (tmp) {
316	free_direntry(de);
317	de = tmp;
318	} else {
319	list_add_tail(&de->list, &ls->ls_dirtbl[bucket].list);
320	}
321	*r_nodeid = de->master_nodeid;
322	write_unlock(&ls->ls_dirtbl[bucket].lock);
323	return 0;
324	}
325
326	int dlm_dir_lookup(struct dlm_ls ls, int nodeid, char name, int namelen,
327	int *r_nodeid)
328	{
329	return get_entry(ls, nodeid, name, namelen, r_nodeid);
330	}
331
332	/* Copy the names of master rsb's into the buffer provided.
333	Only select names whose dir node is the given nodeid. */
334
335	void dlm_copy_master_names(struct dlm_ls ls, char inbuf, int inlen,
336	char *outbuf, int outlen, int nodeid)
337	{
338	struct list_head *list;
339	struct dlm_rsb start_r = NULL, r = NULL;
340	int offset = 0, start_namelen, error, dir_nodeid;
341	char *start_name;
342	uint16_t be_namelen;
343
344	/*
345	* Find the rsb where we left off (or start again)
346	*/
347
348	start_namelen = inlen;
349	start_name = inbuf;
350
351	if (start_namelen > 1) {
352	/*
353	* We could also use a find_rsb_root() function here that
354	* searched the ls_root_list.
355	*/
356	error = dlm_find_rsb(ls, start_name, start_namelen, R_MASTER,
357	&start_r);
358	DLM_ASSERT(!error && start_r,
359	printk("error %d\n", error););
360	DLM_ASSERT(!list_empty(&start_r->res_root_list),
361	dlm_print_rsb(start_r););
362	dlm_put_rsb(start_r);
363	}
364
365	/*
366	* Send rsb names for rsb's we're master of and whose directory node
367	* matches the requesting node.
368	*/
369
370	down_read(&ls->ls_root_sem);
371	if (start_r)
372	list = start_r->res_root_list.next;
373	else
374	list = ls->ls_root_list.next;
375
376	for (offset = 0; list != &ls->ls_root_list; list = list->next) {
377	r = list_entry(list, struct dlm_rsb, res_root_list);
378	if (r->res_nodeid)
379	continue;
380
381	dir_nodeid = dlm_dir_nodeid(r);
382	if (dir_nodeid != nodeid)
383	continue;
384
385	/*
386	* The block ends when we can't fit the following in the
387	* remaining buffer space:
388	* namelen (uint16_t) +
389	* name (r->res_length) +
390	* end-of-block record 0x0000 (uint16_t)
391	*/
392
393	if (offset + sizeof(uint16_t)*2 + r->res_length > outlen) {
394	/* Write end-of-block record */
395	be_namelen = 0;
396	memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
397	offset += sizeof(uint16_t);
398	goto out;
399	}
400
401	be_namelen = cpu_to_be16(r->res_length);
402	memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
403	offset += sizeof(uint16_t);
404	memcpy(outbuf + offset, r->res_name, r->res_length);
405	offset += r->res_length;
406	}
407
408	/*
409	* If we've reached the end of the list (and there's room) write a
410	* terminating record.
411	*/
412
413	if ((list == &ls->ls_root_list) &&
414	(offset + sizeof(uint16_t) <= outlen)) {
415	be_namelen = 0xFFFF;
416	memcpy(outbuf + offset, &be_namelen, sizeof(uint16_t));
417	offset += sizeof(uint16_t);
418	}
419
420	out:
421	up_read(&ls->ls_root_sem);
422	}
423