diff options
author | Christoph Hellwig <hch@infradead.org> | 2008-04-22 03:33:33 -0400 |
---|---|---|
committer | Lachlan McIlroy <lachlan@redback.melbourne.sgi.com> | 2008-04-29 01:53:16 -0400 |
commit | 4e5dbb3498e74514b9936d691413afc55fb84ea9 (patch) | |
tree | 1ed8b98d33e243f404f9c7fa28c4b0e2a6016508 /fs/xfs | |
parent | 42173f6860af7e016a950a9a19a66679cfc46d98 (diff) |
[XFS] kill xfs_getattr
It's currently used by the ACL code to read di_mode/di_uid, but these are
simple 32bit scalar values we can just read directly without locking.
SGI-PV: 976035
SGI-Modid: xfs-linux-melb:xfs-kern:30897a
Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Diffstat (limited to 'fs/xfs')
-rw-r--r-- | fs/xfs/xfs_acl.c | 40 | ||||
-rw-r--r-- | fs/xfs/xfs_vnodeops.c | 126 | ||||
-rw-r--r-- | fs/xfs/xfs_vnodeops.h | 1 |
3 files changed, 7 insertions, 160 deletions
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c index b1275cc45617..796e76ef2713 100644 --- a/fs/xfs/xfs_acl.c +++ b/fs/xfs/xfs_acl.c | |||
@@ -238,15 +238,8 @@ xfs_acl_vget( | |||
238 | error = EINVAL; | 238 | error = EINVAL; |
239 | goto out; | 239 | goto out; |
240 | } | 240 | } |
241 | if (kind == _ACL_TYPE_ACCESS) { | 241 | if (kind == _ACL_TYPE_ACCESS) |
242 | bhv_vattr_t va; | 242 | xfs_acl_sync_mode(xfs_vtoi(vp)->i_d.di_mode, xfs_acl); |
243 | |||
244 | va.va_mask = XFS_AT_MODE; | ||
245 | error = xfs_getattr(xfs_vtoi(vp), &va, 0); | ||
246 | if (error) | ||
247 | goto out; | ||
248 | xfs_acl_sync_mode(va.va_mode, xfs_acl); | ||
249 | } | ||
250 | error = -posix_acl_xfs_to_xattr(xfs_acl, ext_acl, size); | 243 | error = -posix_acl_xfs_to_xattr(xfs_acl, ext_acl, size); |
251 | } | 244 | } |
252 | out: | 245 | out: |
@@ -373,23 +366,15 @@ xfs_acl_allow_set( | |||
373 | bhv_vnode_t *vp, | 366 | bhv_vnode_t *vp, |
374 | int kind) | 367 | int kind) |
375 | { | 368 | { |
376 | xfs_inode_t *ip = xfs_vtoi(vp); | ||
377 | bhv_vattr_t va; | ||
378 | int error; | ||
379 | |||
380 | if (vp->i_flags & (S_IMMUTABLE|S_APPEND)) | 369 | if (vp->i_flags & (S_IMMUTABLE|S_APPEND)) |
381 | return EPERM; | 370 | return EPERM; |
382 | if (kind == _ACL_TYPE_DEFAULT && !S_ISDIR(vp->i_mode)) | 371 | if (kind == _ACL_TYPE_DEFAULT && !S_ISDIR(vp->i_mode)) |
383 | return ENOTDIR; | 372 | return ENOTDIR; |
384 | if (vp->i_sb->s_flags & MS_RDONLY) | 373 | if (vp->i_sb->s_flags & MS_RDONLY) |
385 | return EROFS; | 374 | return EROFS; |
386 | va.va_mask = XFS_AT_UID; | 375 | if (xfs_vtoi(vp)->i_d.di_uid != current->fsuid && !capable(CAP_FOWNER)) |
387 | error = xfs_getattr(ip, &va, 0); | ||
388 | if (error) | ||
389 | return error; | ||
390 | if (va.va_uid != current->fsuid && !capable(CAP_FOWNER)) | ||
391 | return EPERM; | 376 | return EPERM; |
392 | return error; | 377 | return 0; |
393 | } | 378 | } |
394 | 379 | ||
395 | /* | 380 | /* |
@@ -643,7 +628,6 @@ xfs_acl_vtoacl( | |||
643 | xfs_acl_t *access_acl, | 628 | xfs_acl_t *access_acl, |
644 | xfs_acl_t *default_acl) | 629 | xfs_acl_t *default_acl) |
645 | { | 630 | { |
646 | bhv_vattr_t va; | ||
647 | int error = 0; | 631 | int error = 0; |
648 | 632 | ||
649 | if (access_acl) { | 633 | if (access_acl) { |
@@ -652,16 +636,10 @@ xfs_acl_vtoacl( | |||
652 | * be obtained for some reason, invalidate the access ACL. | 636 | * be obtained for some reason, invalidate the access ACL. |
653 | */ | 637 | */ |
654 | xfs_acl_get_attr(vp, access_acl, _ACL_TYPE_ACCESS, 0, &error); | 638 | xfs_acl_get_attr(vp, access_acl, _ACL_TYPE_ACCESS, 0, &error); |
655 | if (!error) { | ||
656 | /* Got the ACL, need the mode... */ | ||
657 | va.va_mask = XFS_AT_MODE; | ||
658 | error = xfs_getattr(xfs_vtoi(vp), &va, 0); | ||
659 | } | ||
660 | |||
661 | if (error) | 639 | if (error) |
662 | access_acl->acl_cnt = XFS_ACL_NOT_PRESENT; | 640 | access_acl->acl_cnt = XFS_ACL_NOT_PRESENT; |
663 | else /* We have a good ACL and the file mode, synchronize. */ | 641 | else /* We have a good ACL and the file mode, synchronize. */ |
664 | xfs_acl_sync_mode(va.va_mode, access_acl); | 642 | xfs_acl_sync_mode(xfs_vtoi(vp)->i_d.di_mode, access_acl); |
665 | } | 643 | } |
666 | 644 | ||
667 | if (default_acl) { | 645 | if (default_acl) { |
@@ -744,7 +722,7 @@ xfs_acl_setmode( | |||
744 | bhv_vattr_t va; | 722 | bhv_vattr_t va; |
745 | xfs_acl_entry_t *ap; | 723 | xfs_acl_entry_t *ap; |
746 | xfs_acl_entry_t *gap = NULL; | 724 | xfs_acl_entry_t *gap = NULL; |
747 | int i, error, nomask = 1; | 725 | int i, nomask = 1; |
748 | 726 | ||
749 | *basicperms = 1; | 727 | *basicperms = 1; |
750 | 728 | ||
@@ -756,11 +734,7 @@ xfs_acl_setmode( | |||
756 | * mode. The m:: bits take precedence over the g:: bits. | 734 | * mode. The m:: bits take precedence over the g:: bits. |
757 | */ | 735 | */ |
758 | va.va_mask = XFS_AT_MODE; | 736 | va.va_mask = XFS_AT_MODE; |
759 | error = xfs_getattr(xfs_vtoi(vp), &va, 0); | 737 | va.va_mode = xfs_vtoi(vp)->i_d.di_mode; |
760 | if (error) | ||
761 | return error; | ||
762 | |||
763 | va.va_mask = XFS_AT_MODE; | ||
764 | va.va_mode &= ~(S_IRWXU|S_IRWXG|S_IRWXO); | 738 | va.va_mode &= ~(S_IRWXU|S_IRWXG|S_IRWXO); |
765 | ap = acl->acl_entry; | 739 | ap = acl->acl_entry; |
766 | for (i = 0; i < acl->acl_cnt; ++i) { | 740 | for (i = 0; i < acl->acl_cnt; ++i) { |
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c index 3fef54b11582..04f3e302feee 100644 --- a/fs/xfs/xfs_vnodeops.c +++ b/fs/xfs/xfs_vnodeops.c | |||
@@ -76,132 +76,6 @@ xfs_open( | |||
76 | } | 76 | } |
77 | 77 | ||
78 | /* | 78 | /* |
79 | * xfs_getattr | ||
80 | */ | ||
81 | int | ||
82 | xfs_getattr( | ||
83 | xfs_inode_t *ip, | ||
84 | bhv_vattr_t *vap, | ||
85 | int flags) | ||
86 | { | ||
87 | bhv_vnode_t *vp = XFS_ITOV(ip); | ||
88 | xfs_mount_t *mp = ip->i_mount; | ||
89 | |||
90 | xfs_itrace_entry(ip); | ||
91 | |||
92 | if (XFS_FORCED_SHUTDOWN(mp)) | ||
93 | return XFS_ERROR(EIO); | ||
94 | |||
95 | if (!(flags & ATTR_LAZY)) | ||
96 | xfs_ilock(ip, XFS_ILOCK_SHARED); | ||
97 | |||
98 | vap->va_size = XFS_ISIZE(ip); | ||
99 | if (vap->va_mask == XFS_AT_SIZE) | ||
100 | goto all_done; | ||
101 | |||
102 | vap->va_nblocks = | ||
103 | XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks); | ||
104 | vap->va_nodeid = ip->i_ino; | ||
105 | #if XFS_BIG_INUMS | ||
106 | vap->va_nodeid += mp->m_inoadd; | ||
107 | #endif | ||
108 | vap->va_nlink = ip->i_d.di_nlink; | ||
109 | |||
110 | /* | ||
111 | * Quick exit for non-stat callers | ||
112 | */ | ||
113 | if ((vap->va_mask & | ||
114 | ~(XFS_AT_SIZE|XFS_AT_FSID|XFS_AT_NODEID| | ||
115 | XFS_AT_NLINK|XFS_AT_BLKSIZE)) == 0) | ||
116 | goto all_done; | ||
117 | |||
118 | /* | ||
119 | * Copy from in-core inode. | ||
120 | */ | ||
121 | vap->va_mode = ip->i_d.di_mode; | ||
122 | vap->va_uid = ip->i_d.di_uid; | ||
123 | vap->va_gid = ip->i_d.di_gid; | ||
124 | vap->va_projid = ip->i_d.di_projid; | ||
125 | |||
126 | /* | ||
127 | * Check vnode type block/char vs. everything else. | ||
128 | */ | ||
129 | switch (ip->i_d.di_mode & S_IFMT) { | ||
130 | case S_IFBLK: | ||
131 | case S_IFCHR: | ||
132 | vap->va_rdev = ip->i_df.if_u2.if_rdev; | ||
133 | vap->va_blocksize = BLKDEV_IOSIZE; | ||
134 | break; | ||
135 | default: | ||
136 | vap->va_rdev = 0; | ||
137 | |||
138 | if (!(XFS_IS_REALTIME_INODE(ip))) { | ||
139 | vap->va_blocksize = xfs_preferred_iosize(mp); | ||
140 | } else { | ||
141 | |||
142 | /* | ||
143 | * If the file blocks are being allocated from a | ||
144 | * realtime partition, then return the inode's | ||
145 | * realtime extent size or the realtime volume's | ||
146 | * extent size. | ||
147 | */ | ||
148 | vap->va_blocksize = | ||
149 | xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog; | ||
150 | } | ||
151 | break; | ||
152 | } | ||
153 | |||
154 | vn_atime_to_timespec(vp, &vap->va_atime); | ||
155 | vap->va_mtime.tv_sec = ip->i_d.di_mtime.t_sec; | ||
156 | vap->va_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec; | ||
157 | vap->va_ctime.tv_sec = ip->i_d.di_ctime.t_sec; | ||
158 | vap->va_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec; | ||
159 | |||
160 | /* | ||
161 | * Exit for stat callers. See if any of the rest of the fields | ||
162 | * to be filled in are needed. | ||
163 | */ | ||
164 | if ((vap->va_mask & | ||
165 | (XFS_AT_XFLAGS|XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS| | ||
166 | XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0) | ||
167 | goto all_done; | ||
168 | |||
169 | /* | ||
170 | * Convert di_flags to xflags. | ||
171 | */ | ||
172 | vap->va_xflags = xfs_ip2xflags(ip); | ||
173 | |||
174 | /* | ||
175 | * Exit for inode revalidate. See if any of the rest of | ||
176 | * the fields to be filled in are needed. | ||
177 | */ | ||
178 | if ((vap->va_mask & | ||
179 | (XFS_AT_EXTSIZE|XFS_AT_NEXTENTS|XFS_AT_ANEXTENTS| | ||
180 | XFS_AT_GENCOUNT|XFS_AT_VCODE)) == 0) | ||
181 | goto all_done; | ||
182 | |||
183 | vap->va_extsize = ip->i_d.di_extsize << mp->m_sb.sb_blocklog; | ||
184 | vap->va_nextents = | ||
185 | (ip->i_df.if_flags & XFS_IFEXTENTS) ? | ||
186 | ip->i_df.if_bytes / sizeof(xfs_bmbt_rec_t) : | ||
187 | ip->i_d.di_nextents; | ||
188 | if (ip->i_afp) | ||
189 | vap->va_anextents = | ||
190 | (ip->i_afp->if_flags & XFS_IFEXTENTS) ? | ||
191 | ip->i_afp->if_bytes / sizeof(xfs_bmbt_rec_t) : | ||
192 | ip->i_d.di_anextents; | ||
193 | else | ||
194 | vap->va_anextents = 0; | ||
195 | vap->va_gen = ip->i_d.di_gen; | ||
196 | |||
197 | all_done: | ||
198 | if (!(flags & ATTR_LAZY)) | ||
199 | xfs_iunlock(ip, XFS_ILOCK_SHARED); | ||
200 | return 0; | ||
201 | } | ||
202 | |||
203 | |||
204 | /* | ||
205 | * xfs_setattr | 79 | * xfs_setattr |
206 | */ | 80 | */ |
207 | int | 81 | int |
diff --git a/fs/xfs/xfs_vnodeops.h b/fs/xfs/xfs_vnodeops.h index 24c53923dc2c..6b66904a3837 100644 --- a/fs/xfs/xfs_vnodeops.h +++ b/fs/xfs/xfs_vnodeops.h | |||
@@ -15,7 +15,6 @@ struct xfs_iomap; | |||
15 | 15 | ||
16 | 16 | ||
17 | int xfs_open(struct xfs_inode *ip); | 17 | int xfs_open(struct xfs_inode *ip); |
18 | int xfs_getattr(struct xfs_inode *ip, struct bhv_vattr *vap, int flags); | ||
19 | int xfs_setattr(struct xfs_inode *ip, struct bhv_vattr *vap, int flags, | 18 | int xfs_setattr(struct xfs_inode *ip, struct bhv_vattr *vap, int flags, |
20 | struct cred *credp); | 19 | struct cred *credp); |
21 | int xfs_readlink(struct xfs_inode *ip, char *link); | 20 | int xfs_readlink(struct xfs_inode *ip, char *link); |