Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8bb8aefd authored by Yi Liu's avatar Yi Liu Committed by Mike Marshall
Browse files

OrangeFS: Change almost all instances of the string PVFS2 to OrangeFS. 



OrangeFS was formerly known as PVFS2 and retains the name in many places.

I leave the device /dev/pvfs2-req since this affects userspace.

I leave the filesystem type pvfs2 since this affects userspace. Further
the OrangeFS sysint library reads fstab for an entry of type pvfs2
independently of kernel mounts.

I leave extended attribute keys user.pvfs2 and system.pvfs2 as the
sysint library understands these.

I leave references to userspace binaries still named pvfs2.

I leave the filenames.

Signed-off-by: default avatarYi Liu <yi9@clemson.edu>
[martin@omnibond.com: clairify above constraints and merge]
Signed-off-by: default avatarMartin Brandenburg <martin@omnibond.com>
Signed-off-by: default avatarMike Marshall <hubcap@omnibond.com>
parent 555fa0fa

fs/orangefs/acl.c

+21 −21
Original line number Diff line number Diff line
@@ -10,7 +10,7 @@ 
#include <linux/posix_acl_xattr.h>

#include <linux/fs_struct.h>



struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)

struct posix_acl *orangefs_get_acl(struct inode *inode, int type)

{

	struct posix_acl *acl;

	int ret;
@@ -18,23 +18,23 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) 


	switch (type) {

	case ACL_TYPE_ACCESS:

		key = PVFS2_XATTR_NAME_ACL_ACCESS;

		key = ORANGEFS_XATTR_NAME_ACL_ACCESS;

		break;

	case ACL_TYPE_DEFAULT:

		key = PVFS2_XATTR_NAME_ACL_DEFAULT;

		key = ORANGEFS_XATTR_NAME_ACL_DEFAULT;

		break;

	default:

		gossip_err("pvfs2_get_acl: bogus value of type %d\n", type);

		gossip_err("orangefs_get_acl: bogus value of type %d\n", type);

		return ERR_PTR(-EINVAL);

	}

	/*

	 * Rather than incurring a network call just to determine the exact

	 * length of the attribute, I just allocate a max length to save on

	 * the network call. Conceivably, we could pass NULL to

	 * pvfs2_inode_getxattr() to probe the length of the value, but

	 * orangefs_inode_getxattr() to probe the length of the value, but

	 * I don't do that for now.

	 */

	value = kmalloc(PVFS_MAX_XATTR_VALUELEN, GFP_KERNEL);

	value = kmalloc(ORANGEFS_MAX_XATTR_VALUELEN, GFP_KERNEL);

	if (value == NULL)

		return ERR_PTR(-ENOMEM);
@@ -43,11 +43,11 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) 
		     get_khandle_from_ino(inode),

		     key,

		     type);

	ret = pvfs2_inode_getxattr(inode,

	ret = orangefs_inode_getxattr(inode,

				   "",

				   key,

				   value,

				   PVFS_MAX_XATTR_VALUELEN);

				   ORANGEFS_MAX_XATTR_VALUELEN);

	/* if the key exists, convert it to an in-memory rep */

	if (ret > 0) {

		acl = posix_acl_from_xattr(&init_user_ns, value, ret);
@@ -64,9 +64,9 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) 
	return acl;

}



int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)

int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type)

{

	struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode);

	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);

	int error = 0;

	void *value = NULL;

	size_t size = 0;
