xfs_iops.c 34.0 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_shared.h"
21 22 23
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
24
#include "xfs_mount.h"
25
#include "xfs_da_format.h"
L
Linus Torvalds 已提交
26 27
#include "xfs_inode.h"
#include "xfs_bmap.h"
D
Dave Chinner 已提交
28
#include "xfs_bmap_util.h"
29 30
#include "xfs_acl.h"
#include "xfs_quota.h"
L
Linus Torvalds 已提交
31 32
#include "xfs_error.h"
#include "xfs_attr.h"
33
#include "xfs_trans.h"
C
Christoph Hellwig 已提交
34
#include "xfs_trace.h"
35
#include "xfs_icache.h"
D
Dave Chinner 已提交
36
#include "xfs_symlink.h"
37
#include "xfs_da_btree.h"
38
#include "xfs_dir2.h"
Z
Zhi Yong Wu 已提交
39
#include "xfs_trans_space.h"
L
Linus Torvalds 已提交
40

41
#include <linux/capability.h>
L
Linus Torvalds 已提交
42 43
#include <linux/xattr.h>
#include <linux/namei.h>
44
#include <linux/posix_acl.h>
45
#include <linux/security.h>
E
Eric Sandeen 已提交
46
#include <linux/fiemap.h>
47
#include <linux/slab.h>
L
Linus Torvalds 已提交
48

49 50 51 52 53 54 55 56 57 58 59 60
/*
 * Directories have different lock order w.r.t. mmap_sem compared to regular
 * files. This is due to readdir potentially triggering page faults on a user
 * buffer inside filldir(), and this happens with the ilock on the directory
 * held. For regular files, the lock order is the other way around - the
 * mmap_sem is taken during the page fault, and then we lock the ilock to do
 * block mapping. Hence we need a different class for the directory ilock so
 * that lockdep can tell them apart.
 */
static struct lock_class_key xfs_nondir_ilock_class;
static struct lock_class_key xfs_dir_ilock_class;

61 62 63 64 65
static int
xfs_initxattrs(
	struct inode		*inode,
	const struct xattr	*xattr_array,
	void			*fs_info)
66
{
67 68 69
	const struct xattr	*xattr;
	struct xfs_inode	*ip = XFS_I(inode);
	int			error = 0;
70 71

	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
D
Dave Chinner 已提交
72
		error = xfs_attr_set(ip, xattr->name, xattr->value,
73
				      xattr->value_len, ATTR_SECURE);
74 75 76 77 78 79
		if (error < 0)
			break;
	}
	return error;
}

80 81 82 83 84 85
/*
 * 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).
 */
86

87
STATIC int
88
xfs_init_security(
89
	struct inode	*inode,
90 91
	struct inode	*dir,
	const struct qstr *qstr)
92
{
D
Dave Chinner 已提交
93
	return security_inode_init_security(inode, dir, qstr,
94
					     &xfs_initxattrs, NULL);
95 96
}

97 98 99
static void
xfs_dentry_to_name(
	struct xfs_name	*namep,
100 101
	struct dentry	*dentry,
	int		mode)
102 103 104
{
	namep->name = dentry->d_name.name;
	namep->len = dentry->d_name.len;
105
	namep->type = xfs_mode_to_ftype[(mode & S_IFMT) >> S_SHIFT];
106 107
}

108
STATIC void
109
xfs_cleanup_inode(
110
	struct inode	*dir,
111
	struct inode	*inode,
112
	struct dentry	*dentry)
113
{
114
	struct xfs_name	teardown;
115 116

	/* Oh, the horror.
117
	 * If we can't add the ACL or we fail in
118
	 * xfs_init_security we must back out.
119 120
	 * ENOSPC can hit here, among other things.
	 */
121
	xfs_dentry_to_name(&teardown, dentry, 0);
122

123
	xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
124 125
}

L
Linus Torvalds 已提交
126
STATIC int
127
xfs_generic_create(
L
Linus Torvalds 已提交
128 129
	struct inode	*dir,
	struct dentry	*dentry,
A
Al Viro 已提交
130
	umode_t		mode,
131 132
	dev_t		rdev,
	bool		tmpfile)	/* unnamed file */
L
Linus Torvalds 已提交
133
{
C
Christoph Hellwig 已提交
134
	struct inode	*inode;
135
	struct xfs_inode *ip = NULL;
136
	struct posix_acl *default_acl, *acl;
137
	struct xfs_name	name;
L
Linus Torvalds 已提交
138 139 140 141 142 143
	int		error;

	/*
	 * Irix uses Missed'em'V split, but doesn't want to see
	 * the upper 5 bits of (14bit) major.
	 */
144 145 146 147 148 149 150
	if (S_ISCHR(mode) || S_ISBLK(mode)) {
		if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
			return -EINVAL;
		rdev = sysv_encode_dev(rdev);
	} else {
		rdev = 0;
	}
L
Linus Torvalds 已提交
151

152 153 154
	error = posix_acl_create(dir, &mode, &default_acl, &acl);
	if (error)
		return error;
L
Linus Torvalds 已提交
155

156 157 158 159 160 161
	if (!tmpfile) {
		xfs_dentry_to_name(&name, dentry, mode);
		error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
	} else {
		error = xfs_create_tmpfile(XFS_I(dir), dentry, mode, &ip);
	}
C
Christoph Hellwig 已提交
162 163
	if (unlikely(error))
		goto out_free_acl;
164

165
	inode = VFS_I(ip);
166

167
	error = xfs_init_security(inode, dir, &dentry->d_name);
C
Christoph Hellwig 已提交
168 169 170
	if (unlikely(error))
		goto out_cleanup_inode;

171
#ifdef CONFIG_XFS_POSIX_ACL
C
Christoph Hellwig 已提交
172
	if (default_acl) {
D
Dave Chinner 已提交
173
		error = xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
174
		if (error)
C
Christoph Hellwig 已提交
175
			goto out_cleanup_inode;
L
Linus Torvalds 已提交
176
	}
177
	if (acl) {
D
Dave Chinner 已提交
178
		error = xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
179 180 181 182
		if (error)
			goto out_cleanup_inode;
	}
#endif
L
Linus Torvalds 已提交
183

184 185 186 187 188
	if (tmpfile)
		d_tmpfile(dentry, inode);
	else
		d_instantiate(dentry, inode);

189 190 191 192 193
 out_free_acl:
	if (default_acl)
		posix_acl_release(default_acl);
	if (acl)
		posix_acl_release(acl);
D
Dave Chinner 已提交
194
	return error;
C
Christoph Hellwig 已提交
195 196

 out_cleanup_inode:
197 198 199
	if (!tmpfile)
		xfs_cleanup_inode(dir, inode, dentry);
	iput(inode);
200
	goto out_free_acl;
L
Linus Torvalds 已提交
201 202
}

