Merge git://oss.sgi.com:8090/oss/git/xfs-2.6

[pandora-kernel.git] / fs / xfs / linux-2.6 / xfs_ioctl.c

diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 4db4779..8447849 100644 (file)
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -138,7 +138,7 @@ xfs_find_handle(
        }
 
        /* we need the vnode */
-       vp = LINVFS_GET_VP(inode);
+       vp = vn_from_inode(inode);
 
        /* now we can grab the fsid */
        memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t));
@@ -256,7 +256,7 @@ xfs_vget_fsop_handlereq(
        }
 
        vpp = XFS_ITOV(ip);
-       inodep = LINVFS_GET_IP(vpp);
+       inodep = vn_to_inode(vpp);
        xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
        *vp = vpp;
@@ -344,7 +344,7 @@ xfs_open_by_handle(
                return -XFS_ERROR(-PTR_ERR(filp));
        }
        if (inode->i_mode & S_IFREG)
-               filp->f_op = &linvfs_invis_file_operations;
+               filp->f_op = &xfs_invis_file_operations;
 
        fd_install(new_fd, filp);
        return new_fd;
@@ -715,7 +715,7 @@ xfs_ioctl(
        xfs_inode_t             *ip;
        xfs_mount_t             *mp;
 
-       vp = LINVFS_GET_VP(inode);
+       vp = vn_from_inode(inode);
 
        vn_trace_entry(vp, "xfs_ioctl", (inst_t *)__return_address);
 
@@ -1160,105 +1160,129 @@ xfs_ioc_xattr(
        void                    __user *arg)
 {
        struct fsxattr          fa;
-       vattr_t                 va;
-       int                     error;
+       struct vattr            *vattr;
+       int                     error = 0;
        int                     attr_flags;
        unsigned int            flags;
 
+       vattr = kmalloc(sizeof(*vattr), GFP_KERNEL);
+       if (unlikely(!vattr))
+               return -ENOMEM;
+
        switch (cmd) {
        case XFS_IOC_FSGETXATTR: {
-               va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
-                            XFS_AT_NEXTENTS | XFS_AT_PROJID;
-               VOP_GETATTR(vp, &va, 0, NULL, error);
-               if (error)
-                       return -error;
+               vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
+                                XFS_AT_NEXTENTS | XFS_AT_PROJID;
+               VOP_GETATTR(vp, vattr, 0, NULL, error);
+               if (unlikely(error)) {
+                       error = -error;
+                       break;
+               }
 
-               fa.fsx_xflags   = va.va_xflags;
-               fa.fsx_extsize  = va.va_extsize;
-               fa.fsx_nextents = va.va_nextents;
-               fa.fsx_projid   = va.va_projid;
+               fa.fsx_xflags   = vattr->va_xflags;
+               fa.fsx_extsize  = vattr->va_extsize;
+               fa.fsx_nextents = vattr->va_nextents;
+               fa.fsx_projid   = vattr->va_projid;
 
-               if (copy_to_user(arg, &fa, sizeof(fa)))
-                       return -XFS_ERROR(EFAULT);
-               return 0;
+               if (copy_to_user(arg, &fa, sizeof(fa))) {
+                       error = -EFAULT;
+                       break;
+               }
+               break;
        }
 
        case XFS_IOC_FSSETXATTR: {
-               if (copy_from_user(&fa, arg, sizeof(fa)))
-                       return -XFS_ERROR(EFAULT);
+               if (copy_from_user(&fa, arg, sizeof(fa))) {
+                       error = -EFAULT;
+                       break;
+               }
 
                attr_flags = 0;
                if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
                        attr_flags |= ATTR_NONBLOCK;
 
-               va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
-               va.va_xflags  = fa.fsx_xflags;
-               va.va_extsize = fa.fsx_extsize;
-               va.va_projid  = fa.fsx_projid;
+               vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | XFS_AT_PROJID;
+               vattr->va_xflags  = fa.fsx_xflags;
+               vattr->va_extsize = fa.fsx_extsize;
+               vattr->va_projid  = fa.fsx_projid;
 
-               VOP_SETATTR(vp, &va, attr_flags, NULL, error);
-               if (!error)
-                       vn_revalidate(vp);      /* update Linux inode flags */
-               return -error;
+               VOP_SETATTR(vp, vattr, attr_flags, NULL, error);
+               if (likely(!error))
+                       __vn_revalidate(vp, vattr);     /* update flags */
+               error = -error;
+               break;
        }
 
        case XFS_IOC_FSGETXATTRA: {
-               va.va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
-                            XFS_AT_ANEXTENTS | XFS_AT_PROJID;
-               VOP_GETATTR(vp, &va, 0, NULL, error);
-               if (error)
-                       return -error;
+               vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
+                                XFS_AT_ANEXTENTS | XFS_AT_PROJID;
+               VOP_GETATTR(vp, vattr, 0, NULL, error);
+               if (unlikely(error)) {
+                       error = -error;
+                       break;
+               }
 
-               fa.fsx_xflags   = va.va_xflags;
-               fa.fsx_extsize  = va.va_extsize;
-               fa.fsx_nextents = va.va_anextents;
-               fa.fsx_projid   = va.va_projid;
+               fa.fsx_xflags   = vattr->va_xflags;
+               fa.fsx_extsize  = vattr->va_extsize;
+               fa.fsx_nextents = vattr->va_anextents;
+               fa.fsx_projid   = vattr->va_projid;
 
-               if (copy_to_user(arg, &fa, sizeof(fa)))
-                       return -XFS_ERROR(EFAULT);
-               return 0;
+               if (copy_to_user(arg, &fa, sizeof(fa))) {
+                       error = -EFAULT;
+                       break;
+               }
+               break;
        }
 
        case XFS_IOC_GETXFLAGS: {
                flags = xfs_di2lxflags(ip->i_d.di_flags);
                if (copy_to_user(arg, &flags, sizeof(flags)))
-                       return -XFS_ERROR(EFAULT);
-               return 0;
+                       error = -EFAULT;
+               break;
        }
 
        case XFS_IOC_SETXFLAGS: {
-               if (copy_from_user(&flags, arg, sizeof(flags)))
-                       return -XFS_ERROR(EFAULT);
+               if (copy_from_user(&flags, arg, sizeof(flags))) {
+                       error = -EFAULT;
+                       break;
+               }
 
                if (flags & ~(LINUX_XFLAG_IMMUTABLE | LINUX_XFLAG_APPEND | \
                              LINUX_XFLAG_NOATIME | LINUX_XFLAG_NODUMP | \
-                             LINUX_XFLAG_SYNC))
-                       return -XFS_ERROR(EOPNOTSUPP);
+                             LINUX_XFLAG_SYNC)) {
+                       error = -EOPNOTSUPP;
+                       break;
+               }
 
                attr_flags = 0;
                if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
                        attr_flags |= ATTR_NONBLOCK;
 
-               va.va_mask = XFS_AT_XFLAGS;
-               va.va_xflags = xfs_merge_ioc_xflags(flags,
-                               xfs_ip2xflags(ip));
+               vattr->va_mask = XFS_AT_XFLAGS;
+               vattr->va_xflags = xfs_merge_ioc_xflags(flags,
+                                                       xfs_ip2xflags(ip));
 
-               VOP_SETATTR(vp, &va, attr_flags, NULL, error);
-               if (!error)
-                       vn_revalidate(vp);      /* update Linux inode flags */
-               return -error;
+               VOP_SETATTR(vp, vattr, attr_flags, NULL, error);
+               if (likely(!error))
+                       __vn_revalidate(vp, vattr);     /* update flags */
+               error = -error;
+               break;
        }
 
        case XFS_IOC_GETVERSION: {
-               flags = LINVFS_GET_IP(vp)->i_generation;
+               flags = vn_to_inode(vp)->i_generation;
                if (copy_to_user(arg, &flags, sizeof(flags)))
-                       return -XFS_ERROR(EFAULT);
-               return 0;
+                       error = -EFAULT;
+               break;
        }
 
        default:
-               return -ENOTTY;
+               error = -ENOTTY;
+               break;
        }
+
+       kfree(vattr);
+       return error;
 }
 
 STATIC int