xfs_iops.c 22.1 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17 18 19
 */
#include "xfs.h"
#include "xfs_fs.h"
20
#include "xfs_bit.h"
L
Linus Torvalds 已提交
21
#include "xfs_log.h"
22
#include "xfs_inum.h"
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_dir2.h"
#include "xfs_alloc.h"
#include "xfs_dmapi.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
32
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
33 34
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
35
#include "xfs_attr_sf.h"
L
Linus Torvalds 已提交
36 37 38
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_bmap.h"
39 40
#include "xfs_btree.h"
#include "xfs_ialloc.h"
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_rw.h"
#include "xfs_acl.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
49
#include "xfs_vnodeops.h"
L
Linus Torvalds 已提交
50

51
#include <linux/capability.h>
L
Linus Torvalds 已提交
52 53
#include <linux/xattr.h>
#include <linux/namei.h>
54
#include <linux/security.h>
D
David Chinner 已提交
55
#include <linux/falloc.h>
L
Linus Torvalds 已提交
56

57 58 59 60 61 62 63 64
/*
 * Bring the atime in the XFS inode uptodate.
 * Used before logging the inode to disk or when the Linux inode goes away.
 */
void
xfs_synchronize_atime(
	xfs_inode_t	*ip)
{
65
	struct inode	*inode = ip->i_vnode;
66

67 68 69
	if (inode) {
		ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
		ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
70 71 72
	}
}

73 74 75 76 77 78 79 80 81
/*
 * If the linux inode exists, mark it dirty.
 * Used when commiting a dirty inode into a transaction so that
 * the inode will get written back by the linux code
 */
void
xfs_mark_inode_dirty_sync(
	xfs_inode_t	*ip)
{
82
	struct inode	*inode = ip->i_vnode;
83

84 85
	if (inode)
		mark_inode_dirty_sync(inode);
86 87
}

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
/*
 * Change the requested timestamp in the given inode.
 * We don't lock across timestamp updates, and we don't log them but
 * we do record the fact that there is dirty information in core.
 *
 * NOTE -- callers MUST combine XFS_ICHGTIME_MOD or XFS_ICHGTIME_CHG
 *		with XFS_ICHGTIME_ACC to be sure that access time
 *		update will take.  Calling first with XFS_ICHGTIME_ACC
 *		and then XFS_ICHGTIME_MOD may fail to modify the access
 *		timestamp if the filesystem is mounted noacctm.
 */
void
xfs_ichgtime(
	xfs_inode_t	*ip,
	int		flags)
{
104
	struct inode	*inode = vn_to_inode(XFS_ITOV(ip));
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
	timespec_t	tv;

	nanotime(&tv);
	if (flags & XFS_ICHGTIME_MOD) {
		inode->i_mtime = tv;
		ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
		ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
	}
	if (flags & XFS_ICHGTIME_ACC) {
		inode->i_atime = tv;
		ip->i_d.di_atime.t_sec = (__int32_t)tv.tv_sec;
		ip->i_d.di_atime.t_nsec = (__int32_t)tv.tv_nsec;
	}
	if (flags & XFS_ICHGTIME_CHG) {
		inode->i_ctime = tv;
		ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
		ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
	}

	/*
	 * We update the i_update_core field _after_ changing
	 * the timestamps in order to coordinate properly with
	 * xfs_iflush() so that we don't lose timestamp updates.
	 * This keeps us from having to hold the inode lock
	 * while doing this.  We use the SYNCHRONIZE macro to
	 * ensure that the compiler does not reorder the update
	 * of i_update_core above the timestamp updates above.
	 */
	SYNCHRONIZE();
	ip->i_update_core = 1;
135
	if (!(inode->i_state & I_NEW))
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
		mark_inode_dirty_sync(inode);
}

/*
 * Variant on the above which avoids querying the system clock
 * in situations where we know the Linux inode timestamps have
 * just been updated (and so we can update our inode cheaply).
 */