@@ -74,7 +74,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) 


	switch (type) {

	case ACL_TYPE_ACCESS:

		name = PVFS2_XATTR_NAME_ACL_ACCESS;

		name = ORANGEFS_XATTR_NAME_ACL_ACCESS;

		if (acl) {

			umode_t mode = inode->i_mode;

			/*
@@ -90,7 +90,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) 
			}



			if (inode->i_mode != mode)

				SetModeFlag(pvfs2_inode);

				SetModeFlag(orangefs_inode);

			inode->i_mode = mode;

			mark_inode_dirty_sync(inode);

			if (error == 0)
@@ -98,7 +98,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) 
		}

		break;

	case ACL_TYPE_DEFAULT:

		name = PVFS2_XATTR_NAME_ACL_DEFAULT;

		name = ORANGEFS_XATTR_NAME_ACL_DEFAULT;

		break;

	default:

		gossip_err("%s: invalid type %d!\n", __func__, type);
@@ -131,7 +131,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) 
	 * will xlate to a removexattr. However, we don't want removexattr

	 * complain if attributes does not exist.

	 */

	error = pvfs2_inode_setxattr(inode, "", name, value, size, 0);

	error = orangefs_inode_setxattr(inode, "", name, value, size, 0);



out:

	kfree(value);
@@ -140,35 +140,35 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) 
	return error;

}



int pvfs2_init_acl(struct inode *inode, struct inode *dir)

int orangefs_init_acl(struct inode *inode, struct inode *dir)

{

	struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode);

	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);

	struct posix_acl *default_acl, *acl;

	umode_t mode = inode->i_mode;

	int error = 0;



	ClearModeFlag(pvfs2_inode);

	ClearModeFlag(orangefs_inode);



	error = posix_acl_create(dir, &mode, &default_acl, &acl);

	if (error)

		return error;



	if (default_acl) {

		error = pvfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);

		error = orangefs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);

		posix_acl_release(default_acl);

	}



	if (acl) {

		if (!error)

			error = pvfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);

			error = orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS);

		posix_acl_release(acl);

	}



	/* If mode of the inode was changed, then do a forcible ->setattr */

	if (mode != inode->i_mode) {

		SetModeFlag(pvfs2_inode);

		SetModeFlag(orangefs_inode);

		inode->i_mode = mode;

		pvfs2_flush_inode(inode);

		orangefs_flush_inode(inode);

	}



	return error;

fs/orangefs/dcache.c

+12 −12
Original line number Diff line number Diff line
@@ -12,27 +12,27 @@ 
#include "pvfs2-kernel.h"



/* Returns 1 if dentry can still be trusted, else 0. */

static int pvfs2_revalidate_lookup(struct dentry *dentry)

static int orangefs_revalidate_lookup(struct dentry *dentry)

{

	struct dentry *parent_dentry = dget_parent(dentry);

	struct inode *parent_inode = parent_dentry->d_inode;

	struct pvfs2_inode_s *parent = PVFS2_I(parent_inode);

	struct orangefs_inode_s *parent = ORANGEFS_I(parent_inode);

	struct inode *inode = dentry->d_inode;

	struct pvfs2_kernel_op_s *new_op;

	struct orangefs_kernel_op_s *new_op;

	int ret = 0;

	int err = 0;



	gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: attempting lookup.\n", __func__);



	new_op = op_alloc(PVFS2_VFS_OP_LOOKUP);

	new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP);

	if (!new_op)

		goto out_put_parent;



	new_op->upcall.req.lookup.sym_follow = PVFS2_LOOKUP_LINK_NO_FOLLOW;

	new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW;

	new_op->upcall.req.lookup.parent_refn = parent->refn;

	strncpy(new_op->upcall.req.lookup.d_name,

		dentry->d_name.name,

		PVFS2_NAME_LEN);

		ORANGEFS_NAME_LEN);



	gossip_debug(GOSSIP_DCACHE_DEBUG,

		     "%s:%s:%d interrupt flag [%d]\n",
@@ -41,7 +41,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry) 
		     __LINE__,

		     get_interruptible_flag(parent_inode));



	err = service_operation(new_op, "pvfs2_lookup",

	err = service_operation(new_op, "orangefs_lookup",

			get_interruptible_flag(parent_inode));

	if (err)

		goto out_drop;
@@ -79,7 +79,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry) 
 *

 * Should return 1 if dentry can still be trusted, else 0

 */

static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)

static int orangefs_d_revalidate(struct dentry *dentry, unsigned int flags)

