[linux-2.6-block.git] / fs / orangefs / dir.c

/*
 * (C) 2001 Clemson University and The University of Chicago
 *
 * See COPYING in top-level directory.
 */

#include "protocol.h"
#include "orangefs-kernel.h"
#include "orangefs-bufmap.h"

/*
 * decode routine used by kmod to deal with the blob sent from
 * userspace for readdirs. The blob contains zero or more of these
 * sub-blobs:
 *   __u32 - represents length of the character string that follows.
 *   string - between 1 and ORANGEFS_NAME_MAX bytes long.
 *   padding - (if needed) to cause the __u32 plus the string to be
 *             eight byte aligned.
 *   khandle - sizeof(khandle) bytes.
 */
static long decode_dirents(char *ptr, size_t size,
                           struct orangefs_readdir_response_s *readdir)
{
	int i;
	struct orangefs_readdir_response_s *rd =
		(struct orangefs_readdir_response_s *) ptr;
	char *buf = ptr;
	int khandle_size = sizeof(struct orangefs_khandle);
	size_t offset = offsetof(struct orangefs_readdir_response_s,
				dirent_array);
	/* 8 reflects eight byte alignment */
	int smallest_blob = khandle_size + 8;
	__u32 len;
	int aligned_len;
	int sizeof_u32 = sizeof(__u32);
	long ret;

	gossip_debug(GOSSIP_DIR_DEBUG, "%s: size:%zu:\n", __func__, size);

	/* size is = offset on empty dirs, > offset on non-empty dirs... */
	if (size < offset) {
		gossip_err("%s: size:%zu: offset:%zu:\n",
			   __func__,
			   size,
			   offset);
		ret = -EINVAL;
		goto out;
	}

        if ((size == offset) && (readdir->orangefs_dirent_outcount != 0)) {
		gossip_err("%s: size:%zu: dirent_outcount:%d:\n",
			   __func__,
			   size,
			   readdir->orangefs_dirent_outcount);
		ret = -EINVAL;
		goto out;
	}

	readdir->token = rd->token;
	readdir->orangefs_dirent_outcount = rd->orangefs_dirent_outcount;
	readdir->dirent_array = kcalloc(readdir->orangefs_dirent_outcount,
					sizeof(*readdir->dirent_array),
					GFP_KERNEL);
	if (readdir->dirent_array == NULL) {
		gossip_err("%s: kcalloc failed.\n", __func__);
		ret = -ENOMEM;
		goto out;
	}

	buf += offset;
	size -= offset;

	for (i = 0; i < readdir->orangefs_dirent_outcount; i++) {
		if (size < smallest_blob) {
			gossip_err("%s: size:%zu: smallest_blob:%d:\n",
				   __func__,
				   size,
				   smallest_blob);
			ret = -EINVAL;
			goto free;
		}

		len = *(__u32 *)buf;
		if ((len < 1) || (len > ORANGEFS_NAME_MAX)) {
			gossip_err("%s: len:%d:\n", __func__, len);
			ret = -EINVAL;
			goto free;
		}

		gossip_debug(GOSSIP_DIR_DEBUG,
			     "%s: size:%zu: len:%d:\n",
			     __func__,
			     size,
			     len);

		readdir->dirent_array[i].d_name = buf + sizeof_u32;
		readdir->dirent_array[i].d_length = len;

		/*
		 * Calculate "aligned" length of this string and its
		 * associated __u32 descriptor.
		 */
		aligned_len = ((sizeof_u32 + len + 1) + 7) & ~7;
		gossip_debug(GOSSIP_DIR_DEBUG,
			     "%s: aligned_len:%d:\n",
			     __func__,
			     aligned_len);

		/*
		 * The end of the blob should coincide with the end
		 * of the last sub-blob.
		 */
		if (size < aligned_len + khandle_size) {
			gossip_err("%s: ran off the end of the blob.\n",
				   __func__);
			ret = -EINVAL;
			goto free;
		}
		size -= aligned_len + khandle_size;

		buf += aligned_len;

		readdir->dirent_array[i].khandle =
			*(struct orangefs_khandle *) buf;
		buf += khandle_size;
	}
	ret = buf - ptr;
	gossip_debug(GOSSIP_DIR_DEBUG, "%s: returning:%ld:\n", __func__, ret);
	goto out;

free:
	kfree(readdir->dirent_array);
	readdir->dirent_array = NULL;

out:
	return ret;
}