203 204 205 206 207 208 209 210 211 212
STATIC int
xfs_vn_mknod(
	struct inode	*dir,
	struct dentry	*dentry,
	umode_t		mode,
	dev_t		rdev)
{
	return xfs_generic_create(dir, dentry, mode, rdev, false);
}

L
Linus Torvalds 已提交
213
STATIC int
214
xfs_vn_create(
L
Linus Torvalds 已提交
215 216
	struct inode	*dir,
	struct dentry	*dentry,
A
Al Viro 已提交
217
	umode_t		mode,
A
Al Viro 已提交
218
	bool		flags)
L
Linus Torvalds 已提交
219
{
220
	return xfs_vn_mknod(dir, dentry, mode, 0);
L
Linus Torvalds 已提交
221 222 223
}

STATIC int
224
xfs_vn_mkdir(
L
Linus Torvalds 已提交
225 226
	struct inode	*dir,
	struct dentry	*dentry,
227
	umode_t		mode)
L
Linus Torvalds 已提交
228
{
229
	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
L
Linus Torvalds 已提交
230 231 232
}

STATIC struct dentry *
233
xfs_vn_lookup(
L
Linus Torvalds 已提交
234 235
	struct inode	*dir,
	struct dentry	*dentry,
A
Al Viro 已提交
236
	unsigned int flags)
L
Linus Torvalds 已提交
237
{
238
	struct xfs_inode *cip;
239
	struct xfs_name	name;
L
Linus Torvalds 已提交
240 241 242 243 244
	int		error;

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

245
	xfs_dentry_to_name(&name, dentry, 0);
246
	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
247
	if (unlikely(error)) {
D
Dave Chinner 已提交
248 249
		if (unlikely(error != -ENOENT))
			return ERR_PTR(error);
L
Linus Torvalds 已提交
250 251 252 253
		d_add(dentry, NULL);
		return NULL;
	}

254
	return d_splice_alias(VFS_I(cip), dentry);
L
Linus Torvalds 已提交
255 256
}

257 258 259 260
STATIC struct dentry *
xfs_vn_ci_lookup(
	struct inode	*dir,
	struct dentry	*dentry,
A
Al Viro 已提交
261
	unsigned int flags)
262 263 264 265 266 267 268 269 270 271
{
	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);

272
	xfs_dentry_to_name(&xname, dentry, 0);
273 274
	error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
	if (unlikely(error)) {
D
Dave Chinner 已提交
275 276
		if (unlikely(error != -ENOENT))
			return ERR_PTR(error);
277 278 279 280 281
		/*
		 * call d_add(dentry, NULL) here when d_drop_negative_children
		 * is called in xfs_vn_mknod (ie. allow negative dentries
		 * with CI filesystems).
		 */
282 283 284 285 286
		return NULL;
	}

	/* if exact match, just splice and exit */
	if (!ci_name.name)
287
		return d_splice_alias(VFS_I(ip), dentry);
288 289 290 291

	/* else case-insensitive match... */
	dname.name = ci_name.name;
	dname.len = ci_name.len;
292
	dentry = d_add_ci(dentry, VFS_I(ip), &dname);
293 294 295 296
	kmem_free(ci_name.name);
	return dentry;
}

L
Linus Torvalds 已提交
297
STATIC int
298
xfs_vn_link(
L
Linus Torvalds 已提交
299 300 301 302
	struct dentry	*old_dentry,
	struct inode	*dir,
	struct dentry	*dentry)
{
303
	struct inode	*inode = old_dentry->d_inode;
304
	struct xfs_name	name;
L
Linus Torvalds 已提交
305 306
	int		error;

307
	xfs_dentry_to_name(&name, dentry, inode->i_mode);
L
Linus Torvalds 已提交
308

309
	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
310
	if (unlikely(error))
D
Dave Chinner 已提交
311
		return error;
312

A
Al Viro 已提交
313
	ihold(inode);
314 315
	d_instantiate(dentry, inode);
	return 0;
L
Linus Torvalds 已提交
316 317 318
}

STATIC int
319
xfs_vn_unlink(
L
Linus Torvalds 已提交
320 321 322
	struct inode	*dir,
	struct dentry	*dentry)
{
323
	struct xfs_name	name;
L
Linus Torvalds 已提交
324 325
	int		error;

326
	xfs_dentry_to_name(&name, dentry, 0);
L
Linus Torvalds 已提交
327

D
Dave Chinner 已提交
328
	error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
329 330 331 332 333 334 335 336 337 338 339
	if (error)
		return error;

