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: Yi Liu <yi9@clemson.edu>
[martin@omnibond.com: clairify above constraints and merge]
Signed-off-by: Martin Brandenburg <martin@omnibond.com>
Signed-off-by: Mike Marshall <hubcap@omnibond.com>

fs/orangefs/acl.c

@@ -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,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/dir.c

@@ -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

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

fs/orangefs/pvfs2-bufmap.h

@@ -4,59 +4,59 @@
  * See COPYING in top-level directory.
  */
 
-#ifndef __PVFS2_BUFMAP_H
-#define __PVFS2_BUFMAP_H
+#ifndef __ORANGEFS_BUFMAP_H
+#define __ORANGEFS_BUFMAP_H
 
 /* used to describe mapped buffers */
-struct pvfs_bufmap_desc {
+struct orangefs_bufmap_desc {
 	void *uaddr;			/* user space address pointer */
 	struct page **page_array;	/* array of mapped pages */
 	int array_count;		/* size of above arrays */
 	struct list_head list_link;
 };
 
-struct pvfs2_bufmap;
+struct orangefs_bufmap;
 
-struct pvfs2_bufmap *pvfs2_bufmap_ref(void);
-void pvfs2_bufmap_unref(struct pvfs2_bufmap *bufmap);
+struct orangefs_bufmap *orangefs_bufmap_ref(void);
+void orangefs_bufmap_unref(struct orangefs_bufmap *bufmap);
 
 /*
- * pvfs_bufmap_size_query is now an inline function because buffer
+ * orangefs_bufmap_size_query is now an inline function because buffer
  * sizes are not hardcoded
  */
-int pvfs_bufmap_size_query(void);
+int orangefs_bufmap_size_query(void);
 
-int pvfs_bufmap_shift_query(void);
+int orangefs_bufmap_shift_query(void);
 
-int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc);
+int orangefs_bufmap_initialize(struct ORANGEFS_dev_map_desc *user_desc);
 
 int get_bufmap_init(void);
 
-void pvfs_bufmap_finalize(void);
+void orangefs_bufmap_finalize(void);
 
-int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index);
+int orangefs_bufmap_get(struct orangefs_bufmap **mapp, int *buffer_index);
 
-void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index);
+void orangefs_bufmap_put(struct orangefs_bufmap *bufmap, int buffer_index);
 
-int readdir_index_get(struct pvfs2_bufmap **mapp, int *buffer_index);
+int readdir_index_get(struct orangefs_bufmap **mapp, int *buffer_index);
 
-void readdir_index_put(struct pvfs2_bufmap *bufmap, int buffer_index);
+void readdir_index_put(struct orangefs_bufmap *bufmap, int buffer_index);
 
-int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap,
+int orangefs_bufmap_copy_from_iovec(struct orangefs_bufmap *bufmap,
 				struct iov_iter *iter,
 				int buffer_index,
 				size_t size);
 
-int pvfs_bufmap_copy_to_iovec(struct pvfs2_bufmap *bufmap,
+int orangefs_bufmap_copy_to_iovec(struct orangefs_bufmap *bufmap,
 			      struct iov_iter *iter,
 			      int buffer_index,
 			      size_t size);
 
-size_t pvfs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk,
+size_t orangefs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk,
 					   struct iovec *iovec,
 					   unsigned long nr_segs,
-					   struct pvfs2_bufmap *bufmap,
+					   struct orangefs_bufmap *bufmap,
 					   int buffer_index,
 					   size_t bytes_to_be_copied);
 
-#endif /* __PVFS2_BUFMAP_H */
+#endif /* __ORANGEFS_BUFMAP_H */

fs/orangefs/pvfs2-cache.c

@@ -11,27 +11,27 @@
 static __u64 next_tag_value;
 static DEFINE_SPINLOCK(next_tag_value_lock);
 
-/* the pvfs2 memory caches */
+/* the orangefs memory caches */
 
-/* a cache for pvfs2 upcall/downcall operations */
+/* a cache for orangefs upcall/downcall operations */
 static struct kmem_cache *op_cache;
 
 /* a cache for device (/dev/pvfs2-req) communication */
 static struct kmem_cache *dev_req_cache;
 
