diff options
Diffstat (limited to 'fs')
-rw-r--r-- | fs/xfs/linux-2.6/xfs_ioctl.c | 16 | ||||
-rw-r--r-- | fs/xfs/linux-2.6/xfs_iops.c | 6 | ||||
-rw-r--r-- | fs/xfs/linux-2.6/xfs_super.c | 35 | ||||
-rw-r--r-- | fs/xfs/linux-2.6/xfs_vnode.c | 16 | ||||
-rw-r--r-- | fs/xfs/linux-2.6/xfs_vnode.h | 26 | ||||
-rw-r--r-- | fs/xfs/xfs_acl.c | 6 | ||||
-rw-r--r-- | fs/xfs/xfs_inode.c | 3 | ||||
-rw-r--r-- | fs/xfs/xfs_vnodeops.c | 45 |
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( | |||
141 | return -XFS_ERROR(EINVAL); | 141 | return -XFS_ERROR(EINVAL); |
142 | } | 142 | } |
143 | 143 | ||
144 | /* we need the vnode */ | 144 | switch (inode->i_mode & S_IFMT) { |
145 | vp = LINVFS_GET_VP(inode); | 145 | case S_IFREG: |
146 | if (vp->v_type != VREG && vp->v_type != VDIR && vp->v_type != VLNK) { | 146 | case S_IFDIR: |
147 | case S_IFLNK: | ||
148 | break; | ||
149 | default: | ||
147 | iput(inode); | 150 | iput(inode); |
148 | return -XFS_ERROR(EBADF); | 151 | return -XFS_ERROR(EBADF); |
149 | } | 152 | } |
150 | 153 | ||
154 | /* we need the vnode */ | ||
155 | vp = LINVFS_GET_VP(inode); | ||
156 | |||
151 | /* now we can grab the fsid */ | 157 | /* now we can grab the fsid */ |
152 | memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t)); | 158 | memcpy(&handle.ha_fsid, vp->v_vfsp->vfs_altfsid, sizeof(xfs_fsid_t)); |
153 | hsize = sizeof(xfs_fsid_t); | 159 | hsize = sizeof(xfs_fsid_t); |
@@ -386,7 +392,7 @@ xfs_readlink_by_handle( | |||
386 | return -error; | 392 | return -error; |
387 | 393 | ||
388 | /* Restrict this handle operation to symlinks only. */ | 394 | /* Restrict this handle operation to symlinks only. */ |
389 | if (vp->v_type != VLNK) { | 395 | if (!S_ISLNK(inode->i_mode)) { |
390 | VN_RELE(vp); | 396 | VN_RELE(vp); |
391 | return -XFS_ERROR(EINVAL); | 397 | return -XFS_ERROR(EINVAL); |
392 | } | 398 | } |
@@ -985,7 +991,7 @@ xfs_ioc_space( | |||
985 | if (!(filp->f_mode & FMODE_WRITE)) | 991 | if (!(filp->f_mode & FMODE_WRITE)) |
986 | return -XFS_ERROR(EBADF); | 992 | return -XFS_ERROR(EBADF); |
987 | 993 | ||
988 | if (vp->v_type != VREG) | 994 | if (!VN_ISREG(vp)) |
989 | return -XFS_ERROR(EINVAL); | 995 | return -XFS_ERROR(EINVAL); |
990 | 996 | ||
991 | if (copy_from_user(&bf, arg, sizeof(bf))) | 997 | 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( | |||
140 | 140 | ||
141 | memset(&va, 0, sizeof(va)); | 141 | memset(&va, 0, sizeof(va)); |
142 | va.va_mask = XFS_AT_TYPE|XFS_AT_MODE; | 142 | va.va_mask = XFS_AT_TYPE|XFS_AT_MODE; |
143 | va.va_type = IFTOVT(mode); | ||
144 | va.va_mode = mode; | 143 | va.va_mode = mode; |
145 | 144 | ||
146 | switch (mode & S_IFMT) { | 145 | switch (mode & S_IFMT) { |
@@ -308,14 +307,13 @@ linvfs_symlink( | |||
308 | cvp = NULL; | 307 | cvp = NULL; |
309 | 308 | ||
310 | memset(&va, 0, sizeof(va)); | 309 | memset(&va, 0, sizeof(va)); |
311 | va.va_type = VLNK; | 310 | va.va_mode = S_IFLNK | |
312 | va.va_mode = irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO; | 311 | (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO); |
313 | va.va_mask = XFS_AT_TYPE|XFS_AT_MODE; | 312 | va.va_mask = XFS_AT_TYPE|XFS_AT_MODE; |
314 | 313 | ||
315 | error = 0; | 314 | error = 0; |
316 | VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error); | 315 | VOP_SYMLINK(dvp, dentry, &va, (char *)symname, &cvp, NULL, error); |
317 | if (!error && cvp) { | 316 | if (!error && cvp) { |
318 | ASSERT(cvp->v_type == VLNK); | ||
319 | ip = LINVFS_GET_IP(cvp); | 317 | ip = LINVFS_GET_IP(cvp); |
320 | d_instantiate(dentry, ip); | 318 | d_instantiate(dentry, ip); |
321 | validate_fields(dir); | 319 | 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 | |||
138 | xfs_set_inodeops( | 138 | xfs_set_inodeops( |
139 | struct inode *inode) | 139 | struct inode *inode) |
140 | { | 140 | { |
141 | vnode_t *vp = LINVFS_GET_VP(inode); | 141 | switch (inode->i_mode & S_IFMT) { |
142 | 142 | case S_IFREG: | |
143 | if (vp->v_type == VNON) { | ||
144 | vn_mark_bad(vp); | ||
145 | } else if (S_ISREG(inode->i_mode)) { | ||
146 | inode->i_op = &linvfs_file_inode_operations; | 143 | inode->i_op = &linvfs_file_inode_operations; |
147 | inode->i_fop = &linvfs_file_operations; | 144 | inode->i_fop = &linvfs_file_operations; |
148 | inode->i_mapping->a_ops = &linvfs_aops; | 145 | inode->i_mapping->a_ops = &linvfs_aops; |
149 | } else if (S_ISDIR(inode->i_mode)) { | 146 | break; |
147 | case S_IFDIR: | ||
150 | inode->i_op = &linvfs_dir_inode_operations; | 148 | inode->i_op = &linvfs_dir_inode_operations; |
151 | inode->i_fop = &linvfs_dir_operations; | 149 | inode->i_fop = &linvfs_dir_operations; |
152 | } else if (S_ISLNK(inode->i_mode)) { | 150 | break; |
151 | case S_IFLNK: | ||
153 | inode->i_op = &linvfs_symlink_inode_operations; | 152 | inode->i_op = &linvfs_symlink_inode_operations; |
154 | if (inode->i_blocks) | 153 | if (inode->i_blocks) |
155 | inode->i_mapping->a_ops = &linvfs_aops; | 154 | inode->i_mapping->a_ops = &linvfs_aops; |
156 | } else { | 155 | break; |
156 | default: | ||
157 | inode->i_op = &linvfs_file_inode_operations; | 157 | inode->i_op = &linvfs_file_inode_operations; |
158 | init_special_inode(inode, inode->i_mode, inode->i_rdev); | 158 | init_special_inode(inode, inode->i_mode, inode->i_rdev); |
159 | break; | ||
159 | } | 160 | } |
160 | } | 161 | } |
161 | 162 | ||
@@ -167,16 +168,23 @@ xfs_revalidate_inode( | |||
167 | { | 168 | { |
168 | struct inode *inode = LINVFS_GET_IP(vp); | 169 | struct inode *inode = LINVFS_GET_IP(vp); |
169 | 170 | ||
170 | inode->i_mode = (ip->i_d.di_mode & MODEMASK) | VTTOIF(vp->v_type); | 171 | inode->i_mode = ip->i_d.di_mode; |
171 | inode->i_nlink = ip->i_d.di_nlink; | 172 | inode->i_nlink = ip->i_d.di_nlink; |
172 | inode->i_uid = ip->i_d.di_uid; | 173 | inode->i_uid = ip->i_d.di_uid; |
173 | inode->i_gid = ip->i_d.di_gid; | 174 | inode->i_gid = ip->i_d.di_gid; |
174 | if (((1 << vp->v_type) & ((1<<VBLK) | (1<<VCHR))) == 0) { | 175 | |
176 | switch (inode->i_mode & S_IFMT) { | ||
177 | case S_IFBLK: | ||
178 | case S_IFCHR: | ||
179 | inode->i_rdev = | ||
180 | MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff, | ||
181 | sysv_minor(ip->i_df.if_u2.if_rdev)); | ||
182 | break; | ||
183 | default: | ||
175 | inode->i_rdev = 0; | 184 | inode->i_rdev = 0; |
176 | } else { | 185 | break; |
177 | xfs_dev_t dev = ip->i_df.if_u2.if_rdev; | ||
178 | inode->i_rdev = MKDEV(sysv_major(dev) & 0x1ff, sysv_minor(dev)); | ||
179 | } | 186 | } |
187 | |||
180 | inode->i_blksize = PAGE_CACHE_SIZE; | 188 | inode->i_blksize = PAGE_CACHE_SIZE; |
181 | inode->i_generation = ip->i_d.di_gen; | 189 | inode->i_generation = ip->i_d.di_gen; |
182 | i_size_write(inode, ip->i_d.di_size); | 190 | i_size_write(inode, ip->i_d.di_size); |
@@ -231,7 +239,6 @@ xfs_initialize_vnode( | |||
231 | * finish our work. | 239 | * finish our work. |
232 | */ | 240 | */ |
233 | if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) { | 241 | if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) { |
234 | vp->v_type = IFTOVT(ip->i_d.di_mode); | ||
235 | xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip); | 242 | xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip); |
236 | xfs_set_inodeops(inode); | 243 | xfs_set_inodeops(inode); |
237 | 244 | ||
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); | |||
44 | #define vptosync(v) (&vsync[((unsigned long)v) % NVSYNC]) | 44 | #define vptosync(v) (&vsync[((unsigned long)v) % NVSYNC]) |
45 | sv_t vsync[NVSYNC]; | 45 | sv_t vsync[NVSYNC]; |
46 | 46 | ||
47 | /* | ||
48 | * Translate stat(2) file types to vnode types and vice versa. | ||
49 | * Aware of numeric order of S_IFMT and vnode type values. | ||
50 | */ | ||
51 | enum vtype iftovt_tab[] = { | ||
52 | VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, | ||
53 | VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VNON | ||
54 | }; | ||
55 | |||
56 | u_short vttoif_tab[] = { | ||
57 | 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO, 0, S_IFSOCK | ||
58 | }; | ||
59 | |||
60 | 47 | ||
61 | void | 48 | void |
62 | vn_init(void) | 49 | vn_init(void) |
@@ -95,7 +82,6 @@ vn_reclaim( | |||
95 | vp->v_flag &= (VRECLM|VWAIT); | 82 | vp->v_flag &= (VRECLM|VWAIT); |
96 | VN_UNLOCK(vp, 0); | 83 | VN_UNLOCK(vp, 0); |
97 | 84 | ||
98 | vp->v_type = VNON; | ||
99 | vp->v_fbhv = NULL; | 85 | vp->v_fbhv = NULL; |
100 | 86 | ||
101 | #ifdef XFS_VNODE_TRACE | 87 | #ifdef XFS_VNODE_TRACE |
@@ -174,7 +160,7 @@ vn_revalidate_core( | |||
174 | { | 160 | { |
175 | struct inode *inode = LINVFS_GET_IP(vp); | 161 | struct inode *inode = LINVFS_GET_IP(vp); |
176 | 162 | ||
177 | inode->i_mode = VTTOIF(vap->va_type) | vap->va_mode; | 163 | inode->i_mode = vap->va_mode; |
178 | inode->i_nlink = vap->va_nlink; | 164 | inode->i_nlink = vap->va_nlink; |
179 | inode->i_uid = vap->va_uid; | 165 | inode->i_uid = vap->va_uid; |
180 | inode->i_gid = vap->va_gid; | 166 | 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; | |||
65 | struct xfs_iomap; | 65 | struct xfs_iomap; |
66 | struct attrlist_cursor_kern; | 66 | struct attrlist_cursor_kern; |
67 | 67 | ||
68 | /* | ||
69 | * Vnode types. VNON means no type. | ||
70 | */ | ||
71 | enum vtype { VNON, VREG, VDIR, VBLK, VCHR, VLNK, VFIFO, VBAD, VSOCK }; | ||
72 | 68 | ||
73 | typedef xfs_ino_t vnumber_t; | 69 | typedef xfs_ino_t vnumber_t; |
74 | typedef struct dentry vname_t; | 70 | typedef struct dentry vname_t; |
@@ -77,11 +73,9 @@ typedef bhv_head_t vn_bhv_head_t; | |||
77 | /* | 73 | /* |
78 | * MP locking protocols: | 74 | * MP locking protocols: |
79 | * v_flag, v_vfsp VN_LOCK/VN_UNLOCK | 75 | * v_flag, v_vfsp VN_LOCK/VN_UNLOCK |
80 | * v_type read-only or fs-dependent | ||
81 | */ | 76 | */ |
82 | typedef struct vnode { | 77 | typedef struct vnode { |
83 | __u32 v_flag; /* vnode flags (see below) */ | 78 | __u32 v_flag; /* vnode flags (see below) */ |
84 | enum vtype v_type; /* vnode type */ | ||
85 | struct vfs *v_vfsp; /* ptr to containing VFS */ | 79 | struct vfs *v_vfsp; /* ptr to containing VFS */ |
86 | vnumber_t v_number; /* in-core vnode number */ | 80 | vnumber_t v_number; /* in-core vnode number */ |
87 | vn_bhv_head_t v_bh; /* behavior head */ | 81 | vn_bhv_head_t v_bh; /* behavior head */ |
@@ -93,6 +87,12 @@ typedef struct vnode { | |||
93 | /* inode MUST be last */ | 87 | /* inode MUST be last */ |
94 | } vnode_t; | 88 | } vnode_t; |
95 | 89 | ||
90 | #define VN_ISLNK(vp) S_ISLNK((vp)->v_inode.i_mode) | ||
91 | #define VN_ISREG(vp) S_ISREG((vp)->v_inode.i_mode) | ||
92 | #define VN_ISDIR(vp) S_ISDIR((vp)->v_inode.i_mode) | ||
93 | #define VN_ISCHR(vp) S_ISCHR((vp)->v_inode.i_mode) | ||
94 | #define VN_ISBLK(vp) S_ISBLK((vp)->v_inode.i_mode) | ||
95 | |||
96 | #define v_fbhv v_bh.bh_first /* first behavior */ | 96 | #define v_fbhv v_bh.bh_first /* first behavior */ |
97 | #define v_fops v_bh.bh_first->bd_ops /* first behavior ops */ | 97 | #define v_fops v_bh.bh_first->bd_ops /* first behavior ops */ |
98 | 98 | ||
@@ -133,17 +133,6 @@ typedef enum { | |||
133 | #define LINVFS_GET_IP(vp) (&(vp)->v_inode) | 133 | #define LINVFS_GET_IP(vp) (&(vp)->v_inode) |
134 | 134 | ||
135 | /* | 135 | /* |
136 | * Convert between vnode types and inode formats (since POSIX.1 | ||
137 | * defines mode word of stat structure in terms of inode formats). | ||
138 | */ | ||
139 | extern enum vtype iftovt_tab[]; | ||
140 | extern u_short vttoif_tab[]; | ||
141 | #define IFTOVT(mode) (iftovt_tab[((mode) & S_IFMT) >> 12]) | ||
142 | #define VTTOIF(indx) (vttoif_tab[(int)(indx)]) | ||
143 | #define MAKEIMODE(indx, mode) (int)(VTTOIF(indx) | (mode)) | ||
144 | |||
145 | |||
146 | /* | ||
147 | * Vnode flags. | 136 | * Vnode flags. |
148 | */ | 137 | */ |
149 | #define VINACT 0x1 /* vnode is being inactivated */ | 138 | #define VINACT 0x1 /* vnode is being inactivated */ |
@@ -408,7 +397,6 @@ typedef struct vnodeops { | |||
408 | */ | 397 | */ |
409 | typedef struct vattr { | 398 | typedef struct vattr { |
410 | int va_mask; /* bit-mask of attributes present */ | 399 | int va_mask; /* bit-mask of attributes present */ |
411 | enum vtype va_type; /* vnode type (for create) */ | ||
412 | mode_t va_mode; /* file access mode and type */ | 400 | mode_t va_mode; /* file access mode and type */ |
413 | xfs_nlink_t va_nlink; /* number of references to file */ | 401 | xfs_nlink_t va_nlink; /* number of references to file */ |
414 | uid_t va_uid; /* owner user id */ | 402 | uid_t va_uid; /* owner user id */ |
@@ -498,7 +486,7 @@ typedef struct vattr { | |||
498 | * Check whether mandatory file locking is enabled. | 486 | * Check whether mandatory file locking is enabled. |
499 | */ | 487 | */ |
500 | #define MANDLOCK(vp, mode) \ | 488 | #define MANDLOCK(vp, mode) \ |
501 | ((vp)->v_type == VREG && ((mode) & (VSGID|(VEXEC>>3))) == VSGID) | 489 | (VN_ISREG(vp) && ((mode) & (VSGID|(VEXEC>>3))) == VSGID) |
502 | 490 | ||
503 | extern void vn_init(void); | 491 | extern void vn_init(void); |
504 | extern int vn_wait(struct vnode *); | 492 | 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( | |||
85 | { | 85 | { |
86 | int error; | 86 | int error; |
87 | 87 | ||
88 | if (vp->v_type != VDIR) | 88 | if (!VN_ISDIR(vp)) |
89 | return 0; | 89 | return 0; |
90 | xfs_acl_get_attr(vp, NULL, _ACL_TYPE_DEFAULT, ATTR_KERNOVAL, &error); | 90 | xfs_acl_get_attr(vp, NULL, _ACL_TYPE_DEFAULT, ATTR_KERNOVAL, &error); |
91 | return (error == 0); | 91 | return (error == 0); |
@@ -389,7 +389,7 @@ xfs_acl_allow_set( | |||
389 | 389 | ||
390 | if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND)) | 390 | if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND)) |
391 | return EPERM; | 391 | return EPERM; |
392 | if (kind == _ACL_TYPE_DEFAULT && vp->v_type != VDIR) | 392 | if (kind == _ACL_TYPE_DEFAULT && !VN_ISDIR(vp)) |
393 | return ENOTDIR; | 393 | return ENOTDIR; |
394 | if (vp->v_vfsp->vfs_flag & VFS_RDONLY) | 394 | if (vp->v_vfsp->vfs_flag & VFS_RDONLY) |
395 | return EROFS; | 395 | return EROFS; |
@@ -750,7 +750,7 @@ xfs_acl_inherit( | |||
750 | * If the new file is a directory, its default ACL is a copy of | 750 | * If the new file is a directory, its default ACL is a copy of |
751 | * the containing directory's default ACL. | 751 | * the containing directory's default ACL. |
752 | */ | 752 | */ |
753 | if (vp->v_type == VDIR) | 753 | if (VN_ISDIR(vp)) |
754 | xfs_acl_set_attr(vp, pdaclp, _ACL_TYPE_DEFAULT, &error); | 754 | xfs_acl_set_attr(vp, pdaclp, _ACL_TYPE_DEFAULT, &error); |
755 | if (!error && !basicperms) | 755 | if (!error && !basicperms) |
756 | xfs_acl_set_attr(vp, cacl, _ACL_TYPE_ACCESS, &error); | 756 | 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( | |||
1128 | ASSERT(ip != NULL); | 1128 | ASSERT(ip != NULL); |
1129 | 1129 | ||
1130 | vp = XFS_ITOV(ip); | 1130 | vp = XFS_ITOV(ip); |
1131 | vp->v_type = IFTOVT(mode); | ||
1132 | ip->i_d.di_mode = (__uint16_t)mode; | 1131 | ip->i_d.di_mode = (__uint16_t)mode; |
1133 | ip->i_d.di_onlink = 0; | 1132 | ip->i_d.di_onlink = 0; |
1134 | ip->i_d.di_nlink = nlink; | 1133 | ip->i_d.di_nlink = nlink; |
@@ -1250,7 +1249,7 @@ xfs_ialloc( | |||
1250 | */ | 1249 | */ |
1251 | xfs_trans_log_inode(tp, ip, flags); | 1250 | xfs_trans_log_inode(tp, ip, flags); |
1252 | 1251 | ||
1253 | /* now that we have a v_type we can set Linux inode ops (& unlock) */ | 1252 | /* now that we have an i_mode we can set Linux inode ops (& unlock) */ |
1254 | VFS_INIT_VNODE(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1); | 1253 | VFS_INIT_VNODE(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1); |
1255 | 1254 | ||
1256 | *ipp = ip; | 1255 | *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( | |||
104 | * If it's a directory with any blocks, read-ahead block 0 | 104 | * If it's a directory with any blocks, read-ahead block 0 |
105 | * as we're almost certain to have the next operation be a read there. | 105 | * as we're almost certain to have the next operation be a read there. |
106 | */ | 106 | */ |
107 | if (vp->v_type == VDIR && ip->i_d.di_nextents > 0) { | 107 | if (VN_ISDIR(vp) && ip->i_d.di_nextents > 0) { |
108 | mode = xfs_ilock_map_shared(ip); | 108 | mode = xfs_ilock_map_shared(ip); |
109 | if (ip->i_d.di_nextents > 0) | 109 | if (ip->i_d.di_nextents > 0) |
110 | (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK); | 110 | (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK); |
@@ -163,18 +163,21 @@ xfs_getattr( | |||
163 | /* | 163 | /* |
164 | * Copy from in-core inode. | 164 | * Copy from in-core inode. |
165 | */ | 165 | */ |
166 | vap->va_type = vp->v_type; | 166 | vap->va_mode = ip->i_d.di_mode; |
167 | vap->va_mode = ip->i_d.di_mode & MODEMASK; | ||
168 | vap->va_uid = ip->i_d.di_uid; | 167 | vap->va_uid = ip->i_d.di_uid; |
169 | vap->va_gid = ip->i_d.di_gid; | 168 | vap->va_gid = ip->i_d.di_gid; |
170 | vap->va_projid = ip->i_d.di_projid; | 169 | vap->va_projid = ip->i_d.di_projid; |
171 | 170 | ||
172 | /* | 171 | /* |
173 | * Check vnode type block/char vs. everything else. | 172 | * Check vnode type block/char vs. everything else. |
174 | * Do it with bitmask because that's faster than looking | ||
175 | * for multiple values individually. | ||
176 | */ | 173 | */ |
177 | if (((1 << vp->v_type) & ((1<<VBLK) | (1<<VCHR))) == 0) { | 174 | switch (ip->i_d.di_mode & S_IFMT) { |
175 | case S_IFBLK: | ||
176 | case S_IFCHR: | ||
177 | vap->va_rdev = ip->i_df.if_u2.if_rdev; | ||
178 | vap->va_blocksize = BLKDEV_IOSIZE; | ||
179 | break; | ||
180 | default: | ||
178 | vap->va_rdev = 0; | 181 | vap->va_rdev = 0; |
179 | 182 | ||
180 | if (!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) { | 183 | if (!(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) { |
@@ -224,9 +227,7 @@ xfs_getattr( | |||
224 | (ip->i_d.di_extsize << mp->m_sb.sb_blocklog) : | 227 | (ip->i_d.di_extsize << mp->m_sb.sb_blocklog) : |
225 | (mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog); | 228 | (mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog); |
226 | } | 229 | } |
227 | } else { | 230 | break; |
228 | vap->va_rdev = ip->i_df.if_u2.if_rdev; | ||
229 | vap->va_blocksize = BLKDEV_IOSIZE; | ||
230 | } | 231 | } |
231 | 232 | ||
232 | vap->va_atime.tv_sec = ip->i_d.di_atime.t_sec; | 233 | vap->va_atime.tv_sec = ip->i_d.di_atime.t_sec; |
@@ -468,7 +469,7 @@ xfs_setattr( | |||
468 | m |= S_ISGID; | 469 | m |= S_ISGID; |
469 | #if 0 | 470 | #if 0 |
470 | /* Linux allows this, Irix doesn't. */ | 471 | /* Linux allows this, Irix doesn't. */ |
471 | if ((vap->va_mode & S_ISVTX) && vp->v_type != VDIR) | 472 | if ((vap->va_mode & S_ISVTX) && !VN_ISDIR(vp)) |
472 | m |= S_ISVTX; | 473 | m |= S_ISVTX; |
473 | #endif | 474 | #endif |
474 | if (m && !capable(CAP_FSETID)) | 475 | if (m && !capable(CAP_FSETID)) |
@@ -546,10 +547,10 @@ xfs_setattr( | |||
546 | goto error_return; | 547 | goto error_return; |
547 | } | 548 | } |
548 | 549 | ||
549 | if (vp->v_type == VDIR) { | 550 | if (VN_ISDIR(vp)) { |
550 | code = XFS_ERROR(EISDIR); | 551 | code = XFS_ERROR(EISDIR); |
551 | goto error_return; | 552 | goto error_return; |
552 | } else if (vp->v_type != VREG) { | 553 | } else if (!VN_ISREG(vp)) { |
553 | code = XFS_ERROR(EINVAL); | 554 | code = XFS_ERROR(EINVAL); |
554 | goto error_return; | 555 | goto error_return; |
555 | } | 556 | } |
@@ -1567,7 +1568,7 @@ xfs_release( | |||
1567 | vp = BHV_TO_VNODE(bdp); | 1568 | vp = BHV_TO_VNODE(bdp); |
1568 | ip = XFS_BHVTOI(bdp); | 1569 | ip = XFS_BHVTOI(bdp); |
1569 | 1570 | ||
1570 | if ((vp->v_type != VREG) || (ip->i_d.di_mode == 0)) { | 1571 | if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0)) { |
1571 | return 0; | 1572 | return 0; |
1572 | } | 1573 | } |
1573 | 1574 | ||
@@ -1895,7 +1896,7 @@ xfs_create( | |||
1895 | dp = XFS_BHVTOI(dir_bdp); | 1896 | dp = XFS_BHVTOI(dir_bdp); |
1896 | mp = dp->i_mount; | 1897 | mp = dp->i_mount; |
1897 | 1898 | ||
1898 | dm_di_mode = vap->va_mode|VTTOIF(vap->va_type); | 1899 | dm_di_mode = vap->va_mode; |
1899 | namelen = VNAMELEN(dentry); | 1900 | namelen = VNAMELEN(dentry); |
1900 | 1901 | ||
1901 | if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) { | 1902 | if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) { |
@@ -1973,8 +1974,7 @@ xfs_create( | |||
1973 | (error = XFS_DIR_CANENTER(mp, tp, dp, name, namelen))) | 1974 | (error = XFS_DIR_CANENTER(mp, tp, dp, name, namelen))) |
1974 | goto error_return; | 1975 | goto error_return; |
1975 | rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0; | 1976 | rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0; |
1976 | error = xfs_dir_ialloc(&tp, dp, | 1977 | error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1, |
1977 | MAKEIMODE(vap->va_type,vap->va_mode), 1, | ||
1978 | rdev, credp, prid, resblks > 0, | 1978 | rdev, credp, prid, resblks > 0, |
1979 | &ip, &committed); | 1979 | &ip, &committed); |
1980 | if (error) { | 1980 | if (error) { |
@@ -2620,7 +2620,7 @@ xfs_link( | |||
2620 | vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address); | 2620 | vn_trace_entry(src_vp, __FUNCTION__, (inst_t *)__return_address); |
2621 | 2621 | ||
2622 | target_namelen = VNAMELEN(dentry); | 2622 | target_namelen = VNAMELEN(dentry); |
2623 | if (src_vp->v_type == VDIR) | 2623 | if (VN_ISDIR(src_vp)) |
2624 | return XFS_ERROR(EPERM); | 2624 | return XFS_ERROR(EPERM); |
2625 | 2625 | ||
2626 | src_bdp = vn_bhv_lookup_unlocked(VN_BHV_HEAD(src_vp), &xfs_vnodeops); | 2626 | src_bdp = vn_bhv_lookup_unlocked(VN_BHV_HEAD(src_vp), &xfs_vnodeops); |
@@ -2805,7 +2805,7 @@ xfs_mkdir( | |||
2805 | 2805 | ||
2806 | tp = NULL; | 2806 | tp = NULL; |
2807 | dp_joined_to_trans = B_FALSE; | 2807 | dp_joined_to_trans = B_FALSE; |
2808 | dm_di_mode = vap->va_mode|VTTOIF(vap->va_type); | 2808 | dm_di_mode = vap->va_mode; |
2809 | 2809 | ||
2810 | if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) { | 2810 | if (DM_EVENT_ENABLED(dir_vp->v_vfsp, dp, DM_EVENT_CREATE)) { |
2811 | error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE, | 2811 | error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE, |
@@ -2879,8 +2879,7 @@ xfs_mkdir( | |||
2879 | /* | 2879 | /* |
2880 | * create the directory inode. | 2880 | * create the directory inode. |
2881 | */ | 2881 | */ |
2882 | error = xfs_dir_ialloc(&tp, dp, | 2882 | error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 2, |
2883 | MAKEIMODE(vap->va_type,vap->va_mode), 2, | ||
2884 | 0, credp, prid, resblks > 0, | 2883 | 0, credp, prid, resblks > 0, |
2885 | &cdp, NULL); | 2884 | &cdp, NULL); |
2886 | if (error) { | 2885 | if (error) { |
@@ -3650,7 +3649,7 @@ xfs_rwlock( | |||
3650 | vnode_t *vp; | 3649 | vnode_t *vp; |
3651 | 3650 | ||
3652 | vp = BHV_TO_VNODE(bdp); | 3651 | vp = BHV_TO_VNODE(bdp); |
3653 | if (vp->v_type == VDIR) | 3652 | if (VN_ISDIR(vp)) |
3654 | return 1; | 3653 | return 1; |
3655 | ip = XFS_BHVTOI(bdp); | 3654 | ip = XFS_BHVTOI(bdp); |
3656 | if (locktype == VRWLOCK_WRITE) { | 3655 | if (locktype == VRWLOCK_WRITE) { |
@@ -3681,7 +3680,7 @@ xfs_rwunlock( | |||
3681 | vnode_t *vp; | 3680 | vnode_t *vp; |
3682 | 3681 | ||
3683 | vp = BHV_TO_VNODE(bdp); | 3682 | vp = BHV_TO_VNODE(bdp); |
3684 | if (vp->v_type == VDIR) | 3683 | if (VN_ISDIR(vp)) |
3685 | return; | 3684 | return; |
3686 | ip = XFS_BHVTOI(bdp); | 3685 | ip = XFS_BHVTOI(bdp); |
3687 | if (locktype == VRWLOCK_WRITE) { | 3686 | if (locktype == VRWLOCK_WRITE) { |
@@ -4567,7 +4566,7 @@ xfs_change_file_space( | |||
4567 | /* | 4566 | /* |
4568 | * must be a regular file and have write permission | 4567 | * must be a regular file and have write permission |
4569 | */ | 4568 | */ |
4570 | if (vp->v_type != VREG) | 4569 | if (!VN_ISREG(vp)) |
4571 | return XFS_ERROR(EINVAL); | 4570 | return XFS_ERROR(EINVAL); |
4572 | 4571 | ||
4573 | xfs_ilock(ip, XFS_ILOCK_SHARED); | 4572 | xfs_ilock(ip, XFS_ILOCK_SHARED); |