void
xfs_ichgtime_fast(
	xfs_inode_t	*ip,
	struct inode	*inode,
	int		flags)
{
	timespec_t	*tvp;

	/*
153 154
	 * Atime updates for read() & friends are handled lazily now, and
	 * explicit updates must go through xfs_ichgtime()
155
	 */
156
	ASSERT((flags & XFS_ICHGTIME_ACC) == 0);
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179

	if (flags & XFS_ICHGTIME_MOD) {
		tvp = &inode->i_mtime;
		ip->i_d.di_mtime.t_sec = (__int32_t)tvp->tv_sec;
		ip->i_d.di_mtime.t_nsec = (__int32_t)tvp->tv_nsec;
	}
	if (flags & XFS_ICHGTIME_CHG) {
		tvp = &inode->i_ctime;
		ip->i_d.di_ctime.t_sec = (__int32_t)tvp->tv_sec;
		ip->i_d.di_ctime.t_nsec = (__int32_t)tvp->tv_nsec;
	}

	/*
	 * We update the i_update_core field _after_ changing
	 * the timestamps in order to coordinate properly with
	 * xfs_iflush() so that we don't lose timestamp updates.
	 * This keeps us from having to hold the inode lock
	 * while doing this.  We use the SYNCHRONIZE macro to
	 * ensure that the compiler does not reorder the update
	 * of i_update_core above the timestamp updates above.
	 */
	SYNCHRONIZE();
	ip->i_update_core = 1;
180
	if (!(inode->i_state & I_NEW))
181 182 183
		mark_inode_dirty_sync(inode);
}

L
Linus Torvalds 已提交
184 185 186 187 188

/*
 * Pull the link count and size up from the xfs inode to the linux inode
 */
STATIC void
189
xfs_validate_fields(
C
Christoph Hellwig 已提交
190
	struct inode		*inode)
L
Linus Torvalds 已提交
191
{
C
Christoph Hellwig 已提交
192 193 194 195 196 197 198
	struct xfs_inode	*ip = XFS_I(inode);
	loff_t size;

	/* we're under i_sem so i_size can't change under us */
	size = XFS_ISIZE(ip);
	if (i_size_read(inode) != size)
		i_size_write(inode, size);
L
Linus Torvalds 已提交
199 200
}

201 202 203 204 205 206 207
/*
 * Hook in SELinux.  This is not quite correct yet, what we really need
 * here (as we do for default ACLs) is a mechanism by which creation of
 * these attrs can be journalled at inode creation time (along with the
 * inode, of course, such that log replay can't cause these to be lost).
 */
STATIC int
208
xfs_init_security(
209
	struct inode	*inode,
210 211
	struct inode	*dir)
{
212
	struct xfs_inode *ip = XFS_I(inode);
213 214 215 216 217
	size_t		length;
	void		*value;
	char		*name;
	int		error;

218 219
	error = security_inode_init_security(inode, dir, &name,
					     &value, &length);
220 221 222 223 224 225
	if (error) {
		if (error == -EOPNOTSUPP)
			return 0;
		return -error;
	}

226
	error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
227
	if (!error)
228
		xfs_iflags_set(ip, XFS_IMODIFIED);
229 230 231 232 233 234

	kfree(name);
	kfree(value);
	return error;
}

235 236 237 238 239 240 241 242 243
static void
xfs_dentry_to_name(
	struct xfs_name	*namep,
	struct dentry	*dentry)
{
	namep->name = dentry->d_name.name;
	namep->len = dentry->d_name.len;
}

244
STATIC void
245
xfs_cleanup_inode(
246
	struct inode	*dir,
247
	struct inode	*inode,
248
	struct dentry	*dentry,
249 250
	int		mode)
{
251
	struct xfs_name	teardown;
252 253

	/* Oh, the horror.
254
	 * If we can't add the ACL or we fail in
255
	 * xfs_init_security we must back out.
256 257
	 * ENOSPC can hit here, among other things.
	 */
258
	xfs_dentry_to_name(&teardown, dentry);
259 260

	if (S_ISDIR(mode))
261
		xfs_rmdir(XFS_I(dir), &teardown, XFS_I(inode));
262
	else
263
		xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
264
	iput(inode);
265 266
}