{

	struct inode *inode;

	int ret = 0;
@@ -105,7 +105,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) 
	 * exists, but is still in the expected place in the name space

	 */

	if (!is_root_handle(inode)) {

		if (!pvfs2_revalidate_lookup(dentry))

		if (!orangefs_revalidate_lookup(dentry))

			goto invalid_exit;

	} else {

		gossip_debug(GOSSIP_DCACHE_DEBUG,
@@ -119,7 +119,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) 
		     __func__,

		     inode,

		     get_khandle_from_ino(inode));

	ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT);

	ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT);

	gossip_debug(GOSSIP_DCACHE_DEBUG,

		     "%s: getattr %s (ret = %d), returning %s for dentry i_count=%d\n",

		     __func__,
@@ -137,6 +137,6 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) 
	return 0;

}



const struct dentry_operations pvfs2_dentry_operations = {

	.d_revalidate = pvfs2_d_revalidate,

const struct dentry_operations orangefs_dentry_operations = {

	.d_revalidate = orangefs_d_revalidate,

};

fs/orangefs/devpvfs2-req.c

+128 −128

File changed.

Preview size limit exceeded, changes collapsed.

fs/orangefs/dir.c

+43 −43
Original line number Diff line number Diff line
@@ -10,7 +10,7 @@ 


struct readdir_handle_s {

	int buffer_index;

	struct pvfs2_readdir_response_s readdir_response;

	struct orangefs_readdir_response_s readdir_response;

	void *dents_buf;

};
@@ -18,28 +18,28 @@ struct readdir_handle_s { 
 * decode routine needed by kmod to make sense of the shared page for readdirs.

 */

static long decode_dirents(char *ptr, size_t size,

			   struct pvfs2_readdir_response_s *readdir)

                           struct orangefs_readdir_response_s *readdir)

{

	int i;

	struct pvfs2_readdir_response_s *rd =

		(struct pvfs2_readdir_response_s *) ptr;

	struct orangefs_readdir_response_s *rd =

		(struct orangefs_readdir_response_s *) ptr;

	char *buf = ptr;



	if (size < offsetof(struct pvfs2_readdir_response_s, dirent_array))

	if (size < offsetof(struct orangefs_readdir_response_s, dirent_array))

		return -EINVAL;



	readdir->token = rd->token;

	readdir->pvfs_dirent_outcount = rd->pvfs_dirent_outcount;

	readdir->dirent_array = kcalloc(readdir->pvfs_dirent_outcount,

	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)

		return -ENOMEM;



	buf += offsetof(struct pvfs2_readdir_response_s, dirent_array);

	size -= offsetof(struct pvfs2_readdir_response_s, dirent_array);

	buf += offsetof(struct orangefs_readdir_response_s, dirent_array);

	size -= offsetof(struct orangefs_readdir_response_s, dirent_array);



	for (i = 0; i < readdir->pvfs_dirent_outcount; i++) {

	for (i = 0; i < readdir->orangefs_dirent_outcount; i++) {

		__u32 len;



		if (size < 4)
@@ -60,7 +60,7 @@ static long decode_dirents(char *ptr, size_t size, 
		buf += len;



		readdir->dirent_array[i].khandle =

			*(struct pvfs2_khandle *) buf;

			*(struct orangefs_khandle *) buf;

		buf += 16;

	}

	return buf - ptr;
@@ -98,7 +98,7 @@ static long readdir_handle_ctor(struct readdir_handle_s *rhandle, void *buf, 
	return ret;

}



static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap,

static void readdir_handle_dtor(struct orangefs_bufmap *bufmap,

		struct readdir_handle_s *rhandle)

{

	if (rhandle == NULL)
@@ -123,9 +123,9 @@ static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap, 
/*

 * Read directory entries from an instance of an open directory.

 */

static int pvfs2_readdir(struct file *file, struct dir_context *ctx)

static int orangefs_readdir(struct file *file, struct dir_context *ctx)

{

	struct pvfs2_bufmap *bufmap = NULL;

	struct orangefs_bufmap *bufmap = NULL;

	int ret = 0;

	int buffer_index;

	/*
@@ -136,8 +136,8 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	__u64 pos = 0;

	ino_t ino = 0;

	struct dentry *dentry = file->f_path.dentry;

	struct pvfs2_kernel_op_s *new_op = NULL;

	struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(dentry->d_inode);

	struct orangefs_kernel_op_s *new_op = NULL;

	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode);

	int buffer_full = 0;

	struct readdir_handle_s rhandle;

	int i = 0;
@@ -155,26 +155,26 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	pos = (__u64) ctx->pos;



	/* are we done? */

	if (pos == PVFS_READDIR_END) {

	if (pos == ORANGEFS_READDIR_END) {

		gossip_debug(GOSSIP_DIR_DEBUG,

			     "Skipping to termination path\n");

		return 0;

	}



	gossip_debug(GOSSIP_DIR_DEBUG,

		     "pvfs2_readdir called on %s (pos=%llu)\n",

		     "orangefs_readdir called on %s (pos=%llu)\n",

		     dentry->d_name.name, llu(pos));



	rhandle.buffer_index = -1;

	rhandle.dents_buf = NULL;

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



	new_op = op_alloc(PVFS2_VFS_OP_READDIR);

	new_op = op_alloc(ORANGEFS_VFS_OP_READDIR);

	if (!new_op)

		return -ENOMEM;



	new_op->uses_shared_memory = 1;

	new_op->upcall.req.readdir.refn = pvfs2_inode->refn;

	new_op->upcall.req.readdir.refn = orangefs_inode->refn;

	new_op->upcall.req.readdir.max_dirent_count = MAX_DIRENT_COUNT_READDIR;



	gossip_debug(GOSSIP_DIR_DEBUG,
@@ -187,14 +187,14 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
get_new_buffer_index:

	ret = readdir_index_get(&bufmap, &buffer_index);

	if (ret < 0) {

		gossip_lerr("pvfs2_readdir: readdir_index_get() failure (%d)\n",

		gossip_lerr("orangefs_readdir: 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,

				"pvfs2_readdir",

				"orangefs_readdir",

				get_interruptible_flag(dentry->d_inode));



	gossip_debug(GOSSIP_DIR_DEBUG,
@@ -238,7 +238,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
				    new_op->downcall.trailer_size,

				    buffer_index);

	if (bytes_decoded < 0) {

		gossip_err("pvfs2_readdir: Could not decode trailer buffer into a readdir response %d\n",

		gossip_err("orangefs_readdir: Could not decode trailer buffer into a readdir response %d\n",

			ret);

		ret = bytes_decoded;

		readdir_index_put(bufmap, buffer_index);
@@ -246,7 +246,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	}



	if (bytes_decoded != new_op->downcall.trailer_size) {

		gossip_err("pvfs2_readdir: # bytes decoded (%ld) "

		gossip_err("orangefs_readdir: # bytes decoded (%ld) "

			   "!= trailer size (%ld)\n",

			   bytes_decoded,

			   (long)new_op->downcall.trailer_size);
@@ -255,7 +255,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	}



	/*

	 *  pvfs2 doesn't actually store dot and dot-dot, but

	 *  orangefs doesn't actually store dot and dot-dot, but

	 *  we need to have them represented.

	 */

	if (pos == 0) {
@@ -279,19 +279,19 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	}



	/*

	 * we stored PVFS_ITERATE_NEXT in ctx->pos last time around

	 * 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 == PVFS_ITERATE_NEXT)

	if (ctx->pos == ORANGEFS_ITERATE_NEXT)

		ctx->pos = 0;



	for (i = ctx->pos;

	     i < rhandle.readdir_response.pvfs_dirent_outcount;

	     i < rhandle.readdir_response.orangefs_dirent_outcount;

	     i++) {

		len = rhandle.readdir_response.dirent_array[i].d_length;

		current_entry = rhandle.readdir_response.dirent_array[i].d_name;

		current_ino = pvfs2_khandle_to_ino(

		current_ino = orangefs_khandle_to_ino(

			&(rhandle.readdir_response.dirent_array[i].khandle));



		gossip_debug(GOSSIP_DIR_DEBUG,
@@ -323,28 +323,28 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) 
	 */

	if (ret) {

		*ptoken = rhandle.readdir_response.token;

		ctx->pos = PVFS_ITERATE_NEXT;

		ctx->pos = ORANGEFS_ITERATE_NEXT;

	}



	/*

	 * Did we hit the end of the directory?

	 */

	if (rhandle.readdir_response.token == PVFS_READDIR_END &&

	if (rhandle.readdir_response.token == ORANGEFS_READDIR_END &&

	    !buffer_full) {

		gossip_debug(GOSSIP_DIR_DEBUG,

		"End of dir detected; setting ctx->pos to PVFS_READDIR_END.\n");

		ctx->pos = PVFS_READDIR_END;

		"End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n");

		ctx->pos = ORANGEFS_READDIR_END;

	}



out_destroy_handle:

	readdir_handle_dtor(bufmap, &rhandle);

out_free_op:

	op_release(new_op);

	gossip_debug(GOSSIP_DIR_DEBUG, "pvfs2_readdir returning %d\n", ret);

	gossip_debug(GOSSIP_DIR_DEBUG, "orangefs_readdir returning %d\n", ret);

	return ret;

}



static int pvfs2_dir_open(struct inode *inode, struct file *file)

static int orangefs_dir_open(struct inode *inode, struct file *file)

{

	__u64 *ptoken;
@@ -353,21 +353,21 @@ static int pvfs2_dir_open(struct inode *inode, struct file *file) 
		return -ENOMEM;



	ptoken = file->private_data;

	*ptoken = PVFS_READDIR_START;

	*ptoken = ORANGEFS_READDIR_START;

	return 0;

}



static int pvfs2_dir_release(struct inode *inode, struct file *file)

static int orangefs_dir_release(struct inode *inode, struct file *file)

{

	pvfs2_flush_inode(inode);

	orangefs_flush_inode(inode);

	kfree(file->private_data);

	return 0;

}



/** PVFS2 implementation of VFS directory operations */

const struct file_operations pvfs2_dir_operations = {

/** ORANGEFS implementation of VFS directory operations */

const struct file_operations orangefs_dir_operations = {

	.read = generic_read_dir,

	.iterate = pvfs2_readdir,

	.open = pvfs2_dir_open,

	.release = pvfs2_dir_release,

	.iterate = orangefs_readdir,

	.open = orangefs_dir_open,

	.release = orangefs_dir_release,

};

fs/orangefs/downcall.h

+42 −42
Original line number Diff line number Diff line
@@ -15,42 +15,42 @@ 
 * Sanitized the device-client core interaction

 * for clean 32-64 bit usage

 */

struct pvfs2_io_response {

struct orangefs_io_response {

	__s64 amt_complete;

};



struct pvfs2_lookup_response {

	struct pvfs2_object_kref refn;

struct orangefs_lookup_response {

	struct orangefs_object_kref refn;

};



struct pvfs2_create_response {

	struct pvfs2_object_kref refn;

struct orangefs_create_response {

	struct orangefs_object_kref refn;

};



struct pvfs2_symlink_response {

	struct pvfs2_object_kref refn;

struct orangefs_symlink_response {

	struct orangefs_object_kref refn;

};



struct pvfs2_getattr_response {

	struct PVFS_sys_attr_s attributes;

	char link_target[PVFS2_NAME_LEN];

struct orangefs_getattr_response {

	struct ORANGEFS_sys_attr_s attributes;

	char link_target[ORANGEFS_NAME_LEN];

};



struct pvfs2_mkdir_response {

	struct pvfs2_object_kref refn;

struct orangefs_mkdir_response {

	struct orangefs_object_kref refn;

};



/*

 * duplication of some system interface structures so that I don't have

 * to allocate extra memory

 */

struct pvfs2_dirent {

struct orangefs_dirent {

	char *d_name;

	int d_length;

	struct pvfs2_khandle khandle;

	struct orangefs_khandle khandle;

};



struct pvfs2_statfs_response {

struct orangefs_statfs_response {

	__s64 block_size;

	__s64 blocks_total;

	__s64 blocks_avail;
@@ -58,47 +58,47 @@ struct pvfs2_statfs_response { 
	__s64 files_avail;

};



struct pvfs2_fs_mount_response {

struct orangefs_fs_mount_response {

	__s32 fs_id;

	__s32 id;

	struct pvfs2_khandle root_khandle;

	struct orangefs_khandle root_khandle;

};



/* the getxattr response is the attribute value */

struct pvfs2_getxattr_response {

struct orangefs_getxattr_response {

	__s32 val_sz;

	__s32 __pad1;

	char val[PVFS_MAX_XATTR_VALUELEN];

	char val[ORANGEFS_MAX_XATTR_VALUELEN];

};



/* the listxattr response is an array of attribute names */

struct pvfs2_listxattr_response {

struct orangefs_listxattr_response {

	__s32 returned_count;

	__s32 __pad1;

	__u64 token;

	char key[PVFS_MAX_XATTR_LISTLEN * PVFS_MAX_XATTR_NAMELEN];

	char key[ORANGEFS_MAX_XATTR_LISTLEN * ORANGEFS_MAX_XATTR_NAMELEN];

	__s32 keylen;

	__s32 __pad2;

	__s32 lengths[PVFS_MAX_XATTR_LISTLEN];

	__s32 lengths[ORANGEFS_MAX_XATTR_LISTLEN];

};



struct pvfs2_param_response {

struct orangefs_param_response {

	__s64 value;

};



#define PERF_COUNT_BUF_SIZE 4096

struct pvfs2_perf_count_response {

struct orangefs_perf_count_response {

	char buffer[PERF_COUNT_BUF_SIZE];

};



#define FS_KEY_BUF_SIZE 4096

struct pvfs2_fs_key_response {

struct orangefs_fs_key_response {

	__s32 fs_keylen;

	__s32 __pad1;

	char fs_key[FS_KEY_BUF_SIZE];

};



struct pvfs2_downcall_s {

struct orangefs_downcall_s {

	__s32 type;

	__s32 status;

	/* currently trailer is used only by readdir */
@@ -106,28 +106,28 @@ struct pvfs2_downcall_s { 
	char *trailer_buf;



	union {

		struct pvfs2_io_response io;

		struct pvfs2_lookup_response lookup;

		struct pvfs2_create_response create;

		struct pvfs2_symlink_response sym;

		struct pvfs2_getattr_response getattr;

		struct pvfs2_mkdir_response mkdir;

		struct pvfs2_statfs_response statfs;

		struct pvfs2_fs_mount_response fs_mount;

		struct pvfs2_getxattr_response getxattr;

		struct pvfs2_listxattr_response listxattr;

		struct pvfs2_param_response param;

		struct pvfs2_perf_count_response perf_count;

		struct pvfs2_fs_key_response fs_key;

		struct orangefs_io_response io;

		struct orangefs_lookup_response lookup;

		struct orangefs_create_response create;

		struct orangefs_symlink_response sym;

		struct orangefs_getattr_response getattr;

		struct orangefs_mkdir_response mkdir;

		struct orangefs_statfs_response statfs;

		struct orangefs_fs_mount_response fs_mount;

		struct orangefs_getxattr_response getxattr;

		struct orangefs_listxattr_response listxattr;

		struct orangefs_param_response param;

		struct orangefs_perf_count_response perf_count;

		struct orangefs_fs_key_response fs_key;

	} resp;

};



struct pvfs2_readdir_response_s {

struct orangefs_readdir_response_s {

	__u64 token;

	__u64 directory_version;

	__u32 __pad2;

	__u32 pvfs_dirent_outcount;

	struct pvfs2_dirent *dirent_array;

	__u32 orangefs_dirent_outcount;

	struct orangefs_dirent *dirent_array;

};



#endif /* __DOWNCALL_H */