/*
 * Read directory entries from an instance of an open directory.
 */
static int orangefs_readdir(struct file *file, struct dir_context *ctx)
{
	int ret = 0;
	int buffer_index;
	/*
	 * ptoken supports Orangefs' distributed directory logic, added
	 * in 2.9.2.
	 */
	__u64 *ptoken = file->private_data;
	__u64 pos = 0;
	ino_t ino = 0;
	struct dentry *dentry = file->f_path.dentry;
	struct orangefs_kernel_op_s *new_op = NULL;
	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode);
	int buffer_full = 0;
	struct orangefs_readdir_response_s readdir_response;
	void *dents_buf;
	int i = 0;
	int len = 0;
	ino_t current_ino = 0;
	char *current_entry = NULL;
	long bytes_decoded;

	gossip_debug(GOSSIP_DIR_DEBUG,
		     "%s: ctx->pos:%lld, ptoken = %llu\n",
		     __func__,
		     lld(ctx->pos),
		     llu(*ptoken));

	pos = (__u64) ctx->pos;

	/* are we done? */
	if (pos == ORANGEFS_READDIR_END) {
		gossip_debug(GOSSIP_DIR_DEBUG,
			     "Skipping to termination path\n");
		return 0;
	}

	gossip_debug(GOSSIP_DIR_DEBUG,
		     "orangefs_readdir called on %s (pos=%llu)\n",
		     dentry->d_name.name, llu(pos));

	memset(&readdir_response, 0, sizeof(readdir_response));

	new_op = op_alloc(ORANGEFS_VFS_OP_READDIR);
	if (!new_op)
		return -ENOMEM;

	/*
	 * Only the indices are shared. No memory is actually shared, but the
	 * mechanism is used.
	 */
	new_op->uses_shared_memory = 1;
	new_op->upcall.req.readdir.refn = orangefs_inode->refn;
	new_op->upcall.req.readdir.max_dirent_count =
	    ORANGEFS_MAX_DIRENT_COUNT_READDIR;

	gossip_debug(GOSSIP_DIR_DEBUG,
		     "%s: upcall.req.readdir.refn.khandle: %pU\n",
		     __func__,
		     &new_op->upcall.req.readdir.refn.khandle);

	new_op->upcall.req.readdir.token = *ptoken;