L
Linus Torvalds 已提交
267
STATIC int
268
xfs_vn_mknod(
L
Linus Torvalds 已提交
269 270 271 272 273
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	dev_t		rdev)
{
C
Christoph Hellwig 已提交
274
	struct inode	*inode;
275
	struct xfs_inode *ip = NULL;
L
Linus Torvalds 已提交
276
	xfs_acl_t	*default_acl = NULL;
277
	struct xfs_name	name;
L
Linus Torvalds 已提交
278 279 280 281 282 283 284
	attrexists_t	test_default_acl = _ACL_DEFAULT_EXISTS;
	int		error;

	/*
	 * Irix uses Missed'em'V split, but doesn't want to see
	 * the upper 5 bits of (14bit) major.
	 */
285
	if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
L
Linus Torvalds 已提交
286 287
		return -EINVAL;

288
	if (test_default_acl && test_default_acl(dir)) {
289
		if (!_ACL_ALLOC(default_acl)) {
L
Linus Torvalds 已提交
290
			return -ENOMEM;
291
		}
292
		if (!_ACL_GET_DEFAULT(dir, default_acl)) {
L
Linus Torvalds 已提交
293 294 295 296 297
			_ACL_FREE(default_acl);
			default_acl = NULL;
		}
	}

298 299
	xfs_dentry_to_name(&name, dentry);

C
Christoph Hellwig 已提交
300
	if (IS_POSIXACL(dir) && !default_acl)
L
Linus Torvalds 已提交
301 302 303
		mode &= ~current->fs->umask;

	switch (mode & S_IFMT) {
C
Christoph Hellwig 已提交
304 305 306 307
	case S_IFCHR:
	case S_IFBLK:
	case S_IFIFO:
	case S_IFSOCK:
308
		rdev = sysv_encode_dev(rdev);
L
Linus Torvalds 已提交
309
	case S_IFREG:
310
		error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip, NULL);
L
Linus Torvalds 已提交
311 312
		break;
	case S_IFDIR:
313
		error = xfs_mkdir(XFS_I(dir), &name, mode, &ip, NULL);
L
Linus Torvalds 已提交
314 315 316 317 318 319
		break;
	default:
		error = EINVAL;
		break;
	}

C
Christoph Hellwig 已提交
320 321
	if (unlikely(error))
		goto out_free_acl;
322

323 324 325
	inode = ip->i_vnode;

	error = xfs_init_security(inode, dir);
C
Christoph Hellwig 已提交
326 327 328 329
	if (unlikely(error))
		goto out_cleanup_inode;

	if (default_acl) {
330
		error = _ACL_INHERIT(inode, mode, default_acl);
C
Christoph Hellwig 已提交
331 332
		if (unlikely(error))
			goto out_cleanup_inode;
333
		xfs_iflags_set(ip, XFS_IMODIFIED);
L
Linus Torvalds 已提交
334 335 336 337
		_ACL_FREE(default_acl);
	}


C
Christoph Hellwig 已提交
338 339 340 341 342 343 344
	if (S_ISDIR(mode))
		xfs_validate_fields(inode);
	d_instantiate(dentry, inode);
	xfs_validate_fields(dir);
	return -error;

 out_cleanup_inode:
345
	xfs_cleanup_inode(dir, inode, dentry, mode);
C
Christoph Hellwig 已提交
346 347 348
 out_free_acl:
	if (default_acl)
		_ACL_FREE(default_acl);
L
Linus Torvalds 已提交
349 350 351 352
	return -error;
}

STATIC int
353
xfs_vn_create(
L
Linus Torvalds 已提交
354 355 356 357 358
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	struct nameidata *nd)
{
359
	return xfs_vn_mknod(dir, dentry, mode, 0);
L
Linus Torvalds 已提交
360 361 362
}

STATIC int
363
xfs_vn_mkdir(
L
Linus Torvalds 已提交
364 365 366 367
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode)
{
368
	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
L
Linus Torvalds 已提交
369 370 371
}

STATIC struct dentry *
372
xfs_vn_lookup(
L
Linus Torvalds 已提交
373 374 375 376
	struct inode	*dir,
	struct dentry	*dentry,
	struct nameidata *nd)
{
377
	struct xfs_inode *cip;
378
	struct xfs_name	name;
L
Linus Torvalds 已提交
379 380 381 382 383
	int		error;