	/*
	 * 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);
	return 0;
L
Linus Torvalds 已提交
340 341 342
}

STATIC int
343
xfs_vn_symlink(
L
Linus Torvalds 已提交
344 345 346 347
	struct inode	*dir,
	struct dentry	*dentry,
	const char	*symname)
{
348 349
	struct inode	*inode;
	struct xfs_inode *cip = NULL;
350
	struct xfs_name	name;
L
Linus Torvalds 已提交
351
	int		error;
A
Al Viro 已提交
352
	umode_t		mode;
L
Linus Torvalds 已提交
353

354
	mode = S_IFLNK |
A
Al Viro 已提交
355
		(irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
356
	xfs_dentry_to_name(&name, dentry, mode);
L
Linus Torvalds 已提交
357

C
Christoph Hellwig 已提交
358
	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
359 360 361
	if (unlikely(error))
		goto out;

362
	inode = VFS_I(cip);
363

364
	error = xfs_init_security(inode, dir, &dentry->d_name);
365 366 367 368 369 370 371
	if (unlikely(error))
		goto out_cleanup_inode;

	d_instantiate(dentry, inode);
	return 0;

 out_cleanup_inode:
372
	xfs_cleanup_inode(dir, inode, dentry);
373
	iput(inode);
374
 out:
D
Dave Chinner 已提交
375
	return error;
L
Linus Torvalds 已提交
376 377 378
}

STATIC int
379
xfs_vn_rename(
L
Linus Torvalds 已提交
380 381 382 383 384 385
	struct inode	*odir,
	struct dentry	*odentry,
	struct inode	*ndir,
	struct dentry	*ndentry)
{
	struct inode	*new_inode = ndentry->d_inode;
386 387
	struct xfs_name	oname;
	struct xfs_name	nname;
L
Linus Torvalds 已提交
388

389 390
	xfs_dentry_to_name(&oname, odentry, 0);
	xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
391

D
Dave Chinner 已提交
392 393
	return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
			  XFS_I(ndir), &nname, new_inode ?
394
						XFS_I(new_inode) : NULL);
L
Linus Torvalds 已提交
395 396 397 398 399 400 401
}

/*
 * 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...
 */
402
STATIC void *
403
xfs_vn_follow_link(
L
Linus Torvalds 已提交
404 405 406 407
	struct dentry		*dentry,
	struct nameidata	*nd)
{
	char			*link;
408
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
409

410
	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
411 412
	if (!link)
		goto out_err;
L
Linus Torvalds 已提交
413

D
Dave Chinner 已提交
414
	error = xfs_readlink(XFS_I(dentry->d_inode), link);
415 416
	if (unlikely(error))
		goto out_kfree;
L
Linus Torvalds 已提交
417 418

	nd_set_link(nd, link);
419
	return NULL;
420 421 422 423 424 425

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

STATIC int
429
xfs_vn_getattr(
430 431 432
	struct vfsmount		*mnt,
	struct dentry		*dentry,
	struct kstat		*stat)
L
Linus Torvalds 已提交
433
{
434 435 436 437
	struct inode		*inode = dentry->d_inode;
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;

C
Christoph Hellwig 已提交
438
	trace_xfs_getattr(ip);
439 440

	if (XFS_FORCED_SHUTDOWN(mp))
E
Eric Sandeen 已提交
441
		return -EIO;
442 443 444 445 446

	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;
447 448
	stat->uid = inode->i_uid;
	stat->gid = inode->i_gid;
449 450
	stat->ino = ip->i_ino;
	stat->atime = inode->i_atime;
451 452
	stat->mtime = inode->i_mtime;
	stat->ctime = inode->i_ctime;
453 454 455 456 457 458 459 460 461 462 463 464
	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:
465
		if (XFS_IS_REALTIME_INODE(ip)) {
466 467 468 469 470 471 472 473 474 475 476
			/*
			 * 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;
477
	}
478 479

	return 0;
L
Linus Torvalds 已提交
480 481
}

482 483 484 485 486
static void
xfs_setattr_mode(
	struct xfs_inode	*ip,
	struct iattr		*iattr)
{
487 488
	struct inode		*inode = VFS_I(ip);
	umode_t			mode = iattr->ia_mode;
489 490 491 492 493 494 495 496 497 498

	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));

	ip->i_d.di_mode &= S_IFMT;
	ip->i_d.di_mode |= mode & ~S_IFMT;

	inode->i_mode &= S_IFMT;
	inode->i_mode |= mode & ~S_IFMT;
}

C
Christoph Hellwig 已提交
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
static void
xfs_setattr_time(
	struct xfs_inode	*ip,
	struct iattr		*iattr)
{
	struct inode		*inode = VFS_I(ip);

	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));

	if (iattr->ia_valid & ATTR_ATIME) {
		inode->i_atime = iattr->ia_atime;
		ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
		ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
	}
	if (iattr->ia_valid & ATTR_CTIME) {
		inode->i_ctime = iattr->ia_ctime;
		ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
		ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
	}
	if (iattr->ia_valid & ATTR_MTIME) {
		inode->i_mtime = iattr->ia_mtime;
		ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
		ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
	}
}

C
Christoph Hellwig 已提交
525 526 527 528 529 530 531 532 533 534 535
int
xfs_setattr_nonsize(
	struct xfs_inode	*ip,
	struct iattr		*iattr,
	int			flags)
{
	xfs_mount_t		*mp = ip->i_mount;
	struct inode		*inode = VFS_I(ip);
	int			mask = iattr->ia_valid;
	xfs_trans_t		*tp;
	int			error;
536 537
	kuid_t			uid = GLOBAL_ROOT_UID, iuid = GLOBAL_ROOT_UID;
	kgid_t			gid = GLOBAL_ROOT_GID, igid = GLOBAL_ROOT_GID;
C
Christoph Hellwig 已提交
538 539 540 541 542
	struct xfs_dquot	*udqp = NULL, *gdqp = NULL;
	struct xfs_dquot	*olddquot1 = NULL, *olddquot2 = NULL;

	trace_xfs_setattr(ip);

543 544 545
	/* If acls are being inherited, we already have this checked */
	if (!(flags & XFS_ATTR_NOACL)) {
		if (mp->m_flags & XFS_MOUNT_RDONLY)
D
Dave Chinner 已提交
546
			return -EROFS;
C
Christoph Hellwig 已提交
547

548
		if (XFS_FORCED_SHUTDOWN(mp))
D
Dave Chinner 已提交
549
			return -EIO;
C
Christoph Hellwig 已提交
550

D
Dave Chinner 已提交
551
		error = inode_change_ok(inode, iattr);
552
		if (error)
E
Eric Sandeen 已提交
553
			return error;
554
	}
C
Christoph Hellwig 已提交
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572

	ASSERT((mask & ATTR_SIZE) == 0);

	/*
	 * If disk quotas is on, we make sure that the dquots do exist on disk,
	 * before we start any other transactions. Trying to do this later
	 * is messy. We don't care to take a readlock to look at the ids
	 * in inode here, because we can't hold it across the trans_reserve.
	 * If the IDs do change before we take the ilock, we're covered
	 * because the i_*dquot fields will get updated anyway.
	 */
	if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
		uint	qflags = 0;

		if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
			uid = iattr->ia_uid;
			qflags |= XFS_QMOPT_UQUOTA;
		} else {
573
			uid = inode->i_uid;
C
Christoph Hellwig 已提交
574 575 576 577 578
		}
		if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
			gid = iattr->ia_gid;
			qflags |= XFS_QMOPT_GQUOTA;
		}  else {
579
			gid = inode->i_gid;
C
Christoph Hellwig 已提交
580 581 582 583 584 585 586 587 588
		}