get_new_buffer_index:
	buffer_index = orangefs_readdir_index_get();
	if (buffer_index < 0) {
		ret = buffer_index;
		gossip_lerr("orangefs_readdir: orangefs_readdir_index_get() failure (%d)\n",
			    ret);
		goto out_free_op;
	}
	new_op->upcall.req.readdir.buf_index = buffer_index;

	ret = service_operation(new_op,
				"orangefs_readdir",
				get_interruptible_flag(dentry->d_inode));

	gossip_debug(GOSSIP_DIR_DEBUG,
		     "Readdir downcall status is %d.  ret:%d\n",
		     new_op->downcall.status,
		     ret);

	orangefs_readdir_index_put(buffer_index);

	if (ret == -EAGAIN && op_state_purged(new_op)) {
		/* Client-core indices are invalid after it restarted. */
		gossip_debug(GOSSIP_DIR_DEBUG,
			"%s: Getting new buffer_index for retry of readdir..\n",
			 __func__);
		goto get_new_buffer_index;
	}

	if (ret == -EIO && op_state_purged(new_op)) {
		gossip_err("%s: Client is down. Aborting readdir call.\n",
			__func__);
		goto out_slot;
	}

	if (ret < 0 || new_op->downcall.status != 0) {
		gossip_debug(GOSSIP_DIR_DEBUG,
			     "Readdir request failed.  Status:%d\n",
			     new_op->downcall.status);
		if (ret >= 0)
			ret = new_op->downcall.status;
		goto out_slot;
	}

	dents_buf = new_op->downcall.trailer_buf;
	if (dents_buf == NULL) {
		gossip_err("Invalid NULL buffer in readdir response\n");
		ret = -ENOMEM;
		goto out_slot;
	}

	bytes_decoded = decode_dirents(dents_buf, new_op->downcall.trailer_size,
					&readdir_response);
	if (bytes_decoded < 0) {
		ret = bytes_decoded;
		gossip_err("Could not decode readdir from buffer %d\n", ret);
		goto out_vfree;
	}

	if (bytes_decoded != new_op->downcall.trailer_size) {
		gossip_err("orangefs_readdir: # bytes decoded (%ld) "
			   "!= trailer size (%ld)\n",
			   bytes_decoded,
			   (long)new_op->downcall.trailer_size);
		ret = -EINVAL;
		goto out_destroy_handle;
	}

	/*
	 *  orangefs doesn't actually store dot and dot-dot, but
	 *  we need to have them represented.
	 */
	if (pos == 0) {
		ino = get_ino_from_khandle(dentry->d_inode);
		gossip_debug(GOSSIP_DIR_DEBUG,
			     "%s: calling dir_emit of \".\" with pos = %llu\n",
			     __func__,
			     llu(pos));
		ret = dir_emit(ctx, ".", 1, ino, DT_DIR);
		pos += 1;
	}

	if (pos == 1) {
		ino = get_parent_ino_from_dentry(dentry);
		gossip_debug(GOSSIP_DIR_DEBUG,
			     "%s: calling dir_emit of \"..\" with pos = %llu\n",
			     __func__,
			     llu(pos));
		ret = dir_emit(ctx, "..", 2, ino, DT_DIR);
		pos += 1;
	}

	/*
	 * we stored ORANGEFS_ITERATE_NEXT in ctx->pos last time around
	 * to prevent "finding" dot and dot-dot on any iteration
	 * other than the first.
	 */
	if (ctx->pos == ORANGEFS_ITERATE_NEXT)
		ctx->pos = 0;

	gossip_debug(GOSSIP_DIR_DEBUG,
		     "%s: dirent_outcount:%d:\n",
		     __func__,
		     readdir_response.orangefs_dirent_outcount);
	for (i = ctx->pos;
	     i < readdir_response.orangefs_dirent_outcount;
	     i++) {
		len = readdir_response.dirent_array[i].d_length;
		current_entry = readdir_response.dirent_array[i].d_name;
		current_ino = orangefs_khandle_to_ino(
			&readdir_response.dirent_array[i].khandle);

		gossip_debug(GOSSIP_DIR_DEBUG,
			     "calling dir_emit for %s with len %d"
			     ", ctx->pos %ld\n",
			     current_entry,
			     len,
			     (unsigned long)ctx->pos);
		/*
		 * type is unknown. We don't return object type
		 * in the dirent_array. This leaves getdents
		 * clueless about type.
		 */
		ret =
		    dir_emit(ctx, current_entry, len, current_ino, DT_UNKNOWN);
		if (!ret)
			break;
		ctx->pos++;
		gossip_debug(GOSSIP_DIR_DEBUG,
			      "%s: ctx->pos:%lld\n",
			      __func__,
			      lld(ctx->pos));

	}

	/*
	 * we ran all the way through the last batch, set up for
	 * getting another batch...
	 */
	if (ret) {
		*ptoken = readdir_response.token;
		ctx->pos = ORANGEFS_ITERATE_NEXT;
	}

	/*
	 * Did we hit the end of the directory?
	 */
	if (readdir_response.token == ORANGEFS_READDIR_END &&
	    !buffer_full) {
		gossip_debug(GOSSIP_DIR_DEBUG,
		"End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n");
		ctx->pos = ORANGEFS_READDIR_END;
	}