	if (dentry->d_name.len >= MAXNAMELEN)
		return ERR_PTR(-ENAMETOOLONG);

384
	xfs_dentry_to_name(&name, dentry);
385
	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
386
	if (unlikely(error)) {
L
Linus Torvalds 已提交
387 388 389 390 391 392
		if (unlikely(error != ENOENT))
			return ERR_PTR(-error);
		d_add(dentry, NULL);
		return NULL;
	}

393
	return d_splice_alias(cip->i_vnode, dentry);
L
Linus Torvalds 已提交
394 395
}

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
STATIC struct dentry *
xfs_vn_ci_lookup(
	struct inode	*dir,
	struct dentry	*dentry,
	struct nameidata *nd)
{
	struct xfs_inode *ip;
	struct xfs_name	xname;
	struct xfs_name ci_name;
	struct qstr	dname;
	int		error;

	if (dentry->d_name.len >= MAXNAMELEN)
		return ERR_PTR(-ENAMETOOLONG);

	xfs_dentry_to_name(&xname, dentry);
	error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
	if (unlikely(error)) {
		if (unlikely(error != ENOENT))
			return ERR_PTR(-error);
416 417 418 419 420
		/*
		 * call d_add(dentry, NULL) here when d_drop_negative_children
		 * is called in xfs_vn_mknod (ie. allow negative dentries
		 * with CI filesystems).
		 */
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
		return NULL;
	}

	/* if exact match, just splice and exit */
	if (!ci_name.name)
		return d_splice_alias(ip->i_vnode, dentry);

	/* else case-insensitive match... */
	dname.name = ci_name.name;
	dname.len = ci_name.len;
	dentry = d_add_ci(ip->i_vnode, dentry, &dname);
	kmem_free(ci_name.name);
	return dentry;
}

L
Linus Torvalds 已提交
436
STATIC int
437
xfs_vn_link(
L
Linus Torvalds 已提交
438 439 440 441
	struct dentry	*old_dentry,
	struct inode	*dir,
	struct dentry	*dentry)
{
442
	struct inode	*inode;	/* inode of guy being linked to */
443
	struct xfs_name	name;
L
Linus Torvalds 已提交
444 445
	int		error;

446
	inode = old_dentry->d_inode;
447
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
448

449
	igrab(inode);
450
	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
451
	if (unlikely(error)) {
452 453
		iput(inode);
		return -error;
L
Linus Torvalds 已提交
454
	}
455 456 457 458 459

	xfs_iflags_set(XFS_I(dir), XFS_IMODIFIED);
	xfs_validate_fields(inode);
	d_instantiate(dentry, inode);
	return 0;
L
Linus Torvalds 已提交
460 461 462
}

STATIC int
463
xfs_vn_unlink(
L
Linus Torvalds 已提交
464 465 466 467
	struct inode	*dir,
	struct dentry	*dentry)
{
	struct inode	*inode;
468
	struct xfs_name	name;
L
Linus Torvalds 已提交
469 470 471
	int		error;

	inode = dentry->d_inode;
472
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
473

474
	error = xfs_remove(XFS_I(dir), &name, XFS_I(inode));
475
	if (likely(!error)) {
C
Christoph Hellwig 已提交
476 477
		xfs_validate_fields(dir);	/* size needs update */
		xfs_validate_fields(inode);
478 479 480 481 482 483 484
		/*
		 * With unlink, the VFS makes the dentry "negative": no inode,
		 * but still hashed. This is incompatible with case-insensitive
		 * mode, so invalidate (unhash) the dentry in CI-mode.
		 */
		if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
			d_invalidate(dentry);
L
Linus Torvalds 已提交
485 486 487 488 489
	}
	return -error;
}

STATIC int
490
xfs_vn_symlink(
L
Linus Torvalds 已提交
491 492 493 494
	struct inode	*dir,
	struct dentry	*dentry,
	const char	*symname)
{
495 496
	struct inode	*inode;
	struct xfs_inode *cip = NULL;
497
	struct xfs_name	name;
L
Linus Torvalds 已提交
498
	int		error;
499
	mode_t		mode;
L
Linus Torvalds 已提交
500

501
	mode = S_IFLNK |
502
		(irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
503
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
504

505
	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip, NULL);
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	if (unlikely(error))
		goto out;

	inode = cip->i_vnode;

	error = xfs_init_security(inode, dir);
	if (unlikely(error))
		goto out_cleanup_inode;

	d_instantiate(dentry, inode);
	xfs_validate_fields(dir);
	xfs_validate_fields(inode);
	return 0;

 out_cleanup_inode:
	xfs_cleanup_inode(dir, inode, dentry, 0);
 out:
L
Linus Torvalds 已提交
523 524 525 526
	return -error;
}

