Skip to content

C
clone-Linux

gsplhtlxg / clone-Linux

通知 2
Star 0
Fork 1
C
clone-Linux

体验新版 GitCode，发现更多精彩内容 >>

提交 8bb8aefd 编写于 作者: Y Yi Liu 提交者： Mike Marshall
浏览文件
操作

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: NYi Liu <yi9@clemson.edu>
[martin@omnibond.com: clairify above constraints and merge]
Signed-off-by: NMartin Brandenburg <martin@omnibond.com>
Signed-off-by: NMike Marshall <hubcap@omnibond.com>
上级 555fa0fa
展开全部 隐藏空白更改
内联 并排
Showing with 1785 addition and 1785 deletion
fs/orangefs/acl.c
浏览文件 @ 8bb8aefd
......@@ -10,7 +10,7 @@
#include <linux/posix_acl_xattr.h>
#include <linux/fs_struct.h>
struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
struct posix_acl *orangefs_get_acl(struct inode *inode, int type)
{
struct posix_acl *acl;
int ret;
......@@ -18,23 +18,23 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
switch (type) {
case ACL_TYPE_ACCESS:
key = PVFS2_XATTR_NAME_ACL_ACCESS;
key = ORANGEFS_XATTR_NAME_ACL_ACCESS;
break;
case ACL_TYPE_DEFAULT:
key = PVFS2_XATTR_NAME_ACL_DEFAULT;
key = ORANGEFS_XATTR_NAME_ACL_DEFAULT;
break;
default:
gossip_err("pvfs2_get_acl: bogus value of type %d\n", type);
gossip_err("orangefs_get_acl: bogus value of type %d\n", type);
return ERR_PTR(-EINVAL);
}
/*
* Rather than incurring a network call just to determine the exact
* length of the attribute, I just allocate a max length to save on
* the network call. Conceivably, we could pass NULL to
* pvfs2_inode_getxattr() to probe the length of the value, but
* orangefs_inode_getxattr() to probe the length of the value, but
* I don't do that for now.
*/
value = kmalloc(PVFS_MAX_XATTR_VALUELEN, GFP_KERNEL);
value = kmalloc(ORANGEFS_MAX_XATTR_VALUELEN, GFP_KERNEL);
if (value == NULL)
return ERR_PTR(-ENOMEM);
......@@ -43,11 +43,11 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
get_khandle_from_ino(inode),
key,
type);
ret = pvfs2_inode_getxattr(inode,
ret = orangefs_inode_getxattr(inode,
"",
key,
value,
PVFS_MAX_XATTR_VALUELEN);
ORANGEFS_MAX_XATTR_VALUELEN);
/* if the key exists, convert it to an in-memory rep */
if (ret > 0) {
acl = posix_acl_from_xattr(&init_user_ns, value, ret);
......@@ -64,9 +64,9 @@ struct posix_acl *pvfs2_get_acl(struct inode *inode, int type)
return acl;
}
int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
int orangefs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
{
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode);
struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
int error = 0;
void *value = NULL;
size_t size = 0;
......@@ -74,7 +74,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
switch (type) {
case ACL_TYPE_ACCESS:
name = PVFS2_XATTR_NAME_ACL_ACCESS;
name = ORANGEFS_XATTR_NAME_ACL_ACCESS;
if (acl) {
umode_t mode = inode->i_mode;
/*
......@@ -90,7 +90,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
}
if (inode->i_mode != mode)
SetModeFlag(pvfs2_inode);
SetModeFlag(orangefs_inode);
inode->i_mode = mode;
mark_inode_dirty_sync(inode);
if (error == 0)
......@@ -98,7 +98,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
}
break;
case ACL_TYPE_DEFAULT:
name = PVFS2_XATTR_NAME_ACL_DEFAULT;
name = ORANGEFS_XATTR_NAME_ACL_DEFAULT;
break;
default:
gossip_err("%s: invalid type %d!\n", __func__, type);
......@@ -131,7 +131,7 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
* will xlate to a removexattr. However, we don't want removexattr
* complain if attributes does not exist.
*/
error = pvfs2_inode_setxattr(inode, "", name, value, size, 0);
error = orangefs_inode_setxattr(inode, "", name, value, size, 0);
out:
kfree(value);
......@@ -140,35 +140,35 @@ int pvfs2_set_acl(struct inode *inode, struct posix_acl *acl, int type)
return error;
}
int pvfs2_init_acl(struct inode *inode, struct inode *dir)
int orangefs_init_acl(struct inode *inode, struct inode *dir)
{
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(inode);
struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
struct posix_acl *default_acl, *acl;
umode_t mode = inode->i_mode;
int error = 0;
ClearModeFlag(pvfs2_inode);
ClearModeFlag(orangefs_inode);
error = posix_acl_create(dir, &mode, &default_acl, &acl);
if (error)
return error;
if (default_acl) {
error = pvfs2_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
error = orangefs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
posix_acl_release(default_acl);
}
if (acl) {
if (!error)
error = pvfs2_set_acl(inode, acl, ACL_TYPE_ACCESS);
error = orangefs_set_acl(inode, acl, ACL_TYPE_ACCESS);
posix_acl_release(acl);
}
/* If mode of the inode was changed, then do a forcible ->setattr */
if (mode != inode->i_mode) {
SetModeFlag(pvfs2_inode);
SetModeFlag(orangefs_inode);
inode->i_mode = mode;
pvfs2_flush_inode(inode);
orangefs_flush_inode(inode);
}
return error;
......
fs/orangefs/dcache.c
浏览文件 @ 8bb8aefd
......@@ -12,27 +12,27 @@
#include "pvfs2-kernel.h"
/* Returns 1 if dentry can still be trusted, else 0. */
static int pvfs2_revalidate_lookup(struct dentry *dentry)
static int orangefs_revalidate_lookup(struct dentry *dentry)
{
struct dentry *parent_dentry = dget_parent(dentry);
struct inode *parent_inode = parent_dentry->d_inode;
struct pvfs2_inode_s *parent = PVFS2_I(parent_inode);
struct orangefs_inode_s *parent = ORANGEFS_I(parent_inode);
struct inode *inode = dentry->d_inode;
struct pvfs2_kernel_op_s *new_op;
struct orangefs_kernel_op_s *new_op;
int ret = 0;
int err = 0;
gossip_debug(GOSSIP_DCACHE_DEBUG, "%s: attempting lookup.\n", __func__);
new_op = op_alloc(PVFS2_VFS_OP_LOOKUP);
new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP);
if (!new_op)
goto out_put_parent;
new_op->upcall.req.lookup.sym_follow = PVFS2_LOOKUP_LINK_NO_FOLLOW;
new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW;
new_op->upcall.req.lookup.parent_refn = parent->refn;
strncpy(new_op->upcall.req.lookup.d_name,
dentry->d_name.name,
PVFS2_NAME_LEN);
ORANGEFS_NAME_LEN);
gossip_debug(GOSSIP_DCACHE_DEBUG,
"%s:%s:%d interrupt flag [%d]\n",
......@@ -41,7 +41,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry)
__LINE__,
get_interruptible_flag(parent_inode));
err = service_operation(new_op, "pvfs2_lookup",
err = service_operation(new_op, "orangefs_lookup",
get_interruptible_flag(parent_inode));
if (err)
goto out_drop;
......@@ -79,7 +79,7 @@ static int pvfs2_revalidate_lookup(struct dentry *dentry)
*
* Should return 1 if dentry can still be trusted, else 0
*/
static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)
static int orangefs_d_revalidate(struct dentry *dentry, unsigned int flags)
{
struct inode *inode;
int ret = 0;
......@@ -105,7 +105,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)
* exists, but is still in the expected place in the name space
*/
if (!is_root_handle(inode)) {
if (!pvfs2_revalidate_lookup(dentry))
if (!orangefs_revalidate_lookup(dentry))
goto invalid_exit;
} else {
gossip_debug(GOSSIP_DCACHE_DEBUG,
......@@ -119,7 +119,7 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)
__func__,
inode,
get_khandle_from_ino(inode));
ret = pvfs2_inode_getattr(inode, PVFS_ATTR_SYS_ALL_NOHINT);
ret = orangefs_inode_getattr(inode, ORANGEFS_ATTR_SYS_ALL_NOHINT);
gossip_debug(GOSSIP_DCACHE_DEBUG,
"%s: getattr %s (ret = %d), returning %s for dentry i_count=%d\n",
__func__,
......@@ -137,6 +137,6 @@ static int pvfs2_d_revalidate(struct dentry *dentry, unsigned int flags)
return 0;
}
const struct dentry_operations pvfs2_dentry_operations = {
.d_revalidate = pvfs2_d_revalidate,
const struct dentry_operations orangefs_dentry_operations = {
.d_revalidate = orangefs_d_revalidate,
};
fs/orangefs/devpvfs2-req.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/dir.c
浏览文件 @ 8bb8aefd
......@@ -10,7 +10,7 @@
struct readdir_handle_s {
int buffer_index;
struct pvfs2_readdir_response_s readdir_response;
struct orangefs_readdir_response_s readdir_response;
void *dents_buf;
};
......@@ -18,28 +18,28 @@ struct readdir_handle_s {
* decode routine needed by kmod to make sense of the shared page for readdirs.
*/
static long decode_dirents(char *ptr, size_t size,
struct pvfs2_readdir_response_s *readdir)
struct orangefs_readdir_response_s *readdir)
{
int i;
struct pvfs2_readdir_response_s *rd =
(struct pvfs2_readdir_response_s *) ptr;
struct orangefs_readdir_response_s *rd =
(struct orangefs_readdir_response_s *) ptr;
char *buf = ptr;
if (size < offsetof(struct pvfs2_readdir_response_s, dirent_array))
if (size < offsetof(struct orangefs_readdir_response_s, dirent_array))
return -EINVAL;
readdir->token = rd->token;
readdir->pvfs_dirent_outcount = rd->pvfs_dirent_outcount;
readdir->dirent_array = kcalloc(readdir->pvfs_dirent_outcount,
readdir->orangefs_dirent_outcount = rd->orangefs_dirent_outcount;
readdir->dirent_array = kcalloc(readdir->orangefs_dirent_outcount,
sizeof(*readdir->dirent_array),
GFP_KERNEL);
if (readdir->dirent_array == NULL)
return -ENOMEM;
buf += offsetof(struct pvfs2_readdir_response_s, dirent_array);
size -= offsetof(struct pvfs2_readdir_response_s, dirent_array);
buf += offsetof(struct orangefs_readdir_response_s, dirent_array);
size -= offsetof(struct orangefs_readdir_response_s, dirent_array);
for (i = 0; i < readdir->pvfs_dirent_outcount; i++) {
for (i = 0; i < readdir->orangefs_dirent_outcount; i++) {
__u32 len;
if (size < 4)
......@@ -60,7 +60,7 @@ static long decode_dirents(char *ptr, size_t size,
buf += len;
readdir->dirent_array[i].khandle =
*(struct pvfs2_khandle *) buf;
*(struct orangefs_khandle *) buf;
buf += 16;
}
return buf - ptr;
......@@ -98,7 +98,7 @@ static long readdir_handle_ctor(struct readdir_handle_s *rhandle, void *buf,
return ret;
}
static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap,
static void readdir_handle_dtor(struct orangefs_bufmap *bufmap,
struct readdir_handle_s *rhandle)
{
if (rhandle == NULL)
......@@ -123,9 +123,9 @@ static void readdir_handle_dtor(struct pvfs2_bufmap *bufmap,
/*
* Read directory entries from an instance of an open directory.
*/
static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
static int orangefs_readdir(struct file *file, struct dir_context *ctx)
{
struct pvfs2_bufmap *bufmap = NULL;
struct orangefs_bufmap *bufmap = NULL;
int ret = 0;
int buffer_index;
/*
......@@ -136,8 +136,8 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
__u64 pos = 0;
ino_t ino = 0;
struct dentry *dentry = file->f_path.dentry;
struct pvfs2_kernel_op_s *new_op = NULL;
struct pvfs2_inode_s *pvfs2_inode = PVFS2_I(dentry->d_inode);
struct orangefs_kernel_op_s *new_op = NULL;
struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(dentry->d_inode);
int buffer_full = 0;
struct readdir_handle_s rhandle;
int i = 0;
......@@ -155,26 +155,26 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
pos = (__u64) ctx->pos;
/* are we done? */
if (pos == PVFS_READDIR_END) {
if (pos == ORANGEFS_READDIR_END) {
gossip_debug(GOSSIP_DIR_DEBUG,
"Skipping to termination path\n");
return 0;
}
gossip_debug(GOSSIP_DIR_DEBUG,
"pvfs2_readdir called on %s (pos=%llu)\n",
"orangefs_readdir called on %s (pos=%llu)\n",
dentry->d_name.name, llu(pos));
rhandle.buffer_index = -1;
rhandle.dents_buf = NULL;
memset(&rhandle.readdir_response, 0, sizeof(rhandle.readdir_response));
new_op = op_alloc(PVFS2_VFS_OP_READDIR);
new_op = op_alloc(ORANGEFS_VFS_OP_READDIR);
if (!new_op)
return -ENOMEM;
new_op->uses_shared_memory = 1;
new_op->upcall.req.readdir.refn = pvfs2_inode->refn;
new_op->upcall.req.readdir.refn = orangefs_inode->refn;
new_op->upcall.req.readdir.max_dirent_count = MAX_DIRENT_COUNT_READDIR;
gossip_debug(GOSSIP_DIR_DEBUG,
......@@ -187,14 +187,14 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
get_new_buffer_index:
ret = readdir_index_get(&bufmap, &buffer_index);
if (ret < 0) {
gossip_lerr("pvfs2_readdir: readdir_index_get() failure (%d)\n",
gossip_lerr("orangefs_readdir: readdir_index_get() failure (%d)\n",
ret);
goto out_free_op;
}
new_op->upcall.req.readdir.buf_index = buffer_index;
ret = service_operation(new_op,
"pvfs2_readdir",
"orangefs_readdir",
get_interruptible_flag(dentry->d_inode));
gossip_debug(GOSSIP_DIR_DEBUG,
......@@ -238,7 +238,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
new_op->downcall.trailer_size,
buffer_index);
if (bytes_decoded < 0) {
gossip_err("pvfs2_readdir: Could not decode trailer buffer into a readdir response %d\n",
gossip_err("orangefs_readdir: Could not decode trailer buffer into a readdir response %d\n",
ret);
ret = bytes_decoded;
readdir_index_put(bufmap, buffer_index);
......@@ -246,7 +246,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
}
if (bytes_decoded != new_op->downcall.trailer_size) {
gossip_err("pvfs2_readdir: # bytes decoded (%ld) "
gossip_err("orangefs_readdir: # bytes decoded (%ld) "
"!= trailer size (%ld)\n",
bytes_decoded,
(long)new_op->downcall.trailer_size);
......@@ -255,7 +255,7 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
}
/*
* pvfs2 doesn't actually store dot and dot-dot, but
* orangefs doesn't actually store dot and dot-dot, but
* we need to have them represented.
*/
if (pos == 0) {
......@@ -279,19 +279,19 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
}
/*
* we stored PVFS_ITERATE_NEXT in ctx->pos last time around
* we stored ORANGEFS_ITERATE_NEXT in ctx->pos last time around
* to prevent "finding" dot and dot-dot on any iteration
* other than the first.
*/
if (ctx->pos == PVFS_ITERATE_NEXT)
if (ctx->pos == ORANGEFS_ITERATE_NEXT)
ctx->pos = 0;
for (i = ctx->pos;
i < rhandle.readdir_response.pvfs_dirent_outcount;
i < rhandle.readdir_response.orangefs_dirent_outcount;
i++) {
len = rhandle.readdir_response.dirent_array[i].d_length;
current_entry = rhandle.readdir_response.dirent_array[i].d_name;
current_ino = pvfs2_khandle_to_ino(
current_ino = orangefs_khandle_to_ino(
&(rhandle.readdir_response.dirent_array[i].khandle));
gossip_debug(GOSSIP_DIR_DEBUG,
......@@ -323,28 +323,28 @@ static int pvfs2_readdir(struct file *file, struct dir_context *ctx)
*/
if (ret) {
*ptoken = rhandle.readdir_response.token;
ctx->pos = PVFS_ITERATE_NEXT;
ctx->pos = ORANGEFS_ITERATE_NEXT;
}
/*
* Did we hit the end of the directory?
*/
if (rhandle.readdir_response.token == PVFS_READDIR_END &&
if (rhandle.readdir_response.token == ORANGEFS_READDIR_END &&
!buffer_full) {
gossip_debug(GOSSIP_DIR_DEBUG,
"End of dir detected; setting ctx->pos to PVFS_READDIR_END.\n");
ctx->pos = PVFS_READDIR_END;
"End of dir detected; setting ctx->pos to ORANGEFS_READDIR_END.\n");
ctx->pos = ORANGEFS_READDIR_END;
}
out_destroy_handle:
readdir_handle_dtor(bufmap, &rhandle);
out_free_op:
op_release(new_op);
gossip_debug(GOSSIP_DIR_DEBUG, "pvfs2_readdir returning %d\n", ret);
gossip_debug(GOSSIP_DIR_DEBUG, "orangefs_readdir returning %d\n", ret);
return ret;
}
static int pvfs2_dir_open(struct inode *inode, struct file *file)
static int orangefs_dir_open(struct inode *inode, struct file *file)
{
__u64 *ptoken;
......@@ -353,21 +353,21 @@ static int pvfs2_dir_open(struct inode *inode, struct file *file)
return -ENOMEM;
ptoken = file->private_data;
*ptoken = PVFS_READDIR_START;
*ptoken = ORANGEFS_READDIR_START;
return 0;
}
static int pvfs2_dir_release(struct inode *inode, struct file *file)
static int orangefs_dir_release(struct inode *inode, struct file *file)
{
pvfs2_flush_inode(inode);
orangefs_flush_inode(inode);
kfree(file->private_data);
return 0;
}
/** PVFS2 implementation of VFS directory operations */
const struct file_operations pvfs2_dir_operations = {
/** ORANGEFS implementation of VFS directory operations */
const struct file_operations orangefs_dir_operations = {
.read = generic_read_dir,
.iterate = pvfs2_readdir,
.open = pvfs2_dir_open,
.release = pvfs2_dir_release,
.iterate = orangefs_readdir,
.open = orangefs_dir_open,
.release = orangefs_dir_release,
};
fs/orangefs/downcall.h
浏览文件 @ 8bb8aefd
......@@ -15,42 +15,42 @@
* Sanitized the device-client core interaction
* for clean 32-64 bit usage
*/
struct pvfs2_io_response {
struct orangefs_io_response {
__s64 amt_complete;
};
struct pvfs2_lookup_response {
struct pvfs2_object_kref refn;
struct orangefs_lookup_response {
struct orangefs_object_kref refn;
};
struct pvfs2_create_response {
struct pvfs2_object_kref refn;
struct orangefs_create_response {
struct orangefs_object_kref refn;
};
struct pvfs2_symlink_response {
struct pvfs2_object_kref refn;
struct orangefs_symlink_response {
struct orangefs_object_kref refn;
};
struct pvfs2_getattr_response {
struct PVFS_sys_attr_s attributes;
char link_target[PVFS2_NAME_LEN];
struct orangefs_getattr_response {
struct ORANGEFS_sys_attr_s attributes;
char link_target[ORANGEFS_NAME_LEN];
};
struct pvfs2_mkdir_response {
struct pvfs2_object_kref refn;
struct orangefs_mkdir_response {
struct orangefs_object_kref refn;
};
/*
* duplication of some system interface structures so that I don't have
* to allocate extra memory
*/
struct pvfs2_dirent {
struct orangefs_dirent {
char *d_name;
int d_length;
struct pvfs2_khandle khandle;
struct orangefs_khandle khandle;
};
struct pvfs2_statfs_response {
struct orangefs_statfs_response {
__s64 block_size;
__s64 blocks_total;
__s64 blocks_avail;
......@@ -58,47 +58,47 @@ struct pvfs2_statfs_response {
__s64 files_avail;
};
struct pvfs2_fs_mount_response {
struct orangefs_fs_mount_response {
__s32 fs_id;
__s32 id;
struct pvfs2_khandle root_khandle;
struct orangefs_khandle root_khandle;
};
/* the getxattr response is the attribute value */
struct pvfs2_getxattr_response {
struct orangefs_getxattr_response {
__s32 val_sz;
__s32 __pad1;
char val[PVFS_MAX_XATTR_VALUELEN];
char val[ORANGEFS_MAX_XATTR_VALUELEN];
};
/* the listxattr response is an array of attribute names */
struct pvfs2_listxattr_response {
struct orangefs_listxattr_response {
__s32 returned_count;
__s32 __pad1;
__u64 token;
char key[PVFS_MAX_XATTR_LISTLEN * PVFS_MAX_XATTR_NAMELEN];
char key[ORANGEFS_MAX_XATTR_LISTLEN * ORANGEFS_MAX_XATTR_NAMELEN];
__s32 keylen;
__s32 __pad2;
__s32 lengths[PVFS_MAX_XATTR_LISTLEN];
__s32 lengths[ORANGEFS_MAX_XATTR_LISTLEN];
};
struct pvfs2_param_response {
struct orangefs_param_response {
__s64 value;
};
#define PERF_COUNT_BUF_SIZE 4096
struct pvfs2_perf_count_response {
struct orangefs_perf_count_response {
char buffer[PERF_COUNT_BUF_SIZE];
};
#define FS_KEY_BUF_SIZE 4096
struct pvfs2_fs_key_response {
struct orangefs_fs_key_response {
__s32 fs_keylen;
__s32 __pad1;
char fs_key[FS_KEY_BUF_SIZE];
};
struct pvfs2_downcall_s {
struct orangefs_downcall_s {
__s32 type;
__s32 status;
/* currently trailer is used only by readdir */
......@@ -106,28 +106,28 @@ struct pvfs2_downcall_s {
char *trailer_buf;
union {
struct pvfs2_io_response io;
struct pvfs2_lookup_response lookup;
struct pvfs2_create_response create;
struct pvfs2_symlink_response sym;
struct pvfs2_getattr_response getattr;
struct pvfs2_mkdir_response mkdir;
struct pvfs2_statfs_response statfs;
struct pvfs2_fs_mount_response fs_mount;
struct pvfs2_getxattr_response getxattr;
struct pvfs2_listxattr_response listxattr;
struct pvfs2_param_response param;
struct pvfs2_perf_count_response perf_count;
struct pvfs2_fs_key_response fs_key;
struct orangefs_io_response io;
struct orangefs_lookup_response lookup;
struct orangefs_create_response create;
struct orangefs_symlink_response sym;
struct orangefs_getattr_response getattr;
struct orangefs_mkdir_response mkdir;
struct orangefs_statfs_response statfs;
struct orangefs_fs_mount_response fs_mount;
struct orangefs_getxattr_response getxattr;
struct orangefs_listxattr_response listxattr;
struct orangefs_param_response param;
struct orangefs_perf_count_response perf_count;
struct orangefs_fs_key_response fs_key;
} resp;
};
struct pvfs2_readdir_response_s {
struct orangefs_readdir_response_s {
__u64 token;
__u64 directory_version;
__u32 __pad2;
__u32 pvfs_dirent_outcount;
struct pvfs2_dirent *dirent_array;
__u32 orangefs_dirent_outcount;
struct orangefs_dirent *dirent_array;
};
#endif /* __DOWNCALL_H */
fs/orangefs/file.c
浏览文件 @ 8bb8aefd
......@@ -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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
* 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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
/* 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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
* 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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
* 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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
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 @@ static ssize_t wait_for_direct_io(enum PVFS_io_type type, struct inode *inode,
* 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 @@ static ssize_t do_readv_writev(enum PVFS_io_type type, struct file *file,
* 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 @@ static ssize_t pvfs2_file_write_iter(struct kiocb *iocb, struct iov_iter *iter)
/*
* 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,
};
fs/orangefs/inode.c
浏览文件 @ 8bb8aefd
......@@ -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:
......
fs/orangefs/namei.c
浏览文件 @ 8bb8aefd
......@@ -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 @@ static int pvfs2_create(struct inode *dir,
* 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 @@ static struct dentry *pvfs2_lookup(struct inode *dir, struct dentry *dentry,
}
/* 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 @@ static int pvfs2_symlink(struct inode *dir,
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 @@ static int pvfs2_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
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,
};
fs/orangefs/protocol.h
浏览文件 @ 8bb8aefd
......@@ -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;
#define PVFS2_SUPER_MAGIC 0x20030528
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 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 PVFS_ATTR_SYS_ALL_SETABLE \
(PVFS_ATTR_SYS_COMMON_ALL-PVFS_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_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 ORANGEFS_ATTR_SYS_ALL_SETABLE \
(ORANGEFS_ATTR_SYS_COMMON_ALL-ORANGEFS_ATTR_SYS_TYPE)
#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 <linux/xattr.h>
*/
#define PVFS_MAX_XATTR_VALUELEN 8192 /* Not the same as XATTR_SIZE_MAX
#define ORANGEFS_MAX_XATTR_VALUELEN 8192 /* Not the same as XATTR_SIZE_MAX
* defined by <linux/xattr.h>
*/
#define PVFS_MAX_XATTR_LISTLEN 16 /* Not the same as XATTR_LIST_MAX
#define ORANGEFS_MAX_XATTR_LISTLEN 16 /* Not the same as XATTR_LIST_MAX
* defined by <linux/xattr.h>
*/
/*
* 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;
......
fs/orangefs/pvfs2-bufmap.c
浏览文件 @ 8bb8aefd
......@@ -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 @@ pvfs2_bufmap_alloc(struct PVFS_dev_map_desc *user_desc)
}
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,
......
fs/orangefs/pvfs2-bufmap.h
浏览文件 @ 8bb8aefd
......@@ -4,59 +4,59 @@
* See COPYING in top-level directory.
*/
#ifndef __PVFS2_BUFMAP_H
#define __PVFS2_BUFMAP_H
#ifndef __ORANGEFS_BUFMAP_H
#define __ORANGEFS_BUFMAP_H
/* used to describe mapped buffers */
struct pvfs_bufmap_desc {
struct orangefs_bufmap_desc {
void *uaddr; /* user space address pointer */
struct page **page_array; /* array of mapped pages */
int array_count; /* size of above arrays */
struct list_head list_link;
};
struct pvfs2_bufmap;
struct orangefs_bufmap;
struct pvfs2_bufmap *pvfs2_bufmap_ref(void);
void pvfs2_bufmap_unref(struct pvfs2_bufmap *bufmap);
struct orangefs_bufmap *orangefs_bufmap_ref(void);
void orangefs_bufmap_unref(struct orangefs_bufmap *bufmap);
/*
* pvfs_bufmap_size_query is now an inline function because buffer
* orangefs_bufmap_size_query is now an inline function because buffer
* sizes are not hardcoded
*/
int pvfs_bufmap_size_query(void);
int orangefs_bufmap_size_query(void);
int pvfs_bufmap_shift_query(void);
int orangefs_bufmap_shift_query(void);
int pvfs_bufmap_initialize(struct PVFS_dev_map_desc *user_desc);
int orangefs_bufmap_initialize(struct ORANGEFS_dev_map_desc *user_desc);
int get_bufmap_init(void);
void pvfs_bufmap_finalize(void);
void orangefs_bufmap_finalize(void);
int pvfs_bufmap_get(struct pvfs2_bufmap **mapp, int *buffer_index);
int orangefs_bufmap_get(struct orangefs_bufmap **mapp, int *buffer_index);
void pvfs_bufmap_put(struct pvfs2_bufmap *bufmap, int buffer_index);
void orangefs_bufmap_put(struct orangefs_bufmap *bufmap, int buffer_index);
int readdir_index_get(struct pvfs2_bufmap **mapp, int *buffer_index);
int readdir_index_get(struct orangefs_bufmap **mapp, int *buffer_index);
void readdir_index_put(struct pvfs2_bufmap *bufmap, int buffer_index);
void readdir_index_put(struct orangefs_bufmap *bufmap, int buffer_index);
int pvfs_bufmap_copy_from_iovec(struct pvfs2_bufmap *bufmap,
int orangefs_bufmap_copy_from_iovec(struct orangefs_bufmap *bufmap,
struct iov_iter *iter,
int buffer_index,
size_t size);
int pvfs_bufmap_copy_to_iovec(struct pvfs2_bufmap *bufmap,
int orangefs_bufmap_copy_to_iovec(struct orangefs_bufmap *bufmap,
struct iov_iter *iter,
int buffer_index,
size_t size);
size_t pvfs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk,
size_t orangefs_bufmap_copy_to_user_task_iovec(struct task_struct *tsk,
struct iovec *iovec,
unsigned long nr_segs,
struct pvfs2_bufmap *bufmap,
struct orangefs_bufmap *bufmap,
int buffer_index,
size_t bytes_to_be_copied);
#endif /* __PVFS2_BUFMAP_H */
#endif /* __ORANGEFS_BUFMAP_H */
fs/orangefs/pvfs2-cache.c
浏览文件 @ 8bb8aefd
......@@ -11,27 +11,27 @@
static __u64 next_tag_value;
static DEFINE_SPINLOCK(next_tag_value_lock);
/* the pvfs2 memory caches */
/* the orangefs memory caches */
/* a cache for pvfs2 upcall/downcall operations */
/* a cache for orangefs upcall/downcall operations */
static struct kmem_cache *op_cache;
/* a cache for device (/dev/pvfs2-req) communication */
static struct kmem_cache *dev_req_cache;
/* a cache for pvfs2_kiocb objects (i.e pvfs2 iocb structures ) */
static struct kmem_cache *pvfs2_kiocb_cache;
/* a cache for orangefs_kiocb objects (i.e orangefs iocb structures ) */
static struct kmem_cache *orangefs_kiocb_cache;
int op_cache_initialize(void)
{
op_cache = kmem_cache_create("pvfs2_op_cache",
sizeof(struct pvfs2_kernel_op_s),
op_cache = kmem_cache_create("orangefs_op_cache",
sizeof(struct orangefs_kernel_op_s),
0,
PVFS2_CACHE_CREATE_FLAGS,
ORANGEFS_CACHE_CREATE_FLAGS,
NULL);
if (!op_cache) {
gossip_err("Cannot create pvfs2_op_cache\n");
gossip_err("Cannot create orangefs_op_cache\n");
return -ENOMEM;
}
......@@ -48,72 +48,72 @@ int op_cache_finalize(void)
return 0;
}
char *get_opname_string(struct pvfs2_kernel_op_s *new_op)
char *get_opname_string(struct orangefs_kernel_op_s *new_op)
{
if (new_op) {
__s32 type = new_op->upcall.type;
if (type == PVFS2_VFS_OP_FILE_IO)
if (type == ORANGEFS_VFS_OP_FILE_IO)
return "OP_FILE_IO";
else if (type == PVFS2_VFS_OP_LOOKUP)
else if (type == ORANGEFS_VFS_OP_LOOKUP)
return "OP_LOOKUP";
else if (type == PVFS2_VFS_OP_CREATE)
else if (type == ORANGEFS_VFS_OP_CREATE)
return "OP_CREATE";
else if (type == PVFS2_VFS_OP_GETATTR)
else if (type == ORANGEFS_VFS_OP_GETATTR)
return "OP_GETATTR";
else if (type == PVFS2_VFS_OP_REMOVE)
else if (type == ORANGEFS_VFS_OP_REMOVE)
return "OP_REMOVE";
else if (type == PVFS2_VFS_OP_MKDIR)
else if (type == ORANGEFS_VFS_OP_MKDIR)
return "OP_MKDIR";
else if (type == PVFS2_VFS_OP_READDIR)
else if (type == ORANGEFS_VFS_OP_READDIR)
return "OP_READDIR";
else if (type == PVFS2_VFS_OP_READDIRPLUS)
else if (type == ORANGEFS_VFS_OP_READDIRPLUS)
return "OP_READDIRPLUS";
else if (type == PVFS2_VFS_OP_SETATTR)
else if (type == ORANGEFS_VFS_OP_SETATTR)
return "OP_SETATTR";
else if (type == PVFS2_VFS_OP_SYMLINK)
else if (type == ORANGEFS_VFS_OP_SYMLINK)
return "OP_SYMLINK";
else if (type == PVFS2_VFS_OP_RENAME)
else if (type == ORANGEFS_VFS_OP_RENAME)
return "OP_RENAME";
else if (type == PVFS2_VFS_OP_STATFS)
else if (type == ORANGEFS_VFS_OP_STATFS)
return "OP_STATFS";
else if (type == PVFS2_VFS_OP_TRUNCATE)
else if (type == ORANGEFS_VFS_OP_TRUNCATE)
return "OP_TRUNCATE";
else if (type == PVFS2_VFS_OP_MMAP_RA_FLUSH)
else if (type == ORANGEFS_VFS_OP_MMAP_RA_FLUSH)
return "OP_MMAP_RA_FLUSH";
else if (type == PVFS2_VFS_OP_FS_MOUNT)
else if (type == ORANGEFS_VFS_OP_FS_MOUNT)
return "OP_FS_MOUNT";
else if (type == PVFS2_VFS_OP_FS_UMOUNT)
else if (type == ORANGEFS_VFS_OP_FS_UMOUNT)
return "OP_FS_UMOUNT";
else if (type == PVFS2_VFS_OP_GETXATTR)
else if (type == ORANGEFS_VFS_OP_GETXATTR)
return "OP_GETXATTR";
else if (type == PVFS2_VFS_OP_SETXATTR)
else if (type == ORANGEFS_VFS_OP_SETXATTR)
return "OP_SETXATTR";
else if (type == PVFS2_VFS_OP_LISTXATTR)
else if (type == ORANGEFS_VFS_OP_LISTXATTR)
return "OP_LISTXATTR";
else if (type == PVFS2_VFS_OP_REMOVEXATTR)
else if (type == ORANGEFS_VFS_OP_REMOVEXATTR)
return "OP_REMOVEXATTR";
else if (type == PVFS2_VFS_OP_PARAM)
else if (type == ORANGEFS_VFS_OP_PARAM)
return "OP_PARAM";
else if (type == PVFS2_VFS_OP_PERF_COUNT)
else if (type == ORANGEFS_VFS_OP_PERF_COUNT)
return "OP_PERF_COUNT";
else if (type == PVFS2_VFS_OP_CANCEL)
else if (type == ORANGEFS_VFS_OP_CANCEL)
return "OP_CANCEL";
else if (type == PVFS2_VFS_OP_FSYNC)
else if (type == ORANGEFS_VFS_OP_FSYNC)
return "OP_FSYNC";
else if (type == PVFS2_VFS_OP_FSKEY)
else if (type == ORANGEFS_VFS_OP_FSKEY)
return "OP_FSKEY";
}
return "OP_UNKNOWN?";
}
struct pvfs2_kernel_op_s *op_alloc(__s32 type)
struct orangefs_kernel_op_s *op_alloc(__s32 type)
{
struct pvfs2_kernel_op_s *new_op = NULL;
struct orangefs_kernel_op_s *new_op = NULL;
new_op = kmem_cache_alloc(op_cache, PVFS2_CACHE_ALLOC_FLAGS);
new_op = kmem_cache_alloc(op_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
if (new_op) {
memset(new_op, 0, sizeof(struct pvfs2_kernel_op_s));
memset(new_op, 0, sizeof(struct orangefs_kernel_op_s));
INIT_LIST_HEAD(&new_op->list);
spin_lock_init(&new_op->lock);
......@@ -122,7 +122,7 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type)
init_waitqueue_head(&new_op->io_completion_waitq);
atomic_set(&new_op->aio_ref_count, 0);
pvfs2_op_initialize(new_op);
orangefs_op_initialize(new_op);
/* initialize the op specific tag and upcall credentials */
spin_lock(&next_tag_value_lock);
......@@ -149,15 +149,15 @@ struct pvfs2_kernel_op_s *op_alloc(__s32 type)
return new_op;
}
void op_release(struct pvfs2_kernel_op_s *pvfs2_op)
void op_release(struct orangefs_kernel_op_s *orangefs_op)
{
if (pvfs2_op) {
if (orangefs_op) {
gossip_debug(GOSSIP_CACHE_DEBUG,
"Releasing OP (%p: %llu)\n",
pvfs2_op,
llu(pvfs2_op->tag));
pvfs2_op_initialize(pvfs2_op);
kmem_cache_free(op_cache, pvfs2_op);
orangefs_op,
llu(orangefs_op->tag));
orangefs_op_initialize(orangefs_op);
kmem_cache_free(op_cache, orangefs_op);
} else {
gossip_err("NULL pointer in op_release\n");
}
......@@ -165,14 +165,14 @@ void op_release(struct pvfs2_kernel_op_s *pvfs2_op)
int dev_req_cache_initialize(void)
{
dev_req_cache = kmem_cache_create("pvfs2_devreqcache",
dev_req_cache = kmem_cache_create("orangefs_devreqcache",
MAX_ALIGNED_DEV_REQ_DOWNSIZE,
0,
PVFS2_CACHE_CREATE_FLAGS,
ORANGEFS_CACHE_CREATE_FLAGS,
NULL);
if (!dev_req_cache) {
gossip_err("Cannot create pvfs2_dev_req_cache\n");
gossip_err("Cannot create orangefs_dev_req_cache\n");
return -ENOMEM;
}
return 0;
......@@ -188,7 +188,7 @@ void *dev_req_alloc(void)
{
void *buffer;
buffer = kmem_cache_alloc(dev_req_cache, PVFS2_CACHE_ALLOC_FLAGS);
buffer = kmem_cache_alloc(dev_req_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
if (buffer == NULL)
gossip_err("Failed to allocate from dev_req_cache\n");
else
......@@ -206,14 +206,14 @@ void dev_req_release(void *buffer)
int kiocb_cache_initialize(void)
{
pvfs2_kiocb_cache = kmem_cache_create("pvfs2_kiocbcache",
sizeof(struct pvfs2_kiocb_s),
orangefs_kiocb_cache = kmem_cache_create("orangefs_kiocbcache",
sizeof(struct orangefs_kiocb_s),
0,
PVFS2_CACHE_CREATE_FLAGS,
ORANGEFS_CACHE_CREATE_FLAGS,
NULL);
if (!pvfs2_kiocb_cache) {
gossip_err("Cannot create pvfs2_kiocb_cache!\n");
if (!orangefs_kiocb_cache) {
gossip_err("Cannot create orangefs_kiocb_cache!\n");
return -ENOMEM;
}
return 0;
......@@ -221,26 +221,26 @@ int kiocb_cache_initialize(void)
int kiocb_cache_finalize(void)
{
kmem_cache_destroy(pvfs2_kiocb_cache);
kmem_cache_destroy(orangefs_kiocb_cache);
return 0;
}
struct pvfs2_kiocb_s *kiocb_alloc(void)
struct orangefs_kiocb_s *kiocb_alloc(void)
{
struct pvfs2_kiocb_s *x = NULL;
struct orangefs_kiocb_s *x = NULL;
x = kmem_cache_alloc(pvfs2_kiocb_cache, PVFS2_CACHE_ALLOC_FLAGS);
x = kmem_cache_alloc(orangefs_kiocb_cache, ORANGEFS_CACHE_ALLOC_FLAGS);
if (x == NULL)
gossip_err("kiocb_alloc: kmem_cache_alloc failed!\n");
else
memset(x, 0, sizeof(struct pvfs2_kiocb_s));
memset(x, 0, sizeof(struct orangefs_kiocb_s));
return x;
}
void kiocb_release(struct pvfs2_kiocb_s *x)
void kiocb_release(struct orangefs_kiocb_s *x)
{
if (x)
kmem_cache_free(pvfs2_kiocb_cache, x);
kmem_cache_free(orangefs_kiocb_cache, x);
else
gossip_err("kiocb_release: kmem_cache_free NULL pointer!\n");
}
fs/orangefs/pvfs2-debug.h
浏览文件 @ 8bb8aefd
......@@ -5,12 +5,12 @@
*/
/* This file just defines debugging masks to be used with the gossip
* logging utility. All debugging masks for PVFS2 are kept here to make
* logging utility. All debugging masks for ORANGEFS are kept here to make
* sure we don't have collisions.
*/
#ifndef __PVFS2_DEBUG_H
#define __PVFS2_DEBUG_H
#ifndef __ORANGEFS_DEBUG_H
#define __ORANGEFS_DEBUG_H
#ifdef __KERNEL__
#include <linux/types.h>
......@@ -90,7 +90,7 @@
GOSSIP_BMI_DEBUG_MX + \
GOSSIP_BMI_DEBUG_PORTALS))
const char *PVFS_debug_get_next_debug_keyword(int position);
const char *ORANGEFS_debug_get_next_debug_keyword(int position);
#define GOSSIP_SUPER_DEBUG ((__u64)1 << 0)
#define GOSSIP_INODE_DEBUG ((__u64)1 << 1)
......@@ -113,10 +113,10 @@ const char *PVFS_debug_get_next_debug_keyword(int position);
#define GOSSIP_MAX_DEBUG (((__u64)1 << GOSSIP_MAX_NR) - 1)
/*function prototypes*/
__u64 PVFS_kmod_eventlog_to_mask(const char *event_logging);
__u64 PVFS_debug_eventlog_to_mask(const char *event_logging);
char *PVFS_debug_mask_to_eventlog(__u64 mask);
char *PVFS_kmod_mask_to_eventlog(__u64 mask);
__u64 ORANGEFS_kmod_eventlog_to_mask(const char *event_logging);
__u64 ORANGEFS_debug_eventlog_to_mask(const char *event_logging);
char *ORANGEFS_debug_mask_to_eventlog(__u64 mask);
char *ORANGEFS_kmod_mask_to_eventlog(__u64 mask);
/* a private internal type */
struct __keyword_mask_s {
......@@ -289,4 +289,4 @@ static const int num_kmod_keyword_mask_map = (int)
static const int num_keyword_mask_map = (int)
(sizeof(s_keyword_mask_map) / sizeof(struct __keyword_mask_s));
#endif /* __PVFS2_DEBUG_H */
#endif /* __ORANGEFS_DEBUG_H */
fs/orangefs/pvfs2-debugfs.c
浏览文件 @ 8bb8aefd
......@@ -95,7 +95,7 @@ static const struct file_operations kernel_debug_fops = {
* initialize kmod debug operations, create orangefs debugfs dir and
* ORANGEFS_KMOD_DEBUG_HELP_FILE.
*/
int pvfs2_debugfs_init(void)
int orangefs_debugfs_init(void)
{
int rc = -ENOMEM;
......@@ -117,12 +117,12 @@ int pvfs2_debugfs_init(void)
out:
if (rc)
pvfs2_debugfs_cleanup();
orangefs_debugfs_cleanup();
return rc;
}
void pvfs2_debugfs_cleanup(void)
void orangefs_debugfs_cleanup(void)
{
debugfs_remove_recursive(debug_dir);
}
......@@ -196,7 +196,7 @@ static int help_show(struct seq_file *m, void *v)
/*
* initialize the kernel-debug file.
*/
int pvfs2_kernel_debug_init(void)
int orangefs_kernel_debug_init(void)
{
int rc = -ENOMEM;
......@@ -205,11 +205,11 @@ int pvfs2_kernel_debug_init(void)
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
k_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
k_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!k_buffer)
goto out;
if (strlen(kernel_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
if (strlen(kernel_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
strcpy(k_buffer, kernel_debug_string);
strcat(k_buffer, "\n");
} else {
......@@ -233,7 +233,7 @@ int pvfs2_kernel_debug_init(void)
out:
if (rc)
pvfs2_debugfs_cleanup();
orangefs_debugfs_cleanup();
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
return rc;
......@@ -242,7 +242,7 @@ int pvfs2_kernel_debug_init(void)
/*
* initialize the client-debug file.
*/
int pvfs2_client_debug_init(void)
int orangefs_client_debug_init(void)
{
int rc = -ENOMEM;
......@@ -250,11 +250,11 @@ int pvfs2_client_debug_init(void)
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: start\n", __func__);
c_buffer = kzalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
c_buffer = kzalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!c_buffer)
goto out;
if (strlen(client_debug_string) + 1 < PVFS2_MAX_DEBUG_STRING_LEN) {
if (strlen(client_debug_string) + 1 < ORANGEFS_MAX_DEBUG_STRING_LEN) {
strcpy(c_buffer, client_debug_string);
strcat(c_buffer, "\n");
} else {
......@@ -278,7 +278,7 @@ int pvfs2_client_debug_init(void)
out:
if (rc)
pvfs2_debugfs_cleanup();
orangefs_debugfs_cleanup();
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "%s: rc:%d:\n", __func__, rc);
return rc;
......@@ -320,7 +320,7 @@ static ssize_t orangefs_debug_read(struct file *file,
gossip_debug(GOSSIP_DEBUGFS_DEBUG, "orangefs_debug_read: start\n");
buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!buf)
goto out;
......@@ -349,7 +349,7 @@ static ssize_t orangefs_debug_write(struct file *file,
int rc = -EFAULT;
size_t silly = 0;
char *debug_string;
struct pvfs2_kernel_op_s *new_op = NULL;
struct orangefs_kernel_op_s *new_op = NULL;
struct client_debug_mask c_mask = { NULL, 0, 0 };
gossip_debug(GOSSIP_DEBUGFS_DEBUG,
......@@ -360,15 +360,15 @@ static ssize_t orangefs_debug_write(struct file *file,
* Thwart users who try to jamb a ridiculous number
* of bytes into the debug file...
*/
if (count > PVFS2_MAX_DEBUG_STRING_LEN + 1) {
if (count > ORANGEFS_MAX_DEBUG_STRING_LEN + 1) {
silly = count;
count = PVFS2_MAX_DEBUG_STRING_LEN + 1;
count = ORANGEFS_MAX_DEBUG_STRING_LEN + 1;
}
buf = kmalloc(PVFS2_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
buf = kmalloc(ORANGEFS_MAX_DEBUG_STRING_LEN, GFP_KERNEL);
if (!buf)
goto out;
memset(buf, 0, PVFS2_MAX_DEBUG_STRING_LEN);
memset(buf, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
if (copy_from_user(buf, ubuf, count - 1)) {
gossip_debug(GOSSIP_DEBUGFS_DEBUG,
......@@ -407,18 +407,18 @@ static ssize_t orangefs_debug_write(struct file *file,
debug_mask_to_string(&c_mask, 1);
debug_string = client_debug_string;
new_op = op_alloc(PVFS2_VFS_OP_PARAM);
new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
if (!new_op) {
pr_info("%s: op_alloc failed!\n", __func__);
goto out;
}
new_op->upcall.req.param.op =
PVFS2_PARAM_REQUEST_OP_TWO_MASK_VALUES;
new_op->upcall.req.param.type = PVFS2_PARAM_REQUEST_SET;
ORANGEFS_PARAM_REQUEST_OP_TWO_MASK_VALUES;
new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;
memset(new_op->upcall.req.param.s_value,
0,
PVFS2_MAX_DEBUG_STRING_LEN);
ORANGEFS_MAX_DEBUG_STRING_LEN);
sprintf(new_op->upcall.req.param.s_value,
"%llx %llx\n",
c_mask.mask1,
......@@ -426,8 +426,8 @@ static ssize_t orangefs_debug_write(struct file *file,
/* service_operation returns 0 on success... */
rc = service_operation(new_op,
"pvfs2_param",
PVFS2_OP_INTERRUPTIBLE);
"orangefs_param",
ORANGEFS_OP_INTERRUPTIBLE);
if (rc)
gossip_debug(GOSSIP_DEBUGFS_DEBUG,
......@@ -439,7 +439,7 @@ static ssize_t orangefs_debug_write(struct file *file,
}
mutex_lock(&orangefs_debug_lock);
memset(file->f_inode->i_private, 0, PVFS2_MAX_DEBUG_STRING_LEN);
memset(file->f_inode->i_private, 0, ORANGEFS_MAX_DEBUG_STRING_LEN);
sprintf((char *)file->f_inode->i_private, "%s\n", debug_string);
mutex_unlock(&orangefs_debug_lock);
......
fs/orangefs/pvfs2-debugfs.h
浏览文件 @ 8bb8aefd
int pvfs2_debugfs_init(void);
int pvfs2_kernel_debug_init(void);
void pvfs2_debugfs_cleanup(void);
int orangefs_debugfs_init(void);
int orangefs_kernel_debug_init(void);
void orangefs_debugfs_cleanup(void);
fs/orangefs/pvfs2-dev-proto.h
浏览文件 @ 8bb8aefd
......@@ -4,8 +4,8 @@
* See COPYING in top-level directory.
*/
#ifndef _PVFS2_DEV_PROTO_H
#define _PVFS2_DEV_PROTO_H
#ifndef _ORANGEFS_DEV_PROTO_H
#define _ORANGEFS_DEV_PROTO_H
/*
* types and constants shared between user space and kernel space for
......@@ -13,46 +13,46 @@
*/
/*
* valid pvfs2 kernel operation types
* valid orangefs kernel operation types
*/
#define PVFS2_VFS_OP_INVALID 0xFF000000
#define PVFS2_VFS_OP_FILE_IO 0xFF000001
#define PVFS2_VFS_OP_LOOKUP 0xFF000002
#define PVFS2_VFS_OP_CREATE 0xFF000003
#define PVFS2_VFS_OP_GETATTR 0xFF000004
#define PVFS2_VFS_OP_REMOVE 0xFF000005
#define PVFS2_VFS_OP_MKDIR 0xFF000006
#define PVFS2_VFS_OP_READDIR 0xFF000007
#define PVFS2_VFS_OP_SETATTR 0xFF000008
#define PVFS2_VFS_OP_SYMLINK 0xFF000009
#define PVFS2_VFS_OP_RENAME 0xFF00000A
#define PVFS2_VFS_OP_STATFS 0xFF00000B
#define PVFS2_VFS_OP_TRUNCATE 0xFF00000C
#define PVFS2_VFS_OP_MMAP_RA_FLUSH 0xFF00000D
#define PVFS2_VFS_OP_FS_MOUNT 0xFF00000E
#define PVFS2_VFS_OP_FS_UMOUNT 0xFF00000F
#define PVFS2_VFS_OP_GETXATTR 0xFF000010
#define PVFS2_VFS_OP_SETXATTR 0xFF000011
#define PVFS2_VFS_OP_LISTXATTR 0xFF000012
#define PVFS2_VFS_OP_REMOVEXATTR 0xFF000013
#define PVFS2_VFS_OP_PARAM 0xFF000014
#define PVFS2_VFS_OP_PERF_COUNT 0xFF000015
#define PVFS2_VFS_OP_CANCEL 0xFF00EE00
#define PVFS2_VFS_OP_FSYNC 0xFF00EE01
#define PVFS2_VFS_OP_FSKEY 0xFF00EE02
#define PVFS2_VFS_OP_READDIRPLUS 0xFF00EE03
#define ORANGEFS_VFS_OP_INVALID 0xFF000000
#define ORANGEFS_VFS_OP_FILE_IO 0xFF000001
#define ORANGEFS_VFS_OP_LOOKUP 0xFF000002
#define ORANGEFS_VFS_OP_CREATE 0xFF000003
#define ORANGEFS_VFS_OP_GETATTR 0xFF000004
#define ORANGEFS_VFS_OP_REMOVE 0xFF000005
#define ORANGEFS_VFS_OP_MKDIR 0xFF000006
#define ORANGEFS_VFS_OP_READDIR 0xFF000007
#define ORANGEFS_VFS_OP_SETATTR 0xFF000008
#define ORANGEFS_VFS_OP_SYMLINK 0xFF000009
#define ORANGEFS_VFS_OP_RENAME 0xFF00000A
#define ORANGEFS_VFS_OP_STATFS 0xFF00000B
#define ORANGEFS_VFS_OP_TRUNCATE 0xFF00000C
#define ORANGEFS_VFS_OP_MMAP_RA_FLUSH 0xFF00000D
#define ORANGEFS_VFS_OP_FS_MOUNT 0xFF00000E
#define ORANGEFS_VFS_OP_FS_UMOUNT 0xFF00000F
#define ORANGEFS_VFS_OP_GETXATTR 0xFF000010
#define ORANGEFS_VFS_OP_SETXATTR 0xFF000011
#define ORANGEFS_VFS_OP_LISTXATTR 0xFF000012
#define ORANGEFS_VFS_OP_REMOVEXATTR 0xFF000013
#define ORANGEFS_VFS_OP_PARAM 0xFF000014
#define ORANGEFS_VFS_OP_PERF_COUNT 0xFF000015
#define ORANGEFS_VFS_OP_CANCEL 0xFF00EE00
#define ORANGEFS_VFS_OP_FSYNC 0xFF00EE01
#define ORANGEFS_VFS_OP_FSKEY 0xFF00EE02
#define ORANGEFS_VFS_OP_READDIRPLUS 0xFF00EE03
/*
* Misc constants. Please retain them as multiples of 8!
* Otherwise 32-64 bit interactions will be messed up :)
*/
#define PVFS2_NAME_LEN 0x00000100
#define PVFS2_MAX_DEBUG_STRING_LEN 0x00000400
#define PVFS2_MAX_DEBUG_ARRAY_LEN 0x00000800
#define ORANGEFS_NAME_LEN 0x00000100
#define ORANGEFS_MAX_DEBUG_STRING_LEN 0x00000400
#define ORANGEFS_MAX_DEBUG_ARRAY_LEN 0x00000800
/*
* MAX_DIRENT_COUNT cannot be larger than PVFS_REQ_LIMIT_LISTATTR.
* The value of PVFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60
* MAX_DIRENT_COUNT cannot be larger than ORANGEFS_REQ_LIMIT_LISTATTR.
* The value of ORANGEFS_REQ_LIMIT_LISTATTR has been changed from 113 to 60
* to accomodate an attribute object with mirrored handles.
* MAX_DIRENT_COUNT is replaced by MAX_DIRENT_COUNT_READDIR and
* MAX_DIRENT_COUNT_READDIRPLUS, since readdir doesn't trigger a listattr
......
fs/orangefs/pvfs2-kernel.h
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/pvfs2-mod.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/pvfs2-sysfs.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/pvfs2-utils.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/super.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/symlink.c
浏览文件 @ 8bb8aefd
......@@ -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,
};
fs/orangefs/upcall.h
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/waitqueue.c
浏览文件 @ 8bb8aefd
此差异已折叠。
fs/orangefs/xattr.c
浏览文件 @ 8bb8aefd
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或