out_destroy_handle:
	/* kfree(NULL) is safe */
	kfree(readdir_response.dirent_array);
out_vfree:
	gossip_debug(GOSSIP_DIR_DEBUG, "vfree %p\n", dents_buf);
	vfree(dents_buf);
out_slot:
	orangefs_readdir_index_put(buffer_index);
out_free_op:
	op_release(new_op);
	gossip_debug(GOSSIP_DIR_DEBUG, "orangefs_readdir returning %d\n", ret);
	return ret;
}

static int orangefs_dir_open(struct inode *inode, struct file *file)
{
	__u64 *ptoken;

	file->private_data = kmalloc(sizeof(__u64), GFP_KERNEL);
	if (!file->private_data)
		return -ENOMEM;

	ptoken = file->private_data;
	*ptoken = ORANGEFS_READDIR_START;
	return 0;
}

static int orangefs_dir_release(struct inode *inode, struct file *file)
{
	orangefs_flush_inode(inode);
	kfree(file->private_data);
	return 0;
}

/** ORANGEFS implementation of VFS directory operations */
const struct file_operations orangefs_dir_operations = {
	.read = generic_read_dir,
	.iterate = orangefs_readdir,
	.open = orangefs_dir_open,
	.release = orangefs_dir_release,
};
Commit	Line	Data
5db11c21 MM	1	/*
	2	* (C) 2001 Clemson University and The University of Chicago
	3	*
	4	* See COPYING in top-level directory.
	5	*/
	6
	7	#include "protocol.h"
