blob: 7b42569968fe1aff876cb46d129ca438b5602749 [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_dir2.h"
27#include "xfs_alloc.h"
28#include "xfs_dmapi.h"
29#include "xfs_quota.h"
30#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_dinode.h"
37#include "xfs_inode.h"
38#include "xfs_bmap.h"
Nathan Scotta844f452005-11-02 14:38:42 +110039#include "xfs_btree.h"
40#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_rtalloc.h"
42#include "xfs_error.h"
43#include "xfs_itable.h"
44#include "xfs_rw.h"
45#include "xfs_acl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "xfs_attr.h"
47#include "xfs_buf_item.h"
48#include "xfs_utils.h"
Christoph Hellwig739bfb22007-08-29 10:58:01 +100049#include "xfs_vnodeops.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080051#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/xattr.h>
53#include <linux/namei.h>
Nathan Scott446ada42006-01-11 15:35:44 +110054#include <linux/security.h>
David Chinner3ed65262007-11-23 16:29:25 +110055#include <linux/falloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Nathan Scott4aeb6642005-11-02 11:43:58 +110057/*
Christoph Hellwig42fe2b12006-01-11 15:35:17 +110058 * Bring the atime in the XFS inode uptodate.
59 * Used before logging the inode to disk or when the Linux inode goes away.
60 */
61void
62xfs_synchronize_atime(
63 xfs_inode_t *ip)
64{
Christoph Hellwigaf048192008-03-06 13:46:43 +110065 struct inode *inode = ip->i_vnode;
Christoph Hellwig42fe2b12006-01-11 15:35:17 +110066
Christoph Hellwigaf048192008-03-06 13:46:43 +110067 if (inode) {
68 ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
69 ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
Christoph Hellwig42fe2b12006-01-11 15:35:17 +110070 }
71}
72
73/*
David Chinner5d51eff2007-11-23 16:29:18 +110074 * If the linux inode exists, mark it dirty.
75 * Used when commiting a dirty inode into a transaction so that
76 * the inode will get written back by the linux code
77 */
78void
79xfs_mark_inode_dirty_sync(
80 xfs_inode_t *ip)
81{
Christoph Hellwigaf048192008-03-06 13:46:43 +110082 struct inode *inode = ip->i_vnode;
David Chinner5d51eff2007-11-23 16:29:18 +110083
Christoph Hellwigaf048192008-03-06 13:46:43 +110084 if (inode)
85 mark_inode_dirty_sync(inode);
David Chinner5d51eff2007-11-23 16:29:18 +110086}
87
88/*
Nathan Scott4aeb6642005-11-02 11:43:58 +110089 * Change the requested timestamp in the given inode.
90 * We don't lock across timestamp updates, and we don't log them but
91 * we do record the fact that there is dirty information in core.
92 *
93 * NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
94 * with XFS_ICHGTIME_ACC to be sure that access time
95 * update will take. Calling first with XFS_ICHGTIME_ACC
96 * and then XFS_ICHGTIME_MOD may fail to modify the access
97 * timestamp if the filesystem is mounted noacctm.
98 */
99void
100xfs_ichgtime(
101 xfs_inode_t *ip,
102 int flags)
103{
Nathan Scottec86dc02006-03-17 17:25:36 +1100104 struct inode *inode = vn_to_inode(XFS_ITOV(ip));
Nathan Scott4aeb6642005-11-02 11:43:58 +1100105 timespec_t tv;
106
Nathan Scott4aeb6642005-11-02 11:43:58 +1100107 nanotime(&tv);
108 if (flags & XFS_ICHGTIME_MOD) {
109 inode->i_mtime = tv;
110 ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
111 ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
112 }
113 if (flags & XFS_ICHGTIME_ACC) {
114 inode->i_atime = tv;
115 ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
116 ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
117 }
118 if (flags & XFS_ICHGTIME_CHG) {
119 inode->i_ctime = tv;
120 ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
121 ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
122 }
123
124 /*
125 * We update the i_update_core field _after_ changing
126 * the timestamps in order to coordinate properly with
127 * xfs_iflush() so that we don't lose timestamp updates.
128 * This keeps us from having to hold the inode lock
129 * while doing this. We use the SYNCHRONIZE macro to
130 * ensure that the compiler does not reorder the update
131 * of i_update_core above the timestamp updates above.
132 */
133 SYNCHRONIZE();
134 ip->i_update_core = 1;
David Chinnercf10e822007-12-07 14:09:11 +1100135 if (!(inode->i_state & I_NEW))
Nathan Scott4aeb6642005-11-02 11:43:58 +1100136 mark_inode_dirty_sync(inode);
137}
138
139/*
140 * Variant on the above which avoids querying the system clock
141 * in situations where we know the Linux inode timestamps have
142 * just been updated (and so we can update our inode cheaply).
Nathan Scott4aeb6642005-11-02 11:43:58 +1100143 */
144void
145xfs_ichgtime_fast(
146 xfs_inode_t *ip,
147 struct inode *inode,
148 int flags)
149{
150 timespec_t *tvp;
151
152 /*
Christoph Hellwig42fe2b12006-01-11 15:35:17 +1100153 * Atime updates for read() & friends are handled lazily now, and
154 * explicit updates must go through xfs_ichgtime()
155 */
156 ASSERT((flags & XFS_ICHGTIME_ACC) == 0);
157
Nathan Scott4aeb6642005-11-02 11:43:58 +1100158 if (flags & XFS_ICHGTIME_MOD) {
159 tvp = &inode->i_mtime;
160 ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
161 ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
162 }
Nathan Scott4aeb6642005-11-02 11:43:58 +1100163 if (flags & XFS_ICHGTIME_CHG) {
164 tvp = &inode->i_ctime;
165 ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
166 ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
167 }
168
169 /*
170 * We update the i_update_core field _after_ changing
171 * the timestamps in order to coordinate properly with
172 * xfs_iflush() so that we don't lose timestamp updates.
173 * This keeps us from having to hold the inode lock
174 * while doing this. We use the SYNCHRONIZE macro to
175 * ensure that the compiler does not reorder the update
176 * of i_update_core above the timestamp updates above.
177 */
178 SYNCHRONIZE();
179 ip->i_update_core = 1;
David Chinnercf10e822007-12-07 14:09:11 +1100180 if (!(inode->i_state & I_NEW))
Nathan Scott4aeb6642005-11-02 11:43:58 +1100181 mark_inode_dirty_sync(inode);
182}
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184/*
Nathan Scott446ada42006-01-11 15:35:44 +1100185 * Hook in SELinux. This is not quite correct yet, what we really need
186 * here (as we do for default ACLs) is a mechanism by which creation of
187 * these attrs can be journalled at inode creation time (along with the
188 * inode, of course, such that log replay can't cause these to be lost).
189 */
190STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100191xfs_init_security(
Christoph Hellwigaf048192008-03-06 13:46:43 +1100192 struct inode *inode,
Nathan Scott446ada42006-01-11 15:35:44 +1100193 struct inode *dir)
194{
Christoph Hellwigaf048192008-03-06 13:46:43 +1100195 struct xfs_inode *ip = XFS_I(inode);
Nathan Scott446ada42006-01-11 15:35:44 +1100196 size_t length;
197 void *value;
198 char *name;
199 int error;
200
Christoph Hellwigaf048192008-03-06 13:46:43 +1100201 error = security_inode_init_security(inode, dir, &name,
202 &value, &length);
Nathan Scott446ada42006-01-11 15:35:44 +1100203 if (error) {
204 if (error == -EOPNOTSUPP)
205 return 0;
206 return -error;
207 }
208
Christoph Hellwigaf048192008-03-06 13:46:43 +1100209 error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
Nathan Scott446ada42006-01-11 15:35:44 +1100210 if (!error)
Christoph Hellwigaf048192008-03-06 13:46:43 +1100211 xfs_iflags_set(ip, XFS_IMODIFIED);
Nathan Scott446ada42006-01-11 15:35:44 +1100212
213 kfree(name);
214 kfree(value);
215 return error;
216}
217
Barry Naujok556b8b12008-04-10 12:22:07 +1000218static void
219xfs_dentry_to_name(
220 struct xfs_name *namep,
221 struct dentry *dentry)
222{
223 namep->name = dentry->d_name.name;
224 namep->len = dentry->d_name.len;
225}
226
David Chinner7989cb82007-02-10 18:34:56 +1100227STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100228xfs_cleanup_inode(
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000229 struct inode *dir,
Christoph Hellwigaf048192008-03-06 13:46:43 +1100230 struct inode *inode,
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000231 struct dentry *dentry)
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100232{
Barry Naujok556b8b12008-04-10 12:22:07 +1000233 struct xfs_name teardown;
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100234
235 /* Oh, the horror.
Nathan Scott220b5282006-03-14 13:33:36 +1100236 * If we can't add the ACL or we fail in
Nathan Scott416c6d52006-03-14 14:00:51 +1100237 * xfs_init_security we must back out.
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100238 * ENOSPC can hit here, among other things.
239 */
Barry Naujok556b8b12008-04-10 12:22:07 +1000240 xfs_dentry_to_name(&teardown, dentry);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100241
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000242 xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
Christoph Hellwigaf048192008-03-06 13:46:43 +1100243 iput(inode);
Yingping Lu3a69c7d2006-02-01 12:14:34 +1100244}
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100247xfs_vn_mknod(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 struct inode *dir,
249 struct dentry *dentry,
250 int mode,
251 dev_t rdev)
252{
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100253 struct inode *inode;
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100254 struct xfs_inode *ip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 xfs_acl_t *default_acl = NULL;
Barry Naujok556b8b12008-04-10 12:22:07 +1000256 struct xfs_name name;
Lachlan McIlroy0ec58512008-06-23 13:23:01 +1000257 int (*test_default_acl)(struct inode *) = _ACL_DEFAULT_EXISTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 int error;
259
260 /*
261 * Irix uses Missed'em'V split, but doesn't want to see
262 * the upper 5 bits of (14bit) major.
263 */
Nathan Scott220b5282006-03-14 13:33:36 +1100264 if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return -EINVAL;
266
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100267 if (test_default_acl && test_default_acl(dir)) {
Nathan Scott220b5282006-03-14 13:33:36 +1100268 if (!_ACL_ALLOC(default_acl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 return -ENOMEM;
Nathan Scott220b5282006-03-14 13:33:36 +1100270 }
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100271 if (!_ACL_GET_DEFAULT(dir, default_acl)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 _ACL_FREE(default_acl);
273 default_acl = NULL;
274 }
275 }
276
Barry Naujok556b8b12008-04-10 12:22:07 +1000277 xfs_dentry_to_name(&name, dentry);
278
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100279 if (IS_POSIXACL(dir) && !default_acl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 mode &= ~current->fs->umask;
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 switch (mode & S_IFMT) {
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100283 case S_IFCHR:
284 case S_IFBLK:
285 case S_IFIFO:
286 case S_IFSOCK:
Christoph Hellwig3e5daf02007-10-11 18:09:12 +1000287 rdev = sysv_encode_dev(rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 case S_IFREG:
Barry Naujok556b8b12008-04-10 12:22:07 +1000289 error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 break;
291 case S_IFDIR:
Barry Naujok556b8b12008-04-10 12:22:07 +1000292 error = xfs_mkdir(XFS_I(dir), &name, mode, &ip, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 break;
294 default:
295 error = EINVAL;
296 break;
297 }
298
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100299 if (unlikely(error))
300 goto out_free_acl;
Nathan Scott446ada42006-01-11 15:35:44 +1100301
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100302 inode = ip->i_vnode;
303
304 error = xfs_init_security(inode, dir);
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100305 if (unlikely(error))
306 goto out_cleanup_inode;
307
308 if (default_acl) {
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100309 error = _ACL_INHERIT(inode, mode, default_acl);
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100310 if (unlikely(error))
311 goto out_cleanup_inode;
Christoph Hellwig979ebab2008-03-06 13:46:05 +1100312 xfs_iflags_set(ip, XFS_IMODIFIED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 _ACL_FREE(default_acl);
314 }
315
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100317 d_instantiate(dentry, inode);
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100318 return -error;
319
320 out_cleanup_inode:
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000321 xfs_cleanup_inode(dir, inode, dentry);
Christoph Hellwigdb0bb7b2008-03-06 13:44:35 +1100322 out_free_acl:
323 if (default_acl)
324 _ACL_FREE(default_acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return -error;
326}
327
328STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100329xfs_vn_create(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 struct inode *dir,
331 struct dentry *dentry,
332 int mode,
333 struct nameidata *nd)
334{
Nathan Scott416c6d52006-03-14 14:00:51 +1100335 return xfs_vn_mknod(dir, dentry, mode, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
338STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100339xfs_vn_mkdir(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 struct inode *dir,
341 struct dentry *dentry,
342 int mode)
343{
Nathan Scott416c6d52006-03-14 14:00:51 +1100344 return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345}
346
347STATIC struct dentry *
Nathan Scott416c6d52006-03-14 14:00:51 +1100348xfs_vn_lookup(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 struct inode *dir,
350 struct dentry *dentry,
351 struct nameidata *nd)
352{
Christoph Hellwigef1f5e72008-03-06 13:46:25 +1100353 struct xfs_inode *cip;
Barry Naujok556b8b12008-04-10 12:22:07 +1000354 struct xfs_name name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 int error;
356
357 if (dentry->d_name.len >= MAXNAMELEN)
358 return ERR_PTR(-ENAMETOOLONG);
359
Barry Naujok556b8b12008-04-10 12:22:07 +1000360 xfs_dentry_to_name(&name, dentry);
Barry Naujok384f3ce2008-05-21 16:58:22 +1000361 error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
Nathan Scott67fcaa72006-06-09 17:00:52 +1000362 if (unlikely(error)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 if (unlikely(error != ENOENT))
364 return ERR_PTR(-error);
365 d_add(dentry, NULL);
366 return NULL;
367 }
368
Christoph Hellwigef1f5e72008-03-06 13:46:25 +1100369 return d_splice_alias(cip->i_vnode, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370}
371
Barry Naujok384f3ce2008-05-21 16:58:22 +1000372STATIC struct dentry *
373xfs_vn_ci_lookup(
374 struct inode *dir,
375 struct dentry *dentry,
376 struct nameidata *nd)
377{
378 struct xfs_inode *ip;
379 struct xfs_name xname;
380 struct xfs_name ci_name;
381 struct qstr dname;
382 int error;
383
384 if (dentry->d_name.len >= MAXNAMELEN)
385 return ERR_PTR(-ENAMETOOLONG);
386
387 xfs_dentry_to_name(&xname, dentry);
388 error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
389 if (unlikely(error)) {
390 if (unlikely(error != ENOENT))
391 return ERR_PTR(-error);
Barry Naujok866d5dc2008-05-22 17:21:40 +1000392 /*
393 * call d_add(dentry, NULL) here when d_drop_negative_children
394 * is called in xfs_vn_mknod (ie. allow negative dentries
395 * with CI filesystems).
396 */
Barry Naujok384f3ce2008-05-21 16:58:22 +1000397 return NULL;
398 }
399
400 /* if exact match, just splice and exit */
401 if (!ci_name.name)
402 return d_splice_alias(ip->i_vnode, dentry);
403
404 /* else case-insensitive match... */
405 dname.name = ci_name.name;
406 dname.len = ci_name.len;
407 dentry = d_add_ci(ip->i_vnode, dentry, &dname);
408 kmem_free(ci_name.name);
409 return dentry;
410}
411
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100413xfs_vn_link(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 struct dentry *old_dentry,
415 struct inode *dir,
416 struct dentry *dentry)
417{
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100418 struct inode *inode; /* inode of guy being linked to */
Barry Naujok556b8b12008-04-10 12:22:07 +1000419 struct xfs_name name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 int error;
421
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100422 inode = old_dentry->d_inode;
Barry Naujok556b8b12008-04-10 12:22:07 +1000423 xfs_dentry_to_name(&name, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100425 igrab(inode);
Barry Naujok556b8b12008-04-10 12:22:07 +1000426 error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
Nathan Scott97dfd702006-06-27 16:13:46 +1000427 if (unlikely(error)) {
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100428 iput(inode);
429 return -error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100431
432 xfs_iflags_set(XFS_I(dir), XFS_IMODIFIED);
Christoph Hellwiga3da7892008-03-06 13:46:12 +1100433 d_instantiate(dentry, inode);
434 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435}
436
437STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100438xfs_vn_unlink(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 struct inode *dir,
440 struct dentry *dentry)
441{
Barry Naujok556b8b12008-04-10 12:22:07 +1000442 struct xfs_name name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 int error;
444
Barry Naujok556b8b12008-04-10 12:22:07 +1000445 xfs_dentry_to_name(&name, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
Christoph Hellwige5700702008-06-23 13:25:25 +1000447 error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
448 if (error)
449 return error;
450
451 /*
452 * With unlink, the VFS makes the dentry "negative": no inode,
453 * but still hashed. This is incompatible with case-insensitive
454 * mode, so invalidate (unhash) the dentry in CI-mode.
455 */
456 if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
457 d_invalidate(dentry);
458 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459}
460
461STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100462xfs_vn_symlink(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 struct inode *dir,
464 struct dentry *dentry,
465 const char *symname)
466{
Christoph Hellwig3937be52008-03-06 13:46:19 +1100467 struct inode *inode;
468 struct xfs_inode *cip = NULL;
Barry Naujok556b8b12008-04-10 12:22:07 +1000469 struct xfs_name name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 int error;
Christoph Hellwig3e5daf02007-10-11 18:09:12 +1000471 mode_t mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Christoph Hellwig3e5daf02007-10-11 18:09:12 +1000473 mode = S_IFLNK |
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000474 (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
Barry Naujok556b8b12008-04-10 12:22:07 +1000475 xfs_dentry_to_name(&name, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Barry Naujok556b8b12008-04-10 12:22:07 +1000477 error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip, NULL);
Christoph Hellwig3937be52008-03-06 13:46:19 +1100478 if (unlikely(error))
479 goto out;
480
481 inode = cip->i_vnode;
482
483 error = xfs_init_security(inode, dir);
484 if (unlikely(error))
485 goto out_cleanup_inode;
486
487 d_instantiate(dentry, inode);
Christoph Hellwig3937be52008-03-06 13:46:19 +1100488 return 0;
489
490 out_cleanup_inode:
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000491 xfs_cleanup_inode(dir, inode, dentry);
Christoph Hellwig3937be52008-03-06 13:46:19 +1100492 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 return -error;
494}
495
496STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100497xfs_vn_rename(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 struct inode *odir,
499 struct dentry *odentry,
500 struct inode *ndir,
501 struct dentry *ndentry)
502{
503 struct inode *new_inode = ndentry->d_inode;
Barry Naujok556b8b12008-04-10 12:22:07 +1000504 struct xfs_name oname;
505 struct xfs_name nname;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Barry Naujok556b8b12008-04-10 12:22:07 +1000507 xfs_dentry_to_name(&oname, odentry);
508 xfs_dentry_to_name(&nname, ndentry);
509
Christoph Hellwige5700702008-06-23 13:25:25 +1000510 return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
Christoph Hellwigcfa853e2008-04-22 17:34:06 +1000511 XFS_I(ndir), &nname, new_inode ?
512 XFS_I(new_inode) : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
514
515/*
516 * careful here - this function can get called recursively, so
517 * we need to be very careful about how much stack we use.
518 * uio is kmalloced for this reason...
519 */
Al Viro008b1502005-08-20 00:17:39 +0100520STATIC void *
Nathan Scott416c6d52006-03-14 14:00:51 +1100521xfs_vn_follow_link(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 struct dentry *dentry,
523 struct nameidata *nd)
524{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 char *link;
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000526 int error = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Panagiotis Issarisf52720c2006-09-27 01:49:39 -0700528 link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000529 if (!link)
530 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000532 error = -xfs_readlink(XFS_I(dentry->d_inode), link);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000533 if (unlikely(error))
534 goto out_kfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535
536 nd_set_link(nd, link);
Al Viro008b1502005-08-20 00:17:39 +0100537 return NULL;
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000538
539 out_kfree:
540 kfree(link);
541 out_err:
542 nd_set_link(nd, ERR_PTR(error));
543 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544}
545
Nathan Scottcde410a2005-09-05 11:47:01 +1000546STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100547xfs_vn_put_link(
Nathan Scottcde410a2005-09-05 11:47:01 +1000548 struct dentry *dentry,
549 struct nameidata *nd,
550 void *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
Nathan Scottcde410a2005-09-05 11:47:01 +1000552 char *s = nd_get_link(nd);
553
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 if (!IS_ERR(s))
555 kfree(s);
556}
557
558#ifdef CONFIG_XFS_POSIX_ACL
559STATIC int
Christoph Hellwig45767582008-02-05 12:13:24 +1100560xfs_check_acl(
561 struct inode *inode,
562 int mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563{
Christoph Hellwig45767582008-02-05 12:13:24 +1100564 struct xfs_inode *ip = XFS_I(inode);
565 int error;
566
567 xfs_itrace_entry(ip);
568
569 if (XFS_IFORK_Q(ip)) {
570 error = xfs_acl_iaccess(ip, mask, NULL);
571 if (error != -1)
572 return -error;
573 }
574
575 return -EAGAIN;
576}
577
578STATIC int
579xfs_vn_permission(
580 struct inode *inode,
Al Viroe6305c42008-07-15 21:03:57 -0400581 int mask)
Christoph Hellwig45767582008-02-05 12:13:24 +1100582{
583 return generic_permission(inode, mask, xfs_check_acl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584}
585#else
Nathan Scott416c6d52006-03-14 14:00:51 +1100586#define xfs_vn_permission NULL
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587#endif
588
589STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100590xfs_vn_getattr(
Christoph Hellwigc43f4082007-10-11 17:46:39 +1000591 struct vfsmount *mnt,
592 struct dentry *dentry,
593 struct kstat *stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594{
Christoph Hellwigc43f4082007-10-11 17:46:39 +1000595 struct inode *inode = dentry->d_inode;
596 struct xfs_inode *ip = XFS_I(inode);
597 struct xfs_mount *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Christoph Hellwigc43f4082007-10-11 17:46:39 +1000599 xfs_itrace_entry(ip);
600
601 if (XFS_FORCED_SHUTDOWN(mp))
602 return XFS_ERROR(EIO);
603
604 stat->size = XFS_ISIZE(ip);
605 stat->dev = inode->i_sb->s_dev;
606 stat->mode = ip->i_d.di_mode;
607 stat->nlink = ip->i_d.di_nlink;
608 stat->uid = ip->i_d.di_uid;
609 stat->gid = ip->i_d.di_gid;
610 stat->ino = ip->i_ino;
611#if XFS_BIG_INUMS
612 stat->ino += mp->m_inoadd;
613#endif
614 stat->atime = inode->i_atime;
615 stat->mtime.tv_sec = ip->i_d.di_mtime.t_sec;
616 stat->mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
617 stat->ctime.tv_sec = ip->i_d.di_ctime.t_sec;
618 stat->ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
619 stat->blocks =
620 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
621
622
623 switch (inode->i_mode & S_IFMT) {
624 case S_IFBLK:
625 case S_IFCHR:
626 stat->blksize = BLKDEV_IOSIZE;
627 stat->rdev = MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
628 sysv_minor(ip->i_df.if_u2.if_rdev));
629 break;
630 default:
Eric Sandeen71ddabb2007-11-23 16:29:42 +1100631 if (XFS_IS_REALTIME_INODE(ip)) {
Christoph Hellwigc43f4082007-10-11 17:46:39 +1000632 /*
633 * If the file blocks are being allocated from a
634 * realtime volume, then return the inode's realtime
635 * extent size or the realtime volume's extent size.
636 */
637 stat->blksize =
638 xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
639 } else
640 stat->blksize = xfs_preferred_iosize(mp);
641 stat->rdev = 0;
642 break;
Nathan Scott69e23b92006-09-28 11:01:22 +1000643 }
Christoph Hellwigc43f4082007-10-11 17:46:39 +1000644
645 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646}
647
648STATIC int
Nathan Scott416c6d52006-03-14 14:00:51 +1100649xfs_vn_setattr(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 struct dentry *dentry,
651 struct iattr *attr)
652{
653 struct inode *inode = dentry->d_inode;
654 unsigned int ia_valid = attr->ia_valid;
Nathan Scott8285fb52006-06-09 17:07:12 +1000655 bhv_vattr_t vattr = { 0 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 int flags = 0;
657 int error;
658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 if (ia_valid & ATTR_UID) {
660 vattr.va_mask |= XFS_AT_UID;
661 vattr.va_uid = attr->ia_uid;
662 }
663 if (ia_valid & ATTR_GID) {
664 vattr.va_mask |= XFS_AT_GID;
665 vattr.va_gid = attr->ia_gid;
666 }
667 if (ia_valid & ATTR_SIZE) {
668 vattr.va_mask |= XFS_AT_SIZE;
669 vattr.va_size = attr->ia_size;
670 }
671 if (ia_valid & ATTR_ATIME) {
672 vattr.va_mask |= XFS_AT_ATIME;
673 vattr.va_atime = attr->ia_atime;
Nathan Scott8c0b5112006-04-11 15:12:45 +1000674 inode->i_atime = attr->ia_atime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676 if (ia_valid & ATTR_MTIME) {
677 vattr.va_mask |= XFS_AT_MTIME;
678 vattr.va_mtime = attr->ia_mtime;
679 }
680 if (ia_valid & ATTR_CTIME) {
681 vattr.va_mask |= XFS_AT_CTIME;
682 vattr.va_ctime = attr->ia_ctime;
683 }
684 if (ia_valid & ATTR_MODE) {
685 vattr.va_mask |= XFS_AT_MODE;
686 vattr.va_mode = attr->ia_mode;
687 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
688 inode->i_mode &= ~S_ISGID;
689 }
690
691 if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
692 flags |= ATTR_UTIME;
693#ifdef ATTR_NO_BLOCK
694 if ((ia_valid & ATTR_NO_BLOCK))
695 flags |= ATTR_NONBLOCK;
696#endif
697
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000698 error = xfs_setattr(XFS_I(inode), &vattr, flags, NULL);
Nathan Scott220b5282006-03-14 13:33:36 +1100699 if (likely(!error))
Christoph Hellwig21a62542007-09-19 15:27:49 +1000700 vn_revalidate(vn_from_inode(inode));
Nathan Scott220b5282006-03-14 13:33:36 +1100701 return -error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702}
703
David Chinnerd87dd632008-04-10 12:21:46 +1000704/*
705 * block_truncate_page can return an error, but we can't propagate it
706 * at all here. Leave a complaint + stack trace in the syslog because
707 * this could be bad. If it is bad, we need to propagate the error further.
708 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709STATIC void
Nathan Scott416c6d52006-03-14 14:00:51 +1100710xfs_vn_truncate(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 struct inode *inode)
712{
David Chinnerd87dd632008-04-10 12:21:46 +1000713 int error;
714 error = block_truncate_page(inode->i_mapping, inode->i_size,
715 xfs_get_blocks);
716 WARN_ON(error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717}
718
David Chinner3ed65262007-11-23 16:29:25 +1100719STATIC long
720xfs_vn_fallocate(
721 struct inode *inode,
722 int mode,
723 loff_t offset,
724 loff_t len)
725{
726 long error;
727 loff_t new_size = 0;
728 xfs_flock64_t bf;
729 xfs_inode_t *ip = XFS_I(inode);
730
731 /* preallocation on directories not yet supported */
732 error = -ENODEV;
733 if (S_ISDIR(inode->i_mode))
734 goto out_error;
735
736 bf.l_whence = 0;
737 bf.l_start = offset;
738 bf.l_len = len;
739
740 xfs_ilock(ip, XFS_IOLOCK_EXCL);
741 error = xfs_change_file_space(ip, XFS_IOC_RESVSP, &bf,
742 0, NULL, ATTR_NOLOCK);
743 if (!error && !(mode & FALLOC_FL_KEEP_SIZE) &&
744 offset + len > i_size_read(inode))
745 new_size = offset + len;
746
747 /* Change file size if needed */
748 if (new_size) {
749 bhv_vattr_t va;
750
751 va.va_mask = XFS_AT_SIZE;
752 va.va_size = new_size;
753 error = xfs_setattr(ip, &va, ATTR_NOLOCK, NULL);
754 }
755
756 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
757out_error:
758 return error;
759}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800761const struct inode_operations xfs_inode_operations = {
Nathan Scott416c6d52006-03-14 14:00:51 +1100762 .permission = xfs_vn_permission,
763 .truncate = xfs_vn_truncate,
764 .getattr = xfs_vn_getattr,
765 .setattr = xfs_vn_setattr,
Lachlan McIlroy0ec58512008-06-23 13:23:01 +1000766 .setxattr = generic_setxattr,
767 .getxattr = generic_getxattr,
768 .removexattr = generic_removexattr,
Nathan Scott416c6d52006-03-14 14:00:51 +1100769 .listxattr = xfs_vn_listxattr,
David Chinner3ed65262007-11-23 16:29:25 +1100770 .fallocate = xfs_vn_fallocate,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771};
772
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800773const struct inode_operations xfs_dir_inode_operations = {
Nathan Scott416c6d52006-03-14 14:00:51 +1100774 .create = xfs_vn_create,
775 .lookup = xfs_vn_lookup,
776 .link = xfs_vn_link,
777 .unlink = xfs_vn_unlink,
778 .symlink = xfs_vn_symlink,
779 .mkdir = xfs_vn_mkdir,
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000780 /*
781 * Yes, XFS uses the same method for rmdir and unlink.
782 *
783 * There are some subtile differences deeper in the code,
784 * but we use S_ISDIR to check for those.
785 */
786 .rmdir = xfs_vn_unlink,
Nathan Scott416c6d52006-03-14 14:00:51 +1100787 .mknod = xfs_vn_mknod,
788 .rename = xfs_vn_rename,
789 .permission = xfs_vn_permission,
790 .getattr = xfs_vn_getattr,
791 .setattr = xfs_vn_setattr,
Lachlan McIlroy0ec58512008-06-23 13:23:01 +1000792 .setxattr = generic_setxattr,
793 .getxattr = generic_getxattr,
794 .removexattr = generic_removexattr,
Nathan Scott416c6d52006-03-14 14:00:51 +1100795 .listxattr = xfs_vn_listxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796};
797
Barry Naujok384f3ce2008-05-21 16:58:22 +1000798const struct inode_operations xfs_dir_ci_inode_operations = {
799 .create = xfs_vn_create,
800 .lookup = xfs_vn_ci_lookup,
801 .link = xfs_vn_link,
802 .unlink = xfs_vn_unlink,
803 .symlink = xfs_vn_symlink,
804 .mkdir = xfs_vn_mkdir,
Christoph Hellwig8f112e32008-06-23 13:25:17 +1000805 /*
806 * Yes, XFS uses the same method for rmdir and unlink.
807 *
808 * There are some subtile differences deeper in the code,
809 * but we use S_ISDIR to check for those.
810 */
811 .rmdir = xfs_vn_unlink,
Barry Naujok384f3ce2008-05-21 16:58:22 +1000812 .mknod = xfs_vn_mknod,
813 .rename = xfs_vn_rename,
814 .permission = xfs_vn_permission,
815 .getattr = xfs_vn_getattr,
816 .setattr = xfs_vn_setattr,
Lachlan McIlroy0ec58512008-06-23 13:23:01 +1000817 .setxattr = generic_setxattr,
818 .getxattr = generic_getxattr,
819 .removexattr = generic_removexattr,
Barry Naujok384f3ce2008-05-21 16:58:22 +1000820 .listxattr = xfs_vn_listxattr,
Barry Naujok384f3ce2008-05-21 16:58:22 +1000821};
822
Arjan van de Venc5ef1c42007-02-12 00:55:40 -0800823const struct inode_operations xfs_symlink_inode_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 .readlink = generic_readlink,
Nathan Scott416c6d52006-03-14 14:00:51 +1100825 .follow_link = xfs_vn_follow_link,
826 .put_link = xfs_vn_put_link,
827 .permission = xfs_vn_permission,
828 .getattr = xfs_vn_getattr,
829 .setattr = xfs_vn_setattr,
Lachlan McIlroy0ec58512008-06-23 13:23:01 +1000830 .setxattr = generic_setxattr,
831 .getxattr = generic_getxattr,
832 .removexattr = generic_removexattr,
Nathan Scott416c6d52006-03-14 14:00:51 +1100833 .listxattr = xfs_vn_listxattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834};