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>

1 files changed, 88 insertions, 88 deletions

diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c
index 70d1c1925ea3..58e83182d3dc 100644
--- a/fs/orangefs/inode.c
+++ b/fs/orangefs/inode.c
@@ -26,7 +26,7 @@ static int read_one_page(struct page *page)
 	iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE);
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		    "pvfs2_readpage called with page %p\n",
+		    "orangefs_readpage called with page %p\n",
 		     page);
 
 	max_block = ((inode->i_size / blocksize) + 1);
@@ -34,10 +34,10 @@ static int read_one_page(struct page *page)
 	if (page->index < max_block) {
 		loff_t blockptr_offset = (((loff_t) page->index) << blockbits);
 
-		bytes_read = pvfs2_inode_read(inode,
-					      &to,
-					      &blockptr_offset,
-					      inode->i_size);
+		bytes_read = orangefs_inode_read(inode,
+						 &to,
+						 &blockptr_offset,
+						 inode->i_size);
 	}
 	/* this will only zero remaining unread portions of the page data */
 	iov_iter_zero(~0U, &to);
@@ -57,12 +57,12 @@ static int read_one_page(struct page *page)
 	return ret;
 }
 
-static int pvfs2_readpage(struct file *file, struct page *page)
+static int orangefs_readpage(struct file *file, struct page *page)
 {
 	return read_one_page(page);
 }
 
-static int pvfs2_readpages(struct file *file,
+static int orangefs_readpages(struct file *file,
 			   struct address_space *mapping,
 			   struct list_head *pages,
 			   unsigned nr_pages)
@@ -70,7 +70,7 @@ static int pvfs2_readpages(struct file *file,
 	int page_idx;
 	int ret;
 
-	gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2_readpages called\n");
+	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n");
 
 	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
 		struct page *page;
@@ -93,12 +93,12 @@ static int pvfs2_readpages(struct file *file,
 	return 0;
 }
 
-static void pvfs2_invalidatepage(struct page *page,
+static void orangefs_invalidatepage(struct page *page,
 				 unsigned int offset,
 				 unsigned int length)
 {
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_invalidatepage called on page %p "
+		     "orangefs_invalidatepage called on page %p "
 		     "(offset is %u)\n",
 		     page,
 		     offset);
@@ -109,10 +109,10 @@ static void pvfs2_invalidatepage(struct page *page,
 
 }
 
-static int pvfs2_releasepage(struct page *page, gfp_t foo)
+static int orangefs_releasepage(struct page *page, gfp_t foo)
 {
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_releasepage called on page %p\n",
+		     "orangefs_releasepage called on page %p\n",
 		     page);
 	return 0;
 }
@@ -131,32 +131,32 @@ static int pvfs2_releasepage(struct page *page, gfp_t foo)
  *			loff_t offset)
  *{
  *	gossip_debug(GOSSIP_INODE_DEBUG,
- *		     "pvfs2_direct_IO: %s\n",
+ *		     "orangefs_direct_IO: %s\n",
  *		     iocb->ki_filp->f_path.dentry->d_name.name);
  *
  *	return -EINVAL;
  *}
  */
 
-struct backing_dev_info pvfs2_backing_dev_info = {
-	.name = "pvfs2",
+struct backing_dev_info orangefs_backing_dev_info = {
+	.name = "orangefs",
 	.ra_pages = 0,
 	.capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK,
 };
 
-/** PVFS2 implementation of address space operations */
-const struct address_space_operations pvfs2_address_operations = {
-	.readpage = pvfs2_readpage,
-	.readpages = pvfs2_readpages,
-	.invalidatepage = pvfs2_invalidatepage,
-	.releasepage = pvfs2_releasepage,
+/** ORANGEFS2 implementation of address space operations */
+const struct address_space_operations orangefs_address_operations = {
+	.readpage = orangefs_readpage,
+	.readpages = orangefs_readpages,
+	.invalidatepage = orangefs_invalidatepage,
+	.releasepage = orangefs_releasepage,
 /*	.direct_IO = pvfs2_direct_IO */
 };
 
-static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr)
+static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr)
 {
-	struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode);
-	struct pvfs2_kernel_op_s *new_op;
+	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
+	struct orangefs_kernel_op_s *new_op;
 	loff_t orig_size = i_size_read(inode);
 	int ret = -EINVAL;
 
@@ -164,17 +164,17 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr)
 		     "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n",
 		     __func__,
 		     get_khandle_from_ino(inode),