575e9461 MM	8	#include "orangefs-kernel.h"
575e9461 MM	9	#include "orangefs-bufmap.h"
5db11c21	10
5db11c21	11	/*
1808f8cc MM	12	* decode routine used by kmod to deal with the blob sent from
	13	* userspace for readdirs. The blob contains zero or more of these
	14	* sub-blobs:
	15	* __u32 - represents length of the character string that follows.
	16	* string - between 1 and ORANGEFS_NAME_MAX bytes long.
	17	* padding - (if needed) to cause the __u32 plus the string to be
	18	* eight byte aligned.
	19	* khandle - sizeof(khandle) bytes.
5db11c21	20	*/
8092895f	21	static long decode_dirents(char *ptr, size_t size,
8bb8aefd	22	struct orangefs_readdir_response_s *readdir)
5db11c21 MM	23	{
5db11c21 MM	24	int i;
8bb8aefd YL	25	struct orangefs_readdir_response_s *rd =
8bb8aefd YL	26	(struct orangefs_readdir_response_s *) ptr;
5db11c21	27	char *buf = ptr;
1808f8cc MM	28	int khandle_size = sizeof(struct orangefs_khandle);
	29	size_t offset = offsetof(struct orangefs_readdir_response_s,
	30	dirent_array);
	31	/* 8 reflects eight byte alignment */
	32	int smallest_blob = khandle_size + 8;
	33	__u32 len;
	34	int aligned_len;
	35	int sizeof_u32 = sizeof(__u32);
	36	long ret;
5db11c21	37
1808f8cc MM	38	gossip_debug(GOSSIP_DIR_DEBUG, "%s: size:%zu:\n", __func__, size);
	39
	40	/* size is = offset on empty dirs, > offset on non-empty dirs... */
	41	if (size < offset) {
	42	gossip_err("%s: size:%zu: offset:%zu:\n",
	43	__func__,
	44	size,
	45	offset);
	46	ret = -EINVAL;
	47	goto out;
	48	}
	49
	50	if ((size == offset) && (readdir->orangefs_dirent_outcount != 0)) {
	51	gossip_err("%s: size:%zu: dirent_outcount:%d:\n",
	52	__func__,
	53	size,
	54	readdir->orangefs_dirent_outcount);
	55	ret = -EINVAL;
	56	goto out;
	57	}
8092895f	58
5db11c21	59	readdir->token = rd->token;
8bb8aefd YL	60	readdir->orangefs_dirent_outcount = rd->orangefs_dirent_outcount;
8bb8aefd YL	61	readdir->dirent_array = kcalloc(readdir->orangefs_dirent_outcount,
5db11c21 MM	62	sizeof(*readdir->dirent_array),
5db11c21 MM	63	GFP_KERNEL);
1808f8cc MM	64	if (readdir->dirent_array == NULL) {
	65	gossip_err("%s: kcalloc failed.\n", __func__);
	66	ret = -ENOMEM;
	67	goto out;
	68	}
8092895f	69
1808f8cc MM	70	buf += offset;
1808f8cc MM	71	size -= offset;
8092895f	72
8bb8aefd	73	for (i = 0; i < readdir->orangefs_dirent_outcount; i++) {
1808f8cc MM	74	if (size < smallest_blob) {
	75	gossip_err("%s: size:%zu: smallest_blob:%d:\n",
	76	__func__,
	77	size,
	78	smallest_blob);
	79	ret = -EINVAL;
	80	goto free;
	81	}
8092895f AV	82
8092895f AV	83	len = (__u32 )buf;
1808f8cc MM	84	if ((len < 1) \|\| (len > ORANGEFS_NAME_MAX)) {
	85	gossip_err("%s: len:%d:\n", __func__, len);
	86	ret = -EINVAL;
	87	goto free;
	88	}
	89
	90	gossip_debug(GOSSIP_DIR_DEBUG,
	91	"%s: size:%zu: len:%d:\n",
	92	__func__,
	93	size,
	94	len);
	95
	96	readdir->dirent_array[i].d_name = buf + sizeof_u32;
9be68b08	97	readdir->dirent_array[i].d_length = len;
8092895f	98
7d221485	99	/*
1808f8cc MM	100	* Calculate "aligned" length of this string and its
	101	* associated __u32 descriptor.
	102	*/
	103	aligned_len = ((sizeof_u32 + len + 1) + 7) & ~7;
	104	gossip_debug(GOSSIP_DIR_DEBUG,
	105	"%s: aligned_len:%d:\n",
	106	__func__,
	107	aligned_len);
	108
	109	/*
	110	* The end of the blob should coincide with the end
	111	* of the last sub-blob.
7d221485	112	*/
1808f8cc MM	113	if (size < aligned_len + khandle_size) {
	114	gossip_err("%s: ran off the end of the blob.\n",
	115	__func__);
	116	ret = -EINVAL;
	117	goto free;
	118	}
	119	size -= aligned_len + khandle_size;
8092895f	120
1808f8cc	121	buf += aligned_len;
8092895f	122
5db11c21	123	readdir->dirent_array[i].khandle =
8bb8aefd	124	(struct orangefs_khandle ) buf;
1808f8cc	125	buf += khandle_size;
5db11c21	126	}
1808f8cc MM	127	ret = buf - ptr;
	128	gossip_debug(GOSSIP_DIR_DEBUG, "%s: returning:%ld:\n", __func__, ret);
	129	goto out;
	130
	131	free:
8092895f AV	132	kfree(readdir->dirent_array);
8092895f AV	133	readdir->dirent_array = NULL;
1808f8cc MM	134
	135	out:
	136	return ret;
5db11c21 MM	137	}
5db11c21 MM	138
5db11c21 MM	139	/*
5db11c21 MM	140	* Read directory entries from an instance of an open directory.
5db11c21	141	*/
8bb8aefd	142	static int orangefs_readdir(struct file file, struct dir_context ctx)
5db11c21	143	{
5db11c21 MM	144	int ret = 0;
5db11c21 MM	145	int buffer_index;
88309aae MM	146	/*
	147	* ptoken supports Orangefs' distributed directory logic, added
	148	* in 2.9.2.
	149	*/
5db11c21 MM	150	__u64 *ptoken = file->private_data;
	151	__u64 pos = 0;
	152	ino_t ino = 0;
	153	struct dentry *dentry = file->f_path.dentry;
8bb8aefd YL	154	struct orangefs_kernel_op_s *new_op = NULL;
8bb8aefd YL	155	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode);
5db11c21	156	int buffer_full = 0;
9f5e2f7f AV	157	struct orangefs_readdir_response_s readdir_response;
9f5e2f7f AV	158	void *dents_buf;
5db11c21 MM	159	int i = 0;
	160	int len = 0;
	161	ino_t current_ino = 0;
	162	char *current_entry = NULL;
	163	long bytes_decoded;
	164
