From 8bb8aefd5afb54a25a002feb4ec70011812d06a0 Mon Sep 17 00:00:00 2001 From: Yi Liu Date: Tue, 24 Nov 2015 15:12:14 -0500 Subject: [PATCH] OrangeFS: Change almost all instances of the string PVFS2 to OrangeFS. OrangeFS was formerly known as PVFS2 and retains the name in many places. I leave the device /dev/pvfs2-req since this affects userspace. I leave the filesystem type pvfs2 since this affects userspace. Further the OrangeFS sysint library reads fstab for an entry of type pvfs2 independently of kernel mounts. I leave extended attribute keys user.pvfs2 and system.pvfs2 as the sysint library understands these. I leave references to userspace binaries still named pvfs2. I leave the filenames. Signed-off-by: Yi Liu [martin@omnibond.com: clairify above constraints and merge] Signed-off-by: Martin Brandenburg Signed-off-by: Mike Marshall --- fs/orangefs/acl.c | 42 ++-- fs/orangefs/dcache.c | 24 +- fs/orangefs/devpvfs2-req.c | 256 +++++++++++----------- fs/orangefs/dir.c | 86 ++++---- fs/orangefs/downcall.h | 84 +++---- fs/orangefs/file.c | 208 +++++++++--------- fs/orangefs/inode.c | 176 +++++++-------- fs/orangefs/namei.c | 134 ++++++------ fs/orangefs/protocol.h | 302 ++++++++++++------------- fs/orangefs/pvfs2-bufmap.c | 168 +++++++------- fs/orangefs/pvfs2-bufmap.h | 40 ++-- fs/orangefs/pvfs2-cache.c | 122 +++++------ fs/orangefs/pvfs2-debug.h | 18 +- fs/orangefs/pvfs2-debugfs.c | 48 ++-- fs/orangefs/pvfs2-debugfs.h | 6 +- fs/orangefs/pvfs2-dev-proto.h | 68 +++--- fs/orangefs/pvfs2-kernel.h | 402 +++++++++++++++++----------------- fs/orangefs/pvfs2-mod.c | 106 ++++----- fs/orangefs/pvfs2-sysfs.c | 108 ++++----- fs/orangefs/pvfs2-utils.c | 336 ++++++++++++++-------------- fs/orangefs/super.c | 280 +++++++++++------------ fs/orangefs/symlink.c | 14 +- fs/orangefs/upcall.h | 250 ++++++++++----------- fs/orangefs/waitqueue.c | 70 +++--- fs/orangefs/xattr.c | 204 ++++++++--------- 25 files changed, 1776 insertions(+), 1776 deletions(-) diff --git a/fs/orangefs/acl.c b/fs/orangefs/acl.c index e462b81a3ba1..5e27d5fcb6bf 100644 --- a/fs/orangefs/acl.c +++ b/fs/orangefs/acl.c @@ -10,7 +10,7 @@ #include #include -struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) +struct posix_acl *orangefs_get_acl(struct inode *inode, int type) { struct posix_acl *acl; int ret; @@ -18,23 +18,23 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) switch (type) { case ACL_TYPE_ACCESS: - key = PVFS2_XATTR_NAME_ACL_ACCESS; + key = ORANGEFS_XATTR_NAME_ACL_ACCESS; break; case ACL_TYPE_DEFAULT: - key = PVFS2_XATTR_NAME_ACL_DEFAULT; + key = ORANGEFS_XATTR_NAME_ACL_DEFAULT; break; default: - gossip_err("pvfs2_get_acl: bogus value of type %d\n", type); + gossip_err("orangefs_get_acl: bogus value of type %d\n", type); return ERR_PTR(-EINVAL); } /* * Rather than incurring a network call just to determine the exact * length of the attribute, I just allocate a max length to save on * the network call. Conceivably, we could pass NULL to - * pvfs2_inode_getxattr() to probe the length of the value, but + * orangefs_inode_getxattr() to probe the length of the value, but * I don't do that for now. */ - value = kmalloc(PVFS_MAX_XATTR_VALUELEN, GFP_KERNEL); + value = kmalloc(ORANGEFS_MAX_XATTR_VALUELEN, GFP_KERNEL); if (value == NULL) return ERR_PTR(-ENOMEM); @@ -43,11 +43,11 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) get_khandle_from_ino(inode), key, type); - ret = pvfs2_inode_getxattr(inode, + ret = orangefs_inode_getxattr(inode, "", key, value, - PVFS_MAX_XATTR_VALUELEN); + ORANGEFS_MAX_XATTR_VALUELEN); /* if the key exists, convert it to an in-memory rep */ if (ret > 0) { acl = posix_acl_from_xattr(&init_user_ns, value, ret); @@ -64,9 +64,9 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type) return acl; } -int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) +int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); int error = 0; void *value = NULL; size_t size = 0; @@ -74,7 +74,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) switch (type) { case ACL_TYPE_ACCESS: - name = PVFS2_XATTR_NAME_ACL_ACCESS; + name = ORANGEFS_XATTR_NAME_ACL_ACCESS; if (acl) { umode_t mode = inode->i_mode; /* @@ -90,7 +90,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) } if (inode->i_mode != mode) - SetModeFlag(pvfs2_inode); + SetModeFlag(orangefs_inode); inode->i_mode = mode; mark_inode_dirty_sync(inode); if (error == 0) @@ -98,7 +98,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) } break; case ACL_TYPE_DEFAULT: - name = PVFS2_XATTR_NAME_ACL_DEFAULT; + name = ORANGEFS_XATTR_NAME_ACL_DEFAULT; break; default: gossip_err("%s: invalid type %d!\n", __func__, type); @@ -131,7 +131,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type) * will xlate to a removexattr. However, we don't want removexattr * complain if attributes does not exist. */ - error = pvfs2_inode_setxattr(inode, "", name, value, size, 0); + error = orangefs_inode_setxattr(inode, "", name, value, size, 0); out: kfree(value); @@ -140,35 +140,35 @@ out: return error; } -int pvfs2_init_acl(struct inode *inode, struct inode *dir) +int orangefs_init_acl(struct inode *inode, struct inode *dir) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); struct posix_acl *default_acl, *acl; umode_t mode = inode->i_mode; int error = 0; - ClearModeFlag(pvfs2_inode); + ClearModeFlag(orangefs_inode); error = posix_acl_create(dir, &mode, &default_acl, &acl); if (error) return error; if (default_acl) { - error = pvfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT); + error = orangefs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT); posix_acl_release(default_acl); } if (acl) { if (!error) - error = pvfs2_set_acl(inode, acl, ACL_TYPE_ACCESS); + error = orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS); posix_acl_release(acl); } /* If mode of the inode was changed, then do a forcible ->setattr */ if (mode != inode->i_mode) { - SetModeFlag(pvfs2_inode); + SetModeFlag(orangefs_inode); inode->i_mode = mode; - pvfs2_flush_inode(inode); + orangefs_flush_inode(inode); } return error; diff --git a/fs/orangefs/dcache.c b/fs/orangefs/dcache.c index 9466b179bf24..12c916fa4c7f 100644 --- a/fs/orangefs/dcache.c +++ b/fs/orangefs/dcache.c @@ -12,27 +12,27 @@ #include "pvfs2-kernel.h" /* Returns 1 if dentry can still be trusted, else 0. */ -static int pvfs2_revalidate_lookup(struct dentry *dentry) +static int orangefs_revalidate_lookup(struct dentry *dentry) { struct dentry *parent_dentry = dget_parent(dentry); struct inode *parent_inode = parent_dentry->d_inode; - struct pvfs2_inode_s *parent = PVFS2_I(parent_inode); + struct orangefs_inode_s *parent = ORANGEFS_I(parent_inode); struct inode *inode = dentry->d_inode; - struct pvfs2_kernel_op_s *new_op; + struct orangefs_kernel_op_s *new_op; int ret = 0; int err = 0; gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: attempting lookup.\n", __func__); - new_op = op_alloc(PVFS2_VFS_OP_LOOKUP); + new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP); if (!new_op) goto out_put_parent; - new_op->upcall.req.lookup.sym_follow = PVFS2_LOOKUP_LINK_NO_FOLLOW; + new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW; new_op->upcall.req.lookup.parent_refn = parent->refn; strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name, - PVFS2_NAME_LEN); + ORANGEFS_NAME_LEN); gossip_debug(GOSSIP_DCACHE_DEBUG, "%s:%s:%d interrupt flag [%d]\n", @@ -41,7 +41,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry) __LINE__, get_interruptible_flag(parent_inode)); - err = service_operation(new_op, "pvfs2_lookup", + err = service_operation(new_op, "orangefs_lookup", get_interruptible_flag(parent_inode)); if (err) goto out_drop; @@ -79,7 +79,7 @@ out_drop: * * Should return 1 if dentry can still be trusted, else 0 */ -static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) +static int orangefs_d_revalidate(struct dentry *dentry, unsigned int flags) { struct inode *inode; int ret = 0; @@ -105,7 +105,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) * exists, but is still in the expected place in the name space */ if (!is_root_handle(inode)) { - if (!pvfs2_revalidate_lookup(dentry)) + if (!orangefs_revalidate_lookup(dentry)) goto invalid_exit; } else { gossip_debug(GOSSIP_DCACHE_DEBUG, @@ -119,7 +119,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags) __func__, inode, get_khandle_from_ino(inode)); - ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT); + ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT); gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: getattr %s (ret = %d), returning %s for dentry i_count=%d\n", __func__, @@ -137,6 +137,6 @@ invalid_exit: return 0; } -const struct dentry_operations pvfs2_dentry_operations = { - .d_revalidate = pvfs2_d_revalidate, +const struct dentry_operations orangefs_dentry_operations = { + .d_revalidate = orangefs_d_revalidate, }; diff --git a/fs/orangefs/devpvfs2-req.c b/fs/orangefs/devpvfs2-req.c index e37b6479a6a1..e18149f0975b 100644 --- a/fs/orangefs/devpvfs2-req.c +++ b/fs/orangefs/devpvfs2-req.c @@ -22,14 +22,14 @@ static int open_access_count; #define DUMP_DEVICE_ERROR() \ do { \ 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 " \ - "are no ", PVFS2_REQDEVICE_NAME); \ + "are no ", ORANGEFS_REQDEVICE_NAME); \ gossip_err("instances of a program using this device\ncurrently " \ "running. (You must verify this!)\n"); \ gossip_err("For example, you can use the lsof program as follows:\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("*****************************************************\n");\ } while (0) @@ -39,7 +39,7 @@ static int hash_func(__u64 tag, 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); @@ -48,9 +48,9 @@ static void pvfs2_devreq_add_op(struct pvfs2_kernel_op_s *op) 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; 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; } -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; 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; } ret = -EACCES; @@ -100,14 +100,14 @@ out: return ret; } -static ssize_t pvfs2_devreq_read(struct file *file, +static ssize_t orangefs_devreq_read(struct file *file, char __user *buf, size_t count, loff_t *offset) { - struct pvfs2_kernel_op_s *op, *temp; - __s32 proto_ver = PVFS_KERNEL_PROTO_VERSION; - static __s32 magic = PVFS2_DEVREQ_MAGIC; - struct pvfs2_kernel_op_s *cur_op = NULL; + struct orangefs_kernel_op_s *op, *temp; + __s32 proto_ver = ORANGEFS_KERNEL_PROTO_VERSION; + static __s32 magic = ORANGEFS_DEVREQ_MAGIC; + struct orangefs_kernel_op_s *cur_op = NULL; unsigned long ret; /* 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. */ - spin_lock(&pvfs2_request_list_lock); - list_for_each_entry_safe(op, temp, &pvfs2_request_list, list) { + spin_lock(&orangefs_request_list_lock); + list_for_each_entry_safe(op, temp, &orangefs_request_list, list) { __s32 fsid; /* This lock is held past the end of the loop when we break. */ spin_lock(&op->lock); fsid = fsid_of_op(op); - if (fsid != PVFS_FS_ID_NULL) { + if (fsid != ORANGEFS_FS_ID_NULL) { int ret; /* Skip ops whose filesystem needs to be mounted. */ ret = fs_mount_pending(fsid); @@ -147,8 +147,8 @@ static ssize_t pvfs2_devreq_read(struct file *file, * it is being mounted. */ /* XXX: is there a better way to detect this? */ } else if (ret == -1 && - !(op->upcall.type == PVFS2_VFS_OP_FS_MOUNT || - op->upcall.type == PVFS2_VFS_OP_GETATTR)) { + !(op->upcall.type == ORANGEFS_VFS_OP_FS_MOUNT || + op->upcall.type == ORANGEFS_VFS_OP_GETATTR)) { gossip_debug(GOSSIP_DEV_DEBUG, "orangefs: skipping op tag %llu %s\n", 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. */ if (!cur_op) { - spin_unlock(&pvfs2_request_list_lock); + spin_unlock(&orangefs_request_list_lock); return -EAGAIN; } @@ -188,7 +188,7 @@ static ssize_t pvfs2_devreq_read(struct file *file, gossip_err("orangefs: ERROR: Current op already queued.\n"); list_del(&cur_op->list); spin_unlock(&cur_op->lock); - spin_unlock(&pvfs2_request_list_lock); + spin_unlock(&orangefs_request_list_lock); return -EAGAIN; } @@ -199,8 +199,8 @@ static ssize_t pvfs2_devreq_read(struct file *file, set_op_state_inprogress(cur_op); list_del(&cur_op->list); - spin_unlock(&pvfs2_request_list_lock); - pvfs2_devreq_add_op(cur_op); + spin_unlock(&orangefs_request_list_lock); + orangefs_devreq_add_op(cur_op); spin_unlock(&cur_op->lock); /* Push the upcall out. */ @@ -214,7 +214,7 @@ static ssize_t pvfs2_devreq_read(struct file *file, if (ret != 0) goto error; 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) goto error; @@ -227,23 +227,23 @@ error: * device is released. */ 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); set_op_state_waiting(cur_op); - pvfs2_devreq_remove_op(cur_op->tag); - list_add(&cur_op->list, &pvfs2_request_list); + orangefs_devreq_remove_op(cur_op->tag); + list_add(&cur_op->list, &orangefs_request_list); spin_unlock(&cur_op->lock); - spin_unlock(&pvfs2_request_list_lock); + spin_unlock(&orangefs_request_list_lock); return -EFAULT; } /* 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, size_t count, loff_t *offset) { - struct pvfs2_kernel_op_s *op = NULL; + struct orangefs_kernel_op_s *op = NULL; void *buffer = NULL; void *ptr = NULL; unsigned long i = 0; @@ -301,7 +301,7 @@ static ssize_t pvfs2_devreq_writev(struct file *file, tag = *((__u64 *) ptr); ptr += sizeof(__u64); - if (magic != PVFS2_DEVREQ_MAGIC) { + if (magic != ORANGEFS_DEVREQ_MAGIC) { gossip_err("Error: Device magic number does not match.\n"); dev_req_release(buffer); return -EPROTO; @@ -311,17 +311,17 @@ static ssize_t pvfs2_devreq_writev(struct file *file, * proto_ver = 20902 for 2.9.2 */ - op = pvfs2_devreq_remove_op(tag); + op = orangefs_devreq_remove_op(tag); if (op) { /* Increase ref count! */ get_op(op); /* cut off magic and tag from payload size */ 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 */ memcpy(&op->downcall, ptr, - sizeof(struct pvfs2_downcall_s)); + sizeof(struct orangefs_downcall_s)); else gossip_debug(GOSSIP_DEV_DEBUG, "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 * the buffers are done being used. */ - if (op->upcall.type == PVFS2_VFS_OP_FILE_IO && - op->upcall.req.io.async_vfs_io == PVFS_VFS_SYNC_IO) { + if (op->upcall.type == ORANGEFS_VFS_OP_FILE_IO && + op->upcall.req.io.async_vfs_io == ORANGEFS_VFS_SYNC_IO) { int timed_out = 0; DECLARE_WAITQUEUE(wait_entry, current); @@ -473,10 +473,10 @@ static ssize_t pvfs2_devreq_writev(struct file *file, 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) { - return pvfs2_devreq_writev(iocb->ki_filp, + return orangefs_devreq_writev(iocb->ki_filp, iter->iov, iter->nr_segs, &iocb->ki_pos); @@ -486,15 +486,15 @@ static ssize_t pvfs2_devreq_write_iter(struct kiocb *iocb, static int mark_all_pending_mounts(void) { int unmounted = 1; - struct pvfs2_sb_info_s *pvfs2_sb = NULL; + struct orangefs_sb_info_s *orangefs_sb = NULL; - spin_lock(&pvfs2_superblocks_lock); - list_for_each_entry(pvfs2_sb, &pvfs2_superblocks, list) { + spin_lock(&orangefs_superblocks_lock); + list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { /* All of these file system require a remount */ - pvfs2_sb->mount_pending = 1; + orangefs_sb->mount_pending = 1; unmounted = 0; } - spin_unlock(&pvfs2_superblocks_lock); + spin_unlock(&orangefs_superblocks_lock); return unmounted; } @@ -507,16 +507,16 @@ static int mark_all_pending_mounts(void) int fs_mount_pending(__s32 fsid) { 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); - list_for_each_entry(pvfs2_sb, &pvfs2_superblocks, list) { - if (pvfs2_sb->fs_id == fsid) { - mount_pending = pvfs2_sb->mount_pending; + spin_lock(&orangefs_superblocks_lock); + list_for_each_entry(orangefs_sb, &orangefs_superblocks, list) { + if (orangefs_sb->fs_id == fsid) { + mount_pending = orangefs_sb->mount_pending; break; } } - spin_unlock(&pvfs2_superblocks_lock); + spin_unlock(&orangefs_superblocks_lock); return mount_pending; } @@ -525,10 +525,10 @@ int fs_mount_pending(__s32 fsid) * 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. * 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 */ -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; @@ -537,12 +537,12 @@ static int pvfs2_devreq_release(struct inode *inode, struct file *file) __func__); mutex_lock(&devreq_mutex); - pvfs_bufmap_finalize(); + orangefs_bufmap_finalize(); open_access_count--; 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")); mutex_unlock(&devreq_mutex); @@ -578,17 +578,17 @@ int is_daemon_in_service(void) static inline long check_ioctl_command(unsigned int command) { /* 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", command, _IOC_TYPE(command), - PVFS_DEV_MAGIC); + ORANGEFS_DEV_MAGIC); return -EINVAL; } /* 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", - _IOC_NR(command), PVFS_DEV_MAXNR); + _IOC_NR(command), ORANGEFS_DEV_MAXNR); return -ENOIOCTLCMD; } 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 __s32 magic = PVFS2_DEVREQ_MAGIC; + static __s32 magic = ORANGEFS_DEVREQ_MAGIC; static __s32 max_up_size = MAX_ALIGNED_DEV_REQ_UPSIZE; 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; struct dev_mask_info_s mask_info = { 0 }; struct dev_mask2_info_s mask2_info = { 0, 0 }; int upstream_kmod = 1; 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 */ switch (command) { - case PVFS_DEV_GET_MAGIC: + case ORANGEFS_DEV_GET_MAGIC: return ((put_user(magic, (__s32 __user *) arg) == -EFAULT) ? -EIO : 0); - case PVFS_DEV_GET_MAX_UPSIZE: + case ORANGEFS_DEV_GET_MAX_UPSIZE: return ((put_user(max_up_size, (__s32 __user *) arg) == -EFAULT) ? -EIO : 0); - case PVFS_DEV_GET_MAX_DOWNSIZE: + case ORANGEFS_DEV_GET_MAX_DOWNSIZE: return ((put_user(max_down_size, (__s32 __user *) arg) == -EFAULT) ? -EIO : 0); - case PVFS_DEV_MAP: + case ORANGEFS_DEV_MAP: ret = copy_from_user(&user_desc, - (struct PVFS_dev_map_desc __user *) + (struct ORANGEFS_dev_map_desc __user *) arg, - sizeof(struct PVFS_dev_map_desc)); - return ret ? -EIO : pvfs_bufmap_initialize(&user_desc); - case PVFS_DEV_REMOUNT_ALL: + sizeof(struct ORANGEFS_dev_map_desc)); + return ret ? -EIO : orangefs_bufmap_initialize(&user_desc); + case ORANGEFS_DEV_REMOUNT_ALL: 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 * without keeping the superblock list locked due to the * 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) return ret; gossip_debug(GOSSIP_DEV_DEBUG, - "pvfs2_devreq_ioctl: priority remount in progress\n"); - list_for_each(tmp, &pvfs2_superblocks) { - pvfs2_sb = - list_entry(tmp, struct pvfs2_sb_info_s, list); - if (pvfs2_sb && (pvfs2_sb->sb)) { + "orangefs_devreq_ioctl: priority remount in progress\n"); + list_for_each(tmp, &orangefs_superblocks) { + orangefs_sb = + list_entry(tmp, struct orangefs_sb_info_s, list); + if (orangefs_sb && (orangefs_sb->sb)) { gossip_debug(GOSSIP_DEV_DEBUG, "Remounting SB %p\n", - pvfs2_sb); + orangefs_sb); - ret = pvfs2_remount(pvfs2_sb->sb); + ret = orangefs_remount(orangefs_sb->sb); if (ret) { gossip_debug(GOSSIP_DEV_DEBUG, "SB %p remount failed\n", - pvfs2_sb); + orangefs_sb); break; } } } gossip_debug(GOSSIP_DEV_DEBUG, - "pvfs2_devreq_ioctl: priority remount complete\n"); + "orangefs_devreq_ioctl: priority remount complete\n"); mutex_unlock(&request_mutex); return ret; - case PVFS_DEV_UPSTREAM: + case ORANGEFS_DEV_UPSTREAM: ret = copy_to_user((void __user *)arg, &upstream_kmod, sizeof(upstream_kmod)); @@ -680,7 +680,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) else return ret; - case PVFS_DEV_CLIENT_MASK: + case ORANGEFS_DEV_CLIENT_MASK: ret = copy_from_user(&mask2_info, (void __user *)arg, sizeof(struct dev_mask2_info_s)); @@ -699,13 +699,13 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) return ret; - case PVFS_DEV_CLIENT_STRING: + case ORANGEFS_DEV_CLIENT_STRING: ret = copy_from_user(&client_debug_array_string, (void __user *)arg, - PVFS2_MAX_DEBUG_STRING_LEN); + ORANGEFS_MAX_DEBUG_STRING_LEN); if (ret != 0) { pr_info("%s: " - "PVFS_DEV_CLIENT_STRING: copy_from_user failed" + "ORANGEFS_DEV_CLIENT_STRING: copy_from_user failed" "\n", __func__); return -EIO; @@ -753,13 +753,13 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) debugfs_remove(client_debug_dentry); - pvfs2_client_debug_init(); + orangefs_client_debug_init(); help_string_initialized++; return ret; - case PVFS_DEV_DEBUG: + case ORANGEFS_DEV_DEBUG: ret = copy_from_user(&mask_info, (void __user *)arg, 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 * kernel module was loaded; don't override * it if the client-core was started without - * a value for PVFS2_KMODMASK. + * a value for ORANGEFS_KMODMASK. */ return 0; } debug_mask_to_string(&mask_info.mask_value, mask_info.mask_type); 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", kernel_debug_string, (unsigned long long)gossip_debug_mask); } else if (mask_info.mask_type == CLIENT_MASK) { debug_mask_to_string(&mask_info.mask_value, 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", client_debug_string, llu(mask_info.mask_value)); @@ -805,7 +805,7 @@ static long dispatch_ioctl_command(unsigned int command, unsigned long arg) return -ENOIOCTLCMD; } -static long pvfs2_devreq_ioctl(struct file *file, +static long orangefs_devreq_ioctl(struct file *file, unsigned int command, unsigned long arg) { long ret; @@ -820,8 +820,8 @@ static long pvfs2_devreq_ioctl(struct file *file, #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ -/* Compat structure for the PVFS_DEV_MAP ioctl */ -struct PVFS_dev_map_desc32 { +/* Compat structure for the ORANGEFS_DEV_MAP ioctl */ +struct ORANGEFS_dev_map_desc32 { compat_uptr_t ptr; __s32 total_size; __s32 size; @@ -830,12 +830,12 @@ struct PVFS_dev_map_desc32 { 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 * 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_uptr_t addr; @@ -863,7 +863,7 @@ err: * 32 bit user-space apps' ioctl handlers when kernel modules * 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) { long ret; @@ -873,7 +873,7 @@ static long pvfs2_devreq_compat_ioctl(struct file *filp, unsigned int cmd, ret = check_ioctl_command(cmd); if (ret < 0) return ret; - if (cmd == PVFS_DEV_MAP) { + if (cmd == ORANGEFS_DEV_MAP) { /* * convert the arguments to what we expect internally * 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... */ #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; } -static void pvfs2_ioctl32_cleanup(void) +static void orangefs_ioctl32_cleanup(void) { return; } #endif /* 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 */ -int pvfs2_dev_init(void) +int orangefs_dev_init(void) { int ret; /* register the ioctl32 sub-system */ - ret = pvfs2_ioctl32_init(); + ret = orangefs_ioctl32_init(); if (ret < 0) return ret; - /* register pvfs2-req device */ - pvfs2_dev_major = register_chrdev(0, - PVFS2_REQDEVICE_NAME, - &pvfs2_devreq_file_operations); - if (pvfs2_dev_major < 0) { + /* register orangefs-req device */ + orangefs_dev_major = register_chrdev(0, + ORANGEFS_REQDEVICE_NAME, + &orangefs_devreq_file_operations); + if (orangefs_dev_major < 0) { gossip_debug(GOSSIP_DEV_DEBUG, "Failed to register /dev/%s (error %d)\n", - PVFS2_REQDEVICE_NAME, pvfs2_dev_major); - pvfs2_ioctl32_cleanup(); - return pvfs2_dev_major; + ORANGEFS_REQDEVICE_NAME, orangefs_dev_major); + orangefs_ioctl32_cleanup(); + return orangefs_dev_major; } gossip_debug(GOSSIP_DEV_DEBUG, "*** /dev/%s character device registered ***\n", - PVFS2_REQDEVICE_NAME); + ORANGEFS_REQDEVICE_NAME); 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; } -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, "*** /dev/%s character device unregistered ***\n", - PVFS2_REQDEVICE_NAME); + ORANGEFS_REQDEVICE_NAME); /* 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) { int poll_revent_mask = 0; 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); - if (!list_empty(&pvfs2_request_list)) + spin_lock(&orangefs_request_list_lock); + if (!list_empty(&orangefs_request_list)) poll_revent_mask |= POLL_IN; - spin_unlock(&pvfs2_request_list_lock); + spin_unlock(&orangefs_request_list_lock); } return poll_revent_mask; } -const struct file_operations pvfs2_devreq_file_operations = { +const struct file_operations orangefs_devreq_file_operations = { .owner = THIS_MODULE, - .read = pvfs2_devreq_read, - .write_iter = pvfs2_devreq_write_iter, - .open = pvfs2_devreq_open, - .release = pvfs2_devreq_release, - .unlocked_ioctl = pvfs2_devreq_ioctl, + .read = orangefs_devreq_read, + .write_iter = orangefs_devreq_write_iter, + .open = orangefs_devreq_open, + .release = orangefs_devreq_release, + .unlocked_ioctl = orangefs_devreq_ioctl, #ifdef CONFIG_COMPAT /* CONFIG_COMPAT is in .config */ - .compat_ioctl = pvfs2_devreq_compat_ioctl, + .compat_ioctl = orangefs_devreq_compat_ioctl, #endif - .poll = pvfs2_devreq_poll + .poll = orangefs_devreq_poll }; diff --git a/fs/orangefs/dir.c b/fs/orangefs/dir.c index 3049cd61b700..452d589b9747 100644 --- a/fs/orangefs/dir.c +++ b/fs/orangefs/dir.c @@ -10,7 +10,7 @@ struct readdir_handle_s { int buffer_index; - struct pvfs2_readdir_response_s readdir_response; + struct orangefs_readdir_response_s readdir_response; void *dents_buf; }; @@ -18,28 +18,28 @@ struct readdir_handle_s { * decode routine needed by kmod to make sense of the shared page for readdirs. */ static long decode_dirents(char *ptr, size_t size, - struct pvfs2_readdir_response_s *readdir) + struct orangefs_readdir_response_s *readdir) { int i; - struct pvfs2_readdir_response_s *rd = - (struct pvfs2_readdir_response_s *) ptr; + struct orangefs_readdir_response_s *rd = + (struct orangefs_readdir_response_s *) ptr; char *buf = ptr; - if (size < offsetof(struct pvfs2_readdir_response_s, dirent_array)) + if (size < offsetof(struct orangefs_readdir_response_s, dirent_array)) return -EINVAL; readdir->token = rd->token; - readdir->pvfs_dirent_outcount = rd->pvfs_dirent_outcount; - readdir->dirent_array = kcalloc(readdir->pvfs_dirent_outcount, + readdir->orangefs_dirent_outcount = rd->orangefs_dirent_outcount; + readdir->dirent_array = kcalloc(readdir->orangefs_dirent_outcount, sizeof(*readdir->dirent_array), GFP_KERNEL); if (readdir->dirent_array == NULL) return -ENOMEM; - buf += offsetof(struct pvfs2_readdir_response_s, dirent_array); - size -= offsetof(struct pvfs2_readdir_response_s, dirent_array); + buf += offsetof(struct orangefs_readdir_response_s, dirent_array); + size -= offsetof(struct orangefs_readdir_response_s, dirent_array); - for (i = 0; i < readdir->pvfs_dirent_outcount; i++) { + for (i = 0; i < readdir->orangefs_dirent_outcount; i++) { __u32 len; if (size < 4) @@ -60,7 +60,7 @@ static long decode_dirents(char *ptr, size_t size, buf += len; readdir->dirent_array[i].khandle = - *(struct pvfs2_khandle *) buf; + *(struct orangefs_khandle *) buf; buf += 16; } return buf - ptr; @@ -98,7 +98,7 @@ static long readdir_handle_ctor(struct readdir_handle_s *rhandle, void *buf, return ret; } -static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap, +static void readdir_handle_dtor(struct orangefs_bufmap *bufmap, struct readdir_handle_s *rhandle) { if (rhandle == NULL) @@ -123,9 +123,9 @@ static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap, /* * Read directory entries from an instance of an open directory. */ -static int pvfs2_readdir(struct file *file, struct dir_context *ctx) +static int orangefs_readdir(struct file *file, struct dir_context *ctx) { - struct pvfs2_bufmap *bufmap = NULL; + struct orangefs_bufmap *bufmap = NULL; int ret = 0; int buffer_index; /* @@ -136,8 +136,8 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) __u64 pos = 0; ino_t ino = 0; struct dentry *dentry = file->f_path.dentry; - struct pvfs2_kernel_op_s *new_op = NULL; - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(dentry->d_inode); + struct orangefs_kernel_op_s *new_op = NULL; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode); int buffer_full = 0; struct readdir_handle_s rhandle; int i = 0; @@ -155,26 +155,26 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) pos = (__u64) ctx->pos; /* are we done? */ - if (pos == PVFS_READDIR_END) { + if (pos == ORANGEFS_READDIR_END) { gossip_debug(GOSSIP_DIR_DEBUG, "Skipping to termination path\n"); return 0; } gossip_debug(GOSSIP_DIR_DEBUG, - "pvfs2_readdir called on %s (pos=%llu)\n", + "orangefs_readdir called on %s (pos=%llu)\n", dentry->d_name.name, llu(pos)); rhandle.buffer_index = -1; rhandle.dents_buf = NULL; memset(&rhandle.readdir_response, 0, sizeof(rhandle.readdir_response)); - new_op = op_alloc(PVFS2_VFS_OP_READDIR); + new_op = op_alloc(ORANGEFS_VFS_OP_READDIR); if (!new_op) return -ENOMEM; new_op->uses_shared_memory = 1; - new_op->upcall.req.readdir.refn = pvfs2_inode->refn; + new_op->upcall.req.readdir.refn = orangefs_inode->refn; new_op->upcall.req.readdir.max_dirent_count = MAX_DIRENT_COUNT_READDIR; gossip_debug(GOSSIP_DIR_DEBUG, @@ -187,14 +187,14 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx) get_new_buffer_index: ret = readdir_index_get(&bufmap, &buffer_index); if (ret < 0) { - gossip_lerr("pvfs2_readdir: readdir_index_get() failure (%d)\n", + gossip_lerr("orangefs_readdir: readdir_index_get() failure (%d)\n", ret); goto out_free_op; } new_op->upcall.req.readdir.buf_index = buffer_index; ret = service_operation(new_op, - "pvfs2_readdir", + "orangefs_readdir", get_interruptible_flag(dentry->d_inode)); gossip_debug(GOSSIP_DIR_DEBUG, @@ -238,7 +238,7 @@ get_new_buffer_index: new_op->downcall.trailer_size, buffer_index); if (bytes_decoded < 0) { - gossip_err("pvfs2_readdir: Could not decode trailer buffer into a readdir response %d\n", + gossip_err("orangefs_readdir: Could not decode trailer buffer into a readdir response %d\n", ret); ret = bytes_decoded; readdir_index_put(bufmap, buffer_index); @@ -246,7 +246,7 @@ get_new_buffer_index: } if (bytes_decoded != new_op->downcall.trailer_size) { - gossip_err("pvfs2_readdir: # bytes decoded (%ld) " + gossip_err("orangefs_readdir: # bytes decoded (%ld) " "!= trailer size (%ld)\n", bytes_decoded, (long)new_op->downcall.trailer_size); @@ -255,7 +255,7 @@ 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. */ 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 * other than the first. */ - if (ctx->pos == PVFS_ITERATE_NEXT) + if (ctx->pos == ORANGEFS_ITERATE_NEXT) ctx->pos = 0; for (i = ctx->pos; - i < rhandle.readdir_response.pvfs_dirent_outcount; + i < rhandle.readdir_response.orangefs_dirent_outcount; i++) { len = rhandle.readdir_response.dirent_array[i].d_length; current_entry = rhandle.readdir_response.dirent_array[i].d_name; - current_ino = pvfs2_khandle_to_ino( + current_ino = orangefs_khandle_to_ino( &(rhandle.readdir_response.dirent_array[i].khandle)); gossip_debug(GOSSIP_DIR_DEBUG, @@ -323,28 +323,28 @@ get_new_buffer_index: */ if (ret) { *ptoken = rhandle.readdir_response.token; - ctx->pos = PVFS_ITERATE_NEXT; + ctx->pos = ORANGEFS_ITERATE_NEXT; } /* * Did we hit the end of the directory? */ - if (rhandle.readdir_response.token == PVFS_READDIR_END && + if (rhandle.readdir_response.token == ORANGEFS_READDIR_END && !buffer_full) { gossip_debug(GOSSIP_DIR_DEBUG, - "End of dir detected; setting ctx->pos to PVFS_READDIR_END.\n"); - ctx->pos = PVFS_READDIR_END; + "End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n"); + ctx->pos = ORANGEFS_READDIR_END; } out_destroy_handle: readdir_handle_dtor(bufmap, &rhandle); out_free_op: op_release(new_op); - gossip_debug(GOSSIP_DIR_DEBUG, "pvfs2_readdir returning %d\n", ret); + gossip_debug(GOSSIP_DIR_DEBUG, "orangefs_readdir returning %d\n", ret); return ret; } -static int pvfs2_dir_open(struct inode *inode, struct file *file) +static int orangefs_dir_open(struct inode *inode, struct file *file) { __u64 *ptoken; @@ -353,21 +353,21 @@ static int pvfs2_dir_open(struct inode *inode, struct file *file) return -ENOMEM; ptoken = file->private_data; - *ptoken = PVFS_READDIR_START; + *ptoken = ORANGEFS_READDIR_START; return 0; } -static int pvfs2_dir_release(struct inode *inode, struct file *file) +static int orangefs_dir_release(struct inode *inode, struct file *file) { - pvfs2_flush_inode(inode); + orangefs_flush_inode(inode); kfree(file->private_data); return 0; } -/** PVFS2 implementation of VFS directory operations */ -const struct file_operations pvfs2_dir_operations = { +/** ORANGEFS implementation of VFS directory operations */ +const struct file_operations orangefs_dir_operations = { .read = generic_read_dir, - .iterate = pvfs2_readdir, - .open = pvfs2_dir_open, - .release = pvfs2_dir_release, + .iterate = orangefs_readdir, + .open = orangefs_dir_open, + .release = orangefs_dir_release, }; diff --git a/fs/orangefs/downcall.h b/fs/orangefs/downcall.h index e372f446f6ba..72d4cac54821 100644 --- a/fs/orangefs/downcall.h +++ b/fs/orangefs/downcall.h @@ -15,42 +15,42 @@ * Sanitized the device-client core interaction * for clean 32-64 bit usage */ -struct pvfs2_io_response { +struct orangefs_io_response { __s64 amt_complete; }; -struct pvfs2_lookup_response { - struct pvfs2_object_kref refn; +struct orangefs_lookup_response { + struct orangefs_object_kref refn; }; -struct pvfs2_create_response { - struct pvfs2_object_kref refn; +struct orangefs_create_response { + struct orangefs_object_kref refn; }; -struct pvfs2_symlink_response { - struct pvfs2_object_kref refn; +struct orangefs_symlink_response { + struct orangefs_object_kref refn; }; -struct pvfs2_getattr_response { - struct PVFS_sys_attr_s attributes; - char link_target[PVFS2_NAME_LEN]; +struct orangefs_getattr_response { + struct ORANGEFS_sys_attr_s attributes; + char link_target[ORANGEFS_NAME_LEN]; }; -struct pvfs2_mkdir_response { - struct pvfs2_object_kref refn; +struct orangefs_mkdir_response { + struct orangefs_object_kref refn; }; /* * duplication of some system interface structures so that I don't have * to allocate extra memory */ -struct pvfs2_dirent { +struct orangefs_dirent { char *d_name; int d_length; - struct pvfs2_khandle khandle; + struct orangefs_khandle khandle; }; -struct pvfs2_statfs_response { +struct orangefs_statfs_response { __s64 block_size; __s64 blocks_total; __s64 blocks_avail; @@ -58,47 +58,47 @@ struct pvfs2_statfs_response { __s64 files_avail; }; -struct pvfs2_fs_mount_response { +struct orangefs_fs_mount_response { __s32 fs_id; __s32 id; - struct pvfs2_khandle root_khandle; + struct orangefs_khandle root_khandle; }; /* the getxattr response is the attribute value */ -struct pvfs2_getxattr_response { +struct orangefs_getxattr_response { __s32 val_sz; __s32 __pad1; - char val[PVFS_MAX_XATTR_VALUELEN]; + char val[ORANGEFS_MAX_XATTR_VALUELEN]; }; /* the listxattr response is an array of attribute names */ -struct pvfs2_listxattr_response { +struct orangefs_listxattr_response { __s32 returned_count; __s32 __pad1; __u64 token; - char key[PVFS_MAX_XATTR_LISTLEN * PVFS_MAX_XATTR_NAMELEN]; + char key[ORANGEFS_MAX_XATTR_LISTLEN * ORANGEFS_MAX_XATTR_NAMELEN]; __s32 keylen; __s32 __pad2; - __s32 lengths[PVFS_MAX_XATTR_LISTLEN]; + __s32 lengths[ORANGEFS_MAX_XATTR_LISTLEN]; }; -struct pvfs2_param_response { +struct orangefs_param_response { __s64 value; }; #define PERF_COUNT_BUF_SIZE 4096 -struct pvfs2_perf_count_response { +struct orangefs_perf_count_response { char buffer[PERF_COUNT_BUF_SIZE]; }; #define FS_KEY_BUF_SIZE 4096 -struct pvfs2_fs_key_response { +struct orangefs_fs_key_response { __s32 fs_keylen; __s32 __pad1; char fs_key[FS_KEY_BUF_SIZE]; }; -struct pvfs2_downcall_s { +struct orangefs_downcall_s { __s32 type; __s32 status; /* currently trailer is used only by readdir */ @@ -106,28 +106,28 @@ struct pvfs2_downcall_s { char *trailer_buf; union { - struct pvfs2_io_response io; - struct pvfs2_lookup_response lookup; - struct pvfs2_create_response create; - struct pvfs2_symlink_response sym; - struct pvfs2_getattr_response getattr; - struct pvfs2_mkdir_response mkdir; - struct pvfs2_statfs_response statfs; - struct pvfs2_fs_mount_response fs_mount; - struct pvfs2_getxattr_response getxattr; - struct pvfs2_listxattr_response listxattr; - struct pvfs2_param_response param; - struct pvfs2_perf_count_response perf_count; - struct pvfs2_fs_key_response fs_key; + struct orangefs_io_response io; + struct orangefs_lookup_response lookup; + struct orangefs_create_response create; + struct orangefs_symlink_response sym; + struct orangefs_getattr_response getattr; + struct orangefs_mkdir_response mkdir; + struct orangefs_statfs_response statfs; + struct orangefs_fs_mount_response fs_mount; + struct orangefs_getxattr_response getxattr; + struct orangefs_listxattr_response listxattr; + struct orangefs_param_response param; + struct orangefs_perf_count_response perf_count; + struct orangefs_fs_key_response fs_key; } resp; }; -struct pvfs2_readdir_response_s { +struct orangefs_readdir_response_s { __u64 token; __u64 directory_version; __u32 __pad2; - __u32 pvfs_dirent_outcount; - struct pvfs2_dirent *dirent_array; + __u32 orangefs_dirent_outcount; + struct orangefs_dirent *dirent_array; }; #endif /* __DOWNCALL_H */ diff --git a/fs/orangefs/file.c b/fs/orangefs/file.c index 3a8140f289f6..ae5d8ed67ed5 100644 --- a/fs/orangefs/file.c +++ b/fs/orangefs/file.c @@ -29,7 +29,7 @@ do { \ * can futher be kernel-space or user-space addresses. * 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, struct iov_iter *iter, size_t total_size) @@ -42,10 +42,10 @@ static int precopy_buffers(struct pvfs2_bufmap *bufmap, if (total_size) { - ret = pvfs_bufmap_copy_from_iovec(bufmap, - iter, - buffer_index, - total_size); + ret = orangefs_bufmap_copy_from_iovec(bufmap, + iter, + buffer_index, + total_size); if (ret < 0) gossip_err("%s: Failed to copy-in buffers. Please make sure that the pvfs2-client is running. %ld\n", __func__, @@ -66,7 +66,7 @@ static int precopy_buffers(struct pvfs2_bufmap *bufmap, * can futher be kernel-space or user-space addresses. * 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, struct iov_iter *iter, size_t total_size) @@ -78,10 +78,10 @@ static int postcopy_buffers(struct pvfs2_bufmap *bufmap, * struct page pointers. */ if (total_size) { - ret = pvfs_bufmap_copy_to_iovec(bufmap, - iter, - buffer_index, - total_size); + ret = orangefs_bufmap_copy_to_iovec(bufmap, + iter, + buffer_index, + total_size); if (ret < 0) gossip_err("%s: Failed to copy-out buffers. Please make sure that the pvfs2-client is running (%ld)\n", __func__, @@ -93,34 +93,34 @@ static int postcopy_buffers(struct pvfs2_bufmap *bufmap, /* * 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, size_t total_size, loff_t readahead_size) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_khandle *handle = &pvfs2_inode->refn.khandle; - struct pvfs2_bufmap *bufmap = NULL; - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_khandle *handle = &orangefs_inode->refn.khandle; + struct orangefs_bufmap *bufmap = NULL; + struct orangefs_kernel_op_s *new_op = NULL; int buffer_index = -1; ssize_t ret; - new_op = op_alloc(PVFS2_VFS_OP_FILE_IO); + new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO); if (!new_op) { ret = -ENOMEM; goto out; } /* 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.io_type = type; - new_op->upcall.req.io.refn = pvfs2_inode->refn; + new_op->upcall.req.io.refn = orangefs_inode->refn; populate_shared_memory: /* get a shared buffer index */ - ret = pvfs_bufmap_get(&bufmap, &buffer_index); + ret = orangefs_bufmap_get(&bufmap, &buffer_index); if (ret < 0) { gossip_debug(GOSSIP_FILE_DEBUG, - "%s: pvfs_bufmap_get failure (%ld)\n", + "%s: orangefs_bufmap_get failure (%ld)\n", __func__, (long)ret); goto out; } @@ -146,7 +146,7 @@ populate_shared_memory: * Stage 1: copy the buffers into client-core's address space * precopy_buffers only pertains to writes. */ - if (type == PVFS_IO_WRITE) { + if (type == ORANGEFS_IO_WRITE) { ret = precopy_buffers(bufmap, buffer_index, iter, @@ -163,14 +163,14 @@ populate_shared_memory: /* Stage 2: Service the I/O operation */ ret = service_operation(new_op, - type == PVFS_IO_WRITE ? + type == ORANGEFS_IO_WRITE ? "file_write" : "file_read", get_interruptible_flag(inode)); /* * 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 * 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 @@ -178,7 +178,7 @@ populate_shared_memory: * a new shared memory location. */ 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, "%s:going to repopulate_shared_memory.\n", __func__); @@ -199,7 +199,7 @@ populate_shared_memory: else gossip_err("%s: error in %s handle %pU, returning %zd\n", __func__, - type == PVFS_IO_READ ? + type == ORANGEFS_IO_READ ? "read from" : "write to", handle, ret); goto out; @@ -209,7 +209,7 @@ populate_shared_memory: * Stage 3: Post copy buffers from client-core's address space * postcopy_buffers only pertains to reads. */ - if (type == PVFS_IO_READ) { + if (type == ORANGEFS_IO_READ) { ret = postcopy_buffers(bufmap, buffer_index, iter, @@ -243,7 +243,7 @@ populate_shared_memory: out: if (buffer_index >= 0) { - pvfs_bufmap_put(bufmap, buffer_index); + orangefs_bufmap_put(bufmap, buffer_index); gossip_debug(GOSSIP_FILE_DEBUG, "%s(%pU): PUT buffer_index %d\n", __func__, handle, buffer_index); @@ -263,12 +263,12 @@ out: * augmented/extended metadata attached to the file. * 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) { struct inode *inode = file->f_mapping->host; - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_khandle *handle = &pvfs2_inode->refn.khandle; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_khandle *handle = &orangefs_inode->refn.khandle; size_t count = iov_iter_count(iter); ssize_t total_count = 0; ssize_t ret = -EINVAL; @@ -279,7 +279,7 @@ static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file, handle, (int)count); - if (type == PVFS_IO_WRITE) { + if (type == ORANGEFS_IO_WRITE) { gossip_debug(GOSSIP_FILE_DEBUG, "%s(%pU): proceeding with offset : %llu, " "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; /* how much to transfer in this loop iteration */ - if (each_count > pvfs_bufmap_size_query()) - each_count = pvfs_bufmap_size_query(); + if (each_count > orangefs_bufmap_size_query()) + each_count = orangefs_bufmap_size_query(); gossip_debug(GOSSIP_FILE_DEBUG, "%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; out: if (ret > 0) { - if (type == PVFS_IO_READ) { + if (type == ORANGEFS_IO_READ) { file_accessed(file); } else { - SetMtimeFlag(pvfs2_inode); + SetMtimeFlag(orangefs_inode); inode->i_mtime = CURRENT_TIME; mark_inode_dirty_sync(inode); } @@ -368,19 +368,19 @@ out: * Read data from a specified offset in a file (referenced by inode). * Data may be placed either in a user or kernel buffer. */ -ssize_t pvfs2_inode_read(struct inode *inode, - struct iov_iter *iter, - loff_t *offset, - loff_t readahead_size) +ssize_t orangefs_inode_read(struct inode *inode, + struct iov_iter *iter, + loff_t *offset, + 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 bufmap_size; 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) { gossip_debug(GOSSIP_FILE_DEBUG, "%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, "%s(%pU) %zd@%llu\n", __func__, - &pvfs2_inode->refn.khandle, + &orangefs_inode->refn.khandle, count, 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); if (ret > 0) *offset += ret; @@ -403,13 +403,13 @@ ssize_t pvfs2_inode_read(struct inode *inode, gossip_debug(GOSSIP_FILE_DEBUG, "%s(%pU): Value(%zd) returned.\n", __func__, - &pvfs2_inode->refn.khandle, + &orangefs_inode->refn.khandle, 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; 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); - 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; 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; 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); - 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); /* Make sure generic_write_checks sees an up to date inode size. */ if (file->f_flags & O_APPEND) { - rc = pvfs2_inode_getattr(file->f_mapping->host, - PVFS_ATTR_SYS_SIZE); + rc = orangefs_inode_getattr(file->f_mapping->host, + ORANGEFS_ATTR_SYS_SIZE); if (rc) { - gossip_err("%s: pvfs2_inode_getattr failed, rc:%zd:.\n", + gossip_err("%s: orangefs_inode_getattr failed, rc:%zd:.\n", __func__, rc); goto out; } } 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); @@ -468,7 +468,7 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter) */ pos = *(&iocb->ki_pos); - rc = do_readv_writev(PVFS_IO_WRITE, + rc = do_readv_writev(ORANGEFS_IO_WRITE, file, &pos, iter); @@ -479,7 +479,7 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter) } iocb->ki_pos = pos; - g_pvfs2_stats.writes++; + g_orangefs_stats.writes++; out: @@ -490,14 +490,14 @@ out: /* * 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; __u64 val = 0; unsigned long uval; gossip_debug(GOSSIP_FILE_DEBUG, - "pvfs2_ioctl: called with cmd %d\n", + "orangefs_ioctl: called with cmd %d\n", cmd); /* @@ -506,17 +506,17 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) */ if (cmd == FS_IOC_GETFLAGS) { val = 0; - ret = pvfs2_inode_getxattr(file_inode(file), - PVFS2_XATTR_NAME_DEFAULT_PREFIX, - "user.pvfs2.meta_hint", - &val, sizeof(val)); + ret = orangefs_inode_getxattr(file_inode(file), + ORANGEFS_XATTR_NAME_DEFAULT_PREFIX, + "user.pvfs2.meta_hint", + &val, sizeof(val)); if (ret < 0 && ret != -ENODATA) return ret; else if (ret == -ENODATA) val = 0; uval = val; gossip_debug(GOSSIP_FILE_DEBUG, - "pvfs2_ioctl: FS_IOC_GETFLAGS: %llu\n", + "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n", (unsigned long long)uval); return put_user(uval, (int __user *)arg); } else if (cmd == FS_IOC_SETFLAGS) { @@ -524,25 +524,25 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) if (get_user(uval, (int __user *)arg)) 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 * on this bit, but the bit is present if the user first gets * the flags and then updates the flags with some new * 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))) { - 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; } val = uval; gossip_debug(GOSSIP_FILE_DEBUG, - "pvfs2_ioctl: FS_IOC_SETFLAGS: %llu\n", + "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n", (unsigned long long)val); - ret = pvfs2_inode_setxattr(file_inode(file), - PVFS2_XATTR_NAME_DEFAULT_PREFIX, - "user.pvfs2.meta_hint", - &val, sizeof(val), 0); + ret = orangefs_inode_setxattr(file_inode(file), + ORANGEFS_XATTR_NAME_DEFAULT_PREFIX, + "user.pvfs2.meta_hint", + &val, sizeof(val), 0); } return ret; @@ -551,10 +551,10 @@ static long pvfs2_ioctl(struct file *file, unsigned int cmd, unsigned long arg) /* * 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, - "pvfs2_file_mmap: called on %s\n", + "orangefs_file_mmap: called on %s\n", (file ? (char *)file->f_path.dentry->d_name.name : (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. */ -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, - "pvfs2_file_release: called on %s\n", + "orangefs_file_release: called on %s\n", 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 @@ -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. */ -static int pvfs2_fsync(struct file *file, +static int orangefs_fsync(struct file *file, loff_t start, loff_t end, int datasync) { int ret = -EINVAL; - struct pvfs2_inode_s *pvfs2_inode = - PVFS2_I(file->f_path.dentry->d_inode); - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_inode_s *orangefs_inode = + ORANGEFS_I(file->f_path.dentry->d_inode); + struct orangefs_kernel_op_s *new_op = NULL; /* required call */ 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) 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, - "pvfs2_fsync", + "orangefs_fsync", get_interruptible_flag(file->f_path.dentry->d_inode)); gossip_debug(GOSSIP_FILE_DEBUG, - "pvfs2_fsync got return value of %d\n", + "orangefs_fsync got return value of %d\n", ret); op_release(new_op); - pvfs2_flush_inode(file->f_path.dentry->d_inode); + orangefs_flush_inode(file->f_path.dentry->d_inode); return ret; } @@ -640,36 +640,36 @@ static int pvfs2_fsync(struct file *file, * Future upgrade could support SEEK_DATA and SEEK_HOLE but would * 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; struct inode *inode = file->f_path.dentry->d_inode; if (!inode) { - gossip_err("pvfs2_file_llseek: invalid inode (NULL)\n"); + gossip_err("orangefs_file_llseek: invalid inode (NULL)\n"); return ret; } - if (origin == PVFS2_SEEK_END) { + if (origin == ORANGEFS_SEEK_END) { /* * revalidate the inode's file size. * NOTE: We are only interested in file size here, * 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) { gossip_debug(GOSSIP_FILE_DEBUG, "%s:%s:%d calling make bad inode\n", __FILE__, __func__, __LINE__); - pvfs2_make_bad_inode(inode); + orangefs_make_bad_inode(inode); return ret; } } 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", (long)offset, 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) * 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; - 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) { rc = 0; posix_test_lock(filp, fl); @@ -698,15 +698,15 @@ static int pvfs2_lock(struct file *filp, int cmd, struct file_lock *fl) return rc; } -/** PVFS2 implementation of VFS file operations */ -const struct file_operations pvfs2_file_operations = { - .llseek = pvfs2_file_llseek, - .read_iter = pvfs2_file_read_iter, - .write_iter = pvfs2_file_write_iter, - .lock = pvfs2_lock, - .unlocked_ioctl = pvfs2_ioctl, - .mmap = pvfs2_file_mmap, +/** ORANGEFS implementation of VFS file operations */ +const struct file_operations orangefs_file_operations = { + .llseek = orangefs_file_llseek, + .read_iter = orangefs_file_read_iter, + .write_iter = orangefs_file_write_iter, + .lock = orangefs_lock, + .unlocked_ioctl = orangefs_ioctl, + .mmap = orangefs_file_mmap, .open = generic_file_open, - .release = pvfs2_file_release, - .fsync = pvfs2_fsync, + .release = orangefs_file_release, + .fsync = orangefs_fsync, }; diff --git a/fs/orangefs/inode.c b/fs/orangefs/inode.c index 70d1c1925ea3..58e83182d3dc 100644 --- a/fs/orangefs/inode.c +++ b/fs/orangefs/inode.c @@ -26,7 +26,7 @@ static int read_one_page(struct page *page) iov_iter_bvec(&to, ITER_BVEC | READ, &bv, 1, PAGE_SIZE); gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_readpage called with page %p\n", + "orangefs_readpage called with page %p\n", page); max_block = ((inode->i_size / blocksize) + 1); @@ -34,10 +34,10 @@ static int read_one_page(struct page *page) if (page->index < max_block) { loff_t blockptr_offset = (((loff_t) page->index) << blockbits); - bytes_read = pvfs2_inode_read(inode, - &to, - &blockptr_offset, - inode->i_size); + bytes_read = orangefs_inode_read(inode, + &to, + &blockptr_offset, + inode->i_size); } /* this will only zero remaining unread portions of the page data */ iov_iter_zero(~0U, &to); @@ -57,12 +57,12 @@ static int read_one_page(struct page *page) return ret; } -static int pvfs2_readpage(struct file *file, struct page *page) +static int orangefs_readpage(struct file *file, struct page *page) { return read_one_page(page); } -static int pvfs2_readpages(struct file *file, +static int orangefs_readpages(struct file *file, struct address_space *mapping, struct list_head *pages, unsigned nr_pages) @@ -70,7 +70,7 @@ static int pvfs2_readpages(struct file *file, int page_idx; int ret; - gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2_readpages called\n"); + gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_readpages called\n"); for (page_idx = 0; page_idx < nr_pages; page_idx++) { struct page *page; @@ -93,12 +93,12 @@ static int pvfs2_readpages(struct file *file, return 0; } -static void pvfs2_invalidatepage(struct page *page, +static void orangefs_invalidatepage(struct page *page, unsigned int offset, unsigned int length) { gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_invalidatepage called on page %p " + "orangefs_invalidatepage called on page %p " "(offset is %u)\n", page, offset); @@ -109,10 +109,10 @@ static void pvfs2_invalidatepage(struct page *page, } -static int pvfs2_releasepage(struct page *page, gfp_t foo) +static int orangefs_releasepage(struct page *page, gfp_t foo) { gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_releasepage called on page %p\n", + "orangefs_releasepage called on page %p\n", page); return 0; } @@ -131,32 +131,32 @@ static int pvfs2_releasepage(struct page *page, gfp_t foo) * loff_t offset) *{ * gossip_debug(GOSSIP_INODE_DEBUG, - * "pvfs2_direct_IO: %s\n", + * "orangefs_direct_IO: %s\n", * iocb->ki_filp->f_path.dentry->d_name.name); * * return -EINVAL; *} */ -struct backing_dev_info pvfs2_backing_dev_info = { - .name = "pvfs2", +struct backing_dev_info orangefs_backing_dev_info = { + .name = "orangefs", .ra_pages = 0, .capabilities = BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_WRITEBACK, }; -/** PVFS2 implementation of address space operations */ -const struct address_space_operations pvfs2_address_operations = { - .readpage = pvfs2_readpage, - .readpages = pvfs2_readpages, - .invalidatepage = pvfs2_invalidatepage, - .releasepage = pvfs2_releasepage, +/** ORANGEFS2 implementation of address space operations */ +const struct address_space_operations orangefs_address_operations = { + .readpage = orangefs_readpage, + .readpages = orangefs_readpages, + .invalidatepage = orangefs_invalidatepage, + .releasepage = orangefs_releasepage, /* .direct_IO = pvfs2_direct_IO */ }; -static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr) +static int orangefs_setattr_size(struct inode *inode, struct iattr *iattr) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op; loff_t orig_size = i_size_read(inode); int ret = -EINVAL; @@ -164,17 +164,17 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr) "%s: %pU: Handle is %pU | fs_id %d | size is %llu\n", __func__, get_khandle_from_ino(inode), - &pvfs2_inode->refn.khandle, - pvfs2_inode->refn.fs_id, + &orangefs_inode->refn.khandle, + orangefs_inode->refn.fs_id, iattr->ia_size); truncate_setsize(inode, iattr->ia_size); - new_op = op_alloc(PVFS2_VFS_OP_TRUNCATE); + new_op = op_alloc(ORANGEFS_VFS_OP_TRUNCATE); if (!new_op) return -ENOMEM; - new_op->upcall.req.truncate.refn = pvfs2_inode->refn; + new_op->upcall.req.truncate.refn = orangefs_inode->refn; new_op->upcall.req.truncate.size = (__s64) iattr->ia_size; ret = service_operation(new_op, __func__, @@ -185,7 +185,7 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr) * the status value tells us if it went through ok or not */ gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2: pvfs2_truncate got return value of %d\n", + "orangefs: orangefs_truncate got return value of %d\n", ret); op_release(new_op); @@ -216,13 +216,13 @@ static int pvfs2_setattr_size(struct inode *inode, struct iattr *iattr) /* * Change attributes of an object referenced by dentry. */ -int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr) +int orangefs_setattr(struct dentry *dentry, struct iattr *iattr) { int ret = -EINVAL; struct inode *inode = dentry->d_inode; gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_setattr: called on %s\n", + "orangefs_setattr: called on %s\n", dentry->d_name.name); ret = inode_change_ok(inode, iattr); @@ -231,7 +231,7 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr) if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size != i_size_read(inode)) { - ret = pvfs2_setattr_size(inode, iattr); + ret = orangefs_setattr_size(inode, iattr); if (ret) goto out; } @@ -239,9 +239,9 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr) setattr_copy(inode, iattr); mark_inode_dirty(inode); - ret = pvfs2_inode_setattr(inode, iattr); + ret = orangefs_inode_setattr(inode, iattr); gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_setattr: inode_setattr returned %d\n", + "orangefs_setattr: inode_setattr returned %d\n", ret); if (!ret && (iattr->ia_valid & ATTR_MODE)) @@ -249,23 +249,23 @@ int pvfs2_setattr(struct dentry *dentry, struct iattr *iattr) ret = posix_acl_chmod(inode, inode->i_mode); out: - gossip_debug(GOSSIP_INODE_DEBUG, "pvfs2_setattr: returning %d\n", ret); + gossip_debug(GOSSIP_INODE_DEBUG, "orangefs_setattr: returning %d\n", ret); return ret; } /* * Obtain attributes of an object given a dentry */ -int pvfs2_getattr(struct vfsmount *mnt, +int orangefs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *kstat) { int ret = -ENOENT; struct inode *inode = dentry->d_inode; - struct pvfs2_inode_s *pvfs2_inode = NULL; + struct orangefs_inode_s *orangefs_inode = NULL; gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_getattr: called on %s\n", + "orangefs_getattr: called on %s\n", dentry->d_name.name); /* @@ -273,12 +273,12 @@ int pvfs2_getattr(struct vfsmount *mnt, * fields/attributes of the inode would be refreshed. So again, we * dont have too much of a choice but refresh all the attributes. */ - ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT); + ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT); if (ret == 0) { generic_fillattr(inode, kstat); /* override block size reported to stat */ - pvfs2_inode = PVFS2_I(inode); - kstat->blksize = pvfs2_inode->blksize; + orangefs_inode = ORANGEFS_I(inode); + kstat->blksize = orangefs_inode->blksize; } else { /* assume an I/O error and flag inode as bad */ gossip_debug(GOSSIP_INODE_DEBUG, @@ -286,39 +286,39 @@ int pvfs2_getattr(struct vfsmount *mnt, __FILE__, __func__, __LINE__); - pvfs2_make_bad_inode(inode); + orangefs_make_bad_inode(inode); } return ret; } -/* PVFS2 implementation of VFS inode operations for files */ -struct inode_operations pvfs2_file_inode_operations = { - .get_acl = pvfs2_get_acl, - .set_acl = pvfs2_set_acl, - .setattr = pvfs2_setattr, - .getattr = pvfs2_getattr, +/* ORANGEDS2 implementation of VFS inode operations for files */ +struct inode_operations orangefs_file_inode_operations = { + .get_acl = orangefs_get_acl, + .set_acl = orangefs_set_acl, + .setattr = orangefs_setattr, + .getattr = orangefs_getattr, .setxattr = generic_setxattr, .getxattr = generic_getxattr, - .listxattr = pvfs2_listxattr, + .listxattr = orangefs_listxattr, .removexattr = generic_removexattr, }; -static int pvfs2_init_iops(struct inode *inode) +static int orangefs_init_iops(struct inode *inode) { - inode->i_mapping->a_ops = &pvfs2_address_operations; + inode->i_mapping->a_ops = &orangefs_address_operations; switch (inode->i_mode & S_IFMT) { case S_IFREG: - inode->i_op = &pvfs2_file_inode_operations; - inode->i_fop = &pvfs2_file_operations; + inode->i_op = &orangefs_file_inode_operations; + inode->i_fop = &orangefs_file_operations; inode->i_blkbits = PAGE_CACHE_SHIFT; break; case S_IFLNK: - inode->i_op = &pvfs2_symlink_inode_operations; + inode->i_op = &orangefs_symlink_inode_operations; break; case S_IFDIR: - inode->i_op = &pvfs2_dir_inode_operations; - inode->i_fop = &pvfs2_dir_operations; + inode->i_op = &orangefs_dir_inode_operations; + inode->i_fop = &orangefs_dir_operations; break; default: gossip_debug(GOSSIP_INODE_DEBUG, @@ -331,75 +331,75 @@ static int pvfs2_init_iops(struct inode *inode) } /* - * Given a PVFS2 object identifier (fsid, handle), convert it into a ino_t type + * Given a ORANGEFS object identifier (fsid, handle), convert it into a ino_t type * that will be used as a hash-index from where the handle will * be searched for in the VFS hash table of inodes. */ -static inline ino_t pvfs2_handle_hash(struct pvfs2_object_kref *ref) +static inline ino_t orangefs_handle_hash(struct orangefs_object_kref *ref) { if (!ref) return 0; - return pvfs2_khandle_to_ino(&(ref->khandle)); + return orangefs_khandle_to_ino(&(ref->khandle)); } /* * Called to set up an inode from iget5_locked. */ -static int pvfs2_set_inode(struct inode *inode, void *data) +static int orangefs_set_inode(struct inode *inode, void *data) { - struct pvfs2_object_kref *ref = (struct pvfs2_object_kref *) data; - struct pvfs2_inode_s *pvfs2_inode = NULL; + struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data; + struct orangefs_inode_s *orangefs_inode = NULL; /* Make sure that we have sane parameters */ if (!data || !inode) return 0; - pvfs2_inode = PVFS2_I(inode); - if (!pvfs2_inode) + orangefs_inode = ORANGEFS_I(inode); + if (!orangefs_inode) return 0; - pvfs2_inode->refn.fs_id = ref->fs_id; - pvfs2_inode->refn.khandle = ref->khandle; + orangefs_inode->refn.fs_id = ref->fs_id; + orangefs_inode->refn.khandle = ref->khandle; return 0; } /* * Called to determine if handles match. */ -static int pvfs2_test_inode(struct inode *inode, void *data) +static int orangefs_test_inode(struct inode *inode, void *data) { - struct pvfs2_object_kref *ref = (struct pvfs2_object_kref *) data; - struct pvfs2_inode_s *pvfs2_inode = NULL; + struct orangefs_object_kref *ref = (struct orangefs_object_kref *) data; + struct orangefs_inode_s *orangefs_inode = NULL; - pvfs2_inode = PVFS2_I(inode); - return (!PVFS_khandle_cmp(&(pvfs2_inode->refn.khandle), &(ref->khandle)) - && pvfs2_inode->refn.fs_id == ref->fs_id); + orangefs_inode = ORANGEFS_I(inode); + return (!ORANGEFS_khandle_cmp(&(orangefs_inode->refn.khandle), &(ref->khandle)) + && orangefs_inode->refn.fs_id == ref->fs_id); } /* - * Front-end to lookup the inode-cache maintained by the VFS using the PVFS2 + * Front-end to lookup the inode-cache maintained by the VFS using the ORANGEFS * file handle. * * @sb: the file system super block instance. - * @ref: The PVFS2 object for which we are trying to locate an inode structure. + * @ref: The ORANGEFS object for which we are trying to locate an inode structure. */ -struct inode *pvfs2_iget(struct super_block *sb, struct pvfs2_object_kref *ref) +struct inode *orangefs_iget(struct super_block *sb, struct orangefs_object_kref *ref) { struct inode *inode = NULL; unsigned long hash; int error; - hash = pvfs2_handle_hash(ref); - inode = iget5_locked(sb, hash, pvfs2_test_inode, pvfs2_set_inode, ref); + hash = orangefs_handle_hash(ref); + inode = iget5_locked(sb, hash, orangefs_test_inode, orangefs_set_inode, ref); if (!inode || !(inode->i_state & I_NEW)) return inode; - error = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT); + error = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT); if (error) { iget_failed(inode); return ERR_PTR(error); } inode->i_ino = hash; /* needed for stat etc */ - pvfs2_init_iops(inode); + orangefs_init_iops(inode); unlock_new_inode(inode); gossip_debug(GOSSIP_INODE_DEBUG, @@ -415,15 +415,15 @@ struct inode *pvfs2_iget(struct super_block *sb, struct pvfs2_object_kref *ref) /* * Allocate an inode for a newly created file and insert it into the inode hash. */ -struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir, - int mode, dev_t dev, struct pvfs2_object_kref *ref) +struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir, + int mode, dev_t dev, struct orangefs_object_kref *ref) { - unsigned long hash = pvfs2_handle_hash(ref); + unsigned long hash = orangefs_handle_hash(ref); struct inode *inode; int error; gossip_debug(GOSSIP_INODE_DEBUG, - "pvfs2_get_custom_inode_common: called\n" + "orangefs_get_custom_inode_common: called\n" "(sb is %p | MAJOR(dev)=%u | MINOR(dev)=%u mode=%o)\n", sb, MAJOR(dev), @@ -434,14 +434,14 @@ struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir, if (!inode) return NULL; - pvfs2_set_inode(inode, ref); + orangefs_set_inode(inode, ref); inode->i_ino = hash; /* needed for stat etc */ - error = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT); + error = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT); if (error) goto out_iput; - pvfs2_init_iops(inode); + orangefs_init_iops(inode); inode->i_mode = mode; inode->i_uid = current_fsuid(); @@ -450,14 +450,14 @@ struct inode *pvfs2_new_inode(struct super_block *sb, struct inode *dir, inode->i_size = PAGE_CACHE_SIZE; inode->i_rdev = dev; - error = insert_inode_locked4(inode, hash, pvfs2_test_inode, ref); + error = insert_inode_locked4(inode, hash, orangefs_test_inode, ref); if (error < 0) goto out_iput; gossip_debug(GOSSIP_INODE_DEBUG, "Initializing ACL's for inode %pU\n", get_khandle_from_ino(inode)); - pvfs2_init_acl(inode, dir); + orangefs_init_acl(inode, dir); return inode; out_iput: diff --git a/fs/orangefs/namei.c b/fs/orangefs/namei.c index 39f96ace0289..333c87c8b0f5 100644 --- a/fs/orangefs/namei.c +++ b/fs/orangefs/namei.c @@ -14,34 +14,34 @@ /* * 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, umode_t mode, bool exclusive) { - struct pvfs2_inode_s *parent = PVFS2_I(dir); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *parent = ORANGEFS_I(dir); + struct orangefs_kernel_op_s *new_op; struct inode *inode; int ret; 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) return -ENOMEM; new_op->upcall.req.create.parent_refn = parent->refn; 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, - dentry->d_name.name, PVFS2_NAME_LEN); + dentry->d_name.name, ORANGEFS_NAME_LEN); ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 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.fs_id, ret); @@ -52,10 +52,10 @@ static int pvfs2_create(struct inode *dir, 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); 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); goto out; } @@ -86,11 +86,11 @@ out: * Attempt to resolve an object name (dentry->d_name), parent handle, and * 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) { - struct pvfs2_inode_s *parent = PVFS2_I(dir); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *parent = ORANGEFS_I(dir); + struct orangefs_kernel_op_s *new_op; struct inode *inode; struct dentry *res; 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", __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); - new_op = op_alloc(PVFS2_VFS_OP_LOOKUP); + new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP); if (!new_op) 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; strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name, - PVFS2_NAME_LEN); + ORANGEFS_NAME_LEN); gossip_debug(GOSSIP_NAME_DEBUG, "%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.fs_id, ((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)); @@ -158,7 +158,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry, */ gossip_debug(GOSSIP_NAME_DEBUG, - "pvfs2_lookup: Adding *negative* dentry " + "orangefs_lookup: Adding *negative* dentry " "%p for %s\n", dentry, dentry->d_name.name); @@ -173,7 +173,7 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry, 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)) { gossip_debug(GOSSIP_NAME_DEBUG, "error %ld from iget\n", PTR_ERR(inode)); @@ -202,11 +202,11 @@ out: } /* 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 pvfs2_inode_s *parent = PVFS2_I(dir); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *parent = ORANGEFS_I(dir); + struct orangefs_kernel_op_s *new_op; int ret; gossip_debug(GOSSIP_NAME_DEBUG, @@ -218,15 +218,15 @@ static int pvfs2_unlink(struct inode *dir, struct dentry *dentry) &parent->refn.khandle, parent->refn.fs_id); - new_op = op_alloc(PVFS2_VFS_OP_REMOVE); + new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE); if (!new_op) return -ENOMEM; new_op->upcall.req.remove.parent_refn = parent->refn; 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)); /* 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; } -static int pvfs2_symlink(struct inode *dir, +static int orangefs_symlink(struct inode *dir, struct dentry *dentry, const char *symname) { - struct pvfs2_inode_s *parent = PVFS2_I(dir); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *parent = ORANGEFS_I(dir); + struct orangefs_kernel_op_s *new_op; struct inode *inode; int mode = 755; int ret; @@ -257,25 +257,25 @@ static int pvfs2_symlink(struct inode *dir, if (!symname) return -EINVAL; - new_op = op_alloc(PVFS2_VFS_OP_SYMLINK); + new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK); if (!new_op) return -ENOMEM; new_op->upcall.req.sym.parent_refn = parent->refn; fill_default_sys_attrs(new_op->upcall.req.sym.attributes, - PVFS_TYPE_SYMLINK, + ORANGEFS_TYPE_SYMLINK, mode); strncpy(new_op->upcall.req.sym.entry_name, dentry->d_name.name, - PVFS2_NAME_LEN); - strncpy(new_op->upcall.req.sym.target, symname, PVFS2_NAME_LEN); + ORANGEFS_NAME_LEN); + strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_LEN); ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 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.fs_id, ret); @@ -286,11 +286,11 @@ static int pvfs2_symlink(struct inode *dir, 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); if (IS_ERR(inode)) { gossip_err - ("*** Failed to allocate pvfs2 symlink inode\n"); + ("*** Failed to allocate orangefs symlink inode\n"); ret = PTR_ERR(inode); goto out; } @@ -316,29 +316,29 @@ out: 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 pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *parent = ORANGEFS_I(dir); + struct orangefs_kernel_op_s *new_op; struct inode *inode; int ret; - new_op = op_alloc(PVFS2_VFS_OP_MKDIR); + new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR); if (!new_op) return -ENOMEM; new_op->upcall.req.mkdir.parent_refn = parent->refn; 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, - dentry->d_name.name, PVFS2_NAME_LEN); + dentry->d_name.name, ORANGEFS_NAME_LEN); ret = service_operation(new_op, __func__, get_interruptible_flag(dir)); 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.fs_id); @@ -349,10 +349,10 @@ static int pvfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 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); 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); goto out; } @@ -381,42 +381,42 @@ out: return ret; } -static int pvfs2_rename(struct inode *old_dir, +static int orangefs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - struct pvfs2_kernel_op_s *new_op; + struct orangefs_kernel_op_s *new_op; int ret; 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_name.name, new_dentry->d_parent->d_name.name, new_dentry->d_name.name, d_count(new_dentry)); - new_op = op_alloc(PVFS2_VFS_OP_RENAME); + new_op = op_alloc(ORANGEFS_VFS_OP_RENAME); if (!new_op) return -EINVAL; - new_op->upcall.req.rename.old_parent_refn = PVFS2_I(old_dir)->refn; - new_op->upcall.req.rename.new_parent_refn = PVFS2_I(new_dir)->refn; + new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn; + new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn; strncpy(new_op->upcall.req.rename.d_old_name, old_dentry->d_name.name, - PVFS2_NAME_LEN); + ORANGEFS_NAME_LEN); strncpy(new_op->upcall.req.rename.d_new_name, new_dentry->d_name.name, - PVFS2_NAME_LEN); + ORANGEFS_NAME_LEN); ret = service_operation(new_op, - "pvfs2_rename", + "orangefs_rename", get_interruptible_flag(old_dentry->d_inode)); gossip_debug(GOSSIP_NAME_DEBUG, - "pvfs2_rename: got downcall status %d\n", + "orangefs_rename: got downcall status %d\n", ret); if (new_dentry->d_inode) @@ -426,21 +426,21 @@ static int pvfs2_rename(struct inode *old_dir, return ret; } -/* PVFS2 implementation of VFS inode operations for directories */ -struct inode_operations pvfs2_dir_inode_operations = { - .lookup = pvfs2_lookup, - .get_acl = pvfs2_get_acl, - .set_acl = pvfs2_set_acl, - .create = pvfs2_create, - .unlink = pvfs2_unlink, - .symlink = pvfs2_symlink, - .mkdir = pvfs2_mkdir, - .rmdir = pvfs2_unlink, - .rename = pvfs2_rename, - .setattr = pvfs2_setattr, - .getattr = pvfs2_getattr, +/* ORANGEFS implementation of VFS inode operations for directories */ +struct inode_operations orangefs_dir_inode_operations = { + .lookup = orangefs_lookup, + .get_acl = orangefs_get_acl, + .set_acl = orangefs_set_acl, + .create = orangefs_create, + .unlink = orangefs_unlink, + .symlink = orangefs_symlink, + .mkdir = orangefs_mkdir, + .rmdir = orangefs_unlink, + .rename = orangefs_rename, + .setattr = orangefs_setattr, + .getattr = orangefs_getattr, .setxattr = generic_setxattr, .getxattr = generic_getxattr, .removexattr = generic_removexattr, - .listxattr = pvfs2_listxattr, + .listxattr = orangefs_listxattr, }; diff --git a/fs/orangefs/protocol.h b/fs/orangefs/protocol.h index 85f611fe0536..5f10ebc83e76 100644 --- a/fs/orangefs/protocol.h +++ b/fs/orangefs/protocol.h @@ -20,13 +20,13 @@ extern int cdm_element_count; #define ORANGEFS_KMOD_DEBUG_HELP_FILE "debug-help" #define ORANGEFS_KMOD_DEBUG_FILE "kernel-debug" #define ORANGEFS_CLIENT_DEBUG_FILE "client-debug" -#define PVFS2_VERBOSE "verbose" -#define PVFS2_ALL "all" +#define ORANGEFS_VERBOSE "verbose" +#define ORANGEFS_ALL "all" /* pvfs2-config.h ***********************************************************/ -#define PVFS2_VERSION_MAJOR 2 -#define PVFS2_VERSION_MINOR 9 -#define PVFS2_VERSION_SUB 0 +#define ORANGEFS_VERSION_MAJOR 2 +#define ORANGEFS_VERSION_MINOR 9 +#define ORANGEFS_VERSION_SUB 0 /* khandle stuff ***********************************************************/ @@ -38,15 +38,15 @@ extern int cdm_element_count; * The kernel module will always use the first four bytes and * the last four bytes as an inum. */ -struct pvfs2_khandle { +struct orangefs_khandle { unsigned char u[16]; } __aligned(8); /* * kernel version of an object ref. */ -struct pvfs2_object_kref { - struct pvfs2_khandle khandle; +struct orangefs_object_kref { + struct orangefs_khandle khandle; __s32 fs_id; __s32 __pad1; }; @@ -55,8 +55,8 @@ struct pvfs2_object_kref { * compare 2 khandles assumes little endian thus from large address to * small address */ -static inline int PVFS_khandle_cmp(const struct pvfs2_khandle *kh1, - const struct pvfs2_khandle *kh2) +static inline int ORANGEFS_khandle_cmp(const struct orangefs_khandle *kh1, + const struct orangefs_khandle *kh2) { int i; @@ -70,7 +70,7 @@ static inline int PVFS_khandle_cmp(const struct pvfs2_khandle *kh1, 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) { @@ -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) { memset(kh, 0, 16); @@ -88,152 +88,152 @@ static inline void PVFS_khandle_from(struct pvfs2_khandle *kh, } /* pvfs2-types.h ************************************************************/ -typedef __u32 PVFS_uid; -typedef __u32 PVFS_gid; -typedef __s32 PVFS_fs_id; -typedef __u32 PVFS_permissions; -typedef __u64 PVFS_time; -typedef __s64 PVFS_size; -typedef __u64 PVFS_flags; -typedef __u64 PVFS_ds_position; -typedef __s32 PVFS_error; -typedef __s64 PVFS_offset; +typedef __u32 ORANGEFS_uid; +typedef __u32 ORANGEFS_gid; +typedef __s32 ORANGEFS_fs_id; +typedef __u32 ORANGEFS_permissions; +typedef __u64 ORANGEFS_time; +typedef __s64 ORANGEFS_size; +typedef __u64 ORANGEFS_flags; +typedef __u64 ORANGEFS_ds_position; +typedef __s32 ORANGEFS_error; +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. */ /* 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 - * encoded errno value or a PVFS2 protocol error. + * Bit 30 specifies that this is a ORANGEFS error. A ORANGEFS error is either an + * 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. */ -#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 * server code the error originated in for logging purposes. It is not used * 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. */ -#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. */ -/* Our own PVFS2 protocol error codes. */ -#define PVFS_ECANCEL (1|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_EDEVINIT (2|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_EDETAIL (3|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_EHOSTNTFD (4|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_EADDRNTFD (5|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_ENORECVR (6|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_ETRYAGAIN (7|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_ENOTPVFS (8|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) -#define PVFS_ESECURITY (9|PVFS_NON_ERRNO_ERROR_BIT|PVFS_ERROR_BIT) +/* Our own ORANGEFS protocol error codes. */ +#define ORANGEFS_ECANCEL (1|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_EDEVINIT (2|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_EDETAIL (3|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_EHOSTNTFD (4|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_EADDRNTFD (5|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_ENORECVR (6|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_ETRYAGAIN (7|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_ENOTPVFS (8|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) +#define ORANGEFS_ESECURITY (9|ORANGEFS_NON_ERRNO_ERROR_BIT|ORANGEFS_ERROR_BIT) /* permission bits */ -#define PVFS_O_EXECUTE (1 << 0) -#define PVFS_O_WRITE (1 << 1) -#define PVFS_O_READ (1 << 2) -#define PVFS_G_EXECUTE (1 << 3) -#define PVFS_G_WRITE (1 << 4) -#define PVFS_G_READ (1 << 5) -#define PVFS_U_EXECUTE (1 << 6) -#define PVFS_U_WRITE (1 << 7) -#define PVFS_U_READ (1 << 8) -/* no PVFS_U_VTX (sticky bit) */ -#define PVFS_G_SGID (1 << 10) -#define PVFS_U_SUID (1 << 11) +#define ORANGEFS_O_EXECUTE (1 << 0) +#define ORANGEFS_O_WRITE (1 << 1) +#define ORANGEFS_O_READ (1 << 2) +#define ORANGEFS_G_EXECUTE (1 << 3) +#define ORANGEFS_G_WRITE (1 << 4) +#define ORANGEFS_G_READ (1 << 5) +#define ORANGEFS_U_EXECUTE (1 << 6) +#define ORANGEFS_U_WRITE (1 << 7) +#define ORANGEFS_U_READ (1 << 8) +/* no ORANGEFS_U_VTX (sticky bit) */ +#define ORANGEFS_G_SGID (1 << 10) +#define ORANGEFS_U_SUID (1 << 11) /* definition taken from stdint.h */ #define INT32_MAX (2147483647) -#define PVFS_ITERATE_START (INT32_MAX - 1) -#define PVFS_ITERATE_END (INT32_MAX - 2) -#define PVFS_ITERATE_NEXT (INT32_MAX - 3) -#define PVFS_READDIR_START PVFS_ITERATE_START -#define PVFS_READDIR_END PVFS_ITERATE_END -#define PVFS_IMMUTABLE_FL FS_IMMUTABLE_FL -#define PVFS_APPEND_FL FS_APPEND_FL -#define PVFS_NOATIME_FL FS_NOATIME_FL -#define PVFS_MIRROR_FL 0x01000000ULL -#define PVFS_O_EXECUTE (1 << 0) -#define PVFS_FS_ID_NULL ((__s32)0) -#define PVFS_ATTR_SYS_UID (1 << 0) -#define PVFS_ATTR_SYS_GID (1 << 1) -#define PVFS_ATTR_SYS_PERM (1 << 2) -#define PVFS_ATTR_SYS_ATIME (1 << 3) -#define PVFS_ATTR_SYS_CTIME (1 << 4) -#define PVFS_ATTR_SYS_MTIME (1 << 5) -#define PVFS_ATTR_SYS_TYPE (1 << 6) -#define PVFS_ATTR_SYS_ATIME_SET (1 << 7) -#define PVFS_ATTR_SYS_MTIME_SET (1 << 8) -#define PVFS_ATTR_SYS_SIZE (1 << 20) -#define PVFS_ATTR_SYS_LNK_TARGET (1 << 24) -#define PVFS_ATTR_SYS_DFILE_COUNT (1 << 25) -#define PVFS_ATTR_SYS_DIRENT_COUNT (1 << 26) -#define PVFS_ATTR_SYS_BLKSIZE (1 << 28) -#define PVFS_ATTR_SYS_MIRROR_COPIES_COUNT (1 << 29) -#define PVFS_ATTR_SYS_COMMON_ALL \ - (PVFS_ATTR_SYS_UID | \ - PVFS_ATTR_SYS_GID | \ - PVFS_ATTR_SYS_PERM | \ - PVFS_ATTR_SYS_ATIME | \ - PVFS_ATTR_SYS_CTIME | \ - PVFS_ATTR_SYS_MTIME | \ - PVFS_ATTR_SYS_TYPE) +#define ORANGEFS_ITERATE_START (INT32_MAX - 1) +#define ORANGEFS_ITERATE_END (INT32_MAX - 2) +#define ORANGEFS_ITERATE_NEXT (INT32_MAX - 3) +#define ORANGEFS_READDIR_START ORANGEFS_ITERATE_START +#define ORANGEFS_READDIR_END ORANGEFS_ITERATE_END +#define ORANGEFS_IMMUTABLE_FL FS_IMMUTABLE_FL +#define ORANGEFS_APPEND_FL FS_APPEND_FL +#define ORANGEFS_NOATIME_FL FS_NOATIME_FL +#define ORANGEFS_MIRROR_FL 0x01000000ULL +#define ORANGEFS_O_EXECUTE (1 << 0) +#define ORANGEFS_FS_ID_NULL ((__s32)0) +#define ORANGEFS_ATTR_SYS_UID (1 << 0) +#define ORANGEFS_ATTR_SYS_GID (1 << 1) +#define ORANGEFS_ATTR_SYS_PERM (1 << 2) +#define ORANGEFS_ATTR_SYS_ATIME (1 << 3) +#define ORANGEFS_ATTR_SYS_CTIME (1 << 4) +#define ORANGEFS_ATTR_SYS_MTIME (1 << 5) +#define ORANGEFS_ATTR_SYS_TYPE (1 << 6) +#define ORANGEFS_ATTR_SYS_ATIME_SET (1 << 7) +#define ORANGEFS_ATTR_SYS_MTIME_SET (1 << 8) +#define ORANGEFS_ATTR_SYS_SIZE (1 << 20) +#define ORANGEFS_ATTR_SYS_LNK_TARGET (1 << 24) +#define ORANGEFS_ATTR_SYS_DFILE_COUNT (1 << 25) +#define ORANGEFS_ATTR_SYS_DIRENT_COUNT (1 << 26) +#define ORANGEFS_ATTR_SYS_BLKSIZE (1 << 28) +#define ORANGEFS_ATTR_SYS_MIRROR_COPIES_COUNT (1 << 29) +#define ORANGEFS_ATTR_SYS_COMMON_ALL \ + (ORANGEFS_ATTR_SYS_UID | \ + ORANGEFS_ATTR_SYS_GID | \ + ORANGEFS_ATTR_SYS_PERM | \ + ORANGEFS_ATTR_SYS_ATIME | \ + ORANGEFS_ATTR_SYS_CTIME | \ + ORANGEFS_ATTR_SYS_MTIME | \ + ORANGEFS_ATTR_SYS_TYPE) -#define PVFS_ATTR_SYS_ALL_SETABLE \ -(PVFS_ATTR_SYS_COMMON_ALL-PVFS_ATTR_SYS_TYPE) +#define ORANGEFS_ATTR_SYS_ALL_SETABLE \ +(ORANGEFS_ATTR_SYS_COMMON_ALL-ORANGEFS_ATTR_SYS_TYPE) -#define PVFS_ATTR_SYS_ALL_NOHINT \ - (PVFS_ATTR_SYS_COMMON_ALL | \ - PVFS_ATTR_SYS_SIZE | \ - PVFS_ATTR_SYS_LNK_TARGET | \ - PVFS_ATTR_SYS_DFILE_COUNT | \ - PVFS_ATTR_SYS_MIRROR_COPIES_COUNT | \ - PVFS_ATTR_SYS_DIRENT_COUNT | \ - PVFS_ATTR_SYS_BLKSIZE) -#define PVFS_XATTR_REPLACE 0x2 -#define PVFS_XATTR_CREATE 0x1 -#define PVFS_MAX_SERVER_ADDR_LEN 256 -#define PVFS_NAME_MAX 256 +#define ORANGEFS_ATTR_SYS_ALL_NOHINT \ + (ORANGEFS_ATTR_SYS_COMMON_ALL | \ + ORANGEFS_ATTR_SYS_SIZE | \ + ORANGEFS_ATTR_SYS_LNK_TARGET | \ + ORANGEFS_ATTR_SYS_DFILE_COUNT | \ + ORANGEFS_ATTR_SYS_MIRROR_COPIES_COUNT | \ + ORANGEFS_ATTR_SYS_DIRENT_COUNT | \ + ORANGEFS_ATTR_SYS_BLKSIZE) +#define ORANGEFS_XATTR_REPLACE 0x2 +#define ORANGEFS_XATTR_CREATE 0x1 +#define ORANGEFS_MAX_SERVER_ADDR_LEN 256 +#define ORANGEFS_NAME_MAX 256 /* * max extended attribute name len as imposed by the VFS and exploited for the * upcall request types. * 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 * 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. */ -#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 * by */ -#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 */ -#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 */ /* - * 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 { - PVFS_IO_READ = 1, - PVFS_IO_WRITE = 2 +enum ORANGEFS_io_type { + ORANGEFS_IO_READ = 1, + 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 * change. */ -enum pvfs2_ds_type { - PVFS_TYPE_NONE = 0, - PVFS_TYPE_METAFILE = (1 << 0), - PVFS_TYPE_DATAFILE = (1 << 1), - PVFS_TYPE_DIRECTORY = (1 << 2), - PVFS_TYPE_SYMLINK = (1 << 3), - PVFS_TYPE_DIRDATA = (1 << 4), - PVFS_TYPE_INTERNAL = (1 << 5) /* for the server's private use */ +enum orangefs_ds_type { + ORANGEFS_TYPE_NONE = 0, + ORANGEFS_TYPE_METAFILE = (1 << 0), + ORANGEFS_TYPE_DATAFILE = (1 << 1), + ORANGEFS_TYPE_DIRECTORY = (1 << 2), + ORANGEFS_TYPE_SYMLINK = (1 << 3), + ORANGEFS_TYPE_DIRDATA = (1 << 4), + 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. */ -struct PVFS_certificate { +struct ORANGEFS_certificate { __u32 buf_size; unsigned char *buf; }; @@ -264,7 +264,7 @@ struct PVFS_certificate { * A credential identifies a user and is signed by the client/user * private key. */ -struct PVFS_credential { +struct ORANGEFS_credential { __u32 userid; /* user id */ __u32 num_groups; /* length of group_array */ __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 */ __u32 sig_size; /* length of the signature in bytes */ 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) + \ - PVFS_REQ_LIMIT_ISSUER + \ - PVFS_REQ_LIMIT_SIGNATURE + \ - extra_size_PVFS_certificate) + ORANGEFS_REQ_LIMIT_ISSUER + \ + ORANGEFS_REQ_LIMIT_SIGNATURE + \ + extra_size_ORANGEFS_certificate) /* This structure is used by the VFS-client interaction alone */ -struct PVFS_keyval_pair { - char key[PVFS_MAX_XATTR_NAMELEN]; +struct ORANGEFS_keyval_pair { + char key[ORANGEFS_MAX_XATTR_NAMELEN]; __s32 key_sz; /* __s32 for portable, fixed-size structures */ __s32 val_sz; - char val[PVFS_MAX_XATTR_VALUELEN]; + char val[ORANGEFS_MAX_XATTR_VALUELEN]; }; /* pvfs2-sysint.h ***********************************************************/ /* Describes attributes for a file, directory, or symlink. */ -struct PVFS_sys_attr_s { +struct ORANGEFS_sys_attr_s { __u32 owner; __u32 group; __u32 perms; @@ -323,18 +323,18 @@ struct PVFS_sys_attr_s { char *dist_params; __s64 dirent_count; - enum pvfs2_ds_type objtype; + enum orangefs_ds_type objtype; __u64 flags; __u32 mask; __s64 blksize; }; -#define PVFS2_LOOKUP_LINK_NO_FOLLOW 0 -#define PVFS2_LOOKUP_LINK_FOLLOW 1 +#define ORANGEFS_LOOKUP_LINK_NO_FOLLOW 0 +#define ORANGEFS_LOOKUP_LINK_FOLLOW 1 /* 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 { enum { KERNEL_MASK, @@ -349,7 +349,7 @@ struct dev_mask2_info_s { }; /* pvfs2-util.h *************************************************************/ -__s32 PVFS_util_translate_mode(int mode); +__s32 ORANGEFS_util_translate_mode(int mode); /* pvfs2-debug.h ************************************************************/ #include "pvfs2-debug.h" @@ -359,9 +359,9 @@ __s32 PVFS_util_translate_mode(int mode); #define lld(x) (long long)(x) /* 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_MAX_UPSIZE 0x2 @@ -376,39 +376,39 @@ __s32 PVFS_util_translate_mode(int mode); /* supported ioctls, codes are with respect to user-space */ enum { - PVFS_DEV_GET_MAGIC = _IOW(PVFS_DEV_MAGIC, DEV_GET_MAGIC, __s32), - PVFS_DEV_GET_MAX_UPSIZE = - _IOW(PVFS_DEV_MAGIC, DEV_GET_MAX_UPSIZE, __s32), - PVFS_DEV_GET_MAX_DOWNSIZE = - _IOW(PVFS_DEV_MAGIC, DEV_GET_MAX_DOWNSIZE, __s32), - PVFS_DEV_MAP = _IO(PVFS_DEV_MAGIC, DEV_MAP), - PVFS_DEV_REMOUNT_ALL = _IO(PVFS_DEV_MAGIC, DEV_REMOUNT_ALL), - PVFS_DEV_DEBUG = _IOR(PVFS_DEV_MAGIC, DEV_DEBUG, __s32), - PVFS_DEV_UPSTREAM = _IOW(PVFS_DEV_MAGIC, DEV_UPSTREAM, int), - PVFS_DEV_CLIENT_MASK = _IOW(PVFS_DEV_MAGIC, + ORANGEFS_DEV_GET_MAGIC = _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAGIC, __s32), + ORANGEFS_DEV_GET_MAX_UPSIZE = + _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAX_UPSIZE, __s32), + ORANGEFS_DEV_GET_MAX_DOWNSIZE = + _IOW(ORANGEFS_DEV_MAGIC, DEV_GET_MAX_DOWNSIZE, __s32), + ORANGEFS_DEV_MAP = _IO(ORANGEFS_DEV_MAGIC, DEV_MAP), + ORANGEFS_DEV_REMOUNT_ALL = _IO(ORANGEFS_DEV_MAGIC, DEV_REMOUNT_ALL), + ORANGEFS_DEV_DEBUG = _IOR(ORANGEFS_DEV_MAGIC, DEV_DEBUG, __s32), + ORANGEFS_DEV_UPSTREAM = _IOW(ORANGEFS_DEV_MAGIC, DEV_UPSTREAM, int), + ORANGEFS_DEV_CLIENT_MASK = _IOW(ORANGEFS_DEV_MAGIC, DEV_CLIENT_MASK, struct dev_mask2_info_s), - PVFS_DEV_CLIENT_STRING = _IOW(PVFS_DEV_MAGIC, + ORANGEFS_DEV_CLIENT_STRING = _IOW(ORANGEFS_DEV_MAGIC, DEV_CLIENT_STRING, char *), - PVFS_DEV_MAXNR = DEV_MAX_NR, + ORANGEFS_DEV_MAXNR = DEV_MAX_NR, }; /* * version number for use in communicating between kernel space and user * 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. * 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 such systems before servicing ioctl calls from user-space binaries * that may be 32 bit! */ -struct PVFS_dev_map_desc { +struct ORANGEFS_dev_map_desc { void *ptr; __s32 total_size; __s32 size; diff --git a/fs/orangefs/pvfs2-bufmap.c b/fs/orangefs/pvfs2-bufmap.c index c7b0f3560734..345287e871b1 100644 --- a/fs/orangefs/pvfs2-bufmap.c +++ b/fs/orangefs/pvfs2-bufmap.c @@ -7,9 +7,9 @@ #include "pvfs2-kernel.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; int desc_size; @@ -19,21 +19,21 @@ static struct pvfs2_bufmap { int page_count; struct page **page_array; - struct pvfs_bufmap_desc *desc_array; + struct orangefs_bufmap_desc *desc_array; /* array to track usage of buffer descriptors */ int *buffer_index_array; spinlock_t buffer_index_lock; /* 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; -} *__pvfs2_bufmap; +} *__orangefs_bufmap; -static DEFINE_SPINLOCK(pvfs2_bufmap_lock); +static DEFINE_SPINLOCK(orangefs_bufmap_lock); static void -pvfs2_bufmap_unmap(struct pvfs2_bufmap *bufmap) +orangefs_bufmap_unmap(struct orangefs_bufmap *bufmap) { int i; @@ -42,7 +42,7 @@ pvfs2_bufmap_unmap(struct pvfs2_bufmap *bufmap) } static void -pvfs2_bufmap_free(struct pvfs2_bufmap *bufmap) +orangefs_bufmap_free(struct orangefs_bufmap *bufmap) { kfree(bufmap->page_array); kfree(bufmap->desc_array); @@ -50,45 +50,45 @@ pvfs2_bufmap_free(struct pvfs2_bufmap *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); - if (__pvfs2_bufmap) { - bufmap = __pvfs2_bufmap; + spin_lock(&orangefs_bufmap_lock); + if (__orangefs_bufmap) { + bufmap = __orangefs_bufmap; atomic_inc(&bufmap->refcnt); } - spin_unlock(&pvfs2_bufmap_lock); + spin_unlock(&orangefs_bufmap_lock); 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)) { - __pvfs2_bufmap = NULL; - spin_unlock(&pvfs2_bufmap_lock); + if (atomic_dec_and_lock(&bufmap->refcnt, &orangefs_bufmap_lock)) { + __orangefs_bufmap = NULL; + spin_unlock(&orangefs_bufmap_lock); - pvfs2_bufmap_unmap(bufmap); - pvfs2_bufmap_free(bufmap); + orangefs_bufmap_unmap(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; - pvfs2_bufmap_unref(bufmap); + orangefs_bufmap_unref(bufmap); 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; - pvfs2_bufmap_unref(bufmap); + orangefs_bufmap_unref(bufmap); return shift; } @@ -105,14 +105,14 @@ static DECLARE_WAIT_QUEUE_HEAD(readdir_waitq); */ int get_bufmap_init(void) { - return __pvfs2_bufmap ? 1 : 0; + return __orangefs_bufmap ? 1 : 0; } -static struct pvfs2_bufmap * -pvfs2_bufmap_alloc(struct PVFS_dev_map_desc *user_desc) +static struct orangefs_bufmap * +orangefs_bufmap_alloc(struct ORANGEFS_dev_map_desc *user_desc) { - struct pvfs2_bufmap *bufmap; + struct orangefs_bufmap *bufmap; bufmap = kzalloc(sizeof(*bufmap), GFP_KERNEL); if (!bufmap) @@ -128,17 +128,17 @@ pvfs2_bufmap_alloc(struct PVFS_dev_map_desc *user_desc) bufmap->buffer_index_array = kcalloc(bufmap->desc_count, sizeof(int), GFP_KERNEL); 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); goto out_free_bufmap; } spin_lock_init(&bufmap->readdir_index_lock); bufmap->desc_array = - kcalloc(bufmap->desc_count, sizeof(struct pvfs_bufmap_desc), + kcalloc(bufmap->desc_count, sizeof(struct orangefs_bufmap_desc), GFP_KERNEL); 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); goto out_free_index_array; } @@ -164,8 +164,8 @@ out: } static int -pvfs2_bufmap_map(struct pvfs2_bufmap *bufmap, - struct PVFS_dev_map_desc *user_desc) +orangefs_bufmap_map(struct orangefs_bufmap *bufmap, + struct ORANGEFS_dev_map_desc *user_desc) { int pages_per_desc = bufmap->desc_size / PAGE_SIZE; int offset = 0, ret, i; @@ -178,7 +178,7 @@ pvfs2_bufmap_map(struct pvfs2_bufmap *bufmap, return ret; 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); 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 * * 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; gossip_debug(GOSSIP_BUFMAP_DEBUG, - "pvfs_bufmap_initialize: called (ptr (" + "orangefs_bufmap_initialize: called (ptr (" "%p) sz (%d) cnt(%d).\n", user_desc->ptr, 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) != (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); goto out; } if (PAGE_ALIGN(((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->total_size); goto out; } 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->size, 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) { - 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); goto out; } ret = -ENOMEM; - bufmap = pvfs2_bufmap_alloc(user_desc); + bufmap = orangefs_bufmap_alloc(user_desc); if (!bufmap) goto out; - ret = pvfs2_bufmap_map(bufmap, user_desc); + ret = orangefs_bufmap_map(bufmap, user_desc); if (ret) goto out_free_bufmap; - spin_lock(&pvfs2_bufmap_lock); - if (__pvfs2_bufmap) { - spin_unlock(&pvfs2_bufmap_lock); - gossip_err("pvfs2: error: bufmap already initialized.\n"); + spin_lock(&orangefs_bufmap_lock); + if (__orangefs_bufmap) { + spin_unlock(&orangefs_bufmap_lock); + gossip_err("orangefs: error: bufmap already initialized.\n"); ret = -EALREADY; goto out_unmap_bufmap; } - __pvfs2_bufmap = bufmap; - spin_unlock(&pvfs2_bufmap_lock); + __orangefs_bufmap = bufmap; + 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 * requests in the in-progress or waiting tables are restarted. I/O * 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 * 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, - "pvfs_bufmap_initialize: exiting normally\n"); + "orangefs_bufmap_initialize: exiting normally\n"); return 0; out_unmap_bufmap: - pvfs2_bufmap_unmap(bufmap); + orangefs_bufmap_unmap(bufmap); out_free_bufmap: - pvfs2_bufmap_free(bufmap); + orangefs_bufmap_free(bufmap); out: return ret; } /* - * pvfs_bufmap_finalize() + * orangefs_bufmap_finalize() * * shuts down the mapped buffer interface and releases any resources * associated with it * * no return value */ -void pvfs_bufmap_finalize(void) +void orangefs_bufmap_finalize(void) { - gossip_debug(GOSSIP_BUFMAP_DEBUG, "pvfs2_bufmap_finalize: called\n"); - BUG_ON(!__pvfs2_bufmap); - pvfs2_bufmap_unref(__pvfs2_bufmap); + gossip_debug(GOSSIP_BUFMAP_DEBUG, "orangefs_bufmap_finalize: called\n"); + BUG_ON(!__orangefs_bufmap); + orangefs_bufmap_unref(__orangefs_bufmap); gossip_debug(GOSSIP_BUFMAP_DEBUG, - "pvfs2_bufmap_finalize: exiting normally\n"); + "orangefs_bufmap_finalize: exiting normally\n"); } struct slot_args { @@ -377,7 +377,7 @@ static int wait_for_a_slot(struct slot_args *slargs, int *buffer_index) continue; } - gossip_debug(GOSSIP_BUFMAP_DEBUG, "pvfs2: %s interrupted.\n", + gossip_debug(GOSSIP_BUFMAP_DEBUG, "orangefs: %s interrupted.\n", __func__); ret = -EINTR; 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 * available if necessary * * 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; int ret; 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; } @@ -430,19 +430,19 @@ int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index) slargs.slot_wq = &bufmap_waitq; ret = wait_for_a_slot(&slargs, buffer_index); if (ret) - pvfs2_bufmap_unref(bufmap); + orangefs_bufmap_unref(bufmap); *mapp = bufmap; return ret; } /* - * pvfs_bufmap_put() + * orangefs_bufmap_put() * * returns a mapped buffer descriptor to the collection * * 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; @@ -451,7 +451,7 @@ void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index) slargs.slot_lock = &bufmap->buffer_index_lock; slargs.slot_wq = &bufmap_waitq; 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 */ -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; int ret; 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; } - 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_lock = &bufmap->readdir_index_lock; slargs.slot_wq = &readdir_waitq; ret = wait_for_a_slot(&slargs, buffer_index); if (ret) - pvfs2_bufmap_unref(bufmap); + orangefs_bufmap_unref(bufmap); *mapp = bufmap; 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; - 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_lock = &bufmap->readdir_index_lock; slargs.slot_wq = &readdir_waitq; 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, int buffer_index, 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; gossip_debug(GOSSIP_BUFMAP_DEBUG, @@ -531,12 +531,12 @@ int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap, * 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, int buffer_index, 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; gossip_debug(GOSSIP_BUFMAP_DEBUG, diff --git a/fs/orangefs/pvfs2-bufmap.h b/fs/orangefs/pvfs2-bufmap.h index d1aedb52a877..91d1755c231a 100644 --- a/fs/orangefs/pvfs2-bufmap.h +++ b/fs/orangefs/pvfs2-bufmap.h @@ -4,59 +4,59 @@ * See COPYING in top-level directory. */ -#ifndef __PVFS2_BUFMAP_H -#define __PVFS2_BUFMAP_H +#ifndef __ORANGEFS_BUFMAP_H +#define __ORANGEFS_BUFMAP_H /* used to describe mapped buffers */ -struct pvfs_bufmap_desc { +struct orangefs_bufmap_desc { void *uaddr; /* user space address pointer */ struct page **page_array; /* array of mapped pages */ int array_count; /* size of above arrays */ struct list_head list_link; }; -struct pvfs2_bufmap; +struct orangefs_bufmap; -struct pvfs2_bufmap *pvfs2_bufmap_ref(void); -void pvfs2_bufmap_unref(struct pvfs2_bufmap *bufmap); +struct orangefs_bufmap *orangefs_bufmap_ref(void); +void orangefs_bufmap_unref(struct orangefs_bufmap *bufmap); /* - * pvfs_bufmap_size_query is now an inline function because buffer + * orangefs_bufmap_size_query is now an inline function because buffer * sizes are not hardcoded */ -int pvfs_bufmap_size_query(void); +int orangefs_bufmap_size_query(void); -int pvfs_bufmap_shift_query(void); +int orangefs_bufmap_shift_query(void); -int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc); +int orangefs_bufmap_initialize(struct ORANGEFS_dev_map_desc *user_desc); int get_bufmap_init(void); -void pvfs_bufmap_finalize(void); +void orangefs_bufmap_finalize(void); -int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index); +int orangefs_bufmap_get(struct orangefs_bufmap **mapp, int *buffer_index); -void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index); +void orangefs_bufmap_put(struct orangefs_bufmap *bufmap, int buffer_index); -int readdir_index_get(struct pvfs2_bufmap **mapp, int *buffer_index); +int readdir_index_get(struct orangefs_bufmap **mapp, int *buffer_index); -void readdir_index_put(struct pvfs2_bufmap *bufmap, int buffer_index); +void readdir_index_put(struct orangefs_bufmap *bufmap, int buffer_index); -int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap, +int orangefs_bufmap_copy_from_iovec(struct orangefs_bufmap *bufmap, struct iov_iter *iter, int buffer_index, size_t size); -int pvfs_bufmap_copy_to_iovec(struct pvfs2_bufmap *bufmap, +int orangefs_bufmap_copy_to_iovec(struct orangefs_bufmap *bufmap, struct iov_iter *iter, int buffer_index, size_t size); -size_t pvfs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk, +size_t orangefs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk, struct iovec *iovec, unsigned long nr_segs, - struct pvfs2_bufmap *bufmap, + struct orangefs_bufmap *bufmap, int buffer_index, size_t bytes_to_be_copied); -#endif /* __PVFS2_BUFMAP_H */ +#endif /* __ORANGEFS_BUFMAP_H */ diff --git a/fs/orangefs/pvfs2-cache.c b/fs/orangefs/pvfs2-cache.c index f982616a4349..a224831770f4 100644 --- a/fs/orangefs/pvfs2-cache.c +++ b/fs/orangefs/pvfs2-cache.c @@ -11,27 +11,27 @@ static __u64 next_tag_value; static DEFINE_SPINLOCK(next_tag_value_lock); -/* the pvfs2 memory caches */ +/* the orangefs memory caches */ -/* a cache for pvfs2 upcall/downcall operations */ +/* a cache for orangefs upcall/downcall operations */ static struct kmem_cache *op_cache; /* a cache for device (/dev/pvfs2-req) communication */ static struct kmem_cache *dev_req_cache; -/* a cache for pvfs2_kiocb objects (i.e pvfs2 iocb structures ) */ -static struct kmem_cache *pvfs2_kiocb_cache; +/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */ +static struct kmem_cache *orangefs_kiocb_cache; int op_cache_initialize(void) { - op_cache = kmem_cache_create("pvfs2_op_cache", - sizeof(struct pvfs2_kernel_op_s), + op_cache = kmem_cache_create("orangefs_op_cache", + sizeof(struct orangefs_kernel_op_s), 0, - PVFS2_CACHE_CREATE_FLAGS, + ORANGEFS_CACHE_CREATE_FLAGS, NULL); if (!op_cache) { - gossip_err("Cannot create pvfs2_op_cache\n"); + gossip_err("Cannot create orangefs_op_cache\n"); return -ENOMEM; } @@ -48,72 +48,72 @@ int op_cache_finalize(void) return 0; } -char *get_opname_string(struct pvfs2_kernel_op_s *new_op) +char *get_opname_string(struct orangefs_kernel_op_s *new_op) { if (new_op) { __s32 type = new_op->upcall.type; - if (type == PVFS2_VFS_OP_FILE_IO) + if (type == ORANGEFS_VFS_OP_FILE_IO) return "OP_FILE_IO"; - else if (type == PVFS2_VFS_OP_LOOKUP) + else if (type == ORANGEFS_VFS_OP_LOOKUP) return "OP_LOOKUP"; - else if (type == PVFS2_VFS_OP_CREATE) + else if (type == ORANGEFS_VFS_OP_CREATE) return "OP_CREATE"; - else if (type == PVFS2_VFS_OP_GETATTR) + else if (type == ORANGEFS_VFS_OP_GETATTR) return "OP_GETATTR"; - else if (type == PVFS2_VFS_OP_REMOVE) + else if (type == ORANGEFS_VFS_OP_REMOVE) return "OP_REMOVE"; - else if (type == PVFS2_VFS_OP_MKDIR) + else if (type == ORANGEFS_VFS_OP_MKDIR) return "OP_MKDIR"; - else if (type == PVFS2_VFS_OP_READDIR) + else if (type == ORANGEFS_VFS_OP_READDIR) return "OP_READDIR"; - else if (type == PVFS2_VFS_OP_READDIRPLUS) + else if (type == ORANGEFS_VFS_OP_READDIRPLUS) return "OP_READDIRPLUS"; - else if (type == PVFS2_VFS_OP_SETATTR) + else if (type == ORANGEFS_VFS_OP_SETATTR) return "OP_SETATTR"; - else if (type == PVFS2_VFS_OP_SYMLINK) + else if (type == ORANGEFS_VFS_OP_SYMLINK) return "OP_SYMLINK"; - else if (type == PVFS2_VFS_OP_RENAME) + else if (type == ORANGEFS_VFS_OP_RENAME) return "OP_RENAME"; - else if (type == PVFS2_VFS_OP_STATFS) + else if (type == ORANGEFS_VFS_OP_STATFS) return "OP_STATFS"; - else if (type == PVFS2_VFS_OP_TRUNCATE) + else if (type == ORANGEFS_VFS_OP_TRUNCATE) return "OP_TRUNCATE"; - else if (type == PVFS2_VFS_OP_MMAP_RA_FLUSH) + else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH) return "OP_MMAP_RA_FLUSH"; - else if (type == PVFS2_VFS_OP_FS_MOUNT) + else if (type == ORANGEFS_VFS_OP_FS_MOUNT) return "OP_FS_MOUNT"; - else if (type == PVFS2_VFS_OP_FS_UMOUNT) + else if (type == ORANGEFS_VFS_OP_FS_UMOUNT) return "OP_FS_UMOUNT"; - else if (type == PVFS2_VFS_OP_GETXATTR) + else if (type == ORANGEFS_VFS_OP_GETXATTR) return "OP_GETXATTR"; - else if (type == PVFS2_VFS_OP_SETXATTR) + else if (type == ORANGEFS_VFS_OP_SETXATTR) return "OP_SETXATTR"; - else if (type == PVFS2_VFS_OP_LISTXATTR) + else if (type == ORANGEFS_VFS_OP_LISTXATTR) return "OP_LISTXATTR"; - else if (type == PVFS2_VFS_OP_REMOVEXATTR) + else if (type == ORANGEFS_VFS_OP_REMOVEXATTR) return "OP_REMOVEXATTR"; - else if (type == PVFS2_VFS_OP_PARAM) + else if (type == ORANGEFS_VFS_OP_PARAM) return "OP_PARAM"; - else if (type == PVFS2_VFS_OP_PERF_COUNT) + else if (type == ORANGEFS_VFS_OP_PERF_COUNT) return "OP_PERF_COUNT"; - else if (type == PVFS2_VFS_OP_CANCEL) + else if (type == ORANGEFS_VFS_OP_CANCEL) return "OP_CANCEL"; - else if (type == PVFS2_VFS_OP_FSYNC) + else if (type == ORANGEFS_VFS_OP_FSYNC) return "OP_FSYNC"; - else if (type == PVFS2_VFS_OP_FSKEY) + else if (type == ORANGEFS_VFS_OP_FSKEY) return "OP_FSKEY"; } return "OP_UNKNOWN?"; } -struct pvfs2_kernel_op_s *op_alloc(__s32 type) +struct orangefs_kernel_op_s *op_alloc(__s32 type) { - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_kernel_op_s *new_op = NULL; - new_op = kmem_cache_alloc(op_cache, PVFS2_CACHE_ALLOC_FLAGS); + new_op = kmem_cache_alloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS); if (new_op) { - memset(new_op, 0, sizeof(struct pvfs2_kernel_op_s)); + memset(new_op, 0, sizeof(struct orangefs_kernel_op_s)); INIT_LIST_HEAD(&new_op->list); spin_lock_init(&new_op->lock); @@ -122,7 +122,7 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type) init_waitqueue_head(&new_op->io_completion_waitq); atomic_set(&new_op->aio_ref_count, 0); - pvfs2_op_initialize(new_op); + orangefs_op_initialize(new_op); /* initialize the op specific tag and upcall credentials */ spin_lock(&next_tag_value_lock); @@ -149,15 +149,15 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type) return new_op; } -void op_release(struct pvfs2_kernel_op_s *pvfs2_op) +void op_release(struct orangefs_kernel_op_s *orangefs_op) { - if (pvfs2_op) { + if (orangefs_op) { gossip_debug(GOSSIP_CACHE_DEBUG, "Releasing OP (%p: %llu)\n", - pvfs2_op, - llu(pvfs2_op->tag)); - pvfs2_op_initialize(pvfs2_op); - kmem_cache_free(op_cache, pvfs2_op); + orangefs_op, + llu(orangefs_op->tag)); + orangefs_op_initialize(orangefs_op); + kmem_cache_free(op_cache, orangefs_op); } else { gossip_err("NULL pointer in op_release\n"); } @@ -165,14 +165,14 @@ void op_release(struct pvfs2_kernel_op_s *pvfs2_op) int dev_req_cache_initialize(void) { - dev_req_cache = kmem_cache_create("pvfs2_devreqcache", + dev_req_cache = kmem_cache_create("orangefs_devreqcache", MAX_ALIGNED_DEV_REQ_DOWNSIZE, 0, - PVFS2_CACHE_CREATE_FLAGS, + ORANGEFS_CACHE_CREATE_FLAGS, NULL); if (!dev_req_cache) { - gossip_err("Cannot create pvfs2_dev_req_cache\n"); + gossip_err("Cannot create orangefs_dev_req_cache\n"); return -ENOMEM; } return 0; @@ -188,7 +188,7 @@ void *dev_req_alloc(void) { void *buffer; - buffer = kmem_cache_alloc(dev_req_cache, PVFS2_CACHE_ALLOC_FLAGS); + buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS); if (buffer == NULL) gossip_err("Failed to allocate from dev_req_cache\n"); else @@ -206,14 +206,14 @@ void dev_req_release(void *buffer) int kiocb_cache_initialize(void) { - pvfs2_kiocb_cache = kmem_cache_create("pvfs2_kiocbcache", - sizeof(struct pvfs2_kiocb_s), + orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache", + sizeof(struct orangefs_kiocb_s), 0, - PVFS2_CACHE_CREATE_FLAGS, + ORANGEFS_CACHE_CREATE_FLAGS, NULL); - if (!pvfs2_kiocb_cache) { - gossip_err("Cannot create pvfs2_kiocb_cache!\n"); + if (!orangefs_kiocb_cache) { + gossip_err("Cannot create orangefs_kiocb_cache!\n"); return -ENOMEM; } return 0; @@ -221,26 +221,26 @@ int kiocb_cache_initialize(void) int kiocb_cache_finalize(void) { - kmem_cache_destroy(pvfs2_kiocb_cache); + kmem_cache_destroy(orangefs_kiocb_cache); return 0; } -struct pvfs2_kiocb_s *kiocb_alloc(void) +struct orangefs_kiocb_s *kiocb_alloc(void) { - struct pvfs2_kiocb_s *x = NULL; + struct orangefs_kiocb_s *x = NULL; - x = kmem_cache_alloc(pvfs2_kiocb_cache, PVFS2_CACHE_ALLOC_FLAGS); + x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS); if (x == NULL) gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n"); else - memset(x, 0, sizeof(struct pvfs2_kiocb_s)); + memset(x, 0, sizeof(struct orangefs_kiocb_s)); return x; } -void kiocb_release(struct pvfs2_kiocb_s *x) +void kiocb_release(struct orangefs_kiocb_s *x) { if (x) - kmem_cache_free(pvfs2_kiocb_cache, x); + kmem_cache_free(orangefs_kiocb_cache, x); else gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n"); } diff --git a/fs/orangefs/pvfs2-debug.h b/fs/orangefs/pvfs2-debug.h index fd71d6c84cf6..e6b4baa5e8fb 100644 --- a/fs/orangefs/pvfs2-debug.h +++ b/fs/orangefs/pvfs2-debug.h @@ -5,12 +5,12 @@ */ /* This file just defines debugging masks to be used with the gossip - * logging utility. All debugging masks for PVFS2 are kept here to make + * logging utility. All debugging masks for ORANGEFS are kept here to make * sure we don't have collisions. */ -#ifndef __PVFS2_DEBUG_H -#define __PVFS2_DEBUG_H +#ifndef __ORANGEFS_DEBUG_H +#define __ORANGEFS_DEBUG_H #ifdef __KERNEL__ #include @@ -90,7 +90,7 @@ GOSSIP_BMI_DEBUG_MX + \ GOSSIP_BMI_DEBUG_PORTALS)) -const char *PVFS_debug_get_next_debug_keyword(int position); +const char *ORANGEFS_debug_get_next_debug_keyword(int position); #define GOSSIP_SUPER_DEBUG ((__u64)1 << 0) #define GOSSIP_INODE_DEBUG ((__u64)1 << 1) @@ -113,10 +113,10 @@ const char *PVFS_debug_get_next_debug_keyword(int position); #define GOSSIP_MAX_DEBUG (((__u64)1 << GOSSIP_MAX_NR) - 1) /*function prototypes*/ -__u64 PVFS_kmod_eventlog_to_mask(const char *event_logging); -__u64 PVFS_debug_eventlog_to_mask(const char *event_logging); -char *PVFS_debug_mask_to_eventlog(__u64 mask); -char *PVFS_kmod_mask_to_eventlog(__u64 mask); +__u64 ORANGEFS_kmod_eventlog_to_mask(const char *event_logging); +__u64 ORANGEFS_debug_eventlog_to_mask(const char *event_logging); +char *ORANGEFS_debug_mask_to_eventlog(__u64 mask); +char *ORANGEFS_kmod_mask_to_eventlog(__u64 mask); /* a private internal type */ struct __keyword_mask_s { @@ -289,4 +289,4 @@ static const int num_kmod_keyword_mask_map = (int) static const int num_keyword_mask_map = (int) (sizeof(s_keyword_mask_map) / sizeof(struct __keyword_mask_s)); -#endif /* __PVFS2_DEBUG_H */ +#endif /* __ORANGEFS_DEBUG_H */ diff --git a/fs/orangefs/pvfs2-debugfs.c b/fs/orangefs/pvfs2-debugfs.c index ba5bfef7a3f3..315dc538b723 100644 --- a/fs/orangefs/pvfs2-debugfs.c +++ b/fs/orangefs/pvfs2-debugfs.c @@ -95,7 +95,7 @@ static const struct file_operations kernel_debug_fops = { * initialize kmod debug operations, create orangefs debugfs dir and * ORANGEFS_KMOD_DEBUG_HELP_FILE. */ -int pvfs2_debugfs_init(void) +int orangefs_debugfs_init(void) { int rc = -ENOMEM; @@ -117,12 +117,12 @@ int pvfs2_debugfs_init(void) out: if (rc) - pvfs2_debugfs_cleanup(); + orangefs_debugfs_cleanup(); return rc; } -void pvfs2_debugfs_cleanup(void) +void orangefs_debugfs_cleanup(void) { debugfs_remove_recursive(debug_dir); } @@ -196,7 +196,7 @@ static int help_show(struct seq_file *m, void *v) /* * initialize the kernel-debug file. */ -int pvfs2_kernel_debug_init(void) +int orangefs_kernel_debug_init(void) { int rc = -ENOMEM; @@ -205,11 +205,11 @@ int pvfs2_kernel_debug_init(void) gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__); - k_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL); + k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!k_buffer) goto out; - if (strlen(kernel_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) { + if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) { strcpy(k_buffer, kernel_debug_string); strcat(k_buffer, "\n"); } else { @@ -233,7 +233,7 @@ int pvfs2_kernel_debug_init(void) out: if (rc) - pvfs2_debugfs_cleanup(); + orangefs_debugfs_cleanup(); gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc); return rc; @@ -242,7 +242,7 @@ out: /* * initialize the client-debug file. */ -int pvfs2_client_debug_init(void) +int orangefs_client_debug_init(void) { int rc = -ENOMEM; @@ -250,11 +250,11 @@ int pvfs2_client_debug_init(void) gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__); - c_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL); + c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!c_buffer) goto out; - if (strlen(client_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) { + if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) { strcpy(c_buffer, client_debug_string); strcat(c_buffer, "\n"); } else { @@ -278,7 +278,7 @@ int pvfs2_client_debug_init(void) out: if (rc) - pvfs2_debugfs_cleanup(); + orangefs_debugfs_cleanup(); gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc); return rc; @@ -320,7 +320,7 @@ static ssize_t orangefs_debug_read(struct file *file, gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n"); - buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL); + buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!buf) goto out; @@ -349,7 +349,7 @@ static ssize_t orangefs_debug_write(struct file *file, int rc = -EFAULT; size_t silly = 0; char *debug_string; - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_kernel_op_s *new_op = NULL; struct client_debug_mask c_mask = { NULL, 0, 0 }; gossip_debug(GOSSIP_DEBUGFS_DEBUG, @@ -360,15 +360,15 @@ static ssize_t orangefs_debug_write(struct file *file, * Thwart users who try to jamb a ridiculous number * of bytes into the debug file... */ - if (count > PVFS2_MAX_DEBUG_STRING_LEN + 1) { + if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) { silly = count; - count = PVFS2_MAX_DEBUG_STRING_LEN + 1; + count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1; } - buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL); + buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL); if (!buf) goto out; - memset(buf, 0, PVFS2_MAX_DEBUG_STRING_LEN); + memset(buf, 0, ORANGEFS_MAX_DEBUG_STRING_LEN); if (copy_from_user(buf, ubuf, count - 1)) { gossip_debug(GOSSIP_DEBUGFS_DEBUG, @@ -407,18 +407,18 @@ static ssize_t orangefs_debug_write(struct file *file, debug_mask_to_string(&c_mask, 1); debug_string = client_debug_string; - new_op = op_alloc(PVFS2_VFS_OP_PARAM); + new_op = op_alloc(ORANGEFS_VFS_OP_PARAM); if (!new_op) { pr_info("%s: op_alloc failed!\n", __func__); goto out; } new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES; - new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET; + ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES; + new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET; memset(new_op->upcall.req.param.s_value, 0, - PVFS2_MAX_DEBUG_STRING_LEN); + ORANGEFS_MAX_DEBUG_STRING_LEN); sprintf(new_op->upcall.req.param.s_value, "%llx %llx\n", c_mask.mask1, @@ -426,8 +426,8 @@ static ssize_t orangefs_debug_write(struct file *file, /* service_operation returns 0 on success... */ rc = service_operation(new_op, - "pvfs2_param", - PVFS2_OP_INTERRUPTIBLE); + "orangefs_param", + ORANGEFS_OP_INTERRUPTIBLE); if (rc) gossip_debug(GOSSIP_DEBUGFS_DEBUG, @@ -439,7 +439,7 @@ static ssize_t orangefs_debug_write(struct file *file, } mutex_lock(&orangefs_debug_lock); - memset(file->f_inode->i_private, 0, PVFS2_MAX_DEBUG_STRING_LEN); + memset(file->f_inode->i_private, 0, ORANGEFS_MAX_DEBUG_STRING_LEN); sprintf((char *)file->f_inode->i_private, "%s\n", debug_string); mutex_unlock(&orangefs_debug_lock); diff --git a/fs/orangefs/pvfs2-debugfs.h b/fs/orangefs/pvfs2-debugfs.h index a66b7d08c14d..e4828c0e3ef9 100644 --- a/fs/orangefs/pvfs2-debugfs.h +++ b/fs/orangefs/pvfs2-debugfs.h @@ -1,3 +1,3 @@ -int pvfs2_debugfs_init(void); -int pvfs2_kernel_debug_init(void); -void pvfs2_debugfs_cleanup(void); +int orangefs_debugfs_init(void); +int orangefs_kernel_debug_init(void); +void orangefs_debugfs_cleanup(void); diff --git a/fs/orangefs/pvfs2-dev-proto.h b/fs/orangefs/pvfs2-dev-proto.h index 71ab56df4ad7..dc1951dd7045 100644 --- a/fs/orangefs/pvfs2-dev-proto.h +++ b/fs/orangefs/pvfs2-dev-proto.h @@ -4,8 +4,8 @@ * See COPYING in top-level directory. */ -#ifndef _PVFS2_DEV_PROTO_H -#define _PVFS2_DEV_PROTO_H +#ifndef _ORANGEFS_DEV_PROTO_H +#define _ORANGEFS_DEV_PROTO_H /* * types and constants shared between user space and kernel space for @@ -13,46 +13,46 @@ */ /* - * valid pvfs2 kernel operation types + * valid orangefs kernel operation types */ -#define PVFS2_VFS_OP_INVALID 0xFF000000 -#define PVFS2_VFS_OP_FILE_IO 0xFF000001 -#define PVFS2_VFS_OP_LOOKUP 0xFF000002 -#define PVFS2_VFS_OP_CREATE 0xFF000003 -#define PVFS2_VFS_OP_GETATTR 0xFF000004 -#define PVFS2_VFS_OP_REMOVE 0xFF000005 -#define PVFS2_VFS_OP_MKDIR 0xFF000006 -#define PVFS2_VFS_OP_READDIR 0xFF000007 -#define PVFS2_VFS_OP_SETATTR 0xFF000008 -#define PVFS2_VFS_OP_SYMLINK 0xFF000009 -#define PVFS2_VFS_OP_RENAME 0xFF00000A -#define PVFS2_VFS_OP_STATFS 0xFF00000B -#define PVFS2_VFS_OP_TRUNCATE 0xFF00000C -#define PVFS2_VFS_OP_MMAP_RA_FLUSH 0xFF00000D -#define PVFS2_VFS_OP_FS_MOUNT 0xFF00000E -#define PVFS2_VFS_OP_FS_UMOUNT 0xFF00000F -#define PVFS2_VFS_OP_GETXATTR 0xFF000010 -#define PVFS2_VFS_OP_SETXATTR 0xFF000011 -#define PVFS2_VFS_OP_LISTXATTR 0xFF000012 -#define PVFS2_VFS_OP_REMOVEXATTR 0xFF000013 -#define PVFS2_VFS_OP_PARAM 0xFF000014 -#define PVFS2_VFS_OP_PERF_COUNT 0xFF000015 -#define PVFS2_VFS_OP_CANCEL 0xFF00EE00 -#define PVFS2_VFS_OP_FSYNC 0xFF00EE01 -#define PVFS2_VFS_OP_FSKEY 0xFF00EE02 -#define PVFS2_VFS_OP_READDIRPLUS 0xFF00EE03 +#define ORANGEFS_VFS_OP_INVALID 0xFF000000 +#define ORANGEFS_VFS_OP_FILE_IO 0xFF000001 +#define ORANGEFS_VFS_OP_LOOKUP 0xFF000002 +#define ORANGEFS_VFS_OP_CREATE 0xFF000003 +#define ORANGEFS_VFS_OP_GETATTR 0xFF000004 +#define ORANGEFS_VFS_OP_REMOVE 0xFF000005 +#define ORANGEFS_VFS_OP_MKDIR 0xFF000006 +#define ORANGEFS_VFS_OP_READDIR 0xFF000007 +#define ORANGEFS_VFS_OP_SETATTR 0xFF000008 +#define ORANGEFS_VFS_OP_SYMLINK 0xFF000009 +#define ORANGEFS_VFS_OP_RENAME 0xFF00000A +#define ORANGEFS_VFS_OP_STATFS 0xFF00000B +#define ORANGEFS_VFS_OP_TRUNCATE 0xFF00000C +#define ORANGEFS_VFS_OP_MMAP_RA_FLUSH 0xFF00000D +#define ORANGEFS_VFS_OP_FS_MOUNT 0xFF00000E +#define ORANGEFS_VFS_OP_FS_UMOUNT 0xFF00000F +#define ORANGEFS_VFS_OP_GETXATTR 0xFF000010 +#define ORANGEFS_VFS_OP_SETXATTR 0xFF000011 +#define ORANGEFS_VFS_OP_LISTXATTR 0xFF000012 +#define ORANGEFS_VFS_OP_REMOVEXATTR 0xFF000013 +#define ORANGEFS_VFS_OP_PARAM 0xFF000014 +#define ORANGEFS_VFS_OP_PERF_COUNT 0xFF000015 +#define ORANGEFS_VFS_OP_CANCEL 0xFF00EE00 +#define ORANGEFS_VFS_OP_FSYNC 0xFF00EE01 +#define ORANGEFS_VFS_OP_FSKEY 0xFF00EE02 +#define ORANGEFS_VFS_OP_READDIRPLUS 0xFF00EE03 /* * Misc constants. Please retain them as multiples of 8! * Otherwise 32-64 bit interactions will be messed up :) */ -#define PVFS2_NAME_LEN 0x00000100 -#define PVFS2_MAX_DEBUG_STRING_LEN 0x00000400 -#define PVFS2_MAX_DEBUG_ARRAY_LEN 0x00000800 +#define ORANGEFS_NAME_LEN 0x00000100 +#define ORANGEFS_MAX_DEBUG_STRING_LEN 0x00000400 +#define ORANGEFS_MAX_DEBUG_ARRAY_LEN 0x00000800 /* - * MAX_DIRENT_COUNT cannot be larger than PVFS_REQ_LIMIT_LISTATTR. - * The value of PVFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60 + * MAX_DIRENT_COUNT cannot be larger than ORANGEFS_REQ_LIMIT_LISTATTR. + * The value of ORANGEFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60 * to accomodate an attribute object with mirrored handles. * MAX_DIRENT_COUNT is replaced by MAX_DIRENT_COUNT_READDIR and * MAX_DIRENT_COUNT_READDIRPLUS, since readdir doesn't trigger a listattr diff --git a/fs/orangefs/pvfs2-kernel.h b/fs/orangefs/pvfs2-kernel.h index 4295e263e25b..33fcf3bccd2e 100644 --- a/fs/orangefs/pvfs2-kernel.h +++ b/fs/orangefs/pvfs2-kernel.h @@ -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). * 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 -#define __PVFS2KERNEL_H +#ifndef __ORANGEFSKERNEL_H +#define __ORANGEFSKERNEL_H #include #include @@ -55,30 +55,30 @@ #include "pvfs2-dev-proto.h" -#ifdef PVFS2_KERNEL_DEBUG -#define PVFS2_DEFAULT_OP_TIMEOUT_SECS 10 +#ifdef ORANGEFS_KERNEL_DEBUG +#define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS 10 #else -#define PVFS2_DEFAULT_OP_TIMEOUT_SECS 20 +#define ORANGEFS_DEFAULT_OP_TIMEOUT_SECS 20 #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 PVFS2_LINK_MAX 0x000000FF -#define PVFS2_PURGE_RETRY_COUNT 0x00000005 -#define PVFS2_SEEK_END 0x00000002 -#define PVFS2_MAX_NUM_OPTIONS 0x00000004 -#define PVFS2_MAX_MOUNT_OPT_LEN 0x00000080 -#define PVFS2_MAX_FSKEY_LEN 64 +#define ORANGEFS_DEVREQ_MAGIC 0x20030529 +#define ORANGEFS_LINK_MAX 0x000000FF +#define ORANGEFS_PURGE_RETRY_COUNT 0x00000005 +#define ORANGEFS_SEEK_END 0x00000002 +#define ORANGEFS_MAX_NUM_OPTIONS 0x00000004 +#define ORANGEFS_MAX_MOUNT_OPT_LEN 0x00000080 +#define ORANGEFS_MAX_FSKEY_LEN 64 #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) + \ -sizeof(__u64) + sizeof(struct pvfs2_downcall_s)) +sizeof(__u64) + sizeof(struct orangefs_downcall_s)) #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)) /* - * valid pvfs2 kernel operation states + * valid orangefs kernel operation states * * unknown - op was just initialized * 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 * exited uncleanly before servicing op */ -enum pvfs2_vfs_op_states { +enum orangefs_vfs_op_states { OP_VFS_STATE_UNKNOWN = 0, OP_VFS_STATE_WAITING = 1, 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 */ -enum PVFS_async_io_type { - PVFS_VFS_SYNC_IO = 0, - PVFS_VFS_ASYNC_IO = 1, +enum ORANGEFS_async_io_type { + ORANGEFS_VFS_SYNC_IO = 0, + 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)) -#define PVFS2_CACHE_CREATE_FLAGS SLAB_RED_ZONE +#if ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) +#define ORANGEFS_CACHE_CREATE_FLAGS SLAB_RED_ZONE #else -#define PVFS2_CACHE_CREATE_FLAGS 0 -#endif /* ((defined PVFS2_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */ +#define ORANGEFS_CACHE_CREATE_FLAGS 0 +#endif /* ((defined ORANGEFS_KERNEL_DEBUG) && (defined CONFIG_DEBUG_SLAB)) */ -#define PVFS2_CACHE_ALLOC_FLAGS (GFP_KERNEL) -#define PVFS2_GFP_FLAGS (GFP_KERNEL) -#define PVFS2_BUFMAP_GFP_FLAGS (GFP_KERNEL) +#define ORANGEFS_CACHE_ALLOC_FLAGS (GFP_KERNEL) +#define ORANGEFS_GFP_FLAGS (GFP_KERNEL) +#define ORANGEFS_BUFMAP_GFP_FLAGS (GFP_KERNEL) -/* pvfs2 xattr and acl related defines */ -#define PVFS2_XATTR_INDEX_POSIX_ACL_ACCESS 1 -#define PVFS2_XATTR_INDEX_POSIX_ACL_DEFAULT 2 -#define PVFS2_XATTR_INDEX_TRUSTED 3 -#define PVFS2_XATTR_INDEX_DEFAULT 4 +/* orangefs xattr and acl related defines */ +#define ORANGEFS_XATTR_INDEX_POSIX_ACL_ACCESS 1 +#define ORANGEFS_XATTR_INDEX_POSIX_ACL_DEFAULT 2 +#define ORANGEFS_XATTR_INDEX_TRUSTED 3 +#define ORANGEFS_XATTR_INDEX_DEFAULT 4 #if 0 #ifndef POSIX_ACL_XATTR_ACCESS @@ -200,17 +200,17 @@ struct client_debug_mask { #endif #endif -#define PVFS2_XATTR_NAME_ACL_ACCESS POSIX_ACL_XATTR_ACCESS -#define PVFS2_XATTR_NAME_ACL_DEFAULT POSIX_ACL_XATTR_DEFAULT -#define PVFS2_XATTR_NAME_TRUSTED_PREFIX "trusted." -#define PVFS2_XATTR_NAME_DEFAULT_PREFIX "" +#define ORANGEFS_XATTR_NAME_ACL_ACCESS POSIX_ACL_XATTR_ACCESS +#define ORANGEFS_XATTR_NAME_ACL_DEFAULT POSIX_ACL_XATTR_DEFAULT +#define ORANGEFS_XATTR_NAME_TRUSTED_PREFIX "trusted." +#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_debugfs_help_string(int); -/* defined in pvfs2-debugfs.c */ -int pvfs2_client_debug_init(void); +/* defined in orangefs-debugfs.c */ +int orangefs_client_debug_init(void); void debug_string_to_mask(char *, void *, int); 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 keyword_is_amalgam(char *); -/*these variables are defined in pvfs2-mod.c */ -extern char kernel_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; -extern char client_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; -extern char client_debug_array_string[PVFS2_MAX_DEBUG_STRING_LEN]; +/*these variables are defined in orangefs-mod.c */ +extern char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN]; +extern char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN]; +extern char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN]; extern unsigned int kernel_mask_set_mod_init; -extern int pvfs2_init_acl(struct inode *inode, struct inode *dir); -extern const struct xattr_handler *pvfs2_xattr_handlers[]; +extern int orangefs_init_acl(struct inode *inode, struct inode *dir); +extern const struct xattr_handler *orangefs_xattr_handlers[]; -extern struct posix_acl *pvfs2_get_acl(struct inode *inode, int type); -extern int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type); +extern struct posix_acl *orangefs_get_acl(struct inode *inode, 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 @@ -244,10 +244,10 @@ struct xtvec { }; /* - * pvfs2 data structures + * orangefs data structures */ -struct pvfs2_kernel_op_s { - enum pvfs2_vfs_op_states op_state; +struct orangefs_kernel_op_s { + enum orangefs_vfs_op_states op_state; __u64 tag; /* @@ -257,8 +257,8 @@ struct pvfs2_kernel_op_s { */ int uses_shared_memory; - struct pvfs2_upcall_s upcall; - struct pvfs2_downcall_s downcall; + struct orangefs_upcall_s upcall; + struct orangefs_downcall_s downcall; wait_queue_head_t waitq; spinlock_t lock; @@ -268,7 +268,7 @@ struct pvfs2_kernel_op_s { /* 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; /* used again for the async I/O code for deallocation */ @@ -279,14 +279,14 @@ struct pvfs2_kernel_op_s { struct list_head list; }; -/* per inode private pvfs2 info */ -struct pvfs2_inode_s { - struct pvfs2_object_kref refn; - char link_target[PVFS_NAME_MAX]; +/* per inode private orangefs info */ +struct orangefs_inode_s { + struct orangefs_object_kref refn; + char link_target[ORANGEFS_NAME_MAX]; __s64 blksize; /* * 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; @@ -299,7 +299,7 @@ struct pvfs2_inode_s { */ 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; }; @@ -324,15 +324,15 @@ struct pvfs2_inode_s { #define SetModeFlag(pinode) set_bit(P_MODE_FLAG, &(pinode)->pinode_flags) #define ModeFlag(pinode) test_bit(P_MODE_FLAG, &(pinode)->pinode_flags) -/* per superblock private pvfs2 info */ -struct pvfs2_sb_info_s { - struct pvfs2_khandle root_khandle; +/* per superblock private orangefs info */ +struct orangefs_sb_info_s { + struct orangefs_khandle root_khandle; __s32 fs_id; int id; int flags; -#define PVFS2_OPT_INTR 0x01 -#define PVFS2_OPT_LOCAL_LOCK 0x02 - char devname[PVFS_MAX_SERVER_ADDR_LEN]; +#define ORANGEFS_OPT_INTR 0x01 +#define ORANGEFS_OPT_LOCAL_LOCK 0x02 + char devname[ORANGEFS_MAX_SERVER_ADDR_LEN]; struct super_block *sb; int mount_pending; struct list_head list; @@ -344,7 +344,7 @@ struct pvfs2_sb_info_s { * or even completion notification so that the VFS client-side daemon * can free up its vfs_request slots. */ -struct pvfs2_kiocb_s { +struct orangefs_kiocb_s { /* the pointer to the task that initiated the AIO */ struct task_struct *tsk; @@ -352,11 +352,11 @@ struct pvfs2_kiocb_s { struct kiocb *kiocb; /* buffer index that was used for the I/O */ - struct pvfs2_bufmap *bufmap; + struct orangefs_bufmap *bufmap; int buffer_index; - /* pvfs2 kernel operation type */ - struct pvfs2_kernel_op_s *op; + /* orangefs kernel operation type */ + struct orangefs_kernel_op_s *op; /* The user space buffers from/to which I/O is being staged */ struct iovec *iov; @@ -377,31 +377,31 @@ struct pvfs2_kiocb_s { int needs_cleanup; }; -struct pvfs2_stats { +struct orangefs_stats { unsigned long cache_hits; unsigned long cache_misses; unsigned long reads; unsigned long writes; }; -extern struct pvfs2_stats g_pvfs2_stats; +extern struct orangefs_stats g_orangefs_stats; /* * NOTE: See Documentation/filesystems/porting for information * 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. */ -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 { unsigned char u[8]; @@ -420,23 +420,23 @@ static inline ino_t pvfs2_khandle_to_ino(struct pvfs2_khandle *khandle) 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) { - 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) { - struct pvfs2_khandle *khandle; + struct orangefs_khandle *khandle; ino_t ino; khandle = get_khandle_from_ino(inode); - ino = pvfs2_khandle_to_ino(khandle); + ino = orangefs_khandle_to_ino(khandle); return ino; } @@ -450,17 +450,17 @@ static inline int is_root_handle(struct inode *inode) gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: root handle: %pU, this handle: %pU:\n", __func__, - &PVFS2_SB(inode->i_sb)->root_khandle, + &ORANGEFS_SB(inode->i_sb)->root_khandle, 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))) return 0; else 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) { gossip_debug(GOSSIP_DCACHE_DEBUG, @@ -469,57 +469,57 @@ static inline int match_handle(struct pvfs2_khandle resp_handle, &resp_handle, 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; else return 1; } /* - * defined in pvfs2-cache.c + * defined in orangefs-cache.c */ int op_cache_initialize(void); int op_cache_finalize(void); -struct pvfs2_kernel_op_s *op_alloc(__s32 type); -char *get_opname_string(struct pvfs2_kernel_op_s *new_op); -void op_release(struct pvfs2_kernel_op_s *op); +struct orangefs_kernel_op_s *op_alloc(__s32 type); +char *get_opname_string(struct orangefs_kernel_op_s *new_op); +void op_release(struct orangefs_kernel_op_s *op); int dev_req_cache_initialize(void); int dev_req_cache_finalize(void); void *dev_req_alloc(void); void dev_req_release(void *); -int pvfs2_inode_cache_initialize(void); -int pvfs2_inode_cache_finalize(void); +int orangefs_inode_cache_initialize(void); +int orangefs_inode_cache_finalize(void); int kiocb_cache_initialize(void); int kiocb_cache_finalize(void); -struct pvfs2_kiocb_s *kiocb_alloc(void); -void kiocb_release(struct pvfs2_kiocb_s *ptr); +struct orangefs_kiocb_s *kiocb_alloc(void); +void kiocb_release(struct orangefs_kiocb_s *ptr); /* - * defined in pvfs2-mod.c + * defined in orangefs-mod.c */ void purge_inprogress_ops(void); /* * defined in waitqueue.c */ -int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op); -int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op); -void pvfs2_clean_up_interrupted_operation(struct pvfs2_kernel_op_s *op); +int wait_for_matching_downcall(struct orangefs_kernel_op_s *op); +int wait_for_cancellation_downcall(struct orangefs_kernel_op_s *op); +void orangefs_clean_up_interrupted_operation(struct orangefs_kernel_op_s *op); void purge_waiting_ops(void); /* * defined in super.c */ -struct dentry *pvfs2_mount(struct file_system_type *fst, +struct dentry *orangefs_mount(struct file_system_type *fst, int flags, const char *devname, void *data); -void pvfs2_kill_sb(struct super_block *sb); -int pvfs2_remount(struct super_block *sb); +void orangefs_kill_sb(struct super_block *sb); +int orangefs_remount(struct super_block *sb); int fsid_key_table_initialize(void); void fsid_key_table_finalize(void); @@ -527,175 +527,175 @@ void fsid_key_table_finalize(void); /* * defined in inode.c */ -__u32 convert_to_pvfs2_mask(unsigned long lite_mask); -struct inode *pvfs2_new_inode(struct super_block *sb, +__u32 convert_to_orangefs_mask(unsigned long lite_mask); +struct inode *orangefs_new_inode(struct super_block *sb, struct inode *dir, int mode, 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 kstat *kstat); /* * defined in xattr.c */ -int pvfs2_setxattr(struct dentry *dentry, +int orangefs_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags); -ssize_t pvfs2_getxattr(struct dentry *dentry, +ssize_t orangefs_getxattr(struct dentry *dentry, const char *name, void *buffer, 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 */ -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); -ssize_t pvfs2_inode_read(struct inode *inode, - struct iov_iter *iter, - loff_t *offset, - loff_t readahead_size); +ssize_t orangefs_inode_read(struct inode *inode, + struct iov_iter *iter, + loff_t *offset, + loff_t readahead_size); /* - * defined in devpvfs2-req.c + * defined in devorangefs-req.c */ -int pvfs2_dev_init(void); -void pvfs2_dev_cleanup(void); +int orangefs_dev_init(void); +void orangefs_dev_cleanup(void); int is_daemon_in_service(void); 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 *name, void *buffer, size_t size); -int pvfs2_inode_setxattr(struct inode *inode, +int orangefs_inode_setxattr(struct inode *inode, const char *prefix, const char *name, const void *value, size_t size, 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 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; } -int pvfs2_normalize_to_errno(__s32 error_code); +int orangefs_normalize_to_errno(__s32 error_code); extern struct mutex devreq_mutex; extern struct mutex request_mutex; extern int debug; extern int op_timeout_secs; extern int slot_timeout_secs; -extern struct list_head pvfs2_superblocks; -extern spinlock_t pvfs2_superblocks_lock; -extern struct list_head pvfs2_request_list; -extern spinlock_t pvfs2_request_list_lock; -extern wait_queue_head_t pvfs2_request_list_waitq; +extern struct list_head orangefs_superblocks; +extern spinlock_t orangefs_superblocks_lock; +extern struct list_head orangefs_request_list; +extern spinlock_t orangefs_request_list_lock; +extern wait_queue_head_t orangefs_request_list_waitq; extern struct list_head *htable_ops_in_progress; extern spinlock_t htable_ops_in_progress_lock; extern int hash_table_size; -extern const struct address_space_operations pvfs2_address_operations; -extern struct backing_dev_info pvfs2_backing_dev_info; -extern struct inode_operations pvfs2_file_inode_operations; -extern const struct file_operations pvfs2_file_operations; -extern struct inode_operations pvfs2_symlink_inode_operations; -extern struct inode_operations pvfs2_dir_inode_operations; -extern const struct file_operations pvfs2_dir_operations; -extern const struct dentry_operations pvfs2_dentry_operations; -extern const struct file_operations pvfs2_devreq_file_operations; +extern const struct address_space_operations orangefs_address_operations; +extern struct backing_dev_info orangefs_backing_dev_info; +extern struct inode_operations orangefs_file_inode_operations; +extern const struct file_operations orangefs_file_operations; +extern struct inode_operations orangefs_symlink_inode_operations; +extern struct inode_operations orangefs_dir_inode_operations; +extern const struct file_operations orangefs_dir_operations; +extern const struct dentry_operations orangefs_dentry_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 */ #define add_op_to_request_list(op) \ do { \ - spin_lock(&pvfs2_request_list_lock); \ + spin_lock(&orangefs_request_list_lock); \ spin_lock(&op->lock); \ set_op_state_waiting(op); \ - list_add_tail(&op->list, &pvfs2_request_list); \ - spin_unlock(&pvfs2_request_list_lock); \ + list_add_tail(&op->list, &orangefs_request_list); \ + spin_unlock(&orangefs_request_list_lock); \ spin_unlock(&op->lock); \ - wake_up_interruptible(&pvfs2_request_list_waitq); \ + wake_up_interruptible(&orangefs_request_list_waitq); \ } while (0) #define add_priority_op_to_request_list(op) \ do { \ - spin_lock(&pvfs2_request_list_lock); \ + spin_lock(&orangefs_request_list_lock); \ spin_lock(&op->lock); \ set_op_state_waiting(op); \ \ - list_add(&op->list, &pvfs2_request_list); \ - spin_unlock(&pvfs2_request_list_lock); \ + list_add(&op->list, &orangefs_request_list); \ + spin_unlock(&orangefs_request_list_lock); \ spin_unlock(&op->lock); \ - wake_up_interruptible(&pvfs2_request_list_waitq); \ + wake_up_interruptible(&orangefs_request_list_waitq); \ } while (0) #define remove_op_from_request_list(op) \ do { \ struct list_head *tmp = 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); \ - list_for_each_safe(tmp, tmp_safe, &pvfs2_request_list) { \ + spin_lock(&orangefs_request_list_lock); \ + list_for_each_safe(tmp, tmp_safe, &orangefs_request_list) { \ tmp_op = list_entry(tmp, \ - struct pvfs2_kernel_op_s, \ + struct orangefs_kernel_op_s, \ list); \ if (tmp_op && (tmp_op == op)) { \ list_del(&tmp_op->list); \ break; \ } \ } \ - spin_unlock(&pvfs2_request_list_lock); \ + spin_unlock(&orangefs_request_list_lock); \ } while (0) -#define PVFS2_OP_INTERRUPTIBLE 1 /* service_operation() is interruptible */ -#define PVFS2_OP_PRIORITY 2 /* service_operation() is high priority */ -#define PVFS2_OP_CANCELLATION 4 /* this is a cancellation */ -#define PVFS2_OP_NO_SEMAPHORE 8 /* don't acquire semaphore */ -#define PVFS2_OP_ASYNC 16 /* Queue it, but don't wait */ +#define ORANGEFS_OP_INTERRUPTIBLE 1 /* service_operation() is interruptible */ +#define ORANGEFS_OP_PRIORITY 2 /* service_operation() is high priority */ +#define ORANGEFS_OP_CANCELLATION 4 /* this is a cancellation */ +#define ORANGEFS_OP_NO_SEMAPHORE 8 /* don't acquire semaphore */ +#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, int flags); @@ -719,7 +719,7 @@ int service_operation(struct pvfs2_kernel_op_s *op, * sent and have handle_error * 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 * 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 @@ -731,77 +731,77 @@ int service_operation(struct pvfs2_kernel_op_s *op, #define handle_io_error() \ do { \ 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); \ } else { \ wake_up_daemon_for_return(new_op); \ } \ new_op = NULL; \ - pvfs_bufmap_put(bufmap, buffer_index); \ + orangefs_bufmap_put(bufmap, buffer_index); \ buffer_index = -1; \ } while (0) #define get_interruptible_flag(inode) \ - ((PVFS2_SB(inode->i_sb)->flags & PVFS2_OPT_INTR) ? \ - PVFS2_OP_INTERRUPTIBLE : 0) + ((ORANGEFS_SB(inode->i_sb)->flags & ORANGEFS_OPT_INTR) ? \ + ORANGEFS_OP_INTERRUPTIBLE : 0) -#define add_pvfs2_sb(sb) \ +#define add_orangefs_sb(sb) \ do { \ gossip_debug(GOSSIP_SUPER_DEBUG, \ - "Adding SB %p to pvfs2 superblocks\n", \ - PVFS2_SB(sb)); \ - spin_lock(&pvfs2_superblocks_lock); \ - list_add_tail(&PVFS2_SB(sb)->list, &pvfs2_superblocks); \ - spin_unlock(&pvfs2_superblocks_lock); \ + "Adding SB %p to orangefs superblocks\n", \ + ORANGEFS_SB(sb)); \ + spin_lock(&orangefs_superblocks_lock); \ + list_add_tail(&ORANGEFS_SB(sb)->list, &orangefs_superblocks); \ + spin_unlock(&orangefs_superblocks_lock); \ } while (0) -#define remove_pvfs2_sb(sb) \ +#define remove_orangefs_sb(sb) \ do { \ struct list_head *tmp = 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); \ - list_for_each_safe(tmp, tmp_safe, &pvfs2_superblocks) { \ - pvfs2_sb = list_entry(tmp, \ - struct pvfs2_sb_info_s, \ + spin_lock(&orangefs_superblocks_lock); \ + list_for_each_safe(tmp, tmp_safe, &orangefs_superblocks) { \ + orangefs_sb = list_entry(tmp, \ + struct orangefs_sb_info_s, \ list); \ - if (pvfs2_sb && (pvfs2_sb->sb == sb)) { \ + if (orangefs_sb && (orangefs_sb->sb == sb)) { \ gossip_debug(GOSSIP_SUPER_DEBUG, \ - "Removing SB %p from pvfs2 superblocks\n", \ - pvfs2_sb); \ - list_del(&pvfs2_sb->list); \ + "Removing SB %p from orangefs superblocks\n", \ + orangefs_sb); \ + list_del(&orangefs_sb->list); \ break; \ } \ } \ - spin_unlock(&pvfs2_superblocks_lock); \ + spin_unlock(&orangefs_superblocks_lock); \ } while (0) -#define pvfs2_lock_inode(inode) spin_lock(&inode->i_lock) -#define pvfs2_unlock_inode(inode) spin_unlock(&inode->i_lock) +#define orangefs_lock_inode(inode) spin_lock(&inode->i_lock) +#define orangefs_unlock_inode(inode) spin_unlock(&inode->i_lock) #define fill_default_sys_attrs(sys_attr, type, mode) \ do { \ sys_attr.owner = from_kuid(current_user_ns(), current_fsuid()); \ sys_attr.group = from_kgid(current_user_ns(), current_fsgid()); \ 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.mask = PVFS_ATTR_SYS_ALL_SETABLE; \ + sys_attr.mask = ORANGEFS_ATTR_SYS_ALL_SETABLE; \ } 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) - pvfs2_inode_lock(inode); + ornagefs_inode_lock(inode); #endif i_size_write(inode, i_size); #if BITS_PER_LONG == 32 && defined(CONFIG_SMP) - pvfs2_inode_unlock(inode); + orangefs_inode_unlock(inode); #endif } @@ -816,4 +816,4 @@ static inline unsigned int diff(struct timeval *end, struct timeval *begin) return (end->tv_sec * 1000000) + end->tv_usec; } -#endif /* __PVFS2KERNEL_H */ +#endif /* __ORANGEFSKERNEL_H */ diff --git a/fs/orangefs/pvfs2-mod.c b/fs/orangefs/pvfs2-mod.c index d848c90413d1..d8642908a917 100644 --- a/fs/orangefs/pvfs2-mod.c +++ b/fs/orangefs/pvfs2-mod.c @@ -12,9 +12,9 @@ #include "pvfs2-debugfs.h" #include "pvfs2-sysfs.h" -/* PVFS2_VERSION is a ./configure define */ -#ifndef PVFS2_VERSION -#define PVFS2_VERSION "Unknown" +/* ORANGEFS_VERSION is a ./configure define */ +#ifndef ORANGEFS_VERSION +#define ORANGEFS_VERSION "Unknown" #endif /* @@ -25,9 +25,9 @@ struct client_debug_mask *cdm_array; int cdm_element_count; -char kernel_debug_string[PVFS2_MAX_DEBUG_STRING_LEN] = "none"; -char client_debug_string[PVFS2_MAX_DEBUG_STRING_LEN]; -char client_debug_array_string[PVFS2_MAX_DEBUG_STRING_LEN]; +char kernel_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN] = "none"; +char client_debug_string[ORANGEFS_MAX_DEBUG_STRING_LEN]; +char client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN]; char *debug_help_string; int help_string_initialized; @@ -36,7 +36,7 @@ struct dentry *client_debug_dentry; struct dentry *debug_dir; int client_verbose_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 */ int hash_table_size = 509; @@ -45,22 +45,22 @@ static ulong module_parm_debug_mask; __u64 gossip_debug_mask; struct client_debug_mask client_debug_mask = { NULL, 0, 0 }; unsigned int kernel_mask_set_mod_init; /* implicitly false */ -int op_timeout_secs = PVFS2_DEFAULT_OP_TIMEOUT_SECS; -int slot_timeout_secs = PVFS2_DEFAULT_SLOT_TIMEOUT_SECS; +int op_timeout_secs = ORANGEFS_DEFAULT_OP_TIMEOUT_SECS; +int slot_timeout_secs = ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS; MODULE_LICENSE("GPL"); -MODULE_AUTHOR("PVFS2 Development Team"); -MODULE_DESCRIPTION("The Linux Kernel VFS interface to PVFS2"); -MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see pvfs2-debug.h for values)"); +MODULE_AUTHOR("ORANGEFS Development Team"); +MODULE_DESCRIPTION("The Linux Kernel VFS interface to ORANGEFS"); +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(slot_timeout_secs, "Slot timeout in seconds"); MODULE_PARM_DESC(hash_table_size, "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", - .mount = pvfs2_mount, - .kill_sb = pvfs2_kill_sb, + .mount = orangefs_mount, + .kill_sb = orangefs_kill_sb, .owner = THIS_MODULE, }; @@ -85,15 +85,15 @@ struct list_head *htable_ops_in_progress; DEFINE_SPINLOCK(htable_ops_in_progress_lock); /* list for queueing upcall operations */ -LIST_HEAD(pvfs2_request_list); +LIST_HEAD(orangefs_request_list); -/* used to protect the above pvfs2_request_list */ -DEFINE_SPINLOCK(pvfs2_request_list_lock); +/* used to protect the above orangefs_request_list */ +DEFINE_SPINLOCK(orangefs_request_list_lock); /* 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; __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 - * 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 * 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; /* 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, (unsigned long long)gossip_debug_mask); - ret = bdi_init(&pvfs2_backing_dev_info); + ret = bdi_init(&orangefs_backing_dev_info); if (ret) return ret; @@ -144,7 +144,7 @@ static int __init pvfs2_init(void) if (ret < 0) goto cleanup_op; - ret = pvfs2_inode_cache_initialize(); + ret = orangefs_inode_cache_initialize(); if (ret < 0) goto cleanup_req; @@ -153,9 +153,9 @@ static int __init pvfs2_init(void) goto cleanup_inode; /* Initialize the pvfsdev subsystem. */ - ret = pvfs2_dev_init(); + ret = orangefs_dev_init(); if (ret < 0) { - gossip_err("pvfs2: could not initialize device subsystem %d!\n", + gossip_err("orangefs: could not initialize device subsystem %d!\n", ret); goto cleanup_kiocb; } @@ -197,17 +197,17 @@ static int __init pvfs2_init(void) if (ret) goto out; - pvfs2_debugfs_init(); - pvfs2_kernel_debug_init(); + orangefs_debugfs_init(); + orangefs_kernel_debug_init(); orangefs_sysfs_init(); - ret = register_filesystem(&pvfs2_fs_type); + ret = register_filesystem(&orangefs_fs_type); 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; } - pvfs2_debugfs_cleanup(); + orangefs_debugfs_cleanup(); orangefs_sysfs_exit(); fsid_key_table_finalize(); @@ -215,13 +215,13 @@ cleanup_progress_table: kfree(htable_ops_in_progress); cleanup_device: - pvfs2_dev_cleanup(); + orangefs_dev_cleanup(); cleanup_kiocb: kiocb_cache_finalize(); cleanup_inode: - pvfs2_inode_cache_finalize(); + orangefs_inode_cache_finalize(); cleanup_req: dev_req_cache_finalize(); @@ -230,29 +230,29 @@ cleanup_op: op_cache_finalize(); err: - bdi_destroy(&pvfs2_backing_dev_info); + bdi_destroy(&orangefs_backing_dev_info); out: return ret; } -static void __exit pvfs2_exit(void) +static void __exit orangefs_exit(void) { 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); - pvfs2_debugfs_cleanup(); + unregister_filesystem(&orangefs_fs_type); + orangefs_debugfs_cleanup(); orangefs_sysfs_exit(); fsid_key_table_finalize(); - pvfs2_dev_cleanup(); + orangefs_dev_cleanup(); /* clear out all pending upcall op requests */ - spin_lock(&pvfs2_request_list_lock); - while (!list_empty(&pvfs2_request_list)) { - cur_op = list_entry(pvfs2_request_list.next, - struct pvfs2_kernel_op_s, + spin_lock(&orangefs_request_list_lock); + while (!list_empty(&orangefs_request_list)) { + cur_op = list_entry(orangefs_request_list.next, + struct orangefs_kernel_op_s, list); list_del(&cur_op->list); gossip_debug(GOSSIP_INIT_DEBUG, @@ -260,26 +260,26 @@ static void __exit pvfs2_exit(void) cur_op->upcall.type); op_release(cur_op); } - spin_unlock(&pvfs2_request_list_lock); + spin_unlock(&orangefs_request_list_lock); for (i = 0; i < hash_table_size; i++) while (!list_empty(&htable_ops_in_progress[i])) { cur_op = list_entry(htable_ops_in_progress[i].next, - struct pvfs2_kernel_op_s, + struct orangefs_kernel_op_s, list); op_release(cur_op); } kiocb_cache_finalize(); - pvfs2_inode_cache_finalize(); + orangefs_inode_cache_finalize(); dev_req_cache_finalize(); op_cache_finalize(); 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; for (i = 0; i < hash_table_size; i++) { - struct pvfs2_kernel_op_s *op; - struct pvfs2_kernel_op_s *next; + struct orangefs_kernel_op_s *op; + struct orangefs_kernel_op_s *next; list_for_each_entry_safe(op, next, @@ -311,5 +311,5 @@ void purge_inprogress_ops(void) } } -module_init(pvfs2_init); -module_exit(pvfs2_exit); +module_init(orangefs_init); +module_exit(orangefs_exit); diff --git a/fs/orangefs/pvfs2-sysfs.c b/fs/orangefs/pvfs2-sysfs.c index ea635b5e431b..f04de2593c79 100644 --- a/fs/orangefs/pvfs2-sysfs.c +++ b/fs/orangefs/pvfs2-sysfs.c @@ -669,13 +669,13 @@ static ssize_t sysfs_int_show(char *kobj_id, char *buf, void *attr) rc = scnprintf(buf, PAGE_SIZE, "%lu\n", - g_pvfs2_stats.reads); + g_orangefs_stats.reads); goto out; } else if (!strcmp(stats_orangefs_attr->attr.name, "writes")) { rc = scnprintf(buf, PAGE_SIZE, "%lu\n", - g_pvfs2_stats.writes); + g_orangefs_stats.writes); goto out; } else { goto out; @@ -752,7 +752,7 @@ out: */ 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; char *ser_op_type = NULL; struct orangefs_attribute *orangefs_attr; @@ -768,9 +768,9 @@ static int sysfs_service_op_show(char *kobj_id, char *buf, void *attr) kobj_id); if (strcmp(kobj_id, PC_KOBJ_ID)) - op_alloc_type = PVFS2_VFS_OP_PARAM; + op_alloc_type = ORANGEFS_VFS_OP_PARAM; else - op_alloc_type = PVFS2_VFS_OP_PERF_COUNT; + op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT; new_op = op_alloc(op_alloc_type); 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)) - 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)) { orangefs_attr = (struct orangefs_attribute *)attr; if (!strcmp(orangefs_attr->attr.name, "perf_history_size")) 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, "perf_time_interval_secs")) 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, "perf_counter_reset")) 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)) { acache_attr = (struct acache_orangefs_attribute *)attr; if (!strcmp(acache_attr->attr.name, "timeout_msecs")) 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")) 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")) 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")) 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)) { capcache_attr = (struct capcache_orangefs_attribute *)attr; if (!strcmp(capcache_attr->attr.name, "timeout_secs")) 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")) 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")) 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")) 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)) { ccache_attr = (struct ccache_orangefs_attribute *)attr; if (!strcmp(ccache_attr->attr.name, "timeout_secs")) 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")) 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")) 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")) 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)) { ncache_attr = (struct ncache_orangefs_attribute *)attr; if (!strcmp(ncache_attr->attr.name, "timeout_msecs")) 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")) 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")) 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")) 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)) { pc_attr = (struct pc_orangefs_attribute *)attr; if (!strcmp(pc_attr->attr.name, ACACHE_KOBJ_ID)) 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)) 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)) new_op->upcall.req.perf_count.type = - PVFS2_PERF_COUNT_REQUEST_NCACHE; + ORANGEFS_PERF_COUNT_REQUEST_NCACHE; } else { 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)) - ser_op_type = "pvfs2_param"; + ser_op_type = "orangefs_param"; else - ser_op_type = "pvfs2_perf_count"; + ser_op_type = "orangefs_perf_count"; /* * The service_operation will return an errno return code on * 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: if (!rc) { @@ -1025,7 +1025,7 @@ static ssize_t */ 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 rc = 0; 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", kobj_id); - new_op = op_alloc(PVFS2_VFS_OP_PARAM); + new_op = op_alloc(ORANGEFS_VFS_OP_PARAM); if (!new_op) { rc = -ENOMEM; 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 (val > 0) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_PERF_HISTORY_SIZE; + ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE; } else { rc = 0; goto out; @@ -1075,7 +1075,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "perf_time_interval_secs")) { if (val > 0) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS; + ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS; } else { rc = 0; goto out; @@ -1084,7 +1084,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "perf_counter_reset")) { if ((val == 0) || (val == 1)) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_PERF_RESET; + ORANGEFS_PARAM_REQUEST_OP_PERF_RESET; } else { rc = 0; 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 (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT; } else { rc = 0; goto out; @@ -1114,7 +1114,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "reclaim_percentage")) { if ((val > -1) && (val < 101)) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE; + ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS; + ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS; } else { rc = 0; 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 (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT; } else { rc = 0; goto out; @@ -1152,7 +1152,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "reclaim_percentage")) { if ((val > -1) && (val < 101)) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE; + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS; + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS; } else { rc = 0; 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 (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT; } else { rc = 0; goto out; @@ -1190,7 +1190,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "reclaim_percentage")) { if ((val > -1) && (val < 101)) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE; + ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS; + ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS; } else { rc = 0; 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 (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT; + ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT; } else { rc = 0; goto out; @@ -1228,7 +1228,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) "reclaim_percentage")) { if ((val > -1) && (val < 101)) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE; + ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE; } else { rc = 0; 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")) { if (val > -1) { new_op->upcall.req.param.op = - PVFS2_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS; + ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS; } else { rc = 0; goto out; @@ -1250,7 +1250,7 @@ static int sysfs_service_op_store(char *kobj_id, const char *buf, void *attr) 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; @@ -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 * 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) { gossip_err("sysfs_service_op_store: service op returned:%d:\n", diff --git a/fs/orangefs/pvfs2-utils.c b/fs/orangefs/pvfs2-utils.c index 1180a2480d2b..d132c5f712a4 100644 --- a/fs/orangefs/pvfs2-utils.c +++ b/fs/orangefs/pvfs2-utils.c @@ -8,67 +8,67 @@ #include "pvfs2-dev-proto.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) { switch (op->upcall.type) { - case PVFS2_VFS_OP_FILE_IO: + case ORANGEFS_VFS_OP_FILE_IO: fsid = op->upcall.req.io.refn.fs_id; break; - case PVFS2_VFS_OP_LOOKUP: + case ORANGEFS_VFS_OP_LOOKUP: fsid = op->upcall.req.lookup.parent_refn.fs_id; break; - case PVFS2_VFS_OP_CREATE: + case ORANGEFS_VFS_OP_CREATE: fsid = op->upcall.req.create.parent_refn.fs_id; break; - case PVFS2_VFS_OP_GETATTR: + case ORANGEFS_VFS_OP_GETATTR: fsid = op->upcall.req.getattr.refn.fs_id; break; - case PVFS2_VFS_OP_REMOVE: + case ORANGEFS_VFS_OP_REMOVE: fsid = op->upcall.req.remove.parent_refn.fs_id; break; - case PVFS2_VFS_OP_MKDIR: + case ORANGEFS_VFS_OP_MKDIR: fsid = op->upcall.req.mkdir.parent_refn.fs_id; break; - case PVFS2_VFS_OP_READDIR: + case ORANGEFS_VFS_OP_READDIR: fsid = op->upcall.req.readdir.refn.fs_id; break; - case PVFS2_VFS_OP_SETATTR: + case ORANGEFS_VFS_OP_SETATTR: fsid = op->upcall.req.setattr.refn.fs_id; break; - case PVFS2_VFS_OP_SYMLINK: + case ORANGEFS_VFS_OP_SYMLINK: fsid = op->upcall.req.sym.parent_refn.fs_id; break; - case PVFS2_VFS_OP_RENAME: + case ORANGEFS_VFS_OP_RENAME: fsid = op->upcall.req.rename.old_parent_refn.fs_id; break; - case PVFS2_VFS_OP_STATFS: + case ORANGEFS_VFS_OP_STATFS: fsid = op->upcall.req.statfs.fs_id; break; - case PVFS2_VFS_OP_TRUNCATE: + case ORANGEFS_VFS_OP_TRUNCATE: fsid = op->upcall.req.truncate.refn.fs_id; 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; break; - case PVFS2_VFS_OP_FS_UMOUNT: + case ORANGEFS_VFS_OP_FS_UMOUNT: fsid = op->upcall.req.fs_umount.fs_id; break; - case PVFS2_VFS_OP_GETXATTR: + case ORANGEFS_VFS_OP_GETXATTR: fsid = op->upcall.req.getxattr.refn.fs_id; break; - case PVFS2_VFS_OP_SETXATTR: + case ORANGEFS_VFS_OP_SETXATTR: fsid = op->upcall.req.setxattr.refn.fs_id; break; - case PVFS2_VFS_OP_LISTXATTR: + case ORANGEFS_VFS_OP_LISTXATTR: fsid = op->upcall.req.listxattr.refn.fs_id; break; - case PVFS2_VFS_OP_REMOVEXATTR: + case ORANGEFS_VFS_OP_REMOVEXATTR: fsid = op->upcall.req.removexattr.refn.fs_id; break; - case PVFS2_VFS_OP_FSYNC: + case ORANGEFS_VFS_OP_FSYNC: fsid = op->upcall.req.fsync.refn.fs_id; break; default: @@ -78,20 +78,20 @@ __s32 fsid_of_op(struct pvfs2_kernel_op_s *op) return fsid; } -static void pvfs2_set_inode_flags(struct inode *inode, - struct PVFS_sys_attr_s *attrs) +static void orangefs_set_inode_flags(struct inode *inode, + struct ORANGEFS_sys_attr_s *attrs) { - if (attrs->flags & PVFS_IMMUTABLE_FL) + if (attrs->flags & ORANGEFS_IMMUTABLE_FL) inode->i_flags |= S_IMMUTABLE; else inode->i_flags &= ~S_IMMUTABLE; - if (attrs->flags & PVFS_APPEND_FL) + if (attrs->flags & ORANGEFS_APPEND_FL) inode->i_flags |= S_APPEND; else inode->i_flags &= ~S_APPEND; - if (attrs->flags & PVFS_NOATIME_FL) + if (attrs->flags & ORANGEFS_NOATIME_FL) inode->i_flags |= S_NOATIME; else 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 */ static int copy_attributes_to_inode(struct inode *inode, - struct PVFS_sys_attr_s *attrs, + struct ORANGEFS_sys_attr_s *attrs, char *symname) { int ret = -1; 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 rounded_up_size = 0; @@ -127,24 +127,24 @@ static int copy_attributes_to_inode(struct inode *inode, gossip_debug(GOSSIP_UTILS_DEBUG, "attrs->mask = %x (objtype = %s)\n", attrs->mask, - attrs->objtype == PVFS_TYPE_METAFILE ? "file" : - attrs->objtype == PVFS_TYPE_DIRECTORY ? "directory" : - attrs->objtype == PVFS_TYPE_SYMLINK ? "symlink" : + attrs->objtype == ORANGEFS_TYPE_METAFILE ? "file" : + attrs->objtype == ORANGEFS_TYPE_DIRECTORY ? "directory" : + attrs->objtype == ORANGEFS_TYPE_SYMLINK ? "symlink" : "invalid/unknown"); switch (attrs->objtype) { - case PVFS_TYPE_METAFILE: - pvfs2_set_inode_flags(inode, attrs); - if (attrs->mask & PVFS_ATTR_SYS_SIZE) { + case ORANGEFS_TYPE_METAFILE: + orangefs_set_inode_flags(inode, attrs); + if (attrs->mask & ORANGEFS_ATTR_SYS_SIZE) { inode_size = (loff_t) attrs->size; rounded_up_size = (inode_size + (4096 - (inode_size % 4096))); - pvfs2_lock_inode(inode); + orangefs_lock_inode(inode); inode->i_bytes = inode_size; inode->i_blocks = (unsigned long)(rounded_up_size / 512); - pvfs2_unlock_inode(inode); + orangefs_unlock_inode(inode); /* * 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; } break; - case PVFS_TYPE_SYMLINK: + case ORANGEFS_TYPE_SYMLINK: if (symname != NULL) { inode->i_size = (loff_t) strlen(symname); break; @@ -164,9 +164,9 @@ static int copy_attributes_to_inode(struct inode *inode, default: inode->i_size = PAGE_CACHE_SIZE; - pvfs2_lock_inode(inode); + orangefs_lock_inode(inode); inode_set_bytes(inode, inode->i_size); - pvfs2_unlock_inode(inode); + orangefs_unlock_inode(inode); break; } @@ -179,30 +179,30 @@ static int copy_attributes_to_inode(struct inode *inode, inode->i_mtime.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; - if (attrs->perms & PVFS_O_WRITE) + if (attrs->perms & ORANGEFS_O_WRITE) perm_mode |= S_IWOTH; - if (attrs->perms & PVFS_O_READ) + if (attrs->perms & ORANGEFS_O_READ) perm_mode |= S_IROTH; - if (attrs->perms & PVFS_G_EXECUTE) + if (attrs->perms & ORANGEFS_G_EXECUTE) perm_mode |= S_IXGRP; - if (attrs->perms & PVFS_G_WRITE) + if (attrs->perms & ORANGEFS_G_WRITE) perm_mode |= S_IWGRP; - if (attrs->perms & PVFS_G_READ) + if (attrs->perms & ORANGEFS_G_READ) perm_mode |= S_IRGRP; - if (attrs->perms & PVFS_U_EXECUTE) + if (attrs->perms & ORANGEFS_U_EXECUTE) perm_mode |= S_IXUSR; - if (attrs->perms & PVFS_U_WRITE) + if (attrs->perms & ORANGEFS_U_WRITE) perm_mode |= S_IWUSR; - if (attrs->perms & PVFS_U_READ) + if (attrs->perms & ORANGEFS_U_READ) perm_mode |= S_IRUSR; - if (attrs->perms & PVFS_G_SGID) + if (attrs->perms & ORANGEFS_G_SGID) perm_mode |= S_ISGID; - if (attrs->perms & PVFS_U_SUID) + if (attrs->perms & ORANGEFS_U_SUID) perm_mode |= S_ISUID; inode->i_mode = perm_mode; @@ -216,11 +216,11 @@ static int copy_attributes_to_inode(struct inode *inode, } switch (attrs->objtype) { - case PVFS_TYPE_METAFILE: + case ORANGEFS_TYPE_METAFILE: inode->i_mode |= S_IFREG; ret = 0; break; - case PVFS_TYPE_DIRECTORY: + case ORANGEFS_TYPE_DIRECTORY: inode->i_mode |= S_IFDIR; /* NOTE: we have no good way to keep nlink consistent * 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); ret = 0; break; - case PVFS_TYPE_SYMLINK: + case ORANGEFS_TYPE_SYMLINK: inode->i_mode |= S_IFLNK; /* copy link target to inode private data */ - if (pvfs2_inode && symname) { - strncpy(pvfs2_inode->link_target, + if (orangefs_inode && symname) { + strncpy(orangefs_inode->link_target, symname, - PVFS_NAME_MAX); + ORANGEFS_NAME_MAX); gossip_debug(GOSSIP_UTILS_DEBUG, "Copied attr link target %s\n", - pvfs2_inode->link_target); + orangefs_inode->link_target); } gossip_debug(GOSSIP_UTILS_DEBUG, "symlink mode %o\n", @@ -248,12 +248,12 @@ static int copy_attributes_to_inode(struct inode *inode, ret = 0; break; 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); } 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, (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. */ 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) { umode_t tmp_mode; @@ -285,36 +285,36 @@ static inline int copy_attributes_from_inode(struct inode *inode, attrs->mask = 0; if (iattr->ia_valid & ATTR_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); } if (iattr->ia_valid & ATTR_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); } 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) { attrs->atime = - pvfs2_convert_time_field(&iattr->ia_atime); - attrs->mask |= PVFS_ATTR_SYS_ATIME_SET; + orangefs_convert_time_field(&iattr->ia_atime); + attrs->mask |= ORANGEFS_ATTR_SYS_ATIME_SET; } } 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) { attrs->mtime = - pvfs2_convert_time_field(&iattr->ia_mtime); - attrs->mask |= PVFS_ATTR_SYS_MTIME_SET; + orangefs_convert_time_field(&iattr->ia_mtime); + attrs->mask |= ORANGEFS_ATTR_SYS_MTIME_SET; } } 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 * ATTR_SIZE */ @@ -342,21 +342,21 @@ static inline int copy_attributes_from_inode(struct inode *inode, return -EINVAL; } - attrs->perms = PVFS_util_translate_mode(tmp_mode); - attrs->mask |= PVFS_ATTR_SYS_PERM; + attrs->perms = ORANGEFS_util_translate_mode(tmp_mode); + attrs->mask |= ORANGEFS_ATTR_SYS_PERM; } 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 */ -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 pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op; int ret = -EINVAL; gossip_debug(GOSSIP_UTILS_DEBUG, @@ -364,10 +364,10 @@ int pvfs2_inode_getattr(struct inode *inode, __u32 getattr_mask) __func__, get_khandle_from_ino(inode)); - new_op = op_alloc(PVFS2_VFS_OP_GETATTR); + new_op = op_alloc(ORANGEFS_VFS_OP_GETATTR); if (!new_op) 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; 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 * perturb any inode related code paths. */ if (new_op->downcall.resp.getattr.attributes.objtype == - PVFS_TYPE_METAFILE) { - pvfs2_inode->blksize = + ORANGEFS_TYPE_METAFILE) { + orangefs_inode->blksize = new_op->downcall.resp.getattr.attributes.blksize; } else { /* 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, "Getattr on handle %pU, " "fsid %d\n (inode ct = %d) returned %d\n", - &pvfs2_inode->refn.khandle, - pvfs2_inode->refn.fs_id, + &orangefs_inode->refn.khandle, + orangefs_inode->refn.fs_id, (int)atomic_read(&inode->i_count), 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 */ -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 pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op; int ret; - new_op = op_alloc(PVFS2_VFS_OP_SETATTR); + new_op = op_alloc(ORANGEFS_VFS_OP_SETATTR); if (!new_op) 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, &new_op->upcall.req.setattr.attributes, iattr); @@ -438,7 +438,7 @@ int pvfs2_inode_setattr(struct inode *inode, struct iattr *iattr) get_interruptible_flag(inode)); gossip_debug(GOSSIP_UTILS_DEBUG, - "pvfs2_inode_setattr: returning %d\n", + "orangefs_inode_setattr: returning %d\n", ret); /* 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. */ if (ret == 0) { - ClearAtimeFlag(pvfs2_inode); - ClearMtimeFlag(pvfs2_inode); - ClearCtimeFlag(pvfs2_inode); - ClearModeFlag(pvfs2_inode); + ClearAtimeFlag(orangefs_inode); + ClearMtimeFlag(orangefs_inode); + ClearCtimeFlag(orangefs_inode); + ClearModeFlag(orangefs_inode); } 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. @@ -472,7 +472,7 @@ int pvfs2_flush_inode(struct inode *inode) int ctime_flag; int atime_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)); @@ -481,14 +481,14 @@ int pvfs2_flush_inode(struct inode *inode) * will prevent multiple processes from all trying to flush the same * inode if they call close() simultaneously */ - mtime_flag = MtimeFlag(pvfs2_inode); - ClearMtimeFlag(pvfs2_inode); - ctime_flag = CtimeFlag(pvfs2_inode); - ClearCtimeFlag(pvfs2_inode); - atime_flag = AtimeFlag(pvfs2_inode); - ClearAtimeFlag(pvfs2_inode); - mode_flag = ModeFlag(pvfs2_inode); - ClearModeFlag(pvfs2_inode); + mtime_flag = MtimeFlag(orangefs_inode); + ClearMtimeFlag(orangefs_inode); + ctime_flag = CtimeFlag(orangefs_inode); + ClearCtimeFlag(orangefs_inode); + atime_flag = AtimeFlag(orangefs_inode); + ClearAtimeFlag(orangefs_inode); + mode_flag = ModeFlag(orangefs_inode); + ClearModeFlag(orangefs_inode); /* -- Lazy atime,mtime and ctime update -- * 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, - "*********** pvfs2_flush_inode: %pU " + "*********** orangefs_flush_inode: %pU " "(ia_valid %d)\n", get_khandle_from_ino(inode), wbattr.ia_valid); if (wbattr.ia_valid == 0) { gossip_debug(GOSSIP_UTILS_DEBUG, - "pvfs2_flush_inode skipping setattr()\n"); + "orangefs_flush_inode skipping setattr()\n"); return 0; } 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), inode->i_mode); - ret = pvfs2_inode_setattr(inode, &wbattr); + ret = orangefs_inode_setattr(inode, &wbattr); return ret; } -int pvfs2_unmount_sb(struct super_block *sb) +int orangefs_unmount_sb(struct super_block *sb) { int ret = -EINVAL; - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_kernel_op_s *new_op = NULL; gossip_debug(GOSSIP_UTILS_DEBUG, - "pvfs2_unmount_sb called on sb %p\n", + "orangefs_unmount_sb called on sb %p\n", sb); - new_op = op_alloc(PVFS2_VFS_OP_FS_UMOUNT); + new_op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT); if (!new_op) return -ENOMEM; - new_op->upcall.req.fs_umount.id = PVFS2_SB(sb)->id; - new_op->upcall.req.fs_umount.fs_id = PVFS2_SB(sb)->fs_id; - strncpy(new_op->upcall.req.fs_umount.pvfs2_config_server, - PVFS2_SB(sb)->devname, - PVFS_MAX_SERVER_ADDR_LEN); + new_op->upcall.req.fs_umount.id = ORANGEFS_SB(sb)->id; + new_op->upcall.req.fs_umount.fs_id = ORANGEFS_SB(sb)->fs_id; + strncpy(new_op->upcall.req.fs_umount.orangefs_config_server, + ORANGEFS_SB(sb)->devname, + ORANGEFS_MAX_SERVER_ADDR_LEN); gossip_debug(GOSSIP_UTILS_DEBUG, - "Attempting PVFS2 Unmount via host %s\n", - new_op->upcall.req.fs_umount.pvfs2_config_server); + "Attempting ORANGEFS Unmount via host %s\n", + 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, - "pvfs2_unmount: got return value of %d\n", ret); + "orangefs_unmount: got return value of %d\n", ret); if (ret) sb = ERR_PTR(ret); else - PVFS2_SB(sb)->mount_pending = 1; + ORANGEFS_SB(sb)->mount_pending = 1; op_release(new_op); return ret; @@ -569,42 +569,42 @@ int pvfs2_unmount_sb(struct super_block *sb) * NOTE: on successful cancellation, be sure to return -EINTR, as * 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; - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_kernel_op_s *new_op = NULL; 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)); - new_op = op_alloc(PVFS2_VFS_OP_CANCEL); + new_op = op_alloc(ORANGEFS_VFS_OP_CANCEL); if (!new_op) return -ENOMEM; new_op->upcall.req.cancel.op_tag = tag; 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)); - 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, - "pvfs2_cancel_op_in_progress: got return value of %d\n", + "orangefs_cancel_op_in_progress: got return value of %d\n", ret); op_release(new_op); return ret; } -void pvfs2_op_initialize(struct pvfs2_kernel_op_s *op) +void orangefs_op_initialize(struct orangefs_kernel_op_s *op) { if (op) { spin_lock(&op->lock); op->io_completed = 0; - op->upcall.type = PVFS2_VFS_OP_INVALID; - op->downcall.type = PVFS2_VFS_OP_INVALID; + op->upcall.type = ORANGEFS_VFS_OP_INVALID; + op->downcall.type = ORANGEFS_VFS_OP_INVALID; op->downcall.status = -1; 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)) { /* @@ -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 - * 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[] = { 0, EPERM, ENOENT, EINTR, EIO, ENXIO, EBADF, EAGAIN, ENOMEM, EFAULT, EBUSY, EEXIST, ENODEV, ENOTDIR, EISDIR, EINVAL, EMFILE, @@ -672,7 +672,7 @@ static int PINT_errno_mapping[] = { EACCES, ECONNRESET, ERANGE }; -int pvfs2_normalize_to_errno(__s32 error_code) +int orangefs_normalize_to_errno(__s32 error_code) { __u32 i; @@ -684,24 +684,24 @@ int pvfs2_normalize_to_errno(__s32 error_code) * server. */ } else if (error_code > 0) { - gossip_err("pvfs2: error status receieved.\n"); - gossip_err("pvfs2: assuming error code is inverted.\n"); + gossip_err("orangefs: error status receieved.\n"); + gossip_err("orangefs: assuming error code is inverted.\n"); 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. */ /* - * Convert PVFS2 error values into errno values suitable for return + * Convert ORANGEFS error values into errno values suitable for return * from the kernel. */ - if ((-error_code) & PVFS_NON_ERRNO_ERROR_BIT) { + if ((-error_code) & ORANGEFS_NON_ERRNO_ERROR_BIT) { if (((-error_code) & - (PVFS_ERROR_NUMBER_BITS|PVFS_NON_ERRNO_ERROR_BIT| - PVFS_ERROR_BIT)) == PVFS_ECANCEL) { + (ORANGEFS_ERROR_NUMBER_BITS|ORANGEFS_NON_ERRNO_ERROR_BIT| + ORANGEFS_ERROR_BIT)) == ORANGEFS_ECANCEL) { /* * cancellation error codes generally correspond to * a timeout from the client's perspective @@ -709,30 +709,30 @@ int pvfs2_normalize_to_errno(__s32 error_code) error_code = -ETIMEDOUT; } else { /* 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; } - /* Convert PVFS2 encoded errno values into regular errno values. */ - } else if ((-error_code) & PVFS_ERROR_BIT) { - i = (-error_code) & ~(PVFS_ERROR_BIT|PVFS_ERROR_CLASS_BITS); + /* Convert ORANGEFS encoded errno values into regular errno values. */ + } else if ((-error_code) & ORANGEFS_ERROR_BIT) { + i = (-error_code) & ~(ORANGEFS_ERROR_BIT|ORANGEFS_ERROR_CLASS_BITS); if (i < sizeof(PINT_errno_mapping)/sizeof(*PINT_errno_mapping)) error_code = -PINT_errno_mapping[i]; else 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. */ } 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; } #define NUM_MODES 11 -__s32 PVFS_util_translate_mode(int mode) +__s32 ORANGEFS_util_translate_mode(int mode) { int ret = 0; int i = 0; @@ -742,16 +742,16 @@ __s32 PVFS_util_translate_mode(int mode) S_IXUSR, S_IWUSR, S_IRUSR, S_ISGID, S_ISUID }; - static int pvfs2_modes[NUM_MODES] = { - PVFS_O_EXECUTE, PVFS_O_WRITE, PVFS_O_READ, - PVFS_G_EXECUTE, PVFS_G_WRITE, PVFS_G_READ, - PVFS_U_EXECUTE, PVFS_U_WRITE, PVFS_U_READ, - PVFS_G_SGID, PVFS_U_SUID + static int orangefs_modes[NUM_MODES] = { + ORANGEFS_O_EXECUTE, ORANGEFS_O_WRITE, ORANGEFS_O_READ, + ORANGEFS_G_EXECUTE, ORANGEFS_G_WRITE, ORANGEFS_G_READ, + ORANGEFS_U_EXECUTE, ORANGEFS_U_WRITE, ORANGEFS_U_READ, + ORANGEFS_G_SGID, ORANGEFS_U_SUID }; for (i = 0; i < NUM_MODES; i++) if (mode & modes[i]) - ret |= pvfs2_modes[i]; + ret |= orangefs_modes[i]; 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].mask2)); - if (!strcmp(cdm_array[i].keyword, PVFS2_VERBOSE)) + if (!strcmp(cdm_array[i].keyword, ORANGEFS_VERBOSE)) client_verbose_index = i; - if (!strcmp(cdm_array[i].keyword, PVFS2_ALL)) + if (!strcmp(cdm_array[i].keyword, ORANGEFS_ALL)) client_all_index = i; 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; } - 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 @@ -998,13 +998,13 @@ void do_k_string(void *k_mask, int index) if (*mask & s_kmod_keyword_mask_map[index].mask_val) { if ((strlen(kernel_debug_string) + strlen(s_kmod_keyword_mask_map[index].keyword)) - < PVFS2_MAX_DEBUG_STRING_LEN - 1) { + < ORANGEFS_MAX_DEBUG_STRING_LEN - 1) { strcat(kernel_debug_string, s_kmod_keyword_mask_map[index].keyword); strcat(kernel_debug_string, ","); } else { gossip_err("%s: overflow!\n", __func__); - strcpy(kernel_debug_string, PVFS2_ALL); + strcpy(kernel_debug_string, ORANGEFS_ALL); goto out; } } @@ -1025,13 +1025,13 @@ void do_c_string(void *c_mask, int index) (mask->mask2 & cdm_array[index].mask2)) { if ((strlen(client_debug_string) + strlen(cdm_array[index].keyword) + 1) - < PVFS2_MAX_DEBUG_STRING_LEN - 2) { + < ORANGEFS_MAX_DEBUG_STRING_LEN - 2) { strcat(client_debug_string, cdm_array[index].keyword); strcat(client_debug_string, ","); } else { gossip_err("%s: overflow!\n", __func__); - strcpy(client_debug_string, PVFS2_ALL); + strcpy(client_debug_string, ORANGEFS_ALL); goto out; } } @@ -1043,7 +1043,7 @@ int keyword_is_amalgam(char *keyword) { int rc = 0; - if ((!strcmp(keyword, PVFS2_ALL)) || (!strcmp(keyword, PVFS2_VERBOSE))) + if ((!strcmp(keyword, ORANGEFS_ALL)) || (!strcmp(keyword, ORANGEFS_VERBOSE))) rc = 1; return rc; @@ -1067,14 +1067,14 @@ int check_amalgam_keyword(void *mask, int type) if ((c_mask->mask1 == cdm_array[client_all_index].mask1) && (c_mask->mask2 == cdm_array[client_all_index].mask2)) { - strcpy(client_debug_string, PVFS2_ALL); + strcpy(client_debug_string, ORANGEFS_ALL); rc = 1; goto out; } if ((c_mask->mask1 == cdm_array[client_verbose_index].mask1) && (c_mask->mask2 == cdm_array[client_verbose_index].mask2)) { - strcpy(client_debug_string, PVFS2_VERBOSE); + strcpy(client_debug_string, ORANGEFS_VERBOSE); rc = 1; goto out; } @@ -1083,7 +1083,7 @@ int check_amalgam_keyword(void *mask, int type) k_mask = (__u64 *) mask; 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; goto out; } diff --git a/fs/orangefs/super.c b/fs/orangefs/super.c index 45db0772a767..c104de1ae5de 100644 --- a/fs/orangefs/super.c +++ b/fs/orangefs/super.c @@ -10,13 +10,13 @@ #include -/* a cache for pvfs2-inode objects (i.e. pvfs2 inode private data) */ -static struct kmem_cache *pvfs2_inode_cache; +/* a cache for orangefs-inode objects (i.e. orangefs inode private data) */ +static struct kmem_cache *orangefs_inode_cache; -/* list for storing pvfs2 specific superblocks in use */ -LIST_HEAD(pvfs2_superblocks); +/* list for storing orangefs specific superblocks in use */ +LIST_HEAD(orangefs_superblocks); -DEFINE_SPINLOCK(pvfs2_superblocks_lock); +DEFINE_SPINLOCK(orangefs_superblocks_lock); enum { Opt_intr, @@ -37,7 +37,7 @@ static const match_table_t tokens = { static int parse_mount_options(struct super_block *sb, char *options, 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]; char *p; @@ -46,8 +46,8 @@ static int parse_mount_options(struct super_block *sb, char *options, * to zero, ie, initialize to unset. */ sb->s_flags &= ~MS_POSIXACL; - pvfs2_sb->flags &= ~PVFS2_OPT_INTR; - pvfs2_sb->flags &= ~PVFS2_OPT_LOCAL_LOCK; + orangefs_sb->flags &= ~ORANGEFS_OPT_INTR; + orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK; while ((p = strsep(&options, ",")) != NULL) { int token; @@ -61,10 +61,10 @@ static int parse_mount_options(struct super_block *sb, char *options, sb->s_flags |= MS_POSIXACL; break; case Opt_intr: - pvfs2_sb->flags |= PVFS2_OPT_INTR; + orangefs_sb->flags |= ORANGEFS_OPT_INTR; break; case Opt_local_lock: - pvfs2_sb->flags |= PVFS2_OPT_LOCAL_LOCK; + orangefs_sb->flags |= ORANGEFS_OPT_LOCAL_LOCK; break; default: goto fail; @@ -78,24 +78,24 @@ fail: 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); - init_rwsem(&pvfs2_inode->xattr_sem); + inode_init_once(&orangefs_inode->vfs_inode); + 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, - PVFS2_CACHE_ALLOC_FLAGS); - if (pvfs2_inode == NULL) { - gossip_err("Failed to allocate pvfs2_inode\n"); + orangefs_inode = kmem_cache_alloc(orangefs_inode_cache, + ORANGEFS_CACHE_ALLOC_FLAGS); + if (orangefs_inode == NULL) { + gossip_err("Failed to allocate orangefs_inode\n"); 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 * vfs_inode. */ - memset(&pvfs2_inode->refn.khandle, 0, 16); - pvfs2_inode->refn.fs_id = PVFS_FS_ID_NULL; - pvfs2_inode->last_failed_block_index_read = 0; - memset(pvfs2_inode->link_target, 0, sizeof(pvfs2_inode->link_target)); - pvfs2_inode->pinode_flags = 0; + memset(&orangefs_inode->refn.khandle, 0, 16); + orangefs_inode->refn.fs_id = ORANGEFS_FS_ID_NULL; + orangefs_inode->last_failed_block_index_read = 0; + memset(orangefs_inode->link_target, 0, sizeof(orangefs_inode->link_target)); + orangefs_inode->pinode_flags = 0; gossip_debug(GOSSIP_SUPER_DEBUG, - "pvfs2_alloc_inode: allocated %p\n", - &pvfs2_inode->vfs_inode); - return &pvfs2_inode->vfs_inode; + "orangefs_alloc_inode: allocated %p\n", + &orangefs_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, "%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 * 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; - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_kernel_op_s *new_op = NULL; int flags = 0; struct super_block *sb = NULL; sb = dentry->d_sb; 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, - (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) 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) - flags = PVFS2_OP_INTERRUPTIBLE; + if (ORANGEFS_SB(sb)->flags & ORANGEFS_OPT_INTR) + 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) goto out_op_release; gossip_debug(GOSSIP_SUPER_DEBUG, - "pvfs2_statfs: got %ld blocks available | " + "orangefs_statfs: got %ld blocks available | " "%ld blocks total | %ld block size\n", (long)new_op->downcall.resp.statfs.blocks_avail, (long)new_op->downcall.resp.statfs.blocks_total, (long)new_op->downcall.resp.statfs.block_size); 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_namelen = PVFS2_NAME_LEN; + buf->f_namelen = ORANGEFS_NAME_LEN; buf->f_blocks = (sector_t) new_op->downcall.resp.statfs.blocks_total; 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: 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; } @@ -186,9 +186,9 @@ out_op_release: * Remount as initiated by VFS layer. We just need to reparse the mount * 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); } @@ -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. * 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; - 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) return -ENOMEM; - strncpy(new_op->upcall.req.fs_mount.pvfs2_config_server, - PVFS2_SB(sb)->devname, - PVFS_MAX_SERVER_ADDR_LEN); + strncpy(new_op->upcall.req.fs_mount.orangefs_config_server, + ORANGEFS_SB(sb)->devname, + ORANGEFS_MAX_SERVER_ADDR_LEN); gossip_debug(GOSSIP_SUPER_DEBUG, - "Attempting PVFS2 Remount via host %s\n", - new_op->upcall.req.fs_mount.pvfs2_config_server); + "Attempting ORANGEFS Remount via host %s\n", + new_op->upcall.req.fs_mount.orangefs_config_server); /* * we assume that the calling function has already acquire the * request_mutex to prevent other operations from bypassing * this one */ - ret = service_operation(new_op, "pvfs2_remount", - PVFS2_OP_PRIORITY | PVFS2_OP_NO_SEMAPHORE); + ret = service_operation(new_op, "orangefs_remount", + ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_SEMAPHORE); gossip_debug(GOSSIP_SUPER_DEBUG, - "pvfs2_remount: mount got return value of %d\n", + "orangefs_remount: mount got return value of %d\n", ret); if (ret == 0) { /* @@ -241,8 +241,8 @@ int pvfs2_remount(struct super_block *sb) * short-lived mapping that the system interface uses * to map this superblock to a particular mount entry */ - PVFS2_SB(sb)->id = new_op->downcall.resp.fs_mount.id; - PVFS2_SB(sb)->mount_pending = 0; + ORANGEFS_SB(sb)->id = new_op->downcall.resp.fs_mount.id; + ORANGEFS_SB(sb)->mount_pending = 0; } 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 */ -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, - "pvfs2_dirty_inode: %pU\n", + "orangefs_dirty_inode: %pU\n", get_khandle_from_ino(inode)); - SetAtimeFlag(pvfs2_inode); + SetAtimeFlag(orangefs_inode); } -static const struct super_operations pvfs2_s_ops = { - .alloc_inode = pvfs2_alloc_inode, - .destroy_inode = pvfs2_destroy_inode, - .dirty_inode = pvfs2_dirty_inode, +static const struct super_operations orangefs_s_ops = { + .alloc_inode = orangefs_alloc_inode, + .destroy_inode = orangefs_destroy_inode, + .dirty_inode = orangefs_dirty_inode, .drop_inode = generic_delete_inode, - .statfs = pvfs2_statfs, - .remount_fs = pvfs2_remount_fs, + .statfs = orangefs_statfs, + .remount_fs = orangefs_remount_fs, .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, int fh_len, int fh_type) { - struct pvfs2_object_kref refn; + struct orangefs_object_kref refn; if (fh_len < 5 || fh_type > 2) 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]; gossip_debug(GOSSIP_SUPER_DEBUG, "fh_to_dentry: handle %pU, fs_id %d\n", &refn.khandle, 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, int *max_len, struct inode *parent) { int len = parent ? 10 : 5; int type = 1; - struct pvfs2_object_kref refn; + struct orangefs_object_kref refn; if (*max_len < len) { gossip_lerr("fh buffer is too small for encoding\n"); @@ -315,8 +315,8 @@ static int pvfs2_encode_fh(struct inode *inode, goto out; } - refn = PVFS2_I(inode)->refn; - PVFS_khandle_to(&refn.khandle, fh, 16); + refn = ORANGEFS_I(inode)->refn; + ORANGEFS_khandle_to(&refn.khandle, fh, 16); fh[4] = refn.fs_id; gossip_debug(GOSSIP_SUPER_DEBUG, @@ -326,8 +326,8 @@ static int pvfs2_encode_fh(struct inode *inode, if (parent) { - refn = PVFS2_I(parent)->refn; - PVFS_khandle_to(&refn.khandle, (char *) fh + 20, 16); + refn = ORANGEFS_I(parent)->refn; + ORANGEFS_khandle_to(&refn.khandle, (char *) fh + 20, 16); fh[9] = refn.fs_id; type = 2; @@ -342,30 +342,30 @@ out: return type; } -static struct export_operations pvfs2_export_ops = { - .encode_fh = pvfs2_encode_fh, - .fh_to_dentry = pvfs2_fh_to_dentry, +static struct export_operations orangefs_export_ops = { + .encode_fh = orangefs_encode_fh, + .fh_to_dentry = orangefs_fh_to_dentry, }; -static int pvfs2_fill_sb(struct super_block *sb, - struct pvfs2_fs_mount_response *fs_mount, +static int orangefs_fill_sb(struct super_block *sb, + struct orangefs_fs_mount_response *fs_mount, void *data, int silent) { int ret = -EINVAL; struct inode *root = 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 = - kzalloc(sizeof(struct pvfs2_sb_info_s), PVFS2_GFP_FLAGS); - if (!PVFS2_SB(sb)) + kzalloc(sizeof(struct orangefs_sb_info_s), ORANGEFS_GFP_FLAGS); + if (!ORANGEFS_SB(sb)) return -ENOMEM; - PVFS2_SB(sb)->sb = sb; + ORANGEFS_SB(sb)->sb = sb; - PVFS2_SB(sb)->root_khandle = fs_mount->root_khandle; - PVFS2_SB(sb)->fs_id = fs_mount->fs_id; - PVFS2_SB(sb)->id = fs_mount->id; + ORANGEFS_SB(sb)->root_khandle = fs_mount->root_khandle; + ORANGEFS_SB(sb)->fs_id = fs_mount->fs_id; + ORANGEFS_SB(sb)->id = fs_mount->id; if (data) { 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 */ - sb->s_xattr = pvfs2_xattr_handlers; - sb->s_magic = PVFS2_SUPER_MAGIC; - sb->s_op = &pvfs2_s_ops; - sb->s_d_op = &pvfs2_dentry_operations; + sb->s_xattr = orangefs_xattr_handlers; + sb->s_magic = ORANGEFS_SUPER_MAGIC; + sb->s_op = &orangefs_s_ops; + sb->s_d_op = &orangefs_dentry_operations; - sb->s_blocksize = pvfs_bufmap_size_query(); - sb->s_blocksize_bits = pvfs_bufmap_shift_query(); + sb->s_blocksize = orangefs_bufmap_size_query(); + sb->s_blocksize_bits = orangefs_bufmap_shift_query(); sb->s_maxbytes = MAX_LFS_FILESIZE; - root_object.khandle = PVFS2_SB(sb)->root_khandle; - root_object.fs_id = PVFS2_SB(sb)->fs_id; + root_object.khandle = ORANGEFS_SB(sb)->root_khandle; + root_object.fs_id = ORANGEFS_SB(sb)->fs_id; gossip_debug(GOSSIP_SUPER_DEBUG, "get inode %pU, fsid %d\n", &root_object.khandle, root_object.fs_id); - root = pvfs2_iget(sb, &root_object); + root = orangefs_iget(sb, &root_object); if (IS_ERR(root)) return PTR_ERR(root); @@ -404,23 +404,23 @@ static int pvfs2_fill_sb(struct super_block *sb, if (!root_dentry) return -ENOMEM; - sb->s_export_op = &pvfs2_export_ops; + sb->s_export_op = &orangefs_export_ops; sb->s_root = root_dentry; return 0; } -struct dentry *pvfs2_mount(struct file_system_type *fst, +struct dentry *orangefs_mount(struct file_system_type *fst, int flags, const char *devname, void *data) { int ret = -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); gossip_debug(GOSSIP_SUPER_DEBUG, - "pvfs2_mount: called with devname %s\n", + "orangefs_mount: called with devname %s\n", devname); if (!devname) { @@ -428,25 +428,25 @@ struct dentry *pvfs2_mount(struct file_system_type *fst, 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) 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, - PVFS_MAX_SERVER_ADDR_LEN); + ORANGEFS_MAX_SERVER_ADDR_LEN); gossip_debug(GOSSIP_SUPER_DEBUG, - "Attempting PVFS2 Mount via host %s\n", - new_op->upcall.req.fs_mount.pvfs2_config_server); + "Attempting ORANGEFS Mount via host %s\n", + 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, - "pvfs2_mount: mount got return value of %d\n", ret); + "orangefs_mount: mount got return value of %d\n", ret); if (ret) 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"); ret = -EINVAL; goto free_op; @@ -459,7 +459,7 @@ struct dentry *pvfs2_mount(struct file_system_type *fst, goto free_op; } - ret = pvfs2_fill_sb(sb, + ret = orangefs_fill_sb(sb, &new_op->downcall.resp.fs_mount, data, 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 * used */ - strncpy(PVFS2_SB(sb)->devname, + strncpy(ORANGEFS_SB(sb)->devname, devname, - PVFS_MAX_SERVER_ADDR_LEN); + ORANGEFS_MAX_SERVER_ADDR_LEN); /* 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 */ - add_pvfs2_sb(sb); + add_orangefs_sb(sb); op_release(new_op); return dget(sb->s_root); 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) { - 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"); } @@ -499,43 +499,43 @@ free_op: 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 * 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_pvfs2_sb(sb); + /* remove the sb from our list of orangefs specific sb's */ + remove_orangefs_sb(sb); /* provided sb cleanup */ kill_anon_super(sb); - /* free the pvfs2 superblock private data */ - kfree(PVFS2_SB(sb)); + /* free the orangefs superblock private data */ + 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", - sizeof(struct pvfs2_inode_s), + orangefs_inode_cache = kmem_cache_create("orangefs_inode_cache", + sizeof(struct orangefs_inode_s), 0, - PVFS2_CACHE_CREATE_FLAGS, - pvfs2_inode_cache_ctor); + ORANGEFS_CACHE_CREATE_FLAGS, + orangefs_inode_cache_ctor); - if (!pvfs2_inode_cache) { - gossip_err("Cannot create pvfs2_inode_cache\n"); + if (!orangefs_inode_cache) { + gossip_err("Cannot create orangefs_inode_cache\n"); return -ENOMEM; } 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; } diff --git a/fs/orangefs/symlink.c b/fs/orangefs/symlink.c index 2adfceff7730..321f626b190b 100644 --- a/fs/orangefs/symlink.c +++ b/fs/orangefs/symlink.c @@ -8,9 +8,9 @@ #include "pvfs2-kernel.h" #include "pvfs2-bufmap.h" -static const char *pvfs2_follow_link(struct dentry *dentry, void **cookie) +static const char *orangefs_follow_link(struct dentry *dentry, void **cookie) { - char *target = PVFS2_I(dentry->d_inode)->link_target; + char *target = ORANGEFS_I(dentry->d_inode)->link_target; gossip_debug(GOSSIP_INODE_DEBUG, "%s: called on %s (target is %p)\n", @@ -21,11 +21,11 @@ static const char *pvfs2_follow_link(struct dentry *dentry, void **cookie) return target; } -struct inode_operations pvfs2_symlink_inode_operations = { +struct inode_operations orangefs_symlink_inode_operations = { .readlink = generic_readlink, - .follow_link = pvfs2_follow_link, - .setattr = pvfs2_setattr, - .getattr = pvfs2_getattr, - .listxattr = pvfs2_listxattr, + .follow_link = orangefs_follow_link, + .setattr = orangefs_setattr, + .getattr = orangefs_getattr, + .listxattr = orangefs_listxattr, .setxattr = generic_setxattr, }; diff --git a/fs/orangefs/upcall.h b/fs/orangefs/upcall.h index 0805778a8185..781cbc38523a 100644 --- a/fs/orangefs/upcall.h +++ b/fs/orangefs/upcall.h @@ -12,68 +12,68 @@ * 32-64 bit interaction issues between * client-core and device */ -struct pvfs2_io_request_s { +struct orangefs_io_request_s { __s32 async_vfs_io; __s32 buf_index; __s32 count; __s32 __pad1; __s64 offset; - struct pvfs2_object_kref refn; - enum PVFS_io_type io_type; + struct orangefs_object_kref refn; + enum ORANGEFS_io_type io_type; __s32 readahead_size; }; -struct pvfs2_lookup_request_s { +struct orangefs_lookup_request_s { __s32 sym_follow; __s32 __pad1; - struct pvfs2_object_kref parent_refn; - char d_name[PVFS2_NAME_LEN]; + struct orangefs_object_kref parent_refn; + char d_name[ORANGEFS_NAME_LEN]; }; -struct pvfs2_create_request_s { - struct pvfs2_object_kref parent_refn; - struct PVFS_sys_attr_s attributes; - char d_name[PVFS2_NAME_LEN]; +struct orangefs_create_request_s { + struct orangefs_object_kref parent_refn; + struct ORANGEFS_sys_attr_s attributes; + char d_name[ORANGEFS_NAME_LEN]; }; -struct pvfs2_symlink_request_s { - struct pvfs2_object_kref parent_refn; - struct PVFS_sys_attr_s attributes; - char entry_name[PVFS2_NAME_LEN]; - char target[PVFS2_NAME_LEN]; +struct orangefs_symlink_request_s { + struct orangefs_object_kref parent_refn; + struct ORANGEFS_sys_attr_s attributes; + char entry_name[ORANGEFS_NAME_LEN]; + char target[ORANGEFS_NAME_LEN]; }; -struct pvfs2_getattr_request_s { - struct pvfs2_object_kref refn; +struct orangefs_getattr_request_s { + struct orangefs_object_kref refn; __u32 mask; __u32 __pad1; }; -struct pvfs2_setattr_request_s { - struct pvfs2_object_kref refn; - struct PVFS_sys_attr_s attributes; +struct orangefs_setattr_request_s { + struct orangefs_object_kref refn; + struct ORANGEFS_sys_attr_s attributes; }; -struct pvfs2_remove_request_s { - struct pvfs2_object_kref parent_refn; - char d_name[PVFS2_NAME_LEN]; +struct orangefs_remove_request_s { + struct orangefs_object_kref parent_refn; + char d_name[ORANGEFS_NAME_LEN]; }; -struct pvfs2_mkdir_request_s { - struct pvfs2_object_kref parent_refn; - struct PVFS_sys_attr_s attributes; - char d_name[PVFS2_NAME_LEN]; +struct orangefs_mkdir_request_s { + struct orangefs_object_kref parent_refn; + struct ORANGEFS_sys_attr_s attributes; + char d_name[ORANGEFS_NAME_LEN]; }; -struct pvfs2_readdir_request_s { - struct pvfs2_object_kref refn; +struct orangefs_readdir_request_s { + struct orangefs_object_kref refn; __u64 token; __s32 max_dirent_count; __s32 buf_index; }; -struct pvfs2_readdirplus_request_s { - struct pvfs2_object_kref refn; +struct orangefs_readdirplus_request_s { + struct orangefs_object_kref refn; __u64 token; __s32 max_dirent_count; __u32 mask; @@ -81,130 +81,130 @@ struct pvfs2_readdirplus_request_s { __s32 __pad1; }; -struct pvfs2_rename_request_s { - struct pvfs2_object_kref old_parent_refn; - struct pvfs2_object_kref new_parent_refn; - char d_old_name[PVFS2_NAME_LEN]; - char d_new_name[PVFS2_NAME_LEN]; +struct orangefs_rename_request_s { + struct orangefs_object_kref old_parent_refn; + struct orangefs_object_kref new_parent_refn; + char d_old_name[ORANGEFS_NAME_LEN]; + char d_new_name[ORANGEFS_NAME_LEN]; }; -struct pvfs2_statfs_request_s { +struct orangefs_statfs_request_s { __s32 fs_id; __s32 __pad1; }; -struct pvfs2_truncate_request_s { - struct pvfs2_object_kref refn; +struct orangefs_truncate_request_s { + struct orangefs_object_kref refn; __s64 size; }; -struct pvfs2_mmap_ra_cache_flush_request_s { - struct pvfs2_object_kref refn; +struct orangefs_mmap_ra_cache_flush_request_s { + struct orangefs_object_kref refn; }; -struct pvfs2_fs_mount_request_s { - char pvfs2_config_server[PVFS_MAX_SERVER_ADDR_LEN]; +struct orangefs_fs_mount_request_s { + char orangefs_config_server[ORANGEFS_MAX_SERVER_ADDR_LEN]; }; -struct pvfs2_fs_umount_request_s { +struct orangefs_fs_umount_request_s { __s32 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 pvfs2_object_kref refn; +struct orangefs_getxattr_request_s { + struct orangefs_object_kref refn; __s32 key_sz; __s32 __pad1; - char key[PVFS_MAX_XATTR_NAMELEN]; + char key[ORANGEFS_MAX_XATTR_NAMELEN]; }; -struct pvfs2_setxattr_request_s { - struct pvfs2_object_kref refn; - struct PVFS_keyval_pair keyval; +struct orangefs_setxattr_request_s { + struct orangefs_object_kref refn; + struct ORANGEFS_keyval_pair keyval; __s32 flags; __s32 __pad1; }; -struct pvfs2_listxattr_request_s { - struct pvfs2_object_kref refn; +struct orangefs_listxattr_request_s { + struct orangefs_object_kref refn; __s32 requested_count; __s32 __pad1; __u64 token; }; -struct pvfs2_removexattr_request_s { - struct pvfs2_object_kref refn; +struct orangefs_removexattr_request_s { + struct orangefs_object_kref refn; __s32 key_sz; __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; }; -struct pvfs2_fsync_request_s { - struct pvfs2_object_kref refn; +struct orangefs_fsync_request_s { + struct orangefs_object_kref refn; }; -enum pvfs2_param_request_type { - PVFS2_PARAM_REQUEST_SET = 1, - PVFS2_PARAM_REQUEST_GET = 2 +enum orangefs_param_request_type { + ORANGEFS_PARAM_REQUEST_SET = 1, + ORANGEFS_PARAM_REQUEST_GET = 2 }; -enum pvfs2_param_request_op { - PVFS2_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS = 1, - PVFS2_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT = 2, - PVFS2_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT = 3, - PVFS2_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE = 4, - PVFS2_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS = 5, - PVFS2_PARAM_REQUEST_OP_PERF_HISTORY_SIZE = 6, - PVFS2_PARAM_REQUEST_OP_PERF_RESET = 7, - PVFS2_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS = 8, - PVFS2_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT = 9, - PVFS2_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT = 10, - PVFS2_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE = 11, - PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_TIMEOUT_MSECS = 12, - PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_HARD_LIMIT = 13, - PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_SOFT_LIMIT = 14, - PVFS2_PARAM_REQUEST_OP_STATIC_ACACHE_RECLAIM_PERCENTAGE = 15, - PVFS2_PARAM_REQUEST_OP_CLIENT_DEBUG = 16, - PVFS2_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS = 17, - PVFS2_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT = 18, - PVFS2_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT = 19, - PVFS2_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE = 20, - PVFS2_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS = 21, - PVFS2_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT = 22, - PVFS2_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT = 23, - PVFS2_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE = 24, - PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES = 25, +enum orangefs_param_request_op { + ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS = 1, + ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT = 2, + ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT = 3, + ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE = 4, + ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS = 5, + ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE = 6, + ORANGEFS_PARAM_REQUEST_OP_PERF_RESET = 7, + ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS = 8, + ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT = 9, + ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT = 10, + ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE = 11, + ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_TIMEOUT_MSECS = 12, + ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_HARD_LIMIT = 13, + ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_SOFT_LIMIT = 14, + ORANGEFS_PARAM_REQUEST_OP_STATIC_ACACHE_RECLAIM_PERCENTAGE = 15, + ORANGEFS_PARAM_REQUEST_OP_CLIENT_DEBUG = 16, + ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS = 17, + ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT = 18, + ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT = 19, + ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE = 20, + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS = 21, + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT = 22, + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT = 23, + ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE = 24, + ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES = 25, }; -struct pvfs2_param_request_s { - enum pvfs2_param_request_type type; - enum pvfs2_param_request_op op; +struct orangefs_param_request_s { + enum orangefs_param_request_type type; + enum orangefs_param_request_op op; __s64 value; - char s_value[PVFS2_MAX_DEBUG_STRING_LEN]; + char s_value[ORANGEFS_MAX_DEBUG_STRING_LEN]; }; -enum pvfs2_perf_count_request_type { - PVFS2_PERF_COUNT_REQUEST_ACACHE = 1, - PVFS2_PERF_COUNT_REQUEST_NCACHE = 2, - PVFS2_PERF_COUNT_REQUEST_CAPCACHE = 3, +enum orangefs_perf_count_request_type { + ORANGEFS_PERF_COUNT_REQUEST_ACACHE = 1, + ORANGEFS_PERF_COUNT_REQUEST_NCACHE = 2, + ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE = 3, }; -struct pvfs2_perf_count_request_s { - enum pvfs2_perf_count_request_type type; +struct orangefs_perf_count_request_s { + enum orangefs_perf_count_request_type type; __s32 __pad1; }; -struct pvfs2_fs_key_request_s { +struct orangefs_fs_key_request_s { __s32 fsid; __s32 __pad1; }; -struct pvfs2_upcall_s { +struct orangefs_upcall_s { __s32 type; __u32 uid; __u32 gid; @@ -215,31 +215,31 @@ struct pvfs2_upcall_s { char *trailer_buf; union { - struct pvfs2_io_request_s io; - struct pvfs2_lookup_request_s lookup; - struct pvfs2_create_request_s create; - struct pvfs2_symlink_request_s sym; - struct pvfs2_getattr_request_s getattr; - struct pvfs2_setattr_request_s setattr; - struct pvfs2_remove_request_s remove; - struct pvfs2_mkdir_request_s mkdir; - struct pvfs2_readdir_request_s readdir; - struct pvfs2_readdirplus_request_s readdirplus; - struct pvfs2_rename_request_s rename; - struct pvfs2_statfs_request_s statfs; - struct pvfs2_truncate_request_s truncate; - struct pvfs2_mmap_ra_cache_flush_request_s ra_cache_flush; - struct pvfs2_fs_mount_request_s fs_mount; - struct pvfs2_fs_umount_request_s fs_umount; - struct pvfs2_getxattr_request_s getxattr; - struct pvfs2_setxattr_request_s setxattr; - struct pvfs2_listxattr_request_s listxattr; - struct pvfs2_removexattr_request_s removexattr; - struct pvfs2_op_cancel_s cancel; - struct pvfs2_fsync_request_s fsync; - struct pvfs2_param_request_s param; - struct pvfs2_perf_count_request_s perf_count; - struct pvfs2_fs_key_request_s fs_key; + struct orangefs_io_request_s io; + struct orangefs_lookup_request_s lookup; + struct orangefs_create_request_s create; + struct orangefs_symlink_request_s sym; + struct orangefs_getattr_request_s getattr; + struct orangefs_setattr_request_s setattr; + struct orangefs_remove_request_s remove; + struct orangefs_mkdir_request_s mkdir; + struct orangefs_readdir_request_s readdir; + struct orangefs_readdirplus_request_s readdirplus; + struct orangefs_rename_request_s rename; + struct orangefs_statfs_request_s statfs; + struct orangefs_truncate_request_s truncate; + struct orangefs_mmap_ra_cache_flush_request_s ra_cache_flush; + struct orangefs_fs_mount_request_s fs_mount; + struct orangefs_fs_umount_request_s fs_umount; + struct orangefs_getxattr_request_s getxattr; + struct orangefs_setxattr_request_s setxattr; + struct orangefs_listxattr_request_s listxattr; + struct orangefs_removexattr_request_s removexattr; + struct orangefs_op_cancel_s cancel; + struct orangefs_fsync_request_s fsync; + struct orangefs_param_request_s param; + struct orangefs_perf_count_request_s perf_count; + struct orangefs_fs_key_request_s fs_key; } req; }; diff --git a/fs/orangefs/waitqueue.c b/fs/orangefs/waitqueue.c index d7b0eba043ab..cfc8dc59c4eb 100644 --- a/fs/orangefs/waitqueue.c +++ b/fs/orangefs/waitqueue.c @@ -25,10 +25,10 @@ */ void purge_waiting_ops(void) { - struct pvfs2_kernel_op_s *op; + struct orangefs_kernel_op_s *op; - spin_lock(&pvfs2_request_list_lock); - list_for_each_entry(op, &pvfs2_request_list, list) { + spin_lock(&orangefs_request_list_lock); + list_for_each_entry(op, &orangefs_request_list, list) { gossip_debug(GOSSIP_WAIT_DEBUG, "pvfs2-client-core: purging op tag %llu %s\n", llu(op->tag), @@ -38,11 +38,11 @@ void purge_waiting_ops(void) spin_unlock(&op->lock); 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 * 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 */ -int service_operation(struct pvfs2_kernel_op_s *op, +int service_operation(struct orangefs_kernel_op_s *op, const char *op_name, int flags) { @@ -70,30 +70,30 @@ int service_operation(struct pvfs2_kernel_op_s *op, retry_servicing: op->downcall.status = 0; gossip_debug(GOSSIP_WAIT_DEBUG, - "pvfs2: service_operation: %s %p\n", + "orangefs: service_operation: %s %p\n", op_name, op); 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->pid); /* 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); - if (!(flags & PVFS2_OP_NO_SEMAPHORE)) { + if (!(flags & ORANGEFS_OP_NO_SEMAPHORE)) { ret = mutex_lock_interruptible(&request_mutex); /* * check to see if we were interrupted while waiting for * semaphore */ if (ret < 0) { - if (!(flags & PVFS2_OP_INTERRUPTIBLE)) + if (!(flags & ORANGEFS_OP_INTERRUPTIBLE)) set_signals(&orig_sigset); op->downcall.status = ret; gossip_debug(GOSSIP_WAIT_DEBUG, - "pvfs2: service_operation interrupted.\n"); + "orangefs: service_operation interrupted.\n"); return ret; } } @@ -116,7 +116,7 @@ retry_servicing: } /* queue up the operation */ - if (flags & PVFS2_OP_PRIORITY) { + if (flags & ORANGEFS_OP_PRIORITY) { add_priority_op_to_request_list(op); } else { gossip_debug(GOSSIP_WAIT_DEBUG, @@ -125,17 +125,17 @@ retry_servicing: add_op_to_request_list(op); } - if (!(flags & PVFS2_OP_NO_SEMAPHORE)) + if (!(flags & ORANGEFS_OP_NO_SEMAPHORE)) mutex_unlock(&request_mutex); /* * If we are asked to service an asynchronous operation from * VFS perspective, we are done. */ - if (flags & PVFS2_OP_ASYNC) + if (flags & ORANGEFS_OP_ASYNC) return 0; - if (flags & PVFS2_OP_CANCELLATION) { + if (flags & ORANGEFS_OP_CANCELLATION) { gossip_debug(GOSSIP_WAIT_DEBUG, "%s:" "About to call wait_for_cancellation_downcall.\n", @@ -148,25 +148,25 @@ retry_servicing: if (ret < 0) { /* failed to get matching downcall */ 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->downcall.status = ret; } else { /* got matching downcall; make sure status is in errno format */ op->downcall.status = - pvfs2_normalize_to_errno(op->downcall.status); + orangefs_normalize_to_errno(op->downcall.status); ret = op->downcall.status; } - if (!(flags & PVFS2_OP_INTERRUPTIBLE)) + if (!(flags & ORANGEFS_OP_INTERRUPTIBLE)) set_signals(&orig_sigset); BUG_ON(ret != op->downcall.status); /* retry if operation has not been serviced and if requested */ if (!op_state_serviced(op) && op->downcall.status == -EAGAIN) { gossip_debug(GOSSIP_WAIT_DEBUG, - "pvfs2: tag %llu (%s)" + "orangefs: tag %llu (%s)" " -- operation to be retried (%d attempt)\n", llu(op->tag), op_name, @@ -204,17 +204,17 @@ retry_servicing: * memory system can be initialized. */ 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); 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. */ ret = schedule_timeout(MSECS_TO_JIFFIES - (1000 * PVFS2_BUFMAP_WAIT_TIMEOUT_SECS)); + (1000 * ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS)); gossip_debug(GOSSIP_WAIT_DEBUG, "Value returned from schedule_timeout:" @@ -225,14 +225,14 @@ retry_servicing: get_bufmap_init()); spin_lock_irqsave(&op->lock, irqflags); - remove_wait_queue(&pvfs2_bufmap_init_waitq, + remove_wait_queue(&orangefs_bufmap_init_waitq, &wait_entry); spin_unlock_irqrestore(&op->lock, irqflags); 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", __func__, - PVFS2_BUFMAP_WAIT_TIMEOUT_SECS, + ORANGEFS_BUFMAP_WAIT_TIMEOUT_SECS, get_opname_string(op)); return -EIO; } @@ -246,14 +246,14 @@ retry_servicing: } 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, ret, op); 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 @@ -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 * 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; DECLARE_WAITQUEUE(wait_entry, current); @@ -386,7 +386,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op) op, op->attempts); ret = -ETIMEDOUT; - pvfs2_clean_up_interrupted_operation + orangefs_clean_up_interrupted_operation (op); break; } @@ -403,7 +403,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op) * core starts, and so on... */ if (op_state_purged(op)) { - ret = (op->attempts < PVFS2_PURGE_RETRY_COUNT) ? + ret = (op->attempts < ORANGEFS_PURGE_RETRY_COUNT) ? -EAGAIN : -EIO; spin_unlock(&op->lock); @@ -415,7 +415,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op) llu(op->tag), op, op->attempts); - pvfs2_clean_up_interrupted_operation(op); + orangefs_clean_up_interrupted_operation(op); break; } spin_unlock(&op->lock); @@ -429,7 +429,7 @@ int wait_for_matching_downcall(struct pvfs2_kernel_op_s *op) __func__, llu(op->tag), op); - pvfs2_clean_up_interrupted_operation(op); + orangefs_clean_up_interrupted_operation(op); ret = -EINTR; 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 * 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; DECLARE_WAITQUEUE(wait_entry, current); @@ -482,7 +482,7 @@ int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op) __func__, llu(op->tag), op); - pvfs2_clean_up_interrupted_operation(op); + orangefs_clean_up_interrupted_operation(op); ret = -EINTR; break; } @@ -502,7 +502,7 @@ int wait_for_cancellation_downcall(struct pvfs2_kernel_op_s *op) "%s:*** operation timed out: %p\n", __func__, op); - pvfs2_clean_up_interrupted_operation(op); + orangefs_clean_up_interrupted_operation(op); ret = -ETIMEDOUT; break; } diff --git a/fs/orangefs/xattr.c b/fs/orangefs/xattr.c index b683daab7425..aeb3c3083591 100644 --- a/fs/orangefs/xattr.c +++ b/fs/orangefs/xattr.c @@ -15,8 +15,8 @@ #include -#define SYSTEM_PVFS2_KEY "system.pvfs2." -#define SYSTEM_PVFS2_KEY_LEN 13 +#define SYSTEM_ORANGEFS_KEY "system.pvfs2." +#define SYSTEM_ORANGEFS_KEY_LEN 13 /* * this function returns @@ -24,15 +24,15 @@ * of a listxattr. * 1 if the key corresponding to name is meant to be returned as part of * 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) { - if (size < SYSTEM_PVFS2_KEY_LEN) + if (size < SYSTEM_ORANGEFS_KEY_LEN) 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) @@ -41,10 +41,10 @@ static inline int convert_to_internal_xattr_flags(int setxattr_flags) if (setxattr_flags & XATTR_REPLACE) { /* Attribute must exist! */ - internal_flag = PVFS_XATTR_REPLACE; + internal_flag = ORANGEFS_XATTR_REPLACE; } else if (setxattr_flags & XATTR_CREATE) { /* Attribute must not exist */ - internal_flag = PVFS_XATTR_CREATE; + internal_flag = ORANGEFS_XATTR_CREATE; } 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 * 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) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op = NULL; ssize_t ret = -ENOMEM; ssize_t length = 0; int fsuid; @@ -74,10 +74,10 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix, __func__, prefix, name, size); 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; } - 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", (int)(strlen(name) + strlen(prefix))); return -EINVAL; @@ -94,15 +94,15 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix, fsuid, 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) 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, - 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 @@ -111,13 +111,13 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix, */ 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)); if (ret != 0) { if (ret == -ENOENT) { ret = -ENODATA; gossip_debug(GOSSIP_XATTR_DEBUG, - "pvfs2_inode_getxattr: inode %pU key %s" + "orangefs_inode_getxattr: inode %pU key %s" " does not exist!\n", get_khandle_from_ino(inode), (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); memcpy(buffer, new_op->downcall.resp.getxattr.val, length); gossip_debug(GOSSIP_XATTR_DEBUG, - "pvfs2_inode_getxattr: inode %pU " + "orangefs_inode_getxattr: inode %pU " "key %s key_sz %d, val_len %d\n", get_khandle_from_ino(inode), (char *)new_op-> @@ -163,44 +163,44 @@ ssize_t pvfs2_inode_getxattr(struct inode *inode, const char *prefix, out_release_op: op_release(new_op); out_unlock: - up_read(&pvfs2_inode->xattr_sem); + up_read(&orangefs_inode->xattr_sem); return ret; } -static int pvfs2_inode_removexattr(struct inode *inode, +static int orangefs_inode_removexattr(struct inode *inode, const char *prefix, const char *name, int flags) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_kernel_op_s *new_op = NULL; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op = NULL; int ret = -ENOMEM; - down_write(&pvfs2_inode->xattr_sem); - new_op = op_alloc(PVFS2_VFS_OP_REMOVEXATTR); + down_write(&orangefs_inode->xattr_sem); + new_op = op_alloc(ORANGEFS_VFS_OP_REMOVEXATTR); if (!new_op) 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 * textual strings, I am going to explicitly pass the * length just in case we change this later on... */ ret = snprintf((char *)new_op->upcall.req.removexattr.key, - PVFS_MAX_XATTR_NAMELEN, + ORANGEFS_MAX_XATTR_NAMELEN, "%s%s", (prefix ? prefix : ""), name); new_op->upcall.req.removexattr.key_sz = ret + 1; 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, (int)new_op->upcall.req.removexattr.key_sz); ret = service_operation(new_op, - "pvfs2_inode_removexattr", + "orangefs_inode_removexattr", get_interruptible_flag(inode)); if (ret == -ENOENT) { /* @@ -213,11 +213,11 @@ static int pvfs2_inode_removexattr(struct inode *inode, } gossip_debug(GOSSIP_XATTR_DEBUG, - "pvfs2_inode_removexattr: returning %d\n", ret); + "orangefs_inode_removexattr: returning %d\n", ret); op_release(new_op); out_unlock: - up_write(&pvfs2_inode->xattr_sem); + up_write(&orangefs_inode->xattr_sem); return ret; } @@ -227,11 +227,11 @@ out_unlock: * Returns a -ve number on error and 0 on success. Key is text, but value * 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) { - struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_kernel_op_s *new_op; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op; int internal_flag = 0; int ret = -ENOMEM; @@ -240,9 +240,9 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix, __func__, prefix, name, size); if (size < 0 || - size >= PVFS_MAX_XATTR_VALUELEN || + size >= ORANGEFS_MAX_XATTR_VALUELEN || 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, flags); return -EINVAL; @@ -250,23 +250,23 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix, if (name == 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; } internal_flag = convert_to_internal_xattr_flags(flags); if (prefix) { - if (strlen(name) + strlen(prefix) >= PVFS_MAX_XATTR_NAMELEN) { + if (strlen(name) + strlen(prefix) >= ORANGEFS_MAX_XATTR_NAMELEN) { gossip_err - ("pvfs2_inode_setxattr: bogus key size (%d)\n", + ("orangefs_inode_setxattr: bogus key size (%d)\n", (int)(strlen(name) + strlen(prefix))); return -EINVAL; } } else { - if (strlen(name) >= PVFS_MAX_XATTR_NAMELEN) { + if (strlen(name) >= ORANGEFS_MAX_XATTR_NAMELEN) { gossip_err - ("pvfs2_inode_setxattr: bogus key size (%d)\n", + ("orangefs_inode_setxattr: bogus key size (%d)\n", (int)(strlen(name))); return -EINVAL; } @@ -278,7 +278,7 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix, "removing xattr (%s%s)\n", prefix, name); - return pvfs2_inode_removexattr(inode, prefix, name, flags); + return orangefs_inode_removexattr(inode, prefix, name, flags); } gossip_debug(GOSSIP_XATTR_DEBUG, @@ -286,13 +286,13 @@ int pvfs2_inode_setxattr(struct inode *inode, const char *prefix, get_khandle_from_ino(inode), name); - down_write(&pvfs2_inode->xattr_sem); - new_op = op_alloc(PVFS2_VFS_OP_SETXATTR); + down_write(&orangefs_inode->xattr_sem); + new_op = op_alloc(ORANGEFS_VFS_OP_SETXATTR); if (!new_op) 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; /* * 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... */ ret = snprintf((char *)new_op->upcall.req.setxattr.keyval.key, - PVFS_MAX_XATTR_NAMELEN, + ORANGEFS_MAX_XATTR_NAMELEN, "%s%s", prefix, name); 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; 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", (char *)new_op->upcall.req.setxattr.keyval.key, (int)new_op->upcall.req.setxattr.keyval.key_sz, size); ret = service_operation(new_op, - "pvfs2_inode_setxattr", + "orangefs_inode_setxattr", get_interruptible_flag(inode)); gossip_debug(GOSSIP_XATTR_DEBUG, - "pvfs2_inode_setxattr: returning %d\n", + "orangefs_inode_setxattr: returning %d\n", ret); /* when request is serviced properly, free req op struct */ op_release(new_op); out_unlock: - up_write(&pvfs2_inode->xattr_sem); + up_write(&orangefs_inode->xattr_sem); return ret; } @@ -336,12 +336,12 @@ out_unlock: * subsequent memory allocations. Thus our return value is always the size of * 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 pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode); - struct pvfs2_kernel_op_s *new_op; - __u64 token = PVFS_ITERATE_START; + struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); + struct orangefs_kernel_op_s *new_op; + __u64 token = ORANGEFS_ITERATE_START; ssize_t ret = -ENOMEM; ssize_t total = 0; ssize_t length = 0; @@ -358,8 +358,8 @@ ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size) return -EINVAL; } - down_read(&pvfs2_inode->xattr_sem); - new_op = op_alloc(PVFS2_VFS_OP_LISTXATTR); + down_read(&orangefs_inode->xattr_sem); + new_op = op_alloc(ORANGEFS_VFS_OP_LISTXATTR); if (!new_op) goto out_unlock; @@ -368,10 +368,10 @@ ssize_t pvfs2_listxattr(struct dentry *dentry, char *buffer, size_t size) try_again: 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.requested_count = - (size == 0) ? 0 : PVFS_MAX_XATTR_LISTLEN; + (size == 0) ? 0 : ORANGEFS_MAX_XATTR_LISTLEN; ret = service_operation(new_op, __func__, get_interruptible_flag(inode)); if (ret != 0) @@ -384,7 +384,7 @@ try_again: * up allocating memory rather than us... */ total = new_op->downcall.resp.listxattr.returned_count * - PVFS_MAX_XATTR_NAMELEN; + ORANGEFS_MAX_XATTR_NAMELEN; goto done; } @@ -429,7 +429,7 @@ try_again: * fetching more keys! */ token = new_op->downcall.resp.listxattr.token; - if (token != PVFS_ITERATE_END) + if (token != ORANGEFS_ITERATE_END) goto try_again; done: @@ -443,88 +443,88 @@ done: if (ret == 0) ret = total; out_unlock: - up_read(&pvfs2_inode->xattr_sem); + up_read(&orangefs_inode->xattr_sem); return ret; } -static int pvfs2_xattr_set_default(const struct xattr_handler *handler, - struct dentry *dentry, - const char *name, - const void *buffer, - size_t size, - int flags) +static int orangefs_xattr_set_default(const struct xattr_handler *handler, + struct dentry *dentry, + const char *name, + const void *buffer, + size_t size, + int flags) { - return pvfs2_inode_setxattr(dentry->d_inode, - PVFS2_XATTR_NAME_DEFAULT_PREFIX, + return orangefs_inode_setxattr(dentry->d_inode, + ORANGEFS_XATTR_NAME_DEFAULT_PREFIX, name, buffer, size, flags); } -static int pvfs2_xattr_get_default(const struct xattr_handler *handler, - struct dentry *dentry, - const char *name, - void *buffer, - size_t size) +static int orangefs_xattr_get_default(const struct xattr_handler *handler, + struct dentry *dentry, + const char *name, + void *buffer, + size_t size) { - return pvfs2_inode_getxattr(dentry->d_inode, - PVFS2_XATTR_NAME_DEFAULT_PREFIX, + return orangefs_inode_getxattr(dentry->d_inode, + ORANGEFS_XATTR_NAME_DEFAULT_PREFIX, name, buffer, size); } -static int pvfs2_xattr_set_trusted(const struct xattr_handler *handler, - struct dentry *dentry, - const char *name, - const void *buffer, - size_t size, - int flags) +static int orangefs_xattr_set_trusted(const struct xattr_handler *handler, + struct dentry *dentry, + const char *name, + const void *buffer, + size_t size, + int flags) { - return pvfs2_inode_setxattr(dentry->d_inode, - PVFS2_XATTR_NAME_TRUSTED_PREFIX, + return orangefs_inode_setxattr(dentry->d_inode, + ORANGEFS_XATTR_NAME_TRUSTED_PREFIX, name, buffer, size, flags); } -static int pvfs2_xattr_get_trusted(const struct xattr_handler *handler, - struct dentry *dentry, - const char *name, - void *buffer, - size_t size) +static int orangefs_xattr_get_trusted(const struct xattr_handler *handler, + struct dentry *dentry, + const char *name, + void *buffer, + size_t size) { - return pvfs2_inode_getxattr(dentry->d_inode, - PVFS2_XATTR_NAME_TRUSTED_PREFIX, + return orangefs_inode_getxattr(dentry->d_inode, + ORANGEFS_XATTR_NAME_TRUSTED_PREFIX, name, buffer, size); } -static struct xattr_handler pvfs2_xattr_trusted_handler = { - .prefix = PVFS2_XATTR_NAME_TRUSTED_PREFIX, - .get = pvfs2_xattr_get_trusted, - .set = pvfs2_xattr_set_trusted, +static struct xattr_handler orangefs_xattr_trusted_handler = { + .prefix = ORANGEFS_XATTR_NAME_TRUSTED_PREFIX, + .get = orangefs_xattr_get_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. * so that all un-prefixed xattrs keys get caught * here! */ - .prefix = PVFS2_XATTR_NAME_DEFAULT_PREFIX, - .get = pvfs2_xattr_get_default, - .set = pvfs2_xattr_set_default, + .prefix = ORANGEFS_XATTR_NAME_DEFAULT_PREFIX, + .get = orangefs_xattr_get_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_default_xattr_handler, - &pvfs2_xattr_trusted_handler, - &pvfs2_xattr_default_handler, + &orangefs_xattr_trusted_handler, + &orangefs_xattr_default_handler, NULL };