STATIC int
527
xfs_vn_rmdir(
L
Linus Torvalds 已提交
528 529 530 531
	struct inode	*dir,
	struct dentry	*dentry)
{
	struct inode	*inode = dentry->d_inode;
532
	struct xfs_name	name;
L
Linus Torvalds 已提交
533 534
	int		error;

535 536 537
	xfs_dentry_to_name(&name, dentry);

	error = xfs_rmdir(XFS_I(dir), &name, XFS_I(inode));
538
	if (likely(!error)) {
C
Christoph Hellwig 已提交
539 540
		xfs_validate_fields(inode);
		xfs_validate_fields(dir);
541 542 543 544 545 546 547
		/*
		 * With rmdir, the VFS makes the dentry "negative": no inode,
		 * but still hashed. This is incompatible with case-insensitive
		 * mode, so invalidate (unhash) the dentry in CI-mode.
		 */
		if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
			d_invalidate(dentry);
L
Linus Torvalds 已提交
548 549 550 551 552
	}
	return -error;
}

STATIC int
553
xfs_vn_rename(
L
Linus Torvalds 已提交
554 555 556 557 558 559
	struct inode	*odir,
	struct dentry	*odentry,
	struct inode	*ndir,
	struct dentry	*ndentry)
{
	struct inode	*new_inode = ndentry->d_inode;
560 561
	struct xfs_name	oname;
	struct xfs_name	nname;
L
Linus Torvalds 已提交
562 563
	int		error;

564 565 566 567
	xfs_dentry_to_name(&oname, odentry);
	xfs_dentry_to_name(&nname, ndentry);

	error = xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
568 569
			   XFS_I(ndir), &nname, new_inode ?
			   			XFS_I(new_inode) : NULL);
570 571
	if (likely(!error)) {
		if (new_inode)
C
Christoph Hellwig 已提交
572 573
			xfs_validate_fields(new_inode);
		xfs_validate_fields(odir);
574
		if (ndir != odir)
C
Christoph Hellwig 已提交
575
			xfs_validate_fields(ndir);
576 577
	}
	return -error;
L
Linus Torvalds 已提交
578 579 580 581 582 583 584
}

/*
 * careful here - this function can get called recursively, so
 * we need to be very careful about how much stack we use.
 * uio is kmalloced for this reason...
 */
585
STATIC void *
586
xfs_vn_follow_link(
L
Linus Torvalds 已提交
587 588 589 590
	struct dentry		*dentry,
	struct nameidata	*nd)
{
	char			*link;
591
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
592

593
	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
594 595
	if (!link)
		goto out_err;
L
Linus Torvalds 已提交
596

597
	error = -xfs_readlink(XFS_I(dentry->d_inode), link);
598 599
	if (unlikely(error))
		goto out_kfree;
L
Linus Torvalds 已提交
600 601

	nd_set_link(nd, link);
602
	return NULL;
603 604 605 606 607 608

 out_kfree:
	kfree(link);
 out_err:
	nd_set_link(nd, ERR_PTR(error));
	return NULL;
L
Linus Torvalds 已提交
609 610
}

611
STATIC void
612
xfs_vn_put_link(
613 614 615
	struct dentry	*dentry,
	struct nameidata *nd,
	void		*p)
L
Linus Torvalds 已提交
616
{
617 618
	char		*s = nd_get_link(nd);

L
Linus Torvalds 已提交
619 620 621 622 623
	if (!IS_ERR(s))
		kfree(s);
}

#ifdef CONFIG_XFS_POSIX_ACL
C
Christoph Hellwig 已提交
624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
STATIC int
xfs_check_acl(
	struct inode		*inode,
	int			mask)
{
	struct xfs_inode	*ip = XFS_I(inode);
	int			error;

	xfs_itrace_entry(ip);

	if (XFS_IFORK_Q(ip)) {
		error = xfs_acl_iaccess(ip, mask, NULL);
		if (error != -1)
			return -error;
	}

	return -EAGAIN;
}