88309aae MM	165	gossip_debug(GOSSIP_DIR_DEBUG,
	166	"%s: ctx->pos:%lld, ptoken = %llu\n",
	167	__func__,
	168	lld(ctx->pos),
	169	llu(*ptoken));
5db11c21 MM	170
	171	pos = (__u64) ctx->pos;
	172
	173	/* are we done? */
8bb8aefd	174	if (pos == ORANGEFS_READDIR_END) {
5db11c21 MM	175	gossip_debug(GOSSIP_DIR_DEBUG,
	176	"Skipping to termination path\n");
	177	return 0;
	178	}
	179
	180	gossip_debug(GOSSIP_DIR_DEBUG,
8bb8aefd	181	"orangefs_readdir called on %s (pos=%llu)\n",
5db11c21 MM	182	dentry->d_name.name, llu(pos));
5db11c21 MM	183
9f5e2f7f	184	memset(&readdir_response, 0, sizeof(readdir_response));
5db11c21	185
8bb8aefd	186	new_op = op_alloc(ORANGEFS_VFS_OP_READDIR);
5db11c21 MM	187	if (!new_op)
	188	return -ENOMEM;
	189
ee3b8d37 MB	190	/*
	191	* Only the indices are shared. No memory is actually shared, but the
	192	* mechanism is used.
	193	*/
5db11c21	194	new_op->uses_shared_memory = 1;
8bb8aefd	195	new_op->upcall.req.readdir.refn = orangefs_inode->refn;
7d221485 MB	196	new_op->upcall.req.readdir.max_dirent_count =
7d221485 MB	197	ORANGEFS_MAX_DIRENT_COUNT_READDIR;
5db11c21 MM	198
	199	gossip_debug(GOSSIP_DIR_DEBUG,
	200	"%s: upcall.req.readdir.refn.khandle: %pU\n",
	201	__func__,
	202	&new_op->upcall.req.readdir.refn.khandle);
	203
5db11c21 MM	204	new_op->upcall.req.readdir.token = *ptoken;
	205
	206	get_new_buffer_index:
b8a99a8f AV	207	buffer_index = orangefs_readdir_index_get();
	208	if (buffer_index < 0) {
	209	ret = buffer_index;
7d221485	210	gossip_lerr("orangefs_readdir: orangefs_readdir_index_get() failure (%d)\n",
5db11c21 MM	211	ret);
	212	goto out_free_op;
	213	}
	214	new_op->upcall.req.readdir.buf_index = buffer_index;
	215
	216	ret = service_operation(new_op,
8bb8aefd	217	"orangefs_readdir",
5db11c21 MM	218	get_interruptible_flag(dentry->d_inode));
	219
	220	gossip_debug(GOSSIP_DIR_DEBUG,
	221	"Readdir downcall status is %d. ret:%d\n",
	222	new_op->downcall.status,
	223	ret);
	224