		/*
		 * We take a reference when we initialize udqp and gdqp,
		 * so it is important that we never blindly double trip on
		 * the same variable. See xfs_create() for an example.
		 */
		ASSERT(udqp == NULL);
		ASSERT(gdqp == NULL);
589 590 591 592
		error = xfs_qm_vop_dqalloc(ip, xfs_kuid_to_uid(uid),
					   xfs_kgid_to_gid(gid),
					   xfs_get_projid(ip),
					   qflags, &udqp, &gdqp, NULL);
C
Christoph Hellwig 已提交
593 594 595 596 597
		if (error)
			return error;
	}

	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
598
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
C
Christoph Hellwig 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
	if (error)
		goto out_dqrele;

	xfs_ilock(ip, XFS_ILOCK_EXCL);

	/*
	 * Change file ownership.  Must be the owner or privileged.
	 */
	if (mask & (ATTR_UID|ATTR_GID)) {
		/*
		 * These IDs could have changed since we last looked at them.
		 * But, we're assured that if the ownership did change
		 * while we didn't have the inode locked, inode's dquot(s)
		 * would have changed also.
		 */
614 615
		iuid = inode->i_uid;
		igid = inode->i_gid;
C
Christoph Hellwig 已提交
616 617 618 619 620 621 622 623
		gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
		uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;

		/*
		 * Do a quota reservation only if uid/gid is actually
		 * going to change.
		 */
		if (XFS_IS_QUOTA_RUNNING(mp) &&
624 625
		    ((XFS_IS_UQUOTA_ON(mp) && !uid_eq(iuid, uid)) ||
		     (XFS_IS_GQUOTA_ON(mp) && !gid_eq(igid, gid)))) {
C
Christoph Hellwig 已提交
626 627
			ASSERT(tp);
			error = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,
628
						NULL, capable(CAP_FOWNER) ?
C
Christoph Hellwig 已提交
629 630 631 632 633 634
						XFS_QMOPT_FORCE_RES : 0);
			if (error)	/* out of quota */
				goto out_trans_cancel;
		}
	}

635
	xfs_trans_ijoin(tp, ip, 0);
C
Christoph Hellwig 已提交
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654

	/*
	 * Change file ownership.  Must be the owner or privileged.
	 */
	if (mask & (ATTR_UID|ATTR_GID)) {
		/*
		 * CAP_FSETID overrides the following restrictions:
		 *
		 * The set-user-ID and set-group-ID bits of a file will be
		 * cleared upon successful return from chown()
		 */
		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
		    !capable(CAP_FSETID))
			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);

		/*
		 * Change the ownerships and register quota modifications
		 * in the transaction.
		 */
655
		if (!uid_eq(iuid, uid)) {
C
Christoph Hellwig 已提交
656 657 658 659 660 661
			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {
				ASSERT(mask & ATTR_UID);
				ASSERT(udqp);
				olddquot1 = xfs_qm_vop_chown(tp, ip,
							&ip->i_udquot, udqp);
			}
662
			ip->i_d.di_uid = xfs_kuid_to_uid(uid);
C
Christoph Hellwig 已提交
663 664
			inode->i_uid = uid;
		}
665
		if (!gid_eq(igid, gid)) {
C
Christoph Hellwig 已提交
666
			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
667 668
				ASSERT(xfs_sb_version_has_pquotino(&mp->m_sb) ||
				       !XFS_IS_PQUOTA_ON(mp));
C
Christoph Hellwig 已提交
669 670 671 672 673
				ASSERT(mask & ATTR_GID);
				ASSERT(gdqp);
				olddquot2 = xfs_qm_vop_chown(tp, ip,
							&ip->i_gdquot, gdqp);
			}
674
			ip->i_d.di_gid = xfs_kgid_to_gid(gid);
C
Christoph Hellwig 已提交
675 676 677 678
			inode->i_gid = gid;
		}
	}

679
	if (mask & ATTR_MODE)
680
		xfs_setattr_mode(ip, iattr);
C
Christoph Hellwig 已提交
681 682
	if (mask & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
		xfs_setattr_time(ip, iattr);
C
Christoph Hellwig 已提交
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	XFS_STATS_INC(xs_ig_attrchg);

	if (mp->m_flags & XFS_MOUNT_WSYNC)
		xfs_trans_set_sync(tp);
	error = xfs_trans_commit(tp, 0);

	xfs_iunlock(ip, XFS_ILOCK_EXCL);

	/*
	 * Release any dquot(s) the inode had kept before chown.
	 */
	xfs_qm_dqrele(olddquot1);
	xfs_qm_dqrele(olddquot2);
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);

	if (error)
E
Eric Sandeen 已提交
703
		return error;
C
Christoph Hellwig 已提交
704 705 706 707 708 709 710 711 712

	/*
	 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
	 * 	     update.  We could avoid this with linked transactions
	 * 	     and passing down the transaction pointer all the way
	 *	     to attr_set.  No previous user of the generic
	 * 	     Posix ACL code seems to care about this issue either.
	 */
	if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
D
Dave Chinner 已提交
713
		error = posix_acl_chmod(inode, inode->i_mode);
C
Christoph Hellwig 已提交
714
		if (error)
E
Eric Sandeen 已提交
715
			return error;
C
Christoph Hellwig 已提交
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
	}

	return 0;

out_trans_cancel:
	xfs_trans_cancel(tp, 0);
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
out_dqrele:
	xfs_qm_dqrele(udqp);
	xfs_qm_dqrele(gdqp);
	return error;
}