L
Linus Torvalds 已提交
643
STATIC int
644
xfs_vn_permission(
C
Christoph Hellwig 已提交
645
	struct inode		*inode,
646
	int			mask)
L
Linus Torvalds 已提交
647
{
C
Christoph Hellwig 已提交
648
	return generic_permission(inode, mask, xfs_check_acl);
L
Linus Torvalds 已提交
649 650
}
#else
651
#define xfs_vn_permission NULL
L
Linus Torvalds 已提交
652 653 654
#endif

STATIC int
655
xfs_vn_getattr(
656 657 658
	struct vfsmount		*mnt,
	struct dentry		*dentry,
	struct kstat		*stat)
L
Linus Torvalds 已提交
659
{
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695
	struct inode		*inode = dentry->d_inode;
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;

	xfs_itrace_entry(ip);

	if (XFS_FORCED_SHUTDOWN(mp))
		return XFS_ERROR(EIO);

	stat->size = XFS_ISIZE(ip);
	stat->dev = inode->i_sb->s_dev;
	stat->mode = ip->i_d.di_mode;
	stat->nlink = ip->i_d.di_nlink;
	stat->uid = ip->i_d.di_uid;
	stat->gid = ip->i_d.di_gid;
	stat->ino = ip->i_ino;
#if XFS_BIG_INUMS
	stat->ino += mp->m_inoadd;
#endif
	stat->atime = inode->i_atime;
	stat->mtime.tv_sec = ip->i_d.di_mtime.t_sec;
	stat->mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
	stat->ctime.tv_sec = ip->i_d.di_ctime.t_sec;
	stat->ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
	stat->blocks =
		XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);


	switch (inode->i_mode & S_IFMT) {
	case S_IFBLK:
	case S_IFCHR:
		stat->blksize = BLKDEV_IOSIZE;
		stat->rdev = MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
				   sysv_minor(ip->i_df.if_u2.if_rdev));
		break;
	default:
696
		if (XFS_IS_REALTIME_INODE(ip)) {
697 698 699 700 701 702 703 704 705 706 707
			/*
			 * If the file blocks are being allocated from a
			 * realtime volume, then return the inode's realtime
			 * extent size or the realtime volume's extent size.
			 */
			stat->blksize =
				xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
		} else
			stat->blksize = xfs_preferred_iosize(mp);
		stat->rdev = 0;
		break;
708
	}
709 710

	return 0;
L
Linus Torvalds 已提交
711 712 713
}

STATIC int
714
xfs_vn_setattr(
L
Linus Torvalds 已提交
715 716 717 718 719
	struct dentry	*dentry,
	struct iattr	*attr)
{
	struct inode	*inode = dentry->d_inode;
	unsigned int	ia_valid = attr->ia_valid;
720
	bhv_vattr_t	vattr = { 0 };
L
Linus Torvalds 已提交
721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
	int		flags = 0;
	int		error;

	if (ia_valid & ATTR_UID) {
		vattr.va_mask |= XFS_AT_UID;
		vattr.va_uid = attr->ia_uid;
	}
	if (ia_valid & ATTR_GID) {
		vattr.va_mask |= XFS_AT_GID;
		vattr.va_gid = attr->ia_gid;
	}
	if (ia_valid & ATTR_SIZE) {
		vattr.va_mask |= XFS_AT_SIZE;
		vattr.va_size = attr->ia_size;
	}
	if (ia_valid & ATTR_ATIME) {
		vattr.va_mask |= XFS_AT_ATIME;
		vattr.va_atime = attr->ia_atime;
739
		inode->i_atime = attr->ia_atime;
L
Linus Torvalds 已提交
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762
	}
	if (ia_valid & ATTR_MTIME) {
		vattr.va_mask |= XFS_AT_MTIME;
		vattr.va_mtime = attr->ia_mtime;
	}
	if (ia_valid & ATTR_CTIME) {
		vattr.va_mask |= XFS_AT_CTIME;
		vattr.va_ctime = attr->ia_ctime;
	}
	if (ia_valid & ATTR_MODE) {
		vattr.va_mask |= XFS_AT_MODE;
		vattr.va_mode = attr->ia_mode;
		if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
			inode->i_mode &= ~S_ISGID;
	}

