blob: 149237304fb6b59e457037e06ae2325ee17193ba [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
19#include "xfs_fs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
26#include "xfs_dir.h"
27#include "xfs_dir2.h"
28#include "xfs_alloc.h"
29#include "xfs_dmapi.h"
30#include "xfs_quota.h"
31#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dir_sf.h"
36#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110037#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "xfs_dinode.h"
39#include "xfs_inode.h"
40#include "xfs_bmap.h"
Nathan Scotta844f452005-11-02 14:38:42 +110041#include "xfs_btree.h"
42#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include "xfs_rtalloc.h"
44#include "xfs_error.h"
45#include "xfs_itable.h"
46#include "xfs_rw.h"
47#include "xfs_acl.h"
48#include "xfs_cap.h"
49#include "xfs_mac.h"
50#include "xfs_attr.h"
51#include "xfs_buf_item.h"
52#include "xfs_utils.h"
53
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080054#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/xattr.h>
56#include <linux/namei.h>
Nathan Scott446ada42006-01-11 15:35:44 +110057#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Nathan Scott4aeb6642005-11-02 11:43:58 +110059/*
Christoph Hellwig75e17b32006-01-11 20:58:44 +110060 * Get a XFS inode from a given vnode.
61 */
62xfs_inode_t *
63xfs_vtoi(
64 struct vnode *vp)
65{
66 bhv_desc_t *bdp;
67
68 bdp = bhv_lookup_range(VN_BHV_HEAD(vp),
69 VNODE_POSITION_XFS, VNODE_POSITION_XFS);
70 if (unlikely(bdp == NULL))
71 return NULL;
72 return XFS_BHVTOI(bdp);
73}
74
75/*
Christoph Hellwig42fe2b12006-01-11 15:35:17 +110076 * Bring the atime in the XFS inode uptodate.
77 * Used before logging the inode to disk or when the Linux inode goes away.
78 */
79void
80xfs_synchronize_atime(
81 xfs_inode_t *ip)
82{
83 vnode_t *vp;
84
85 vp = XFS_ITOV_NULL(ip);
86 if (vp) {
87 struct inode *inode = &vp->v_inode;
88 ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
89 ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
90 }
91}
92
93/*
Nathan Scott4aeb6642005-11-02 11:43:58 +110094 * Change the requested timestamp in the given inode.
95 * We don't lock across timestamp updates, and we don't log them but
96 * we do record the fact that there is dirty information in core.
97 *
98 * NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
99 * with XFS_ICHGTIME_ACC to be sure that access time
100 * update will take. Calling first with XFS_ICHGTIME_ACC
101 * and then XFS_ICHGTIME_MOD may fail to modify the access
102 * timestamp if the filesystem is mounted noacctm.
103 */
104void
105xfs_ichgtime(
106 xfs_inode_t *ip,
107 int flags)
108{
Nathan Scottec86dc02006-03-17 17:25:36 +1100109 struct inode *inode = vn_to_inode(XFS_ITOV(ip));
Nathan Scott4aeb6642005-11-02 11:43:58 +1100110 timespec_t tv;
111
Nathan Scott4aeb6642005-11-02 11:43:58 +1100112 nanotime(&tv);
113 if (flags & XFS_ICHGTIME_MOD) {
114 inode->i_mtime = tv;
115 ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
116 ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
117 }
118 if (flags & XFS_ICHGTIME_ACC) {
119 inode->i_atime = tv;
120 ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
121 ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
122 }
123 if (flags & XFS_ICHGTIME_CHG) {
124 inode->i_ctime = tv;
125 ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
126 ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
127 }
128
129 /*
130 * We update the i_update_core field _after_ changing
131 * the timestamps in order to coordinate properly with
132 * xfs_iflush() so that we don't lose timestamp updates.
133 * This keeps us from having to hold the inode lock
134 * while doing this. We use the SYNCHRONIZE macro to
135 * ensure that the compiler does not reorder the update
136 * of i_update_core above the timestamp updates above.
137 */
138 SYNCHRONIZE();
139 ip->i_update_core = 1;
140 if (!(inode->i_state & I_LOCK))
141 mark_inode_dirty_sync(inode);
142}
143
144/*
145 * Variant on the above which avoids querying the system clock
146 * in situations where we know the Linux inode timestamps have
147 * just been updated (and so we can update our inode cheaply).
Nathan Scott4aeb6642005-11-02 11:43:58 +1100148 */
149void
150xfs_ichgtime_fast(
151 xfs_inode_t *ip,
152 struct inode *inode,
153 int flags)
154{
155 timespec_t *tvp;
156
157 /*
Christoph Hellwig42fe2b12006-01-11 15:35:17 +1100158 * Atime updates for read() & friends are handled lazily now, and
159 * explicit updates must go through xfs_ichgtime()
160 */
161 ASSERT((flags & XFS_ICHGTIME_ACC) == 0);
162
163 /*
Nathan Scott4aeb6642005-11-02 11:43:58 +1100164 * We're not supposed to change timestamps in readonly-mounted
165 * filesystems. Throw it away if anyone asks us.
166 */
167 if (unlikely(IS_RDONLY(inode)))
168 return;
169
Nathan Scott4aeb6642005-11-02 11:43:58 +1100170 if (flags & XFS_ICHGTIME_MOD) {
171 tvp = &inode->i_mtime;
172 ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
173 ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
174 }
Nathan Scott4aeb6642005-11-02 11:43:58 +1100175 if (flags & XFS_ICHGTIME_CHG) {
176 tvp = &inode->i_ctime;
177 ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
178 ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
179 }
180
181 /*
182 * We update the i_update_core field _after_ changing
183 * the timestamps in order to coordinate properly with
184 * xfs_iflush() so that we don't lose timestamp updates.
185 * This keeps us from having to hold the inode lock
186 * while doing this. We use the SYNCHRONIZE macro to
187 * ensure that the compiler does not reorder the update
188 * of i_update_core above the timestamp updates above.
189 */
190 SYNCHRONIZE();
191 ip->i_update_core = 1;
192 if (!(inode->i_state & I_LOCK))
193 mark_inode_dirty_sync(inode);
194}
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
197/*
198 * Pull the link count and size up from the xfs inode to the linux inode
199 */
200STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100201xfs_validate_fields(
Nathan Scott220b5282006-03-14 13:33:36 +1100202 struct inode *ip,
203 struct vattr *vattr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Nathan Scottec86dc02006-03-17 17:25:36 +1100205 vnode_t *vp = vn_from_inode(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 int error;
207
Nathan Scott220b5282006-03-14 13:33:36 +1100208 vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
209 VOP_GETATTR(vp, vattr, ATTR_LAZY, NULL, error);
210 if (likely(!error)) {
211 ip->i_nlink = vattr->va_nlink;
212 ip->i_blocks = vattr->va_nblocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
Nathan Scott220b5282006-03-14 13:33:36 +1100214 /* we're under i_sem so i_size can't change under us */
215 if (i_size_read(ip) != vattr->va_size)
216 i_size_write(ip, vattr->va_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 }
218}
219
220/*
Nathan Scott446ada42006-01-11 15:35:44 +1100221 * Hook in SELinux. This is not quite correct yet, what we really need
222 * here (as we do for default ACLs) is a mechanism by which creation of
223 * these attrs can be journalled at inode creation time (along with the
224 * inode, of course, such that log replay can't cause these to be lost).
225 */
226STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100227xfs_init_security(
Nathan Scott446ada42006-01-11 15:35:44 +1100228 struct vnode *vp,
229 struct inode *dir)
230{
Nathan Scottec86dc02006-03-17 17:25:36 +1100231 struct inode *ip = vn_to_inode(vp);
Nathan Scott446ada42006-01-11 15:35:44 +1100232 size_t length;
233 void *value;
234 char *name;
235 int error;
236
237 error = security_inode_init_security(ip, dir, &name, &value, &length);
238 if (error) {
239 if (error == -EOPNOTSUPP)
240 return 0;
241 return -error;
242 }
243
244 VOP_ATTR_SET(vp, name, value, length, ATTR_SECURE, NULL, error);
245 if (!error)
246 VMODIFY(vp);
247
248 kfree(name);
249 kfree(value);
250 return error;
251}
252
253/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 * Determine whether a process has a valid fs_struct (kernel daemons
255 * like knfsd don't have an fs_struct).
256 *
257 * XXX(hch): nfsd is broken, better fix it instead.
258 */
259STATIC inline int
Nathan Scott416c6d52006-03-14 14:00:51 +1100260xfs_has_fs_struct(struct task_struct *task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
262 return (task->fs != init_task.fs);
263}
264
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100265STATIC inline void
Nathan Scott416c6d52006-03-14 14:00:51 +1100266xfs_cleanup_inode(
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100267 vnode_t *dvp,
268 vnode_t *vp,
Nathan Scott220b5282006-03-14 13:33:36 +1100269 struct dentry *dentry,
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100270 int mode)
271{
272 struct dentry teardown = {};
Nathan Scott220b5282006-03-14 13:33:36 +1100273 int error;
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100274
275 /* Oh, the horror.
Nathan Scott220b5282006-03-14 13:33:36 +1100276 * If we can't add the ACL or we fail in
Nathan Scott416c6d52006-03-14 14:00:51 +1100277 * xfs_init_security we must back out.
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100278 * ENOSPC can hit here, among other things.
279 */
Nathan Scottec86dc02006-03-17 17:25:36 +1100280 teardown.d_inode = vn_to_inode(vp);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100281 teardown.d_name = dentry->d_name;
282
283 if (S_ISDIR(mode))
Nathan Scott220b5282006-03-14 13:33:36 +1100284 VOP_RMDIR(dvp, &teardown, NULL, error);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100285 else
Nathan Scott220b5282006-03-14 13:33:36 +1100286 VOP_REMOVE(dvp, &teardown, NULL, error);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100287 VN_RELE(vp);
288}
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100291xfs_vn_mknod(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 struct inode *dir,
293 struct dentry *dentry,
294 int mode,
295 dev_t rdev)
296{
297 struct inode *ip;
Nathan Scott524fbf52006-03-14 14:07:53 +1100298 vattr_t vattr = { 0 };
Nathan Scottec86dc02006-03-17 17:25:36 +1100299 vnode_t *vp = NULL, *dvp = vn_from_inode(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 xfs_acl_t *default_acl = NULL;
301 attrexists_t test_default_acl = _ACL_DEFAULT_EXISTS;
302 int error;
303
304 /*
305 * Irix uses Missed'em'V split, but doesn't want to see
306 * the upper 5 bits of (14bit) major.
307 */
Nathan Scott220b5282006-03-14 13:33:36 +1100308 if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return -EINVAL;
310
Nathan Scott220b5282006-03-14 13:33:36 +1100311 if (unlikely(test_default_acl && test_default_acl(dvp))) {
312 if (!_ACL_ALLOC(default_acl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 return -ENOMEM;
Nathan Scott220b5282006-03-14 13:33:36 +1100314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 if (!_ACL_GET_DEFAULT(dvp, default_acl)) {
316 _ACL_FREE(default_acl);
317 default_acl = NULL;
318 }
319 }
320
Nathan Scott416c6d52006-03-14 14:00:51 +1100321 if (IS_POSIXACL(dir) && !default_acl && xfs_has_fs_struct(current))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 mode &= ~current->fs->umask;
323
Nathan Scott524fbf52006-03-14 14:07:53 +1100324 vattr.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
325 vattr.va_mode = mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 switch (mode & S_IFMT) {
328 case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK:
Nathan Scott524fbf52006-03-14 14:07:53 +1100329 vattr.va_rdev = sysv_encode_dev(rdev);
330 vattr.va_mask |= XFS_AT_RDEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 /*FALLTHROUGH*/
332 case S_IFREG:
Nathan Scott524fbf52006-03-14 14:07:53 +1100333 VOP_CREATE(dvp, dentry, &vattr, &vp, NULL, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 break;
335 case S_IFDIR:
Nathan Scott524fbf52006-03-14 14:07:53 +1100336 VOP_MKDIR(dvp, dentry, &vattr, &vp, NULL, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 break;
338 default:
339 error = EINVAL;
340 break;
341 }
342
Nathan Scott220b5282006-03-14 13:33:36 +1100343 if (unlikely(!error)) {
Nathan Scott416c6d52006-03-14 14:00:51 +1100344 error = xfs_init_security(vp, dir);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100345 if (error)
Nathan Scott416c6d52006-03-14 14:00:51 +1100346 xfs_cleanup_inode(dvp, vp, dentry, mode);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100347 }
Nathan Scott446ada42006-01-11 15:35:44 +1100348
Nathan Scott220b5282006-03-14 13:33:36 +1100349 if (unlikely(default_acl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 if (!error) {
Nathan Scott524fbf52006-03-14 14:07:53 +1100351 error = _ACL_INHERIT(vp, &vattr, default_acl);
Nathan Scott220b5282006-03-14 13:33:36 +1100352 if (!error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 VMODIFY(vp);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100354 else
Nathan Scott416c6d52006-03-14 14:00:51 +1100355 xfs_cleanup_inode(dvp, vp, dentry, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 }
357 _ACL_FREE(default_acl);
358 }
359
Nathan Scott220b5282006-03-14 13:33:36 +1100360 if (likely(!error)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 ASSERT(vp);
Nathan Scottec86dc02006-03-17 17:25:36 +1100362 ip = vn_to_inode(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 if (S_ISCHR(mode) || S_ISBLK(mode))
365 ip->i_rdev = rdev;
366 else if (S_ISDIR(mode))
Nathan Scott524fbf52006-03-14 14:07:53 +1100367 xfs_validate_fields(ip, &vattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 d_instantiate(dentry, ip);
Nathan Scott524fbf52006-03-14 14:07:53 +1100369 xfs_validate_fields(dir, &vattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 }
371 return -error;
372}
373
374STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100375xfs_vn_create(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 struct inode *dir,
377 struct dentry *dentry,
378 int mode,
379 struct nameidata *nd)
380{
Nathan Scott416c6d52006-03-14 14:00:51 +1100381 return xfs_vn_mknod(dir, dentry, mode, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382}
383
384STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100385xfs_vn_mkdir(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 struct inode *dir,
387 struct dentry *dentry,
388 int mode)
389{
Nathan Scott416c6d52006-03-14 14:00:51 +1100390 return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391}
392
393STATIC struct dentry *
Nathan Scott416c6d52006-03-14 14:00:51 +1100394xfs_vn_lookup(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 struct inode *dir,
396 struct dentry *dentry,
397 struct nameidata *nd)
398{
Nathan Scottec86dc02006-03-17 17:25:36 +1100399 struct vnode *vp = vn_from_inode(dir), *cvp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 int error;
401
402 if (dentry->d_name.len >= MAXNAMELEN)
403 return ERR_PTR(-ENAMETOOLONG);
404
405 VOP_LOOKUP(vp, dentry, &cvp, 0, NULL, NULL, error);
406 if (error) {
407 if (unlikely(error != ENOENT))
408 return ERR_PTR(-error);
409 d_add(dentry, NULL);
410 return NULL;
411 }
412
Nathan Scottec86dc02006-03-17 17:25:36 +1100413 return d_splice_alias(vn_to_inode(cvp), dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414}
415
416STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100417xfs_vn_link(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 struct dentry *old_dentry,
419 struct inode *dir,
420 struct dentry *dentry)
421{
422 struct inode *ip; /* inode of guy being linked to */
423 vnode_t *tdvp; /* target directory for new name/link */
424 vnode_t *vp; /* vp of name being linked */
Nathan Scott524fbf52006-03-14 14:07:53 +1100425 vattr_t vattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 int error;
427
428 ip = old_dentry->d_inode; /* inode being linked to */
429 if (S_ISDIR(ip->i_mode))
430 return -EPERM;
431
Nathan Scottec86dc02006-03-17 17:25:36 +1100432 tdvp = vn_from_inode(dir);
433 vp = vn_from_inode(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435 VOP_LINK(tdvp, vp, dentry, NULL, error);
Nathan Scott220b5282006-03-14 13:33:36 +1100436 if (likely(!error)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 VMODIFY(tdvp);
438 VN_HOLD(vp);
Nathan Scott524fbf52006-03-14 14:07:53 +1100439 xfs_validate_fields(ip, &vattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 d_instantiate(dentry, ip);
441 }
442 return -error;
443}
444
445STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100446xfs_vn_unlink(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 struct inode *dir,
448 struct dentry *dentry)
449{
450 struct inode *inode;
451 vnode_t *dvp; /* directory containing name to remove */
Nathan Scott524fbf52006-03-14 14:07:53 +1100452 vattr_t vattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 int error;
454
455 inode = dentry->d_inode;
Nathan Scottec86dc02006-03-17 17:25:36 +1100456 dvp = vn_from_inode(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
458 VOP_REMOVE(dvp, dentry, NULL, error);
Nathan Scott220b5282006-03-14 13:33:36 +1100459 if (likely(!error)) {
Nathan Scott524fbf52006-03-14 14:07:53 +1100460 xfs_validate_fields(dir, &vattr); /* size needs update */
461 xfs_validate_fields(inode, &vattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return -error;
464}
465
466STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100467xfs_vn_symlink(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 struct inode *dir,
469 struct dentry *dentry,
470 const char *symname)
471{
472 struct inode *ip;
Nathan Scott524fbf52006-03-14 14:07:53 +1100473 vattr_t vattr = { 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 vnode_t *dvp; /* directory containing name of symlink */
475 vnode_t *cvp; /* used to lookup symlink to put in dentry */
476 int error;
477
Nathan Scottec86dc02006-03-17 17:25:36 +1100478 dvp = vn_from_inode(dir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 cvp = NULL;
480
Nathan Scott524fbf52006-03-14 14:07:53 +1100481 vattr.va_mode = S_IFLNK |
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000482 (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
Nathan Scott524fbf52006-03-14 14:07:53 +1100483 vattr.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484
485 error = 0;
Nathan Scott524fbf52006-03-14 14:07:53 +1100486 VOP_SYMLINK(dvp, dentry, &vattr, (char *)symname, &cvp, NULL, error);
Nathan Scott54245702006-01-16 15:54:05 +1100487 if (likely(!error && cvp)) {
Nathan Scott416c6d52006-03-14 14:00:51 +1100488 error = xfs_init_security(cvp, dir);
Nathan Scott54245702006-01-16 15:54:05 +1100489 if (likely(!error)) {
Nathan Scottec86dc02006-03-17 17:25:36 +1100490 ip = vn_to_inode(cvp);
Nathan Scott54245702006-01-16 15:54:05 +1100491 d_instantiate(dentry, ip);
Nathan Scott524fbf52006-03-14 14:07:53 +1100492 xfs_validate_fields(dir, &vattr);
493 xfs_validate_fields(ip, &vattr);
Nathan Scottce9d37c2006-03-17 17:26:34 +1100494 } else {
495 xfs_cleanup_inode(dvp, cvp, dentry, 0);
Nathan Scott54245702006-01-16 15:54:05 +1100496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
498 return -error;
499}
500
501STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100502xfs_vn_rmdir(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 struct inode *dir,
504 struct dentry *dentry)
505{
506 struct inode *inode = dentry->d_inode;
Nathan Scottec86dc02006-03-17 17:25:36 +1100507 vnode_t *dvp = vn_from_inode(dir);
Nathan Scott524fbf52006-03-14 14:07:53 +1100508 vattr_t vattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 int error;
510
511 VOP_RMDIR(dvp, dentry, NULL, error);
Nathan Scott220b5282006-03-14 13:33:36 +1100512 if (likely(!error)) {
Nathan Scott524fbf52006-03-14 14:07:53 +1100513 xfs_validate_fields(inode, &vattr);
514 xfs_validate_fields(dir, &vattr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 }
516 return -error;
517}
518
519STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100520xfs_vn_rename(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 struct inode *odir,
522 struct dentry *odentry,
523 struct inode *ndir,
524 struct dentry *ndentry)
525{
526 struct inode *new_inode = ndentry->d_inode;
527 vnode_t *fvp; /* from directory */
528 vnode_t *tvp; /* target directory */
Nathan Scott524fbf52006-03-14 14:07:53 +1100529 vattr_t vattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 int error;
531
Nathan Scottec86dc02006-03-17 17:25:36 +1100532 fvp = vn_from_inode(odir);
533 tvp = vn_from_inode(ndir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 VOP_RENAME(fvp, odentry, tvp, ndentry, NULL, error);
Nathan Scott220b5282006-03-14 13:33:36 +1100536 if (likely(!error)) {
537 if (new_inode)
Nathan Scott524fbf52006-03-14 14:07:53 +1100538 xfs_validate_fields(new_inode, &vattr);
539 xfs_validate_fields(odir, &vattr);
Nathan Scott220b5282006-03-14 13:33:36 +1100540 if (ndir != odir)
Nathan Scott524fbf52006-03-14 14:07:53 +1100541 xfs_validate_fields(ndir, &vattr);
Nathan Scott220b5282006-03-14 13:33:36 +1100542 }
Nathan Scott220b5282006-03-14 13:33:36 +1100543 return -error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544}
545
546/*
547 * careful here - this function can get called recursively, so
548 * we need to be very careful about how much stack we use.
549 * uio is kmalloced for this reason...
550 */
Al Viro008b1502005-08-20 00:17:39 +0100551STATIC void *
Nathan Scott416c6d52006-03-14 14:00:51 +1100552xfs_vn_follow_link(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 struct dentry *dentry,
554 struct nameidata *nd)
555{
556 vnode_t *vp;
557 uio_t *uio;
558 iovec_t iov;
559 int error;
560 char *link;
561
562 ASSERT(dentry);
563 ASSERT(nd);
564
Nathan Scott0d1335b2006-01-12 10:32:51 +1100565 link = (char *)kmalloc(MAXPATHLEN+1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (!link) {
567 nd_set_link(nd, ERR_PTR(-ENOMEM));
Al Viro008b1502005-08-20 00:17:39 +0100568 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 }
570
571 uio = (uio_t *)kmalloc(sizeof(uio_t), GFP_KERNEL);
572 if (!uio) {
573 kfree(link);
574 nd_set_link(nd, ERR_PTR(-ENOMEM));
Al Viro008b1502005-08-20 00:17:39 +0100575 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 }
577
Nathan Scottec86dc02006-03-17 17:25:36 +1100578 vp = vn_from_inode(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 iov.iov_base = link;
Nathan Scott0d1335b2006-01-12 10:32:51 +1100581 iov.iov_len = MAXPATHLEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 uio->uio_iov = &iov;
584 uio->uio_offset = 0;
585 uio->uio_segflg = UIO_SYSSPACE;
Nathan Scott0d1335b2006-01-12 10:32:51 +1100586 uio->uio_resid = MAXPATHLEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 uio->uio_iovcnt = 1;
588
589 VOP_READLINK(vp, uio, 0, NULL, error);
590 if (error) {
591 kfree(link);
592 link = ERR_PTR(-error);
593 } else {
Nathan Scott0d1335b2006-01-12 10:32:51 +1100594 link[MAXPATHLEN - uio->uio_resid] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 }
596 kfree(uio);
597
598 nd_set_link(nd, link);
Al Viro008b1502005-08-20 00:17:39 +0100599 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
Nathan Scottcde410a2005-09-05 11:47:01 +1000602STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100603xfs_vn_put_link(
Nathan Scottcde410a2005-09-05 11:47:01 +1000604 struct dentry *dentry,
605 struct nameidata *nd,
606 void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
Nathan Scottcde410a2005-09-05 11:47:01 +1000608 char *s = nd_get_link(nd);
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 if (!IS_ERR(s))
611 kfree(s);
612}
613
614#ifdef CONFIG_XFS_POSIX_ACL
615STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100616xfs_vn_permission(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 struct inode *inode,
618 int mode,
619 struct nameidata *nd)
620{
Nathan Scottec86dc02006-03-17 17:25:36 +1100621 vnode_t *vp = vn_from_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 int error;
623
624 mode <<= 6; /* convert from linux to vnode access bits */
625 VOP_ACCESS(vp, mode, NULL, error);
626 return -error;
627}
628#else
Nathan Scott416c6d52006-03-14 14:00:51 +1100629#define xfs_vn_permission NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630#endif
631
632STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100633xfs_vn_getattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 struct vfsmount *mnt,
635 struct dentry *dentry,
636 struct kstat *stat)
637{
638 struct inode *inode = dentry->d_inode;
Nathan Scottec86dc02006-03-17 17:25:36 +1100639 vnode_t *vp = vn_from_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 int error = 0;
641
642 if (unlikely(vp->v_flag & VMODIFIED))
643 error = vn_revalidate(vp);
644 if (!error)
645 generic_fillattr(inode, stat);
646 return 0;
647}
648
649STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100650xfs_vn_setattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 struct dentry *dentry,
652 struct iattr *attr)
653{
654 struct inode *inode = dentry->d_inode;
655 unsigned int ia_valid = attr->ia_valid;
Nathan Scottec86dc02006-03-17 17:25:36 +1100656 vnode_t *vp = vn_from_inode(inode);
Nathan Scott220b5282006-03-14 13:33:36 +1100657 vattr_t vattr = { 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 int flags = 0;
659 int error;
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 if (ia_valid & ATTR_UID) {
662 vattr.va_mask |= XFS_AT_UID;
663 vattr.va_uid = attr->ia_uid;
664 }
665 if (ia_valid & ATTR_GID) {
666 vattr.va_mask |= XFS_AT_GID;
667 vattr.va_gid = attr->ia_gid;
668 }
669 if (ia_valid & ATTR_SIZE) {
670 vattr.va_mask |= XFS_AT_SIZE;
671 vattr.va_size = attr->ia_size;
672 }
673 if (ia_valid & ATTR_ATIME) {
674 vattr.va_mask |= XFS_AT_ATIME;
675 vattr.va_atime = attr->ia_atime;
Nathan Scott9bd6f132006-02-07 20:27:44 +1100676 if (ia_valid & ATTR_ATIME_SET)
677 inode->i_atime = attr->ia_atime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 }
679 if (ia_valid & ATTR_MTIME) {
680 vattr.va_mask |= XFS_AT_MTIME;
681 vattr.va_mtime = attr->ia_mtime;
682 }
683 if (ia_valid & ATTR_CTIME) {
684 vattr.va_mask |= XFS_AT_CTIME;
685 vattr.va_ctime = attr->ia_ctime;
686 }
687 if (ia_valid & ATTR_MODE) {
688 vattr.va_mask |= XFS_AT_MODE;
689 vattr.va_mode = attr->ia_mode;
690 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
691 inode->i_mode &= ~S_ISGID;
692 }
693
694 if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
695 flags |= ATTR_UTIME;
696#ifdef ATTR_NO_BLOCK
697 if ((ia_valid & ATTR_NO_BLOCK))
698 flags |= ATTR_NONBLOCK;
699#endif
700
701 VOP_SETATTR(vp, &vattr, flags, NULL, error);
Nathan Scott220b5282006-03-14 13:33:36 +1100702 if (likely(!error))
703 __vn_revalidate(vp, &vattr);
704 return -error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
707STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100708xfs_vn_truncate(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 struct inode *inode)
710{
Nathan Scottc2536662006-03-29 10:44:40 +1000711 block_truncate_page(inode->i_mapping, inode->i_size, xfs_get_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712}
713
714STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100715xfs_vn_setxattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 struct dentry *dentry,
717 const char *name,
718 const void *data,
719 size_t size,
720 int flags)
721{
Nathan Scottec86dc02006-03-17 17:25:36 +1100722 vnode_t *vp = vn_from_inode(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 char *attr = (char *)name;
724 attrnames_t *namesp;
725 int xflags = 0;
726 int error;
727
728 namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
729 if (!namesp)
730 return -EOPNOTSUPP;
731 attr += namesp->attr_namelen;
732 error = namesp->attr_capable(vp, NULL);
733 if (error)
734 return error;
735
736 /* Convert Linux syscall to XFS internal ATTR flags */
737 if (flags & XATTR_CREATE)
738 xflags |= ATTR_CREATE;
739 if (flags & XATTR_REPLACE)
740 xflags |= ATTR_REPLACE;
741 xflags |= namesp->attr_flag;
742 return namesp->attr_set(vp, attr, (void *)data, size, xflags);
743}
744
745STATIC ssize_t
Nathan Scott416c6d52006-03-14 14:00:51 +1100746xfs_vn_getxattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 struct dentry *dentry,
748 const char *name,
749 void *data,
750 size_t size)
751{
Nathan Scottec86dc02006-03-17 17:25:36 +1100752 vnode_t *vp = vn_from_inode(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 char *attr = (char *)name;
754 attrnames_t *namesp;
755 int xflags = 0;
756 ssize_t error;
757
758 namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
759 if (!namesp)
760 return -EOPNOTSUPP;
761 attr += namesp->attr_namelen;
762 error = namesp->attr_capable(vp, NULL);
763 if (error)
764 return error;
765
766 /* Convert Linux syscall to XFS internal ATTR flags */
767 if (!size) {
768 xflags |= ATTR_KERNOVAL;
769 data = NULL;
770 }
771 xflags |= namesp->attr_flag;
772 return namesp->attr_get(vp, attr, (void *)data, size, xflags);
773}
774
775STATIC ssize_t
Nathan Scott416c6d52006-03-14 14:00:51 +1100776xfs_vn_listxattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct dentry *dentry,
778 char *data,
779 size_t size)
780{
Nathan Scottec86dc02006-03-17 17:25:36 +1100781 vnode_t *vp = vn_from_inode(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 int error, xflags = ATTR_KERNAMELS;
783 ssize_t result;
784
785 if (!size)
786 xflags |= ATTR_KERNOVAL;
787 xflags |= capable(CAP_SYS_ADMIN) ? ATTR_KERNFULLS : ATTR_KERNORMALS;
788
789 error = attr_generic_list(vp, data, size, xflags, &result);
790 if (error < 0)
791 return error;
792 return result;
793}
794
795STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100796xfs_vn_removexattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 struct dentry *dentry,
798 const char *name)
799{
Nathan Scottec86dc02006-03-17 17:25:36 +1100800 vnode_t *vp = vn_from_inode(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 char *attr = (char *)name;
802 attrnames_t *namesp;
803 int xflags = 0;
804 int error;
805
806 namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
807 if (!namesp)
808 return -EOPNOTSUPP;
809 attr += namesp->attr_namelen;
810 error = namesp->attr_capable(vp, NULL);
811 if (error)
812 return error;
813 xflags |= namesp->attr_flag;
814 return namesp->attr_remove(vp, attr, xflags);
815}
816
817
Nathan Scott416c6d52006-03-14 14:00:51 +1100818struct inode_operations xfs_inode_operations = {
819 .permission = xfs_vn_permission,
820 .truncate = xfs_vn_truncate,
821 .getattr = xfs_vn_getattr,
822 .setattr = xfs_vn_setattr,
823 .setxattr = xfs_vn_setxattr,
824 .getxattr = xfs_vn_getxattr,
825 .listxattr = xfs_vn_listxattr,
826 .removexattr = xfs_vn_removexattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827};
828
Nathan Scott416c6d52006-03-14 14:00:51 +1100829struct inode_operations xfs_dir_inode_operations = {
830 .create = xfs_vn_create,
831 .lookup = xfs_vn_lookup,
832 .link = xfs_vn_link,
833 .unlink = xfs_vn_unlink,
834 .symlink = xfs_vn_symlink,
835 .mkdir = xfs_vn_mkdir,
836 .rmdir = xfs_vn_rmdir,
837 .mknod = xfs_vn_mknod,
838 .rename = xfs_vn_rename,
839 .permission = xfs_vn_permission,
840 .getattr = xfs_vn_getattr,
841 .setattr = xfs_vn_setattr,
842 .setxattr = xfs_vn_setxattr,
843 .getxattr = xfs_vn_getxattr,
844 .listxattr = xfs_vn_listxattr,
845 .removexattr = xfs_vn_removexattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846};
847
Nathan Scott416c6d52006-03-14 14:00:51 +1100848struct inode_operations xfs_symlink_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 .readlink = generic_readlink,
Nathan Scott416c6d52006-03-14 14:00:51 +1100850 .follow_link = xfs_vn_follow_link,
851 .put_link = xfs_vn_put_link,
852 .permission = xfs_vn_permission,
853 .getattr = xfs_vn_getattr,
854 .setattr = xfs_vn_setattr,
855 .setxattr = xfs_vn_setxattr,
856 .getxattr = xfs_vn_getxattr,
857 .listxattr = xfs_vn_listxattr,
858 .removexattr = xfs_vn_removexattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859};