/*
 * Truncate file.  Must have write permission and not be a directory.
 */
int
xfs_setattr_size(
	struct xfs_inode	*ip,
735
	struct iattr		*iattr)
C
Christoph Hellwig 已提交
736 737 738
{
	struct xfs_mount	*mp = ip->i_mount;
	struct inode		*inode = VFS_I(ip);
739
	xfs_off_t		oldsize, newsize;
C
Christoph Hellwig 已提交
740 741
	struct xfs_trans	*tp;
	int			error;
742
	uint			lock_flags = 0;
C
Christoph Hellwig 已提交
743 744 745 746 747
	uint			commit_flags = 0;

	trace_xfs_setattr(ip);

	if (mp->m_flags & XFS_MOUNT_RDONLY)
D
Dave Chinner 已提交
748
		return -EROFS;
C
Christoph Hellwig 已提交
749 750

	if (XFS_FORCED_SHUTDOWN(mp))
D
Dave Chinner 已提交
751
		return -EIO;
C
Christoph Hellwig 已提交
752

D
Dave Chinner 已提交
753
	error = inode_change_ok(inode, iattr);
C
Christoph Hellwig 已提交
754
	if (error)
E
Eric Sandeen 已提交
755
		return error;
C
Christoph Hellwig 已提交
756

757
	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
C
Christoph Hellwig 已提交
758
	ASSERT(S_ISREG(ip->i_d.di_mode));
759 760
	ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
		ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
C
Christoph Hellwig 已提交
761

762
	oldsize = inode->i_size;
763 764
	newsize = iattr->ia_size;

C
Christoph Hellwig 已提交
765 766 767
	/*
	 * Short circuit the truncate case for zero length files.
	 */
768
	if (newsize == 0 && oldsize == 0 && ip->i_d.di_nextents == 0) {
769
		if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
770
			return 0;
771 772 773 774 775 776

		/*
		 * Use the regular setattr path to update the timestamps.
		 */
		iattr->ia_valid &= ~ATTR_SIZE;
		return xfs_setattr_nonsize(ip, iattr, 0);
C
Christoph Hellwig 已提交
777 778 779 780 781
	}

	/*
	 * Make sure that the dquots are attached to the inode.
	 */
782
	error = xfs_qm_dqattach(ip, 0);
C
Christoph Hellwig 已提交
783
	if (error)
784
		return error;
C
Christoph Hellwig 已提交
785 786 787 788 789 790 791 792

	/*
	 * Now we can make the changes.  Before we join the inode to the
	 * transaction, take care of the part of the truncation that must be
	 * done without the inode lock.  This needs to be done before joining
	 * the inode to the transaction, because the inode cannot be unlocked
	 * once it is a part of the transaction.
	 */
793
	if (newsize > oldsize) {
C
Christoph Hellwig 已提交
794 795 796 797 798 799
		/*
		 * Do the first part of growing a file: zero any data in the
		 * last block that is beyond the old EOF.  We need to do this
		 * before the inode is joined to the transaction to modify
		 * i_size.
		 */
800
		error = xfs_zero_eof(ip, newsize, oldsize);
C
Christoph Hellwig 已提交
801
		if (error)
802
			return error;
C
Christoph Hellwig 已提交
803 804 805 806 807 808 809 810 811 812 813 814 815 816
	}

	/*
	 * We are going to log the inode size change in this transaction so
	 * any previous writes that are beyond the on disk EOF and the new
	 * EOF that have not been written out need to be written here.  If we
	 * do not write the data out, we expose ourselves to the null files
	 * problem.
	 *
	 * Only flush from the on disk size to the smaller of the in memory
	 * file size or the new size as that's the range we really care about
	 * here and prevents waiting for other data not within the range we
	 * care about here.
	 */
817
	if (oldsize != ip->i_d.di_size && newsize > ip->i_d.di_size) {
D
Dave Chinner 已提交
818
		error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
D
Dave Chinner 已提交
819
						      ip->i_d.di_size, newsize);
C
Christoph Hellwig 已提交
820
		if (error)
821
			return error;
C
Christoph Hellwig 已提交
822 823 824
	}

	/*
C
Christoph Hellwig 已提交
825
	 * Wait for all direct I/O to complete.
C
Christoph Hellwig 已提交
826
	 */
C
Christoph Hellwig 已提交
827
	inode_dio_wait(inode);
C
Christoph Hellwig 已提交
828

829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
	/*
	 * Do all the page cache truncate work outside the transaction context
	 * as the "lock" order is page lock->log space reservation.  i.e.
	 * locking pages inside the transaction can ABBA deadlock with
	 * writeback. We have to do the VFS inode size update before we truncate
	 * the pagecache, however, to avoid racing with page faults beyond the
	 * new EOF they are not serialised against truncate operations except by
	 * page locks and size updates.
	 *
	 * Hence we are in a situation where a truncate can fail with ENOMEM
	 * from xfs_trans_reserve(), but having already truncated the in-memory
	 * version of the file (i.e. made user visible changes). There's not
	 * much we can do about this, except to hope that the caller sees ENOMEM
	 * and retries the truncate operation.
	 */
D
Dave Chinner 已提交
844
	error = block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
C
Christoph Hellwig 已提交
845
	if (error)
846
		return error;
847
	truncate_setsize(inode, newsize);
C
Christoph Hellwig 已提交
848

849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
	/*
	 * The "we can't serialise against page faults" pain gets worse.
	 *
	 * If the file is mapped then we have to clean the page at the old EOF
	 * when extending the file. Extending the file can expose changes the
	 * underlying page mapping (e.g. from beyond EOF to a hole or
	 * unwritten), and so on the next attempt to write to that page we need
	 * to remap it for write. i.e. we need .page_mkwrite() to be called.
	 * Hence we need to clean the page to clean the pte and so a new write
	 * fault will be triggered appropriately.
	 *
	 * If we do it before we change the inode size, then we can race with a
	 * page fault that maps the page with exactly the same problem. If we do
	 * it after we change the file size, then a new page fault can come in
	 * and allocate space before we've run the rest of the truncate
	 * transaction. That's kinda grotesque, but it's better than have data
	 * over a hole, and so that's the lesser evil that has been chosen here.
	 *
	 * The real solution, however, is to have some mechanism for locking out
	 * page faults while a truncate is in progress.
	 */
	if (newsize > oldsize && mapping_mapped(VFS_I(ip)->i_mapping)) {
		error = filemap_write_and_wait_range(
				VFS_I(ip)->i_mapping,
				round_down(oldsize, PAGE_CACHE_SIZE),
				round_up(oldsize, PAGE_CACHE_SIZE) - 1);
		if (error)
			return error;
	}

