[XFS] remove struct vnode::v_type

SGI-PV: 936236
SGI-Modid: xfs-linux:xfs-kern:195878a

Signed-off-by: Christoph Hellwig <hch@sgi.com>
Signed-off-by: Nathan Scott <nathans@sgi.com>

8 files changed, 68 insertions, 85 deletions

diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 35cbd88e1a54..6a3326bcd8d0 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -141,13 +141,19 @@ xfs_find_handle(
                 return -XFS_ERROR(EINVAL);
         }
 
-        /* we need the vnode */
-        vp = LINVFS_GET_VP(inode);
-        if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) {
+        switch (inode->i_mode & S_IFMT) {
+        case S_IFREG:
+        case S_IFDIR:
+        case S_IFLNK:
+                break;
+        default:
                 iput(inode);
                 return -XFS_ERROR(EBADF);
         }
 
+        /* we need the vnode */
+        vp = LINVFS_GET_VP(inode);
+
         /* now we can grab the fsid */
         memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t));
         hsize = sizeof(xfs_fsid_t);
@@ -386,7 +392,7 @@ xfs_readlink_by_handle(
                 return -error;
 
         /* Restrict this handle operation to symlinks only. */
-        if (vp->v_type != VLNK) {
+        if (!S_ISLNK(inode->i_mode)) {
                 VN_RELE(vp);
                 return -XFS_ERROR(EINVAL);
         }
@@ -985,7 +991,7 @@ xfs_ioc_space(
         if (!(filp->f_mode & FMODE_WRITE))
                 return -XFS_ERROR(EBADF);
 
-        if (vp->v_type != VREG)
+        if (!VN_ISREG(vp))
                 return -XFS_ERROR(EINVAL);
 
         if (copy_from_user(&bf, arg, sizeof(bf)))
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index f252605514eb..d237cc5be767 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -140,7 +140,6 @@ linvfs_mknod(
 
         memset(&va, 0, sizeof(va));
         va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
-        va.va_type = IFTOVT(mode);
         va.va_mode = mode;
 
         switch (mode & S_IFMT) {
@@ -308,14 +307,13 @@ linvfs_symlink(
         cvp = NULL;
 
         memset(&va, 0, sizeof(va));
-        va.va_type = VLNK;
-        va.va_mode = irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO;
+        va.va_mode = S_IFLNK |
+                (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
         va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
 
         error = 0;
         VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error);
         if (!error && cvp) {
-                ASSERT(cvp->v_type == VLNK);
                 ip = LINVFS_GET_IP(cvp);
                 d_instantiate(dentry, ip);
                 validate_fields(dir);
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index f6dd7de25927..d2c8a11e22b8 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -138,24 +138,25 @@ STATIC __inline__ void
 xfs_set_inodeops(
         struct inode            *inode)
 {
-        vnode_t                 *vp = LINVFS_GET_VP(inode);
-
-        if (vp->v_type == VNON) {
-                vn_mark_bad(vp);
-        } else if (S_ISREG(inode->i_mode)) {
+        switch (inode->i_mode & S_IFMT) {
+        case S_IFREG:
                 inode->i_op = &linvfs_file_inode_operations;
                 inode->i_fop = &linvfs_file_operations;
                 inode->i_mapping->a_ops = &linvfs_aops;
-        } else if (S_ISDIR(inode->i_mode)) {
+                break;
+        case S_IFDIR:
                 inode->i_op = &linvfs_dir_inode_operations;
                 inode->i_fop = &linvfs_dir_operations;
-        } else if (S_ISLNK(inode->i_mode)) {
+                break;
+        case S_IFLNK:
                 inode->i_op = &linvfs_symlink_inode_operations;
                 if (inode->i_blocks)
                         inode->i_mapping->a_ops = &linvfs_aops;
-        } else {
+                break;
+        default:
                 inode->i_op = &linvfs_file_inode_operations;
                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
+                break;
         }
 }
 
@@ -167,16 +168,23 @@ xfs_revalidate_inode(
 {
         struct inode            *inode = LINVFS_GET_IP(vp);
 
-        inode->i_mode   = (ip->i_d.di_mode & MODEMASK) | VTTOIF(vp->v_type);
+        inode->i_mode   = ip->i_d.di_mode;
         inode->i_nlink  = ip->i_d.di_nlink;
         inode->i_uid    = ip->i_d.di_uid;
         inode->i_gid    = ip->i_d.di_gid;
-        if (((1 << vp->v_type) & ((1<<VBLK) | (1<<VCHR))) == 0) {
+
+        switch (inode->i_mode & S_IFMT) {
+        case S_IFBLK:
+        case S_IFCHR:
+                inode->i_rdev =
+                        MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
+                              sysv_minor(ip->i_df.if_u2.if_rdev));
+                break;
+        default:
                 inode->i_rdev = 0;
-        } else {
-                xfs_dev_t dev = ip->i_df.if_u2.if_rdev;
-                inode->i_rdev = MKDEV(sysv_major(dev) & 0x1ff, sysv_minor(dev));
+                break;
         }
+
         inode->i_blksize = PAGE_CACHE_SIZE;
         inode->i_generation = ip->i_d.di_gen;
         i_size_write(inode, ip->i_d.di_size);
@@ -231,7 +239,6 @@ xfs_initialize_vnode(
          * finish our work.
          */
         if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
-                vp->v_type = IFTOVT(ip->i_d.di_mode);
                 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
                 xfs_set_inodeops(inode);
         
diff --git a/fs/xfs/linux-2.6/xfs_vnode.c b/fs/xfs/linux-2.6/xfs_vnode.c
index 353276bda344..ad16af38e965 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.c
+++ b/fs/xfs/linux-2.6/xfs_vnode.c
@@ -44,19 +44,6 @@ DEFINE_SPINLOCK(vnumber_lock);
 #define vptosync(v)             (&vsync[((unsigned long)v) % NVSYNC])
 sv_t vsync[NVSYNC];
 
-/*
- * Translate stat(2) file types to vnode types and vice versa.
- * Aware of numeric order of S_IFMT and vnode type values.
- */
-enum vtype iftovt_tab[] = {
-        VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON,
-        VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VNON
-};
-
-u_short vttoif_tab[] = {
-        0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO, 0, S_IFSOCK
-};
-
 
 void
 vn_init(void)
@@ -95,7 +82,6 @@ vn_reclaim(
         vp->v_flag &= (VRECLM|VWAIT);
         VN_UNLOCK(vp, 0);
 
-        vp->v_type = VNON;
         vp->v_fbhv = NULL;
 
 #ifdef XFS_VNODE_TRACE
@@ -174,7 +160,7 @@ vn_revalidate_core(
 {
         struct inode    *inode = LINVFS_GET_IP(vp);
 
-        inode->i_mode       = VTTOIF(vap->va_type) | vap->va_mode;
+        inode->i_mode       = vap->va_mode;
         inode->i_nlink      = vap->va_nlink;
         inode->i_uid        = vap->va_uid;
         inode->i_gid        = vap->va_gid;
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 6cb0a01df25d..bc9ed722ba1e 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -65,10 +65,6 @@ struct vattr;
 struct xfs_iomap;
 struct attrlist_cursor_kern;
 
-/*
- * Vnode types.  VNON means no type.
- */
-enum vtype      { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VFIFO, VBAD, VSOCK };
 
 typedef xfs_ino_t vnumber_t;
 typedef struct dentry vname_t;
@@ -77,11 +73,9 @@ typedef bhv_head_t vn_bhv_head_t;
 /*
  * MP locking protocols:
  *      v_flag, v_vfsp                          VN_LOCK/VN_UNLOCK
- *      v_type                                  read-only or fs-dependent
  */
 typedef struct vnode {
         __u32           v_flag;                 /* vnode flags (see below) */
-        enum vtype      v_type;                 /* vnode type */
         struct vfs      *v_vfsp;                /* ptr to containing VFS */
         vnumber_t       v_number;               /* in-core vnode number */
         vn_bhv_head_t   v_bh;                   /* behavior head */
@@ -93,6 +87,12 @@ typedef struct vnode {
         /* inode MUST be last */
 } vnode_t;
 
+#define VN_ISLNK(vp)    S_ISLNK((vp)->v_inode.i_mode)
+#define VN_ISREG(vp)    S_ISREG((vp)->v_inode.i_mode)
+#define VN_ISDIR(vp)    S_ISDIR((vp)->v_inode.i_mode)
+#define VN_ISCHR(vp)    S_ISCHR((vp)->v_inode.i_mode)
+#define VN_ISBLK(vp)    S_ISBLK((vp)->v_inode.i_mode)
+
 #define v_fbhv                  v_bh.bh_first          /* first behavior */
 #define v_fops                  v_bh.bh_first->bd_ops  /* first behavior ops */
 
@@ -133,17 +133,6 @@ typedef enum {
 #define LINVFS_GET_IP(vp)       (&(vp)->v_inode)
 
 /*
- * Convert between vnode types and inode formats (since POSIX.1
- * defines mode word of stat structure in terms of inode formats).
- */
-extern enum vtype       iftovt_tab[];
-extern u_short          vttoif_tab[];
-#define IFTOVT(mode)    (iftovt_tab[((mode) & S_IFMT) >> 12])
-#define VTTOIF(indx)    (vttoif_tab[(int)(indx)])
-#define MAKEIMODE(indx, mode)   (int)(VTTOIF(indx) | (mode))
-
-
-/*
  * Vnode flags.
  */
 #define VINACT                 0x1      /* vnode is being inactivated   */
@@ -408,7 +397,6 @@ typedef struct vnodeops {
  */
 typedef struct vattr {
         int             va_mask;        /* bit-mask of attributes present */
-        enum vtype      va_type;        /* vnode type (for create) */
         mode_t          va_mode;        /* file access mode and type */
         xfs_nlink_t     va_nlink;       /* number of references to file */
         uid_t           va_uid;         /* owner user id */
@@ -498,7 +486,7 @@ typedef struct vattr {
  * Check whether mandatory file locking is enabled.
  */
 #define MANDLOCK(vp, mode)      \
-        ((vp)->v_type == VREG && ((mode) & (VSGID|(VEXEC>>3))) == VSGID)
+        (VN_ISREG(vp) && ((mode) & (VSGID|(VEXEC>>3))) == VSGID)
 
 extern void     vn_init(void);
 extern int      vn_wait(struct vnode *);
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 8d01dce8c532..92fd1d67f878 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -85,7 +85,7 @@ xfs_acl_vhasacl_default(
 {
         int             error;
 
-        if (vp->v_type != VDIR)
+        if (!VN_ISDIR(vp))
                 return 0;
         xfs_acl_get_attr(vp, NULL, _ACL_TYPE_DEFAULT, ATTR_KERNOVAL, &error);
         return (error == 0);
@@ -389,7 +389,7 @@ xfs_acl_allow_set(
 
         if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND))
                 return EPERM;
-        if (kind == _ACL_TYPE_DEFAULT && vp->v_type != VDIR)
+        if (kind == _ACL_TYPE_DEFAULT && !VN_ISDIR(vp))
                 return ENOTDIR;
         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
                 return EROFS;
@@ -750,7 +750,7 @@ xfs_acl_inherit(
          * If the new file is a directory, its default ACL is a copy of
          * the containing directory's default ACL.
          */
-        if (vp->v_type == VDIR)
+        if (VN_ISDIR(vp))
                 xfs_acl_set_attr(vp, pdaclp, _ACL_TYPE_DEFAULT, &error);
         if (!error && !basicperms)
                 xfs_acl_set_attr(vp, cacl, _ACL_TYPE_ACCESS, &error);
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 34bdf5909687..db43308aae93 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1128,7 +1128,6 @@ xfs_ialloc(
         ASSERT(ip != NULL);
 
         vp = XFS_ITOV(ip);
-        vp->v_type = IFTOVT(mode);
         ip->i_d.di_mode = (__uint16_t)mode;
         ip->i_d.di_onlink = 0;
         ip->i_d.di_nlink = nlink;
@@ -1250,7 +1249,7 @@ xfs_ialloc(
          */
         xfs_trans_log_inode(tp, ip, flags);
 
-        /* now that we have a v_type we can set Linux inode ops (& unlock) */
+        /* now that we have an i_mode  we can set Linux inode ops (& unlock) */
         VFS_INIT_VNODE(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1);
 
         *ipp = ip;
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 1377c868f3f4..c4aa24ff85a2 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -104,7 +104,7 @@ xfs_open(
          * If it's a directory with any blocks, read-ahead block 0
          * as we're almost certain to have the next operation be a read there.
          */
-        if (vp->v_type == VDIR && ip->i_d.di_nextents > 0) {
+        if (VN_ISDIR(vp) && ip->i_d.di_nextents > 0) {
                 mode = xfs_ilock_map_shared(ip);
                 if (ip->i_d.di_nextents > 0)
                         (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK);
@@ -163,18 +163,21 @@ xfs_getattr(
         /*
          * Copy from in-core inode.
          */
-        vap->va_type = vp->v_type;
-        vap->va_mode = ip->i_d.di_mode & MODEMASK;
+        vap->va_mode = ip->i_d.di_mode;
         vap->va_uid = ip->i_d.di_uid;
         vap->va_gid = ip->i_d.di_gid;
         vap->va_projid = ip->i_d.di_projid;
 
         /*
          * Check vnode type block/char vs. everything else.
-         * Do it with bitmask because that's faster than looking
-         * for multiple values individually.
          */
-        if (((1 << vp->v_type) & ((1<<VBLK) | (1<<VCHR))) == 0) {
+        switch (ip->i_d.di_mode & S_IFMT) {
+        case S_IFBLK:
+        case S_IFCHR:
+                vap->va_rdev = ip->i_df.if_u2.if_rdev;
+                vap->va_blocksize = BLKDEV_IOSIZE;
+                break;
+        default:
                 vap->va_rdev = 0;
 
                 if (!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) {
@@ -224,9 +227,7 @@ xfs_getattr(
                                 (ip->i_d.di_extsize << mp->m_sb.sb_blocklog) :
                                 (mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog);
                 }
-        } else {
-                vap->va_rdev = ip->i_df.if_u2.if_rdev;
-                vap->va_blocksize = BLKDEV_IOSIZE;
+                break;
         }
 
         vap->va_atime.tv_sec = ip->i_d.di_atime.t_sec;
@@ -468,7 +469,7 @@ xfs_setattr(
                                 m |= S_ISGID;
 #if 0
                         /* Linux allows this, Irix doesn't. */
-                        if ((vap->va_mode & S_ISVTX) && vp->v_type != VDIR)
+                        if ((vap->va_mode & S_ISVTX) && !VN_ISDIR(vp))
                                 m |= S_ISVTX;
 #endif
                         if (m && !capable(CAP_FSETID))
@@ -546,10 +547,10 @@ xfs_setattr(
                         goto error_return;
                 }
 
-                if (vp->v_type == VDIR) {
+                if (VN_ISDIR(vp)) {
                         code = XFS_ERROR(EISDIR);
                         goto error_return;
-                } else if (vp->v_type != VREG) {
+                } else if (!VN_ISREG(vp)) {
                         code = XFS_ERROR(EINVAL);
                         goto error_return;
                 }
@@ -1567,7 +1568,7 @@ xfs_release(
         vp = BHV_TO_VNODE(bdp);
         ip = XFS_BHVTOI(bdp);
 
-        if ((vp->v_type != VREG) || (ip->i_d.di_mode == 0)) {
+        if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0)) {
                 return 0;
         }
 
@@ -1895,7 +1896,7 @@ xfs_create(
         dp = XFS_BHVTOI(dir_bdp);
         mp = dp->i_mount;
 
-        dm_di_mode = vap->va_mode|VTTOIF(vap->va_type);
+        dm_di_mode = vap->va_mode;
         namelen = VNAMELEN(dentry);
 
         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
@@ -1973,8 +1974,7 @@ xfs_create(
             (error = XFS_DIR_CANENTER(mp, tp, dp, name, namelen)))
                 goto error_return;
         rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
-        error = xfs_dir_ialloc(&tp, dp,
-                        MAKEIMODE(vap->va_type,vap->va_mode), 1,
+        error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
                         rdev, credp, prid, resblks > 0,
                         &ip, &committed);
         if (error) {
@@ -2620,7 +2620,7 @@ xfs_link(
         vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address);
 
         target_namelen = VNAMELEN(dentry);
-        if (src_vp->v_type == VDIR)
+        if (VN_ISDIR(src_vp))
                 return XFS_ERROR(EPERM);
 
         src_bdp = vn_bhv_lookup_unlocked(VN_BHV_HEAD(src_vp), &xfs_vnodeops);
@@ -2805,7 +2805,7 @@ xfs_mkdir(
 
         tp = NULL;
         dp_joined_to_trans = B_FALSE;
-        dm_di_mode = vap->va_mode|VTTOIF(vap->va_type);
+        dm_di_mode = vap->va_mode;
 
         if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) {
                 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
@@ -2879,8 +2879,7 @@ xfs_mkdir(
         /*
          * create the directory inode.
          */
-        error = xfs_dir_ialloc(&tp, dp,
-                        MAKEIMODE(vap->va_type,vap->va_mode), 2,
+        error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 2,
                         0, credp, prid, resblks > 0,
                 &cdp, NULL);
         if (error) {
@@ -3650,7 +3649,7 @@ xfs_rwlock(
         vnode_t         *vp;
 
         vp = BHV_TO_VNODE(bdp);
-        if (vp->v_type == VDIR)
+        if (VN_ISDIR(vp))
                 return 1;
         ip = XFS_BHVTOI(bdp);
         if (locktype == VRWLOCK_WRITE) {
@@ -3681,7 +3680,7 @@ xfs_rwunlock(
         vnode_t         *vp;
 
         vp = BHV_TO_VNODE(bdp);
-        if (vp->v_type == VDIR)
+        if (VN_ISDIR(vp))
                 return;
         ip = XFS_BHVTOI(bdp);
         if (locktype == VRWLOCK_WRITE) {
@@ -4567,7 +4566,7 @@ xfs_change_file_space(
         /*
          * must be a regular file and have write permission
          */
-        if (vp->v_type != VREG)
+        if (!VN_ISREG(vp))
                 return XFS_ERROR(EINVAL);
 
         xfs_ilock(ip, XFS_ILOCK_SHARED);