ee3b8d37 MB	225	orangefs_readdir_index_put(buffer_index);
ee3b8d37 MB	226
5db11c21	227	if (ret == -EAGAIN && op_state_purged(new_op)) {
ee3b8d37	228	/* Client-core indices are invalid after it restarted. */
5db11c21 MM	229	gossip_debug(GOSSIP_DIR_DEBUG,
	230	"%s: Getting new buffer_index for retry of readdir..\n",
	231	__func__);
5db11c21 MM	232	goto get_new_buffer_index;
	233	}
	234
	235	if (ret == -EIO && op_state_purged(new_op)) {
	236	gossip_err("%s: Client is down. Aborting readdir call.\n",
	237	__func__);
9f5e2f7f	238	goto out_slot;
5db11c21 MM	239	}
	240
	241	if (ret < 0 \|\| new_op->downcall.status != 0) {
	242	gossip_debug(GOSSIP_DIR_DEBUG,
	243	"Readdir request failed. Status:%d\n",
	244	new_op->downcall.status);
5db11c21 MM	245	if (ret >= 0)
5db11c21 MM	246	ret = new_op->downcall.status;
9f5e2f7f AV	247	goto out_slot;
	248	}
	249
	250	dents_buf = new_op->downcall.trailer_buf;
	251	if (dents_buf == NULL) {
	252	gossip_err("Invalid NULL buffer in readdir response\n");
	253	ret = -ENOMEM;
	254	goto out_slot;
5db11c21 MM	255	}
5db11c21 MM	256
9f5e2f7f AV	257	bytes_decoded = decode_dirents(dents_buf, new_op->downcall.trailer_size,
9f5e2f7f AV	258	&readdir_response);
5db11c21	259	if (bytes_decoded < 0) {
5db11c21	260	ret = bytes_decoded;
9f5e2f7f AV	261	gossip_err("Could not decode readdir from buffer %d\n", ret);
9f5e2f7f AV	262	goto out_vfree;
5db11c21 MM	263	}
	264
	265	if (bytes_decoded != new_op->downcall.trailer_size) {
8bb8aefd	266	gossip_err("orangefs_readdir: # bytes decoded (%ld) "
88309aae MM	267	"!= trailer size (%ld)\n",
	268	bytes_decoded,
	269	(long)new_op->downcall.trailer_size);
5db11c21 MM	270	ret = -EINVAL;
	271	goto out_destroy_handle;
	272	}
	273
88309aae	274	/*
8bb8aefd	275	* orangefs doesn't actually store dot and dot-dot, but
88309aae MM	276	* we need to have them represented.
88309aae MM	277	*/
5db11c21 MM	278	if (pos == 0) {
	279	ino = get_ino_from_khandle(dentry->d_inode);
	280	gossip_debug(GOSSIP_DIR_DEBUG,
	281	"%s: calling dir_emit of \".\" with pos = %llu\n",
	282	__func__,
	283	llu(pos));
	284	ret = dir_emit(ctx, ".", 1, ino, DT_DIR);
88309aae	285	pos += 1;
5db11c21 MM	286	}
	287
	288	if (pos == 1) {
	289	ino = get_parent_ino_from_dentry(dentry);
	290	gossip_debug(GOSSIP_DIR_DEBUG,
	291	"%s: calling dir_emit of \"..\" with pos = %llu\n",
	292	__func__,
	293	llu(pos));
	294	ret = dir_emit(ctx, "..", 2, ino, DT_DIR);
88309aae	295	pos += 1;
5db11c21 MM	296	}
5db11c21 MM	297
88309aae	298	/*
8bb8aefd	299	* we stored ORANGEFS_ITERATE_NEXT in ctx->pos last time around
88309aae MM	300	* to prevent "finding" dot and dot-dot on any iteration
	301	* other than the first.
	302	*/