	if (ia_valid & (ATTR_MTIME_SET | ATTR_ATIME_SET))
		flags |= ATTR_UTIME;
#ifdef ATTR_NO_BLOCK
	if ((ia_valid & ATTR_NO_BLOCK))
		flags |= ATTR_NONBLOCK;
#endif

763
	error = xfs_setattr(XFS_I(inode), &vattr, flags, NULL);
764
	if (likely(!error))
C
Christoph Hellwig 已提交
765
		vn_revalidate(vn_from_inode(inode));
766
	return -error;
L
Linus Torvalds 已提交
767 768
}

769 770 771 772 773
/*
 * block_truncate_page can return an error, but we can't propagate it
 * at all here. Leave a complaint + stack trace in the syslog because
 * this could be bad. If it is bad, we need to propagate the error further.
 */
L
Linus Torvalds 已提交
774
STATIC void
775
xfs_vn_truncate(
L
Linus Torvalds 已提交
776 777
	struct inode	*inode)
{
778 779 780 781
	int	error;
	error = block_truncate_page(inode->i_mapping, inode->i_size,
							xfs_get_blocks);
	WARN_ON(error);
L
Linus Torvalds 已提交
782 783 784
}

STATIC int
785
xfs_vn_setxattr(
L
Linus Torvalds 已提交
786 787 788 789 790 791
	struct dentry	*dentry,
	const char	*name,
	const void	*data,
	size_t		size,
	int		flags)
{
792
	bhv_vnode_t	*vp = vn_from_inode(dentry->d_inode);
L
Linus Torvalds 已提交
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
	char		*attr = (char *)name;
	attrnames_t	*namesp;
	int		xflags = 0;

	namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
	if (!namesp)
		return -EOPNOTSUPP;
	attr += namesp->attr_namelen;

	/* Convert Linux syscall to XFS internal ATTR flags */
	if (flags & XATTR_CREATE)
		xflags |= ATTR_CREATE;
	if (flags & XATTR_REPLACE)
		xflags |= ATTR_REPLACE;
	xflags |= namesp->attr_flag;
	return namesp->attr_set(vp, attr, (void *)data, size, xflags);
}

STATIC ssize_t
812
xfs_vn_getxattr(
L
Linus Torvalds 已提交
813 814 815 816 817
	struct dentry	*dentry,
	const char	*name,
	void		*data,
	size_t		size)
{
818
	bhv_vnode_t	*vp = vn_from_inode(dentry->d_inode);
L
Linus Torvalds 已提交
819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	char		*attr = (char *)name;
	attrnames_t	*namesp;
	int		xflags = 0;

	namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
	if (!namesp)
		return -EOPNOTSUPP;
	attr += namesp->attr_namelen;

	/* Convert Linux syscall to XFS internal ATTR flags */
	if (!size) {
		xflags |= ATTR_KERNOVAL;
		data = NULL;
	}
	xflags |= namesp->attr_flag;
	return namesp->attr_get(vp, attr, (void *)data, size, xflags);
}

STATIC ssize_t
838
xfs_vn_listxattr(
L
Linus Torvalds 已提交
839 840 841 842
	struct dentry		*dentry,
	char			*data,
	size_t			size)
{
843
	bhv_vnode_t		*vp = vn_from_inode(dentry->d_inode);
L
Linus Torvalds 已提交
844 845 846 847 848 849 850 851 852 853 854 855 856 857
	int			error, xflags = ATTR_KERNAMELS;
	ssize_t			result;

	if (!size)
		xflags |= ATTR_KERNOVAL;
	xflags |= capable(CAP_SYS_ADMIN) ? ATTR_KERNFULLS : ATTR_KERNORMALS;

	error = attr_generic_list(vp, data, size, xflags, &result);
	if (error < 0)
		return error;
	return result;
}