C
Christoph Hellwig 已提交
879
	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
880
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
C
Christoph Hellwig 已提交
881 882 883 884 885 886
	if (error)
		goto out_trans_cancel;

	commit_flags = XFS_TRANS_RELEASE_LOG_RES;
	lock_flags |= XFS_ILOCK_EXCL;
	xfs_ilock(ip, XFS_ILOCK_EXCL);
887
	xfs_trans_ijoin(tp, ip, 0);
C
Christoph Hellwig 已提交
888 889 890 891 892 893 894 895 896 897 898

	/*
	 * Only change the c/mtime if we are changing the size or we are
	 * explicitly asked to change it.  This handles the semantic difference
	 * between truncate() and ftruncate() as implemented in the VFS.
	 *
	 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
	 * special case where we need to update the times despite not having
	 * these flags set.  For all other operations the VFS set these flags
	 * explicitly if it wants a timestamp update.
	 */
899 900
	if (newsize != oldsize &&
	    !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
C
Christoph Hellwig 已提交
901 902
		iattr->ia_ctime = iattr->ia_mtime =
			current_fs_time(inode->i_sb);
903
		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
C
Christoph Hellwig 已提交
904 905
	}

906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
	/*
	 * The first thing we do is set the size to new_size permanently on
	 * disk.  This way we don't have to worry about anyone ever being able
	 * to look at the data being freed even in the face of a crash.
	 * What we're getting around here is the case where we free a block, it
	 * is allocated to another file, it is written to, and then we crash.
	 * If the new data gets written to the file but the log buffers
	 * containing the free and reallocation don't, then we'd end up with
	 * garbage in the blocks being freed.  As long as we make the new size
	 * permanent before actually freeing any blocks it doesn't matter if
	 * they get written to.
	 */
	ip->i_d.di_size = newsize;
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	if (newsize <= oldsize) {
		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
C
Christoph Hellwig 已提交
923 924 925 926 927 928 929 930 931 932 933
		if (error)
			goto out_trans_abort;

		/*
		 * Truncated "down", so we're removing references to old data
		 * here - if we delay flushing for a long time, we expose
		 * ourselves unduly to the notorious NULL files problem.  So,
		 * we mark this inode and flush it when the file is closed,
		 * and do not wait the usual (long) time for writeout.
		 */
		xfs_iflags_set(ip, XFS_ITRUNCATED);
934 935 936

		/* A truncate down always removes post-EOF blocks. */
		xfs_inode_clear_eofblocks_tag(ip);
C
Christoph Hellwig 已提交
937 938
	}

939
	if (iattr->ia_valid & ATTR_MODE)
940
		xfs_setattr_mode(ip, iattr);
941
	if (iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
C
Christoph Hellwig 已提交
942
		xfs_setattr_time(ip, iattr);
C
Christoph Hellwig 已提交
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963

	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	XFS_STATS_INC(xs_ig_attrchg);

	if (mp->m_flags & XFS_MOUNT_WSYNC)
		xfs_trans_set_sync(tp);

	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
out_unlock:
	if (lock_flags)
		xfs_iunlock(ip, lock_flags);
	return error;

out_trans_abort:
	commit_flags |= XFS_TRANS_ABORT;
out_trans_cancel:
	xfs_trans_cancel(tp, commit_flags);
	goto out_unlock;
}

L
Linus Torvalds 已提交
964
STATIC int
965
xfs_vn_setattr(
966 967
	struct dentry		*dentry,
	struct iattr		*iattr)
L
Linus Torvalds 已提交
968
{
969 970 971 972 973 974 975 976 977 978 979
	struct xfs_inode	*ip = XFS_I(dentry->d_inode);
	int			error;

	if (iattr->ia_valid & ATTR_SIZE) {
		xfs_ilock(ip, XFS_IOLOCK_EXCL);
		error = xfs_setattr_size(ip, iattr);
		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
	} else {
		error = xfs_setattr_nonsize(ip, iattr, 0);
	}

D
Dave Chinner 已提交
980
	return error;
L
Linus Torvalds 已提交
981 982
}

C
Christoph Hellwig 已提交
983 984 985 986 987 988 989 990 991 992 993 994 995 996
STATIC int
xfs_vn_update_time(
	struct inode		*inode,
	struct timespec		*now,
	int			flags)
{
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_trans	*tp;
	int			error;

	trace_xfs_update_time(ip);

	tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
997
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
C
Christoph Hellwig 已提交
998 999
	if (error) {
		xfs_trans_cancel(tp, 0);
D
Dave Chinner 已提交
1000
		return error;
C
Christoph Hellwig 已提交
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
	}

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	if (flags & S_CTIME) {
		inode->i_ctime = *now;
		ip->i_d.di_ctime.t_sec = (__int32_t)now->tv_sec;
		ip->i_d.di_ctime.t_nsec = (__int32_t)now->tv_nsec;
	}
	if (flags & S_MTIME) {
		inode->i_mtime = *now;
		ip->i_d.di_mtime.t_sec = (__int32_t)now->tv_sec;
		ip->i_d.di_mtime.t_nsec = (__int32_t)now->tv_nsec;
	}
	if (flags & S_ATIME) {
		inode->i_atime = *now;
		ip->i_d.di_atime.t_sec = (__int32_t)now->tv_sec;
		ip->i_d.di_atime.t_nsec = (__int32_t)now->tv_nsec;
	}
	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
	xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
D
Dave Chinner 已提交
1021
	return xfs_trans_commit(tp, 0);
C
Christoph Hellwig 已提交
1022 1023
}