-		     &pvfs2_inode->refn.khandle,
-		     pvfs2_inode->refn.fs_id,
+		     &orangefs_inode->refn.khandle,
+		     orangefs_inode->refn.fs_id,
 		     iattr->ia_size);
 
 	truncate_setsize(inode, iattr->ia_size);
 
-	new_op = op_alloc(PVFS2_VFS_OP_TRUNCATE);
+	new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE);
 	if (!new_op)
 		return -ENOMEM;
 
-	new_op->upcall.req.truncate.refn = pvfs2_inode->refn;
+	new_op->upcall.req.truncate.refn = orangefs_inode->refn;
 	new_op->upcall.req.truncate.size = (__s64) iattr->ia_size;
 
 	ret = service_operation(new_op, __func__,
@@ -185,7 +185,7 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr)
 	 * the status value tells us if it went through ok or not
 	 */
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2: pvfs2_truncate got return value of %d\n",
+		     "orangefs: orangefs_truncate got return value of %d\n",
 		     ret);
 
 	op_release(new_op);
@@ -216,13 +216,13 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr)
 /*
  * Change attributes of an object referenced by dentry.
  */
-int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr)
+int orangefs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
 	int ret = -EINVAL;
 	struct inode *inode = dentry->d_inode;
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_setattr: called on %s\n",
+		     "orangefs_setattr: called on %s\n",
 		     dentry->d_name.name);
 
 	ret = inode_change_ok(inode, iattr);
@@ -231,7 +231,7 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr)
 
 	if ((iattr->ia_valid & ATTR_SIZE) &&
 	    iattr->ia_size != i_size_read(inode)) {
-		ret = pvfs2_setattr_size(inode, iattr);
+		ret = orangefs_setattr_size(inode, iattr);
 		if (ret)
 			goto out;
 	}
@@ -239,9 +239,9 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr)
 	setattr_copy(inode, iattr);
 	mark_inode_dirty(inode);
 
-	ret = pvfs2_inode_setattr(inode, iattr);
+	ret = orangefs_inode_setattr(inode, iattr);
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_setattr: inode_setattr returned %d\n",
+		     "orangefs_setattr: inode_setattr returned %d\n",
 		     ret);
 
 	if (!ret && (iattr->ia_valid & ATTR_MODE))
@@ -249,23 +249,23 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr)
 		ret = posix_acl_chmod(inode, inode->i_mode);
 
 out:
-	gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2_setattr: returning %d\n", ret);
+	gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret);
 	return ret;
 }
 
 /*
  * Obtain attributes of an object given a dentry
  */
-int pvfs2_getattr(struct vfsmount *mnt,
+int orangefs_getattr(struct vfsmount *mnt,
 		  struct dentry *dentry,
 		  struct kstat *kstat)
 {
 	int ret = -ENOENT;
 	struct inode *inode = dentry->d_inode;
-	struct pvfs2_inode_s *pvfs2_inode = NULL;
+	struct orangefs_inode_s *orangefs_inode = NULL;
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_getattr: called on %s\n",
+		     "orangefs_getattr: called on %s\n",
 		     dentry->d_name.name);
 
 	/*
@@ -273,12 +273,12 @@ int pvfs2_getattr(struct vfsmount *mnt,
 	 * fields/attributes of the inode would be refreshed. So again, we
 	 * dont have too much of a choice but refresh all the attributes.
 	 */
-	ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT);
+	ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT);
 	if (ret == 0) {
 		generic_fillattr(inode, kstat);
 		/* override block size reported to stat */
-		pvfs2_inode = PVFS2_I(inode);
-		kstat->blksize = pvfs2_inode->blksize;
+		orangefs_inode = ORANGEFS_I(inode);
+		kstat->blksize = orangefs_inode->blksize;
 	} else {
 		/* assume an I/O error and flag inode as bad */
 		gossip_debug(GOSSIP_INODE_DEBUG,
@@ -286,39 +286,39 @@ int pvfs2_getattr(struct vfsmount *mnt,
 			     __FILE__,
 			     __func__,
 			     __LINE__);
-		pvfs2_make_bad_inode(inode);
+		orangefs_make_bad_inode(inode);
 	}
 	return ret;
 }
 