-/* a cache for pvfs2_kiocb objects (i.e pvfs2 iocb structures ) */
-static struct kmem_cache *pvfs2_kiocb_cache;
+/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
+static struct kmem_cache *orangefs_kiocb_cache;
 
 int op_cache_initialize(void)
 {
-	op_cache = kmem_cache_create("pvfs2_op_cache",
-				     sizeof(struct pvfs2_kernel_op_s),
+	op_cache = kmem_cache_create("orangefs_op_cache",
+				     sizeof(struct orangefs_kernel_op_s),
 				     0,
-				     PVFS2_CACHE_CREATE_FLAGS,
+				     ORANGEFS_CACHE_CREATE_FLAGS,
 				     NULL);
 
 	if (!op_cache) {
-		gossip_err("Cannot create pvfs2_op_cache\n");
+		gossip_err("Cannot create orangefs_op_cache\n");
 		return -ENOMEM;
 	}
 
@@ -48,72 +48,72 @@ int op_cache_finalize(void)
 	return 0;
 }
 
-char *get_opname_string(struct pvfs2_kernel_op_s *new_op)
+char *get_opname_string(struct orangefs_kernel_op_s *new_op)
 {
 	if (new_op) {
 		__s32 type = new_op->upcall.type;
 
-		if (type == PVFS2_VFS_OP_FILE_IO)
+		if (type == ORANGEFS_VFS_OP_FILE_IO)
 			return "OP_FILE_IO";
-		else if (type == PVFS2_VFS_OP_LOOKUP)
+		else if (type == ORANGEFS_VFS_OP_LOOKUP)
 			return "OP_LOOKUP";
-		else if (type == PVFS2_VFS_OP_CREATE)
+		else if (type == ORANGEFS_VFS_OP_CREATE)
 			return "OP_CREATE";
-		else if (type == PVFS2_VFS_OP_GETATTR)
+		else if (type == ORANGEFS_VFS_OP_GETATTR)
 			return "OP_GETATTR";
-		else if (type == PVFS2_VFS_OP_REMOVE)
+		else if (type == ORANGEFS_VFS_OP_REMOVE)
 			return "OP_REMOVE";
-		else if (type == PVFS2_VFS_OP_MKDIR)
+		else if (type == ORANGEFS_VFS_OP_MKDIR)
 			return "OP_MKDIR";
-		else if (type == PVFS2_VFS_OP_READDIR)
+		else if (type == ORANGEFS_VFS_OP_READDIR)
 			return "OP_READDIR";
-		else if (type == PVFS2_VFS_OP_READDIRPLUS)
+		else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
 			return "OP_READDIRPLUS";
-		else if (type == PVFS2_VFS_OP_SETATTR)
+		else if (type == ORANGEFS_VFS_OP_SETATTR)
 			return "OP_SETATTR";
-		else if (type == PVFS2_VFS_OP_SYMLINK)
+		else if (type == ORANGEFS_VFS_OP_SYMLINK)
 			return "OP_SYMLINK";
-		else if (type == PVFS2_VFS_OP_RENAME)
+		else if (type == ORANGEFS_VFS_OP_RENAME)
 			return "OP_RENAME";
-		else if (type == PVFS2_VFS_OP_STATFS)
+		else if (type == ORANGEFS_VFS_OP_STATFS)
 			return "OP_STATFS";
-		else if (type == PVFS2_VFS_OP_TRUNCATE)
+		else if (type == ORANGEFS_VFS_OP_TRUNCATE)
 			return "OP_TRUNCATE";
-		else if (type == PVFS2_VFS_OP_MMAP_RA_FLUSH)
+		else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
 			return "OP_MMAP_RA_FLUSH";
-		else if (type == PVFS2_VFS_OP_FS_MOUNT)
+		else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
 			return "OP_FS_MOUNT";
-		else if (type == PVFS2_VFS_OP_FS_UMOUNT)
+		else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
 			return "OP_FS_UMOUNT";
-		else if (type == PVFS2_VFS_OP_GETXATTR)
+		else if (type == ORANGEFS_VFS_OP_GETXATTR)
 			return "OP_GETXATTR";
-		else if (type == PVFS2_VFS_OP_SETXATTR)
+		else if (type == ORANGEFS_VFS_OP_SETXATTR)
 			return "OP_SETXATTR";
-		else if (type == PVFS2_VFS_OP_LISTXATTR)
+		else if (type == ORANGEFS_VFS_OP_LISTXATTR)
 			return "OP_LISTXATTR";
-		else if (type == PVFS2_VFS_OP_REMOVEXATTR)
+		else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
 			return "OP_REMOVEXATTR";
-		else if (type == PVFS2_VFS_OP_PARAM)
+		else if (type == ORANGEFS_VFS_OP_PARAM)
 			return "OP_PARAM";
-		else if (type == PVFS2_VFS_OP_PERF_COUNT)
+		else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
 			return "OP_PERF_COUNT";
-		else if (type == PVFS2_VFS_OP_CANCEL)
+		else if (type == ORANGEFS_VFS_OP_CANCEL)
 			return "OP_CANCEL";
-		else if (type == PVFS2_VFS_OP_FSYNC)
+		else if (type == ORANGEFS_VFS_OP_FSYNC)
 			return "OP_FSYNC";
-		else if (type == PVFS2_VFS_OP_FSKEY)
+		else if (type == ORANGEFS_VFS_OP_FSKEY)
 			return "OP_FSKEY";
 	}
 	return "OP_UNKNOWN?";
 }
 
-struct pvfs2_kernel_op_s *op_alloc(__s32 type)
+struct orangefs_kernel_op_s *op_alloc(__s32 type)
 {
-	struct pvfs2_kernel_op_s *new_op = NULL;
+	struct orangefs_kernel_op_s *new_op = NULL;
 
-	new_op = kmem_cache_alloc(op_cache, PVFS2_CACHE_ALLOC_FLAGS);
+	new_op = kmem_cache_alloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 	if (new_op) {
-		memset(new_op, 0, sizeof(struct pvfs2_kernel_op_s));
+		memset(new_op, 0, sizeof(struct orangefs_kernel_op_s));
 
 		INIT_LIST_HEAD(&new_op->list);
 		spin_lock_init(&new_op->lock);
@@ -122,7 +122,7 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type)
 		init_waitqueue_head(&new_op->io_completion_waitq);
 		atomic_set(&new_op->aio_ref_count, 0);
 
-		pvfs2_op_initialize(new_op);
+		orangefs_op_initialize(new_op);
 
 		/* initialize the op specific tag and upcall credentials */
 		spin_lock(&next_tag_value_lock);
@@ -149,15 +149,15 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type)
 	return new_op;
 }
 