E
Eric Sandeen 已提交
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
#define XFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)

/*
 * Call fiemap helper to fill in user data.
 * Returns positive errors to xfs_getbmap.
 */
STATIC int
xfs_fiemap_format(
	void			**arg,
	struct getbmapx		*bmv,
	int			*full)
{
	int			error;
	struct fiemap_extent_info *fieinfo = *arg;
	u32			fiemap_flags = 0;
	u64			logical, physical, length;

	/* Do nothing for a hole */
	if (bmv->bmv_block == -1LL)
		return 0;

	logical = BBTOB(bmv->bmv_offset);
	physical = BBTOB(bmv->bmv_block);
	length = BBTOB(bmv->bmv_length);

	if (bmv->bmv_oflags & BMV_OF_PREALLOC)
		fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;
	else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {
1052 1053
		fiemap_flags |= (FIEMAP_EXTENT_DELALLOC |
				 FIEMAP_EXTENT_UNKNOWN);
E
Eric Sandeen 已提交
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
		physical = 0;   /* no block yet */
	}
	if (bmv->bmv_oflags & BMV_OF_LAST)
		fiemap_flags |= FIEMAP_EXTENT_LAST;

	error = fiemap_fill_next_extent(fieinfo, logical, physical,
					length, fiemap_flags);
	if (error > 0) {
		error = 0;
		*full = 1;	/* user array now full */
	}

D
Dave Chinner 已提交
1066
	return error;
E
Eric Sandeen 已提交
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
}

STATIC int
xfs_vn_fiemap(
	struct inode		*inode,
	struct fiemap_extent_info *fieinfo,
	u64			start,
	u64			length)
{
	xfs_inode_t		*ip = XFS_I(inode);
	struct getbmapx		bm;
	int			error;

	error = fiemap_check_flags(fieinfo, XFS_FIEMAP_FLAGS);
	if (error)
		return error;

	/* Set up bmap header for xfs internal routine */
1085
	bm.bmv_offset = BTOBBT(start);
E
Eric Sandeen 已提交
1086 1087 1088 1089
	/* Special case for whole file */
	if (length == FIEMAP_MAX_OFFSET)
		bm.bmv_length = -1LL;
	else
1090
		bm.bmv_length = BTOBB(start + length) - bm.bmv_offset;
E
Eric Sandeen 已提交
1091

1092
	/* We add one because in getbmap world count includes the header */
T
Tao Ma 已提交
1093 1094 1095 1096
	bm.bmv_count = !fieinfo->fi_extents_max ? MAXEXTNUM :
					fieinfo->fi_extents_max + 1;
	bm.bmv_count = min_t(__s32, bm.bmv_count,
			     (PAGE_SIZE * 16 / sizeof(struct getbmapx)));
T
Tao Ma 已提交
1097
	bm.bmv_iflags = BMV_IF_PREALLOC | BMV_IF_NO_HOLES;
E
Eric Sandeen 已提交
1098 1099 1100 1101 1102 1103 1104
	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR)
		bm.bmv_iflags |= BMV_IF_ATTRFORK;
	if (!(fieinfo->fi_flags & FIEMAP_FLAG_SYNC))
		bm.bmv_iflags |= BMV_IF_DELALLOC;

	error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
	if (error)
D
Dave Chinner 已提交
1105
		return error;
E
Eric Sandeen 已提交
1106 1107 1108 1109

	return 0;
}

Z
Zhi Yong Wu 已提交
1110 1111 1112 1113 1114 1115
STATIC int
xfs_vn_tmpfile(
	struct inode	*dir,
	struct dentry	*dentry,
	umode_t		mode)
{
1116
	return xfs_generic_create(dir, dentry, mode, 0, true);
Z
Zhi Yong Wu 已提交
1117 1118
}

1119
static const struct inode_operations xfs_inode_operations = {
1120
	.get_acl		= xfs_get_acl,
1121
	.set_acl		= xfs_set_acl,
1122 1123
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
1124 1125 1126
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
1127
	.listxattr		= xfs_vn_listxattr,
E
Eric Sandeen 已提交
1128
	.fiemap			= xfs_vn_fiemap,
C
Christoph Hellwig 已提交
1129
	.update_time		= xfs_vn_update_time,
L
Linus Torvalds 已提交
1130 1131
};

1132
static const struct inode_operations xfs_dir_inode_operations = {
1133 1134 1135 1136 1137 1138
	.create			= xfs_vn_create,
	.lookup			= xfs_vn_lookup,
	.link			= xfs_vn_link,
	.unlink			= xfs_vn_unlink,
	.symlink		= xfs_vn_symlink,
	.mkdir			= xfs_vn_mkdir,
1139 1140 1141 1142 1143 1144 1145
	/*
	 * Yes, XFS uses the same method for rmdir and unlink.
	 *
	 * There are some subtile differences deeper in the code,
	 * but we use S_ISDIR to check for those.
	 */
	.rmdir			= xfs_vn_unlink,
1146 1147
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
1148
	.get_acl		= xfs_get_acl,
1149
	.set_acl		= xfs_set_acl,
1150 1151
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
1152 1153 1154
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
1155
	.listxattr		= xfs_vn_listxattr,
C
Christoph Hellwig 已提交
1156
	.update_time		= xfs_vn_update_time,
Z
Zhi Yong Wu 已提交
1157
	.tmpfile		= xfs_vn_tmpfile,
L
Linus Torvalds 已提交
1158 1159
};

1160
static const struct inode_operations xfs_dir_ci_inode_operations = {
1161 1162 1163 1164 1165 1166
	.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,
1167 1168 1169 1170 1171 1172 1173
	/*
	 * Yes, XFS uses the same method for rmdir and unlink.
	 *
	 * There are some subtile differences deeper in the code,
	 * but we use S_ISDIR to check for those.
	 */
	.rmdir			= xfs_vn_unlink,
1174 1175
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
1176
	.get_acl		= xfs_get_acl,
1177
	.set_acl		= xfs_set_acl,
1178 1179
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
1180 1181 1182
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
1183
	.listxattr		= xfs_vn_listxattr,
C
Christoph Hellwig 已提交
1184
	.update_time		= xfs_vn_update_time,
Z
Zhi Yong Wu 已提交
1185
	.tmpfile		= xfs_vn_tmpfile,
1186 1187
};