-/* PVFS2 implementation of VFS inode operations for files */
-struct inode_operations pvfs2_file_inode_operations = {
-	.get_acl = pvfs2_get_acl,
-	.set_acl = pvfs2_set_acl,
-	.setattr = pvfs2_setattr,
-	.getattr = pvfs2_getattr,
+/* ORANGEDS2 implementation of VFS inode operations for files */
+struct inode_operations orangefs_file_inode_operations = {
+	.get_acl = orangefs_get_acl,
+	.set_acl = orangefs_set_acl,
+	.setattr = orangefs_setattr,
+	.getattr = orangefs_getattr,
 	.setxattr = generic_setxattr,
 	.getxattr = generic_getxattr,
-	.listxattr = pvfs2_listxattr,
+	.listxattr = orangefs_listxattr,
 	.removexattr = generic_removexattr,
 };
 
-static int pvfs2_init_iops(struct inode *inode)
+static int orangefs_init_iops(struct inode *inode)
 {
-	inode->i_mapping->a_ops = &pvfs2_address_operations;
+	inode->i_mapping->a_ops = &orangefs_address_operations;
 
 	switch (inode->i_mode & S_IFMT) {
 	case S_IFREG:
-		inode->i_op = &pvfs2_file_inode_operations;
-		inode->i_fop = &pvfs2_file_operations;
+		inode->i_op = &orangefs_file_inode_operations;
+		inode->i_fop = &orangefs_file_operations;
 		inode->i_blkbits = PAGE_CACHE_SHIFT;
 		break;
 	case S_IFLNK:
-		inode->i_op = &pvfs2_symlink_inode_operations;
+		inode->i_op = &orangefs_symlink_inode_operations;
 		break;
 	case S_IFDIR:
-		inode->i_op = &pvfs2_dir_inode_operations;
-		inode->i_fop = &pvfs2_dir_operations;
+		inode->i_op = &orangefs_dir_inode_operations;
+		inode->i_fop = &orangefs_dir_operations;
 		break;
 	default:
 		gossip_debug(GOSSIP_INODE_DEBUG,
@@ -331,75 +331,75 @@ static int pvfs2_init_iops(struct inode *inode)
 }
 
 /*
- * Given a PVFS2 object identifier (fsid, handle), convert it into a ino_t type
+ * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type
  * that will be used as a hash-index from where the handle will
  * be searched for in the VFS hash table of inodes.
  */
-static inline ino_t pvfs2_handle_hash(struct pvfs2_object_kref *ref)
+static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref)
 {
 	if (!ref)
 		return 0;
-	return pvfs2_khandle_to_ino(&(ref->khandle));
+	return orangefs_khandle_to_ino(&(ref->khandle));
 }
 
 /*
  * Called to set up an inode from iget5_locked.
  */
-static int pvfs2_set_inode(struct inode *inode, void *data)
+static int orangefs_set_inode(struct inode *inode, void *data)
 {
-	struct pvfs2_object_kref *ref = (struct pvfs2_object_kref *) data;
-	struct pvfs2_inode_s *pvfs2_inode = NULL;
+	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
+	struct orangefs_inode_s *orangefs_inode = NULL;
 
 	/* Make sure that we have sane parameters */
 	if (!data || !inode)
 		return 0;
-	pvfs2_inode = PVFS2_I(inode);
-	if (!pvfs2_inode)
+	orangefs_inode = ORANGEFS_I(inode);
+	if (!orangefs_inode)
 		return 0;
-	pvfs2_inode->refn.fs_id = ref->fs_id;
-	pvfs2_inode->refn.khandle = ref->khandle;
+	orangefs_inode->refn.fs_id = ref->fs_id;
+	orangefs_inode->refn.khandle = ref->khandle;
 	return 0;
 }
 
 /*
  * Called to determine if handles match.
  */
-static int pvfs2_test_inode(struct inode *inode, void *data)
+static int orangefs_test_inode(struct inode *inode, void *data)
 {
-	struct pvfs2_object_kref *ref = (struct pvfs2_object_kref *) data;
-	struct pvfs2_inode_s *pvfs2_inode = NULL;
+	struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data;
+	struct orangefs_inode_s *orangefs_inode = NULL;
 
-	pvfs2_inode = PVFS2_I(inode);
-	return (!PVFS_khandle_cmp(&(pvfs2_inode->refn.khandle), &(ref->khandle))
-		&& pvfs2_inode->refn.fs_id == ref->fs_id);
+	orangefs_inode = ORANGEFS_I(inode);
+	return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle))
+		&& orangefs_inode->refn.fs_id == ref->fs_id);
 }
 
 /*
- * Front-end to lookup the inode-cache maintained by the VFS using the PVFS2
+ * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS
  * file handle.
  *
  * @sb: the file system super block instance.
- * @ref: The PVFS2 object for which we are trying to locate an inode structure.
+ * @ref: The ORANGEFS object for which we are trying to locate an inode structure.
  */