STATIC int
858
xfs_vn_removexattr(
L
Linus Torvalds 已提交
859 860 861
	struct dentry	*dentry,
	const char	*name)
{
862
	bhv_vnode_t	*vp = vn_from_inode(dentry->d_inode);
L
Linus Torvalds 已提交
863 864 865 866 867 868 869 870
	char		*attr = (char *)name;
	attrnames_t	*namesp;
	int		xflags = 0;

	namesp = attr_lookup_namespace(attr, attr_namespaces, ATTR_NAMECOUNT);
	if (!namesp)
		return -EOPNOTSUPP;
	attr += namesp->attr_namelen;
871

L
Linus Torvalds 已提交
872 873 874 875
	xflags |= namesp->attr_flag;
	return namesp->attr_remove(vp, attr, xflags);
}

D
David Chinner 已提交
876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
STATIC long
xfs_vn_fallocate(
	struct inode	*inode,
	int		mode,
	loff_t		offset,
	loff_t		len)
{
	long		error;
	loff_t		new_size = 0;
	xfs_flock64_t	bf;
	xfs_inode_t	*ip = XFS_I(inode);

	/* preallocation on directories not yet supported */
	error = -ENODEV;
	if (S_ISDIR(inode->i_mode))
		goto out_error;

	bf.l_whence = 0;
	bf.l_start = offset;
	bf.l_len = len;

	xfs_ilock(ip, XFS_IOLOCK_EXCL);
	error = xfs_change_file_space(ip, XFS_IOC_RESVSP, &bf,
						0, NULL, ATTR_NOLOCK);
	if (!error && !(mode & FALLOC_FL_KEEP_SIZE) &&
	    offset + len > i_size_read(inode))
		new_size = offset + len;

	/* Change file size if needed */
	if (new_size) {
		bhv_vattr_t	va;

		va.va_mask = XFS_AT_SIZE;
		va.va_size = new_size;
		error = xfs_setattr(ip, &va, ATTR_NOLOCK, NULL);
	}

	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
out_error:
	return error;
}
L
Linus Torvalds 已提交
917

918
const struct inode_operations xfs_inode_operations = {
919 920 921 922 923 924 925 926
	.permission		= xfs_vn_permission,
	.truncate		= xfs_vn_truncate,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
	.setxattr		= xfs_vn_setxattr,
	.getxattr		= xfs_vn_getxattr,
	.listxattr		= xfs_vn_listxattr,
	.removexattr		= xfs_vn_removexattr,
D
David Chinner 已提交
927
	.fallocate		= xfs_vn_fallocate,
L
Linus Torvalds 已提交
928 929
};

930
const struct inode_operations xfs_dir_inode_operations = {
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946
	.create			= xfs_vn_create,
	.lookup			= xfs_vn_lookup,
	.link			= xfs_vn_link,
	.unlink			= xfs_vn_unlink,
	.symlink		= xfs_vn_symlink,
	.mkdir			= xfs_vn_mkdir,
	.rmdir			= xfs_vn_rmdir,
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
	.setxattr		= xfs_vn_setxattr,
	.getxattr		= xfs_vn_getxattr,
	.listxattr		= xfs_vn_listxattr,
	.removexattr		= xfs_vn_removexattr,
L
Linus Torvalds 已提交
947 948
};

949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
const struct inode_operations xfs_dir_ci_inode_operations = {
	.create			= xfs_vn_create,
	.lookup			= xfs_vn_ci_lookup,
	.link			= xfs_vn_link,
	.unlink			= xfs_vn_unlink,
	.symlink		= xfs_vn_symlink,
	.mkdir			= xfs_vn_mkdir,
	.rmdir			= xfs_vn_rmdir,
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
	.setxattr		= xfs_vn_setxattr,
	.getxattr		= xfs_vn_getxattr,
	.listxattr		= xfs_vn_listxattr,
	.removexattr		= xfs_vn_removexattr,
};

968
const struct inode_operations xfs_symlink_inode_operations = {
L
Linus Torvalds 已提交
969
	.readlink		= generic_readlink,
970 971 972 973 974 975 976 977 978
	.follow_link		= xfs_vn_follow_link,
	.put_link		= xfs_vn_put_link,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
	.setxattr		= xfs_vn_setxattr,
	.getxattr		= xfs_vn_getxattr,
	.listxattr		= xfs_vn_listxattr,
	.removexattr		= xfs_vn_removexattr,
L
Linus Torvalds 已提交
979
};