8bb8aefd	303	if (ctx->pos == ORANGEFS_ITERATE_NEXT)
88309aae MM	304	ctx->pos = 0;
88309aae MM	305
cf07c0bf MM	306	gossip_debug(GOSSIP_DIR_DEBUG,
	307	"%s: dirent_outcount:%d:\n",
	308	__func__,
9f5e2f7f	309	readdir_response.orangefs_dirent_outcount);
88309aae	310	for (i = ctx->pos;
9f5e2f7f	311	i < readdir_response.orangefs_dirent_outcount;
88309aae	312	i++) {
9f5e2f7f AV	313	len = readdir_response.dirent_array[i].d_length;
9f5e2f7f AV	314	current_entry = readdir_response.dirent_array[i].d_name;
8bb8aefd	315	current_ino = orangefs_khandle_to_ino(
9f5e2f7f	316	&readdir_response.dirent_array[i].khandle);
5db11c21 MM	317
5db11c21 MM	318	gossip_debug(GOSSIP_DIR_DEBUG,
88309aae MM	319	"calling dir_emit for %s with len %d"
88309aae MM	320	", ctx->pos %ld\n",
5db11c21 MM	321	current_entry,
5db11c21 MM	322	len,
88309aae MM	323	(unsigned long)ctx->pos);
	324	/*
	325	* type is unknown. We don't return object type
	326	* in the dirent_array. This leaves getdents
	327	* clueless about type.
	328	*/
5db11c21 MM	329	ret =
5db11c21 MM	330	dir_emit(ctx, current_entry, len, current_ino, DT_UNKNOWN);
88309aae MM	331	if (!ret)
88309aae MM	332	break;
5db11c21	333	ctx->pos++;
88309aae	334	gossip_debug(GOSSIP_DIR_DEBUG,
5db11c21 MM	335	"%s: ctx->pos:%lld\n",
	336	__func__,
	337	lld(ctx->pos));
	338
5db11c21 MM	339	}
5db11c21 MM	340
54804949	341	/*
88309aae MM	342	* we ran all the way through the last batch, set up for
	343	* getting another batch...
	344	*/
	345	if (ret) {
9f5e2f7f	346	*ptoken = readdir_response.token;
8bb8aefd	347	ctx->pos = ORANGEFS_ITERATE_NEXT;
5db11c21 MM	348	}
	349
	350	/*
	351	* Did we hit the end of the directory?
	352	*/
9f5e2f7f	353	if (readdir_response.token == ORANGEFS_READDIR_END &&
5db11c21	354	!buffer_full) {
88309aae	355	gossip_debug(GOSSIP_DIR_DEBUG,
8bb8aefd YL	356	"End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n");
8bb8aefd YL	357	ctx->pos = ORANGEFS_READDIR_END;
5db11c21 MM	358	}
5db11c21 MM	359
5db11c21	360	out_destroy_handle:
9f5e2f7f AV	361	/* kfree(NULL) is safe */
	362	kfree(readdir_response.dirent_array);
	363	out_vfree:
	364	gossip_debug(GOSSIP_DIR_DEBUG, "vfree %p\n", dents_buf);
	365	vfree(dents_buf);
	366	out_slot:
	367	orangefs_readdir_index_put(buffer_index);
5db11c21 MM	368	out_free_op:
5db11c21 MM	369	op_release(new_op);
8bb8aefd	370	gossip_debug(GOSSIP_DIR_DEBUG, "orangefs_readdir returning %d\n", ret);
5db11c21 MM	371	return ret;
	372	}
	373
8bb8aefd	374	static int orangefs_dir_open(struct inode inode, struct file file)
5db11c21 MM	375	{
	376	__u64 *ptoken;
	377
	378	file->private_data = kmalloc(sizeof(__u64), GFP_KERNEL);
	379	if (!file->private_data)
	380	return -ENOMEM;
	381
	382	ptoken = file->private_data;
8bb8aefd	383	*ptoken = ORANGEFS_READDIR_START;
5db11c21 MM	384	return 0;
	385	}
	386
8bb8aefd	387	static int orangefs_dir_release(struct inode inode, struct file file)
5db11c21	388	{
8bb8aefd	389	orangefs_flush_inode(inode);
5db11c21 MM	390	kfree(file->private_data);
	391	return 0;
	392	}
	393
8bb8aefd YL	394	/** ORANGEFS implementation of VFS directory operations */
8bb8aefd YL	395	const struct file_operations orangefs_dir_operations = {
5db11c21	396	.read = generic_read_dir,
8bb8aefd YL	397	.iterate = orangefs_readdir,
	398	.open = orangefs_dir_open,
	399	.release = orangefs_dir_release,
5db11c21	400	};