1188
static const struct inode_operations xfs_symlink_inode_operations = {
L
Linus Torvalds 已提交
1189
	.readlink		= generic_readlink,
1190
	.follow_link		= xfs_vn_follow_link,
A
Al Viro 已提交
1191
	.put_link		= kfree_put_link,
1192 1193
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
1194 1195 1196
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
1197
	.listxattr		= xfs_vn_listxattr,
C
Christoph Hellwig 已提交
1198
	.update_time		= xfs_vn_update_time,
L
Linus Torvalds 已提交
1199
};
1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230

STATIC void
xfs_diflags_to_iflags(
	struct inode		*inode,
	struct xfs_inode	*ip)
{
	if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
		inode->i_flags |= S_IMMUTABLE;
	else
		inode->i_flags &= ~S_IMMUTABLE;
	if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
		inode->i_flags |= S_APPEND;
	else
		inode->i_flags &= ~S_APPEND;
	if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
		inode->i_flags |= S_SYNC;
	else
		inode->i_flags &= ~S_SYNC;
	if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
		inode->i_flags |= S_NOATIME;
	else
		inode->i_flags &= ~S_NOATIME;
}

/*
 * Initialize the Linux inode, set up the operation vectors and
 * unlock the inode.
 *
 * When reading existing inodes from disk this is called directly
 * from xfs_iget, when creating a new inode it is called from
 * xfs_ialloc after setting up the inode.
1231 1232 1233 1234
 *
 * We are always called with an uninitialised linux inode here.
 * We need to initialise the necessary fields and take a reference
 * on it.
1235 1236 1237 1238 1239
 */
void
xfs_setup_inode(
	struct xfs_inode	*ip)
{
1240
	struct inode		*inode = &ip->i_vnode;
1241
	gfp_t			gfp_mask;
1242 1243

	inode->i_ino = ip->i_ino;
C
Christoph Hellwig 已提交
1244
	inode->i_state = I_NEW;
1245 1246

	inode_sb_list_add(inode);
C
Christoph Hellwig 已提交
1247 1248
	/* make the inode look hashed for the writeback code */
	hlist_add_fake(&inode->i_hash);
1249 1250

	inode->i_mode	= ip->i_d.di_mode;
M
Miklos Szeredi 已提交
1251
	set_nlink(inode, ip->i_d.di_nlink);
1252 1253
	inode->i_uid    = xfs_uid_to_kuid(ip->i_d.di_uid);
	inode->i_gid    = xfs_gid_to_kgid(ip->i_d.di_gid);
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276

	switch (inode->i_mode & S_IFMT) {
	case S_IFBLK:
	case S_IFCHR:
		inode->i_rdev =
			MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
			      sysv_minor(ip->i_df.if_u2.if_rdev));
		break;
	default:
		inode->i_rdev = 0;
		break;
	}

	inode->i_generation = ip->i_d.di_gen;
	i_size_write(inode, ip->i_d.di_size);
	inode->i_atime.tv_sec	= ip->i_d.di_atime.t_sec;
	inode->i_atime.tv_nsec	= ip->i_d.di_atime.t_nsec;
	inode->i_mtime.tv_sec	= ip->i_d.di_mtime.t_sec;
	inode->i_mtime.tv_nsec	= ip->i_d.di_mtime.t_nsec;
	inode->i_ctime.tv_sec	= ip->i_d.di_ctime.t_sec;
	inode->i_ctime.tv_nsec	= ip->i_d.di_ctime.t_nsec;
	xfs_diflags_to_iflags(inode, ip);

D
Dave Chinner 已提交
1277
	ip->d_ops = ip->i_mount->m_nondir_inode_ops;
1278
	lockdep_set_class(&ip->i_lock.mr_lock, &xfs_nondir_ilock_class);
1279 1280 1281 1282 1283 1284 1285
	switch (inode->i_mode & S_IFMT) {
	case S_IFREG:
		inode->i_op = &xfs_inode_operations;
		inode->i_fop = &xfs_file_operations;
		inode->i_mapping->a_ops = &xfs_address_space_operations;
		break;
	case S_IFDIR:
1286
		lockdep_set_class(&ip->i_lock.mr_lock, &xfs_dir_ilock_class);
1287 1288 1289 1290 1291
		if (xfs_sb_version_hasasciici(&XFS_M(inode->i_sb)->m_sb))
			inode->i_op = &xfs_dir_ci_inode_operations;
		else
			inode->i_op = &xfs_dir_inode_operations;
		inode->i_fop = &xfs_dir_file_operations;
1292
		ip->d_ops = ip->i_mount->m_dir_inode_ops;
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
		break;
	case S_IFLNK:
		inode->i_op = &xfs_symlink_inode_operations;
		if (!(ip->i_df.if_flags & XFS_IFINLINE))
			inode->i_mapping->a_ops = &xfs_address_space_operations;
		break;
	default:
		inode->i_op = &xfs_inode_operations;
		init_special_inode(inode, inode->i_mode, inode->i_rdev);
		break;
	}

1305 1306 1307 1308 1309 1310 1311 1312
	/*
	 * Ensure all page cache allocations are done from GFP_NOFS context to
	 * prevent direct reclaim recursion back into the filesystem and blowing
	 * stacks or deadlocking.
	 */
	gfp_mask = mapping_gfp_mask(inode->i_mapping);
	mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));

1313 1314 1315 1316 1317 1318
	/*
	 * If there is no attribute fork no ACL can exist on this inode,
	 * and it can't have any file capabilities attached to it either.
	 */
	if (!XFS_IFORK_Q(ip)) {
		inode_has_no_xattr(inode);
1319
		cache_no_acl(inode);
1320
	}
1321

1322 1323 1324 1325 1326
	xfs_iflags_clear(ip, XFS_INEW);
	barrier();

	unlock_new_inode(inode);
}