niansa-misc/linux
1
0
Fork 0
mirror of synced 2025-03-06 20:59:54 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source 
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>
This commit is contained in:
Yi Liu 2015-11-24 15:12:14 -05:00 • committed by Mike Marshall
parent 555fa0fa61
commit 8bb8aefd5a
25 changed files with 1776 additions and 1776 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
fs/orangefs/acl.c
View file

@ -10,7 +10,7 @@
#include <linux/posix_acl_xattr.h> #include <linux/posix_acl_xattr.h>
#include <linux/fs_struct.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; struct posix_acl *acl;
int ret; int ret;
@ -18,23 +18,23 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
switch (type) { switch (type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
key = PVFS2_XATTR_NAME_ACL_ACCESS; key = ORANGEFS_XATTR_NAME_ACL_ACCESS;
break; break;
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
key = PVFS2_XATTR_NAME_ACL_DEFAULT; key = ORANGEFS_XATTR_NAME_ACL_DEFAULT;
break; break;
default: 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); return ERR_PTR(-EINVAL);
} }
/* /*
* Rather than incurring a network call just to determine the exact * Rather than incurring a network call just to determine the exact
* length of the attribute, I just allocate a max length to save on * length of the attribute, I just allocate a max length to save on
* the network call. Conceivably, we could pass NULL to * 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. * 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) if (value == NULL)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
@ -43,11 +43,11 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
key, key,
type); type);
ret = pvfs2_inode_getxattr(inode, ret = orangefs_inode_getxattr(inode,
"", "",
key, key,
value, value,
PVFS_MAX_XATTR_VALUELEN); ORANGEFS_MAX_XATTR_VALUELEN);
/* if the key exists, convert it to an in-memory rep */ /* if the key exists, convert it to an in-memory rep */
if (ret > 0) { if (ret > 0) {
acl = posix_acl_from_xattr(&init_user_ns, value, ret); 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; 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; int error = 0;
void *value = NULL; void *value = NULL;
size_t size = 0; size_t size = 0;
@ -74,7 +74,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
switch (type) { switch (type) {
case ACL_TYPE_ACCESS: case ACL_TYPE_ACCESS:
name = PVFS2_XATTR_NAME_ACL_ACCESS; name = ORANGEFS_XATTR_NAME_ACL_ACCESS;
if (acl) { if (acl) {
umode_t mode = inode->i_mode; 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) if (inode->i_mode != mode)
SetModeFlag(pvfs2_inode); SetModeFlag(orangefs_inode);
inode->i_mode = mode; inode->i_mode = mode;
mark_inode_dirty_sync(inode); mark_inode_dirty_sync(inode);
if (error == 0) if (error == 0)
@ -98,7 +98,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
} }
break; break;
case ACL_TYPE_DEFAULT: case ACL_TYPE_DEFAULT:
name = PVFS2_XATTR_NAME_ACL_DEFAULT; name = ORANGEFS_XATTR_NAME_ACL_DEFAULT;
break; break;
default: default:
gossip_err("%s: invalid type %d!\n", __func__, type); 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 * will xlate to a removexattr. However, we don't want removexattr
* complain if attributes does not exist. * 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: out:
kfree(value); kfree(value);
@ -140,35 +140,35 @@ out:
return error; 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; struct posix_acl *default_acl, *acl;
umode_t mode = inode->i_mode; umode_t mode = inode->i_mode;
int error = 0; int error = 0;
ClearModeFlag(pvfs2_inode); ClearModeFlag(orangefs_inode);
error = posix_acl_create(dir, &mode, &default_acl, &acl); error = posix_acl_create(dir, &mode, &default_acl, &acl);
if (error) if (error)
return error; return error;
if (default_acl) { 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); posix_acl_release(default_acl);
} }
if (acl) { if (acl) {
if (!error) if (!error)
error = pvfs2_set_acl(inode, acl, ACL_TYPE_ACCESS); error = orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS);
posix_acl_release(acl); posix_acl_release(acl);
} }
/* If mode of the inode was changed, then do a forcible ->setattr */ /* If mode of the inode was changed, then do a forcible ->setattr */
if (mode != inode->i_mode) { if (mode != inode->i_mode) {
SetModeFlag(pvfs2_inode); SetModeFlag(orangefs_inode);
inode->i_mode = mode; inode->i_mode = mode;
pvfs2_flush_inode(inode); orangefs_flush_inode(inode);
} }
return error; return error;

24
fs/orangefs/dcache.c
View file

@ -12,27 +12,27 @@
#include "pvfs2-kernel.h" #include "pvfs2-kernel.h"
/* Returns 1 if dentry can still be trusted, else 0. */ /* 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 dentry *parent_dentry = dget_parent(dentry);
struct inode *parent_inode = parent_dentry->d_inode; 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 inode *inode = dentry->d_inode;
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret = 0; int ret = 0;
int err = 0; int err = 0;
gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: attempting lookup.\n", __func__); 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) if (!new_op)
goto out_put_parent; 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; new_op->upcall.req.lookup.parent_refn = parent->refn;
strncpy(new_op->upcall.req.lookup.d_name, strncpy(new_op->upcall.req.lookup.d_name,
dentry->d_name.name, dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
gossip_debug(GOSSIP_DCACHE_DEBUG, gossip_debug(GOSSIP_DCACHE_DEBUG,
"%s:%s:%d interrupt flag [%d]\n", "%s:%s:%d interrupt flag [%d]\n",
@ -41,7 +41,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry)
__LINE__, __LINE__,
get_interruptible_flag(parent_inode)); get_interruptible_flag(parent_inode));
err = service_operation(new_op, "pvfs2_lookup", err = service_operation(new_op, "orangefs_lookup",
get_interruptible_flag(parent_inode)); get_interruptible_flag(parent_inode));
if (err) if (err)
goto out_drop; goto out_drop;
@ -79,7 +79,7 @@ out_drop:
* *
* Should return 1 if dentry can still be trusted, else 0 * 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; struct inode *inode;
int ret = 0; 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 * exists, but is still in the expected place in the name space
*/ */
if (!is_root_handle(inode)) { if (!is_root_handle(inode)) {
if (!pvfs2_revalidate_lookup(dentry)) if (!orangefs_revalidate_lookup(dentry))
goto invalid_exit; goto invalid_exit;
} else { } else {
gossip_debug(GOSSIP_DCACHE_DEBUG, gossip_debug(GOSSIP_DCACHE_DEBUG,
@ -119,7 +119,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)
__func__, __func__,
inode, inode,
get_khandle_from_ino(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, gossip_debug(GOSSIP_DCACHE_DEBUG,
"%s: getattr %s (ret = %d), returning %s for dentry i_count=%d\n", "%s: getattr %s (ret = %d), returning %s for dentry i_count=%d\n",
__func__, __func__,
@ -137,6 +137,6 @@ invalid_exit:
return 0; return 0;
} }
const struct dentry_operations pvfs2_dentry_operations = { const struct dentry_operations orangefs_dentry_operations = {
.d_revalidate = pvfs2_d_revalidate, .d_revalidate = orangefs_d_revalidate,
}; };

256
fs/orangefs/devpvfs2-req.c
View file

@ -22,14 +22,14 @@ static int open_access_count;
#define DUMP_DEVICE_ERROR() \ #define DUMP_DEVICE_ERROR() \
do { \ do { \
gossip_err("*****************************************************\n");\ gossip_err("*****************************************************\n");\
gossip_err("PVFS2 Device Error: You cannot open the device file "); \ gossip_err("ORANGEFS Device Error: You cannot open the device file "); \
gossip_err("\n/dev/%s more than once. Please make sure that\nthere " \ gossip_err("\n/dev/%s more than once. Please make sure that\nthere " \
"are no ", PVFS2_REQDEVICE_NAME); \ "are no ", ORANGEFS_REQDEVICE_NAME); \
gossip_err("instances of a program using this device\ncurrently " \ gossip_err("instances of a program using this device\ncurrently " \
"running. (You must verify this!)\n"); \ "running. (You must verify this!)\n"); \
gossip_err("For example, you can use the lsof program as follows:\n");\ gossip_err("For example, you can use the lsof program as follows:\n");\
gossip_err("'lsof | grep %s' (run this as root)\n", \ gossip_err("'lsof | grep %s' (run this as root)\n", \
PVFS2_REQDEVICE_NAME); \ ORANGEFS_REQDEVICE_NAME); \
gossip_err(" open_access_count = %d\n", open_access_count); \ gossip_err(" open_access_count = %d\n", open_access_count); \
gossip_err("*****************************************************\n");\ gossip_err("*****************************************************\n");\
} while (0) } while (0)
@ -39,7 +39,7 @@ static int hash_func(__u64 tag, int table_size)
return do_div(tag, (unsigned int)table_size); return do_div(tag, (unsigned int)table_size);
} }
static void pvfs2_devreq_add_op(struct pvfs2_kernel_op_s *op) static void orangefs_devreq_add_op(struct orangefs_kernel_op_s *op)
{ {
int index = hash_func(op->tag, hash_table_size); int index = hash_func(op->tag, hash_table_size);
@ -48,9 +48,9 @@ static void pvfs2_devreq_add_op(struct pvfs2_kernel_op_s *op)
spin_unlock(&htable_ops_in_progress_lock); spin_unlock(&htable_ops_in_progress_lock);
} }
static struct pvfs2_kernel_op_s *pvfs2_devreq_remove_op(__u64 tag) static struct orangefs_kernel_op_s *orangefs_devreq_remove_op(__u64 tag)
{ {
struct pvfs2_kernel_op_s *op, *next; struct orangefs_kernel_op_s *op, *next;
int index; int index;
index = hash_func(tag, hash_table_size); index = hash_func(tag, hash_table_size);
@ -71,12 +71,12 @@ static struct pvfs2_kernel_op_s *pvfs2_devreq_remove_op(__u64 tag)
return NULL; return NULL;
} }
static int pvfs2_devreq_open(struct inode *inode, struct file *file) static int orangefs_devreq_open(struct inode *inode, struct file *file)
{ {
int ret = -EINVAL; int ret = -EINVAL;
if (!(file->f_flags & O_NONBLOCK)) { if (!(file->f_flags & O_NONBLOCK)) {
gossip_err("pvfs2: device cannot be opened in blocking mode\n"); gossip_err("orangefs: device cannot be opened in blocking mode\n");
goto out; goto out;
} }
ret = -EACCES; ret = -EACCES;
@ -100,14 +100,14 @@ out:
return ret; return ret;
} }
static ssize_t pvfs2_devreq_read(struct file *file, static ssize_t orangefs_devreq_read(struct file *file,
char __user *buf, char __user *buf,
size_t count, loff_t *offset) size_t count, loff_t *offset)
{ {
struct pvfs2_kernel_op_s *op, *temp; struct orangefs_kernel_op_s *op, *temp;
__s32 proto_ver = PVFS_KERNEL_PROTO_VERSION; __s32 proto_ver = ORANGEFS_KERNEL_PROTO_VERSION;
static __s32 magic = PVFS2_DEVREQ_MAGIC; static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
struct pvfs2_kernel_op_s *cur_op = NULL; struct orangefs_kernel_op_s *cur_op = NULL;
unsigned long ret; unsigned long ret;
/* We do not support blocking IO. */ /* We do not support blocking IO. */
@ -126,14 +126,14 @@ static ssize_t pvfs2_devreq_read(struct file *file,
} }
/* Get next op (if any) from top of list. */ /* Get next op (if any) from top of list. */
spin_lock(&pvfs2_request_list_lock); spin_lock(&orangefs_request_list_lock);
list_for_each_entry_safe(op, temp, &pvfs2_request_list, list) { list_for_each_entry_safe(op, temp, &orangefs_request_list, list) {
__s32 fsid; __s32 fsid;
/* This lock is held past the end of the loop when we break. */ /* This lock is held past the end of the loop when we break. */
spin_lock(&op->lock); spin_lock(&op->lock);
fsid = fsid_of_op(op); fsid = fsid_of_op(op);
if (fsid != PVFS_FS_ID_NULL) { if (fsid != ORANGEFS_FS_ID_NULL) {
int ret; int ret;
/* Skip ops whose filesystem needs to be mounted. */ /* Skip ops whose filesystem needs to be mounted. */
ret = fs_mount_pending(fsid); ret = fs_mount_pending(fsid);
@ -147,8 +147,8 @@ static ssize_t pvfs2_devreq_read(struct file *file,
* it is being mounted. */ * it is being mounted. */
/* XXX: is there a better way to detect this? */ /* XXX: is there a better way to detect this? */
} else if (ret == -1 && } else if (ret == -1 &&
!(op->upcall.type == PVFS2_VFS_OP_FS_MOUNT || !(op->upcall.type == ORANGEFS_VFS_OP_FS_MOUNT ||
op->upcall.type == PVFS2_VFS_OP_GETATTR)) { op->upcall.type == ORANGEFS_VFS_OP_GETATTR)) {
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"orangefs: skipping op tag %llu %s\n", "orangefs: skipping op tag %llu %s\n",
llu(op->tag), get_opname_string(op)); llu(op->tag), get_opname_string(op));
@ -173,7 +173,7 @@ static ssize_t pvfs2_devreq_read(struct file *file,
* found an op and must ask the client to try again later. * found an op and must ask the client to try again later.
*/ */
if (!cur_op) { if (!cur_op) {
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
return -EAGAIN; return -EAGAIN;
} }
@ -188,7 +188,7 @@ static ssize_t pvfs2_devreq_read(struct file *file,
gossip_err("orangefs: ERROR: Current op already queued.\n"); gossip_err("orangefs: ERROR: Current op already queued.\n");
list_del(&cur_op->list); list_del(&cur_op->list);
spin_unlock(&cur_op->lock); spin_unlock(&cur_op->lock);
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
return -EAGAIN; return -EAGAIN;
} }
@ -199,8 +199,8 @@ static ssize_t pvfs2_devreq_read(struct file *file,
set_op_state_inprogress(cur_op); set_op_state_inprogress(cur_op);
list_del(&cur_op->list); list_del(&cur_op->list);
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
pvfs2_devreq_add_op(cur_op); orangefs_devreq_add_op(cur_op);
spin_unlock(&cur_op->lock); spin_unlock(&cur_op->lock);
/* Push the upcall out. */ /* Push the upcall out. */
@ -214,7 +214,7 @@ static ssize_t pvfs2_devreq_read(struct file *file,
if (ret != 0) if (ret != 0)
goto error; goto error;
ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall, ret = copy_to_user(buf+2*sizeof(__s32)+sizeof(__u64), &cur_op->upcall,
sizeof(struct pvfs2_upcall_s)); sizeof(struct orangefs_upcall_s));
if (ret != 0) if (ret != 0)
goto error; goto error;
@ -227,23 +227,23 @@ error:
* device is released. * device is released.
*/ */
gossip_err("orangefs: Failed to copy data to user space\n"); gossip_err("orangefs: Failed to copy data to user space\n");
spin_lock(&pvfs2_request_list_lock); spin_lock(&orangefs_request_list_lock);
spin_lock(&cur_op->lock); spin_lock(&cur_op->lock);
set_op_state_waiting(cur_op); set_op_state_waiting(cur_op);
pvfs2_devreq_remove_op(cur_op->tag); orangefs_devreq_remove_op(cur_op->tag);
list_add(&cur_op->list, &pvfs2_request_list); list_add(&cur_op->list, &orangefs_request_list);
spin_unlock(&cur_op->lock); spin_unlock(&cur_op->lock);
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
return -EFAULT; return -EFAULT;
} }
/* Function for writev() callers into the device */ /* Function for writev() callers into the device */
static ssize_t pvfs2_devreq_writev(struct file *file, static ssize_t orangefs_devreq_writev(struct file *file,
const struct iovec *iov, const struct iovec *iov,
size_t count, size_t count,
loff_t *offset) loff_t *offset)
{ {
struct pvfs2_kernel_op_s *op = NULL; struct orangefs_kernel_op_s *op = NULL;
void *buffer = NULL; void *buffer = NULL;
void *ptr = NULL; void *ptr = NULL;
unsigned long i = 0; unsigned long i = 0;
@ -301,7 +301,7 @@ static ssize_t pvfs2_devreq_writev(struct file *file,
tag = *((__u64 *) ptr); tag = *((__u64 *) ptr);
ptr += sizeof(__u64); ptr += sizeof(__u64);
if (magic != PVFS2_DEVREQ_MAGIC) { if (magic != ORANGEFS_DEVREQ_MAGIC) {
gossip_err("Error: Device magic number does not match.\n"); gossip_err("Error: Device magic number does not match.\n");
dev_req_release(buffer); dev_req_release(buffer);
return -EPROTO; return -EPROTO;
@ -311,17 +311,17 @@ static ssize_t pvfs2_devreq_writev(struct file *file,
* proto_ver = 20902 for 2.9.2 * proto_ver = 20902 for 2.9.2
*/ */
op = pvfs2_devreq_remove_op(tag); op = orangefs_devreq_remove_op(tag);
if (op) { if (op) {
/* Increase ref count! */ /* Increase ref count! */
get_op(op); get_op(op);
/* cut off magic and tag from payload size */ /* cut off magic and tag from payload size */
payload_size -= (2 * sizeof(__s32) + sizeof(__u64)); payload_size -= (2 * sizeof(__s32) + sizeof(__u64));
if (payload_size <= sizeof(struct pvfs2_downcall_s)) if (payload_size <= sizeof(struct orangefs_downcall_s))
/* copy the passed in downcall into the op */ /* copy the passed in downcall into the op */
memcpy(&op->downcall, memcpy(&op->downcall,
ptr, ptr,
sizeof(struct pvfs2_downcall_s)); sizeof(struct orangefs_downcall_s));
else else
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"writev: Ignoring %d bytes\n", "writev: Ignoring %d bytes\n",
@ -392,8 +392,8 @@ static ssize_t pvfs2_devreq_writev(struct file *file,
* application reading/writing this device to return until * application reading/writing this device to return until
* the buffers are done being used. * the buffers are done being used.
*/ */
if (op->upcall.type == PVFS2_VFS_OP_FILE_IO && if (op->upcall.type == ORANGEFS_VFS_OP_FILE_IO &&
op->upcall.req.io.async_vfs_io == PVFS_VFS_SYNC_IO) { op->upcall.req.io.async_vfs_io == ORANGEFS_VFS_SYNC_IO) {
int timed_out = 0; int timed_out = 0;
DECLARE_WAITQUEUE(wait_entry, current); DECLARE_WAITQUEUE(wait_entry, current);
@ -473,10 +473,10 @@ static ssize_t pvfs2_devreq_writev(struct file *file,
return total_returned_size; return total_returned_size;
} }
static ssize_t pvfs2_devreq_write_iter(struct kiocb *iocb, static ssize_t orangefs_devreq_write_iter(struct kiocb *iocb,
struct iov_iter *iter) struct iov_iter *iter)
{ {
return pvfs2_devreq_writev(iocb->ki_filp, return orangefs_devreq_writev(iocb->ki_filp,
iter->iov, iter->iov,
iter->nr_segs, iter->nr_segs,
&iocb->ki_pos); &iocb->ki_pos);
@ -486,15 +486,15 @@ static ssize_t pvfs2_devreq_write_iter(struct kiocb *iocb,
static int mark_all_pending_mounts(void) static int mark_all_pending_mounts(void)
{ {
int unmounted = 1; int unmounted = 1;
struct pvfs2_sb_info_s *pvfs2_sb = NULL; struct orangefs_sb_info_s *orangefs_sb = NULL;
spin_lock(&pvfs2_superblocks_lock); spin_lock(&orangefs_superblocks_lock);
list_for_each_entry(pvfs2_sb, &pvfs2_superblocks, list) { list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
/* All of these file system require a remount */ /* All of these file system require a remount */
pvfs2_sb->mount_pending = 1; orangefs_sb->mount_pending = 1;
unmounted = 0; unmounted = 0;
} }
spin_unlock(&pvfs2_superblocks_lock); spin_unlock(&orangefs_superblocks_lock);
return unmounted; return unmounted;
} }
@ -507,16 +507,16 @@ static int mark_all_pending_mounts(void)
int fs_mount_pending(__s32 fsid) int fs_mount_pending(__s32 fsid)
{ {
int mount_pending = -1; int mount_pending = -1;
struct pvfs2_sb_info_s *pvfs2_sb = NULL; struct orangefs_sb_info_s *orangefs_sb = NULL;
spin_lock(&pvfs2_superblocks_lock); spin_lock(&orangefs_superblocks_lock);
list_for_each_entry(pvfs2_sb, &pvfs2_superblocks, list) { list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) {
if (pvfs2_sb->fs_id == fsid) { if (orangefs_sb->fs_id == fsid) {
mount_pending = pvfs2_sb->mount_pending; mount_pending = orangefs_sb->mount_pending;
break; break;
} }
} }
spin_unlock(&pvfs2_superblocks_lock); spin_unlock(&orangefs_superblocks_lock);
return mount_pending; return mount_pending;
} }
@ -525,10 +525,10 @@ int fs_mount_pending(__s32 fsid)
* Using the open_access_count variable, we enforce a reference count * Using the open_access_count variable, we enforce a reference count
* on this file so that it can be opened by only one process at a time. * on this file so that it can be opened by only one process at a time.
* the devreq_mutex is used to make sure all i/o has completed * the devreq_mutex is used to make sure all i/o has completed
* before we call pvfs_bufmap_finalize, and similar such tricky * before we call orangefs_bufmap_finalize, and similar such tricky
* situations * situations
*/ */
static int pvfs2_devreq_release(struct inode *inode, struct file *file) static int orangefs_devreq_release(struct inode *inode, struct file *file)
{ {
int unmounted = 0; int unmounted = 0;
@ -537,12 +537,12 @@ static int pvfs2_devreq_release(struct inode *inode, struct file *file)
__func__); __func__);
mutex_lock(&devreq_mutex); mutex_lock(&devreq_mutex);
pvfs_bufmap_finalize(); orangefs_bufmap_finalize();
open_access_count--; open_access_count--;
unmounted = mark_all_pending_mounts(); unmounted = mark_all_pending_mounts();
gossip_debug(GOSSIP_DEV_DEBUG, "PVFS2 Device Close: Filesystem(s) %s\n", gossip_debug(GOSSIP_DEV_DEBUG, "ORANGEFS Device Close: Filesystem(s) %s\n",
(unmounted ? "UNMOUNTED" : "MOUNTED")); (unmounted ? "UNMOUNTED" : "MOUNTED"));
mutex_unlock(&devreq_mutex); mutex_unlock(&devreq_mutex);
@ -578,17 +578,17 @@ int is_daemon_in_service(void)
static inline long check_ioctl_command(unsigned int command) static inline long check_ioctl_command(unsigned int command)
{ {
/* Check for valid ioctl codes */ /* Check for valid ioctl codes */
if (_IOC_TYPE(command) != PVFS_DEV_MAGIC) { if (_IOC_TYPE(command) != ORANGEFS_DEV_MAGIC) {
gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n", gossip_err("device ioctl magic numbers don't match! Did you rebuild pvfs2-client-core/libpvfs2? [cmd %x, magic %x != %x]\n",
command, command,
_IOC_TYPE(command), _IOC_TYPE(command),
PVFS_DEV_MAGIC); ORANGEFS_DEV_MAGIC);
return -EINVAL; return -EINVAL;
} }
/* and valid ioctl commands */ /* and valid ioctl commands */
if (_IOC_NR(command) >= PVFS_DEV_MAXNR || _IOC_NR(command) <= 0) { if (_IOC_NR(command) >= ORANGEFS_DEV_MAXNR || _IOC_NR(command) <= 0) {
gossip_err("Invalid ioctl command number [%d >= %d]\n", gossip_err("Invalid ioctl command number [%d >= %d]\n",
_IOC_NR(command), PVFS_DEV_MAXNR); _IOC_NR(command), ORANGEFS_DEV_MAXNR);
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
} }
return 0; return 0;
@ -596,46 +596,46 @@ static inline long check_ioctl_command(unsigned int command)
static long dispatch_ioctl_command(unsigned int command, unsigned long arg) static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
{ {
static __s32 magic = PVFS2_DEVREQ_MAGIC; static __s32 magic = ORANGEFS_DEVREQ_MAGIC;
static __s32 max_up_size = MAX_ALIGNED_DEV_REQ_UPSIZE; static __s32 max_up_size = MAX_ALIGNED_DEV_REQ_UPSIZE;
static __s32 max_down_size = MAX_ALIGNED_DEV_REQ_DOWNSIZE; static __s32 max_down_size = MAX_ALIGNED_DEV_REQ_DOWNSIZE;
struct PVFS_dev_map_desc user_desc; struct ORANGEFS_dev_map_desc user_desc;
int ret = 0; int ret = 0;
struct dev_mask_info_s mask_info = { 0 }; struct dev_mask_info_s mask_info = { 0 };
struct dev_mask2_info_s mask2_info = { 0, 0 }; struct dev_mask2_info_s mask2_info = { 0, 0 };
int upstream_kmod = 1; int upstream_kmod = 1;
struct list_head *tmp = NULL; struct list_head *tmp = NULL;
struct pvfs2_sb_info_s *pvfs2_sb = NULL; struct orangefs_sb_info_s *orangefs_sb = NULL;
/* mtmoore: add locking here */ /* mtmoore: add locking here */
switch (command) { switch (command) {
case PVFS_DEV_GET_MAGIC: case ORANGEFS_DEV_GET_MAGIC:
return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ? return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ?
-EIO : -EIO :
0); 0);
case PVFS_DEV_GET_MAX_UPSIZE: case ORANGEFS_DEV_GET_MAX_UPSIZE:
return ((put_user(max_up_size, return ((put_user(max_up_size,
(__s32 __user *) arg) == -EFAULT) ? (__s32 __user *) arg) == -EFAULT) ?
-EIO : -EIO :
0); 0);
case PVFS_DEV_GET_MAX_DOWNSIZE: case ORANGEFS_DEV_GET_MAX_DOWNSIZE:
return ((put_user(max_down_size, return ((put_user(max_down_size,
(__s32 __user *) arg) == -EFAULT) ? (__s32 __user *) arg) == -EFAULT) ?
-EIO : -EIO :
0); 0);
case PVFS_DEV_MAP: case ORANGEFS_DEV_MAP:
ret = copy_from_user(&user_desc, ret = copy_from_user(&user_desc,
(struct PVFS_dev_map_desc __user *) (struct ORANGEFS_dev_map_desc __user *)
arg, arg,
sizeof(struct PVFS_dev_map_desc)); sizeof(struct ORANGEFS_dev_map_desc));
return ret ? -EIO : pvfs_bufmap_initialize(&user_desc); return ret ? -EIO : orangefs_bufmap_initialize(&user_desc);
case PVFS_DEV_REMOUNT_ALL: case ORANGEFS_DEV_REMOUNT_ALL:
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"pvfs2_devreq_ioctl: got PVFS_DEV_REMOUNT_ALL\n"); "orangefs_devreq_ioctl: got ORANGEFS_DEV_REMOUNT_ALL\n");
/* /*
* remount all mounted pvfs2 volumes to regain the lost * remount all mounted orangefs volumes to regain the lost
* dynamic mount tables (if any) -- NOTE: this is done * dynamic mount tables (if any) -- NOTE: this is done
* without keeping the superblock list locked due to the * without keeping the superblock list locked due to the
* upcall/downcall waiting. also, the request semaphore is * upcall/downcall waiting. also, the request semaphore is
@ -647,30 +647,30 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
if (ret < 0) if (ret < 0)
return ret; return ret;
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"pvfs2_devreq_ioctl: priority remount in progress\n"); "orangefs_devreq_ioctl: priority remount in progress\n");
list_for_each(tmp, &pvfs2_superblocks) { list_for_each(tmp, &orangefs_superblocks) {
pvfs2_sb = orangefs_sb =
list_entry(tmp, struct pvfs2_sb_info_s, list); list_entry(tmp, struct orangefs_sb_info_s, list);
if (pvfs2_sb && (pvfs2_sb->sb)) { if (orangefs_sb && (orangefs_sb->sb)) {
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"Remounting SB %p\n", "Remounting SB %p\n",
pvfs2_sb); orangefs_sb);
ret = pvfs2_remount(pvfs2_sb->sb); ret = orangefs_remount(orangefs_sb->sb);
if (ret) { if (ret) {
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"SB %p remount failed\n", "SB %p remount failed\n",
pvfs2_sb); orangefs_sb);
break; break;
} }
} }
} }
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"pvfs2_devreq_ioctl: priority remount complete\n"); "orangefs_devreq_ioctl: priority remount complete\n");
mutex_unlock(&request_mutex); mutex_unlock(&request_mutex);
return ret; return ret;
case PVFS_DEV_UPSTREAM: case ORANGEFS_DEV_UPSTREAM:
ret = copy_to_user((void __user *)arg, ret = copy_to_user((void __user *)arg,
&upstream_kmod, &upstream_kmod,
sizeof(upstream_kmod)); sizeof(upstream_kmod));
@ -680,7 +680,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
else else
return ret; return ret;
case PVFS_DEV_CLIENT_MASK: case ORANGEFS_DEV_CLIENT_MASK:
ret = copy_from_user(&mask2_info, ret = copy_from_user(&mask2_info,
(void __user *)arg, (void __user *)arg,
sizeof(struct dev_mask2_info_s)); sizeof(struct dev_mask2_info_s));
@ -699,13 +699,13 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
return ret; return ret;
case PVFS_DEV_CLIENT_STRING: case ORANGEFS_DEV_CLIENT_STRING:
ret = copy_from_user(&client_debug_array_string, ret = copy_from_user(&client_debug_array_string,
(void __user *)arg, (void __user *)arg,
PVFS2_MAX_DEBUG_STRING_LEN); ORANGEFS_MAX_DEBUG_STRING_LEN);
if (ret != 0) { if (ret != 0) {
pr_info("%s: " pr_info("%s: "
"PVFS_DEV_CLIENT_STRING: copy_from_user failed" "ORANGEFS_DEV_CLIENT_STRING: copy_from_user failed"
"\n", "\n",
__func__); __func__);
return -EIO; return -EIO;
@ -753,13 +753,13 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
debugfs_remove(client_debug_dentry); debugfs_remove(client_debug_dentry);
pvfs2_client_debug_init(); orangefs_client_debug_init();
help_string_initialized++; help_string_initialized++;
return ret; return ret;
case PVFS_DEV_DEBUG: case ORANGEFS_DEV_DEBUG:
ret = copy_from_user(&mask_info, ret = copy_from_user(&mask_info,
(void __user *)arg, (void __user *)arg,
sizeof(mask_info)); sizeof(mask_info));
@ -774,21 +774,21 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
* the kernel debug mask was set when the * the kernel debug mask was set when the
* kernel module was loaded; don't override * kernel module was loaded; don't override
* it if the client-core was started without * it if the client-core was started without
* a value for PVFS2_KMODMASK. * a value for ORANGEFS_KMODMASK.
*/ */
return 0; return 0;
} }
debug_mask_to_string(&mask_info.mask_value, debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type); mask_info.mask_type);
gossip_debug_mask = mask_info.mask_value; gossip_debug_mask = mask_info.mask_value;
pr_info("PVFS: kernel debug mask has been modified to " pr_info("ORANGEFS: kernel debug mask has been modified to "
":%s: :%llx:\n", ":%s: :%llx:\n",
kernel_debug_string, kernel_debug_string,
(unsigned long long)gossip_debug_mask); (unsigned long long)gossip_debug_mask);
} else if (mask_info.mask_type == CLIENT_MASK) { } else if (mask_info.mask_type == CLIENT_MASK) {
debug_mask_to_string(&mask_info.mask_value, debug_mask_to_string(&mask_info.mask_value,
mask_info.mask_type); mask_info.mask_type);
pr_info("PVFS: client debug mask has been modified to" pr_info("ORANGEFS: client debug mask has been modified to"
":%s: :%llx:\n", ":%s: :%llx:\n",
client_debug_string, client_debug_string,
llu(mask_info.mask_value)); llu(mask_info.mask_value));
@ -805,7 +805,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg)
return -ENOIOCTLCMD; return -ENOIOCTLCMD;
} }
static long pvfs2_devreq_ioctl(struct file *file, static long orangefs_devreq_ioctl(struct file *file,
unsigned int command, unsigned long arg) unsigned int command, unsigned long arg)
{ {
long ret; long ret;
@ -820,8 +820,8 @@ static long pvfs2_devreq_ioctl(struct file *file,
#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
/* Compat structure for the PVFS_DEV_MAP ioctl */ /* Compat structure for the ORANGEFS_DEV_MAP ioctl */
struct PVFS_dev_map_desc32 { struct ORANGEFS_dev_map_desc32 {
compat_uptr_t ptr; compat_uptr_t ptr;
__s32 total_size; __s32 total_size;
__s32 size; __s32 size;
@ -830,12 +830,12 @@ struct PVFS_dev_map_desc32 {
static unsigned long translate_dev_map26(unsigned long args, long *error) static unsigned long translate_dev_map26(unsigned long args, long *error)
{ {
struct PVFS_dev_map_desc32 __user *p32 = (void __user *)args; struct ORANGEFS_dev_map_desc32 __user *p32 = (void __user *)args;
/* /*
* Depending on the architecture, allocate some space on the * Depending on the architecture, allocate some space on the
* user-call-stack based on our expected layout. * user-call-stack based on our expected layout.
*/ */
struct PVFS_dev_map_desc __user *p = struct ORANGEFS_dev_map_desc __user *p =
compat_alloc_user_space(sizeof(*p)); compat_alloc_user_space(sizeof(*p));
compat_uptr_t addr; compat_uptr_t addr;
@ -863,7 +863,7 @@ err:
* 32 bit user-space apps' ioctl handlers when kernel modules * 32 bit user-space apps' ioctl handlers when kernel modules
* is compiled as a 64 bit one * is compiled as a 64 bit one
*/ */
static long pvfs2_devreq_compat_ioctl(struct file *filp, unsigned int cmd, static long orangefs_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
unsigned long args) unsigned long args)
{ {
long ret; long ret;
@ -873,7 +873,7 @@ static long pvfs2_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
ret = check_ioctl_command(cmd); ret = check_ioctl_command(cmd);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (cmd == PVFS_DEV_MAP) { if (cmd == ORANGEFS_DEV_MAP) {
/* /*
* convert the arguments to what we expect internally * convert the arguments to what we expect internally
* in kernel space * in kernel space
@ -896,89 +896,89 @@ static long pvfs2_devreq_compat_ioctl(struct file *filp, unsigned int cmd,
* not noticed until we tried to compile on power pc... * not noticed until we tried to compile on power pc...
*/ */
#if (defined(CONFIG_COMPAT) && !defined(HAVE_REGISTER_IOCTL32_CONVERSION)) || !defined(CONFIG_COMPAT) #if (defined(CONFIG_COMPAT) && !defined(HAVE_REGISTER_IOCTL32_CONVERSION)) || !defined(CONFIG_COMPAT)
static int pvfs2_ioctl32_init(void) static int orangefs_ioctl32_init(void)
{ {
return 0; return 0;
} }
static void pvfs2_ioctl32_cleanup(void) static void orangefs_ioctl32_cleanup(void)
{ {
return; return;
} }
#endif #endif
/* the assigned character device major number */ /* the assigned character device major number */
static int pvfs2_dev_major; static int orangefs_dev_major;
/* /*
* Initialize pvfs2 device specific state: * Initialize orangefs device specific state:
* Must be called at module load time only * Must be called at module load time only
*/ */
int pvfs2_dev_init(void) int orangefs_dev_init(void)
{ {
int ret; int ret;
/* register the ioctl32 sub-system */ /* register the ioctl32 sub-system */
ret = pvfs2_ioctl32_init(); ret = orangefs_ioctl32_init();
if (ret < 0) if (ret < 0)
return ret; return ret;
/* register pvfs2-req device */ /* register orangefs-req device */
pvfs2_dev_major = register_chrdev(0, orangefs_dev_major = register_chrdev(0,
PVFS2_REQDEVICE_NAME, ORANGEFS_REQDEVICE_NAME,
&pvfs2_devreq_file_operations); &orangefs_devreq_file_operations);
if (pvfs2_dev_major < 0) { if (orangefs_dev_major < 0) {
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"Failed to register /dev/%s (error %d)\n", "Failed to register /dev/%s (error %d)\n",
PVFS2_REQDEVICE_NAME, pvfs2_dev_major); ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
pvfs2_ioctl32_cleanup(); orangefs_ioctl32_cleanup();
return pvfs2_dev_major; return orangefs_dev_major;
} }
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"*** /dev/%s character device registered ***\n", "*** /dev/%s character device registered ***\n",
PVFS2_REQDEVICE_NAME); ORANGEFS_REQDEVICE_NAME);
gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n", gossip_debug(GOSSIP_DEV_DEBUG, "'mknod /dev/%s c %d 0'.\n",
PVFS2_REQDEVICE_NAME, pvfs2_dev_major); ORANGEFS_REQDEVICE_NAME, orangefs_dev_major);
return 0; return 0;
} }
void pvfs2_dev_cleanup(void) void orangefs_dev_cleanup(void)
{ {
unregister_chrdev(pvfs2_dev_major, PVFS2_REQDEVICE_NAME); unregister_chrdev(orangefs_dev_major, ORANGEFS_REQDEVICE_NAME);
gossip_debug(GOSSIP_DEV_DEBUG, gossip_debug(GOSSIP_DEV_DEBUG,
"*** /dev/%s character device unregistered ***\n", "*** /dev/%s character device unregistered ***\n",
PVFS2_REQDEVICE_NAME); ORANGEFS_REQDEVICE_NAME);
/* unregister the ioctl32 sub-system */ /* unregister the ioctl32 sub-system */
pvfs2_ioctl32_cleanup(); orangefs_ioctl32_cleanup();
} }
static unsigned int pvfs2_devreq_poll(struct file *file, static unsigned int orangefs_devreq_poll(struct file *file,
struct poll_table_struct *poll_table) struct poll_table_struct *poll_table)
{ {
int poll_revent_mask = 0; int poll_revent_mask = 0;
if (open_access_count == 1) { if (open_access_count == 1) {
poll_wait(file, &pvfs2_request_list_waitq, poll_table); poll_wait(file, &orangefs_request_list_waitq, poll_table);
spin_lock(&pvfs2_request_list_lock); spin_lock(&orangefs_request_list_lock);
if (!list_empty(&pvfs2_request_list)) if (!list_empty(&orangefs_request_list))
poll_revent_mask |= POLL_IN; poll_revent_mask |= POLL_IN;
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
} }
return poll_revent_mask; return poll_revent_mask;
} }
const struct file_operations pvfs2_devreq_file_operations = { const struct file_operations orangefs_devreq_file_operations = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.read = pvfs2_devreq_read, .read = orangefs_devreq_read,
.write_iter = pvfs2_devreq_write_iter, .write_iter = orangefs_devreq_write_iter,
.open = pvfs2_devreq_open, .open = orangefs_devreq_open,
.release = pvfs2_devreq_release, .release = orangefs_devreq_release,
.unlocked_ioctl = pvfs2_devreq_ioctl, .unlocked_ioctl = orangefs_devreq_ioctl,
#ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */
.compat_ioctl = pvfs2_devreq_compat_ioctl, .compat_ioctl = orangefs_devreq_compat_ioctl,
#endif #endif
.poll = pvfs2_devreq_poll .poll = orangefs_devreq_poll
}; };

86
fs/orangefs/dir.c
View file

@ -10,7 +10,7 @@
struct readdir_handle_s { struct readdir_handle_s {
int buffer_index; int buffer_index;
struct pvfs2_readdir_response_s readdir_response; struct orangefs_readdir_response_s readdir_response;
void *dents_buf; 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. * decode routine needed by kmod to make sense of the shared page for readdirs.
*/ */
static long decode_dirents(char *ptr, size_t size, static long decode_dirents(char *ptr, size_t size,
struct pvfs2_readdir_response_s *readdir) struct orangefs_readdir_response_s *readdir)
{ {
int i; int i;
struct pvfs2_readdir_response_s *rd = struct orangefs_readdir_response_s *rd =
(struct pvfs2_readdir_response_s *) ptr; (struct orangefs_readdir_response_s *) ptr;
char *buf = 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; return -EINVAL;
readdir->token = rd->token; readdir->token = rd->token;
readdir->pvfs_dirent_outcount = rd->pvfs_dirent_outcount; readdir->orangefs_dirent_outcount = rd->orangefs_dirent_outcount;
readdir->dirent_array = kcalloc(readdir->pvfs_dirent_outcount, readdir->dirent_array = kcalloc(readdir->orangefs_dirent_outcount,
sizeof(*readdir->dirent_array), sizeof(*readdir->dirent_array),
GFP_KERNEL); GFP_KERNEL);
if (readdir->dirent_array == NULL) if (readdir->dirent_array == NULL)
return -ENOMEM; return -ENOMEM;
buf += offsetof(struct pvfs2_readdir_response_s, dirent_array); buf += offsetof(struct orangefs_readdir_response_s, dirent_array);
size -= offsetof(struct pvfs2_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; __u32 len;
if (size < 4) if (size < 4)
@ -60,7 +60,7 @@ static long decode_dirents(char *ptr, size_t size,
buf += len; buf += len;
readdir->dirent_array[i].khandle = readdir->dirent_array[i].khandle =
*(struct pvfs2_khandle *) buf; *(struct orangefs_khandle *) buf;
buf += 16; buf += 16;
} }
return buf - ptr; return buf - ptr;
@ -98,7 +98,7 @@ static long readdir_handle_ctor(struct readdir_handle_s *rhandle, void *buf,
return ret; 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) struct readdir_handle_s *rhandle)
{ {
if (rhandle == NULL) 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. * 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 ret = 0;
int buffer_index; int buffer_index;
/* /*
@ -136,8 +136,8 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
__u64 pos = 0; __u64 pos = 0;
ino_t ino = 0; ino_t ino = 0;
struct dentry *dentry = file->f_path.dentry; struct dentry *dentry = file->f_path.dentry;
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(dentry->d_inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode);
int buffer_full = 0; int buffer_full = 0;
struct readdir_handle_s rhandle; struct readdir_handle_s rhandle;
int i = 0; int i = 0;
@ -155,26 +155,26 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
pos = (__u64) ctx->pos; pos = (__u64) ctx->pos;
/* are we done? */ /* are we done? */
if (pos == PVFS_READDIR_END) { if (pos == ORANGEFS_READDIR_END) {
gossip_debug(GOSSIP_DIR_DEBUG, gossip_debug(GOSSIP_DIR_DEBUG,
"Skipping to termination path\n"); "Skipping to termination path\n");
return 0; return 0;
} }
gossip_debug(GOSSIP_DIR_DEBUG, 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)); dentry->d_name.name, llu(pos));
rhandle.buffer_index = -1; rhandle.buffer_index = -1;
rhandle.dents_buf = NULL; rhandle.dents_buf = NULL;
memset(&rhandle.readdir_response, 0, sizeof(rhandle.readdir_response)); 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) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->uses_shared_memory = 1; 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; new_op->upcall.req.readdir.max_dirent_count = MAX_DIRENT_COUNT_READDIR;
gossip_debug(GOSSIP_DIR_DEBUG, gossip_debug(GOSSIP_DIR_DEBUG,
@ -187,14 +187,14 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
get_new_buffer_index: get_new_buffer_index:
ret = readdir_index_get(&bufmap, &buffer_index); ret = readdir_index_get(&bufmap, &buffer_index);
if (ret < 0) { if (ret < 0) {
gossip_lerr("pvfs2_readdir: readdir_index_get() failure (%d)\n", gossip_lerr("orangefs_readdir: readdir_index_get() failure (%d)\n",
ret); ret);
goto out_free_op; goto out_free_op;
} }
new_op->upcall.req.readdir.buf_index = buffer_index; new_op->upcall.req.readdir.buf_index = buffer_index;
ret = service_operation(new_op, ret = service_operation(new_op,
"pvfs2_readdir", "orangefs_readdir",
get_interruptible_flag(dentry->d_inode)); get_interruptible_flag(dentry->d_inode));
gossip_debug(GOSSIP_DIR_DEBUG, gossip_debug(GOSSIP_DIR_DEBUG,
@ -238,7 +238,7 @@ get_new_buffer_index:
new_op->downcall.trailer_size, new_op->downcall.trailer_size,
buffer_index); buffer_index);
if (bytes_decoded < 0) { 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);
ret = bytes_decoded; ret = bytes_decoded;
readdir_index_put(bufmap, buffer_index); readdir_index_put(bufmap, buffer_index);
@ -246,7 +246,7 @@ get_new_buffer_index:
} }
if (bytes_decoded != new_op->downcall.trailer_size) { 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", "!= trailer size (%ld)\n",
bytes_decoded, bytes_decoded,
(long)new_op->downcall.trailer_size); (long)new_op->downcall.trailer_size);
@ -255,7 +255,7 @@ get_new_buffer_index:
} }
/* /*
* 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. * we need to have them represented.
*/ */
if (pos == 0) { if (pos == 0) {
@ -279,19 +279,19 @@ get_new_buffer_index:
} }
/* /*
* 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 * to prevent "finding" dot and dot-dot on any iteration
* other than the first. * other than the first.
*/ */
if (ctx->pos == PVFS_ITERATE_NEXT) if (ctx->pos == ORANGEFS_ITERATE_NEXT)
ctx->pos = 0; ctx->pos = 0;
for (i = ctx->pos; for (i = ctx->pos;
i < rhandle.readdir_response.pvfs_dirent_outcount; i < rhandle.readdir_response.orangefs_dirent_outcount;
i++) { i++) {
len = rhandle.readdir_response.dirent_array[i].d_length; len = rhandle.readdir_response.dirent_array[i].d_length;
current_entry = rhandle.readdir_response.dirent_array[i].d_name; 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)); &(rhandle.readdir_response.dirent_array[i].khandle));
gossip_debug(GOSSIP_DIR_DEBUG, gossip_debug(GOSSIP_DIR_DEBUG,
@ -323,28 +323,28 @@ get_new_buffer_index:
*/ */
if (ret) { if (ret) {
*ptoken = rhandle.readdir_response.token; *ptoken = rhandle.readdir_response.token;
ctx->pos = PVFS_ITERATE_NEXT; ctx->pos = ORANGEFS_ITERATE_NEXT;
} }
/* /*
* Did we hit the end of the directory? * 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) { !buffer_full) {
gossip_debug(GOSSIP_DIR_DEBUG, gossip_debug(GOSSIP_DIR_DEBUG,
"End of dir detected; setting ctx->pos to PVFS_READDIR_END.\n"); "End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n");
ctx->pos = PVFS_READDIR_END; ctx->pos = ORANGEFS_READDIR_END;
} }
out_destroy_handle: out_destroy_handle:
readdir_handle_dtor(bufmap, &rhandle); readdir_handle_dtor(bufmap, &rhandle);
out_free_op: out_free_op:
op_release(new_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; 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; __u64 *ptoken;
@ -353,21 +353,21 @@ static int pvfs2_dir_open(struct inode *inode, struct file *file)
return -ENOMEM; return -ENOMEM;
ptoken = file->private_data; ptoken = file->private_data;
*ptoken = PVFS_READDIR_START; *ptoken = ORANGEFS_READDIR_START;
return 0; 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); kfree(file->private_data);
return 0; return 0;
} }
/** PVFS2 implementation of VFS directory operations */ /** ORANGEFS implementation of VFS directory operations */
const struct file_operations pvfs2_dir_operations = { const struct file_operations orangefs_dir_operations = {
.read = generic_read_dir, .read = generic_read_dir,
.iterate = pvfs2_readdir, .iterate = orangefs_readdir,
.open = pvfs2_dir_open, .open = orangefs_dir_open,
.release = pvfs2_dir_release, .release = orangefs_dir_release,
}; };

84
fs/orangefs/downcall.h
View file

@ -15,42 +15,42 @@
* Sanitized the device-client core interaction * Sanitized the device-client core interaction
* for clean 32-64 bit usage * for clean 32-64 bit usage
*/ */
struct pvfs2_io_response { struct orangefs_io_response {
__s64 amt_complete; __s64 amt_complete;
}; };
struct pvfs2_lookup_response { struct orangefs_lookup_response {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
struct pvfs2_create_response { struct orangefs_create_response {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
struct pvfs2_symlink_response { struct orangefs_symlink_response {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
struct pvfs2_getattr_response { struct orangefs_getattr_response {
struct PVFS_sys_attr_s attributes; struct ORANGEFS_sys_attr_s attributes;
char link_target[PVFS2_NAME_LEN]; char link_target[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_mkdir_response { struct orangefs_mkdir_response {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
/* /*
* duplication of some system interface structures so that I don't have * duplication of some system interface structures so that I don't have
* to allocate extra memory * to allocate extra memory
*/ */
struct pvfs2_dirent { struct orangefs_dirent {
char *d_name; char *d_name;
int d_length; int d_length;
struct pvfs2_khandle khandle; struct orangefs_khandle khandle;
}; };
struct pvfs2_statfs_response { struct orangefs_statfs_response {
__s64 block_size; __s64 block_size;
__s64 blocks_total; __s64 blocks_total;
__s64 blocks_avail; __s64 blocks_avail;
@ -58,47 +58,47 @@ struct pvfs2_statfs_response {
__s64 files_avail; __s64 files_avail;
}; };
struct pvfs2_fs_mount_response { struct orangefs_fs_mount_response {
__s32 fs_id; __s32 fs_id;
__s32 id; __s32 id;
struct pvfs2_khandle root_khandle; struct orangefs_khandle root_khandle;
}; };
/* the getxattr response is the attribute value */ /* the getxattr response is the attribute value */
struct pvfs2_getxattr_response { struct orangefs_getxattr_response {
__s32 val_sz; __s32 val_sz;
__s32 __pad1; __s32 __pad1;
char val[PVFS_MAX_XATTR_VALUELEN]; char val[ORANGEFS_MAX_XATTR_VALUELEN];
}; };
/* the listxattr response is an array of attribute names */ /* the listxattr response is an array of attribute names */
struct pvfs2_listxattr_response { struct orangefs_listxattr_response {
__s32 returned_count; __s32 returned_count;
__s32 __pad1; __s32 __pad1;
__u64 token; __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 keylen;
__s32 __pad2; __s32 __pad2;
__s32 lengths[PVFS_MAX_XATTR_LISTLEN]; __s32 lengths[ORANGEFS_MAX_XATTR_LISTLEN];
}; };
struct pvfs2_param_response { struct orangefs_param_response {
__s64 value; __s64 value;
}; };
#define PERF_COUNT_BUF_SIZE 4096 #define PERF_COUNT_BUF_SIZE 4096
struct pvfs2_perf_count_response { struct orangefs_perf_count_response {
char buffer[PERF_COUNT_BUF_SIZE]; char buffer[PERF_COUNT_BUF_SIZE];
}; };
#define FS_KEY_BUF_SIZE 4096 #define FS_KEY_BUF_SIZE 4096
struct pvfs2_fs_key_response { struct orangefs_fs_key_response {
__s32 fs_keylen; __s32 fs_keylen;
__s32 __pad1; __s32 __pad1;
char fs_key[FS_KEY_BUF_SIZE]; char fs_key[FS_KEY_BUF_SIZE];
}; };
struct pvfs2_downcall_s { struct orangefs_downcall_s {
__s32 type; __s32 type;
__s32 status; __s32 status;
/* currently trailer is used only by readdir */ /* currently trailer is used only by readdir */
@ -106,28 +106,28 @@ struct pvfs2_downcall_s {
char *trailer_buf; char *trailer_buf;
union { union {
struct pvfs2_io_response io; struct orangefs_io_response io;
struct pvfs2_lookup_response lookup; struct orangefs_lookup_response lookup;
struct pvfs2_create_response create; struct orangefs_create_response create;
struct pvfs2_symlink_response sym; struct orangefs_symlink_response sym;
struct pvfs2_getattr_response getattr; struct orangefs_getattr_response getattr;
struct pvfs2_mkdir_response mkdir; struct orangefs_mkdir_response mkdir;
struct pvfs2_statfs_response statfs; struct orangefs_statfs_response statfs;
struct pvfs2_fs_mount_response fs_mount; struct orangefs_fs_mount_response fs_mount;
struct pvfs2_getxattr_response getxattr; struct orangefs_getxattr_response getxattr;
struct pvfs2_listxattr_response listxattr; struct orangefs_listxattr_response listxattr;
struct pvfs2_param_response param; struct orangefs_param_response param;
struct pvfs2_perf_count_response perf_count; struct orangefs_perf_count_response perf_count;
struct pvfs2_fs_key_response fs_key; struct orangefs_fs_key_response fs_key;
} resp; } resp;
}; };
struct pvfs2_readdir_response_s { struct orangefs_readdir_response_s {
__u64 token; __u64 token;
__u64 directory_version; __u64 directory_version;
__u32 __pad2; __u32 __pad2;
__u32 pvfs_dirent_outcount; __u32 orangefs_dirent_outcount;
struct pvfs2_dirent *dirent_array; struct orangefs_dirent *dirent_array;
}; };
#endif /* __DOWNCALL_H */ #endif /* __DOWNCALL_H */

182
fs/orangefs/file.c
View file

@ -29,7 +29,7 @@ do { \
* can futher be kernel-space or user-space addresses. * can futher be kernel-space or user-space addresses.
* or it can pointers to struct page's * or it can pointers to struct page's
*/ */
static int precopy_buffers(struct pvfs2_bufmap *bufmap, static int precopy_buffers(struct orangefs_bufmap *bufmap,
int buffer_index, int buffer_index,
struct iov_iter *iter, struct iov_iter *iter,
size_t total_size) size_t total_size)
@ -42,7 +42,7 @@ static int precopy_buffers(struct pvfs2_bufmap *bufmap,
if (total_size) { if (total_size) {
ret = pvfs_bufmap_copy_from_iovec(bufmap, ret = orangefs_bufmap_copy_from_iovec(bufmap,
iter, iter,
buffer_index, buffer_index,
total_size); total_size);
@ -66,7 +66,7 @@ static int precopy_buffers(struct pvfs2_bufmap *bufmap,
* can futher be kernel-space or user-space addresses. * can futher be kernel-space or user-space addresses.
* or it can pointers to struct page's * or it can pointers to struct page's
*/ */
static int postcopy_buffers(struct pvfs2_bufmap *bufmap, static int postcopy_buffers(struct orangefs_bufmap *bufmap,
int buffer_index, int buffer_index,
struct iov_iter *iter, struct iov_iter *iter,
size_t total_size) size_t total_size)
@ -78,7 +78,7 @@ static int postcopy_buffers(struct pvfs2_bufmap *bufmap,
* struct page pointers. * struct page pointers.
*/ */
if (total_size) { if (total_size) {
ret = pvfs_bufmap_copy_to_iovec(bufmap, ret = orangefs_bufmap_copy_to_iovec(bufmap,
iter, iter,
buffer_index, buffer_index,
total_size); total_size);
@ -93,34 +93,34 @@ static int postcopy_buffers(struct pvfs2_bufmap *bufmap,
/* /*
* Post and wait for the I/O upcall to finish * Post and wait for the I/O upcall to finish
*/ */
static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode, static ssize_t wait_for_direct_io(enum ORANGEFS_io_type type, struct inode *inode,
loff_t *offset, struct iov_iter *iter, loff_t *offset, struct iov_iter *iter,
size_t total_size, loff_t readahead_size) size_t total_size, loff_t readahead_size)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_khandle *handle = &pvfs2_inode->refn.khandle; struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
struct pvfs2_bufmap *bufmap = NULL; struct orangefs_bufmap *bufmap = NULL;
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
int buffer_index = -1; int buffer_index = -1;
ssize_t ret; ssize_t ret;
new_op = op_alloc(PVFS2_VFS_OP_FILE_IO); new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO);
if (!new_op) { if (!new_op) {
ret = -ENOMEM; ret = -ENOMEM;
goto out; goto out;
} }
/* synchronous I/O */ /* synchronous I/O */
new_op->upcall.req.io.async_vfs_io = PVFS_VFS_SYNC_IO; new_op->upcall.req.io.async_vfs_io = ORANGEFS_VFS_SYNC_IO;
new_op->upcall.req.io.readahead_size = readahead_size; new_op->upcall.req.io.readahead_size = readahead_size;
new_op->upcall.req.io.io_type = type; new_op->upcall.req.io.io_type = type;
new_op->upcall.req.io.refn = pvfs2_inode->refn; new_op->upcall.req.io.refn = orangefs_inode->refn;
populate_shared_memory: populate_shared_memory:
/* get a shared buffer index */ /* get a shared buffer index */
ret = pvfs_bufmap_get(&bufmap, &buffer_index); ret = orangefs_bufmap_get(&bufmap, &buffer_index);
if (ret < 0) { if (ret < 0) {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s: pvfs_bufmap_get failure (%ld)\n", "%s: orangefs_bufmap_get failure (%ld)\n",
__func__, (long)ret); __func__, (long)ret);
goto out; goto out;
} }
@ -146,7 +146,7 @@ populate_shared_memory:
* Stage 1: copy the buffers into client-core's address space * Stage 1: copy the buffers into client-core's address space
* precopy_buffers only pertains to writes. * precopy_buffers only pertains to writes.
*/ */
if (type == PVFS_IO_WRITE) { if (type == ORANGEFS_IO_WRITE) {
ret = precopy_buffers(bufmap, ret = precopy_buffers(bufmap,
buffer_index, buffer_index,
iter, iter,
@ -163,14 +163,14 @@ populate_shared_memory:
/* Stage 2: Service the I/O operation */ /* Stage 2: Service the I/O operation */
ret = service_operation(new_op, ret = service_operation(new_op,
type == PVFS_IO_WRITE ? type == ORANGEFS_IO_WRITE ?
"file_write" : "file_write" :
"file_read", "file_read",
get_interruptible_flag(inode)); get_interruptible_flag(inode));
/* /*
* If service_operation() returns -EAGAIN #and# the operation was * If service_operation() returns -EAGAIN #and# the operation was
* purged from pvfs2_request_list or htable_ops_in_progress, then * purged from orangefs_request_list or htable_ops_in_progress, then
* we know that the client was restarted, causing the shared memory * we know that the client was restarted, causing the shared memory
* area to be wiped clean. To restart a write operation in this * area to be wiped clean. To restart a write operation in this
* case, we must re-copy the data from the user's iovec to a NEW * case, we must re-copy the data from the user's iovec to a NEW
@ -178,7 +178,7 @@ populate_shared_memory:
* a new shared memory location. * a new shared memory location.
*/ */
if (ret == -EAGAIN && op_state_purged(new_op)) { if (ret == -EAGAIN && op_state_purged(new_op)) {
pvfs_bufmap_put(bufmap, buffer_index); orangefs_bufmap_put(bufmap, buffer_index);
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s:going to repopulate_shared_memory.\n", "%s:going to repopulate_shared_memory.\n",
__func__); __func__);
@ -199,7 +199,7 @@ populate_shared_memory:
else else
gossip_err("%s: error in %s handle %pU, returning %zd\n", gossip_err("%s: error in %s handle %pU, returning %zd\n",
__func__, __func__,
type == PVFS_IO_READ ? type == ORANGEFS_IO_READ ?
"read from" : "write to", "read from" : "write to",
handle, ret); handle, ret);
goto out; goto out;
@ -209,7 +209,7 @@ populate_shared_memory:
* Stage 3: Post copy buffers from client-core's address space * Stage 3: Post copy buffers from client-core's address space
* postcopy_buffers only pertains to reads. * postcopy_buffers only pertains to reads.
*/ */
if (type == PVFS_IO_READ) { if (type == ORANGEFS_IO_READ) {
ret = postcopy_buffers(bufmap, ret = postcopy_buffers(bufmap,
buffer_index, buffer_index,
iter, iter,
@ -243,7 +243,7 @@ populate_shared_memory:
out: out:
if (buffer_index >= 0) { if (buffer_index >= 0) {
pvfs_bufmap_put(bufmap, buffer_index); orangefs_bufmap_put(bufmap, buffer_index);
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s(%pU): PUT buffer_index %d\n", "%s(%pU): PUT buffer_index %d\n",
__func__, handle, buffer_index); __func__, handle, buffer_index);
@ -263,12 +263,12 @@ out:
* augmented/extended metadata attached to the file. * augmented/extended metadata attached to the file.
* Note: File extended attributes override any mount options. * Note: File extended attributes override any mount options.
*/ */
static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file, static ssize_t do_readv_writev(enum ORANGEFS_io_type type, struct file *file,
loff_t *offset, struct iov_iter *iter) loff_t *offset, struct iov_iter *iter)
{ {
struct inode *inode = file->f_mapping->host; struct inode *inode = file->f_mapping->host;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_khandle *handle = &pvfs2_inode->refn.khandle; struct orangefs_khandle *handle = &orangefs_inode->refn.khandle;
size_t count = iov_iter_count(iter); size_t count = iov_iter_count(iter);
ssize_t total_count = 0; ssize_t total_count = 0;
ssize_t ret = -EINVAL; ssize_t ret = -EINVAL;
@ -279,7 +279,7 @@ static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file,
handle, handle,
(int)count); (int)count);
if (type == PVFS_IO_WRITE) { if (type == ORANGEFS_IO_WRITE) {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s(%pU): proceeding with offset : %llu, " "%s(%pU): proceeding with offset : %llu, "
"size %d\n", "size %d\n",
@ -299,8 +299,8 @@ static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file,
size_t amt_complete; size_t amt_complete;
/* how much to transfer in this loop iteration */ /* how much to transfer in this loop iteration */
if (each_count > pvfs_bufmap_size_query()) if (each_count > orangefs_bufmap_size_query())
each_count = pvfs_bufmap_size_query(); each_count = orangefs_bufmap_size_query();
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s(%pU): size of each_count(%d)\n", "%s(%pU): size of each_count(%d)\n",
@ -346,10 +346,10 @@ static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file,
ret = total_count; ret = total_count;
out: out:
if (ret > 0) { if (ret > 0) {
if (type == PVFS_IO_READ) { if (type == ORANGEFS_IO_READ) {
file_accessed(file); file_accessed(file);
} else { } else {
SetMtimeFlag(pvfs2_inode); SetMtimeFlag(orangefs_inode);
inode->i_mtime = CURRENT_TIME; inode->i_mtime = CURRENT_TIME;
mark_inode_dirty_sync(inode); mark_inode_dirty_sync(inode);
} }
@ -368,19 +368,19 @@ out:
* Read data from a specified offset in a file (referenced by inode). * Read data from a specified offset in a file (referenced by inode).
* Data may be placed either in a user or kernel buffer. * Data may be placed either in a user or kernel buffer.
*/ */
ssize_t pvfs2_inode_read(struct inode *inode, ssize_t orangefs_inode_read(struct inode *inode,
struct iov_iter *iter, struct iov_iter *iter,
loff_t *offset, loff_t *offset,
loff_t readahead_size) loff_t readahead_size)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
size_t count = iov_iter_count(iter); size_t count = iov_iter_count(iter);
size_t bufmap_size; size_t bufmap_size;
ssize_t ret = -EINVAL; ssize_t ret = -EINVAL;
g_pvfs2_stats.reads++; g_orangefs_stats.reads++;
bufmap_size = pvfs_bufmap_size_query(); bufmap_size = orangefs_bufmap_size_query();
if (count > bufmap_size) { if (count > bufmap_size) {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s: count is too large (%zd/%zd)!\n", "%s: count is too large (%zd/%zd)!\n",
@ -391,11 +391,11 @@ ssize_t pvfs2_inode_read(struct inode *inode,
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s(%pU) %zd@%llu\n", "%s(%pU) %zd@%llu\n",
__func__, __func__,
&pvfs2_inode->refn.khandle, &orangefs_inode->refn.khandle,
count, count,
llu(*offset)); llu(*offset));
ret = wait_for_direct_io(PVFS_IO_READ, inode, offset, iter, ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, offset, iter,
count, readahead_size); count, readahead_size);
if (ret > 0) if (ret > 0)
*offset += ret; *offset += ret;
@ -403,13 +403,13 @@ ssize_t pvfs2_inode_read(struct inode *inode,
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s(%pU): Value(%zd) returned.\n", "%s(%pU): Value(%zd) returned.\n",
__func__, __func__,
&pvfs2_inode->refn.khandle, &orangefs_inode->refn.khandle,
ret); ret);
return ret; return ret;
} }
static ssize_t pvfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{ {
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
loff_t pos = *(&iocb->ki_pos); loff_t pos = *(&iocb->ki_pos);
@ -417,17 +417,17 @@ static ssize_t pvfs2_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
BUG_ON(iocb->private); BUG_ON(iocb->private);
gossip_debug(GOSSIP_FILE_DEBUG, "pvfs2_file_read_iter\n"); gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n");
g_pvfs2_stats.reads++; g_orangefs_stats.reads++;
rc = do_readv_writev(PVFS_IO_READ, file, &pos, iter); rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter);
iocb->ki_pos = pos; iocb->ki_pos = pos;
return rc; return rc;
} }
static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter) static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
{ {
struct file *file = iocb->ki_filp; struct file *file = iocb->ki_filp;
loff_t pos; loff_t pos;
@ -435,23 +435,23 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
BUG_ON(iocb->private); BUG_ON(iocb->private);
gossip_debug(GOSSIP_FILE_DEBUG, "pvfs2_file_write_iter\n"); gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_write_iter\n");
mutex_lock(&file->f_mapping->host->i_mutex); mutex_lock(&file->f_mapping->host->i_mutex);
/* Make sure generic_write_checks sees an up to date inode size. */ /* Make sure generic_write_checks sees an up to date inode size. */
if (file->f_flags & O_APPEND) { if (file->f_flags & O_APPEND) {
rc = pvfs2_inode_getattr(file->f_mapping->host, rc = orangefs_inode_getattr(file->f_mapping->host,
PVFS_ATTR_SYS_SIZE); ORANGEFS_ATTR_SYS_SIZE);
if (rc) { if (rc) {
gossip_err("%s: pvfs2_inode_getattr failed, rc:%zd:.\n", gossip_err("%s: orangefs_inode_getattr failed, rc:%zd:.\n",
__func__, rc); __func__, rc);
goto out; goto out;
} }
} }
if (file->f_pos > i_size_read(file->f_mapping->host)) if (file->f_pos > i_size_read(file->f_mapping->host))
pvfs2_i_size_write(file->f_mapping->host, file->f_pos); orangefs_i_size_write(file->f_mapping->host, file->f_pos);
rc = generic_write_checks(iocb, iter); rc = generic_write_checks(iocb, iter);
@ -468,7 +468,7 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
*/ */
pos = *(&iocb->ki_pos); pos = *(&iocb->ki_pos);
rc = do_readv_writev(PVFS_IO_WRITE, rc = do_readv_writev(ORANGEFS_IO_WRITE,
file, file,
&pos, &pos,
iter); iter);
@ -479,7 +479,7 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
} }
iocb->ki_pos = pos; iocb->ki_pos = pos;
g_pvfs2_stats.writes++; g_orangefs_stats.writes++;
out: out:
@ -490,14 +490,14 @@ out:
/* /*
* Perform a miscellaneous operation on a file. * Perform a miscellaneous operation on a file.
*/ */
static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) static long orangefs_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ {
int ret = -ENOTTY; int ret = -ENOTTY;
__u64 val = 0; __u64 val = 0;
unsigned long uval; unsigned long uval;
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_ioctl: called with cmd %d\n", "orangefs_ioctl: called with cmd %d\n",
cmd); cmd);
/* /*
@ -506,8 +506,8 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
*/ */
if (cmd == FS_IOC_GETFLAGS) { if (cmd == FS_IOC_GETFLAGS) {
val = 0; val = 0;
ret = pvfs2_inode_getxattr(file_inode(file), ret = orangefs_inode_getxattr(file_inode(file),
PVFS2_XATTR_NAME_DEFAULT_PREFIX, ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
"user.pvfs2.meta_hint", "user.pvfs2.meta_hint",
&val, sizeof(val)); &val, sizeof(val));
if (ret < 0 && ret != -ENODATA) if (ret < 0 && ret != -ENODATA)
@ -516,7 +516,7 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
val = 0; val = 0;
uval = val; uval = val;
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_ioctl: FS_IOC_GETFLAGS: %llu\n", "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n",
(unsigned long long)uval); (unsigned long long)uval);
return put_user(uval, (int __user *)arg); return put_user(uval, (int __user *)arg);
} else if (cmd == FS_IOC_SETFLAGS) { } else if (cmd == FS_IOC_SETFLAGS) {
@ -524,23 +524,23 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
if (get_user(uval, (int __user *)arg)) if (get_user(uval, (int __user *)arg))
return -EFAULT; return -EFAULT;
/* /*
* PVFS_MIRROR_FL is set internally when the mirroring mode * ORANGEFS_MIRROR_FL is set internally when the mirroring mode
* is turned on for a file. The user is not allowed to turn * is turned on for a file. The user is not allowed to turn
* on this bit, but the bit is present if the user first gets * on this bit, but the bit is present if the user first gets
* the flags and then updates the flags with some new * the flags and then updates the flags with some new
* settings. So, we ignore it in the following edit. bligon. * settings. So, we ignore it in the following edit. bligon.
*/ */
if ((uval & ~PVFS_MIRROR_FL) & if ((uval & ~ORANGEFS_MIRROR_FL) &
(~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) { (~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) {
gossip_err("pvfs2_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n"); gossip_err("orangefs_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n");
return -EINVAL; return -EINVAL;
} }
val = uval; val = uval;
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_ioctl: FS_IOC_SETFLAGS: %llu\n", "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n",
(unsigned long long)val); (unsigned long long)val);
ret = pvfs2_inode_setxattr(file_inode(file), ret = orangefs_inode_setxattr(file_inode(file),
PVFS2_XATTR_NAME_DEFAULT_PREFIX, ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
"user.pvfs2.meta_hint", "user.pvfs2.meta_hint",
&val, sizeof(val), 0); &val, sizeof(val), 0);
} }
@ -551,10 +551,10 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
/* /*
* Memory map a region of a file. * Memory map a region of a file.
*/ */
static int pvfs2_file_mmap(struct file *file, struct vm_area_struct *vma) static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma)
{ {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_file_mmap: called on %s\n", "orangefs_file_mmap: called on %s\n",
(file ? (file ?
(char *)file->f_path.dentry->d_name.name : (char *)file->f_path.dentry->d_name.name :
(char *)"Unknown")); (char *)"Unknown"));
@ -575,13 +575,13 @@ static int pvfs2_file_mmap(struct file *file, struct vm_area_struct *vma)
* *
* \note Not called when each file is closed. * \note Not called when each file is closed.
*/ */
static int pvfs2_file_release(struct inode *inode, struct file *file) static int orangefs_file_release(struct inode *inode, struct file *file)
{ {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_file_release: called on %s\n", "orangefs_file_release: called on %s\n",
file->f_path.dentry->d_name.name); file->f_path.dentry->d_name.name);
pvfs2_flush_inode(inode); orangefs_flush_inode(inode);
/* /*
* remove all associated inode pages from the page cache and mmap * remove all associated inode pages from the page cache and mmap
@ -599,35 +599,35 @@ static int pvfs2_file_release(struct inode *inode, struct file *file)
/* /*
* Push all data for a specific file onto permanent storage. * Push all data for a specific file onto permanent storage.
*/ */
static int pvfs2_fsync(struct file *file, static int orangefs_fsync(struct file *file,
loff_t start, loff_t start,
loff_t end, loff_t end,
int datasync) int datasync)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct pvfs2_inode_s *pvfs2_inode = struct orangefs_inode_s *orangefs_inode =
PVFS2_I(file->f_path.dentry->d_inode); ORANGEFS_I(file->f_path.dentry->d_inode);
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
/* required call */ /* required call */
filemap_write_and_wait_range(file->f_mapping, start, end); filemap_write_and_wait_range(file->f_mapping, start, end);
new_op = op_alloc(PVFS2_VFS_OP_FSYNC); new_op = op_alloc(ORANGEFS_VFS_OP_FSYNC);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.fsync.refn = pvfs2_inode->refn; new_op->upcall.req.fsync.refn = orangefs_inode->refn;
ret = service_operation(new_op, ret = service_operation(new_op,
"pvfs2_fsync", "orangefs_fsync",
get_interruptible_flag(file->f_path.dentry->d_inode)); get_interruptible_flag(file->f_path.dentry->d_inode));
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_fsync got return value of %d\n", "orangefs_fsync got return value of %d\n",
ret); ret);
op_release(new_op); op_release(new_op);
pvfs2_flush_inode(file->f_path.dentry->d_inode); orangefs_flush_inode(file->f_path.dentry->d_inode);
return ret; return ret;
} }
@ -640,36 +640,36 @@ static int pvfs2_fsync(struct file *file,
* Future upgrade could support SEEK_DATA and SEEK_HOLE but would * Future upgrade could support SEEK_DATA and SEEK_HOLE but would
* require much changes to the FS * require much changes to the FS
*/ */
static loff_t pvfs2_file_llseek(struct file *file, loff_t offset, int origin) static loff_t orangefs_file_llseek(struct file *file, loff_t offset, int origin)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct inode *inode = file->f_path.dentry->d_inode; struct inode *inode = file->f_path.dentry->d_inode;
if (!inode) { if (!inode) {
gossip_err("pvfs2_file_llseek: invalid inode (NULL)\n"); gossip_err("orangefs_file_llseek: invalid inode (NULL)\n");
return ret; return ret;
} }
if (origin == PVFS2_SEEK_END) { if (origin == ORANGEFS_SEEK_END) {
/* /*
* revalidate the inode's file size. * revalidate the inode's file size.
* NOTE: We are only interested in file size here, * NOTE: We are only interested in file size here,
* so we set mask accordingly. * so we set mask accordingly.
*/ */
ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_SIZE); ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_SIZE);
if (ret) { if (ret) {
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"%s:%s:%d calling make bad inode\n", "%s:%s:%d calling make bad inode\n",
__FILE__, __FILE__,
__func__, __func__,
__LINE__); __LINE__);
pvfs2_make_bad_inode(inode); orangefs_make_bad_inode(inode);
return ret; return ret;
} }
} }
gossip_debug(GOSSIP_FILE_DEBUG, gossip_debug(GOSSIP_FILE_DEBUG,
"pvfs2_file_llseek: offset is %ld | origin is %d" "orangefs_file_llseek: offset is %ld | origin is %d"
" | inode size is %lu\n", " | inode size is %lu\n",
(long)offset, (long)offset,
origin, origin,
@ -682,11 +682,11 @@ static loff_t pvfs2_file_llseek(struct file *file, loff_t offset, int origin)
* Support local locks (locks that only this kernel knows about) * Support local locks (locks that only this kernel knows about)
* if Orangefs was mounted -o local_lock. * if Orangefs was mounted -o local_lock.
*/ */
static int pvfs2_lock(struct file *filp, int cmd, struct file_lock *fl) static int orangefs_lock(struct file *filp, int cmd, struct file_lock *fl)
{ {
int rc = -EINVAL; int rc = -EINVAL;
if (PVFS2_SB(filp->f_inode->i_sb)->flags & PVFS2_OPT_LOCAL_LOCK) { if (ORANGEFS_SB(filp->f_inode->i_sb)->flags & ORANGEFS_OPT_LOCAL_LOCK) {
if (cmd == F_GETLK) { if (cmd == F_GETLK) {
rc = 0; rc = 0;
posix_test_lock(filp, fl); posix_test_lock(filp, fl);
@ -698,15 +698,15 @@ static int pvfs2_lock(struct file *filp, int cmd, struct file_lock *fl)
return rc; return rc;
} }
/** PVFS2 implementation of VFS file operations */ /** ORANGEFS implementation of VFS file operations */
const struct file_operations pvfs2_file_operations = { const struct file_operations orangefs_file_operations = {
.llseek = pvfs2_file_llseek, .llseek = orangefs_file_llseek,
.read_iter = pvfs2_file_read_iter, .read_iter = orangefs_file_read_iter,
.write_iter = pvfs2_file_write_iter, .write_iter = orangefs_file_write_iter,
.lock = pvfs2_lock, .lock = orangefs_lock,
.unlocked_ioctl = pvfs2_ioctl, .unlocked_ioctl = orangefs_ioctl,
.mmap = pvfs2_file_mmap, .mmap = orangefs_file_mmap,
.open = generic_file_open, .open = generic_file_open,
.release = pvfs2_file_release, .release = orangefs_file_release,
.fsync = pvfs2_fsync, .fsync = orangefs_fsync,
}; };

170
fs/orangefs/inode.c
View file

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

134
fs/orangefs/namei.c
View file

@ -14,34 +14,34 @@
/* /*
* Get a newly allocated inode to go with a negative dentry. * Get a newly allocated inode to go with a negative dentry.
*/ */
static int pvfs2_create(struct inode *dir, static int orangefs_create(struct inode *dir,
struct dentry *dentry, struct dentry *dentry,
umode_t mode, umode_t mode,
bool exclusive) bool exclusive)
{ {
struct pvfs2_inode_s *parent = PVFS2_I(dir); struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
struct inode *inode; struct inode *inode;
int ret; int ret;
gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__); gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__);
new_op = op_alloc(PVFS2_VFS_OP_CREATE); new_op = op_alloc(ORANGEFS_VFS_OP_CREATE);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.create.parent_refn = parent->refn; new_op->upcall.req.create.parent_refn = parent->refn;
fill_default_sys_attrs(new_op->upcall.req.create.attributes, fill_default_sys_attrs(new_op->upcall.req.create.attributes,
PVFS_TYPE_METAFILE, mode); ORANGEFS_TYPE_METAFILE, mode);
strncpy(new_op->upcall.req.create.d_name, strncpy(new_op->upcall.req.create.d_name,
dentry->d_name.name, PVFS2_NAME_LEN); dentry->d_name.name, ORANGEFS_NAME_LEN);
ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"Create Got PVFS2 handle %pU on fsid %d (ret=%d)\n", "Create Got ORANGEFS handle %pU on fsid %d (ret=%d)\n",
&new_op->downcall.resp.create.refn.khandle, &new_op->downcall.resp.create.refn.khandle,
new_op->downcall.resp.create.refn.fs_id, ret); new_op->downcall.resp.create.refn.fs_id, ret);
@ -52,10 +52,10 @@ static int pvfs2_create(struct inode *dir,
goto out; goto out;
} }
inode = pvfs2_new_inode(dir->i_sb, dir, S_IFREG | mode, 0, inode = orangefs_new_inode(dir->i_sb, dir, S_IFREG | mode, 0,
&new_op->downcall.resp.create.refn); &new_op->downcall.resp.create.refn);
if (IS_ERR(inode)) { if (IS_ERR(inode)) {
gossip_err("*** Failed to allocate pvfs2 file inode\n"); gossip_err("*** Failed to allocate orangefs file inode\n");
ret = PTR_ERR(inode); ret = PTR_ERR(inode);
goto out; goto out;
} }
@ -86,11 +86,11 @@ out:
* Attempt to resolve an object name (dentry->d_name), parent handle, and * Attempt to resolve an object name (dentry->d_name), parent handle, and
* fsid into a handle for the object. * fsid into a handle for the object.
*/ */
static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry, static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry,
unsigned int flags) unsigned int flags)
{ {
struct pvfs2_inode_s *parent = PVFS2_I(dir); struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
struct inode *inode; struct inode *inode;
struct dentry *res; struct dentry *res;
int ret = -EINVAL; int ret = -EINVAL;
@ -106,10 +106,10 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %s\n", gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %s\n",
__func__, dentry->d_name.name); __func__, dentry->d_name.name);
if (dentry->d_name.len > (PVFS2_NAME_LEN - 1)) if (dentry->d_name.len > (ORANGEFS_NAME_LEN - 1))
return ERR_PTR(-ENAMETOOLONG); return ERR_PTR(-ENAMETOOLONG);
new_op = op_alloc(PVFS2_VFS_OP_LOOKUP); new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP);
if (!new_op) if (!new_op)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
@ -123,7 +123,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
new_op->upcall.req.lookup.parent_refn = parent->refn; new_op->upcall.req.lookup.parent_refn = parent->refn;
strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name, strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"%s: doing lookup on %s under %pU,%d (follow=%s)\n", "%s: doing lookup on %s under %pU,%d (follow=%s)\n",
@ -132,7 +132,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
&new_op->upcall.req.lookup.parent_refn.khandle, &new_op->upcall.req.lookup.parent_refn.khandle,
new_op->upcall.req.lookup.parent_refn.fs_id, new_op->upcall.req.lookup.parent_refn.fs_id,
((new_op->upcall.req.lookup.sym_follow == ((new_op->upcall.req.lookup.sym_follow ==
PVFS2_LOOKUP_LINK_FOLLOW) ? "yes" : "no")); ORANGEFS_LOOKUP_LINK_FOLLOW) ? "yes" : "no"));
ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
@ -158,7 +158,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
*/ */
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"pvfs2_lookup: Adding *negative* dentry " "orangefs_lookup: Adding *negative* dentry "
"%p for %s\n", "%p for %s\n",
dentry, dentry,
dentry->d_name.name); dentry->d_name.name);
@ -173,7 +173,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
goto out; goto out;
} }
inode = pvfs2_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn); inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn);
if (IS_ERR(inode)) { if (IS_ERR(inode)) {
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"error %ld from iget\n", PTR_ERR(inode)); "error %ld from iget\n", PTR_ERR(inode));
@ -202,11 +202,11 @@ out:
} }
/* return 0 on success; non-zero otherwise */ /* return 0 on success; non-zero otherwise */
static int pvfs2_unlink(struct inode *dir, struct dentry *dentry) static int orangefs_unlink(struct inode *dir, struct dentry *dentry)
{ {
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
struct pvfs2_inode_s *parent = PVFS2_I(dir); struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret; int ret;
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
@ -218,15 +218,15 @@ static int pvfs2_unlink(struct inode *dir, struct dentry *dentry)
&parent->refn.khandle, &parent->refn.khandle,
parent->refn.fs_id); parent->refn.fs_id);
new_op = op_alloc(PVFS2_VFS_OP_REMOVE); new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.remove.parent_refn = parent->refn; new_op->upcall.req.remove.parent_refn = parent->refn;
strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name, strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
ret = service_operation(new_op, "pvfs2_unlink", ret = service_operation(new_op, "orangefs_unlink",
get_interruptible_flag(inode)); get_interruptible_flag(inode));
/* when request is serviced properly, free req op struct */ /* when request is serviced properly, free req op struct */
@ -242,12 +242,12 @@ static int pvfs2_unlink(struct inode *dir, struct dentry *dentry)
return ret; return ret;
} }
static int pvfs2_symlink(struct inode *dir, static int orangefs_symlink(struct inode *dir,
struct dentry *dentry, struct dentry *dentry,
const char *symname) const char *symname)
{ {
struct pvfs2_inode_s *parent = PVFS2_I(dir); struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
struct inode *inode; struct inode *inode;
int mode = 755; int mode = 755;
int ret; int ret;
@ -257,25 +257,25 @@ static int pvfs2_symlink(struct inode *dir,
if (!symname) if (!symname)
return -EINVAL; return -EINVAL;
new_op = op_alloc(PVFS2_VFS_OP_SYMLINK); new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.sym.parent_refn = parent->refn; new_op->upcall.req.sym.parent_refn = parent->refn;
fill_default_sys_attrs(new_op->upcall.req.sym.attributes, fill_default_sys_attrs(new_op->upcall.req.sym.attributes,
PVFS_TYPE_SYMLINK, ORANGEFS_TYPE_SYMLINK,
mode); mode);
strncpy(new_op->upcall.req.sym.entry_name, strncpy(new_op->upcall.req.sym.entry_name,
dentry->d_name.name, dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
strncpy(new_op->upcall.req.sym.target, symname, PVFS2_NAME_LEN); strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_LEN);
ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"Symlink Got PVFS2 handle %pU on fsid %d (ret=%d)\n", "Symlink Got ORANGEFS handle %pU on fsid %d (ret=%d)\n",
&new_op->downcall.resp.sym.refn.khandle, &new_op->downcall.resp.sym.refn.khandle,
new_op->downcall.resp.sym.refn.fs_id, ret); new_op->downcall.resp.sym.refn.fs_id, ret);
@ -286,11 +286,11 @@ static int pvfs2_symlink(struct inode *dir,
goto out; goto out;
} }
inode = pvfs2_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0, inode = orangefs_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0,
&new_op->downcall.resp.sym.refn); &new_op->downcall.resp.sym.refn);
if (IS_ERR(inode)) { if (IS_ERR(inode)) {
gossip_err gossip_err
("*** Failed to allocate pvfs2 symlink inode\n"); ("*** Failed to allocate orangefs symlink inode\n");
ret = PTR_ERR(inode); ret = PTR_ERR(inode);
goto out; goto out;
} }
@ -316,29 +316,29 @@ out:
return ret; return ret;
} }
static int pvfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
{ {
struct pvfs2_inode_s *parent = PVFS2_I(dir); struct orangefs_inode_s *parent = ORANGEFS_I(dir);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
struct inode *inode; struct inode *inode;
int ret; int ret;
new_op = op_alloc(PVFS2_VFS_OP_MKDIR); new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.mkdir.parent_refn = parent->refn; new_op->upcall.req.mkdir.parent_refn = parent->refn;
fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes, fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes,
PVFS_TYPE_DIRECTORY, mode); ORANGEFS_TYPE_DIRECTORY, mode);
strncpy(new_op->upcall.req.mkdir.d_name, strncpy(new_op->upcall.req.mkdir.d_name,
dentry->d_name.name, PVFS2_NAME_LEN); dentry->d_name.name, ORANGEFS_NAME_LEN);
ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"Mkdir Got PVFS2 handle %pU on fsid %d\n", "Mkdir Got ORANGEFS handle %pU on fsid %d\n",
&new_op->downcall.resp.mkdir.refn.khandle, &new_op->downcall.resp.mkdir.refn.khandle,
new_op->downcall.resp.mkdir.refn.fs_id); new_op->downcall.resp.mkdir.refn.fs_id);
@ -349,10 +349,10 @@ static int pvfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
goto out; goto out;
} }
inode = pvfs2_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0, inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0,
&new_op->downcall.resp.mkdir.refn); &new_op->downcall.resp.mkdir.refn);
if (IS_ERR(inode)) { if (IS_ERR(inode)) {
gossip_err("*** Failed to allocate pvfs2 dir inode\n"); gossip_err("*** Failed to allocate orangefs dir inode\n");
ret = PTR_ERR(inode); ret = PTR_ERR(inode);
goto out; goto out;
} }
@ -381,42 +381,42 @@ out:
return ret; return ret;
} }
static int pvfs2_rename(struct inode *old_dir, static int orangefs_rename(struct inode *old_dir,
struct dentry *old_dentry, struct dentry *old_dentry,
struct inode *new_dir, struct inode *new_dir,
struct dentry *new_dentry) struct dentry *new_dentry)
{ {
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret; int ret;
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"pvfs2_rename: called (%s/%s => %s/%s) ct=%d\n", "orangefs_rename: called (%s/%s => %s/%s) ct=%d\n",
old_dentry->d_parent->d_name.name, old_dentry->d_parent->d_name.name,
old_dentry->d_name.name, old_dentry->d_name.name,
new_dentry->d_parent->d_name.name, new_dentry->d_parent->d_name.name,
new_dentry->d_name.name, new_dentry->d_name.name,
d_count(new_dentry)); d_count(new_dentry));
new_op = op_alloc(PVFS2_VFS_OP_RENAME); new_op = op_alloc(ORANGEFS_VFS_OP_RENAME);
if (!new_op) if (!new_op)
return -EINVAL; return -EINVAL;
new_op->upcall.req.rename.old_parent_refn = PVFS2_I(old_dir)->refn; new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn;
new_op->upcall.req.rename.new_parent_refn = PVFS2_I(new_dir)->refn; new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn;
strncpy(new_op->upcall.req.rename.d_old_name, strncpy(new_op->upcall.req.rename.d_old_name,
old_dentry->d_name.name, old_dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
strncpy(new_op->upcall.req.rename.d_new_name, strncpy(new_op->upcall.req.rename.d_new_name,
new_dentry->d_name.name, new_dentry->d_name.name,
PVFS2_NAME_LEN); ORANGEFS_NAME_LEN);
ret = service_operation(new_op, ret = service_operation(new_op,
"pvfs2_rename", "orangefs_rename",
get_interruptible_flag(old_dentry->d_inode)); get_interruptible_flag(old_dentry->d_inode));
gossip_debug(GOSSIP_NAME_DEBUG, gossip_debug(GOSSIP_NAME_DEBUG,
"pvfs2_rename: got downcall status %d\n", "orangefs_rename: got downcall status %d\n",
ret); ret);
if (new_dentry->d_inode) if (new_dentry->d_inode)
@ -426,21 +426,21 @@ static int pvfs2_rename(struct inode *old_dir,
return ret; return ret;
} }
/* PVFS2 implementation of VFS inode operations for directories */ /* ORANGEFS implementation of VFS inode operations for directories */
struct inode_operations pvfs2_dir_inode_operations = { struct inode_operations orangefs_dir_inode_operations = {
.lookup = pvfs2_lookup, .lookup = orangefs_lookup,
.get_acl = pvfs2_get_acl, .get_acl = orangefs_get_acl,
.set_acl = pvfs2_set_acl, .set_acl = orangefs_set_acl,
.create = pvfs2_create, .create = orangefs_create,
.unlink = pvfs2_unlink, .unlink = orangefs_unlink,
.symlink = pvfs2_symlink, .symlink = orangefs_symlink,
.mkdir = pvfs2_mkdir, .mkdir = orangefs_mkdir,
.rmdir = pvfs2_unlink, .rmdir = orangefs_unlink,
.rename = pvfs2_rename, .rename = orangefs_rename,
.setattr = pvfs2_setattr, .setattr = orangefs_setattr,
.getattr = pvfs2_getattr, .getattr = orangefs_getattr,
.setxattr = generic_setxattr, .setxattr = generic_setxattr,
.getxattr = generic_getxattr, .getxattr = generic_getxattr,
.removexattr = generic_removexattr, .removexattr = generic_removexattr,
.listxattr = pvfs2_listxattr, .listxattr = orangefs_listxattr,
}; };

302
fs/orangefs/protocol.h
View file

@ -20,13 +20,13 @@ extern int cdm_element_count;
#define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help" #define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help"
#define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug" #define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug"
#define ORANGEFS_CLIENT_DEBUG_FILE "client-debug" #define ORANGEFS_CLIENT_DEBUG_FILE "client-debug"
#define PVFS2_VERBOSE "verbose" #define ORANGEFS_VERBOSE "verbose"
#define PVFS2_ALL "all" #define ORANGEFS_ALL "all"
/* pvfs2-config.h ***********************************************************/ /* pvfs2-config.h ***********************************************************/
#define PVFS2_VERSION_MAJOR 2 #define ORANGEFS_VERSION_MAJOR 2
#define PVFS2_VERSION_MINOR 9 #define ORANGEFS_VERSION_MINOR 9
#define PVFS2_VERSION_SUB 0 #define ORANGEFS_VERSION_SUB 0
/* khandle stuff ***********************************************************/ /* khandle stuff ***********************************************************/
@ -38,15 +38,15 @@ extern int cdm_element_count;
* The kernel module will always use the first four bytes and * The kernel module will always use the first four bytes and
* the last four bytes as an inum. * the last four bytes as an inum.
*/ */
struct pvfs2_khandle { struct orangefs_khandle {
unsigned char u[16]; unsigned char u[16];
} __aligned(8); } __aligned(8);
/* /*
* kernel version of an object ref. * kernel version of an object ref.
*/ */
struct pvfs2_object_kref { struct orangefs_object_kref {
struct pvfs2_khandle khandle; struct orangefs_khandle khandle;
__s32 fs_id; __s32 fs_id;
__s32 __pad1; __s32 __pad1;
}; };
@ -55,8 +55,8 @@ struct pvfs2_object_kref {
* compare 2 khandles assumes little endian thus from large address to * compare 2 khandles assumes little endian thus from large address to
* small address * small address
*/ */
static inline int PVFS_khandle_cmp(const struct pvfs2_khandle *kh1, static inline int ORANGEFS_khandle_cmp(const struct orangefs_khandle *kh1,
const struct pvfs2_khandle *kh2) const struct orangefs_khandle *kh2)
{ {
int i; int i;
@ -70,7 +70,7 @@ static inline int PVFS_khandle_cmp(const struct pvfs2_khandle *kh1,
return 0; return 0;
} }
static inline void PVFS_khandle_to(const struct pvfs2_khandle *kh, static inline void ORANGEFS_khandle_to(const struct orangefs_khandle *kh,
void *p, int size) void *p, int size)
{ {
@ -79,7 +79,7 @@ static inline void PVFS_khandle_to(const struct pvfs2_khandle *kh,
} }
static inline void PVFS_khandle_from(struct pvfs2_khandle *kh, static inline void ORANGEFS_khandle_from(struct orangefs_khandle *kh,
void *p, int size) void *p, int size)
{ {
memset(kh, 0, 16); memset(kh, 0, 16);
@ -88,152 +88,152 @@ static inline void PVFS_khandle_from(struct pvfs2_khandle *kh,
} }
/* pvfs2-types.h ************************************************************/ /* pvfs2-types.h ************************************************************/
typedef __u32 PVFS_uid; typedef __u32 ORANGEFS_uid;
typedef __u32 PVFS_gid; typedef __u32 ORANGEFS_gid;
typedef __s32 PVFS_fs_id; typedef __s32 ORANGEFS_fs_id;
typedef __u32 PVFS_permissions; typedef __u32 ORANGEFS_permissions;
typedef __u64 PVFS_time; typedef __u64 ORANGEFS_time;
typedef __s64 PVFS_size; typedef __s64 ORANGEFS_size;
typedef __u64 PVFS_flags; typedef __u64 ORANGEFS_flags;
typedef __u64 PVFS_ds_position; typedef __u64 ORANGEFS_ds_position;
typedef __s32 PVFS_error; typedef __s32 ORANGEFS_error;
typedef __s64 PVFS_offset; typedef __s64 ORANGEFS_offset;
#define PVFS2_SUPER_MAGIC 0x20030528 #define ORANGEFS_SUPER_MAGIC 0x20030528
/* /*
* PVFS2 error codes are a signed 32-bit integer. Error codes are negative, but * ORANGEFS error codes are a signed 32-bit integer. Error codes are negative, but
* the sign is stripped before decoding. * the sign is stripped before decoding.
*/ */
/* Bit 31 is not used since it is the sign. */ /* Bit 31 is not used since it is the sign. */
/* /*
* Bit 30 specifies that this is a PVFS2 error. A PVFS2 error is either an * Bit 30 specifies that this is a ORANGEFS error. A ORANGEFS error is either an
* encoded errno value or a PVFS2 protocol error. * encoded errno value or a ORANGEFS protocol error.
*/ */
#define PVFS_ERROR_BIT (1 << 30) #define ORANGEFS_ERROR_BIT (1 << 30)
/* /*
* Bit 29 specifies that this is a PVFS2 protocol error and not an encoded * Bit 29 specifies that this is a ORANGEFS protocol error and not an encoded
* errno value. * errno value.
*/ */
#define PVFS_NON_ERRNO_ERROR_BIT (1 << 29) #define ORANGEFS_NON_ERRNO_ERROR_BIT (1 << 29)
/* /*
* Bits 9, 8, and 7 specify the error class, which encodes the section of * Bits 9, 8, and 7 specify the error class, which encodes the section of
* server code the error originated in for logging purposes. It is not used * server code the error originated in for logging purposes. It is not used
* in the kernel except to be masked out. * in the kernel except to be masked out.
*/ */
#define PVFS_ERROR_CLASS_BITS 0x380 #define ORANGEFS_ERROR_CLASS_BITS 0x380
/* Bits 6 - 0 are reserved for the actual error code. */ /* Bits 6 - 0 are reserved for the actual error code. */
#define PVFS_ERROR_NUMBER_BITS 0x7f #define ORANGEFS_ERROR_NUMBER_BITS 0x7f
/* Encoded errno values are decoded by PINT_errno_mapping in pvfs2-utils.c. */ /* Encoded errno values are decoded by PINT_errno_mapping in pvfs2-utils.c. */
/* Our own PVFS2 protocol error codes. */ /* Our own ORANGEFS protocol error codes. */
#define PVFS_ECANCEL (1|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_ECANCEL (1|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_EDEVINIT (2|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_EDEVINIT (2|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_EDETAIL (3|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_EDETAIL (3|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_EHOSTNTFD (4|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_EHOSTNTFD (4|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_EADDRNTFD (5|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_EADDRNTFD (5|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_ENORECVR (6|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_ENORECVR (6|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_ETRYAGAIN (7|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_ETRYAGAIN (7|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_ENOTPVFS (8|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_ENOTPVFS (8|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
#define PVFS_ESECURITY (9|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) #define ORANGEFS_ESECURITY (9|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT)
/* permission bits */ /* permission bits */
#define PVFS_O_EXECUTE (1 << 0) #define ORANGEFS_O_EXECUTE (1 << 0)
#define PVFS_O_WRITE (1 << 1) #define ORANGEFS_O_WRITE (1 << 1)
#define PVFS_O_READ (1 << 2) #define ORANGEFS_O_READ (1 << 2)
#define PVFS_G_EXECUTE (1 << 3) #define ORANGEFS_G_EXECUTE (1 << 3)
#define PVFS_G_WRITE (1 << 4) #define ORANGEFS_G_WRITE (1 << 4)
#define PVFS_G_READ (1 << 5) #define ORANGEFS_G_READ (1 << 5)
#define PVFS_U_EXECUTE (1 << 6) #define ORANGEFS_U_EXECUTE (1 << 6)
#define PVFS_U_WRITE (1 << 7) #define ORANGEFS_U_WRITE (1 << 7)
#define PVFS_U_READ (1 << 8) #define ORANGEFS_U_READ (1 << 8)
/* no PVFS_U_VTX (sticky bit) */ /* no ORANGEFS_U_VTX (sticky bit) */
#define PVFS_G_SGID (1 << 10) #define ORANGEFS_G_SGID (1 << 10)
#define PVFS_U_SUID (1 << 11) #define ORANGEFS_U_SUID (1 << 11)
/* definition taken from stdint.h */ /* definition taken from stdint.h */
#define INT32_MAX (2147483647) #define INT32_MAX (2147483647)
#define PVFS_ITERATE_START (INT32_MAX - 1) #define ORANGEFS_ITERATE_START (INT32_MAX - 1)
#define PVFS_ITERATE_END (INT32_MAX - 2) #define ORANGEFS_ITERATE_END (INT32_MAX - 2)
#define PVFS_ITERATE_NEXT (INT32_MAX - 3) #define ORANGEFS_ITERATE_NEXT (INT32_MAX - 3)
#define PVFS_READDIR_START PVFS_ITERATE_START #define ORANGEFS_READDIR_START ORANGEFS_ITERATE_START
#define PVFS_READDIR_END PVFS_ITERATE_END #define ORANGEFS_READDIR_END ORANGEFS_ITERATE_END
#define PVFS_IMMUTABLE_FL FS_IMMUTABLE_FL #define ORANGEFS_IMMUTABLE_FL FS_IMMUTABLE_FL
#define PVFS_APPEND_FL FS_APPEND_FL #define ORANGEFS_APPEND_FL FS_APPEND_FL
#define PVFS_NOATIME_FL FS_NOATIME_FL #define ORANGEFS_NOATIME_FL FS_NOATIME_FL
#define PVFS_MIRROR_FL 0x01000000ULL #define ORANGEFS_MIRROR_FL 0x01000000ULL
#define PVFS_O_EXECUTE (1 << 0) #define ORANGEFS_O_EXECUTE (1 << 0)
#define PVFS_FS_ID_NULL ((__s32)0) #define ORANGEFS_FS_ID_NULL ((__s32)0)
#define PVFS_ATTR_SYS_UID (1 << 0) #define ORANGEFS_ATTR_SYS_UID (1 << 0)
#define PVFS_ATTR_SYS_GID (1 << 1) #define ORANGEFS_ATTR_SYS_GID (1 << 1)
#define PVFS_ATTR_SYS_PERM (1 << 2) #define ORANGEFS_ATTR_SYS_PERM (1 << 2)
#define PVFS_ATTR_SYS_ATIME (1 << 3) #define ORANGEFS_ATTR_SYS_ATIME (1 << 3)
#define PVFS_ATTR_SYS_CTIME (1 << 4) #define ORANGEFS_ATTR_SYS_CTIME (1 << 4)
#define PVFS_ATTR_SYS_MTIME (1 << 5) #define ORANGEFS_ATTR_SYS_MTIME (1 << 5)
#define PVFS_ATTR_SYS_TYPE (1 << 6) #define ORANGEFS_ATTR_SYS_TYPE (1 << 6)
#define PVFS_ATTR_SYS_ATIME_SET (1 << 7) #define ORANGEFS_ATTR_SYS_ATIME_SET (1 << 7)
#define PVFS_ATTR_SYS_MTIME_SET (1 << 8) #define ORANGEFS_ATTR_SYS_MTIME_SET (1 << 8)
#define PVFS_ATTR_SYS_SIZE (1 << 20) #define ORANGEFS_ATTR_SYS_SIZE (1 << 20)
#define PVFS_ATTR_SYS_LNK_TARGET (1 << 24) #define ORANGEFS_ATTR_SYS_LNK_TARGET (1 << 24)
#define PVFS_ATTR_SYS_DFILE_COUNT (1 << 25) #define ORANGEFS_ATTR_SYS_DFILE_COUNT (1 << 25)
#define PVFS_ATTR_SYS_DIRENT_COUNT (1 << 26) #define ORANGEFS_ATTR_SYS_DIRENT_COUNT (1 << 26)
#define PVFS_ATTR_SYS_BLKSIZE (1 << 28) #define ORANGEFS_ATTR_SYS_BLKSIZE (1 << 28)
#define PVFS_ATTR_SYS_MIRROR_COPIES_COUNT (1 << 29) #define ORANGEFS_ATTR_SYS_MIRROR_COPIES_COUNT (1 << 29)
#define PVFS_ATTR_SYS_COMMON_ALL \ #define ORANGEFS_ATTR_SYS_COMMON_ALL \
(PVFS_ATTR_SYS_UID | \ (ORANGEFS_ATTR_SYS_UID | \
PVFS_ATTR_SYS_GID | \ ORANGEFS_ATTR_SYS_GID | \
PVFS_ATTR_SYS_PERM | \ ORANGEFS_ATTR_SYS_PERM | \
PVFS_ATTR_SYS_ATIME | \ ORANGEFS_ATTR_SYS_ATIME | \
PVFS_ATTR_SYS_CTIME | \ ORANGEFS_ATTR_SYS_CTIME | \
PVFS_ATTR_SYS_MTIME | \ ORANGEFS_ATTR_SYS_MTIME | \
PVFS_ATTR_SYS_TYPE) ORANGEFS_ATTR_SYS_TYPE)
#define PVFS_ATTR_SYS_ALL_SETABLE \ #define ORANGEFS_ATTR_SYS_ALL_SETABLE \
(PVFS_ATTR_SYS_COMMON_ALL-PVFS_ATTR_SYS_TYPE) (ORANGEFS_ATTR_SYS_COMMON_ALL-ORANGEFS_ATTR_SYS_TYPE)
#define PVFS_ATTR_SYS_ALL_NOHINT \ #define ORANGEFS_ATTR_SYS_ALL_NOHINT \
(PVFS_ATTR_SYS_COMMON_ALL | \ (ORANGEFS_ATTR_SYS_COMMON_ALL | \
PVFS_ATTR_SYS_SIZE | \ ORANGEFS_ATTR_SYS_SIZE | \
PVFS_ATTR_SYS_LNK_TARGET | \ ORANGEFS_ATTR_SYS_LNK_TARGET | \
PVFS_ATTR_SYS_DFILE_COUNT | \ ORANGEFS_ATTR_SYS_DFILE_COUNT | \
PVFS_ATTR_SYS_MIRROR_COPIES_COUNT | \ ORANGEFS_ATTR_SYS_MIRROR_COPIES_COUNT | \
PVFS_ATTR_SYS_DIRENT_COUNT | \ ORANGEFS_ATTR_SYS_DIRENT_COUNT | \
PVFS_ATTR_SYS_BLKSIZE) ORANGEFS_ATTR_SYS_BLKSIZE)
#define PVFS_XATTR_REPLACE 0x2 #define ORANGEFS_XATTR_REPLACE 0x2
#define PVFS_XATTR_CREATE 0x1 #define ORANGEFS_XATTR_CREATE 0x1
#define PVFS_MAX_SERVER_ADDR_LEN 256 #define ORANGEFS_MAX_SERVER_ADDR_LEN 256
#define PVFS_NAME_MAX 256 #define ORANGEFS_NAME_MAX 256
/* /*
* max extended attribute name len as imposed by the VFS and exploited for the * max extended attribute name len as imposed by the VFS and exploited for the
* upcall request types. * upcall request types.
* NOTE: Please retain them as multiples of 8 even if you wish to change them * NOTE: Please retain them as multiples of 8 even if you wish to change them
* This is *NECESSARY* for supporting 32 bit user-space binaries on a 64-bit * This is *NECESSARY* for supporting 32 bit user-space binaries on a 64-bit
* kernel. Due to implementation within DBPF, this really needs to be * kernel. Due to implementation within DBPF, this really needs to be
* PVFS_NAME_MAX, which it was the same value as, but no reason to let it * ORANGEFS_NAME_MAX, which it was the same value as, but no reason to let it
* break if that changes in the future. * break if that changes in the future.
*/ */
#define PVFS_MAX_XATTR_NAMELEN PVFS_NAME_MAX /* Not the same as #define ORANGEFS_MAX_XATTR_NAMELEN ORANGEFS_NAME_MAX /* Not the same as
* XATTR_NAME_MAX defined * XATTR_NAME_MAX defined
* by <linux/xattr.h> * by <linux/xattr.h>
*/ */
#define PVFS_MAX_XATTR_VALUELEN 8192 /* Not the same as XATTR_SIZE_MAX #define ORANGEFS_MAX_XATTR_VALUELEN 8192 /* Not the same as XATTR_SIZE_MAX
* defined by <linux/xattr.h> * defined by <linux/xattr.h>
*/ */
#define PVFS_MAX_XATTR_LISTLEN 16 /* Not the same as XATTR_LIST_MAX #define ORANGEFS_MAX_XATTR_LISTLEN 16 /* Not the same as XATTR_LIST_MAX
* defined by <linux/xattr.h> * defined by <linux/xattr.h>
*/ */
/* /*
* PVFS I/O operation types, used in both system and server interfaces. * ORANGEFS I/O operation types, used in both system and server interfaces.
*/ */
enum PVFS_io_type { enum ORANGEFS_io_type {
PVFS_IO_READ = 1, ORANGEFS_IO_READ = 1,
PVFS_IO_WRITE = 2 ORANGEFS_IO_WRITE = 2
}; };
/* /*
@ -241,21 +241,21 @@ enum PVFS_io_type {
* batch and low threshold sizes may need to be modified to reflect this * batch and low threshold sizes may need to be modified to reflect this
* change. * change.
*/ */
enum pvfs2_ds_type { enum orangefs_ds_type {
PVFS_TYPE_NONE = 0, ORANGEFS_TYPE_NONE = 0,
PVFS_TYPE_METAFILE = (1 << 0), ORANGEFS_TYPE_METAFILE = (1 << 0),
PVFS_TYPE_DATAFILE = (1 << 1), ORANGEFS_TYPE_DATAFILE = (1 << 1),
PVFS_TYPE_DIRECTORY = (1 << 2), ORANGEFS_TYPE_DIRECTORY = (1 << 2),
PVFS_TYPE_SYMLINK = (1 << 3), ORANGEFS_TYPE_SYMLINK = (1 << 3),
PVFS_TYPE_DIRDATA = (1 << 4), ORANGEFS_TYPE_DIRDATA = (1 << 4),
PVFS_TYPE_INTERNAL = (1 << 5) /* for the server's private use */ ORANGEFS_TYPE_INTERNAL = (1 << 5) /* for the server's private use */
}; };
/* /*
* PVFS_certificate simply stores a buffer with the buffer size. * ORANGEFS_certificate simply stores a buffer with the buffer size.
* The buffer can be converted to an OpenSSL X509 struct for use. * The buffer can be converted to an OpenSSL X509 struct for use.
*/ */
struct PVFS_certificate { struct ORANGEFS_certificate {
__u32 buf_size; __u32 buf_size;
unsigned char *buf; unsigned char *buf;
}; };
@ -264,7 +264,7 @@ struct PVFS_certificate {
* A credential identifies a user and is signed by the client/user * A credential identifies a user and is signed by the client/user
* private key. * private key.
*/ */
struct PVFS_credential { struct ORANGEFS_credential {
__u32 userid; /* user id */ __u32 userid; /* user id */
__u32 num_groups; /* length of group_array */ __u32 num_groups; /* length of group_array */
__u32 *group_array; /* groups for which the user is a member */ __u32 *group_array; /* groups for which the user is a member */
@ -272,25 +272,25 @@ struct PVFS_credential {
__u64 timeout; /* seconds after epoch to time out */ __u64 timeout; /* seconds after epoch to time out */
__u32 sig_size; /* length of the signature in bytes */ __u32 sig_size; /* length of the signature in bytes */
unsigned char *signature; /* digital signature */ unsigned char *signature; /* digital signature */
struct PVFS_certificate certificate; /* user certificate buffer */ struct ORANGEFS_certificate certificate; /* user certificate buffer */
}; };
#define extra_size_PVFS_credential (PVFS_REQ_LIMIT_GROUPS * \ #define extra_size_ORANGEFS_credential (ORANGEFS_REQ_LIMIT_GROUPS * \
sizeof(__u32) + \ sizeof(__u32) + \
PVFS_REQ_LIMIT_ISSUER + \ ORANGEFS_REQ_LIMIT_ISSUER + \
PVFS_REQ_LIMIT_SIGNATURE + \ ORANGEFS_REQ_LIMIT_SIGNATURE + \
extra_size_PVFS_certificate) extra_size_ORANGEFS_certificate)
/* This structure is used by the VFS-client interaction alone */ /* This structure is used by the VFS-client interaction alone */
struct PVFS_keyval_pair { struct ORANGEFS_keyval_pair {
char key[PVFS_MAX_XATTR_NAMELEN]; char key[ORANGEFS_MAX_XATTR_NAMELEN];
__s32 key_sz; /* __s32 for portable, fixed-size structures */ __s32 key_sz; /* __s32 for portable, fixed-size structures */
__s32 val_sz; __s32 val_sz;
char val[PVFS_MAX_XATTR_VALUELEN]; char val[ORANGEFS_MAX_XATTR_VALUELEN];
}; };
/* pvfs2-sysint.h ***********************************************************/ /* pvfs2-sysint.h ***********************************************************/
/* Describes attributes for a file, directory, or symlink. */ /* Describes attributes for a file, directory, or symlink. */
struct PVFS_sys_attr_s { struct ORANGEFS_sys_attr_s {
__u32 owner; __u32 owner;
__u32 group; __u32 group;
__u32 perms; __u32 perms;
@ -323,18 +323,18 @@ struct PVFS_sys_attr_s {
char *dist_params; char *dist_params;
__s64 dirent_count; __s64 dirent_count;
enum pvfs2_ds_type objtype; enum orangefs_ds_type objtype;
__u64 flags; __u64 flags;
__u32 mask; __u32 mask;
__s64 blksize; __s64 blksize;
}; };
#define PVFS2_LOOKUP_LINK_NO_FOLLOW 0 #define ORANGEFS_LOOKUP_LINK_NO_FOLLOW 0
#define PVFS2_LOOKUP_LINK_FOLLOW 1 #define ORANGEFS_LOOKUP_LINK_FOLLOW 1
/* pint-dev.h ***************************************************************/ /* pint-dev.h ***************************************************************/
/* parameter structure used in PVFS_DEV_DEBUG ioctl command */ /* parameter structure used in ORANGEFS_DEV_DEBUG ioctl command */
struct dev_mask_info_s { struct dev_mask_info_s {
enum { enum {
KERNEL_MASK, KERNEL_MASK,
@ -349,7 +349,7 @@ struct dev_mask2_info_s {
}; };
/* pvfs2-util.h *************************************************************/ /* pvfs2-util.h *************************************************************/
__s32 PVFS_util_translate_mode(int mode); __s32 ORANGEFS_util_translate_mode(int mode);
/* pvfs2-debug.h ************************************************************/ /* pvfs2-debug.h ************************************************************/
#include "pvfs2-debug.h" #include "pvfs2-debug.h"
@ -359,9 +359,9 @@ __s32 PVFS_util_translate_mode(int mode);
#define lld(x) (long long)(x) #define lld(x) (long long)(x)
/* pint-dev-shared.h ********************************************************/ /* pint-dev-shared.h ********************************************************/
#define PVFS_DEV_MAGIC 'k' #define ORANGEFS_DEV_MAGIC 'k'
#define PVFS2_READDIR_DEFAULT_DESC_COUNT 5 #define ORANGEFS_READDIR_DEFAULT_DESC_COUNT 5
#define DEV_GET_MAGIC 0x1 #define DEV_GET_MAGIC 0x1
#define DEV_GET_MAX_UPSIZE 0x2 #define DEV_GET_MAX_UPSIZE 0x2
@ -376,39 +376,39 @@ __s32 PVFS_util_translate_mode(int mode);
/* supported ioctls, codes are with respect to user-space */ /* supported ioctls, codes are with respect to user-space */
enum { enum {
PVFS_DEV_GET_MAGIC = _IOW(PVFS_DEV_MAGIC, DEV_GET_MAGIC, __s32), ORANGEFS_DEV_GET_MAGIC = _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAGIC, __s32),
PVFS_DEV_GET_MAX_UPSIZE = ORANGEFS_DEV_GET_MAX_UPSIZE =
_IOW(PVFS_DEV_MAGIC, DEV_GET_MAX_UPSIZE, __s32), _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAX_UPSIZE, __s32),
PVFS_DEV_GET_MAX_DOWNSIZE = ORANGEFS_DEV_GET_MAX_DOWNSIZE =
_IOW(PVFS_DEV_MAGIC, DEV_GET_MAX_DOWNSIZE, __s32), _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAX_DOWNSIZE, __s32),
PVFS_DEV_MAP = _IO(PVFS_DEV_MAGIC, DEV_MAP), ORANGEFS_DEV_MAP = _IO(ORANGEFS_DEV_MAGIC, DEV_MAP),
PVFS_DEV_REMOUNT_ALL = _IO(PVFS_DEV_MAGIC, DEV_REMOUNT_ALL), ORANGEFS_DEV_REMOUNT_ALL = _IO(ORANGEFS_DEV_MAGIC, DEV_REMOUNT_ALL),
PVFS_DEV_DEBUG = _IOR(PVFS_DEV_MAGIC, DEV_DEBUG, __s32), ORANGEFS_DEV_DEBUG = _IOR(ORANGEFS_DEV_MAGIC, DEV_DEBUG, __s32),
PVFS_DEV_UPSTREAM = _IOW(PVFS_DEV_MAGIC, DEV_UPSTREAM, int), ORANGEFS_DEV_UPSTREAM = _IOW(ORANGEFS_DEV_MAGIC, DEV_UPSTREAM, int),
PVFS_DEV_CLIENT_MASK = _IOW(PVFS_DEV_MAGIC, ORANGEFS_DEV_CLIENT_MASK = _IOW(ORANGEFS_DEV_MAGIC,
DEV_CLIENT_MASK, DEV_CLIENT_MASK,
struct dev_mask2_info_s), struct dev_mask2_info_s),
PVFS_DEV_CLIENT_STRING = _IOW(PVFS_DEV_MAGIC, ORANGEFS_DEV_CLIENT_STRING = _IOW(ORANGEFS_DEV_MAGIC,
DEV_CLIENT_STRING, DEV_CLIENT_STRING,
char *), char *),
PVFS_DEV_MAXNR = DEV_MAX_NR, ORANGEFS_DEV_MAXNR = DEV_MAX_NR,
}; };
/* /*
* version number for use in communicating between kernel space and user * version number for use in communicating between kernel space and user
* space. Zero signifies the upstream version of the kernel module. * space. Zero signifies the upstream version of the kernel module.
*/ */
#define PVFS_KERNEL_PROTO_VERSION 0 #define ORANGEFS_KERNEL_PROTO_VERSION 0
/* /*
* describes memory regions to map in the PVFS_DEV_MAP ioctl. * describes memory regions to map in the ORANGEFS_DEV_MAP ioctl.
* NOTE: See devpvfs2-req.c for 32 bit compat structure. * NOTE: See devpvfs2-req.c for 32 bit compat structure.
* Since this structure has a variable-sized layout that is different * Since this structure has a variable-sized layout that is different
* on 32 and 64 bit platforms, we need to normalize to a 64 bit layout * on 32 and 64 bit platforms, we need to normalize to a 64 bit layout
* on such systems before servicing ioctl calls from user-space binaries * on such systems before servicing ioctl calls from user-space binaries
* that may be 32 bit! * that may be 32 bit!
*/ */
struct PVFS_dev_map_desc { struct ORANGEFS_dev_map_desc {
void *ptr; void *ptr;
__s32 total_size; __s32 total_size;
__s32 size; __s32 size;

168
fs/orangefs/pvfs2-bufmap.c
View file

@ -7,9 +7,9 @@
#include "pvfs2-kernel.h" #include "pvfs2-kernel.h"
#include "pvfs2-bufmap.h" #include "pvfs2-bufmap.h"
DECLARE_WAIT_QUEUE_HEAD(pvfs2_bufmap_init_waitq); DECLARE_WAIT_QUEUE_HEAD(orangefs_bufmap_init_waitq);
static struct pvfs2_bufmap { static struct orangefs_bufmap {
atomic_t refcnt; atomic_t refcnt;
int desc_size; int desc_size;
@ -19,21 +19,21 @@ static struct pvfs2_bufmap {
int page_count; int page_count;
struct page **page_array; struct page **page_array;
struct pvfs_bufmap_desc *desc_array; struct orangefs_bufmap_desc *desc_array;
/* array to track usage of buffer descriptors */ /* array to track usage of buffer descriptors */
int *buffer_index_array; int *buffer_index_array;
spinlock_t buffer_index_lock; spinlock_t buffer_index_lock;
/* array to track usage of buffer descriptors for readdir */ /* array to track usage of buffer descriptors for readdir */
int readdir_index_array[PVFS2_READDIR_DEFAULT_DESC_COUNT]; int readdir_index_array[ORANGEFS_READDIR_DEFAULT_DESC_COUNT];
spinlock_t readdir_index_lock; spinlock_t readdir_index_lock;
} *__pvfs2_bufmap; } *__orangefs_bufmap;
static DEFINE_SPINLOCK(pvfs2_bufmap_lock); static DEFINE_SPINLOCK(orangefs_bufmap_lock);
static void static void
pvfs2_bufmap_unmap(struct pvfs2_bufmap *bufmap) orangefs_bufmap_unmap(struct orangefs_bufmap *bufmap)
{ {
int i; int i;
@ -42,7 +42,7 @@ pvfs2_bufmap_unmap(struct pvfs2_bufmap *bufmap)
} }
static void static void
pvfs2_bufmap_free(struct pvfs2_bufmap *bufmap) orangefs_bufmap_free(struct orangefs_bufmap *bufmap)
{ {
kfree(bufmap->page_array); kfree(bufmap->page_array);
kfree(bufmap->desc_array); kfree(bufmap->desc_array);
@ -50,45 +50,45 @@ pvfs2_bufmap_free(struct pvfs2_bufmap *bufmap)
kfree(bufmap); kfree(bufmap);
} }
struct pvfs2_bufmap *pvfs2_bufmap_ref(void) struct orangefs_bufmap *orangefs_bufmap_ref(void)
{ {
struct pvfs2_bufmap *bufmap = NULL; struct orangefs_bufmap *bufmap = NULL;
spin_lock(&pvfs2_bufmap_lock); spin_lock(&orangefs_bufmap_lock);
if (__pvfs2_bufmap) { if (__orangefs_bufmap) {
bufmap = __pvfs2_bufmap; bufmap = __orangefs_bufmap;
atomic_inc(&bufmap->refcnt); atomic_inc(&bufmap->refcnt);
} }
spin_unlock(&pvfs2_bufmap_lock); spin_unlock(&orangefs_bufmap_lock);
return bufmap; return bufmap;
} }
void pvfs2_bufmap_unref(struct pvfs2_bufmap *bufmap) void orangefs_bufmap_unref(struct orangefs_bufmap *bufmap)
{ {
if (atomic_dec_and_lock(&bufmap->refcnt, &pvfs2_bufmap_lock)) { if (atomic_dec_and_lock(&bufmap->refcnt, &orangefs_bufmap_lock)) {
__pvfs2_bufmap = NULL; __orangefs_bufmap = NULL;
spin_unlock(&pvfs2_bufmap_lock); spin_unlock(&orangefs_bufmap_lock);
pvfs2_bufmap_unmap(bufmap); orangefs_bufmap_unmap(bufmap);
pvfs2_bufmap_free(bufmap); orangefs_bufmap_free(bufmap);
} }
} }
inline int pvfs_bufmap_size_query(void) inline int orangefs_bufmap_size_query(void)
{ {
struct pvfs2_bufmap *bufmap = pvfs2_bufmap_ref(); struct orangefs_bufmap *bufmap = orangefs_bufmap_ref();
int size = bufmap ? bufmap->desc_size : 0; int size = bufmap ? bufmap->desc_size : 0;
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
return size; return size;
} }
inline int pvfs_bufmap_shift_query(void) inline int orangefs_bufmap_shift_query(void)
{ {
struct pvfs2_bufmap *bufmap = pvfs2_bufmap_ref(); struct orangefs_bufmap *bufmap = orangefs_bufmap_ref();
int shift = bufmap ? bufmap->desc_shift : 0; int shift = bufmap ? bufmap->desc_shift : 0;
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
return shift; return shift;
} }
@ -105,14 +105,14 @@ static DECLARE_WAIT_QUEUE_HEAD(readdir_waitq);
*/ */
int get_bufmap_init(void) int get_bufmap_init(void)
{ {
return __pvfs2_bufmap ? 1 : 0; return __orangefs_bufmap ? 1 : 0;
} }
static struct pvfs2_bufmap * static struct orangefs_bufmap *
pvfs2_bufmap_alloc(struct PVFS_dev_map_desc *user_desc) orangefs_bufmap_alloc(struct ORANGEFS_dev_map_desc *user_desc)
{ {
struct pvfs2_bufmap *bufmap; struct orangefs_bufmap *bufmap;
bufmap = kzalloc(sizeof(*bufmap), GFP_KERNEL); bufmap = kzalloc(sizeof(*bufmap), GFP_KERNEL);
if (!bufmap) if (!bufmap)
@ -128,17 +128,17 @@ pvfs2_bufmap_alloc(struct PVFS_dev_map_desc *user_desc)
bufmap->buffer_index_array = bufmap->buffer_index_array =
kcalloc(bufmap->desc_count, sizeof(int), GFP_KERNEL); kcalloc(bufmap->desc_count, sizeof(int), GFP_KERNEL);
if (!bufmap->buffer_index_array) { if (!bufmap->buffer_index_array) {
gossip_err("pvfs2: could not allocate %d buffer indices\n", gossip_err("orangefs: could not allocate %d buffer indices\n",
bufmap->desc_count); bufmap->desc_count);
goto out_free_bufmap; goto out_free_bufmap;
} }
spin_lock_init(&bufmap->readdir_index_lock); spin_lock_init(&bufmap->readdir_index_lock);
bufmap->desc_array = bufmap->desc_array =
kcalloc(bufmap->desc_count, sizeof(struct pvfs_bufmap_desc), kcalloc(bufmap->desc_count, sizeof(struct orangefs_bufmap_desc),
GFP_KERNEL); GFP_KERNEL);
if (!bufmap->desc_array) { if (!bufmap->desc_array) {
gossip_err("pvfs2: could not allocate %d descriptors\n", gossip_err("orangefs: could not allocate %d descriptors\n",
bufmap->desc_count); bufmap->desc_count);
goto out_free_index_array; goto out_free_index_array;
} }
@ -164,8 +164,8 @@ out:
} }
static int static int
pvfs2_bufmap_map(struct pvfs2_bufmap *bufmap, orangefs_bufmap_map(struct orangefs_bufmap *bufmap,
struct PVFS_dev_map_desc *user_desc) struct ORANGEFS_dev_map_desc *user_desc)
{ {
int pages_per_desc = bufmap->desc_size / PAGE_SIZE; int pages_per_desc = bufmap->desc_size / PAGE_SIZE;
int offset = 0, ret, i; int offset = 0, ret, i;
@ -178,7 +178,7 @@ pvfs2_bufmap_map(struct pvfs2_bufmap *bufmap,
return ret; return ret;
if (ret != bufmap->page_count) { if (ret != bufmap->page_count) {
gossip_err("pvfs2 error: asked for %d pages, only got %d.\n", gossip_err("orangefs error: asked for %d pages, only got %d.\n",
bufmap->page_count, ret); bufmap->page_count, ret);
for (i = 0; i < ret; i++) { for (i = 0; i < ret; i++) {
@ -210,19 +210,19 @@ pvfs2_bufmap_map(struct pvfs2_bufmap *bufmap,
} }
/* /*
* pvfs_bufmap_initialize() * orangefs_bufmap_initialize()
* *
* initializes the mapped buffer interface * initializes the mapped buffer interface
* *
* returns 0 on success, -errno on failure * returns 0 on success, -errno on failure
*/ */
int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc) int orangefs_bufmap_initialize(struct ORANGEFS_dev_map_desc *user_desc)
{ {
struct pvfs2_bufmap *bufmap; struct orangefs_bufmap *bufmap;
int ret = -EINVAL; int ret = -EINVAL;
gossip_debug(GOSSIP_BUFMAP_DEBUG, gossip_debug(GOSSIP_BUFMAP_DEBUG,
"pvfs_bufmap_initialize: called (ptr (" "orangefs_bufmap_initialize: called (ptr ("
"%p) sz (%d) cnt(%d).\n", "%p) sz (%d) cnt(%d).\n",
user_desc->ptr, user_desc->ptr,
user_desc->size, user_desc->size,
@ -234,21 +234,21 @@ int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc)
*/ */
if (PAGE_ALIGN((unsigned long)user_desc->ptr) != if (PAGE_ALIGN((unsigned long)user_desc->ptr) !=
(unsigned long)user_desc->ptr) { (unsigned long)user_desc->ptr) {
gossip_err("pvfs2 error: memory alignment (front). %p\n", gossip_err("orangefs error: memory alignment (front). %p\n",
user_desc->ptr); user_desc->ptr);
goto out; goto out;
} }
if (PAGE_ALIGN(((unsigned long)user_desc->ptr + user_desc->total_size)) if (PAGE_ALIGN(((unsigned long)user_desc->ptr + user_desc->total_size))
!= (unsigned long)(user_desc->ptr + user_desc->total_size)) { != (unsigned long)(user_desc->ptr + user_desc->total_size)) {
gossip_err("pvfs2 error: memory alignment (back).(%p + %d)\n", gossip_err("orangefs error: memory alignment (back).(%p + %d)\n",
user_desc->ptr, user_desc->ptr,
user_desc->total_size); user_desc->total_size);
goto out; goto out;
} }
if (user_desc->total_size != (user_desc->size * user_desc->count)) { if (user_desc->total_size != (user_desc->size * user_desc->count)) {
gossip_err("pvfs2 error: user provided an oddly sized buffer: (%d, %d, %d)\n", gossip_err("orangefs error: user provided an oddly sized buffer: (%d, %d, %d)\n",
user_desc->total_size, user_desc->total_size,
user_desc->size, user_desc->size,
user_desc->count); user_desc->count);
@ -256,33 +256,33 @@ int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc)
} }
if ((user_desc->size % PAGE_SIZE) != 0) { if ((user_desc->size % PAGE_SIZE) != 0) {
gossip_err("pvfs2 error: bufmap size not page size divisible (%d).\n", gossip_err("orangefs error: bufmap size not page size divisible (%d).\n",
user_desc->size); user_desc->size);
goto out; goto out;
} }
ret = -ENOMEM; ret = -ENOMEM;
bufmap = pvfs2_bufmap_alloc(user_desc); bufmap = orangefs_bufmap_alloc(user_desc);
if (!bufmap) if (!bufmap)
goto out; goto out;
ret = pvfs2_bufmap_map(bufmap, user_desc); ret = orangefs_bufmap_map(bufmap, user_desc);
if (ret) if (ret)
goto out_free_bufmap; goto out_free_bufmap;
spin_lock(&pvfs2_bufmap_lock); spin_lock(&orangefs_bufmap_lock);
if (__pvfs2_bufmap) { if (__orangefs_bufmap) {
spin_unlock(&pvfs2_bufmap_lock); spin_unlock(&orangefs_bufmap_lock);
gossip_err("pvfs2: error: bufmap already initialized.\n"); gossip_err("orangefs: error: bufmap already initialized.\n");
ret = -EALREADY; ret = -EALREADY;
goto out_unmap_bufmap; goto out_unmap_bufmap;
} }
__pvfs2_bufmap = bufmap; __orangefs_bufmap = bufmap;
spin_unlock(&pvfs2_bufmap_lock); spin_unlock(&orangefs_bufmap_lock);
/* /*
* If there are operations in pvfs2_bufmap_init_waitq, wake them up. * If there are operations in orangefs_bufmap_init_waitq, wake them up.
* This scenario occurs when the client-core is restarted and I/O * This scenario occurs when the client-core is restarted and I/O
* requests in the in-progress or waiting tables are restarted. I/O * requests in the in-progress or waiting tables are restarted. I/O
* requests cannot be restarted until the shared memory system is * requests cannot be restarted until the shared memory system is
@ -291,35 +291,35 @@ int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc)
* are also on a timer, so they don't wait forever just in case the * are also on a timer, so they don't wait forever just in case the
* client-core doesn't come back up. * client-core doesn't come back up.
*/ */
wake_up_interruptible(&pvfs2_bufmap_init_waitq); wake_up_interruptible(&orangefs_bufmap_init_waitq);
gossip_debug(GOSSIP_BUFMAP_DEBUG, gossip_debug(GOSSIP_BUFMAP_DEBUG,
"pvfs_bufmap_initialize: exiting normally\n"); "orangefs_bufmap_initialize: exiting normally\n");
return 0; return 0;
out_unmap_bufmap: out_unmap_bufmap:
pvfs2_bufmap_unmap(bufmap); orangefs_bufmap_unmap(bufmap);
out_free_bufmap: out_free_bufmap:
pvfs2_bufmap_free(bufmap); orangefs_bufmap_free(bufmap);
out: out:
return ret; return ret;
} }
/* /*
* pvfs_bufmap_finalize() * orangefs_bufmap_finalize()
* *
* shuts down the mapped buffer interface and releases any resources * shuts down the mapped buffer interface and releases any resources
* associated with it * associated with it
* *
* no return value * no return value
*/ */
void pvfs_bufmap_finalize(void) void orangefs_bufmap_finalize(void)
{ {
gossip_debug(GOSSIP_BUFMAP_DEBUG, "pvfs2_bufmap_finalize: called\n"); gossip_debug(GOSSIP_BUFMAP_DEBUG, "orangefs_bufmap_finalize: called\n");
BUG_ON(!__pvfs2_bufmap); BUG_ON(!__orangefs_bufmap);
pvfs2_bufmap_unref(__pvfs2_bufmap); orangefs_bufmap_unref(__orangefs_bufmap);
gossip_debug(GOSSIP_BUFMAP_DEBUG, gossip_debug(GOSSIP_BUFMAP_DEBUG,
"pvfs2_bufmap_finalize: exiting normally\n"); "orangefs_bufmap_finalize: exiting normally\n");
} }
struct slot_args { struct slot_args {
@ -377,7 +377,7 @@ static int wait_for_a_slot(struct slot_args *slargs, int *buffer_index)
continue; continue;
} }
gossip_debug(GOSSIP_BUFMAP_DEBUG, "pvfs2: %s interrupted.\n", gossip_debug(GOSSIP_BUFMAP_DEBUG, "orangefs: %s interrupted.\n",
__func__); __func__);
ret = -EINTR; ret = -EINTR;
break; break;
@ -406,21 +406,21 @@ static void put_back_slot(struct slot_args *slargs, int buffer_index)
} }
/* /*
* pvfs_bufmap_get() * orangefs_bufmap_get()
* *
* gets a free mapped buffer descriptor, will sleep until one becomes * gets a free mapped buffer descriptor, will sleep until one becomes
* available if necessary * available if necessary
* *
* returns 0 on success, -errno on failure * returns 0 on success, -errno on failure
*/ */
int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index) int orangefs_bufmap_get(struct orangefs_bufmap **mapp, int *buffer_index)
{ {
struct pvfs2_bufmap *bufmap = pvfs2_bufmap_ref(); struct orangefs_bufmap *bufmap = orangefs_bufmap_ref();
struct slot_args slargs; struct slot_args slargs;
int ret; int ret;
if (!bufmap) { if (!bufmap) {
gossip_err("pvfs2: please confirm that pvfs2-client daemon is running.\n"); gossip_err("orangefs: please confirm that pvfs2-client daemon is running.\n");
return -EIO; return -EIO;
} }
@ -430,19 +430,19 @@ int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index)
slargs.slot_wq = &bufmap_waitq; slargs.slot_wq = &bufmap_waitq;
ret = wait_for_a_slot(&slargs, buffer_index); ret = wait_for_a_slot(&slargs, buffer_index);
if (ret) if (ret)
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
*mapp = bufmap; *mapp = bufmap;
return ret; return ret;
} }
/* /*
* pvfs_bufmap_put() * orangefs_bufmap_put()
* *
* returns a mapped buffer descriptor to the collection * returns a mapped buffer descriptor to the collection
* *
* no return value * no return value
*/ */
void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index) void orangefs_bufmap_put(struct orangefs_bufmap *bufmap, int buffer_index)
{ {
struct slot_args slargs; struct slot_args slargs;
@ -451,7 +451,7 @@ void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index)
slargs.slot_lock = &bufmap->buffer_index_lock; slargs.slot_lock = &bufmap->buffer_index_lock;
slargs.slot_wq = &bufmap_waitq; slargs.slot_wq = &bufmap_waitq;
put_back_slot(&slargs, buffer_index); put_back_slot(&slargs, buffer_index);
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
} }
/* /*
@ -465,46 +465,46 @@ void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index)
* *
* returns 0 on success, -errno on failure * returns 0 on success, -errno on failure
*/ */
int readdir_index_get(struct pvfs2_bufmap **mapp, int *buffer_index) int readdir_index_get(struct orangefs_bufmap **mapp, int *buffer_index)
{ {
struct pvfs2_bufmap *bufmap = pvfs2_bufmap_ref(); struct orangefs_bufmap *bufmap = orangefs_bufmap_ref();
struct slot_args slargs; struct slot_args slargs;
int ret; int ret;
if (!bufmap) { if (!bufmap) {
gossip_err("pvfs2: please confirm that pvfs2-client daemon is running.\n"); gossip_err("orangefs: please confirm that pvfs2-client daemon is running.\n");
return -EIO; return -EIO;
} }
slargs.slot_count = PVFS2_READDIR_DEFAULT_DESC_COUNT; slargs.slot_count = ORANGEFS_READDIR_DEFAULT_DESC_COUNT;
slargs.slot_array = bufmap->readdir_index_array; slargs.slot_array = bufmap->readdir_index_array;
slargs.slot_lock = &bufmap->readdir_index_lock; slargs.slot_lock = &bufmap->readdir_index_lock;
slargs.slot_wq = &readdir_waitq; slargs.slot_wq = &readdir_waitq;
ret = wait_for_a_slot(&slargs, buffer_index); ret = wait_for_a_slot(&slargs, buffer_index);
if (ret) if (ret)
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
*mapp = bufmap; *mapp = bufmap;
return ret; return ret;
} }
void readdir_index_put(struct pvfs2_bufmap *bufmap, int buffer_index) void readdir_index_put(struct orangefs_bufmap *bufmap, int buffer_index)
{ {
struct slot_args slargs; struct slot_args slargs;
slargs.slot_count = PVFS2_READDIR_DEFAULT_DESC_COUNT; slargs.slot_count = ORANGEFS_READDIR_DEFAULT_DESC_COUNT;
slargs.slot_array = bufmap->readdir_index_array; slargs.slot_array = bufmap->readdir_index_array;
slargs.slot_lock = &bufmap->readdir_index_lock; slargs.slot_lock = &bufmap->readdir_index_lock;
slargs.slot_wq = &readdir_waitq; slargs.slot_wq = &readdir_waitq;
put_back_slot(&slargs, buffer_index); put_back_slot(&slargs, buffer_index);
pvfs2_bufmap_unref(bufmap); orangefs_bufmap_unref(bufmap);
} }
int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap, int orangefs_bufmap_copy_from_iovec(struct orangefs_bufmap *bufmap,
struct iov_iter *iter, struct iov_iter *iter,
int buffer_index, int buffer_index,
size_t size) size_t size)
{ {
struct pvfs_bufmap_desc *to = &bufmap->desc_array[buffer_index]; struct orangefs_bufmap_desc *to = &bufmap->desc_array[buffer_index];
int i; int i;
gossip_debug(GOSSIP_BUFMAP_DEBUG, gossip_debug(GOSSIP_BUFMAP_DEBUG,
@ -531,12 +531,12 @@ int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap,
* a file being read. * a file being read.
* *
*/ */
int pvfs_bufmap_copy_to_iovec(struct pvfs2_bufmap *bufmap, int orangefs_bufmap_copy_to_iovec(struct orangefs_bufmap *bufmap,
struct iov_iter *iter, struct iov_iter *iter,
int buffer_index, int buffer_index,
size_t size) size_t size)
{ {
struct pvfs_bufmap_desc *from = &bufmap->desc_array[buffer_index]; struct orangefs_bufmap_desc *from = &bufmap->desc_array[buffer_index];
int i; int i;
gossip_debug(GOSSIP_BUFMAP_DEBUG, gossip_debug(GOSSIP_BUFMAP_DEBUG,

40
fs/orangefs/pvfs2-bufmap.h
View file

@ -4,59 +4,59 @@
* See COPYING in top-level directory. * See COPYING in top-level directory.
*/ */
#ifndef __PVFS2_BUFMAP_H #ifndef __ORANGEFS_BUFMAP_H
#define __PVFS2_BUFMAP_H #define __ORANGEFS_BUFMAP_H
/* used to describe mapped buffers */ /* used to describe mapped buffers */
struct pvfs_bufmap_desc { struct orangefs_bufmap_desc {
void *uaddr; /* user space address pointer */ void *uaddr; /* user space address pointer */
struct page **page_array; /* array of mapped pages */ struct page **page_array; /* array of mapped pages */
int array_count; /* size of above arrays */ int array_count; /* size of above arrays */
struct list_head list_link; struct list_head list_link;
}; };
struct pvfs2_bufmap; struct orangefs_bufmap;
struct pvfs2_bufmap *pvfs2_bufmap_ref(void); struct orangefs_bufmap *orangefs_bufmap_ref(void);
void pvfs2_bufmap_unref(struct pvfs2_bufmap *bufmap); 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 * 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); 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, struct iov_iter *iter,
int buffer_index, int buffer_index,
size_t size); 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, struct iov_iter *iter,
int buffer_index, int buffer_index,
size_t size); 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, struct iovec *iovec,
unsigned long nr_segs, unsigned long nr_segs,
struct pvfs2_bufmap *bufmap, struct orangefs_bufmap *bufmap,
int buffer_index, int buffer_index,
size_t bytes_to_be_copied); size_t bytes_to_be_copied);
#endif /* __PVFS2_BUFMAP_H */ #endif /* __ORANGEFS_BUFMAP_H */

122
fs/orangefs/pvfs2-cache.c
View file

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

18
fs/orangefs/pvfs2-debug.h
View file

@ -5,12 +5,12 @@
*/ */
/* This file just defines debugging masks to be used with the gossip /* 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. * sure we don't have collisions.
*/ */
#ifndef __PVFS2_DEBUG_H #ifndef __ORANGEFS_DEBUG_H
#define __PVFS2_DEBUG_H #define __ORANGEFS_DEBUG_H
#ifdef __KERNEL__ #ifdef __KERNEL__
#include <linux/types.h> #include <linux/types.h>
@ -90,7 +90,7 @@
GOSSIP_BMI_DEBUG_MX + \ GOSSIP_BMI_DEBUG_MX + \
GOSSIP_BMI_DEBUG_PORTALS)) 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_SUPER_DEBUG ((__u64)1 << 0)
#define GOSSIP_INODE_DEBUG ((__u64)1 << 1) #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) #define GOSSIP_MAX_DEBUG (((__u64)1 << GOSSIP_MAX_NR) - 1)
/*function prototypes*/ /*function prototypes*/
__u64 PVFS_kmod_eventlog_to_mask(const char *event_logging); __u64 ORANGEFS_kmod_eventlog_to_mask(const char *event_logging);
__u64 PVFS_debug_eventlog_to_mask(const char *event_logging); __u64 ORANGEFS_debug_eventlog_to_mask(const char *event_logging);
char *PVFS_debug_mask_to_eventlog(__u64 mask); char *ORANGEFS_debug_mask_to_eventlog(__u64 mask);
char *PVFS_kmod_mask_to_eventlog(__u64 mask); char *ORANGEFS_kmod_mask_to_eventlog(__u64 mask);
/* a private internal type */ /* a private internal type */
struct __keyword_mask_s { 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) static const int num_keyword_mask_map = (int)
(sizeof(s_keyword_mask_map) / sizeof(struct __keyword_mask_s)); (sizeof(s_keyword_mask_map) / sizeof(struct __keyword_mask_s));
#endif /* __PVFS2_DEBUG_H */ #endif /* __ORANGEFS_DEBUG_H */

48
fs/orangefs/pvfs2-debugfs.c
View file

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

6
fs/orangefs/pvfs2-debugfs.h
View file

@ -1,3 +1,3 @@
int pvfs2_debugfs_init(void); int orangefs_debugfs_init(void);
int pvfs2_kernel_debug_init(void); int orangefs_kernel_debug_init(void);
void pvfs2_debugfs_cleanup(void); void orangefs_debugfs_cleanup(void);

68
fs/orangefs/pvfs2-dev-proto.h
View file

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

396
fs/orangefs/pvfs2-kernel.h
View file

@ -5,18 +5,18 @@
*/ */
/* /*
* The PVFS2 Linux kernel support allows PVFS2 volumes to be mounted and * The ORANGEFS Linux kernel support allows ORANGEFS volumes to be mounted and
* accessed through the Linux VFS (i.e. using standard I/O system calls). * accessed through the Linux VFS (i.e. using standard I/O system calls).
* This support is only needed on clients that wish to mount the file system. * This support is only needed on clients that wish to mount the file system.
* *
*/ */
/* /*
* Declarations and macros for the PVFS2 Linux kernel support. * Declarations and macros for the ORANGEFS Linux kernel support.
*/ */
#ifndef __PVFS2KERNEL_H #ifndef __ORANGEFSKERNEL_H
#define __PVFS2KERNEL_H #define __ORANGEFSKERNEL_H
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
@ -55,30 +55,30 @@
#include "pvfs2-dev-proto.h" #include "pvfs2-dev-proto.h"
#ifdef PVFS2_KERNEL_DEBUG #ifdef ORANGEFS_KERNEL_DEBUG
#define PVFS2_DEFAULT_OP_TIMEOUT_SECS 10 #define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS 10
#else #else
#define PVFS2_DEFAULT_OP_TIMEOUT_SECS 20 #define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS 20
#endif #endif
#define PVFS2_BUFMAP_WAIT_TIMEOUT_SECS 30 #define ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS 30
#define PVFS2_DEFAULT_SLOT_TIMEOUT_SECS 900 /* 15 minutes */ #define ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS 900 /* 15 minutes */
#define PVFS2_REQDEVICE_NAME "pvfs2-req" #define ORANGEFS_REQDEVICE_NAME "pvfs2-req"
#define PVFS2_DEVREQ_MAGIC 0x20030529 #define ORANGEFS_DEVREQ_MAGIC 0x20030529
#define PVFS2_LINK_MAX 0x000000FF #define ORANGEFS_LINK_MAX 0x000000FF
#define PVFS2_PURGE_RETRY_COUNT 0x00000005 #define ORANGEFS_PURGE_RETRY_COUNT 0x00000005
#define PVFS2_SEEK_END 0x00000002 #define ORANGEFS_SEEK_END 0x00000002
#define PVFS2_MAX_NUM_OPTIONS 0x00000004 #define ORANGEFS_MAX_NUM_OPTIONS 0x00000004
#define PVFS2_MAX_MOUNT_OPT_LEN 0x00000080 #define ORANGEFS_MAX_MOUNT_OPT_LEN 0x00000080
#define PVFS2_MAX_FSKEY_LEN 64 #define ORANGEFS_MAX_FSKEY_LEN 64
#define MAX_DEV_REQ_UPSIZE (2*sizeof(__s32) + \ #define MAX_DEV_REQ_UPSIZE (2*sizeof(__s32) + \
sizeof(__u64) + sizeof(struct pvfs2_upcall_s)) sizeof(__u64) + sizeof(struct orangefs_upcall_s))
#define MAX_DEV_REQ_DOWNSIZE (2*sizeof(__s32) + \ #define MAX_DEV_REQ_DOWNSIZE (2*sizeof(__s32) + \
sizeof(__u64) + sizeof(struct pvfs2_downcall_s)) sizeof(__u64) + sizeof(struct orangefs_downcall_s))
#define BITS_PER_LONG_DIV_8 (BITS_PER_LONG >> 3) #define BITS_PER_LONG_DIV_8 (BITS_PER_LONG >> 3)
@ -104,7 +104,7 @@ sizeof(__u64) + sizeof(struct pvfs2_downcall_s))
MAX_DEV_REQ_DOWNSIZE)) MAX_DEV_REQ_DOWNSIZE))
/* /*
* valid pvfs2 kernel operation states * valid orangefs kernel operation states
* *
* unknown - op was just initialized * unknown - op was just initialized
* waiting - op is on request_list (upward bound) * waiting - op is on request_list (upward bound)
@ -113,7 +113,7 @@ sizeof(__u64) + sizeof(struct pvfs2_downcall_s))
* purged - op has to start a timer since client-core * purged - op has to start a timer since client-core
* exited uncleanly before servicing op * exited uncleanly before servicing op
*/ */
enum pvfs2_vfs_op_states { enum orangefs_vfs_op_states {
OP_VFS_STATE_UNKNOWN = 0, OP_VFS_STATE_UNKNOWN = 0,
OP_VFS_STATE_WAITING = 1, OP_VFS_STATE_WAITING = 1,
OP_VFS_STATE_INPROGR = 2, OP_VFS_STATE_INPROGR = 2,
@ -156,9 +156,9 @@ enum pvfs2_vfs_op_states {
/* /*
* Defines for controlling whether I/O upcalls are for async or sync operations * Defines for controlling whether I/O upcalls are for async or sync operations
*/ */
enum PVFS_async_io_type { enum ORANGEFS_async_io_type {
PVFS_VFS_SYNC_IO = 0, ORANGEFS_VFS_SYNC_IO = 0,
PVFS_VFS_ASYNC_IO = 1, ORANGEFS_VFS_ASYNC_IO = 1,
}; };
/* /*
@ -172,24 +172,24 @@ struct client_debug_mask {
}; };
/* /*
* pvfs2 kernel memory related flags * orangefs kernel memory related flags
*/ */
#if ((defined PVFS2_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) #if ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB))
#define PVFS2_CACHE_CREATE_FLAGS SLAB_RED_ZONE #define ORANGEFS_CACHE_CREATE_FLAGS SLAB_RED_ZONE
#else #else
#define PVFS2_CACHE_CREATE_FLAGS 0 #define ORANGEFS_CACHE_CREATE_FLAGS 0
#endif /* ((defined PVFS2_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */ #endif /* ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */
#define PVFS2_CACHE_ALLOC_FLAGS (GFP_KERNEL) #define ORANGEFS_CACHE_ALLOC_FLAGS (GFP_KERNEL)
#define PVFS2_GFP_FLAGS (GFP_KERNEL) #define ORANGEFS_GFP_FLAGS (GFP_KERNEL)
#define PVFS2_BUFMAP_GFP_FLAGS (GFP_KERNEL) #define ORANGEFS_BUFMAP_GFP_FLAGS (GFP_KERNEL)
/* pvfs2 xattr and acl related defines */ /* orangefs xattr and acl related defines */
#define PVFS2_XATTR_INDEX_POSIX_ACL_ACCESS 1 #define ORANGEFS_XATTR_INDEX_POSIX_ACL_ACCESS 1
#define PVFS2_XATTR_INDEX_POSIX_ACL_DEFAULT 2 #define ORANGEFS_XATTR_INDEX_POSIX_ACL_DEFAULT 2
#define PVFS2_XATTR_INDEX_TRUSTED 3 #define ORANGEFS_XATTR_INDEX_TRUSTED 3
#define PVFS2_XATTR_INDEX_DEFAULT 4 #define ORANGEFS_XATTR_INDEX_DEFAULT 4
#if 0 #if 0
#ifndef POSIX_ACL_XATTR_ACCESS #ifndef POSIX_ACL_XATTR_ACCESS
@ -200,17 +200,17 @@ struct client_debug_mask {
#endif #endif
#endif #endif
#define PVFS2_XATTR_NAME_ACL_ACCESS POSIX_ACL_XATTR_ACCESS #define ORANGEFS_XATTR_NAME_ACL_ACCESS POSIX_ACL_XATTR_ACCESS
#define PVFS2_XATTR_NAME_ACL_DEFAULT POSIX_ACL_XATTR_DEFAULT #define ORANGEFS_XATTR_NAME_ACL_DEFAULT POSIX_ACL_XATTR_DEFAULT
#define PVFS2_XATTR_NAME_TRUSTED_PREFIX "trusted." #define ORANGEFS_XATTR_NAME_TRUSTED_PREFIX "trusted."
#define PVFS2_XATTR_NAME_DEFAULT_PREFIX "" #define ORANGEFS_XATTR_NAME_DEFAULT_PREFIX ""
/* these functions are defined in pvfs2-utils.c */ /* these functions are defined in orangefs-utils.c */
int orangefs_prepare_cdm_array(char *debug_array_string); int orangefs_prepare_cdm_array(char *debug_array_string);
int orangefs_prepare_debugfs_help_string(int); int orangefs_prepare_debugfs_help_string(int);
/* defined in pvfs2-debugfs.c */ /* defined in orangefs-debugfs.c */
int pvfs2_client_debug_init(void); int orangefs_client_debug_init(void);
void debug_string_to_mask(char *, void *, int); void debug_string_to_mask(char *, void *, int);
void do_c_mask(int, char *, struct client_debug_mask **); void do_c_mask(int, char *, struct client_debug_mask **);
@ -222,17 +222,17 @@ void do_c_string(void *, int);
int check_amalgam_keyword(void *, int); int check_amalgam_keyword(void *, int);
int keyword_is_amalgam(char *); int keyword_is_amalgam(char *);
/*these variables are defined in pvfs2-mod.c */ /*these variables are defined in orangefs-mod.c */
extern char kernel_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; extern char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern char client_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; extern char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern char client_debug_array_string[PVFS2_MAX_DEBUG_STRING_LEN]; extern char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
extern unsigned int kernel_mask_set_mod_init; extern unsigned int kernel_mask_set_mod_init;
extern int pvfs2_init_acl(struct inode *inode, struct inode *dir); extern int orangefs_init_acl(struct inode *inode, struct inode *dir);
extern const struct xattr_handler *pvfs2_xattr_handlers[]; extern const struct xattr_handler *orangefs_xattr_handlers[];
extern struct posix_acl *pvfs2_get_acl(struct inode *inode, int type); extern struct posix_acl *orangefs_get_acl(struct inode *inode, int type);
extern int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type); extern int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type);
/* /*
* Redefine xtvec structure so that we could move helper functions out of * Redefine xtvec structure so that we could move helper functions out of
@ -244,10 +244,10 @@ struct xtvec {
}; };
/* /*
* pvfs2 data structures * orangefs data structures
*/ */
struct pvfs2_kernel_op_s { struct orangefs_kernel_op_s {
enum pvfs2_vfs_op_states op_state; enum orangefs_vfs_op_states op_state;
__u64 tag; __u64 tag;
/* /*
@ -257,8 +257,8 @@ struct pvfs2_kernel_op_s {
*/ */
int uses_shared_memory; int uses_shared_memory;
struct pvfs2_upcall_s upcall; struct orangefs_upcall_s upcall;
struct pvfs2_downcall_s downcall; struct orangefs_downcall_s downcall;
wait_queue_head_t waitq; wait_queue_head_t waitq;
spinlock_t lock; spinlock_t lock;
@ -268,7 +268,7 @@ struct pvfs2_kernel_op_s {
/* VFS aio fields */ /* VFS aio fields */
/* used by the async I/O code to stash the pvfs2_kiocb_s structure */ /* used by the async I/O code to stash the orangefs_kiocb_s structure */
void *priv; void *priv;
/* used again for the async I/O code for deallocation */ /* used again for the async I/O code for deallocation */
@ -279,14 +279,14 @@ struct pvfs2_kernel_op_s {
struct list_head list; struct list_head list;
}; };
/* per inode private pvfs2 info */ /* per inode private orangefs info */
struct pvfs2_inode_s { struct orangefs_inode_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
char link_target[PVFS_NAME_MAX]; char link_target[ORANGEFS_NAME_MAX];
__s64 blksize; __s64 blksize;
/* /*
* Reading/Writing Extended attributes need to acquire the appropriate * Reading/Writing Extended attributes need to acquire the appropriate
* reader/writer semaphore on the pvfs2_inode_s structure. * reader/writer semaphore on the orangefs_inode_s structure.
*/ */
struct rw_semaphore xattr_sem; struct rw_semaphore xattr_sem;
@ -299,7 +299,7 @@ struct pvfs2_inode_s {
*/ */
unsigned long pinode_flags; unsigned long pinode_flags;
/* All allocated pvfs2_inode_s objects are chained to a list */ /* All allocated orangefs_inode_s objects are chained to a list */
struct list_head list; struct list_head list;
}; };
@ -324,15 +324,15 @@ struct pvfs2_inode_s {
#define SetModeFlag(pinode) set_bit(P_MODE_FLAG, &(pinode)->pinode_flags) #define SetModeFlag(pinode) set_bit(P_MODE_FLAG, &(pinode)->pinode_flags)
#define ModeFlag(pinode) test_bit(P_MODE_FLAG, &(pinode)->pinode_flags) #define ModeFlag(pinode) test_bit(P_MODE_FLAG, &(pinode)->pinode_flags)
/* per superblock private pvfs2 info */ /* per superblock private orangefs info */
struct pvfs2_sb_info_s { struct orangefs_sb_info_s {
struct pvfs2_khandle root_khandle; struct orangefs_khandle root_khandle;
__s32 fs_id; __s32 fs_id;
int id; int id;
int flags; int flags;
#define PVFS2_OPT_INTR 0x01 #define ORANGEFS_OPT_INTR 0x01
#define PVFS2_OPT_LOCAL_LOCK 0x02 #define ORANGEFS_OPT_LOCAL_LOCK 0x02
char devname[PVFS_MAX_SERVER_ADDR_LEN]; char devname[ORANGEFS_MAX_SERVER_ADDR_LEN];
struct super_block *sb; struct super_block *sb;
int mount_pending; int mount_pending;
struct list_head list; struct list_head list;
@ -344,7 +344,7 @@ struct pvfs2_sb_info_s {
* or even completion notification so that the VFS client-side daemon * or even completion notification so that the VFS client-side daemon
* can free up its vfs_request slots. * can free up its vfs_request slots.
*/ */
struct pvfs2_kiocb_s { struct orangefs_kiocb_s {
/* the pointer to the task that initiated the AIO */ /* the pointer to the task that initiated the AIO */
struct task_struct *tsk; struct task_struct *tsk;
@ -352,11 +352,11 @@ struct pvfs2_kiocb_s {
struct kiocb *kiocb; struct kiocb *kiocb;
/* buffer index that was used for the I/O */ /* buffer index that was used for the I/O */
struct pvfs2_bufmap *bufmap; struct orangefs_bufmap *bufmap;
int buffer_index; int buffer_index;
/* pvfs2 kernel operation type */ /* orangefs kernel operation type */
struct pvfs2_kernel_op_s *op; struct orangefs_kernel_op_s *op;
/* The user space buffers from/to which I/O is being staged */ /* The user space buffers from/to which I/O is being staged */
struct iovec *iov; struct iovec *iov;
@ -377,31 +377,31 @@ struct pvfs2_kiocb_s {
int needs_cleanup; int needs_cleanup;
}; };
struct pvfs2_stats { struct orangefs_stats {
unsigned long cache_hits; unsigned long cache_hits;
unsigned long cache_misses; unsigned long cache_misses;
unsigned long reads; unsigned long reads;
unsigned long writes; unsigned long writes;
}; };
extern struct pvfs2_stats g_pvfs2_stats; extern struct orangefs_stats g_orangefs_stats;
/* /*
* NOTE: See Documentation/filesystems/porting for information * NOTE: See Documentation/filesystems/porting for information
* on implementing FOO_I and properly accessing fs private data * on implementing FOO_I and properly accessing fs private data
*/ */
static inline struct pvfs2_inode_s *PVFS2_I(struct inode *inode) static inline struct orangefs_inode_s *ORANGEFS_I(struct inode *inode)
{ {
return container_of(inode, struct pvfs2_inode_s, vfs_inode); return container_of(inode, struct orangefs_inode_s, vfs_inode);
} }
static inline struct pvfs2_sb_info_s *PVFS2_SB(struct super_block *sb) static inline struct orangefs_sb_info_s *ORANGEFS_SB(struct super_block *sb)
{ {
return (struct pvfs2_sb_info_s *) sb->s_fs_info; return (struct orangefs_sb_info_s *) sb->s_fs_info;
} }
/* ino_t descends from "unsigned long", 8 bytes, 64 bits. */ /* ino_t descends from "unsigned long", 8 bytes, 64 bits. */
static inline ino_t pvfs2_khandle_to_ino(struct pvfs2_khandle *khandle) static inline ino_t orangefs_khandle_to_ino(struct orangefs_khandle *khandle)
{ {
union { union {
unsigned char u[8]; unsigned char u[8];
@ -420,23 +420,23 @@ static inline ino_t pvfs2_khandle_to_ino(struct pvfs2_khandle *khandle)
return ihandle.ino; return ihandle.ino;
} }
static inline struct pvfs2_khandle *get_khandle_from_ino(struct inode *inode) static inline struct orangefs_khandle *get_khandle_from_ino(struct inode *inode)
{ {
return &(PVFS2_I(inode)->refn.khandle); return &(ORANGEFS_I(inode)->refn.khandle);
} }
static inline __s32 get_fsid_from_ino(struct inode *inode) static inline __s32 get_fsid_from_ino(struct inode *inode)
{ {
return PVFS2_I(inode)->refn.fs_id; return ORANGEFS_I(inode)->refn.fs_id;
} }
static inline ino_t get_ino_from_khandle(struct inode *inode) static inline ino_t get_ino_from_khandle(struct inode *inode)
{ {
struct pvfs2_khandle *khandle; struct orangefs_khandle *khandle;
ino_t ino; ino_t ino;
khandle = get_khandle_from_ino(inode); khandle = get_khandle_from_ino(inode);
ino = pvfs2_khandle_to_ino(khandle); ino = orangefs_khandle_to_ino(khandle);
return ino; return ino;
} }
@ -450,17 +450,17 @@ static inline int is_root_handle(struct inode *inode)
gossip_debug(GOSSIP_DCACHE_DEBUG, gossip_debug(GOSSIP_DCACHE_DEBUG,
"%s: root handle: %pU, this handle: %pU:\n", "%s: root handle: %pU, this handle: %pU:\n",
__func__, __func__,
&PVFS2_SB(inode->i_sb)->root_khandle, &ORANGEFS_SB(inode->i_sb)->root_khandle,
get_khandle_from_ino(inode)); get_khandle_from_ino(inode));
if (PVFS_khandle_cmp(&(PVFS2_SB(inode->i_sb)->root_khandle), if (ORANGEFS_khandle_cmp(&(ORANGEFS_SB(inode->i_sb)->root_khandle),
get_khandle_from_ino(inode))) get_khandle_from_ino(inode)))
return 0; return 0;
else else
return 1; return 1;
} }
static inline int match_handle(struct pvfs2_khandle resp_handle, static inline int match_handle(struct orangefs_khandle resp_handle,
struct inode *inode) struct inode *inode)
{ {
gossip_debug(GOSSIP_DCACHE_DEBUG, gossip_debug(GOSSIP_DCACHE_DEBUG,
@ -469,57 +469,57 @@ static inline int match_handle(struct pvfs2_khandle resp_handle,
&resp_handle, &resp_handle,
get_khandle_from_ino(inode)); get_khandle_from_ino(inode));
if (PVFS_khandle_cmp(&resp_handle, get_khandle_from_ino(inode))) if (ORANGEFS_khandle_cmp(&resp_handle, get_khandle_from_ino(inode)))
return 0; return 0;
else else
return 1; return 1;
} }
/* /*
* defined in pvfs2-cache.c * defined in orangefs-cache.c
*/ */
int op_cache_initialize(void); int op_cache_initialize(void);
int op_cache_finalize(void); int op_cache_finalize(void);
struct pvfs2_kernel_op_s *op_alloc(__s32 type); struct orangefs_kernel_op_s *op_alloc(__s32 type);
char *get_opname_string(struct pvfs2_kernel_op_s *new_op); char *get_opname_string(struct orangefs_kernel_op_s *new_op);
void op_release(struct pvfs2_kernel_op_s *op); void op_release(struct orangefs_kernel_op_s *op);
int dev_req_cache_initialize(void); int dev_req_cache_initialize(void);
int dev_req_cache_finalize(void); int dev_req_cache_finalize(void);
void *dev_req_alloc(void); void *dev_req_alloc(void);
void dev_req_release(void *); void dev_req_release(void *);
int pvfs2_inode_cache_initialize(void); int orangefs_inode_cache_initialize(void);
int pvfs2_inode_cache_finalize(void); int orangefs_inode_cache_finalize(void);
int kiocb_cache_initialize(void); int kiocb_cache_initialize(void);
int kiocb_cache_finalize(void); int kiocb_cache_finalize(void);
struct pvfs2_kiocb_s *kiocb_alloc(void); struct orangefs_kiocb_s *kiocb_alloc(void);
void kiocb_release(struct pvfs2_kiocb_s *ptr); void kiocb_release(struct orangefs_kiocb_s *ptr);
/* /*
* defined in pvfs2-mod.c * defined in orangefs-mod.c
*/ */
void purge_inprogress_ops(void); void purge_inprogress_ops(void);
/* /*
* defined in waitqueue.c * defined in waitqueue.c
*/ */
int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op); int wait_for_matching_downcall(struct orangefs_kernel_op_s *op);
int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op); int wait_for_cancellation_downcall(struct orangefs_kernel_op_s *op);
void pvfs2_clean_up_interrupted_operation(struct pvfs2_kernel_op_s *op); void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *op);
void purge_waiting_ops(void); void purge_waiting_ops(void);
/* /*
* defined in super.c * defined in super.c
*/ */
struct dentry *pvfs2_mount(struct file_system_type *fst, struct dentry *orangefs_mount(struct file_system_type *fst,
int flags, int flags,
const char *devname, const char *devname,
void *data); void *data);
void pvfs2_kill_sb(struct super_block *sb); void orangefs_kill_sb(struct super_block *sb);
int pvfs2_remount(struct super_block *sb); int orangefs_remount(struct super_block *sb);
int fsid_key_table_initialize(void); int fsid_key_table_initialize(void);
void fsid_key_table_finalize(void); void fsid_key_table_finalize(void);
@ -527,175 +527,175 @@ void fsid_key_table_finalize(void);
/* /*
* defined in inode.c * defined in inode.c
*/ */
__u32 convert_to_pvfs2_mask(unsigned long lite_mask); __u32 convert_to_orangefs_mask(unsigned long lite_mask);
struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *orangefs_new_inode(struct super_block *sb,
struct inode *dir, struct inode *dir,
int mode, int mode,
dev_t dev, dev_t dev,
struct pvfs2_object_kref *ref); struct orangefs_object_kref *ref);
int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr); int orangefs_setattr(struct dentry *dentry, struct iattr *iattr);
int pvfs2_getattr(struct vfsmount *mnt, int orangefs_getattr(struct vfsmount *mnt,
struct dentry *dentry, struct dentry *dentry,
struct kstat *kstat); struct kstat *kstat);
/* /*
* defined in xattr.c * defined in xattr.c
*/ */
int pvfs2_setxattr(struct dentry *dentry, int orangefs_setxattr(struct dentry *dentry,
const char *name, const char *name,
const void *value, const void *value,
size_t size, size_t size,
int flags); int flags);
ssize_t pvfs2_getxattr(struct dentry *dentry, ssize_t orangefs_getxattr(struct dentry *dentry,
const char *name, const char *name,
void *buffer, void *buffer,
size_t size); size_t size);
ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size); ssize_t orangefs_listxattr(struct dentry *dentry, char *buffer, size_t size);
/* /*
* defined in namei.c * defined in namei.c
*/ */
struct inode *pvfs2_iget(struct super_block *sb, struct inode *orangefs_iget(struct super_block *sb,
struct pvfs2_object_kref *ref); struct orangefs_object_kref *ref);
ssize_t pvfs2_inode_read(struct inode *inode, ssize_t orangefs_inode_read(struct inode *inode,
struct iov_iter *iter, struct iov_iter *iter,
loff_t *offset, loff_t *offset,
loff_t readahead_size); loff_t readahead_size);
/* /*
* defined in devpvfs2-req.c * defined in devorangefs-req.c
*/ */
int pvfs2_dev_init(void); int orangefs_dev_init(void);
void pvfs2_dev_cleanup(void); void orangefs_dev_cleanup(void);
int is_daemon_in_service(void); int is_daemon_in_service(void);
int fs_mount_pending(__s32 fsid); int fs_mount_pending(__s32 fsid);
/* /*
* defined in pvfs2-utils.c * defined in orangefs-utils.c
*/ */
__s32 fsid_of_op(struct pvfs2_kernel_op_s *op); __s32 fsid_of_op(struct orangefs_kernel_op_s *op);
int pvfs2_flush_inode(struct inode *inode); int orangefs_flush_inode(struct inode *inode);
ssize_t pvfs2_inode_getxattr(struct inode *inode, ssize_t orangefs_inode_getxattr(struct inode *inode,
const char *prefix, const char *prefix,
const char *name, const char *name,
void *buffer, void *buffer,
size_t size); size_t size);
int pvfs2_inode_setxattr(struct inode *inode, int orangefs_inode_setxattr(struct inode *inode,
const char *prefix, const char *prefix,
const char *name, const char *name,
const void *value, const void *value,
size_t size, size_t size,
int flags); int flags);
int pvfs2_inode_getattr(struct inode *inode, __u32 mask); int orangefs_inode_getattr(struct inode *inode, __u32 mask);
int pvfs2_inode_setattr(struct inode *inode, struct iattr *iattr); int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr);
void pvfs2_op_initialize(struct pvfs2_kernel_op_s *op); void orangefs_op_initialize(struct orangefs_kernel_op_s *op);
void pvfs2_make_bad_inode(struct inode *inode); void orangefs_make_bad_inode(struct inode *inode);
void block_signals(sigset_t *); void block_signals(sigset_t *);
void set_signals(sigset_t *); void set_signals(sigset_t *);
int pvfs2_unmount_sb(struct super_block *sb); int orangefs_unmount_sb(struct super_block *sb);
int pvfs2_cancel_op_in_progress(__u64 tag); int orangefs_cancel_op_in_progress(__u64 tag);
static inline __u64 pvfs2_convert_time_field(const struct timespec *ts) static inline __u64 orangefs_convert_time_field(const struct timespec *ts)
{ {
return (__u64)ts->tv_sec; return (__u64)ts->tv_sec;
} }
int pvfs2_normalize_to_errno(__s32 error_code); int orangefs_normalize_to_errno(__s32 error_code);
extern struct mutex devreq_mutex; extern struct mutex devreq_mutex;
extern struct mutex request_mutex; extern struct mutex request_mutex;
extern int debug; extern int debug;
extern int op_timeout_secs; extern int op_timeout_secs;
extern int slot_timeout_secs; extern int slot_timeout_secs;
extern struct list_head pvfs2_superblocks; extern struct list_head orangefs_superblocks;
extern spinlock_t pvfs2_superblocks_lock; extern spinlock_t orangefs_superblocks_lock;
extern struct list_head pvfs2_request_list; extern struct list_head orangefs_request_list;
extern spinlock_t pvfs2_request_list_lock; extern spinlock_t orangefs_request_list_lock;
extern wait_queue_head_t pvfs2_request_list_waitq; extern wait_queue_head_t orangefs_request_list_waitq;
extern struct list_head *htable_ops_in_progress; extern struct list_head *htable_ops_in_progress;
extern spinlock_t htable_ops_in_progress_lock; extern spinlock_t htable_ops_in_progress_lock;
extern int hash_table_size; extern int hash_table_size;
extern const struct address_space_operations pvfs2_address_operations; extern const struct address_space_operations orangefs_address_operations;
extern struct backing_dev_info pvfs2_backing_dev_info; extern struct backing_dev_info orangefs_backing_dev_info;
extern struct inode_operations pvfs2_file_inode_operations; extern struct inode_operations orangefs_file_inode_operations;
extern const struct file_operations pvfs2_file_operations; extern const struct file_operations orangefs_file_operations;
extern struct inode_operations pvfs2_symlink_inode_operations; extern struct inode_operations orangefs_symlink_inode_operations;
extern struct inode_operations pvfs2_dir_inode_operations; extern struct inode_operations orangefs_dir_inode_operations;
extern const struct file_operations pvfs2_dir_operations; extern const struct file_operations orangefs_dir_operations;
extern const struct dentry_operations pvfs2_dentry_operations; extern const struct dentry_operations orangefs_dentry_operations;
extern const struct file_operations pvfs2_devreq_file_operations; extern const struct file_operations orangefs_devreq_file_operations;
extern wait_queue_head_t pvfs2_bufmap_init_waitq; extern wait_queue_head_t orangefs_bufmap_init_waitq;
/* /*
* misc convenience macros * misc convenience macros
*/ */
#define add_op_to_request_list(op) \ #define add_op_to_request_list(op) \
do { \ do { \
spin_lock(&pvfs2_request_list_lock); \ spin_lock(&orangefs_request_list_lock); \
spin_lock(&op->lock); \ spin_lock(&op->lock); \
set_op_state_waiting(op); \ set_op_state_waiting(op); \
list_add_tail(&op->list, &pvfs2_request_list); \ list_add_tail(&op->list, &orangefs_request_list); \
spin_unlock(&pvfs2_request_list_lock); \ spin_unlock(&orangefs_request_list_lock); \
spin_unlock(&op->lock); \ spin_unlock(&op->lock); \
wake_up_interruptible(&pvfs2_request_list_waitq); \ wake_up_interruptible(&orangefs_request_list_waitq); \
} while (0) } while (0)
#define add_priority_op_to_request_list(op) \ #define add_priority_op_to_request_list(op) \
do { \ do { \
spin_lock(&pvfs2_request_list_lock); \ spin_lock(&orangefs_request_list_lock); \
spin_lock(&op->lock); \ spin_lock(&op->lock); \
set_op_state_waiting(op); \ set_op_state_waiting(op); \
\ \
list_add(&op->list, &pvfs2_request_list); \ list_add(&op->list, &orangefs_request_list); \
spin_unlock(&pvfs2_request_list_lock); \ spin_unlock(&orangefs_request_list_lock); \
spin_unlock(&op->lock); \ spin_unlock(&op->lock); \
wake_up_interruptible(&pvfs2_request_list_waitq); \ wake_up_interruptible(&orangefs_request_list_waitq); \
} while (0) } while (0)
#define remove_op_from_request_list(op) \ #define remove_op_from_request_list(op) \
do { \ do { \
struct list_head *tmp = NULL; \ struct list_head *tmp = NULL; \
struct list_head *tmp_safe = NULL; \ struct list_head *tmp_safe = NULL; \
struct pvfs2_kernel_op_s *tmp_op = NULL; \ struct orangefs_kernel_op_s *tmp_op = NULL; \
\ \
spin_lock(&pvfs2_request_list_lock); \ spin_lock(&orangefs_request_list_lock); \
list_for_each_safe(tmp, tmp_safe, &pvfs2_request_list) { \ list_for_each_safe(tmp, tmp_safe, &orangefs_request_list) { \
tmp_op = list_entry(tmp, \ tmp_op = list_entry(tmp, \
struct pvfs2_kernel_op_s, \ struct orangefs_kernel_op_s, \
list); \ list); \
if (tmp_op && (tmp_op == op)) { \ if (tmp_op && (tmp_op == op)) { \
list_del(&tmp_op->list); \ list_del(&tmp_op->list); \
break; \ break; \
} \ } \
} \ } \
spin_unlock(&pvfs2_request_list_lock); \ spin_unlock(&orangefs_request_list_lock); \
} while (0) } while (0)
#define PVFS2_OP_INTERRUPTIBLE 1 /* service_operation() is interruptible */ #define ORANGEFS_OP_INTERRUPTIBLE 1 /* service_operation() is interruptible */
#define PVFS2_OP_PRIORITY 2 /* service_operation() is high priority */ #define ORANGEFS_OP_PRIORITY 2 /* service_operation() is high priority */
#define PVFS2_OP_CANCELLATION 4 /* this is a cancellation */ #define ORANGEFS_OP_CANCELLATION 4 /* this is a cancellation */
#define PVFS2_OP_NO_SEMAPHORE 8 /* don't acquire semaphore */ #define ORANGEFS_OP_NO_SEMAPHORE 8 /* don't acquire semaphore */
#define PVFS2_OP_ASYNC 16 /* Queue it, but don't wait */ #define ORANGEFS_OP_ASYNC 16 /* Queue it, but don't wait */
int service_operation(struct pvfs2_kernel_op_s *op, int service_operation(struct orangefs_kernel_op_s *op,
const char *op_name, const char *op_name,
int flags); int flags);
@ -719,7 +719,7 @@ int service_operation(struct pvfs2_kernel_op_s *op,
* sent and have handle_error * sent and have handle_error
* take care of this situation as well.. * take care of this situation as well..
* *
* if a pvfs2 sysint level error occured and i/o has been completed, * if a orangefs sysint level error occured and i/o has been completed,
* there is no need to cancel the operation, as the user has finished * there is no need to cancel the operation, as the user has finished
* using the bufmap page and so there is no danger in this case. in * using the bufmap page and so there is no danger in this case. in
* this case, we wake up the device normally so that it may free the * this case, we wake up the device normally so that it may free the
@ -731,77 +731,77 @@ int service_operation(struct pvfs2_kernel_op_s *op,
#define handle_io_error() \ #define handle_io_error() \
do { \ do { \
if (!op_state_serviced(new_op)) { \ if (!op_state_serviced(new_op)) { \
pvfs2_cancel_op_in_progress(new_op->tag); \ orangefs_cancel_op_in_progress(new_op->tag); \
op_release(new_op); \ op_release(new_op); \
} else { \ } else { \
wake_up_daemon_for_return(new_op); \ wake_up_daemon_for_return(new_op); \
} \ } \
new_op = NULL; \ new_op = NULL; \
pvfs_bufmap_put(bufmap, buffer_index); \ orangefs_bufmap_put(bufmap, buffer_index); \
buffer_index = -1; \ buffer_index = -1; \
} while (0) } while (0)
#define get_interruptible_flag(inode) \ #define get_interruptible_flag(inode) \
((PVFS2_SB(inode->i_sb)->flags & PVFS2_OPT_INTR) ? \ ((ORANGEFS_SB(inode->i_sb)->flags & ORANGEFS_OPT_INTR) ? \
PVFS2_OP_INTERRUPTIBLE : 0) ORANGEFS_OP_INTERRUPTIBLE : 0)
#define add_pvfs2_sb(sb) \ #define add_orangefs_sb(sb) \
do { \ do { \
gossip_debug(GOSSIP_SUPER_DEBUG, \ gossip_debug(GOSSIP_SUPER_DEBUG, \
"Adding SB %p to pvfs2 superblocks\n", \ "Adding SB %p to orangefs superblocks\n", \
PVFS2_SB(sb)); \ ORANGEFS_SB(sb)); \
spin_lock(&pvfs2_superblocks_lock); \ spin_lock(&orangefs_superblocks_lock); \
list_add_tail(&PVFS2_SB(sb)->list, &pvfs2_superblocks); \ list_add_tail(&ORANGEFS_SB(sb)->list, &orangefs_superblocks); \
spin_unlock(&pvfs2_superblocks_lock); \ spin_unlock(&orangefs_superblocks_lock); \
} while (0) } while (0)
#define remove_pvfs2_sb(sb) \ #define remove_orangefs_sb(sb) \
do { \ do { \
struct list_head *tmp = NULL; \ struct list_head *tmp = NULL; \
struct list_head *tmp_safe = NULL; \ struct list_head *tmp_safe = NULL; \
struct pvfs2_sb_info_s *pvfs2_sb = NULL; \ struct orangefs_sb_info_s *orangefs_sb = NULL; \
\ \
spin_lock(&pvfs2_superblocks_lock); \ spin_lock(&orangefs_superblocks_lock); \
list_for_each_safe(tmp, tmp_safe, &pvfs2_superblocks) { \ list_for_each_safe(tmp, tmp_safe, &orangefs_superblocks) { \
pvfs2_sb = list_entry(tmp, \ orangefs_sb = list_entry(tmp, \
struct pvfs2_sb_info_s, \ struct orangefs_sb_info_s, \
list); \ list); \
if (pvfs2_sb && (pvfs2_sb->sb == sb)) { \ if (orangefs_sb && (orangefs_sb->sb == sb)) { \
gossip_debug(GOSSIP_SUPER_DEBUG, \ gossip_debug(GOSSIP_SUPER_DEBUG, \
"Removing SB %p from pvfs2 superblocks\n", \ "Removing SB %p from orangefs superblocks\n", \
pvfs2_sb); \ orangefs_sb); \
list_del(&pvfs2_sb->list); \ list_del(&orangefs_sb->list); \
break; \ break; \
} \ } \
} \ } \
spin_unlock(&pvfs2_superblocks_lock); \ spin_unlock(&orangefs_superblocks_lock); \
} while (0) } while (0)
#define pvfs2_lock_inode(inode) spin_lock(&inode->i_lock) #define orangefs_lock_inode(inode) spin_lock(&inode->i_lock)
#define pvfs2_unlock_inode(inode) spin_unlock(&inode->i_lock) #define orangefs_unlock_inode(inode) spin_unlock(&inode->i_lock)
#define fill_default_sys_attrs(sys_attr, type, mode) \ #define fill_default_sys_attrs(sys_attr, type, mode) \
do { \ do { \
sys_attr.owner = from_kuid(current_user_ns(), current_fsuid()); \ sys_attr.owner = from_kuid(current_user_ns(), current_fsuid()); \
sys_attr.group = from_kgid(current_user_ns(), current_fsgid()); \ sys_attr.group = from_kgid(current_user_ns(), current_fsgid()); \
sys_attr.size = 0; \ sys_attr.size = 0; \
sys_attr.perms = PVFS_util_translate_mode(mode); \ sys_attr.perms = ORANGEFS_util_translate_mode(mode); \
sys_attr.objtype = type; \ sys_attr.objtype = type; \
sys_attr.mask = PVFS_ATTR_SYS_ALL_SETABLE; \ sys_attr.mask = ORANGEFS_ATTR_SYS_ALL_SETABLE; \
} while (0) } while (0)
#define pvfs2_inode_lock(__i) mutex_lock(&(__i)->i_mutex) #define orangefs_inode_lock(__i) mutex_lock(&(__i)->i_mutex)
#define pvfs2_inode_unlock(__i) mutex_unlock(&(__i)->i_mutex) #define orangefs_inode_unlock(__i) mutex_unlock(&(__i)->i_mutex)
static inline void pvfs2_i_size_write(struct inode *inode, loff_t i_size) static inline void orangefs_i_size_write(struct inode *inode, loff_t i_size)
{ {
#if BITS_PER_LONG == 32 && defined(CONFIG_SMP) #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
pvfs2_inode_lock(inode); ornagefs_inode_lock(inode);
#endif #endif
i_size_write(inode, i_size); i_size_write(inode, i_size);
#if BITS_PER_LONG == 32 && defined(CONFIG_SMP) #if BITS_PER_LONG == 32 && defined(CONFIG_SMP)
pvfs2_inode_unlock(inode); orangefs_inode_unlock(inode);
#endif #endif
} }
@ -816,4 +816,4 @@ static inline unsigned int diff(struct timeval *end, struct timeval *begin)
return (end->tv_sec * 1000000) + end->tv_usec; return (end->tv_sec * 1000000) + end->tv_usec;
} }
#endif /* __PVFS2KERNEL_H */ #endif /* __ORANGEFSKERNEL_H */

106
fs/orangefs/pvfs2-mod.c
View file

@ -12,9 +12,9 @@
#include "pvfs2-debugfs.h" #include "pvfs2-debugfs.h"
#include "pvfs2-sysfs.h" #include "pvfs2-sysfs.h"
/* PVFS2_VERSION is a ./configure define */ /* ORANGEFS_VERSION is a ./configure define */
#ifndef PVFS2_VERSION #ifndef ORANGEFS_VERSION
#define PVFS2_VERSION "Unknown" #define ORANGEFS_VERSION "Unknown"
#endif #endif
/* /*
@ -25,9 +25,9 @@
struct client_debug_mask *cdm_array; struct client_debug_mask *cdm_array;
int cdm_element_count; int cdm_element_count;
char kernel_debug_string[PVFS2_MAX_DEBUG_STRING_LEN] = "none"; char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none";
char client_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
char client_debug_array_string[PVFS2_MAX_DEBUG_STRING_LEN]; char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN];
char *debug_help_string; char *debug_help_string;
int help_string_initialized; int help_string_initialized;
@ -36,7 +36,7 @@ struct dentry *client_debug_dentry;
struct dentry *debug_dir; struct dentry *debug_dir;
int client_verbose_index; int client_verbose_index;
int client_all_index; int client_all_index;
struct pvfs2_stats g_pvfs2_stats; struct orangefs_stats g_orangefs_stats;
/* the size of the hash tables for ops in progress */ /* the size of the hash tables for ops in progress */
int hash_table_size = 509; int hash_table_size = 509;
@ -45,22 +45,22 @@ static ulong module_parm_debug_mask;
__u64 gossip_debug_mask; __u64 gossip_debug_mask;
struct client_debug_mask client_debug_mask = { NULL, 0, 0 }; struct client_debug_mask client_debug_mask = { NULL, 0, 0 };
unsigned int kernel_mask_set_mod_init; /* implicitly false */ unsigned int kernel_mask_set_mod_init; /* implicitly false */
int op_timeout_secs = PVFS2_DEFAULT_OP_TIMEOUT_SECS; int op_timeout_secs = ORANGEFS_DEFAULT_OP_TIMEOUT_SECS;
int slot_timeout_secs = PVFS2_DEFAULT_SLOT_TIMEOUT_SECS; int slot_timeout_secs = ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS;
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_AUTHOR("PVFS2 Development Team"); MODULE_AUTHOR("ORANGEFS Development Team");
MODULE_DESCRIPTION("The Linux Kernel VFS interface to PVFS2"); MODULE_DESCRIPTION("The Linux Kernel VFS interface to ORANGEFS");
MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see pvfs2-debug.h for values)"); MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see orangefs-debug.h for values)");
MODULE_PARM_DESC(op_timeout_secs, "Operation timeout in seconds"); MODULE_PARM_DESC(op_timeout_secs, "Operation timeout in seconds");
MODULE_PARM_DESC(slot_timeout_secs, "Slot timeout in seconds"); MODULE_PARM_DESC(slot_timeout_secs, "Slot timeout in seconds");
MODULE_PARM_DESC(hash_table_size, MODULE_PARM_DESC(hash_table_size,
"size of hash table for operations in progress"); "size of hash table for operations in progress");
static struct file_system_type pvfs2_fs_type = { static struct file_system_type orangefs_fs_type = {
.name = "pvfs2", .name = "pvfs2",
.mount = pvfs2_mount, .mount = orangefs_mount,
.kill_sb = pvfs2_kill_sb, .kill_sb = orangefs_kill_sb,
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
@ -85,15 +85,15 @@ struct list_head *htable_ops_in_progress;
DEFINE_SPINLOCK(htable_ops_in_progress_lock); DEFINE_SPINLOCK(htable_ops_in_progress_lock);
/* list for queueing upcall operations */ /* list for queueing upcall operations */
LIST_HEAD(pvfs2_request_list); LIST_HEAD(orangefs_request_list);
/* used to protect the above pvfs2_request_list */ /* used to protect the above orangefs_request_list */
DEFINE_SPINLOCK(pvfs2_request_list_lock); DEFINE_SPINLOCK(orangefs_request_list_lock);
/* used for incoming request notification */ /* used for incoming request notification */
DECLARE_WAIT_QUEUE_HEAD(pvfs2_request_list_waitq); DECLARE_WAIT_QUEUE_HEAD(orangefs_request_list_waitq);
static int __init pvfs2_init(void) static int __init orangefs_init(void)
{ {
int ret = -1; int ret = -1;
__u32 i = 0; __u32 i = 0;
@ -112,7 +112,7 @@ static int __init pvfs2_init(void)
/* /*
* if the mask has a non-zero value, then indicate that the mask * if the mask has a non-zero value, then indicate that the mask
* was set when the kernel module was loaded. The pvfs2 dev ioctl * was set when the kernel module was loaded. The orangefs dev ioctl
* command will look at this boolean to determine if the kernel's * command will look at this boolean to determine if the kernel's
* debug mask should be overwritten when the client-core is started. * debug mask should be overwritten when the client-core is started.
*/ */
@ -120,11 +120,11 @@ static int __init pvfs2_init(void)
kernel_mask_set_mod_init = true; kernel_mask_set_mod_init = true;
/* print information message to the system log */ /* print information message to the system log */
pr_info("pvfs2: pvfs2_init called with debug mask: :%s: :%llx:\n", pr_info("orangefs: orangefs_init called with debug mask: :%s: :%llx:\n",
kernel_debug_string, kernel_debug_string,
(unsigned long long)gossip_debug_mask); (unsigned long long)gossip_debug_mask);
ret = bdi_init(&pvfs2_backing_dev_info); ret = bdi_init(&orangefs_backing_dev_info);
if (ret) if (ret)
return ret; return ret;
@ -144,7 +144,7 @@ static int __init pvfs2_init(void)
if (ret < 0) if (ret < 0)
goto cleanup_op; goto cleanup_op;
ret = pvfs2_inode_cache_initialize(); ret = orangefs_inode_cache_initialize();
if (ret < 0) if (ret < 0)
goto cleanup_req; goto cleanup_req;
@ -153,9 +153,9 @@ static int __init pvfs2_init(void)
goto cleanup_inode; goto cleanup_inode;
/* Initialize the pvfsdev subsystem. */ /* Initialize the pvfsdev subsystem. */
ret = pvfs2_dev_init(); ret = orangefs_dev_init();
if (ret < 0) { if (ret < 0) {
gossip_err("pvfs2: could not initialize device subsystem %d!\n", gossip_err("orangefs: could not initialize device subsystem %d!\n",
ret); ret);
goto cleanup_kiocb; goto cleanup_kiocb;
} }
@ -197,17 +197,17 @@ static int __init pvfs2_init(void)
if (ret) if (ret)
goto out; goto out;
pvfs2_debugfs_init(); orangefs_debugfs_init();
pvfs2_kernel_debug_init(); orangefs_kernel_debug_init();
orangefs_sysfs_init(); orangefs_sysfs_init();
ret = register_filesystem(&pvfs2_fs_type); ret = register_filesystem(&orangefs_fs_type);
if (ret == 0) { if (ret == 0) {
pr_info("pvfs2: module version %s loaded\n", PVFS2_VERSION); pr_info("orangefs: module version %s loaded\n", ORANGEFS_VERSION);
return 0; return 0;
} }
pvfs2_debugfs_cleanup(); orangefs_debugfs_cleanup();
orangefs_sysfs_exit(); orangefs_sysfs_exit();
fsid_key_table_finalize(); fsid_key_table_finalize();
@ -215,13 +215,13 @@ cleanup_progress_table:
kfree(htable_ops_in_progress); kfree(htable_ops_in_progress);
cleanup_device: cleanup_device:
pvfs2_dev_cleanup(); orangefs_dev_cleanup();
cleanup_kiocb: cleanup_kiocb:
kiocb_cache_finalize(); kiocb_cache_finalize();
cleanup_inode: cleanup_inode:
pvfs2_inode_cache_finalize(); orangefs_inode_cache_finalize();
cleanup_req: cleanup_req:
dev_req_cache_finalize(); dev_req_cache_finalize();
@ -230,29 +230,29 @@ cleanup_op:
op_cache_finalize(); op_cache_finalize();
err: err:
bdi_destroy(&pvfs2_backing_dev_info); bdi_destroy(&orangefs_backing_dev_info);
out: out:
return ret; return ret;
} }
static void __exit pvfs2_exit(void) static void __exit orangefs_exit(void)
{ {
int i = 0; int i = 0;
struct pvfs2_kernel_op_s *cur_op = NULL; struct orangefs_kernel_op_s *cur_op = NULL;
gossip_debug(GOSSIP_INIT_DEBUG, "pvfs2: pvfs2_exit called\n"); gossip_debug(GOSSIP_INIT_DEBUG, "orangefs: orangefs_exit called\n");
unregister_filesystem(&pvfs2_fs_type); unregister_filesystem(&orangefs_fs_type);
pvfs2_debugfs_cleanup(); orangefs_debugfs_cleanup();
orangefs_sysfs_exit(); orangefs_sysfs_exit();
fsid_key_table_finalize(); fsid_key_table_finalize();
pvfs2_dev_cleanup(); orangefs_dev_cleanup();
/* clear out all pending upcall op requests */ /* clear out all pending upcall op requests */
spin_lock(&pvfs2_request_list_lock); spin_lock(&orangefs_request_list_lock);
while (!list_empty(&pvfs2_request_list)) { while (!list_empty(&orangefs_request_list)) {
cur_op = list_entry(pvfs2_request_list.next, cur_op = list_entry(orangefs_request_list.next,
struct pvfs2_kernel_op_s, struct orangefs_kernel_op_s,
list); list);
list_del(&cur_op->list); list_del(&cur_op->list);
gossip_debug(GOSSIP_INIT_DEBUG, gossip_debug(GOSSIP_INIT_DEBUG,
@ -260,26 +260,26 @@ static void __exit pvfs2_exit(void)
cur_op->upcall.type); cur_op->upcall.type);
op_release(cur_op); op_release(cur_op);
} }
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
for (i = 0; i < hash_table_size; i++) for (i = 0; i < hash_table_size; i++)
while (!list_empty(&htable_ops_in_progress[i])) { while (!list_empty(&htable_ops_in_progress[i])) {
cur_op = list_entry(htable_ops_in_progress[i].next, cur_op = list_entry(htable_ops_in_progress[i].next,
struct pvfs2_kernel_op_s, struct orangefs_kernel_op_s,
list); list);
op_release(cur_op); op_release(cur_op);
} }
kiocb_cache_finalize(); kiocb_cache_finalize();
pvfs2_inode_cache_finalize(); orangefs_inode_cache_finalize();
dev_req_cache_finalize(); dev_req_cache_finalize();
op_cache_finalize(); op_cache_finalize();
kfree(htable_ops_in_progress); kfree(htable_ops_in_progress);
bdi_destroy(&pvfs2_backing_dev_info); bdi_destroy(&orangefs_backing_dev_info);
pr_info("pvfs2: module version %s unloaded\n", PVFS2_VERSION); pr_info("orangefs: module version %s unloaded\n", ORANGEFS_VERSION);
} }
/* /*
@ -291,8 +291,8 @@ void purge_inprogress_ops(void)
int i; int i;
for (i = 0; i < hash_table_size; i++) { for (i = 0; i < hash_table_size; i++) {
struct pvfs2_kernel_op_s *op; struct orangefs_kernel_op_s *op;
struct pvfs2_kernel_op_s *next; struct orangefs_kernel_op_s *next;
list_for_each_entry_safe(op, list_for_each_entry_safe(op,
next, next,
@ -311,5 +311,5 @@ void purge_inprogress_ops(void)
} }
} }
module_init(pvfs2_init); module_init(orangefs_init);
module_exit(pvfs2_exit); module_exit(orangefs_exit);

108
fs/orangefs/pvfs2-sysfs.c
View file

@ -669,13 +669,13 @@ static ssize_t sysfs_int_show(char *kobj_id, char *buf, void *attr)
rc = scnprintf(buf, rc = scnprintf(buf,
PAGE_SIZE, PAGE_SIZE,
"%lu\n", "%lu\n",
g_pvfs2_stats.reads); g_orangefs_stats.reads);
goto out; goto out;
} else if (!strcmp(stats_orangefs_attr->attr.name, "writes")) { } else if (!strcmp(stats_orangefs_attr->attr.name, "writes")) {
rc = scnprintf(buf, rc = scnprintf(buf,
PAGE_SIZE, PAGE_SIZE,
"%lu\n", "%lu\n",
g_pvfs2_stats.writes); g_orangefs_stats.writes);
goto out; goto out;
} else { } else {
goto out; goto out;
@ -752,7 +752,7 @@ out:
*/ */
static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr) static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
{ {
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
int rc = 0; int rc = 0;
char *ser_op_type = NULL; char *ser_op_type = NULL;
struct orangefs_attribute *orangefs_attr; struct orangefs_attribute *orangefs_attr;
@ -768,9 +768,9 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
kobj_id); kobj_id);
if (strcmp(kobj_id, PC_KOBJ_ID)) if (strcmp(kobj_id, PC_KOBJ_ID))
op_alloc_type = PVFS2_VFS_OP_PARAM; op_alloc_type = ORANGEFS_VFS_OP_PARAM;
else else
op_alloc_type = PVFS2_VFS_OP_PERF_COUNT; op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT;
new_op = op_alloc(op_alloc_type); new_op = op_alloc(op_alloc_type);
if (!new_op) { if (!new_op) {
@ -788,113 +788,113 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
} }
if (strcmp(kobj_id, PC_KOBJ_ID)) if (strcmp(kobj_id, PC_KOBJ_ID))
new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_GET; new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_GET;
if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) { if (!strcmp(kobj_id, ORANGEFS_KOBJ_ID)) {
orangefs_attr = (struct orangefs_attribute *)attr; orangefs_attr = (struct orangefs_attribute *)attr;
if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) if (!strcmp(orangefs_attr->attr.name, "perf_history_size"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_HISTORY_SIZE; ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
else if (!strcmp(orangefs_attr->attr.name, else if (!strcmp(orangefs_attr->attr.name,
"perf_time_interval_secs")) "perf_time_interval_secs"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS; ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
else if (!strcmp(orangefs_attr->attr.name, else if (!strcmp(orangefs_attr->attr.name,
"perf_counter_reset")) "perf_counter_reset"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_RESET; ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
} else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) { } else if (!strcmp(kobj_id, ACACHE_KOBJ_ID)) {
acache_attr = (struct acache_orangefs_attribute *)attr; acache_attr = (struct acache_orangefs_attribute *)attr;
if (!strcmp(acache_attr->attr.name, "timeout_msecs")) if (!strcmp(acache_attr->attr.name, "timeout_msecs"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS; ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
if (!strcmp(acache_attr->attr.name, "hard_limit")) if (!strcmp(acache_attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
if (!strcmp(acache_attr->attr.name, "soft_limit")) if (!strcmp(acache_attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
if (!strcmp(acache_attr->attr.name, "reclaim_percentage")) if (!strcmp(acache_attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) { } else if (!strcmp(kobj_id, CAPCACHE_KOBJ_ID)) {
capcache_attr = (struct capcache_orangefs_attribute *)attr; capcache_attr = (struct capcache_orangefs_attribute *)attr;
if (!strcmp(capcache_attr->attr.name, "timeout_secs")) if (!strcmp(capcache_attr->attr.name, "timeout_secs"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
if (!strcmp(capcache_attr->attr.name, "hard_limit")) if (!strcmp(capcache_attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
if (!strcmp(capcache_attr->attr.name, "soft_limit")) if (!strcmp(capcache_attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
if (!strcmp(capcache_attr->attr.name, "reclaim_percentage")) if (!strcmp(capcache_attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) { } else if (!strcmp(kobj_id, CCACHE_KOBJ_ID)) {
ccache_attr = (struct ccache_orangefs_attribute *)attr; ccache_attr = (struct ccache_orangefs_attribute *)attr;
if (!strcmp(ccache_attr->attr.name, "timeout_secs")) if (!strcmp(ccache_attr->attr.name, "timeout_secs"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS; ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
if (!strcmp(ccache_attr->attr.name, "hard_limit")) if (!strcmp(ccache_attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
if (!strcmp(ccache_attr->attr.name, "soft_limit")) if (!strcmp(ccache_attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
if (!strcmp(ccache_attr->attr.name, "reclaim_percentage")) if (!strcmp(ccache_attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) { } else if (!strcmp(kobj_id, NCACHE_KOBJ_ID)) {
ncache_attr = (struct ncache_orangefs_attribute *)attr; ncache_attr = (struct ncache_orangefs_attribute *)attr;
if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) if (!strcmp(ncache_attr->attr.name, "timeout_msecs"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS; ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
if (!strcmp(ncache_attr->attr.name, "hard_limit")) if (!strcmp(ncache_attr->attr.name, "hard_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
if (!strcmp(ncache_attr->attr.name, "soft_limit")) if (!strcmp(ncache_attr->attr.name, "soft_limit"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
if (!strcmp(ncache_attr->attr.name, "reclaim_percentage")) if (!strcmp(ncache_attr->attr.name, "reclaim_percentage"))
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
} else if (!strcmp(kobj_id, PC_KOBJ_ID)) { } else if (!strcmp(kobj_id, PC_KOBJ_ID)) {
pc_attr = (struct pc_orangefs_attribute *)attr; pc_attr = (struct pc_orangefs_attribute *)attr;
if (!strcmp(pc_attr->attr.name, ACACHE_KOBJ_ID)) if (!strcmp(pc_attr->attr.name, ACACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type = new_op->upcall.req.perf_count.type =
PVFS2_PERF_COUNT_REQUEST_ACACHE; ORANGEFS_PERF_COUNT_REQUEST_ACACHE;
if (!strcmp(pc_attr->attr.name, CAPCACHE_KOBJ_ID)) if (!strcmp(pc_attr->attr.name, CAPCACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type = new_op->upcall.req.perf_count.type =
PVFS2_PERF_COUNT_REQUEST_CAPCACHE; ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE;
if (!strcmp(pc_attr->attr.name, NCACHE_KOBJ_ID)) if (!strcmp(pc_attr->attr.name, NCACHE_KOBJ_ID))
new_op->upcall.req.perf_count.type = new_op->upcall.req.perf_count.type =
PVFS2_PERF_COUNT_REQUEST_NCACHE; ORANGEFS_PERF_COUNT_REQUEST_NCACHE;
} else { } else {
gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n", gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n",
@ -905,15 +905,15 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr)
if (strcmp(kobj_id, PC_KOBJ_ID)) if (strcmp(kobj_id, PC_KOBJ_ID))
ser_op_type = "pvfs2_param"; ser_op_type = "orangefs_param";
else else
ser_op_type = "pvfs2_perf_count"; ser_op_type = "orangefs_perf_count";
/* /*
* The service_operation will return an errno return code on * The service_operation will return an errno return code on
* error, and zero on success. * error, and zero on success.
*/ */
rc = service_operation(new_op, ser_op_type, PVFS2_OP_INTERRUPTIBLE); rc = service_operation(new_op, ser_op_type, ORANGEFS_OP_INTERRUPTIBLE);
out: out:
if (!rc) { if (!rc) {
@ -1025,7 +1025,7 @@ static ssize_t
*/ */
static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
{ {
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
int val = 0; int val = 0;
int rc = 0; int rc = 0;
struct orangefs_attribute *orangefs_attr; struct orangefs_attribute *orangefs_attr;
@ -1038,7 +1038,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"sysfs_service_op_store: id:%s:\n", "sysfs_service_op_store: id:%s:\n",
kobj_id); kobj_id);
new_op = op_alloc(PVFS2_VFS_OP_PARAM); new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
if (!new_op) { if (!new_op) {
rc = -ENOMEM; rc = -ENOMEM;
goto out; goto out;
@ -1066,7 +1066,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) { if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) {
if (val > 0) { if (val > 0) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_HISTORY_SIZE; ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1075,7 +1075,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"perf_time_interval_secs")) { "perf_time_interval_secs")) {
if (val > 0) { if (val > 0) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS; ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1084,7 +1084,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"perf_counter_reset")) { "perf_counter_reset")) {
if ((val == 0) || (val == 1)) { if ((val == 0) || (val == 1)) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_PERF_RESET; ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1097,7 +1097,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
if (!strcmp(acache_attr->attr.name, "hard_limit")) { if (!strcmp(acache_attr->attr.name, "hard_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1105,7 +1105,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(acache_attr->attr.name, "soft_limit")) { } else if (!strcmp(acache_attr->attr.name, "soft_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1114,7 +1114,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"reclaim_percentage")) { "reclaim_percentage")) {
if ((val > -1) && (val < 101)) { if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1122,7 +1122,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(acache_attr->attr.name, "timeout_msecs")) { } else if (!strcmp(acache_attr->attr.name, "timeout_msecs")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS; ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1135,7 +1135,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
if (!strcmp(capcache_attr->attr.name, "hard_limit")) { if (!strcmp(capcache_attr->attr.name, "hard_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1143,7 +1143,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(capcache_attr->attr.name, "soft_limit")) { } else if (!strcmp(capcache_attr->attr.name, "soft_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1152,7 +1152,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"reclaim_percentage")) { "reclaim_percentage")) {
if ((val > -1) && (val < 101)) { if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1160,7 +1160,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(capcache_attr->attr.name, "timeout_secs")) { } else if (!strcmp(capcache_attr->attr.name, "timeout_secs")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS; ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1173,7 +1173,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
if (!strcmp(ccache_attr->attr.name, "hard_limit")) { if (!strcmp(ccache_attr->attr.name, "hard_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1181,7 +1181,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(ccache_attr->attr.name, "soft_limit")) { } else if (!strcmp(ccache_attr->attr.name, "soft_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1190,7 +1190,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"reclaim_percentage")) { "reclaim_percentage")) {
if ((val > -1) && (val < 101)) { if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1198,7 +1198,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(ccache_attr->attr.name, "timeout_secs")) { } else if (!strcmp(ccache_attr->attr.name, "timeout_secs")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS; ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1211,7 +1211,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
if (!strcmp(ncache_attr->attr.name, "hard_limit")) { if (!strcmp(ncache_attr->attr.name, "hard_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT; ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1219,7 +1219,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(ncache_attr->attr.name, "soft_limit")) { } else if (!strcmp(ncache_attr->attr.name, "soft_limit")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT; ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1228,7 +1228,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
"reclaim_percentage")) { "reclaim_percentage")) {
if ((val > -1) && (val < 101)) { if ((val > -1) && (val < 101)) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE; ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1236,7 +1236,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
} else if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) { } else if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) {
if (val > -1) { if (val > -1) {
new_op->upcall.req.param.op = new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS; ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
} else { } else {
rc = 0; rc = 0;
goto out; goto out;
@ -1250,7 +1250,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
goto out; goto out;
} }
new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET; new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
new_op->upcall.req.param.value = val; new_op->upcall.req.param.value = val;
@ -1258,7 +1258,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr)
* The service_operation will return a errno return code on * The service_operation will return a errno return code on
* error, and zero on success. * error, and zero on success.
*/ */
rc = service_operation(new_op, "pvfs2_param", PVFS2_OP_INTERRUPTIBLE); rc = service_operation(new_op, "orangefs_param", ORANGEFS_OP_INTERRUPTIBLE);
if (rc < 0) { if (rc < 0) {
gossip_err("sysfs_service_op_store: service op returned:%d:\n", gossip_err("sysfs_service_op_store: service op returned:%d:\n",

336
fs/orangefs/pvfs2-utils.c
View file

@ -8,67 +8,67 @@
#include "pvfs2-dev-proto.h" #include "pvfs2-dev-proto.h"
#include "pvfs2-bufmap.h" #include "pvfs2-bufmap.h"
__s32 fsid_of_op(struct pvfs2_kernel_op_s *op) __s32 fsid_of_op(struct orangefs_kernel_op_s *op)
{ {
__s32 fsid = PVFS_FS_ID_NULL; __s32 fsid = ORANGEFS_FS_ID_NULL;
if (op) { if (op) {
switch (op->upcall.type) { switch (op->upcall.type) {
case PVFS2_VFS_OP_FILE_IO: case ORANGEFS_VFS_OP_FILE_IO:
fsid = op->upcall.req.io.refn.fs_id; fsid = op->upcall.req.io.refn.fs_id;
break; break;
case PVFS2_VFS_OP_LOOKUP: case ORANGEFS_VFS_OP_LOOKUP:
fsid = op->upcall.req.lookup.parent_refn.fs_id; fsid = op->upcall.req.lookup.parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_CREATE: case ORANGEFS_VFS_OP_CREATE:
fsid = op->upcall.req.create.parent_refn.fs_id; fsid = op->upcall.req.create.parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_GETATTR: case ORANGEFS_VFS_OP_GETATTR:
fsid = op->upcall.req.getattr.refn.fs_id; fsid = op->upcall.req.getattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_REMOVE: case ORANGEFS_VFS_OP_REMOVE:
fsid = op->upcall.req.remove.parent_refn.fs_id; fsid = op->upcall.req.remove.parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_MKDIR: case ORANGEFS_VFS_OP_MKDIR:
fsid = op->upcall.req.mkdir.parent_refn.fs_id; fsid = op->upcall.req.mkdir.parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_READDIR: case ORANGEFS_VFS_OP_READDIR:
fsid = op->upcall.req.readdir.refn.fs_id; fsid = op->upcall.req.readdir.refn.fs_id;
break; break;
case PVFS2_VFS_OP_SETATTR: case ORANGEFS_VFS_OP_SETATTR:
fsid = op->upcall.req.setattr.refn.fs_id; fsid = op->upcall.req.setattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_SYMLINK: case ORANGEFS_VFS_OP_SYMLINK:
fsid = op->upcall.req.sym.parent_refn.fs_id; fsid = op->upcall.req.sym.parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_RENAME: case ORANGEFS_VFS_OP_RENAME:
fsid = op->upcall.req.rename.old_parent_refn.fs_id; fsid = op->upcall.req.rename.old_parent_refn.fs_id;
break; break;
case PVFS2_VFS_OP_STATFS: case ORANGEFS_VFS_OP_STATFS:
fsid = op->upcall.req.statfs.fs_id; fsid = op->upcall.req.statfs.fs_id;
break; break;
case PVFS2_VFS_OP_TRUNCATE: case ORANGEFS_VFS_OP_TRUNCATE:
fsid = op->upcall.req.truncate.refn.fs_id; fsid = op->upcall.req.truncate.refn.fs_id;
break; break;
case PVFS2_VFS_OP_MMAP_RA_FLUSH: case ORANGEFS_VFS_OP_MMAP_RA_FLUSH:
fsid = op->upcall.req.ra_cache_flush.refn.fs_id; fsid = op->upcall.req.ra_cache_flush.refn.fs_id;
break; break;
case PVFS2_VFS_OP_FS_UMOUNT: case ORANGEFS_VFS_OP_FS_UMOUNT:
fsid = op->upcall.req.fs_umount.fs_id; fsid = op->upcall.req.fs_umount.fs_id;
break; break;
case PVFS2_VFS_OP_GETXATTR: case ORANGEFS_VFS_OP_GETXATTR:
fsid = op->upcall.req.getxattr.refn.fs_id; fsid = op->upcall.req.getxattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_SETXATTR: case ORANGEFS_VFS_OP_SETXATTR:
fsid = op->upcall.req.setxattr.refn.fs_id; fsid = op->upcall.req.setxattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_LISTXATTR: case ORANGEFS_VFS_OP_LISTXATTR:
fsid = op->upcall.req.listxattr.refn.fs_id; fsid = op->upcall.req.listxattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_REMOVEXATTR: case ORANGEFS_VFS_OP_REMOVEXATTR:
fsid = op->upcall.req.removexattr.refn.fs_id; fsid = op->upcall.req.removexattr.refn.fs_id;
break; break;
case PVFS2_VFS_OP_FSYNC: case ORANGEFS_VFS_OP_FSYNC:
fsid = op->upcall.req.fsync.refn.fs_id; fsid = op->upcall.req.fsync.refn.fs_id;
break; break;
default: default:
@ -78,20 +78,20 @@ __s32 fsid_of_op(struct pvfs2_kernel_op_s *op)
return fsid; return fsid;
} }
static void pvfs2_set_inode_flags(struct inode *inode, static void orangefs_set_inode_flags(struct inode *inode,
struct PVFS_sys_attr_s *attrs) struct ORANGEFS_sys_attr_s *attrs)
{ {
if (attrs->flags & PVFS_IMMUTABLE_FL) if (attrs->flags & ORANGEFS_IMMUTABLE_FL)
inode->i_flags |= S_IMMUTABLE; inode->i_flags |= S_IMMUTABLE;
else else
inode->i_flags &= ~S_IMMUTABLE; inode->i_flags &= ~S_IMMUTABLE;
if (attrs->flags & PVFS_APPEND_FL) if (attrs->flags & ORANGEFS_APPEND_FL)
inode->i_flags |= S_APPEND; inode->i_flags |= S_APPEND;
else else
inode->i_flags &= ~S_APPEND; inode->i_flags &= ~S_APPEND;
if (attrs->flags & PVFS_NOATIME_FL) if (attrs->flags & ORANGEFS_NOATIME_FL)
inode->i_flags |= S_NOATIME; inode->i_flags |= S_NOATIME;
else else
inode->i_flags &= ~S_NOATIME; inode->i_flags &= ~S_NOATIME;
@ -100,12 +100,12 @@ static void pvfs2_set_inode_flags(struct inode *inode,
/* NOTE: symname is ignored unless the inode is a sym link */ /* NOTE: symname is ignored unless the inode is a sym link */
static int copy_attributes_to_inode(struct inode *inode, static int copy_attributes_to_inode(struct inode *inode,
struct PVFS_sys_attr_s *attrs, struct ORANGEFS_sys_attr_s *attrs,
char *symname) char *symname)
{ {
int ret = -1; int ret = -1;
int perm_mode = 0; int perm_mode = 0;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
loff_t inode_size = 0; loff_t inode_size = 0;
loff_t rounded_up_size = 0; loff_t rounded_up_size = 0;
@ -127,24 +127,24 @@ static int copy_attributes_to_inode(struct inode *inode,
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"attrs->mask = %x (objtype = %s)\n", "attrs->mask = %x (objtype = %s)\n",
attrs->mask, attrs->mask,
attrs->objtype == PVFS_TYPE_METAFILE ? "file" : attrs->objtype == ORANGEFS_TYPE_METAFILE ? "file" :
attrs->objtype == PVFS_TYPE_DIRECTORY ? "directory" : attrs->objtype == ORANGEFS_TYPE_DIRECTORY ? "directory" :
attrs->objtype == PVFS_TYPE_SYMLINK ? "symlink" : attrs->objtype == ORANGEFS_TYPE_SYMLINK ? "symlink" :
"invalid/unknown"); "invalid/unknown");
switch (attrs->objtype) { switch (attrs->objtype) {
case PVFS_TYPE_METAFILE: case ORANGEFS_TYPE_METAFILE:
pvfs2_set_inode_flags(inode, attrs); orangefs_set_inode_flags(inode, attrs);
if (attrs->mask & PVFS_ATTR_SYS_SIZE) { if (attrs->mask & ORANGEFS_ATTR_SYS_SIZE) {
inode_size = (loff_t) attrs->size; inode_size = (loff_t) attrs->size;
rounded_up_size = rounded_up_size =
(inode_size + (4096 - (inode_size % 4096))); (inode_size + (4096 - (inode_size % 4096)));
pvfs2_lock_inode(inode); orangefs_lock_inode(inode);
inode->i_bytes = inode_size; inode->i_bytes = inode_size;
inode->i_blocks = inode->i_blocks =
(unsigned long)(rounded_up_size / 512); (unsigned long)(rounded_up_size / 512);
pvfs2_unlock_inode(inode); orangefs_unlock_inode(inode);
/* /*
* NOTE: make sure all the places we're called * NOTE: make sure all the places we're called
@ -155,7 +155,7 @@ static int copy_attributes_to_inode(struct inode *inode,
inode->i_size = inode_size; inode->i_size = inode_size;
} }
break; break;
case PVFS_TYPE_SYMLINK: case ORANGEFS_TYPE_SYMLINK:
if (symname != NULL) { if (symname != NULL) {
inode->i_size = (loff_t) strlen(symname); inode->i_size = (loff_t) strlen(symname);
break; break;
@ -164,9 +164,9 @@ static int copy_attributes_to_inode(struct inode *inode,
default: default:
inode->i_size = PAGE_CACHE_SIZE; inode->i_size = PAGE_CACHE_SIZE;
pvfs2_lock_inode(inode); orangefs_lock_inode(inode);
inode_set_bytes(inode, inode->i_size); inode_set_bytes(inode, inode->i_size);
pvfs2_unlock_inode(inode); orangefs_unlock_inode(inode);
break; break;
} }
@ -179,30 +179,30 @@ static int copy_attributes_to_inode(struct inode *inode,
inode->i_mtime.tv_nsec = 0; inode->i_mtime.tv_nsec = 0;
inode->i_ctime.tv_nsec = 0; inode->i_ctime.tv_nsec = 0;
if (attrs->perms & PVFS_O_EXECUTE) if (attrs->perms & ORANGEFS_O_EXECUTE)
perm_mode |= S_IXOTH; perm_mode |= S_IXOTH;
if (attrs->perms & PVFS_O_WRITE) if (attrs->perms & ORANGEFS_O_WRITE)
perm_mode |= S_IWOTH; perm_mode |= S_IWOTH;
if (attrs->perms & PVFS_O_READ) if (attrs->perms & ORANGEFS_O_READ)
perm_mode |= S_IROTH; perm_mode |= S_IROTH;
if (attrs->perms & PVFS_G_EXECUTE) if (attrs->perms & ORANGEFS_G_EXECUTE)
perm_mode |= S_IXGRP; perm_mode |= S_IXGRP;
if (attrs->perms & PVFS_G_WRITE) if (attrs->perms & ORANGEFS_G_WRITE)
perm_mode |= S_IWGRP; perm_mode |= S_IWGRP;
if (attrs->perms & PVFS_G_READ) if (attrs->perms & ORANGEFS_G_READ)
perm_mode |= S_IRGRP; perm_mode |= S_IRGRP;
if (attrs->perms & PVFS_U_EXECUTE) if (attrs->perms & ORANGEFS_U_EXECUTE)
perm_mode |= S_IXUSR; perm_mode |= S_IXUSR;
if (attrs->perms & PVFS_U_WRITE) if (attrs->perms & ORANGEFS_U_WRITE)
perm_mode |= S_IWUSR; perm_mode |= S_IWUSR;
if (attrs->perms & PVFS_U_READ) if (attrs->perms & ORANGEFS_U_READ)
perm_mode |= S_IRUSR; perm_mode |= S_IRUSR;
if (attrs->perms & PVFS_G_SGID) if (attrs->perms & ORANGEFS_G_SGID)
perm_mode |= S_ISGID; perm_mode |= S_ISGID;
if (attrs->perms & PVFS_U_SUID) if (attrs->perms & ORANGEFS_U_SUID)
perm_mode |= S_ISUID; perm_mode |= S_ISUID;
inode->i_mode = perm_mode; inode->i_mode = perm_mode;
@ -216,11 +216,11 @@ static int copy_attributes_to_inode(struct inode *inode,
} }
switch (attrs->objtype) { switch (attrs->objtype) {
case PVFS_TYPE_METAFILE: case ORANGEFS_TYPE_METAFILE:
inode->i_mode |= S_IFREG; inode->i_mode |= S_IFREG;
ret = 0; ret = 0;
break; break;
case PVFS_TYPE_DIRECTORY: case ORANGEFS_TYPE_DIRECTORY:
inode->i_mode |= S_IFDIR; inode->i_mode |= S_IFDIR;
/* NOTE: we have no good way to keep nlink consistent /* NOTE: we have no good way to keep nlink consistent
* for directories across clients; keep constant at 1. * for directories across clients; keep constant at 1.
@ -230,17 +230,17 @@ static int copy_attributes_to_inode(struct inode *inode,
set_nlink(inode, 1); set_nlink(inode, 1);
ret = 0; ret = 0;
break; break;
case PVFS_TYPE_SYMLINK: case ORANGEFS_TYPE_SYMLINK:
inode->i_mode |= S_IFLNK; inode->i_mode |= S_IFLNK;
/* copy link target to inode private data */ /* copy link target to inode private data */
if (pvfs2_inode && symname) { if (orangefs_inode && symname) {
strncpy(pvfs2_inode->link_target, strncpy(orangefs_inode->link_target,
symname, symname,
PVFS_NAME_MAX); ORANGEFS_NAME_MAX);
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"Copied attr link target %s\n", "Copied attr link target %s\n",
pvfs2_inode->link_target); orangefs_inode->link_target);
} }
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"symlink mode %o\n", "symlink mode %o\n",
@ -248,12 +248,12 @@ static int copy_attributes_to_inode(struct inode *inode,
ret = 0; ret = 0;
break; break;
default: default:
gossip_err("pvfs2: copy_attributes_to_inode: got invalid attribute type %x\n", gossip_err("orangefs: copy_attributes_to_inode: got invalid attribute type %x\n",
attrs->objtype); attrs->objtype);
} }
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2: copy_attributes_to_inode: setting i_mode to %o, i_size to %lu\n", "orangefs: copy_attributes_to_inode: setting i_mode to %o, i_size to %lu\n",
inode->i_mode, inode->i_mode,
(unsigned long)i_size_read(inode)); (unsigned long)i_size_read(inode));
@ -265,7 +265,7 @@ static int copy_attributes_to_inode(struct inode *inode,
* anything, so don't bother copying it into the sys_attr object here. * anything, so don't bother copying it into the sys_attr object here.
*/ */
static inline int copy_attributes_from_inode(struct inode *inode, static inline int copy_attributes_from_inode(struct inode *inode,
struct PVFS_sys_attr_s *attrs, struct ORANGEFS_sys_attr_s *attrs,
struct iattr *iattr) struct iattr *iattr)
{ {
umode_t tmp_mode; umode_t tmp_mode;
@ -285,36 +285,36 @@ static inline int copy_attributes_from_inode(struct inode *inode,
attrs->mask = 0; attrs->mask = 0;
if (iattr->ia_valid & ATTR_UID) { if (iattr->ia_valid & ATTR_UID) {
attrs->owner = from_kuid(current_user_ns(), iattr->ia_uid); attrs->owner = from_kuid(current_user_ns(), iattr->ia_uid);
attrs->mask |= PVFS_ATTR_SYS_UID; attrs->mask |= ORANGEFS_ATTR_SYS_UID;
gossip_debug(GOSSIP_UTILS_DEBUG, "(UID) %d\n", attrs->owner); gossip_debug(GOSSIP_UTILS_DEBUG, "(UID) %d\n", attrs->owner);
} }
if (iattr->ia_valid & ATTR_GID) { if (iattr->ia_valid & ATTR_GID) {
attrs->group = from_kgid(current_user_ns(), iattr->ia_gid); attrs->group = from_kgid(current_user_ns(), iattr->ia_gid);
attrs->mask |= PVFS_ATTR_SYS_GID; attrs->mask |= ORANGEFS_ATTR_SYS_GID;
gossip_debug(GOSSIP_UTILS_DEBUG, "(GID) %d\n", attrs->group); gossip_debug(GOSSIP_UTILS_DEBUG, "(GID) %d\n", attrs->group);
} }
if (iattr->ia_valid & ATTR_ATIME) { if (iattr->ia_valid & ATTR_ATIME) {
attrs->mask |= PVFS_ATTR_SYS_ATIME; attrs->mask |= ORANGEFS_ATTR_SYS_ATIME;
if (iattr->ia_valid & ATTR_ATIME_SET) { if (iattr->ia_valid & ATTR_ATIME_SET) {
attrs->atime = attrs->atime =
pvfs2_convert_time_field(&iattr->ia_atime); orangefs_convert_time_field(&iattr->ia_atime);
attrs->mask |= PVFS_ATTR_SYS_ATIME_SET; attrs->mask |= ORANGEFS_ATTR_SYS_ATIME_SET;
} }
} }
if (iattr->ia_valid & ATTR_MTIME) { if (iattr->ia_valid & ATTR_MTIME) {
attrs->mask |= PVFS_ATTR_SYS_MTIME; attrs->mask |= ORANGEFS_ATTR_SYS_MTIME;
if (iattr->ia_valid & ATTR_MTIME_SET) { if (iattr->ia_valid & ATTR_MTIME_SET) {
attrs->mtime = attrs->mtime =
pvfs2_convert_time_field(&iattr->ia_mtime); orangefs_convert_time_field(&iattr->ia_mtime);
attrs->mask |= PVFS_ATTR_SYS_MTIME_SET; attrs->mask |= ORANGEFS_ATTR_SYS_MTIME_SET;
} }
} }
if (iattr->ia_valid & ATTR_CTIME) if (iattr->ia_valid & ATTR_CTIME)
attrs->mask |= PVFS_ATTR_SYS_CTIME; attrs->mask |= ORANGEFS_ATTR_SYS_CTIME;
/* /*
* PVFS2 cannot set size with a setattr operation. Probably not likely * ORANGEFS cannot set size with a setattr operation. Probably not likely
* to be requested through the VFS, but just in case, don't worry about * to be requested through the VFS, but just in case, don't worry about
* ATTR_SIZE * ATTR_SIZE
*/ */
@ -342,21 +342,21 @@ static inline int copy_attributes_from_inode(struct inode *inode,
return -EINVAL; return -EINVAL;
} }
attrs->perms = PVFS_util_translate_mode(tmp_mode); attrs->perms = ORANGEFS_util_translate_mode(tmp_mode);
attrs->mask |= PVFS_ATTR_SYS_PERM; attrs->mask |= ORANGEFS_ATTR_SYS_PERM;
} }
return 0; return 0;
} }
/* /*
* issues a pvfs2 getattr request and fills in the appropriate inode * issues a orangefs getattr request and fills in the appropriate inode
* attributes if successful. returns 0 on success; -errno otherwise * attributes if successful. returns 0 on success; -errno otherwise
*/ */
int pvfs2_inode_getattr(struct inode *inode, __u32 getattr_mask) int orangefs_inode_getattr(struct inode *inode, __u32 getattr_mask)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret = -EINVAL; int ret = -EINVAL;
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
@ -364,10 +364,10 @@ int pvfs2_inode_getattr(struct inode *inode, __u32 getattr_mask)
__func__, __func__,
get_khandle_from_ino(inode)); get_khandle_from_ino(inode));
new_op = op_alloc(PVFS2_VFS_OP_GETATTR); new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.getattr.refn = pvfs2_inode->refn; new_op->upcall.req.getattr.refn = orangefs_inode->refn;
new_op->upcall.req.getattr.mask = getattr_mask; new_op->upcall.req.getattr.mask = getattr_mask;
ret = service_operation(new_op, __func__, ret = service_operation(new_op, __func__,
@ -384,17 +384,17 @@ int pvfs2_inode_getattr(struct inode *inode, __u32 getattr_mask)
} }
/* /*
* Store blksize in pvfs2 specific part of inode structure; we are * Store blksize in orangefs specific part of inode structure; we are
* only going to use this to report to stat to make sure it doesn't * only going to use this to report to stat to make sure it doesn't
* perturb any inode related code paths. * perturb any inode related code paths.
*/ */
if (new_op->downcall.resp.getattr.attributes.objtype == if (new_op->downcall.resp.getattr.attributes.objtype ==
PVFS_TYPE_METAFILE) { ORANGEFS_TYPE_METAFILE) {
pvfs2_inode->blksize = orangefs_inode->blksize =
new_op->downcall.resp.getattr.attributes.blksize; new_op->downcall.resp.getattr.attributes.blksize;
} else { } else {
/* mimic behavior of generic_fillattr() for other types. */ /* mimic behavior of generic_fillattr() for other types. */
pvfs2_inode->blksize = (1 << inode->i_blkbits); orangefs_inode->blksize = (1 << inode->i_blkbits);
} }
@ -402,8 +402,8 @@ out:
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"Getattr on handle %pU, " "Getattr on handle %pU, "
"fsid %d\n (inode ct = %d) returned %d\n", "fsid %d\n (inode ct = %d) returned %d\n",
&pvfs2_inode->refn.khandle, &orangefs_inode->refn.khandle,
pvfs2_inode->refn.fs_id, orangefs_inode->refn.fs_id,
(int)atomic_read(&inode->i_count), (int)atomic_read(&inode->i_count),
ret); ret);
@ -412,20 +412,20 @@ out:
} }
/* /*
* issues a pvfs2 setattr request to make sure the new attribute values * issues a orangefs setattr request to make sure the new attribute values
* take effect if successful. returns 0 on success; -errno otherwise * take effect if successful. returns 0 on success; -errno otherwise
*/ */
int pvfs2_inode_setattr(struct inode *inode, struct iattr *iattr) int orangefs_inode_setattr(struct inode *inode, struct iattr *iattr)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret; int ret;
new_op = op_alloc(PVFS2_VFS_OP_SETATTR); new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.setattr.refn = pvfs2_inode->refn; new_op->upcall.req.setattr.refn = orangefs_inode->refn;
ret = copy_attributes_from_inode(inode, ret = copy_attributes_from_inode(inode,
&new_op->upcall.req.setattr.attributes, &new_op->upcall.req.setattr.attributes,
iattr); iattr);
@ -438,7 +438,7 @@ int pvfs2_inode_setattr(struct inode *inode, struct iattr *iattr)
get_interruptible_flag(inode)); get_interruptible_flag(inode));
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_inode_setattr: returning %d\n", "orangefs_inode_setattr: returning %d\n",
ret); ret);
/* when request is serviced properly, free req op struct */ /* when request is serviced properly, free req op struct */
@ -449,16 +449,16 @@ int pvfs2_inode_setattr(struct inode *inode, struct iattr *iattr)
* ctime flags. * ctime flags.
*/ */
if (ret == 0) { if (ret == 0) {
ClearAtimeFlag(pvfs2_inode); ClearAtimeFlag(orangefs_inode);
ClearMtimeFlag(pvfs2_inode); ClearMtimeFlag(orangefs_inode);
ClearCtimeFlag(pvfs2_inode); ClearCtimeFlag(orangefs_inode);
ClearModeFlag(pvfs2_inode); ClearModeFlag(orangefs_inode);
} }
return ret; return ret;
} }
int pvfs2_flush_inode(struct inode *inode) int orangefs_flush_inode(struct inode *inode)
{ {
/* /*
* If it is a dirty inode, this function gets called. * If it is a dirty inode, this function gets called.
@ -472,7 +472,7 @@ int pvfs2_flush_inode(struct inode *inode)
int ctime_flag; int ctime_flag;
int atime_flag; int atime_flag;
int mode_flag; int mode_flag;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
memset(&wbattr, 0, sizeof(wbattr)); memset(&wbattr, 0, sizeof(wbattr));
@ -481,14 +481,14 @@ int pvfs2_flush_inode(struct inode *inode)
* will prevent multiple processes from all trying to flush the same * will prevent multiple processes from all trying to flush the same
* inode if they call close() simultaneously * inode if they call close() simultaneously
*/ */
mtime_flag = MtimeFlag(pvfs2_inode); mtime_flag = MtimeFlag(orangefs_inode);
ClearMtimeFlag(pvfs2_inode); ClearMtimeFlag(orangefs_inode);
ctime_flag = CtimeFlag(pvfs2_inode); ctime_flag = CtimeFlag(orangefs_inode);
ClearCtimeFlag(pvfs2_inode); ClearCtimeFlag(orangefs_inode);
atime_flag = AtimeFlag(pvfs2_inode); atime_flag = AtimeFlag(orangefs_inode);
ClearAtimeFlag(pvfs2_inode); ClearAtimeFlag(orangefs_inode);
mode_flag = ModeFlag(pvfs2_inode); mode_flag = ModeFlag(orangefs_inode);
ClearModeFlag(pvfs2_inode); ClearModeFlag(orangefs_inode);
/* -- Lazy atime,mtime and ctime update -- /* -- Lazy atime,mtime and ctime update --
* Note: all times are dictated by server in the new scheme * Note: all times are dictated by server in the new scheme
@ -510,56 +510,56 @@ int pvfs2_flush_inode(struct inode *inode)
} }
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"*********** pvfs2_flush_inode: %pU " "*********** orangefs_flush_inode: %pU "
"(ia_valid %d)\n", "(ia_valid %d)\n",
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
wbattr.ia_valid); wbattr.ia_valid);
if (wbattr.ia_valid == 0) { if (wbattr.ia_valid == 0) {
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_flush_inode skipping setattr()\n"); "orangefs_flush_inode skipping setattr()\n");
return 0; return 0;
} }
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_flush_inode (%pU) writing mode %o\n", "orangefs_flush_inode (%pU) writing mode %o\n",
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
inode->i_mode); inode->i_mode);
ret = pvfs2_inode_setattr(inode, &wbattr); ret = orangefs_inode_setattr(inode, &wbattr);
return ret; return ret;
} }
int pvfs2_unmount_sb(struct super_block *sb) int orangefs_unmount_sb(struct super_block *sb)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_unmount_sb called on sb %p\n", "orangefs_unmount_sb called on sb %p\n",
sb); sb);
new_op = op_alloc(PVFS2_VFS_OP_FS_UMOUNT); new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.fs_umount.id = PVFS2_SB(sb)->id; new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id;
new_op->upcall.req.fs_umount.fs_id = PVFS2_SB(sb)->fs_id; new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id;
strncpy(new_op->upcall.req.fs_umount.pvfs2_config_server, strncpy(new_op->upcall.req.fs_umount.orangefs_config_server,
PVFS2_SB(sb)->devname, ORANGEFS_SB(sb)->devname,
PVFS_MAX_SERVER_ADDR_LEN); ORANGEFS_MAX_SERVER_ADDR_LEN);
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"Attempting PVFS2 Unmount via host %s\n", "Attempting ORANGEFS Unmount via host %s\n",
new_op->upcall.req.fs_umount.pvfs2_config_server); new_op->upcall.req.fs_umount.orangefs_config_server);
ret = service_operation(new_op, "pvfs2_fs_umount", 0); ret = service_operation(new_op, "orangefs_fs_umount", 0);
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_unmount: got return value of %d\n", ret); "orangefs_unmount: got return value of %d\n", ret);
if (ret) if (ret)
sb = ERR_PTR(ret); sb = ERR_PTR(ret);
else else
PVFS2_SB(sb)->mount_pending = 1; ORANGEFS_SB(sb)->mount_pending = 1;
op_release(new_op); op_release(new_op);
return ret; return ret;
@ -569,42 +569,42 @@ int pvfs2_unmount_sb(struct super_block *sb)
* NOTE: on successful cancellation, be sure to return -EINTR, as * NOTE: on successful cancellation, be sure to return -EINTR, as
* that's the return value the caller expects * that's the return value the caller expects
*/ */
int pvfs2_cancel_op_in_progress(__u64 tag) int orangefs_cancel_op_in_progress(__u64 tag)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_cancel_op_in_progress called on tag %llu\n", "orangefs_cancel_op_in_progress called on tag %llu\n",
llu(tag)); llu(tag));
new_op = op_alloc(PVFS2_VFS_OP_CANCEL); new_op = op_alloc(ORANGEFS_VFS_OP_CANCEL);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
new_op->upcall.req.cancel.op_tag = tag; new_op->upcall.req.cancel.op_tag = tag;
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"Attempting PVFS2 operation cancellation of tag %llu\n", "Attempting ORANGEFS operation cancellation of tag %llu\n",
llu(new_op->upcall.req.cancel.op_tag)); llu(new_op->upcall.req.cancel.op_tag));
ret = service_operation(new_op, "pvfs2_cancel", PVFS2_OP_CANCELLATION); ret = service_operation(new_op, "orangefs_cancel", ORANGEFS_OP_CANCELLATION);
gossip_debug(GOSSIP_UTILS_DEBUG, gossip_debug(GOSSIP_UTILS_DEBUG,
"pvfs2_cancel_op_in_progress: got return value of %d\n", "orangefs_cancel_op_in_progress: got return value of %d\n",
ret); ret);
op_release(new_op); op_release(new_op);
return ret; return ret;
} }
void pvfs2_op_initialize(struct pvfs2_kernel_op_s *op) void orangefs_op_initialize(struct orangefs_kernel_op_s *op)
{ {
if (op) { if (op) {
spin_lock(&op->lock); spin_lock(&op->lock);
op->io_completed = 0; op->io_completed = 0;
op->upcall.type = PVFS2_VFS_OP_INVALID; op->upcall.type = ORANGEFS_VFS_OP_INVALID;
op->downcall.type = PVFS2_VFS_OP_INVALID; op->downcall.type = ORANGEFS_VFS_OP_INVALID;
op->downcall.status = -1; op->downcall.status = -1;
op->op_state = OP_VFS_STATE_UNKNOWN; op->op_state = OP_VFS_STATE_UNKNOWN;
@ -613,7 +613,7 @@ void pvfs2_op_initialize(struct pvfs2_kernel_op_s *op)
} }
} }
void pvfs2_make_bad_inode(struct inode *inode) void orangefs_make_bad_inode(struct inode *inode)
{ {
if (is_root_handle(inode)) { if (is_root_handle(inode)) {
/* /*
@ -655,10 +655,10 @@ void set_signals(sigset_t *sigset)
/* /*
* The following is a very dirty hack that is now a permanent part of the * The following is a very dirty hack that is now a permanent part of the
* PVFS2 protocol. See protocol.h for more error definitions. * ORANGEFS protocol. See protocol.h for more error definitions.
*/ */
/* The order matches include/pvfs2-types.h in the OrangeFS source. */ /* The order matches include/orangefs-types.h in the OrangeFS source. */
static int PINT_errno_mapping[] = { static int PINT_errno_mapping[] = {
0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM, 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM,
EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE, EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE,
@ -672,7 +672,7 @@ static int PINT_errno_mapping[] = {
EACCES, ECONNRESET, ERANGE EACCES, ECONNRESET, ERANGE
}; };
int pvfs2_normalize_to_errno(__s32 error_code) int orangefs_normalize_to_errno(__s32 error_code)
{ {
__u32 i; __u32 i;
@ -684,24 +684,24 @@ int pvfs2_normalize_to_errno(__s32 error_code)
* server. * server.
*/ */
} else if (error_code > 0) { } else if (error_code > 0) {
gossip_err("pvfs2: error status receieved.\n"); gossip_err("orangefs: error status receieved.\n");
gossip_err("pvfs2: assuming error code is inverted.\n"); gossip_err("orangefs: assuming error code is inverted.\n");
error_code = -error_code; error_code = -error_code;
} }
/* /*
* XXX: This is very bad since error codes from PVFS2 may not be * XXX: This is very bad since error codes from ORANGEFS may not be
* suitable for return into userspace. * suitable for return into userspace.
*/ */
/* /*
* Convert PVFS2 error values into errno values suitable for return * Convert ORANGEFS error values into errno values suitable for return
* from the kernel. * from the kernel.
*/ */
if ((-error_code) & PVFS_NON_ERRNO_ERROR_BIT) { if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) {
if (((-error_code) & if (((-error_code) &
(PVFS_ERROR_NUMBER_BITS|PVFS_NON_ERRNO_ERROR_BIT| (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT|
PVFS_ERROR_BIT)) == PVFS_ECANCEL) { ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) {
/* /*
* cancellation error codes generally correspond to * cancellation error codes generally correspond to
* a timeout from the client's perspective * a timeout from the client's perspective
@ -709,30 +709,30 @@ int pvfs2_normalize_to_errno(__s32 error_code)
error_code = -ETIMEDOUT; error_code = -ETIMEDOUT;
} else { } else {
/* assume a default error code */ /* assume a default error code */
gossip_err("pvfs2: warning: got error code without errno equivalent: %d.\n", error_code); gossip_err("orangefs: warning: got error code without errno equivalent: %d.\n", error_code);
error_code = -EINVAL; error_code = -EINVAL;
} }
/* Convert PVFS2 encoded errno values into regular errno values. */ /* Convert ORANGEFS encoded errno values into regular errno values. */
} else if ((-error_code) & PVFS_ERROR_BIT) { } else if ((-error_code) & ORANGEFS_ERROR_BIT) {
i = (-error_code) & ~(PVFS_ERROR_BIT|PVFS_ERROR_CLASS_BITS); i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS);
if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping)) if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping))
error_code = -PINT_errno_mapping[i]; error_code = -PINT_errno_mapping[i];
else else
error_code = -EINVAL; error_code = -EINVAL;
/* /*
* Only PVFS2 protocol error codes should ever come here. Otherwise * Only ORANGEFS protocol error codes should ever come here. Otherwise
* there is a bug somewhere. * there is a bug somewhere.
*/ */
} else { } else {
gossip_err("pvfs2: pvfs2_normalize_to_errno: got error code which is not from PVFS2.\n"); gossip_err("orangefs: orangefs_normalize_to_errno: got error code which is not from ORANGEFS.\n");
} }
return error_code; return error_code;
} }
#define NUM_MODES 11 #define NUM_MODES 11
__s32 PVFS_util_translate_mode(int mode) __s32 ORANGEFS_util_translate_mode(int mode)
{ {
int ret = 0; int ret = 0;
int i = 0; int i = 0;
@ -742,16 +742,16 @@ __s32 PVFS_util_translate_mode(int mode)
S_IXUSR, S_IWUSR, S_IRUSR, S_IXUSR, S_IWUSR, S_IRUSR,
S_ISGID, S_ISUID S_ISGID, S_ISUID
}; };
static int pvfs2_modes[NUM_MODES] = { static int orangefs_modes[NUM_MODES] = {
PVFS_O_EXECUTE, PVFS_O_WRITE, PVFS_O_READ, ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ,
PVFS_G_EXECUTE, PVFS_G_WRITE, PVFS_G_READ, ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ,
PVFS_U_EXECUTE, PVFS_U_WRITE, PVFS_U_READ, ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ,
PVFS_G_SGID, PVFS_U_SUID ORANGEFS_G_SGID, ORANGEFS_U_SUID
}; };
for (i = 0; i < NUM_MODES; i++) for (i = 0; i < NUM_MODES; i++)
if (mode & modes[i]) if (mode & modes[i])
ret |= pvfs2_modes[i]; ret |= orangefs_modes[i];
return ret; return ret;
} }
@ -813,10 +813,10 @@ int orangefs_prepare_cdm_array(char *debug_array_string)
(unsigned long long *)&(cdm_array[i].mask1), (unsigned long long *)&(cdm_array[i].mask1),
(unsigned long long *)&(cdm_array[i].mask2)); (unsigned long long *)&(cdm_array[i].mask2));
if (!strcmp(cdm_array[i].keyword, PVFS2_VERBOSE)) if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE))
client_verbose_index = i; client_verbose_index = i;
if (!strcmp(cdm_array[i].keyword, PVFS2_ALL)) if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL))
client_all_index = i; client_all_index = i;
cds_head = cds_delimiter + 1; cds_head = cds_delimiter + 1;
@ -952,7 +952,7 @@ void debug_mask_to_string(void *mask, int type)
element_count = num_kmod_keyword_mask_map; element_count = num_kmod_keyword_mask_map;
} }
memset(debug_string, 0, PVFS2_MAX_DEBUG_STRING_LEN); memset(debug_string, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
/* /*
* Some keywords, like "all" or "verbose", are amalgams of * Some keywords, like "all" or "verbose", are amalgams of
@ -998,13 +998,13 @@ void do_k_string(void *k_mask, int index)
if (*mask & s_kmod_keyword_mask_map[index].mask_val) { if (*mask & s_kmod_keyword_mask_map[index].mask_val) {
if ((strlen(kernel_debug_string) + if ((strlen(kernel_debug_string) +
strlen(s_kmod_keyword_mask_map[index].keyword)) strlen(s_kmod_keyword_mask_map[index].keyword))
< PVFS2_MAX_DEBUG_STRING_LEN - 1) { < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) {
strcat(kernel_debug_string, strcat(kernel_debug_string,
s_kmod_keyword_mask_map[index].keyword); s_kmod_keyword_mask_map[index].keyword);
strcat(kernel_debug_string, ","); strcat(kernel_debug_string, ",");
} else { } else {
gossip_err("%s: overflow!\n", __func__); gossip_err("%s: overflow!\n", __func__);
strcpy(kernel_debug_string, PVFS2_ALL); strcpy(kernel_debug_string, ORANGEFS_ALL);
goto out; goto out;
} }
} }
@ -1025,13 +1025,13 @@ void do_c_string(void *c_mask, int index)
(mask->mask2 & cdm_array[index].mask2)) { (mask->mask2 & cdm_array[index].mask2)) {
if ((strlen(client_debug_string) + if ((strlen(client_debug_string) +
strlen(cdm_array[index].keyword) + 1) strlen(cdm_array[index].keyword) + 1)
< PVFS2_MAX_DEBUG_STRING_LEN - 2) { < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) {
strcat(client_debug_string, strcat(client_debug_string,
cdm_array[index].keyword); cdm_array[index].keyword);
strcat(client_debug_string, ","); strcat(client_debug_string, ",");
} else { } else {
gossip_err("%s: overflow!\n", __func__); gossip_err("%s: overflow!\n", __func__);
strcpy(client_debug_string, PVFS2_ALL); strcpy(client_debug_string, ORANGEFS_ALL);
goto out; goto out;
} }
} }
@ -1043,7 +1043,7 @@ int keyword_is_amalgam(char *keyword)
{ {
int rc = 0; int rc = 0;
if ((!strcmp(keyword, PVFS2_ALL)) || (!strcmp(keyword, PVFS2_VERBOSE))) if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE)))
rc = 1; rc = 1;
return rc; return rc;
@ -1067,14 +1067,14 @@ int check_amalgam_keyword(void *mask, int type)
if ((c_mask->mask1 == cdm_array[client_all_index].mask1) && if ((c_mask->mask1 == cdm_array[client_all_index].mask1) &&
(c_mask->mask2 == cdm_array[client_all_index].mask2)) { (c_mask->mask2 == cdm_array[client_all_index].mask2)) {
strcpy(client_debug_string, PVFS2_ALL); strcpy(client_debug_string, ORANGEFS_ALL);
rc = 1; rc = 1;
goto out; goto out;
} }
if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) && if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) &&
(c_mask->mask2 == cdm_array[client_verbose_index].mask2)) { (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) {
strcpy(client_debug_string, PVFS2_VERBOSE); strcpy(client_debug_string, ORANGEFS_VERBOSE);
rc = 1; rc = 1;
goto out; goto out;
} }
@ -1083,7 +1083,7 @@ int check_amalgam_keyword(void *mask, int type)
k_mask = (__u64 *) mask; k_mask = (__u64 *) mask;
if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) { if (*k_mask >= s_kmod_keyword_mask_map[k_all_index].mask_val) {
strcpy(kernel_debug_string, PVFS2_ALL); strcpy(kernel_debug_string, ORANGEFS_ALL);
rc = 1; rc = 1;
goto out; goto out;
} }

280
fs/orangefs/super.c
View file

@ -10,13 +10,13 @@
#include <linux/parser.h> #include <linux/parser.h>
/* a cache for pvfs2-inode objects (i.e. pvfs2 inode private data) */ /* a cache for orangefs-inode objects (i.e. orangefs inode private data) */
static struct kmem_cache *pvfs2_inode_cache; static struct kmem_cache *orangefs_inode_cache;
/* list for storing pvfs2 specific superblocks in use */ /* list for storing orangefs specific superblocks in use */
LIST_HEAD(pvfs2_superblocks); LIST_HEAD(orangefs_superblocks);
DEFINE_SPINLOCK(pvfs2_superblocks_lock); DEFINE_SPINLOCK(orangefs_superblocks_lock);
enum { enum {
Opt_intr, Opt_intr,
@ -37,7 +37,7 @@ static const match_table_t tokens = {
static int parse_mount_options(struct super_block *sb, char *options, static int parse_mount_options(struct super_block *sb, char *options,
int silent) int silent)
{ {
struct pvfs2_sb_info_s *pvfs2_sb = PVFS2_SB(sb); struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(sb);
substring_t args[MAX_OPT_ARGS]; substring_t args[MAX_OPT_ARGS];
char *p; char *p;
@ -46,8 +46,8 @@ static int parse_mount_options(struct super_block *sb, char *options,
* to zero, ie, initialize to unset. * to zero, ie, initialize to unset.
*/ */
sb->s_flags &= ~MS_POSIXACL; sb->s_flags &= ~MS_POSIXACL;
pvfs2_sb->flags &= ~PVFS2_OPT_INTR; orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;
pvfs2_sb->flags &= ~PVFS2_OPT_LOCAL_LOCK; orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;
while ((p = strsep(&options, ",")) != NULL) { while ((p = strsep(&options, ",")) != NULL) {
int token; int token;
@ -61,10 +61,10 @@ static int parse_mount_options(struct super_block *sb, char *options,
sb->s_flags |= MS_POSIXACL; sb->s_flags |= MS_POSIXACL;
break; break;
case Opt_intr: case Opt_intr:
pvfs2_sb->flags |= PVFS2_OPT_INTR; orangefs_sb->flags |= ORANGEFS_OPT_INTR;
break; break;
case Opt_local_lock: case Opt_local_lock:
pvfs2_sb->flags |= PVFS2_OPT_LOCAL_LOCK; orangefs_sb->flags |= ORANGEFS_OPT_LOCAL_LOCK;
break; break;
default: default:
goto fail; goto fail;
@ -78,24 +78,24 @@ fail:
return -EINVAL; return -EINVAL;
} }
static void pvfs2_inode_cache_ctor(void *req) static void orangefs_inode_cache_ctor(void *req)
{ {
struct pvfs2_inode_s *pvfs2_inode = req; struct orangefs_inode_s *orangefs_inode = req;
inode_init_once(&pvfs2_inode->vfs_inode); inode_init_once(&orangefs_inode->vfs_inode);
init_rwsem(&pvfs2_inode->xattr_sem); init_rwsem(&orangefs_inode->xattr_sem);
pvfs2_inode->vfs_inode.i_version = 1; orangefs_inode->vfs_inode.i_version = 1;
} }
static struct inode *pvfs2_alloc_inode(struct super_block *sb) static struct inode *orangefs_alloc_inode(struct super_block *sb)
{ {
struct pvfs2_inode_s *pvfs2_inode; struct orangefs_inode_s *orangefs_inode;
pvfs2_inode = kmem_cache_alloc(pvfs2_inode_cache, orangefs_inode = kmem_cache_alloc(orangefs_inode_cache,
PVFS2_CACHE_ALLOC_FLAGS); ORANGEFS_CACHE_ALLOC_FLAGS);
if (pvfs2_inode == NULL) { if (orangefs_inode == NULL) {
gossip_err("Failed to allocate pvfs2_inode\n"); gossip_err("Failed to allocate orangefs_inode\n");
return NULL; return NULL;
} }
@ -103,71 +103,71 @@ static struct inode *pvfs2_alloc_inode(struct super_block *sb)
* We want to clear everything except for rw_semaphore and the * We want to clear everything except for rw_semaphore and the
* vfs_inode. * vfs_inode.
*/ */
memset(&pvfs2_inode->refn.khandle, 0, 16); memset(&orangefs_inode->refn.khandle, 0, 16);
pvfs2_inode->refn.fs_id = PVFS_FS_ID_NULL; orangefs_inode->refn.fs_id = ORANGEFS_FS_ID_NULL;
pvfs2_inode->last_failed_block_index_read = 0; orangefs_inode->last_failed_block_index_read = 0;
memset(pvfs2_inode->link_target, 0, sizeof(pvfs2_inode->link_target)); memset(orangefs_inode->link_target, 0, sizeof(orangefs_inode->link_target));
pvfs2_inode->pinode_flags = 0; orangefs_inode->pinode_flags = 0;
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_alloc_inode: allocated %p\n", "orangefs_alloc_inode: allocated %p\n",
&pvfs2_inode->vfs_inode); &orangefs_inode->vfs_inode);
return &pvfs2_inode->vfs_inode; return &orangefs_inode->vfs_inode;
} }
static void pvfs2_destroy_inode(struct inode *inode) static void orangefs_destroy_inode(struct inode *inode)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"%s: deallocated %p destroying inode %pU\n", "%s: deallocated %p destroying inode %pU\n",
__func__, pvfs2_inode, get_khandle_from_ino(inode)); __func__, orangefs_inode, get_khandle_from_ino(inode));
kmem_cache_free(pvfs2_inode_cache, pvfs2_inode); kmem_cache_free(orangefs_inode_cache, orangefs_inode);
} }
/* /*
* NOTE: information filled in here is typically reflected in the * NOTE: information filled in here is typically reflected in the
* output of the system command 'df' * output of the system command 'df'
*/ */
static int pvfs2_statfs(struct dentry *dentry, struct kstatfs *buf) static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf)
{ {
int ret = -ENOMEM; int ret = -ENOMEM;
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
int flags = 0; int flags = 0;
struct super_block *sb = NULL; struct super_block *sb = NULL;
sb = dentry->d_sb; sb = dentry->d_sb;
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_statfs: called on sb %p (fs_id is %d)\n", "orangefs_statfs: called on sb %p (fs_id is %d)\n",
sb, sb,
(int)(PVFS2_SB(sb)->fs_id)); (int)(ORANGEFS_SB(sb)->fs_id));
new_op = op_alloc(PVFS2_VFS_OP_STATFS); new_op = op_alloc(ORANGEFS_VFS_OP_STATFS);
if (!new_op) if (!new_op)
return ret; return ret;
new_op->upcall.req.statfs.fs_id = PVFS2_SB(sb)->fs_id; new_op->upcall.req.statfs.fs_id = ORANGEFS_SB(sb)->fs_id;
if (PVFS2_SB(sb)->flags & PVFS2_OPT_INTR) if (ORANGEFS_SB(sb)->flags & ORANGEFS_OPT_INTR)
flags = PVFS2_OP_INTERRUPTIBLE; flags = ORANGEFS_OP_INTERRUPTIBLE;
ret = service_operation(new_op, "pvfs2_statfs", flags); ret = service_operation(new_op, "orangefs_statfs", flags);
if (new_op->downcall.status < 0) if (new_op->downcall.status < 0)
goto out_op_release; goto out_op_release;
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_statfs: got %ld blocks available | " "orangefs_statfs: got %ld blocks available | "
"%ld blocks total | %ld block size\n", "%ld blocks total | %ld block size\n",
(long)new_op->downcall.resp.statfs.blocks_avail, (long)new_op->downcall.resp.statfs.blocks_avail,
(long)new_op->downcall.resp.statfs.blocks_total, (long)new_op->downcall.resp.statfs.blocks_total,
(long)new_op->downcall.resp.statfs.block_size); (long)new_op->downcall.resp.statfs.block_size);
buf->f_type = sb->s_magic; buf->f_type = sb->s_magic;
memcpy(&buf->f_fsid, &PVFS2_SB(sb)->fs_id, sizeof(buf->f_fsid)); memcpy(&buf->f_fsid, &ORANGEFS_SB(sb)->fs_id, sizeof(buf->f_fsid));
buf->f_bsize = new_op->downcall.resp.statfs.block_size; buf->f_bsize = new_op->downcall.resp.statfs.block_size;
buf->f_namelen = PVFS2_NAME_LEN; buf->f_namelen = ORANGEFS_NAME_LEN;
buf->f_blocks = (sector_t) new_op->downcall.resp.statfs.blocks_total; buf->f_blocks = (sector_t) new_op->downcall.resp.statfs.blocks_total;
buf->f_bfree = (sector_t) new_op->downcall.resp.statfs.blocks_avail; buf->f_bfree = (sector_t) new_op->downcall.resp.statfs.blocks_avail;
@ -178,7 +178,7 @@ static int pvfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
out_op_release: out_op_release:
op_release(new_op); op_release(new_op);
gossip_debug(GOSSIP_SUPER_DEBUG, "pvfs2_statfs: returning %d\n", ret); gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_statfs: returning %d\n", ret);
return ret; return ret;
} }
@ -186,9 +186,9 @@ out_op_release:
* Remount as initiated by VFS layer. We just need to reparse the mount * Remount as initiated by VFS layer. We just need to reparse the mount
* options, no need to signal pvfs2-client-core about it. * options, no need to signal pvfs2-client-core about it.
*/ */
static int pvfs2_remount_fs(struct super_block *sb, int *flags, char *data) static int orangefs_remount_fs(struct super_block *sb, int *flags, char *data)
{ {
gossip_debug(GOSSIP_SUPER_DEBUG, "pvfs2_remount_fs: called\n"); gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount_fs: called\n");
return parse_mount_options(sb, data, 1); return parse_mount_options(sb, data, 1);
} }
@ -207,33 +207,33 @@ static int pvfs2_remount_fs(struct super_block *sb, int *flags, char *data)
* the client regains all of the mount information from us. * the client regains all of the mount information from us.
* NOTE: this function assumes that the request_mutex is already acquired! * NOTE: this function assumes that the request_mutex is already acquired!
*/ */
int pvfs2_remount(struct super_block *sb) int orangefs_remount(struct super_block *sb)
{ {
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int ret = -EINVAL; int ret = -EINVAL;
gossip_debug(GOSSIP_SUPER_DEBUG, "pvfs2_remount: called\n"); gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount: called\n");
new_op = op_alloc(PVFS2_VFS_OP_FS_MOUNT); new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT);
if (!new_op) if (!new_op)
return -ENOMEM; return -ENOMEM;
strncpy(new_op->upcall.req.fs_mount.pvfs2_config_server, strncpy(new_op->upcall.req.fs_mount.orangefs_config_server,
PVFS2_SB(sb)->devname, ORANGEFS_SB(sb)->devname,
PVFS_MAX_SERVER_ADDR_LEN); ORANGEFS_MAX_SERVER_ADDR_LEN);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"Attempting PVFS2 Remount via host %s\n", "Attempting ORANGEFS Remount via host %s\n",
new_op->upcall.req.fs_mount.pvfs2_config_server); new_op->upcall.req.fs_mount.orangefs_config_server);
/* /*
* we assume that the calling function has already acquire the * we assume that the calling function has already acquire the
* request_mutex to prevent other operations from bypassing * request_mutex to prevent other operations from bypassing
* this one * this one
*/ */
ret = service_operation(new_op, "pvfs2_remount", ret = service_operation(new_op, "orangefs_remount",
PVFS2_OP_PRIORITY | PVFS2_OP_NO_SEMAPHORE); ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_SEMAPHORE);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_remount: mount got return value of %d\n", "orangefs_remount: mount got return value of %d\n",
ret); ret);
if (ret == 0) { if (ret == 0) {
/* /*
@ -241,8 +241,8 @@ int pvfs2_remount(struct super_block *sb)
* short-lived mapping that the system interface uses * short-lived mapping that the system interface uses
* to map this superblock to a particular mount entry * to map this superblock to a particular mount entry
*/ */
PVFS2_SB(sb)->id = new_op->downcall.resp.fs_mount.id; ORANGEFS_SB(sb)->id = new_op->downcall.resp.fs_mount.id;
PVFS2_SB(sb)->mount_pending = 0; ORANGEFS_SB(sb)->mount_pending = 0;
} }
op_release(new_op); op_release(new_op);
@ -259,54 +259,54 @@ void fsid_key_table_finalize(void)
} }
/* Called whenever the VFS dirties the inode in response to atime updates */ /* Called whenever the VFS dirties the inode in response to atime updates */
static void pvfs2_dirty_inode(struct inode *inode, int flags) static void orangefs_dirty_inode(struct inode *inode, int flags)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_dirty_inode: %pU\n", "orangefs_dirty_inode: %pU\n",
get_khandle_from_ino(inode)); get_khandle_from_ino(inode));
SetAtimeFlag(pvfs2_inode); SetAtimeFlag(orangefs_inode);
} }
static const struct super_operations pvfs2_s_ops = { static const struct super_operations orangefs_s_ops = {
.alloc_inode = pvfs2_alloc_inode, .alloc_inode = orangefs_alloc_inode,
.destroy_inode = pvfs2_destroy_inode, .destroy_inode = orangefs_destroy_inode,
.dirty_inode = pvfs2_dirty_inode, .dirty_inode = orangefs_dirty_inode,
.drop_inode = generic_delete_inode, .drop_inode = generic_delete_inode,
.statfs = pvfs2_statfs, .statfs = orangefs_statfs,
.remount_fs = pvfs2_remount_fs, .remount_fs = orangefs_remount_fs,
.show_options = generic_show_options, .show_options = generic_show_options,
}; };
static struct dentry *pvfs2_fh_to_dentry(struct super_block *sb, static struct dentry *orangefs_fh_to_dentry(struct super_block *sb,
struct fid *fid, struct fid *fid,
int fh_len, int fh_len,
int fh_type) int fh_type)
{ {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
if (fh_len < 5 || fh_type > 2) if (fh_len < 5 || fh_type > 2)
return NULL; return NULL;
PVFS_khandle_from(&(refn.khandle), fid->raw, 16); ORANGEFS_khandle_from(&(refn.khandle), fid->raw, 16);
refn.fs_id = (u32) fid->raw[4]; refn.fs_id = (u32) fid->raw[4];
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"fh_to_dentry: handle %pU, fs_id %d\n", "fh_to_dentry: handle %pU, fs_id %d\n",
&refn.khandle, &refn.khandle,
refn.fs_id); refn.fs_id);
return d_obtain_alias(pvfs2_iget(sb, &refn)); return d_obtain_alias(orangefs_iget(sb, &refn));
} }
static int pvfs2_encode_fh(struct inode *inode, static int orangefs_encode_fh(struct inode *inode,
__u32 *fh, __u32 *fh,
int *max_len, int *max_len,
struct inode *parent) struct inode *parent)
{ {
int len = parent ? 10 : 5; int len = parent ? 10 : 5;
int type = 1; int type = 1;
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
if (*max_len < len) { if (*max_len < len) {
gossip_lerr("fh buffer is too small for encoding\n"); gossip_lerr("fh buffer is too small for encoding\n");
@ -315,8 +315,8 @@ static int pvfs2_encode_fh(struct inode *inode,
goto out; goto out;
} }
refn = PVFS2_I(inode)->refn; refn = ORANGEFS_I(inode)->refn;
PVFS_khandle_to(&refn.khandle, fh, 16); ORANGEFS_khandle_to(&refn.khandle, fh, 16);
fh[4] = refn.fs_id; fh[4] = refn.fs_id;
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
@ -326,8 +326,8 @@ static int pvfs2_encode_fh(struct inode *inode,
if (parent) { if (parent) {
refn = PVFS2_I(parent)->refn; refn = ORANGEFS_I(parent)->refn;
PVFS_khandle_to(&refn.khandle, (char *) fh + 20, 16); ORANGEFS_khandle_to(&refn.khandle, (char *) fh + 20, 16);
fh[9] = refn.fs_id; fh[9] = refn.fs_id;
type = 2; type = 2;
@ -342,30 +342,30 @@ out:
return type; return type;
} }
static struct export_operations pvfs2_export_ops = { static struct export_operations orangefs_export_ops = {
.encode_fh = pvfs2_encode_fh, .encode_fh = orangefs_encode_fh,
.fh_to_dentry = pvfs2_fh_to_dentry, .fh_to_dentry = orangefs_fh_to_dentry,
}; };
static int pvfs2_fill_sb(struct super_block *sb, static int orangefs_fill_sb(struct super_block *sb,
struct pvfs2_fs_mount_response *fs_mount, struct orangefs_fs_mount_response *fs_mount,
void *data, int silent) void *data, int silent)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct inode *root = NULL; struct inode *root = NULL;
struct dentry *root_dentry = NULL; struct dentry *root_dentry = NULL;
struct pvfs2_object_kref root_object; struct orangefs_object_kref root_object;
/* alloc and init our private pvfs2 sb info */ /* alloc and init our private orangefs sb info */
sb->s_fs_info = sb->s_fs_info =
kzalloc(sizeof(struct pvfs2_sb_info_s), PVFS2_GFP_FLAGS); kzalloc(sizeof(struct orangefs_sb_info_s), ORANGEFS_GFP_FLAGS);
if (!PVFS2_SB(sb)) if (!ORANGEFS_SB(sb))
return -ENOMEM; return -ENOMEM;
PVFS2_SB(sb)->sb = sb; ORANGEFS_SB(sb)->sb = sb;
PVFS2_SB(sb)->root_khandle = fs_mount->root_khandle; ORANGEFS_SB(sb)->root_khandle = fs_mount->root_khandle;
PVFS2_SB(sb)->fs_id = fs_mount->fs_id; ORANGEFS_SB(sb)->fs_id = fs_mount->fs_id;
PVFS2_SB(sb)->id = fs_mount->id; ORANGEFS_SB(sb)->id = fs_mount->id;
if (data) { if (data) {
ret = parse_mount_options(sb, data, silent); ret = parse_mount_options(sb, data, silent);
@ -374,23 +374,23 @@ static int pvfs2_fill_sb(struct super_block *sb,
} }
/* Hang the xattr handlers off the superblock */ /* Hang the xattr handlers off the superblock */
sb->s_xattr = pvfs2_xattr_handlers; sb->s_xattr = orangefs_xattr_handlers;
sb->s_magic = PVFS2_SUPER_MAGIC; sb->s_magic = ORANGEFS_SUPER_MAGIC;
sb->s_op = &pvfs2_s_ops; sb->s_op = &orangefs_s_ops;
sb->s_d_op = &pvfs2_dentry_operations; sb->s_d_op = &orangefs_dentry_operations;
sb->s_blocksize = pvfs_bufmap_size_query(); sb->s_blocksize = orangefs_bufmap_size_query();
sb->s_blocksize_bits = pvfs_bufmap_shift_query(); sb->s_blocksize_bits = orangefs_bufmap_shift_query();
sb->s_maxbytes = MAX_LFS_FILESIZE; sb->s_maxbytes = MAX_LFS_FILESIZE;
root_object.khandle = PVFS2_SB(sb)->root_khandle; root_object.khandle = ORANGEFS_SB(sb)->root_khandle;
root_object.fs_id = PVFS2_SB(sb)->fs_id; root_object.fs_id = ORANGEFS_SB(sb)->fs_id;
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"get inode %pU, fsid %d\n", "get inode %pU, fsid %d\n",
&root_object.khandle, &root_object.khandle,
root_object.fs_id); root_object.fs_id);
root = pvfs2_iget(sb, &root_object); root = orangefs_iget(sb, &root_object);
if (IS_ERR(root)) if (IS_ERR(root))
return PTR_ERR(root); return PTR_ERR(root);
@ -404,23 +404,23 @@ static int pvfs2_fill_sb(struct super_block *sb,
if (!root_dentry) if (!root_dentry)
return -ENOMEM; return -ENOMEM;
sb->s_export_op = &pvfs2_export_ops; sb->s_export_op = &orangefs_export_ops;
sb->s_root = root_dentry; sb->s_root = root_dentry;
return 0; return 0;
} }
struct dentry *pvfs2_mount(struct file_system_type *fst, struct dentry *orangefs_mount(struct file_system_type *fst,
int flags, int flags,
const char *devname, const char *devname,
void *data) void *data)
{ {
int ret = -EINVAL; int ret = -EINVAL;
struct super_block *sb = ERR_PTR(-EINVAL); struct super_block *sb = ERR_PTR(-EINVAL);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
struct dentry *d = ERR_PTR(-EINVAL); struct dentry *d = ERR_PTR(-EINVAL);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_mount: called with devname %s\n", "orangefs_mount: called with devname %s\n",
devname); devname);
if (!devname) { if (!devname) {
@ -428,25 +428,25 @@ struct dentry *pvfs2_mount(struct file_system_type *fst,
return ERR_PTR(-EINVAL); return ERR_PTR(-EINVAL);
} }
new_op = op_alloc(PVFS2_VFS_OP_FS_MOUNT); new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT);
if (!new_op) if (!new_op)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
strncpy(new_op->upcall.req.fs_mount.pvfs2_config_server, strncpy(new_op->upcall.req.fs_mount.orangefs_config_server,
devname, devname,
PVFS_MAX_SERVER_ADDR_LEN); ORANGEFS_MAX_SERVER_ADDR_LEN);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"Attempting PVFS2 Mount via host %s\n", "Attempting ORANGEFS Mount via host %s\n",
new_op->upcall.req.fs_mount.pvfs2_config_server); new_op->upcall.req.fs_mount.orangefs_config_server);
ret = service_operation(new_op, "pvfs2_mount", 0); ret = service_operation(new_op, "orangefs_mount", 0);
gossip_debug(GOSSIP_SUPER_DEBUG, gossip_debug(GOSSIP_SUPER_DEBUG,
"pvfs2_mount: mount got return value of %d\n", ret); "orangefs_mount: mount got return value of %d\n", ret);
if (ret) if (ret)
goto free_op; goto free_op;
if (new_op->downcall.resp.fs_mount.fs_id == PVFS_FS_ID_NULL) { if (new_op->downcall.resp.fs_mount.fs_id == ORANGEFS_FS_ID_NULL) {
gossip_err("ERROR: Retrieved null fs_id\n"); gossip_err("ERROR: Retrieved null fs_id\n");
ret = -EINVAL; ret = -EINVAL;
goto free_op; goto free_op;
@ -459,7 +459,7 @@ struct dentry *pvfs2_mount(struct file_system_type *fst,
goto free_op; goto free_op;
} }
ret = pvfs2_fill_sb(sb, ret = orangefs_fill_sb(sb,
&new_op->downcall.resp.fs_mount, data, &new_op->downcall.resp.fs_mount, data,
flags & MS_SILENT ? 1 : 0); flags & MS_SILENT ? 1 : 0);
@ -472,25 +472,25 @@ struct dentry *pvfs2_mount(struct file_system_type *fst,
* on successful mount, store the devname and data * on successful mount, store the devname and data
* used * used
*/ */
strncpy(PVFS2_SB(sb)->devname, strncpy(ORANGEFS_SB(sb)->devname,
devname, devname,
PVFS_MAX_SERVER_ADDR_LEN); ORANGEFS_MAX_SERVER_ADDR_LEN);
/* mount_pending must be cleared */ /* mount_pending must be cleared */
PVFS2_SB(sb)->mount_pending = 0; ORANGEFS_SB(sb)->mount_pending = 0;
/* /*
* finally, add this sb to our list of known pvfs2 * finally, add this sb to our list of known orangefs
* sb's * sb's
*/ */
add_pvfs2_sb(sb); add_orangefs_sb(sb);
op_release(new_op); op_release(new_op);
return dget(sb->s_root); return dget(sb->s_root);
free_op: free_op:
gossip_err("pvfs2_mount: mount request failed with %d\n", ret); gossip_err("orangefs_mount: mount request failed with %d\n", ret);
if (ret == -EINVAL) { if (ret == -EINVAL) {
gossip_err("Ensure that all pvfs2-servers have the same FS configuration files\n"); gossip_err("Ensure that all orangefs-servers have the same FS configuration files\n");
gossip_err("Look at pvfs2-client-core log file (typically /tmp/pvfs2-client.log) for more details\n"); gossip_err("Look at pvfs2-client-core log file (typically /tmp/pvfs2-client.log) for more details\n");
} }
@ -499,43 +499,43 @@ free_op:
return d; return d;
} }
void pvfs2_kill_sb(struct super_block *sb) void orangefs_kill_sb(struct super_block *sb)
{ {
gossip_debug(GOSSIP_SUPER_DEBUG, "pvfs2_kill_sb: called\n"); gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_kill_sb: called\n");
/* /*
* issue the unmount to userspace to tell it to remove the * issue the unmount to userspace to tell it to remove the
* dynamic mount info it has for this superblock * dynamic mount info it has for this superblock
*/ */
pvfs2_unmount_sb(sb); orangefs_unmount_sb(sb);
/* remove the sb from our list of pvfs2 specific sb's */ /* remove the sb from our list of orangefs specific sb's */
remove_pvfs2_sb(sb); remove_orangefs_sb(sb);
/* provided sb cleanup */ /* provided sb cleanup */
kill_anon_super(sb); kill_anon_super(sb);
/* free the pvfs2 superblock private data */ /* free the orangefs superblock private data */
kfree(PVFS2_SB(sb)); kfree(ORANGEFS_SB(sb));
} }
int pvfs2_inode_cache_initialize(void) int orangefs_inode_cache_initialize(void)
{ {
pvfs2_inode_cache = kmem_cache_create("pvfs2_inode_cache", orangefs_inode_cache = kmem_cache_create("orangefs_inode_cache",
sizeof(struct pvfs2_inode_s), sizeof(struct orangefs_inode_s),
0, 0,
PVFS2_CACHE_CREATE_FLAGS, ORANGEFS_CACHE_CREATE_FLAGS,
pvfs2_inode_cache_ctor); orangefs_inode_cache_ctor);
if (!pvfs2_inode_cache) { if (!orangefs_inode_cache) {
gossip_err("Cannot create pvfs2_inode_cache\n"); gossip_err("Cannot create orangefs_inode_cache\n");
return -ENOMEM; return -ENOMEM;
} }
return 0; return 0;
} }
int pvfs2_inode_cache_finalize(void) int orangefs_inode_cache_finalize(void)
{ {
kmem_cache_destroy(pvfs2_inode_cache); kmem_cache_destroy(orangefs_inode_cache);
return 0; return 0;
} }

14
fs/orangefs/symlink.c
View file

@ -8,9 +8,9 @@
#include "pvfs2-kernel.h" #include "pvfs2-kernel.h"
#include "pvfs2-bufmap.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, gossip_debug(GOSSIP_INODE_DEBUG,
"%s: called on %s (target is %p)\n", "%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; return target;
} }
struct inode_operations pvfs2_symlink_inode_operations = { struct inode_operations orangefs_symlink_inode_operations = {
.readlink = generic_readlink, .readlink = generic_readlink,
.follow_link = pvfs2_follow_link, .follow_link = orangefs_follow_link,
.setattr = pvfs2_setattr, .setattr = orangefs_setattr,
.getattr = pvfs2_getattr, .getattr = orangefs_getattr,
.listxattr = pvfs2_listxattr, .listxattr = orangefs_listxattr,
.setxattr = generic_setxattr, .setxattr = generic_setxattr,
}; };

250
fs/orangefs/upcall.h
View file

@ -12,68 +12,68 @@
* 32-64 bit interaction issues between * 32-64 bit interaction issues between
* client-core and device * client-core and device
*/ */
struct pvfs2_io_request_s { struct orangefs_io_request_s {
__s32 async_vfs_io; __s32 async_vfs_io;
__s32 buf_index; __s32 buf_index;
__s32 count; __s32 count;
__s32 __pad1; __s32 __pad1;
__s64 offset; __s64 offset;
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
enum PVFS_io_type io_type; enum ORANGEFS_io_type io_type;
__s32 readahead_size; __s32 readahead_size;
}; };
struct pvfs2_lookup_request_s { struct orangefs_lookup_request_s {
__s32 sym_follow; __s32 sym_follow;
__s32 __pad1; __s32 __pad1;
struct pvfs2_object_kref parent_refn; struct orangefs_object_kref parent_refn;
char d_name[PVFS2_NAME_LEN]; char d_name[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_create_request_s { struct orangefs_create_request_s {
struct pvfs2_object_kref parent_refn; struct orangefs_object_kref parent_refn;
struct PVFS_sys_attr_s attributes; struct ORANGEFS_sys_attr_s attributes;
char d_name[PVFS2_NAME_LEN]; char d_name[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_symlink_request_s { struct orangefs_symlink_request_s {
struct pvfs2_object_kref parent_refn; struct orangefs_object_kref parent_refn;
struct PVFS_sys_attr_s attributes; struct ORANGEFS_sys_attr_s attributes;
char entry_name[PVFS2_NAME_LEN]; char entry_name[ORANGEFS_NAME_LEN];
char target[PVFS2_NAME_LEN]; char target[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_getattr_request_s { struct orangefs_getattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__u32 mask; __u32 mask;
__u32 __pad1; __u32 __pad1;
}; };
struct pvfs2_setattr_request_s { struct orangefs_setattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
struct PVFS_sys_attr_s attributes; struct ORANGEFS_sys_attr_s attributes;
}; };
struct pvfs2_remove_request_s { struct orangefs_remove_request_s {
struct pvfs2_object_kref parent_refn; struct orangefs_object_kref parent_refn;
char d_name[PVFS2_NAME_LEN]; char d_name[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_mkdir_request_s { struct orangefs_mkdir_request_s {
struct pvfs2_object_kref parent_refn; struct orangefs_object_kref parent_refn;
struct PVFS_sys_attr_s attributes; struct ORANGEFS_sys_attr_s attributes;
char d_name[PVFS2_NAME_LEN]; char d_name[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_readdir_request_s { struct orangefs_readdir_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__u64 token; __u64 token;
__s32 max_dirent_count; __s32 max_dirent_count;
__s32 buf_index; __s32 buf_index;
}; };
struct pvfs2_readdirplus_request_s { struct orangefs_readdirplus_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__u64 token; __u64 token;
__s32 max_dirent_count; __s32 max_dirent_count;
__u32 mask; __u32 mask;
@ -81,130 +81,130 @@ struct pvfs2_readdirplus_request_s {
__s32 __pad1; __s32 __pad1;
}; };
struct pvfs2_rename_request_s { struct orangefs_rename_request_s {
struct pvfs2_object_kref old_parent_refn; struct orangefs_object_kref old_parent_refn;
struct pvfs2_object_kref new_parent_refn; struct orangefs_object_kref new_parent_refn;
char d_old_name[PVFS2_NAME_LEN]; char d_old_name[ORANGEFS_NAME_LEN];
char d_new_name[PVFS2_NAME_LEN]; char d_new_name[ORANGEFS_NAME_LEN];
}; };
struct pvfs2_statfs_request_s { struct orangefs_statfs_request_s {
__s32 fs_id; __s32 fs_id;
__s32 __pad1; __s32 __pad1;
}; };
struct pvfs2_truncate_request_s { struct orangefs_truncate_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__s64 size; __s64 size;
}; };
struct pvfs2_mmap_ra_cache_flush_request_s { struct orangefs_mmap_ra_cache_flush_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
struct pvfs2_fs_mount_request_s { struct orangefs_fs_mount_request_s {
char pvfs2_config_server[PVFS_MAX_SERVER_ADDR_LEN]; char orangefs_config_server[ORANGEFS_MAX_SERVER_ADDR_LEN];
}; };
struct pvfs2_fs_umount_request_s { struct orangefs_fs_umount_request_s {
__s32 id; __s32 id;
__s32 fs_id; __s32 fs_id;
char pvfs2_config_server[PVFS_MAX_SERVER_ADDR_LEN]; char orangefs_config_server[ORANGEFS_MAX_SERVER_ADDR_LEN];
}; };
struct pvfs2_getxattr_request_s { struct orangefs_getxattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__s32 key_sz; __s32 key_sz;
__s32 __pad1; __s32 __pad1;
char key[PVFS_MAX_XATTR_NAMELEN]; char key[ORANGEFS_MAX_XATTR_NAMELEN];
}; };
struct pvfs2_setxattr_request_s { struct orangefs_setxattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
struct PVFS_keyval_pair keyval; struct ORANGEFS_keyval_pair keyval;
__s32 flags; __s32 flags;
__s32 __pad1; __s32 __pad1;
}; };
struct pvfs2_listxattr_request_s { struct orangefs_listxattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__s32 requested_count; __s32 requested_count;
__s32 __pad1; __s32 __pad1;
__u64 token; __u64 token;
}; };
struct pvfs2_removexattr_request_s { struct orangefs_removexattr_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
__s32 key_sz; __s32 key_sz;
__s32 __pad1; __s32 __pad1;
char key[PVFS_MAX_XATTR_NAMELEN]; char key[ORANGEFS_MAX_XATTR_NAMELEN];
}; };
struct pvfs2_op_cancel_s { struct orangefs_op_cancel_s {
__u64 op_tag; __u64 op_tag;
}; };
struct pvfs2_fsync_request_s { struct orangefs_fsync_request_s {
struct pvfs2_object_kref refn; struct orangefs_object_kref refn;
}; };
enum pvfs2_param_request_type { enum orangefs_param_request_type {
PVFS2_PARAM_REQUEST_SET = 1, ORANGEFS_PARAM_REQUEST_SET = 1,
PVFS2_PARAM_REQUEST_GET = 2 ORANGEFS_PARAM_REQUEST_GET = 2
}; };
enum pvfs2_param_request_op { enum orangefs_param_request_op {
PVFS2_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS = 1, ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS = 1,
PVFS2_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT = 2, ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT = 2,
PVFS2_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT = 3, ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT = 3,
PVFS2_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE = 4, ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE = 4,
PVFS2_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS = 5, ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS = 5,
PVFS2_PARAM_REQUEST_OP_PERF_HISTORY_SIZE = 6, ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE = 6,
PVFS2_PARAM_REQUEST_OP_PERF_RESET = 7, ORANGEFS_PARAM_REQUEST_OP_PERF_RESET = 7,
PVFS2_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS = 8, ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS = 8,
PVFS2_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT = 9, ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT = 9,
PVFS2_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT = 10, ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT = 10,
PVFS2_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE = 11, ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE = 11,
PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_TIMEOUT_MSECS = 12, ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_TIMEOUT_MSECS = 12,
PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_HARD_LIMIT = 13, ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_HARD_LIMIT = 13,
PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_SOFT_LIMIT = 14, ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_SOFT_LIMIT = 14,
PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_RECLAIM_PERCENTAGE = 15, ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_RECLAIM_PERCENTAGE = 15,
PVFS2_PARAM_REQUEST_OP_CLIENT_DEBUG = 16, ORANGEFS_PARAM_REQUEST_OP_CLIENT_DEBUG = 16,
PVFS2_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS = 17, ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS = 17,
PVFS2_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT = 18, ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT = 18,
PVFS2_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT = 19, ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT = 19,
PVFS2_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE = 20, ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE = 20,
PVFS2_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS = 21, ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS = 21,
PVFS2_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT = 22, ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT = 22,
PVFS2_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT = 23, ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT = 23,
PVFS2_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE = 24, ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE = 24,
PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES = 25, ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES = 25,
}; };
struct pvfs2_param_request_s { struct orangefs_param_request_s {
enum pvfs2_param_request_type type; enum orangefs_param_request_type type;
enum pvfs2_param_request_op op; enum orangefs_param_request_op op;
__s64 value; __s64 value;
char s_value[PVFS2_MAX_DEBUG_STRING_LEN]; char s_value[ORANGEFS_MAX_DEBUG_STRING_LEN];
}; };
enum pvfs2_perf_count_request_type { enum orangefs_perf_count_request_type {
PVFS2_PERF_COUNT_REQUEST_ACACHE = 1, ORANGEFS_PERF_COUNT_REQUEST_ACACHE = 1,
PVFS2_PERF_COUNT_REQUEST_NCACHE = 2, ORANGEFS_PERF_COUNT_REQUEST_NCACHE = 2,
PVFS2_PERF_COUNT_REQUEST_CAPCACHE = 3, ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE = 3,
}; };
struct pvfs2_perf_count_request_s { struct orangefs_perf_count_request_s {
enum pvfs2_perf_count_request_type type; enum orangefs_perf_count_request_type type;
__s32 __pad1; __s32 __pad1;
}; };
struct pvfs2_fs_key_request_s { struct orangefs_fs_key_request_s {
__s32 fsid; __s32 fsid;
__s32 __pad1; __s32 __pad1;
}; };
struct pvfs2_upcall_s { struct orangefs_upcall_s {
__s32 type; __s32 type;
__u32 uid; __u32 uid;
__u32 gid; __u32 gid;
@ -215,31 +215,31 @@ struct pvfs2_upcall_s {
char *trailer_buf; char *trailer_buf;
union { union {
struct pvfs2_io_request_s io; struct orangefs_io_request_s io;
struct pvfs2_lookup_request_s lookup; struct orangefs_lookup_request_s lookup;
struct pvfs2_create_request_s create; struct orangefs_create_request_s create;
struct pvfs2_symlink_request_s sym; struct orangefs_symlink_request_s sym;
struct pvfs2_getattr_request_s getattr; struct orangefs_getattr_request_s getattr;
struct pvfs2_setattr_request_s setattr; struct orangefs_setattr_request_s setattr;
struct pvfs2_remove_request_s remove; struct orangefs_remove_request_s remove;
struct pvfs2_mkdir_request_s mkdir; struct orangefs_mkdir_request_s mkdir;
struct pvfs2_readdir_request_s readdir; struct orangefs_readdir_request_s readdir;
struct pvfs2_readdirplus_request_s readdirplus; struct orangefs_readdirplus_request_s readdirplus;
struct pvfs2_rename_request_s rename; struct orangefs_rename_request_s rename;
struct pvfs2_statfs_request_s statfs; struct orangefs_statfs_request_s statfs;
struct pvfs2_truncate_request_s truncate; struct orangefs_truncate_request_s truncate;
struct pvfs2_mmap_ra_cache_flush_request_s ra_cache_flush; struct orangefs_mmap_ra_cache_flush_request_s ra_cache_flush;
struct pvfs2_fs_mount_request_s fs_mount; struct orangefs_fs_mount_request_s fs_mount;
struct pvfs2_fs_umount_request_s fs_umount; struct orangefs_fs_umount_request_s fs_umount;
struct pvfs2_getxattr_request_s getxattr; struct orangefs_getxattr_request_s getxattr;
struct pvfs2_setxattr_request_s setxattr; struct orangefs_setxattr_request_s setxattr;
struct pvfs2_listxattr_request_s listxattr; struct orangefs_listxattr_request_s listxattr;
struct pvfs2_removexattr_request_s removexattr; struct orangefs_removexattr_request_s removexattr;
struct pvfs2_op_cancel_s cancel; struct orangefs_op_cancel_s cancel;
struct pvfs2_fsync_request_s fsync; struct orangefs_fsync_request_s fsync;
struct pvfs2_param_request_s param; struct orangefs_param_request_s param;
struct pvfs2_perf_count_request_s perf_count; struct orangefs_perf_count_request_s perf_count;
struct pvfs2_fs_key_request_s fs_key; struct orangefs_fs_key_request_s fs_key;
} req; } req;
}; };

70
fs/orangefs/waitqueue.c
View file

@ -25,10 +25,10 @@
*/ */
void purge_waiting_ops(void) void purge_waiting_ops(void)
{ {
struct pvfs2_kernel_op_s *op; struct orangefs_kernel_op_s *op;
spin_lock(&pvfs2_request_list_lock); spin_lock(&orangefs_request_list_lock);
list_for_each_entry(op, &pvfs2_request_list, list) { list_for_each_entry(op, &orangefs_request_list, list) {
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2-client-core: purging op tag %llu %s\n", "pvfs2-client-core: purging op tag %llu %s\n",
llu(op->tag), llu(op->tag),
@ -38,11 +38,11 @@ void purge_waiting_ops(void)
spin_unlock(&op->lock); spin_unlock(&op->lock);
wake_up_interruptible(&op->waitq); wake_up_interruptible(&op->waitq);
} }
spin_unlock(&pvfs2_request_list_lock); spin_unlock(&orangefs_request_list_lock);
} }
/* /*
* submits a PVFS2 operation and waits for it to complete * submits a ORANGEFS operation and waits for it to complete
* *
* Note op->downcall.status will contain the status of the operation (in * Note op->downcall.status will contain the status of the operation (in
* errno format), whether provided by pvfs2-client or a result of failure to * errno format), whether provided by pvfs2-client or a result of failure to
@ -51,7 +51,7 @@ void purge_waiting_ops(void)
* *
* Returns contents of op->downcall.status for convenience * Returns contents of op->downcall.status for convenience
*/ */
int service_operation(struct pvfs2_kernel_op_s *op, int service_operation(struct orangefs_kernel_op_s *op,
const char *op_name, const char *op_name,
int flags) int flags)
{ {
@ -70,30 +70,30 @@ int service_operation(struct pvfs2_kernel_op_s *op,
retry_servicing: retry_servicing:
op->downcall.status = 0; op->downcall.status = 0;
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2: service_operation: %s %p\n", "orangefs: service_operation: %s %p\n",
op_name, op_name,
op); op);
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2: operation posted by process: %s, pid: %i\n", "orangefs: operation posted by process: %s, pid: %i\n",
current->comm, current->comm,
current->pid); current->pid);
/* mask out signals if this operation is not to be interrupted */ /* mask out signals if this operation is not to be interrupted */
if (!(flags & PVFS2_OP_INTERRUPTIBLE)) if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
block_signals(&orig_sigset); block_signals(&orig_sigset);
if (!(flags & PVFS2_OP_NO_SEMAPHORE)) { if (!(flags & ORANGEFS_OP_NO_SEMAPHORE)) {
ret = mutex_lock_interruptible(&request_mutex); ret = mutex_lock_interruptible(&request_mutex);
/* /*
* check to see if we were interrupted while waiting for * check to see if we were interrupted while waiting for
* semaphore * semaphore
*/ */
if (ret < 0) { if (ret < 0) {
if (!(flags & PVFS2_OP_INTERRUPTIBLE)) if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
set_signals(&orig_sigset); set_signals(&orig_sigset);
op->downcall.status = ret; op->downcall.status = ret;
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2: service_operation interrupted.\n"); "orangefs: service_operation interrupted.\n");
return ret; return ret;
} }
} }
@ -116,7 +116,7 @@ retry_servicing:
} }
/* queue up the operation */ /* queue up the operation */
if (flags & PVFS2_OP_PRIORITY) { if (flags & ORANGEFS_OP_PRIORITY) {
add_priority_op_to_request_list(op); add_priority_op_to_request_list(op);
} else { } else {
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
@ -125,17 +125,17 @@ retry_servicing:
add_op_to_request_list(op); add_op_to_request_list(op);
} }
if (!(flags & PVFS2_OP_NO_SEMAPHORE)) if (!(flags & ORANGEFS_OP_NO_SEMAPHORE))
mutex_unlock(&request_mutex); mutex_unlock(&request_mutex);
/* /*
* If we are asked to service an asynchronous operation from * If we are asked to service an asynchronous operation from
* VFS perspective, we are done. * VFS perspective, we are done.
*/ */
if (flags & PVFS2_OP_ASYNC) if (flags & ORANGEFS_OP_ASYNC)
return 0; return 0;
if (flags & PVFS2_OP_CANCELLATION) { if (flags & ORANGEFS_OP_CANCELLATION) {
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"%s:" "%s:"
"About to call wait_for_cancellation_downcall.\n", "About to call wait_for_cancellation_downcall.\n",
@ -148,25 +148,25 @@ retry_servicing:
if (ret < 0) { if (ret < 0) {
/* failed to get matching downcall */ /* failed to get matching downcall */
if (ret == -ETIMEDOUT) { if (ret == -ETIMEDOUT) {
gossip_err("pvfs2: %s -- wait timed out; aborting attempt.\n", gossip_err("orangefs: %s -- wait timed out; aborting attempt.\n",
op_name); op_name);
} }
op->downcall.status = ret; op->downcall.status = ret;
} else { } else {
/* got matching downcall; make sure status is in errno format */ /* got matching downcall; make sure status is in errno format */
op->downcall.status = op->downcall.status =
pvfs2_normalize_to_errno(op->downcall.status); orangefs_normalize_to_errno(op->downcall.status);
ret = op->downcall.status; ret = op->downcall.status;
} }
if (!(flags & PVFS2_OP_INTERRUPTIBLE)) if (!(flags & ORANGEFS_OP_INTERRUPTIBLE))
set_signals(&orig_sigset); set_signals(&orig_sigset);
BUG_ON(ret != op->downcall.status); BUG_ON(ret != op->downcall.status);
/* retry if operation has not been serviced and if requested */ /* retry if operation has not been serviced and if requested */
if (!op_state_serviced(op) && op->downcall.status == -EAGAIN) { if (!op_state_serviced(op) && op->downcall.status == -EAGAIN) {
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2: tag %llu (%s)" "orangefs: tag %llu (%s)"
" -- operation to be retried (%d attempt)\n", " -- operation to be retried (%d attempt)\n",
llu(op->tag), llu(op->tag),
op_name, op_name,
@ -204,17 +204,17 @@ retry_servicing:
* memory system can be initialized. * memory system can be initialized.
*/ */
spin_lock_irqsave(&op->lock, irqflags); spin_lock_irqsave(&op->lock, irqflags);
add_wait_queue(&pvfs2_bufmap_init_waitq, &wait_entry); add_wait_queue(&orangefs_bufmap_init_waitq, &wait_entry);
spin_unlock_irqrestore(&op->lock, irqflags); spin_unlock_irqrestore(&op->lock, irqflags);
set_current_state(TASK_INTERRUPTIBLE); set_current_state(TASK_INTERRUPTIBLE);
/* /*
* Wait for pvfs_bufmap_initialize() to wake me up * Wait for orangefs_bufmap_initialize() to wake me up
* within the allotted time. * within the allotted time.
*/ */
ret = schedule_timeout(MSECS_TO_JIFFIES ret = schedule_timeout(MSECS_TO_JIFFIES
(1000 * PVFS2_BUFMAP_WAIT_TIMEOUT_SECS)); (1000 * ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS));
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"Value returned from schedule_timeout:" "Value returned from schedule_timeout:"
@ -225,14 +225,14 @@ retry_servicing:
get_bufmap_init()); get_bufmap_init());
spin_lock_irqsave(&op->lock, irqflags); spin_lock_irqsave(&op->lock, irqflags);
remove_wait_queue(&pvfs2_bufmap_init_waitq, remove_wait_queue(&orangefs_bufmap_init_waitq,
&wait_entry); &wait_entry);
spin_unlock_irqrestore(&op->lock, irqflags); spin_unlock_irqrestore(&op->lock, irqflags);
if (get_bufmap_init() == 0) { if (get_bufmap_init() == 0) {
gossip_err("%s:The shared memory system has not started in %d seconds after the client core restarted. Aborting user's request(%s).\n", gossip_err("%s:The shared memory system has not started in %d seconds after the client core restarted. Aborting user's request(%s).\n",
__func__, __func__,
PVFS2_BUFMAP_WAIT_TIMEOUT_SECS, ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS,
get_opname_string(op)); get_opname_string(op));
return -EIO; return -EIO;
} }
@ -246,14 +246,14 @@ retry_servicing:
} }
gossip_debug(GOSSIP_WAIT_DEBUG, gossip_debug(GOSSIP_WAIT_DEBUG,
"pvfs2: service_operation %s returning: %d for %p.\n", "orangefs: service_operation %s returning: %d for %p.\n",
op_name, op_name,
ret, ret,
op); op);
return ret; return ret;
} }
void pvfs2_clean_up_interrupted_operation(struct pvfs2_kernel_op_s *op) void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *op)
{ {
/* /*
* handle interrupted cases depending on what state we were in when * handle interrupted cases depending on what state we were in when
@ -339,7 +339,7 @@ void pvfs2_clean_up_interrupted_operation(struct pvfs2_kernel_op_s *op)
* operation since client-core seems to be exiting too often * operation since client-core seems to be exiting too often
* or if we were interrupted. * or if we were interrupted.
*/ */
int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op) int wait_for_matching_downcall(struct orangefs_kernel_op_s *op)
{ {
int ret = -EINVAL; int ret = -EINVAL;
DECLARE_WAITQUEUE(wait_entry, current); DECLARE_WAITQUEUE(wait_entry, current);
@ -386,7 +386,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op)
op, op,
op->attempts); op->attempts);
ret = -ETIMEDOUT; ret = -ETIMEDOUT;
pvfs2_clean_up_interrupted_operation orangefs_clean_up_interrupted_operation
(op); (op);
break; break;
} }
@ -403,7 +403,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op)
* core starts, and so on... * core starts, and so on...
*/ */
if (op_state_purged(op)) { if (op_state_purged(op)) {
ret = (op->attempts < PVFS2_PURGE_RETRY_COUNT) ? ret = (op->attempts < ORANGEFS_PURGE_RETRY_COUNT) ?
-EAGAIN : -EAGAIN :
-EIO; -EIO;
spin_unlock(&op->lock); spin_unlock(&op->lock);
@ -415,7 +415,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op)
llu(op->tag), llu(op->tag),
op, op,
op->attempts); op->attempts);
pvfs2_clean_up_interrupted_operation(op); orangefs_clean_up_interrupted_operation(op);
break; break;
} }
spin_unlock(&op->lock); spin_unlock(&op->lock);
@ -429,7 +429,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op)
__func__, __func__,
llu(op->tag), llu(op->tag),
op); op);
pvfs2_clean_up_interrupted_operation(op); orangefs_clean_up_interrupted_operation(op);
ret = -EINTR; ret = -EINTR;
break; break;
} }
@ -452,7 +452,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op)
* cancellation upcall anyway. the only way to exit this is to either * cancellation upcall anyway. the only way to exit this is to either
* timeout or have the cancellation be serviced properly. * timeout or have the cancellation be serviced properly.
*/ */
int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op) int wait_for_cancellation_downcall(struct orangefs_kernel_op_s *op)
{ {
int ret = -EINVAL; int ret = -EINVAL;
DECLARE_WAITQUEUE(wait_entry, current); DECLARE_WAITQUEUE(wait_entry, current);
@ -482,7 +482,7 @@ int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op)
__func__, __func__,
llu(op->tag), llu(op->tag),
op); op);
pvfs2_clean_up_interrupted_operation(op); orangefs_clean_up_interrupted_operation(op);
ret = -EINTR; ret = -EINTR;
break; break;
} }
@ -502,7 +502,7 @@ int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op)
"%s:*** operation timed out: %p\n", "%s:*** operation timed out: %p\n",
__func__, __func__,
op); op);
pvfs2_clean_up_interrupted_operation(op); orangefs_clean_up_interrupted_operation(op);
ret = -ETIMEDOUT; ret = -ETIMEDOUT;
break; break;
} }

168
fs/orangefs/xattr.c
View file

@ -15,8 +15,8 @@
#include <linux/xattr.h> #include <linux/xattr.h>
#define SYSTEM_PVFS2_KEY "system.pvfs2." #define SYSTEM_ORANGEFS_KEY "system.pvfs2."
#define SYSTEM_PVFS2_KEY_LEN 13 #define SYSTEM_ORANGEFS_KEY_LEN 13
/* /*
* this function returns * this function returns
@ -24,15 +24,15 @@
* of a listxattr. * of a listxattr.
* 1 if the key corresponding to name is meant to be returned as part of * 1 if the key corresponding to name is meant to be returned as part of
* a listxattr. * a listxattr.
* The ones that start SYSTEM_PVFS2_KEY are the ones to avoid printing. * The ones that start SYSTEM_ORANGEFS_KEY are the ones to avoid printing.
*/ */
static int is_reserved_key(const char *key, size_t size) static int is_reserved_key(const char *key, size_t size)
{ {
if (size < SYSTEM_PVFS2_KEY_LEN) if (size < SYSTEM_ORANGEFS_KEY_LEN)
return 1; return 1;
return strncmp(key, SYSTEM_PVFS2_KEY, SYSTEM_PVFS2_KEY_LEN) ? 1 : 0; return strncmp(key, SYSTEM_ORANGEFS_KEY, SYSTEM_ORANGEFS_KEY_LEN) ? 1 : 0;
} }
static inline int convert_to_internal_xattr_flags(int setxattr_flags) static inline int convert_to_internal_xattr_flags(int setxattr_flags)
@ -41,10 +41,10 @@ static inline int convert_to_internal_xattr_flags(int setxattr_flags)
if (setxattr_flags & XATTR_REPLACE) { if (setxattr_flags & XATTR_REPLACE) {
/* Attribute must exist! */ /* Attribute must exist! */
internal_flag = PVFS_XATTR_REPLACE; internal_flag = ORANGEFS_XATTR_REPLACE;
} else if (setxattr_flags & XATTR_CREATE) { } else if (setxattr_flags & XATTR_CREATE) {
/* Attribute must not exist */ /* Attribute must not exist */
internal_flag = PVFS_XATTR_CREATE; internal_flag = ORANGEFS_XATTR_CREATE;
} }
return internal_flag; return internal_flag;
} }
@ -59,11 +59,11 @@ static inline int convert_to_internal_xattr_flags(int setxattr_flags)
* unless the key does not exist for the file and/or if * unless the key does not exist for the file and/or if
* there were errors in fetching the attribute value. * there were errors in fetching the attribute value.
*/ */
ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix, ssize_t orangefs_inode_getxattr(struct inode *inode, const char *prefix,
const char *name, void *buffer, size_t size) const char *name, void *buffer, size_t size)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
ssize_t ret = -ENOMEM; ssize_t ret = -ENOMEM;
ssize_t length = 0; ssize_t length = 0;
int fsuid; int fsuid;
@ -74,10 +74,10 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix,
__func__, prefix, name, size); __func__, prefix, name, size);
if (name == NULL || (size > 0 && buffer == NULL)) { if (name == NULL || (size > 0 && buffer == NULL)) {
gossip_err("pvfs2_inode_getxattr: bogus NULL pointers\n"); gossip_err("orangefs_inode_getxattr: bogus NULL pointers\n");
return -EINVAL; return -EINVAL;
} }
if ((strlen(name) + strlen(prefix)) >= PVFS_MAX_XATTR_NAMELEN) { if ((strlen(name) + strlen(prefix)) >= ORANGEFS_MAX_XATTR_NAMELEN) {
gossip_err("Invalid key length (%d)\n", gossip_err("Invalid key length (%d)\n",
(int)(strlen(name) + strlen(prefix))); (int)(strlen(name) + strlen(prefix)));
return -EINVAL; return -EINVAL;
@ -94,15 +94,15 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix,
fsuid, fsuid,
fsgid); fsgid);
down_read(&pvfs2_inode->xattr_sem); down_read(&orangefs_inode->xattr_sem);
new_op = op_alloc(PVFS2_VFS_OP_GETXATTR); new_op = op_alloc(ORANGEFS_VFS_OP_GETXATTR);
if (!new_op) if (!new_op)
goto out_unlock; goto out_unlock;
new_op->upcall.req.getxattr.refn = pvfs2_inode->refn; new_op->upcall.req.getxattr.refn = orangefs_inode->refn;
ret = snprintf((char *)new_op->upcall.req.getxattr.key, ret = snprintf((char *)new_op->upcall.req.getxattr.key,
PVFS_MAX_XATTR_NAMELEN, "%s%s", prefix, name); ORANGEFS_MAX_XATTR_NAMELEN, "%s%s", prefix, name);
/* /*
* NOTE: Although keys are meant to be NULL terminated textual * NOTE: Although keys are meant to be NULL terminated textual
@ -111,13 +111,13 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix,
*/ */
new_op->upcall.req.getxattr.key_sz = ret + 1; new_op->upcall.req.getxattr.key_sz = ret + 1;
ret = service_operation(new_op, "pvfs2_inode_getxattr", ret = service_operation(new_op, "orangefs_inode_getxattr",
get_interruptible_flag(inode)); get_interruptible_flag(inode));
if (ret != 0) { if (ret != 0) {
if (ret == -ENOENT) { if (ret == -ENOENT) {
ret = -ENODATA; ret = -ENODATA;
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_getxattr: inode %pU key %s" "orangefs_inode_getxattr: inode %pU key %s"
" does not exist!\n", " does not exist!\n",
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
(char *)new_op->upcall.req.getxattr.key); (char *)new_op->upcall.req.getxattr.key);
@ -149,7 +149,7 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix,
memset(buffer, 0, size); memset(buffer, 0, size);
memcpy(buffer, new_op->downcall.resp.getxattr.val, length); memcpy(buffer, new_op->downcall.resp.getxattr.val, length);
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_getxattr: inode %pU " "orangefs_inode_getxattr: inode %pU "
"key %s key_sz %d, val_len %d\n", "key %s key_sz %d, val_len %d\n",
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
(char *)new_op-> (char *)new_op->
@ -163,44 +163,44 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix,
out_release_op: out_release_op:
op_release(new_op); op_release(new_op);
out_unlock: out_unlock:
up_read(&pvfs2_inode->xattr_sem); up_read(&orangefs_inode->xattr_sem);
return ret; return ret;
} }
static int pvfs2_inode_removexattr(struct inode *inode, static int orangefs_inode_removexattr(struct inode *inode,
const char *prefix, const char *prefix,
const char *name, const char *name,
int flags) int flags)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op = NULL; struct orangefs_kernel_op_s *new_op = NULL;
int ret = -ENOMEM; int ret = -ENOMEM;
down_write(&pvfs2_inode->xattr_sem); down_write(&orangefs_inode->xattr_sem);
new_op = op_alloc(PVFS2_VFS_OP_REMOVEXATTR); new_op = op_alloc(ORANGEFS_VFS_OP_REMOVEXATTR);
if (!new_op) if (!new_op)
goto out_unlock; goto out_unlock;
new_op->upcall.req.removexattr.refn = pvfs2_inode->refn; new_op->upcall.req.removexattr.refn = orangefs_inode->refn;
/* /*
* NOTE: Although keys are meant to be NULL terminated * NOTE: Although keys are meant to be NULL terminated
* textual strings, I am going to explicitly pass the * textual strings, I am going to explicitly pass the
* length just in case we change this later on... * length just in case we change this later on...
*/ */
ret = snprintf((char *)new_op->upcall.req.removexattr.key, ret = snprintf((char *)new_op->upcall.req.removexattr.key,
PVFS_MAX_XATTR_NAMELEN, ORANGEFS_MAX_XATTR_NAMELEN,
"%s%s", "%s%s",
(prefix ? prefix : ""), (prefix ? prefix : ""),
name); name);
new_op->upcall.req.removexattr.key_sz = ret + 1; new_op->upcall.req.removexattr.key_sz = ret + 1;
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_removexattr: key %s, key_sz %d\n", "orangefs_inode_removexattr: key %s, key_sz %d\n",
(char *)new_op->upcall.req.removexattr.key, (char *)new_op->upcall.req.removexattr.key,
(int)new_op->upcall.req.removexattr.key_sz); (int)new_op->upcall.req.removexattr.key_sz);
ret = service_operation(new_op, ret = service_operation(new_op,
"pvfs2_inode_removexattr", "orangefs_inode_removexattr",
get_interruptible_flag(inode)); get_interruptible_flag(inode));
if (ret == -ENOENT) { if (ret == -ENOENT) {
/* /*
@ -213,11 +213,11 @@ static int pvfs2_inode_removexattr(struct inode *inode,
} }
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_removexattr: returning %d\n", ret); "orangefs_inode_removexattr: returning %d\n", ret);
op_release(new_op); op_release(new_op);
out_unlock: out_unlock:
up_write(&pvfs2_inode->xattr_sem); up_write(&orangefs_inode->xattr_sem);
return ret; return ret;
} }
@ -227,11 +227,11 @@ out_unlock:
* Returns a -ve number on error and 0 on success. Key is text, but value * Returns a -ve number on error and 0 on success. Key is text, but value
* can be binary! * can be binary!
*/ */
int pvfs2_inode_setxattr(struct inode *inode, const char *prefix, int orangefs_inode_setxattr(struct inode *inode, const char *prefix,
const char *name, const void *value, size_t size, int flags) const char *name, const void *value, size_t size, int flags)
{ {
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
int internal_flag = 0; int internal_flag = 0;
int ret = -ENOMEM; int ret = -ENOMEM;
@ -240,9 +240,9 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
__func__, prefix, name, size); __func__, prefix, name, size);
if (size < 0 || if (size < 0 ||
size >= PVFS_MAX_XATTR_VALUELEN || size >= ORANGEFS_MAX_XATTR_VALUELEN ||
flags < 0) { flags < 0) {
gossip_err("pvfs2_inode_setxattr: bogus values of size(%d), flags(%d)\n", gossip_err("orangefs_inode_setxattr: bogus values of size(%d), flags(%d)\n",
(int)size, (int)size,
flags); flags);
return -EINVAL; return -EINVAL;
@ -250,23 +250,23 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
if (name == NULL || if (name == NULL ||
(size > 0 && value == NULL)) { (size > 0 && value == NULL)) {
gossip_err("pvfs2_inode_setxattr: bogus NULL pointers!\n"); gossip_err("orangefs_inode_setxattr: bogus NULL pointers!\n");
return -EINVAL; return -EINVAL;
} }
internal_flag = convert_to_internal_xattr_flags(flags); internal_flag = convert_to_internal_xattr_flags(flags);
if (prefix) { if (prefix) {
if (strlen(name) + strlen(prefix) >= PVFS_MAX_XATTR_NAMELEN) { if (strlen(name) + strlen(prefix) >= ORANGEFS_MAX_XATTR_NAMELEN) {
gossip_err gossip_err
("pvfs2_inode_setxattr: bogus key size (%d)\n", ("orangefs_inode_setxattr: bogus key size (%d)\n",
(int)(strlen(name) + strlen(prefix))); (int)(strlen(name) + strlen(prefix)));
return -EINVAL; return -EINVAL;
} }
} else { } else {
if (strlen(name) >= PVFS_MAX_XATTR_NAMELEN) { if (strlen(name) >= ORANGEFS_MAX_XATTR_NAMELEN) {
gossip_err gossip_err
("pvfs2_inode_setxattr: bogus key size (%d)\n", ("orangefs_inode_setxattr: bogus key size (%d)\n",
(int)(strlen(name))); (int)(strlen(name)));
return -EINVAL; return -EINVAL;
} }
@ -278,7 +278,7 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
"removing xattr (%s%s)\n", "removing xattr (%s%s)\n",
prefix, prefix,
name); name);
return pvfs2_inode_removexattr(inode, prefix, name, flags); return orangefs_inode_removexattr(inode, prefix, name, flags);
} }
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
@ -286,13 +286,13 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
get_khandle_from_ino(inode), get_khandle_from_ino(inode),
name); name);
down_write(&pvfs2_inode->xattr_sem); down_write(&orangefs_inode->xattr_sem);
new_op = op_alloc(PVFS2_VFS_OP_SETXATTR); new_op = op_alloc(ORANGEFS_VFS_OP_SETXATTR);
if (!new_op) if (!new_op)
goto out_unlock; goto out_unlock;
new_op->upcall.req.setxattr.refn = pvfs2_inode->refn; new_op->upcall.req.setxattr.refn = orangefs_inode->refn;
new_op->upcall.req.setxattr.flags = internal_flag; new_op->upcall.req.setxattr.flags = internal_flag;
/* /*
* NOTE: Although keys are meant to be NULL terminated textual * NOTE: Although keys are meant to be NULL terminated textual
@ -300,7 +300,7 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
* case we change this later on... * case we change this later on...
*/ */
ret = snprintf((char *)new_op->upcall.req.setxattr.keyval.key, ret = snprintf((char *)new_op->upcall.req.setxattr.keyval.key,
PVFS_MAX_XATTR_NAMELEN, ORANGEFS_MAX_XATTR_NAMELEN,
"%s%s", "%s%s",
prefix, name); prefix, name);
new_op->upcall.req.setxattr.keyval.key_sz = ret + 1; new_op->upcall.req.setxattr.keyval.key_sz = ret + 1;
@ -308,24 +308,24 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix,
new_op->upcall.req.setxattr.keyval.val_sz = size; new_op->upcall.req.setxattr.keyval.val_sz = size;
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_setxattr: key %s, key_sz %d " "orangefs_inode_setxattr: key %s, key_sz %d "
" value size %zd\n", " value size %zd\n",
(char *)new_op->upcall.req.setxattr.keyval.key, (char *)new_op->upcall.req.setxattr.keyval.key,
(int)new_op->upcall.req.setxattr.keyval.key_sz, (int)new_op->upcall.req.setxattr.keyval.key_sz,
size); size);
ret = service_operation(new_op, ret = service_operation(new_op,
"pvfs2_inode_setxattr", "orangefs_inode_setxattr",
get_interruptible_flag(inode)); get_interruptible_flag(inode));
gossip_debug(GOSSIP_XATTR_DEBUG, gossip_debug(GOSSIP_XATTR_DEBUG,
"pvfs2_inode_setxattr: returning %d\n", "orangefs_inode_setxattr: returning %d\n",
ret); ret);
/* when request is serviced properly, free req op struct */ /* when request is serviced properly, free req op struct */
op_release(new_op); op_release(new_op);
out_unlock: out_unlock:
up_write(&pvfs2_inode->xattr_sem); up_write(&orangefs_inode->xattr_sem);
return ret; return ret;
} }
@ -336,12 +336,12 @@ out_unlock:
* subsequent memory allocations. Thus our return value is always the size of * subsequent memory allocations. Thus our return value is always the size of
* all the keys unless there were errors in fetching the keys! * all the keys unless there were errors in fetching the keys!
*/ */
ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size) ssize_t orangefs_listxattr(struct dentry *dentry, char *buffer, size_t size)
{ {
struct inode *inode = dentry->d_inode; struct inode *inode = dentry->d_inode;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct pvfs2_kernel_op_s *new_op; struct orangefs_kernel_op_s *new_op;
__u64 token = PVFS_ITERATE_START; __u64 token = ORANGEFS_ITERATE_START;
ssize_t ret = -ENOMEM; ssize_t ret = -ENOMEM;
ssize_t total = 0; ssize_t total = 0;
ssize_t length = 0; ssize_t length = 0;
@ -358,8 +358,8 @@ ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
return -EINVAL; return -EINVAL;
} }
down_read(&pvfs2_inode->xattr_sem); down_read(&orangefs_inode->xattr_sem);
new_op = op_alloc(PVFS2_VFS_OP_LISTXATTR); new_op = op_alloc(ORANGEFS_VFS_OP_LISTXATTR);
if (!new_op) if (!new_op)
goto out_unlock; goto out_unlock;
@ -368,10 +368,10 @@ ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
try_again: try_again:
key_size = 0; key_size = 0;
new_op->upcall.req.listxattr.refn = pvfs2_inode->refn; new_op->upcall.req.listxattr.refn = orangefs_inode->refn;
new_op->upcall.req.listxattr.token = token; new_op->upcall.req.listxattr.token = token;
new_op->upcall.req.listxattr.requested_count = new_op->upcall.req.listxattr.requested_count =
(size == 0) ? 0 : PVFS_MAX_XATTR_LISTLEN; (size == 0) ? 0 : ORANGEFS_MAX_XATTR_LISTLEN;
ret = service_operation(new_op, __func__, ret = service_operation(new_op, __func__,
get_interruptible_flag(inode)); get_interruptible_flag(inode));
if (ret != 0) if (ret != 0)
@ -384,7 +384,7 @@ try_again:
* up allocating memory rather than us... * up allocating memory rather than us...
*/ */
total = new_op->downcall.resp.listxattr.returned_count * total = new_op->downcall.resp.listxattr.returned_count *
PVFS_MAX_XATTR_NAMELEN; ORANGEFS_MAX_XATTR_NAMELEN;
goto done; goto done;
} }
@ -429,7 +429,7 @@ try_again:
* fetching more keys! * fetching more keys!
*/ */
token = new_op->downcall.resp.listxattr.token; token = new_op->downcall.resp.listxattr.token;
if (token != PVFS_ITERATE_END) if (token != ORANGEFS_ITERATE_END)
goto try_again; goto try_again;
done: done:
@ -443,88 +443,88 @@ done:
if (ret == 0) if (ret == 0)
ret = total; ret = total;
out_unlock: out_unlock:
up_read(&pvfs2_inode->xattr_sem); up_read(&orangefs_inode->xattr_sem);
return ret; return ret;
} }
static int pvfs2_xattr_set_default(const struct xattr_handler *handler, static int orangefs_xattr_set_default(const struct xattr_handler *handler,
struct dentry *dentry, struct dentry *dentry,
const char *name, const char *name,
const void *buffer, const void *buffer,
size_t size, size_t size,
int flags) int flags)
{ {
return pvfs2_inode_setxattr(dentry->d_inode, return orangefs_inode_setxattr(dentry->d_inode,
PVFS2_XATTR_NAME_DEFAULT_PREFIX, ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
name, name,
buffer, buffer,
size, size,
flags); flags);
} }
static int pvfs2_xattr_get_default(const struct xattr_handler *handler, static int orangefs_xattr_get_default(const struct xattr_handler *handler,
struct dentry *dentry, struct dentry *dentry,
const char *name, const char *name,
void *buffer, void *buffer,
size_t size) size_t size)
{ {
return pvfs2_inode_getxattr(dentry->d_inode, return orangefs_inode_getxattr(dentry->d_inode,
PVFS2_XATTR_NAME_DEFAULT_PREFIX, ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
name, name,
buffer, buffer,
size); size);
} }
static int pvfs2_xattr_set_trusted(const struct xattr_handler *handler, static int orangefs_xattr_set_trusted(const struct xattr_handler *handler,
struct dentry *dentry, struct dentry *dentry,
const char *name, const char *name,
const void *buffer, const void *buffer,
size_t size, size_t size,
int flags) int flags)
{ {
return pvfs2_inode_setxattr(dentry->d_inode, return orangefs_inode_setxattr(dentry->d_inode,
PVFS2_XATTR_NAME_TRUSTED_PREFIX, ORANGEFS_XATTR_NAME_TRUSTED_PREFIX,
name, name,
buffer, buffer,
size, size,
flags); flags);
} }
static int pvfs2_xattr_get_trusted(const struct xattr_handler *handler, static int orangefs_xattr_get_trusted(const struct xattr_handler *handler,
struct dentry *dentry, struct dentry *dentry,
const char *name, const char *name,
void *buffer, void *buffer,
size_t size) size_t size)
{ {
return pvfs2_inode_getxattr(dentry->d_inode, return orangefs_inode_getxattr(dentry->d_inode,
PVFS2_XATTR_NAME_TRUSTED_PREFIX, ORANGEFS_XATTR_NAME_TRUSTED_PREFIX,
name, name,
buffer, buffer,
size); size);
} }
static struct xattr_handler pvfs2_xattr_trusted_handler = { static struct xattr_handler orangefs_xattr_trusted_handler = {
.prefix = PVFS2_XATTR_NAME_TRUSTED_PREFIX, .prefix = ORANGEFS_XATTR_NAME_TRUSTED_PREFIX,
.get = pvfs2_xattr_get_trusted, .get = orangefs_xattr_get_trusted,
.set = pvfs2_xattr_set_trusted, .set = orangefs_xattr_set_trusted,
}; };
static struct xattr_handler pvfs2_xattr_default_handler = { static struct xattr_handler orangefs_xattr_default_handler = {
/* /*
* NOTE: this is set to be the empty string. * NOTE: this is set to be the empty string.
* so that all un-prefixed xattrs keys get caught * so that all un-prefixed xattrs keys get caught
* here! * here!
*/ */
.prefix = PVFS2_XATTR_NAME_DEFAULT_PREFIX, .prefix = ORANGEFS_XATTR_NAME_DEFAULT_PREFIX,
.get = pvfs2_xattr_get_default, .get = orangefs_xattr_get_default,
.set = pvfs2_xattr_set_default, .set = orangefs_xattr_set_default,
}; };
const struct xattr_handler *pvfs2_xattr_handlers[] = { const struct xattr_handler *orangefs_xattr_handlers[] = {
&posix_acl_access_xattr_handler, &posix_acl_access_xattr_handler,
&posix_acl_default_xattr_handler, &posix_acl_default_xattr_handler,
&pvfs2_xattr_trusted_handler, &orangefs_xattr_trusted_handler,
&pvfs2_xattr_default_handler, &orangefs_xattr_default_handler,
NULL NULL
}; };