-struct inode *pvfs2_iget(struct super_block *sb, struct pvfs2_object_kref *ref)
+struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref)
 {
 	struct inode *inode = NULL;
 	unsigned long hash;
 	int error;
 
-	hash = pvfs2_handle_hash(ref);
-	inode = iget5_locked(sb, hash, pvfs2_test_inode, pvfs2_set_inode, ref);
+	hash = orangefs_handle_hash(ref);
+	inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref);
 	if (!inode || !(inode->i_state & I_NEW))
 		return inode;
 
-	error = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT);
+	error = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT);
 	if (error) {
 		iget_failed(inode);
 		return ERR_PTR(error);
 	}
 
 	inode->i_ino = hash;	/* needed for stat etc */
-	pvfs2_init_iops(inode);
+	orangefs_init_iops(inode);
 	unlock_new_inode(inode);
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
@@ -415,15 +415,15 @@ struct inode *pvfs2_iget(struct super_block *sb, struct pvfs2_object_kref *ref)
 /*
  * Allocate an inode for a newly created file and insert it into the inode hash.
  */
-struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir,
-		int mode, dev_t dev, struct pvfs2_object_kref *ref)
+struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir,
+		int mode, dev_t dev, struct orangefs_object_kref *ref)
 {
-	unsigned long hash = pvfs2_handle_hash(ref);
+	unsigned long hash = orangefs_handle_hash(ref);
 	struct inode *inode;
 	int error;
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
-		     "pvfs2_get_custom_inode_common: called\n"
+		     "orangefs_get_custom_inode_common: called\n"
 		     "(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n",
 		     sb,
 		     MAJOR(dev),
@@ -434,14 +434,14 @@ struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir,
 	if (!inode)
 		return NULL;
 
-	pvfs2_set_inode(inode, ref);
+	orangefs_set_inode(inode, ref);
 	inode->i_ino = hash;	/* needed for stat etc */
 
-	error = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT);
+	error = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT);
 	if (error)
 		goto out_iput;
 
-	pvfs2_init_iops(inode);
+	orangefs_init_iops(inode);
 
 	inode->i_mode = mode;
 	inode->i_uid = current_fsuid();
@@ -450,14 +450,14 @@ struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir,
 	inode->i_size = PAGE_CACHE_SIZE;
 	inode->i_rdev = dev;
 
-	error = insert_inode_locked4(inode, hash, pvfs2_test_inode, ref);
+	error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref);
 	if (error < 0)
 		goto out_iput;
 
 	gossip_debug(GOSSIP_INODE_DEBUG,
 		     "Initializing ACL's for inode %pU\n",
 		     get_khandle_from_ino(inode));
-	pvfs2_init_acl(inode, dir);
+	orangefs_init_acl(inode, dir);
 	return inode;
 
 out_iput: