#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
+#include "xfs_dir.h"
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_bmap_btree.h"
#include "xfs_alloc_btree.h"
#include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
#include "xfs_dir2_sf.h"
#include "xfs_attr_sf.h"
#include "xfs_dinode.h"
*/
xfs_inode_t *
xfs_vtoi(
- bhv_vnode_t *vp)
+ struct vnode *vp)
{
bhv_desc_t *bdp;
xfs_synchronize_atime(
xfs_inode_t *ip)
{
- bhv_vnode_t *vp;
+ vnode_t *vp;
vp = XFS_ITOV_NULL(ip);
if (vp) {
STATIC void
xfs_validate_fields(
struct inode *ip,
- bhv_vattr_t *vattr)
+ struct vattr *vattr)
{
+ vnode_t *vp = vn_from_inode(ip);
+ int error;
+
vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
- if (!bhv_vop_getattr(vn_from_inode(ip), vattr, ATTR_LAZY, NULL)) {
+ VOP_GETATTR(vp, vattr, ATTR_LAZY, NULL, error);
+ if (likely(!error)) {
ip->i_nlink = vattr->va_nlink;
ip->i_blocks = vattr->va_nblocks;
*/
STATIC int
xfs_init_security(
- bhv_vnode_t *vp,
+ struct vnode *vp,
struct inode *dir)
{
struct inode *ip = vn_to_inode(vp);
return -error;
}
- error = bhv_vop_attr_set(vp, name, value, length, ATTR_SECURE, NULL);
+ VOP_ATTR_SET(vp, name, value, length, ATTR_SECURE, NULL, error);
if (!error)
VMODIFY(vp);
STATIC inline void
xfs_cleanup_inode(
- bhv_vnode_t *dvp,
- bhv_vnode_t *vp,
+ vnode_t *dvp,
+ vnode_t *vp,
struct dentry *dentry,
int mode)
{
struct dentry teardown = {};
+ int error;
/* Oh, the horror.
* If we can't add the ACL or we fail in
teardown.d_name = dentry->d_name;
if (S_ISDIR(mode))
- bhv_vop_rmdir(dvp, &teardown, NULL);
+ VOP_RMDIR(dvp, &teardown, NULL, error);
else
- bhv_vop_remove(dvp, &teardown, NULL);
+ VOP_REMOVE(dvp, &teardown, NULL, error);
VN_RELE(vp);
}
dev_t rdev)
{
struct inode *ip;
- bhv_vattr_t vattr = { 0 };
- bhv_vnode_t *vp = NULL, *dvp = vn_from_inode(dir);
+ vattr_t vattr = { 0 };
+ vnode_t *vp = NULL, *dvp = vn_from_inode(dir);
xfs_acl_t *default_acl = NULL;
attrexists_t test_default_acl = _ACL_DEFAULT_EXISTS;
int error;
vattr.va_mask |= XFS_AT_RDEV;
/*FALLTHROUGH*/
case S_IFREG:
- error = bhv_vop_create(dvp, dentry, &vattr, &vp, NULL);
+ VOP_CREATE(dvp, dentry, &vattr, &vp, NULL, error);
break;
case S_IFDIR:
- error = bhv_vop_mkdir(dvp, dentry, &vattr, &vp, NULL);
+ VOP_MKDIR(dvp, dentry, &vattr, &vp, NULL, error);
break;
default:
error = EINVAL;
struct dentry *dentry,
struct nameidata *nd)
{
- bhv_vnode_t *vp = vn_from_inode(dir), *cvp;
+ struct vnode *vp = vn_from_inode(dir), *cvp;
int error;
if (dentry->d_name.len >= MAXNAMELEN)
return ERR_PTR(-ENAMETOOLONG);
- error = bhv_vop_lookup(vp, dentry, &cvp, 0, NULL, NULL);
- if (unlikely(error)) {
+ VOP_LOOKUP(vp, dentry, &cvp, 0, NULL, NULL, error);
+ if (error) {
if (unlikely(error != ENOENT))
return ERR_PTR(-error);
d_add(dentry, NULL);
struct dentry *dentry)
{
struct inode *ip; /* inode of guy being linked to */
- bhv_vnode_t *tdvp; /* target directory for new name/link */
- bhv_vnode_t *vp; /* vp of name being linked */
- bhv_vattr_t vattr;
+ vnode_t *tdvp; /* target directory for new name/link */
+ vnode_t *vp; /* vp of name being linked */
+ vattr_t vattr;
int error;
ip = old_dentry->d_inode; /* inode being linked to */
+ if (S_ISDIR(ip->i_mode))
+ return -EPERM;
+
tdvp = vn_from_inode(dir);
vp = vn_from_inode(ip);
- VN_HOLD(vp);
- error = bhv_vop_link(tdvp, vp, dentry, NULL);
- if (unlikely(error)) {
- VN_RELE(vp);
- } else {
+ VOP_LINK(tdvp, vp, dentry, NULL, error);
+ if (likely(!error)) {
VMODIFY(tdvp);
+ VN_HOLD(vp);
xfs_validate_fields(ip, &vattr);
d_instantiate(dentry, ip);
}
struct dentry *dentry)
{
struct inode *inode;
- bhv_vnode_t *dvp; /* directory containing name to remove */
- bhv_vattr_t vattr;
+ vnode_t *dvp; /* directory containing name to remove */
+ vattr_t vattr;
int error;
inode = dentry->d_inode;
dvp = vn_from_inode(dir);
- error = bhv_vop_remove(dvp, dentry, NULL);
+ VOP_REMOVE(dvp, dentry, NULL, error);
if (likely(!error)) {
xfs_validate_fields(dir, &vattr); /* size needs update */
xfs_validate_fields(inode, &vattr);
const char *symname)
{
struct inode *ip;
- bhv_vattr_t va = { 0 };
- bhv_vnode_t *dvp; /* directory containing name of symlink */
- bhv_vnode_t *cvp; /* used to lookup symlink to put in dentry */
+ vattr_t vattr = { 0 };
+ vnode_t *dvp; /* directory containing name of symlink */
+ vnode_t *cvp; /* used to lookup symlink to put in dentry */
int error;
dvp = vn_from_inode(dir);
cvp = NULL;
- va.va_mode = S_IFLNK |
+ vattr.va_mode = S_IFLNK |
(irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
- va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
+ vattr.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
- error = bhv_vop_symlink(dvp, dentry, &va, (char *)symname, &cvp, NULL);
+ error = 0;
+ VOP_SYMLINK(dvp, dentry, &vattr, (char *)symname, &cvp, NULL, error);
if (likely(!error && cvp)) {
error = xfs_init_security(cvp, dir);
if (likely(!error)) {
ip = vn_to_inode(cvp);
d_instantiate(dentry, ip);
- xfs_validate_fields(dir, &va);
- xfs_validate_fields(ip, &va);
+ xfs_validate_fields(dir, &vattr);
+ xfs_validate_fields(ip, &vattr);
} else {
xfs_cleanup_inode(dvp, cvp, dentry, 0);
}
struct dentry *dentry)
{
struct inode *inode = dentry->d_inode;
- bhv_vnode_t *dvp = vn_from_inode(dir);
- bhv_vattr_t vattr;
+ vnode_t *dvp = vn_from_inode(dir);
+ vattr_t vattr;
int error;
- error = bhv_vop_rmdir(dvp, dentry, NULL);
+ VOP_RMDIR(dvp, dentry, NULL, error);
if (likely(!error)) {
xfs_validate_fields(inode, &vattr);
xfs_validate_fields(dir, &vattr);
struct dentry *ndentry)
{
struct inode *new_inode = ndentry->d_inode;
- bhv_vnode_t *fvp; /* from directory */
- bhv_vnode_t *tvp; /* target directory */
- bhv_vattr_t vattr;
+ vnode_t *fvp; /* from directory */
+ vnode_t *tvp; /* target directory */
+ vattr_t vattr;
int error;
fvp = vn_from_inode(odir);
tvp = vn_from_inode(ndir);
- error = bhv_vop_rename(fvp, odentry, tvp, ndentry, NULL);
+ VOP_RENAME(fvp, odentry, tvp, ndentry, NULL, error);
if (likely(!error)) {
if (new_inode)
xfs_validate_fields(new_inode, &vattr);
struct dentry *dentry,
struct nameidata *nd)
{
- bhv_vnode_t *vp;
+ vnode_t *vp;
uio_t *uio;
iovec_t iov;
int error;
uio->uio_resid = MAXPATHLEN;
uio->uio_iovcnt = 1;
- error = bhv_vop_readlink(vp, uio, 0, NULL);
- if (unlikely(error)) {
+ VOP_READLINK(vp, uio, 0, NULL, error);
+ if (error) {
kfree(link);
link = ERR_PTR(-error);
} else {
int mode,
struct nameidata *nd)
{
- return -bhv_vop_access(vn_from_inode(inode), mode << 6, NULL);
+ vnode_t *vp = vn_from_inode(inode);
+ int error;
+
+ mode <<= 6; /* convert from linux to vnode access bits */
+ VOP_ACCESS(vp, mode, NULL, error);
+ return -error;
}
#else
#define xfs_vn_permission NULL
struct kstat *stat)
{
struct inode *inode = dentry->d_inode;
- bhv_vnode_t *vp = vn_from_inode(inode);
- bhv_vattr_t vattr = { .va_mask = XFS_AT_STAT };
- int error;
+ vnode_t *vp = vn_from_inode(inode);
+ int error = 0;
- error = bhv_vop_getattr(vp, &vattr, ATTR_LAZY, NULL);
- if (likely(!error)) {
- stat->size = i_size_read(inode);
- stat->dev = inode->i_sb->s_dev;
- stat->rdev = (vattr.va_rdev == 0) ? 0 :
- MKDEV(sysv_major(vattr.va_rdev) & 0x1ff,
- sysv_minor(vattr.va_rdev));
- stat->mode = vattr.va_mode;
- stat->nlink = vattr.va_nlink;
- stat->uid = vattr.va_uid;
- stat->gid = vattr.va_gid;
- stat->ino = vattr.va_nodeid;
- stat->atime = vattr.va_atime;
- stat->mtime = vattr.va_mtime;
- stat->ctime = vattr.va_ctime;
- stat->blocks = vattr.va_nblocks;
- stat->blksize = vattr.va_blocksize;
- }
- return -error;
+ if (unlikely(vp->v_flag & VMODIFIED))
+ error = vn_revalidate(vp);
+ if (!error)
+ generic_fillattr(inode, stat);
+ return 0;
}
STATIC int
{
struct inode *inode = dentry->d_inode;
unsigned int ia_valid = attr->ia_valid;
- bhv_vnode_t *vp = vn_from_inode(inode);
- bhv_vattr_t vattr = { 0 };
+ vnode_t *vp = vn_from_inode(inode);
+ vattr_t vattr = { 0 };
int flags = 0;
int error;
flags |= ATTR_NONBLOCK;
#endif
- error = bhv_vop_setattr(vp, &vattr, flags, NULL);
+ VOP_SETATTR(vp, &vattr, flags, NULL, error);
if (likely(!error))
__vn_revalidate(vp, &vattr);
return -error;
xfs_vn_sync_flags(struct inode *inode)
{
unsigned int oldflags, newflags;
+ vattr_t vattr;
int flags = 0;
int error;
- bhv_vattr_t vattr;
- bhv_vnode_t *vp = vn_from_inode(inode);
+ vnode_t *vp = vn_from_inode(inode);
- memset(&vattr, 0, sizeof vattr);
+ memset(&vattr, 0, sizeof(vattr_t));
vattr.va_mask = XFS_AT_XFLAGS;
- error = bhv_vop_getattr(vp, &vattr, 0, NULL);
-
+ VOP_GETATTR(vp, &vattr, 0, NULL, error);
if (error)
return error;
oldflags = vattr.va_xflags;
if (oldflags ^ newflags) {
vattr.va_xflags = newflags;
vattr.va_mask |= XFS_AT_XFLAGS;
- error = bhv_vop_setattr(vp, &vattr, flags, NULL);
+ VOP_SETATTR(vp, &vattr, flags, NULL, error);
}
vn_revalidate(vp);
return error;
size_t size,
int flags)
{
- bhv_vnode_t *vp = vn_from_inode(dentry->d_inode);
+ vnode_t *vp = vn_from_inode(dentry->d_inode);
char *attr = (char *)name;
attrnames_t *namesp;
int xflags = 0;
void *data,
size_t size)
{
- bhv_vnode_t *vp = vn_from_inode(dentry->d_inode);
+ vnode_t *vp = vn_from_inode(dentry->d_inode);
char *attr = (char *)name;
attrnames_t *namesp;
int xflags = 0;
char *data,
size_t size)
{
- bhv_vnode_t *vp = vn_from_inode(dentry->d_inode);
+ vnode_t *vp = vn_from_inode(dentry->d_inode);
int error, xflags = ATTR_KERNAMELS;
ssize_t result;
struct dentry *dentry,
const char *name)
{
- bhv_vnode_t *vp = vn_from_inode(dentry->d_inode);
+ vnode_t *vp = vn_from_inode(dentry->d_inode);
char *attr = (char *)name;
attrnames_t *namesp;
int xflags = 0;
git://git.onelab.eu / linux-2.6.git / blobdiff