-void op_release(struct pvfs2_kernel_op_s *pvfs2_op)
+void op_release(struct orangefs_kernel_op_s *orangefs_op)
 {
-	if (pvfs2_op) {
+	if (orangefs_op) {
 		gossip_debug(GOSSIP_CACHE_DEBUG,
 			     "Releasing OP (%p: %llu)\n",
-			     pvfs2_op,
-			     llu(pvfs2_op->tag));
-		pvfs2_op_initialize(pvfs2_op);
-		kmem_cache_free(op_cache, pvfs2_op);
+			     orangefs_op,
+			     llu(orangefs_op->tag));
+		orangefs_op_initialize(orangefs_op);
+		kmem_cache_free(op_cache, orangefs_op);
 	} else {
 		gossip_err("NULL pointer in op_release\n");
 	}
@@ -165,14 +165,14 @@ void op_release(struct pvfs2_kernel_op_s *pvfs2_op)
 
 int dev_req_cache_initialize(void)
 {
-	dev_req_cache = kmem_cache_create("pvfs2_devreqcache",
+	dev_req_cache = kmem_cache_create("orangefs_devreqcache",
 					  MAX_ALIGNED_DEV_REQ_DOWNSIZE,
 					  0,
-					  PVFS2_CACHE_CREATE_FLAGS,
+					  ORANGEFS_CACHE_CREATE_FLAGS,
 					  NULL);
 
 	if (!dev_req_cache) {
-		gossip_err("Cannot create pvfs2_dev_req_cache\n");
+		gossip_err("Cannot create orangefs_dev_req_cache\n");
 		return -ENOMEM;
 	}
 	return 0;
@@ -188,7 +188,7 @@ void *dev_req_alloc(void)
 {
 	void *buffer;
 
-	buffer = kmem_cache_alloc(dev_req_cache, PVFS2_CACHE_ALLOC_FLAGS);
+	buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 	if (buffer == NULL)
 		gossip_err("Failed to allocate from dev_req_cache\n");
 	else
@@ -206,14 +206,14 @@ void dev_req_release(void *buffer)
 
 int kiocb_cache_initialize(void)
 {
-	pvfs2_kiocb_cache = kmem_cache_create("pvfs2_kiocbcache",
-					      sizeof(struct pvfs2_kiocb_s),
+	orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
+					      sizeof(struct orangefs_kiocb_s),
 					      0,
-					      PVFS2_CACHE_CREATE_FLAGS,
+					      ORANGEFS_CACHE_CREATE_FLAGS,
 					      NULL);
 
-	if (!pvfs2_kiocb_cache) {
-		gossip_err("Cannot create pvfs2_kiocb_cache!\n");
+	if (!orangefs_kiocb_cache) {
+		gossip_err("Cannot create orangefs_kiocb_cache!\n");
 		return -ENOMEM;
 	}
 	return 0;
@@ -221,26 +221,26 @@ int kiocb_cache_initialize(void)
 
 int kiocb_cache_finalize(void)
 {
-	kmem_cache_destroy(pvfs2_kiocb_cache);
+	kmem_cache_destroy(orangefs_kiocb_cache);
 	return 0;
 }
 
-struct pvfs2_kiocb_s *kiocb_alloc(void)
+struct orangefs_kiocb_s *kiocb_alloc(void)
 {
-	struct pvfs2_kiocb_s *x = NULL;
+	struct orangefs_kiocb_s *x = NULL;
 
-	x = kmem_cache_alloc(pvfs2_kiocb_cache, PVFS2_CACHE_ALLOC_FLAGS);
+	x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
 	if (x == NULL)
 		gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
 	else
-		memset(x, 0, sizeof(struct pvfs2_kiocb_s));
+		memset(x, 0, sizeof(struct orangefs_kiocb_s));
 	return x;
 }
 
-void kiocb_release(struct pvfs2_kiocb_s *x)
+void kiocb_release(struct orangefs_kiocb_s *x)
 {
 	if (x)
-		kmem_cache_free(pvfs2_kiocb_cache, x);
+		kmem_cache_free(orangefs_kiocb_cache, x);
 	else
 		gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
 }

fs/orangefs/pvfs2-debug.h

@@ -5,12 +5,12 @@
  */
 
 /* This file just defines debugging masks to be used with the gossip
- * logging utility.  All debugging masks for PVFS2 are kept here to make
+ * logging utility.  All debugging masks for ORANGEFS are kept here to make
  * sure we don't have collisions.
  */
 
-#ifndef __PVFS2_DEBUG_H
-#define __PVFS2_DEBUG_H
+#ifndef __ORANGEFS_DEBUG_H
+#define __ORANGEFS_DEBUG_H
 
 #ifdef __KERNEL__
 #include <linux/types.h>
@@ -90,7 +90,7 @@
 					 GOSSIP_BMI_DEBUG_MX +		\
 					 GOSSIP_BMI_DEBUG_PORTALS))
 
-const char *PVFS_debug_get_next_debug_keyword(int position);
+const char *ORANGEFS_debug_get_next_debug_keyword(int position);
 
 #define GOSSIP_SUPER_DEBUG		((__u64)1 << 0)
 #define GOSSIP_INODE_DEBUG		((__u64)1 << 1)
@@ -113,10 +113,10 @@ const char *PVFS_debug_get_next_debug_keyword(int position);
 #define GOSSIP_MAX_DEBUG              (((__u64)1 << GOSSIP_MAX_NR) - 1)
 
 /*function prototypes*/
-__u64 PVFS_kmod_eventlog_to_mask(const char *event_logging);
-__u64 PVFS_debug_eventlog_to_mask(const char *event_logging);
-char *PVFS_debug_mask_to_eventlog(__u64 mask);
-char *PVFS_kmod_mask_to_eventlog(__u64 mask);
+__u64 ORANGEFS_kmod_eventlog_to_mask(const char *event_logging);
+__u64 ORANGEFS_debug_eventlog_to_mask(const char *event_logging);
+char *ORANGEFS_debug_mask_to_eventlog(__u64 mask);
+char *ORANGEFS_kmod_mask_to_eventlog(__u64 mask);
 
 /* a private internal type */
 struct __keyword_mask_s {
@@ -289,4 +289,4 @@ static const int num_kmod_keyword_mask_map = (int)
 static const int num_keyword_mask_map = (int)
 	(sizeof(s_keyword_mask_map) / sizeof(struct __keyword_mask_s));
 
-#endif /* __PVFS2_DEBUG_H */
+#endif /* __ORANGEFS_DEBUG_H */

fs/orangefs/pvfs2-debugfs.c

@@ -95,7 +95,7 @@ static const struct file_operations kernel_debug_fops = {
  * initialize kmod debug operations, create orangefs debugfs dir and
  * ORANGEFS_KMOD_DEBUG_HELP_FILE.
  */
-int pvfs2_debugfs_init(void)
+int orangefs_debugfs_init(void)
 {
 
 	int rc = -ENOMEM;
@@ -117,12 +117,12 @@ int pvfs2_debugfs_init(void)
 
 out:
 	if (rc)
-		pvfs2_debugfs_cleanup();
+		orangefs_debugfs_cleanup();
 
 	return rc;
 }
 
-void pvfs2_debugfs_cleanup(void)
+void orangefs_debugfs_cleanup(void)
 {
 	debugfs_remove_recursive(debug_dir);
 }
@@ -196,7 +196,7 @@ static int help_show(struct seq_file *m, void *v)
 /*
  * initialize the kernel-debug file.
  */
-int pvfs2_kernel_debug_init(void)
+int orangefs_kernel_debug_init(void)
 {
 
 	int rc = -ENOMEM;
@@ -205,11 +205,11 @@ int pvfs2_kernel_debug_init(void)
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
 
-	k_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
+	k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 	if (!k_buffer)
 		goto out;
 
-	if (strlen(kernel_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
+	if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
 		strcpy(k_buffer, kernel_debug_string);
 		strcat(k_buffer, "\n");
 	} else {
@@ -233,7 +233,7 @@ int pvfs2_kernel_debug_init(void)
 
 out:
 	if (rc)
-		pvfs2_debugfs_cleanup();
+		orangefs_debugfs_cleanup();
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 	return rc;
@@ -242,7 +242,7 @@ int pvfs2_kernel_debug_init(void)
 /*
  * initialize the client-debug file.
  */
-int pvfs2_client_debug_init(void)
+int orangefs_client_debug_init(void)
 {
 
 	int rc = -ENOMEM;
@@ -250,11 +250,11 @@ int pvfs2_client_debug_init(void)
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
 
-	c_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
+	c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 	if (!c_buffer)
 		goto out;
 
-	if (strlen(client_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
+	if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
 		strcpy(c_buffer, client_debug_string);
 		strcat(c_buffer, "\n");
 	} else {
@@ -278,7 +278,7 @@ int pvfs2_client_debug_init(void)
 
 out:
 	if (rc)
-		pvfs2_debugfs_cleanup();
+		orangefs_debugfs_cleanup();
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
 	return rc;
@@ -320,7 +320,7 @@ static ssize_t orangefs_debug_read(struct file *file,
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
 
-	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
+	buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 	if (!buf)
 		goto out;
 
@@ -349,7 +349,7 @@ static ssize_t orangefs_debug_write(struct file *file,
 	int rc = -EFAULT;
 	size_t silly = 0;
 	char *debug_string;
-	struct pvfs2_kernel_op_s *new_op = NULL;
+	struct orangefs_kernel_op_s *new_op = NULL;
 	struct client_debug_mask c_mask = { NULL, 0, 0 };
 
 	gossip_debug(GOSSIP_DEBUGFS_DEBUG,
@@ -360,15 +360,15 @@ static ssize_t orangefs_debug_write(struct file *file,
 	 * Thwart users who try to jamb a ridiculous number
 	 * of bytes into the debug file...
 	 */
-	if (count > PVFS2_MAX_DEBUG_STRING_LEN + 1) {
+	if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
 		silly = count;
-		count = PVFS2_MAX_DEBUG_STRING_LEN + 1;
+		count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
 	}
 
-	buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
+	buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
 	if (!buf)
 		goto out;
-	memset(buf, 0, PVFS2_MAX_DEBUG_STRING_LEN);
+	memset(buf, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 
 	if (copy_from_user(buf, ubuf, count - 1)) {
 		gossip_debug(GOSSIP_DEBUGFS_DEBUG,
@@ -407,18 +407,18 @@ static ssize_t orangefs_debug_write(struct file *file,
 		debug_mask_to_string(&c_mask, 1);
 		debug_string = client_debug_string;
 
-		new_op = op_alloc(PVFS2_VFS_OP_PARAM);
+		new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
 		if (!new_op) {
 			pr_info("%s: op_alloc failed!\n", __func__);
 			goto out;
 		}
 
 		new_op->upcall.req.param.op =
-			PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES;
-		new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET;
+			ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
+		new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
 		memset(new_op->upcall.req.param.s_value,
 		       0,
-		       PVFS2_MAX_DEBUG_STRING_LEN);
+		       ORANGEFS_MAX_DEBUG_STRING_LEN);
 		sprintf(new_op->upcall.req.param.s_value,
 			"%llx %llx\n",
 			c_mask.mask1,
@@ -426,8 +426,8 @@ static ssize_t orangefs_debug_write(struct file *file,
 
 		/* service_operation returns 0 on success... */
 		rc = service_operation(new_op,
-				       "pvfs2_param",
-					PVFS2_OP_INTERRUPTIBLE);
+				       "orangefs_param",
+					ORANGEFS_OP_INTERRUPTIBLE);
 
 		if (rc)
 			gossip_debug(GOSSIP_DEBUGFS_DEBUG,
@@ -439,7 +439,7 @@ static ssize_t orangefs_debug_write(struct file *file,
 	}
 
 	mutex_lock(&orangefs_debug_lock);
-	memset(file->f_inode->i_private, 0, PVFS2_MAX_DEBUG_STRING_LEN);
+	memset(file->f_inode->i_private, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
 	sprintf((char *)file->f_inode->i_private, "%s\n", debug_string);
 	mutex_unlock(&orangefs_debug_lock);
 

fs/orangefs/pvfs2-debugfs.h

-int pvfs2_debugfs_init(void);
-int pvfs2_kernel_debug_init(void);
-void pvfs2_debugfs_cleanup(void);
+int orangefs_debugfs_init(void);
+int orangefs_kernel_debug_init(void);
+void orangefs_debugfs_cleanup(void);

fs/orangefs/pvfs2-dev-proto.h

@@ -4,8 +4,8 @@
  * See COPYING in top-level directory.
  */
 
-#ifndef _PVFS2_DEV_PROTO_H
-#define _PVFS2_DEV_PROTO_H
+#ifndef _ORANGEFS_DEV_PROTO_H
+#define _ORANGEFS_DEV_PROTO_H
 
 /*
  * types and constants shared between user space and kernel space for
@@ -13,46 +13,46 @@
  */
 
 /*
- * valid pvfs2 kernel operation types
+ * valid orangefs kernel operation types
  */
-#define PVFS2_VFS_OP_INVALID           0xFF000000
-#define PVFS2_VFS_OP_FILE_IO           0xFF000001
-#define PVFS2_VFS_OP_LOOKUP            0xFF000002
-#define PVFS2_VFS_OP_CREATE            0xFF000003
-#define PVFS2_VFS_OP_GETATTR           0xFF000004
-#define PVFS2_VFS_OP_REMOVE            0xFF000005
-#define PVFS2_VFS_OP_MKDIR             0xFF000006
-#define PVFS2_VFS_OP_READDIR           0xFF000007
-#define PVFS2_VFS_OP_SETATTR           0xFF000008
-#define PVFS2_VFS_OP_SYMLINK           0xFF000009
-#define PVFS2_VFS_OP_RENAME            0xFF00000A
-#define PVFS2_VFS_OP_STATFS            0xFF00000B
-#define PVFS2_VFS_OP_TRUNCATE          0xFF00000C
-#define PVFS2_VFS_OP_MMAP_RA_FLUSH     0xFF00000D
-#define PVFS2_VFS_OP_FS_MOUNT          0xFF00000E
-#define PVFS2_VFS_OP_FS_UMOUNT         0xFF00000F
-#define PVFS2_VFS_OP_GETXATTR          0xFF000010
-#define PVFS2_VFS_OP_SETXATTR          0xFF000011
-#define PVFS2_VFS_OP_LISTXATTR         0xFF000012
-#define PVFS2_VFS_OP_REMOVEXATTR       0xFF000013
-#define PVFS2_VFS_OP_PARAM             0xFF000014
-#define PVFS2_VFS_OP_PERF_COUNT        0xFF000015
-#define PVFS2_VFS_OP_CANCEL            0xFF00EE00
-#define PVFS2_VFS_OP_FSYNC             0xFF00EE01
-#define PVFS2_VFS_OP_FSKEY             0xFF00EE02
-#define PVFS2_VFS_OP_READDIRPLUS       0xFF00EE03
+#define ORANGEFS_VFS_OP_INVALID           0xFF000000
+#define ORANGEFS_VFS_OP_FILE_IO        0xFF000001
+#define ORANGEFS_VFS_OP_LOOKUP         0xFF000002
+#define ORANGEFS_VFS_OP_CREATE         0xFF000003
+#define ORANGEFS_VFS_OP_GETATTR        0xFF000004
+#define ORANGEFS_VFS_OP_REMOVE         0xFF000005
+#define ORANGEFS_VFS_OP_MKDIR          0xFF000006
+#define ORANGEFS_VFS_OP_READDIR        0xFF000007
+#define ORANGEFS_VFS_OP_SETATTR        0xFF000008
+#define ORANGEFS_VFS_OP_SYMLINK        0xFF000009
+#define ORANGEFS_VFS_OP_RENAME         0xFF00000A
+#define ORANGEFS_VFS_OP_STATFS         0xFF00000B
+#define ORANGEFS_VFS_OP_TRUNCATE       0xFF00000C
+#define ORANGEFS_VFS_OP_MMAP_RA_FLUSH  0xFF00000D
+#define ORANGEFS_VFS_OP_FS_MOUNT       0xFF00000E
+#define ORANGEFS_VFS_OP_FS_UMOUNT      0xFF00000F
+#define ORANGEFS_VFS_OP_GETXATTR       0xFF000010
+#define ORANGEFS_VFS_OP_SETXATTR          0xFF000011
+#define ORANGEFS_VFS_OP_LISTXATTR         0xFF000012
+#define ORANGEFS_VFS_OP_REMOVEXATTR       0xFF000013
+#define ORANGEFS_VFS_OP_PARAM          0xFF000014
+#define ORANGEFS_VFS_OP_PERF_COUNT     0xFF000015
+#define ORANGEFS_VFS_OP_CANCEL            0xFF00EE00
+#define ORANGEFS_VFS_OP_FSYNC          0xFF00EE01
+#define ORANGEFS_VFS_OP_FSKEY             0xFF00EE02
+#define ORANGEFS_VFS_OP_READDIRPLUS       0xFF00EE03
 
 /*
  * Misc constants. Please retain them as multiples of 8!
  * Otherwise 32-64 bit interactions will be messed up :)
  */
-#define PVFS2_NAME_LEN			0x00000100
-#define PVFS2_MAX_DEBUG_STRING_LEN	0x00000400
-#define PVFS2_MAX_DEBUG_ARRAY_LEN	0x00000800
+#define ORANGEFS_NAME_LEN		0x00000100
+#define ORANGEFS_MAX_DEBUG_STRING_LEN	0x00000400
+#define ORANGEFS_MAX_DEBUG_ARRAY_LEN	0x00000800
 
 /*
- * MAX_DIRENT_COUNT cannot be larger than PVFS_REQ_LIMIT_LISTATTR.
- * The value of PVFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60
+ * MAX_DIRENT_COUNT cannot be larger than ORANGEFS_REQ_LIMIT_LISTATTR.
+ * The value of ORANGEFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60
  * to accomodate an attribute object with mirrored handles.
  * MAX_DIRENT_COUNT is replaced by MAX_DIRENT_COUNT_READDIR and
  * MAX_DIRENT_COUNT_READDIRPLUS, since readdir doesn't trigger a listattr

fs/orangefs/symlink.c

@@ -8,9 +8,9 @@
 #include "pvfs2-kernel.h"
 #include "pvfs2-bufmap.h"
 
-static const char *pvfs2_follow_link(struct dentry *dentry, void **cookie)
+static const char *orangefs_follow_link(struct dentry *dentry, void **cookie)
 {
-	char *target =  PVFS2_I(dentry->d_inode)->link_target;
+	char *target =  ORANGEFS_I(dentry->d_inode)->link_target;
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
 		     "%s: called on %s (target is %p)\n",
@@ -21,11 +21,11 @@ static const char *pvfs2_follow_link(struct dentry *dentry, void **cookie)
 	return target;
 }
 
-struct inode_operations pvfs2_symlink_inode_operations = {
+struct inode_operations orangefs_symlink_inode_operations = {
 	.readlink = generic_readlink,
-	.follow_link = pvfs2_follow_link,
-	.setattr = pvfs2_setattr,
-	.getattr = pvfs2_getattr,
-	.listxattr = pvfs2_listxattr,
+	.follow_link = orangefs_follow_link,
+	.setattr = orangefs_setattr,
+	.getattr = orangefs_getattr,
+	.listxattr = orangefs_listxattr,
 	.setxattr = generic_setxattr,
 };