xfs_iops.c 18.6 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_acl.h"
21
#include "xfs_bit.h"
L
Linus Torvalds 已提交
22
#include "xfs_log.h"
23
#include "xfs_inum.h"
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#include "xfs_trans.h"
#include "xfs_sb.h"
#include "xfs_ag.h"
#include "xfs_alloc.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_itable.h"
#include "xfs_rw.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
41
#include "xfs_vnodeops.h"
C
Christoph Hellwig 已提交
42
#include "xfs_trace.h"
L
Linus Torvalds 已提交
43

44
#include <linux/capability.h>
L
Linus Torvalds 已提交
45 46
#include <linux/xattr.h>
#include <linux/namei.h>
47
#include <linux/posix_acl.h>
48
#include <linux/security.h>
D
David Chinner 已提交
49
#include <linux/falloc.h>
E
Eric Sandeen 已提交
50
#include <linux/fiemap.h>
51
#include <linux/slab.h>
L
Linus Torvalds 已提交
52

53
/*
54 55 56
 * Bring the timestamps in the XFS inode uptodate.
 *
 * Used before writing the inode to disk.
57 58
 */
void
59
xfs_synchronize_times(
60 61
	xfs_inode_t	*ip)
{
62
	struct inode	*inode = VFS_I(ip);
63

64 65 66 67 68 69
	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;
	ip->i_d.di_ctime.t_sec = (__int32_t)inode->i_ctime.tv_sec;
	ip->i_d.di_ctime.t_nsec = (__int32_t)inode->i_ctime.tv_nsec;
	ip->i_d.di_mtime.t_sec = (__int32_t)inode->i_mtime.tv_sec;
	ip->i_d.di_mtime.t_nsec = (__int32_t)inode->i_mtime.tv_nsec;
70 71
}

72
/*
73
 * If the linux inode is valid, mark it dirty.
74 75 76 77 78 79 80
 * 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)
{
81
	struct inode	*inode = VFS_I(ip);
82

A
Al Viro 已提交
83
	if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
84
		mark_inode_dirty_sync(inode);
85 86
}

87 88 89 90 91 92
void
xfs_mark_inode_dirty(
	xfs_inode_t	*ip)
{
	struct inode	*inode = VFS_I(ip);

A
Al Viro 已提交
93
	if (!(inode->i_state & (I_WILL_FREE|I_FREEING)))
94 95 96
		mark_inode_dirty(inode);
}

97 98 99 100 101 102 103
/*
 * 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
104
xfs_init_security(
105
	struct inode	*inode,
106 107
	struct inode	*dir)
{
108
	struct xfs_inode *ip = XFS_I(inode);
109 110
	size_t		length;
	void		*value;
111
	unsigned char	*name;
112 113
	int		error;

114
	error = security_inode_init_security(inode, dir, (char **)&name,
115
					     &value, &length);
116 117 118 119 120 121
	if (error) {
		if (error == -EOPNOTSUPP)
			return 0;
		return -error;
	}

122
	error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
123 124 125 126 127 128

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

129 130 131 132 133 134 135 136 137
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;
}

138
STATIC void
139
xfs_cleanup_inode(
140
	struct inode	*dir,
141
	struct inode	*inode,
142
	struct dentry	*dentry)
143
{
144
	struct xfs_name	teardown;
145 146

	/* Oh, the horror.
147
	 * If we can't add the ACL or we fail in
148
	 * xfs_init_security we must back out.
149 150
	 * ENOSPC can hit here, among other things.
	 */
151
	xfs_dentry_to_name(&teardown, dentry);
152

153
	xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
154
	iput(inode);
155 156
}

L
Linus Torvalds 已提交
157
STATIC int
158
xfs_vn_mknod(
L
Linus Torvalds 已提交
159 160 161 162 163
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	dev_t		rdev)
{
C
Christoph Hellwig 已提交
164
	struct inode	*inode;
165
	struct xfs_inode *ip = NULL;
166
	struct posix_acl *default_acl = NULL;
167
	struct xfs_name	name;
L
Linus Torvalds 已提交
168 169 170 171 172 173
	int		error;

	/*
	 * Irix uses Missed'em'V split, but doesn't want to see
	 * the upper 5 bits of (14bit) major.
	 */
174 175 176 177 178 179 180
	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 已提交
181

182 183 184 185
	if (IS_POSIXACL(dir)) {
		default_acl = xfs_get_acl(dir, ACL_TYPE_DEFAULT);
		if (IS_ERR(default_acl))
			return -PTR_ERR(default_acl);
L
Linus Torvalds 已提交
186

187 188
		if (!default_acl)
			mode &= ~current_umask();
189
	}
L
Linus Torvalds 已提交
190

191
	xfs_dentry_to_name(&name, dentry);
C
Christoph Hellwig 已提交
192
	error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
C
Christoph Hellwig 已提交
193 194
	if (unlikely(error))
		goto out_free_acl;
195

196
	inode = VFS_I(ip);
197 198

	error = xfs_init_security(inode, dir);
C
Christoph Hellwig 已提交
199 200 201 202
	if (unlikely(error))
		goto out_cleanup_inode;

	if (default_acl) {
203
		error = -xfs_inherit_acl(inode, default_acl);
C
Christoph Hellwig 已提交
204 205
		if (unlikely(error))
			goto out_cleanup_inode;
206
		posix_acl_release(default_acl);
L
Linus Torvalds 已提交
207 208 209
	}


C
Christoph Hellwig 已提交
210 211 212 213
	d_instantiate(dentry, inode);
	return -error;

 out_cleanup_inode:
214
	xfs_cleanup_inode(dir, inode, dentry);
C
Christoph Hellwig 已提交
215
 out_free_acl:
216
	posix_acl_release(default_acl);
L
Linus Torvalds 已提交
217 218 219 220
	return -error;
}

STATIC int
221
xfs_vn_create(
L
Linus Torvalds 已提交
222 223 224 225 226
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	struct nameidata *nd)
{
227
	return xfs_vn_mknod(dir, dentry, mode, 0);
L
Linus Torvalds 已提交
228 229 230
}

STATIC int
231
xfs_vn_mkdir(
L
Linus Torvalds 已提交
232 233 234 235
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode)
{
236
	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
L
Linus Torvalds 已提交
237 238 239
}

STATIC struct dentry *
240
xfs_vn_lookup(
L
Linus Torvalds 已提交
241 242 243 244
	struct inode	*dir,
	struct dentry	*dentry,
	struct nameidata *nd)
{
245
	struct xfs_inode *cip;
246
	struct xfs_name	name;
L
Linus Torvalds 已提交
247 248 249 250 251
	int		error;

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

252
	xfs_dentry_to_name(&name, dentry);
253
	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
254
	if (unlikely(error)) {
L
Linus Torvalds 已提交
255 256 257 258 259 260
		if (unlikely(error != ENOENT))
			return ERR_PTR(-error);
		d_add(dentry, NULL);
		return NULL;
	}

261
	return d_splice_alias(VFS_I(cip), dentry);
L
Linus Torvalds 已提交
262 263
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
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);
284 285 286 287 288
		/*
		 * call d_add(dentry, NULL) here when d_drop_negative_children
		 * is called in xfs_vn_mknod (ie. allow negative dentries
		 * with CI filesystems).
		 */
289 290 291 292 293
		return NULL;
	}

	/* if exact match, just splice and exit */
	if (!ci_name.name)
294
		return d_splice_alias(VFS_I(ip), dentry);
295 296 297 298

	/* else case-insensitive match... */
	dname.name = ci_name.name;
	dname.len = ci_name.len;
299
	dentry = d_add_ci(dentry, VFS_I(ip), &dname);
300 301 302 303
	kmem_free(ci_name.name);
	return dentry;
}

L
Linus Torvalds 已提交
304
STATIC int
305
xfs_vn_link(
L
Linus Torvalds 已提交
306 307 308 309
	struct dentry	*old_dentry,
	struct inode	*dir,
	struct dentry	*dentry)
{
310
	struct inode	*inode = old_dentry->d_inode;
311
	struct xfs_name	name;
L
Linus Torvalds 已提交
312 313
	int		error;

314
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
315

316
	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
317
	if (unlikely(error))
318 319
		return -error;

A
Al Viro 已提交
320
	ihold(inode);
321 322
	d_instantiate(dentry, inode);
	return 0;
L
Linus Torvalds 已提交
323 324 325
}

STATIC int
326
xfs_vn_unlink(
L
Linus Torvalds 已提交
327 328 329
	struct inode	*dir,
	struct dentry	*dentry)
{
330
	struct xfs_name	name;
L
Linus Torvalds 已提交
331 332
	int		error;

333
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
334

335 336 337 338 339 340 341 342 343 344 345 346
	error = -xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
	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 已提交
347 348 349
}

STATIC int
350
xfs_vn_symlink(
L
Linus Torvalds 已提交
351 352 353 354
	struct inode	*dir,
	struct dentry	*dentry,
	const char	*symname)
{
355 356
	struct inode	*inode;
	struct xfs_inode *cip = NULL;
357
	struct xfs_name	name;
L
Linus Torvalds 已提交
358
	int		error;
359
	mode_t		mode;
L
Linus Torvalds 已提交
360

361
	mode = S_IFLNK |
A
Al Viro 已提交
362
		(irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
363
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
364

C
Christoph Hellwig 已提交
365
	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
366 367 368
	if (unlikely(error))
		goto out;

369
	inode = VFS_I(cip);
370 371 372 373 374 375 376 377 378

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

	d_instantiate(dentry, inode);
	return 0;

 out_cleanup_inode:
379
	xfs_cleanup_inode(dir, inode, dentry);
380
 out:
L
Linus Torvalds 已提交
381 382 383 384
	return -error;
}

STATIC int
385
xfs_vn_rename(
L
Linus Torvalds 已提交
386 387 388 389 390 391
	struct inode	*odir,
	struct dentry	*odentry,
	struct inode	*ndir,
	struct dentry	*ndentry)
{
	struct inode	*new_inode = ndentry->d_inode;
392 393
	struct xfs_name	oname;
	struct xfs_name	nname;
L
Linus Torvalds 已提交
394

395 396 397
	xfs_dentry_to_name(&oname, odentry);
	xfs_dentry_to_name(&nname, ndentry);

398
	return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
399 400
			   XFS_I(ndir), &nname, new_inode ?
			   			XFS_I(new_inode) : NULL);
L
Linus Torvalds 已提交
401 402 403 404 405 406 407
}

/*
 * 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...
 */
408
STATIC void *
409
xfs_vn_follow_link(
L
Linus Torvalds 已提交
410 411 412 413
	struct dentry		*dentry,
	struct nameidata	*nd)
{
	char			*link;
414
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
415

416
	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
417 418
	if (!link)
		goto out_err;
L
Linus Torvalds 已提交
419

420
	error = -xfs_readlink(XFS_I(dentry->d_inode), link);
421 422
	if (unlikely(error))
		goto out_kfree;
L
Linus Torvalds 已提交
423 424

	nd_set_link(nd, link);
425
	return NULL;
426 427 428 429 430 431

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

434
STATIC void
435
xfs_vn_put_link(
436 437 438
	struct dentry	*dentry,
	struct nameidata *nd,
	void		*p)
L
Linus Torvalds 已提交
439
{
440 441
	char		*s = nd_get_link(nd);

L
Linus Torvalds 已提交
442 443 444 445 446
	if (!IS_ERR(s))
		kfree(s);
}

STATIC int
447
xfs_vn_getattr(
448 449 450
	struct vfsmount		*mnt,
	struct dentry		*dentry,
	struct kstat		*stat)
L
Linus Torvalds 已提交
451
{
452 453 454 455
	struct inode		*inode = dentry->d_inode;
	struct xfs_inode	*ip = XFS_I(inode);
	struct xfs_mount	*mp = ip->i_mount;

C
Christoph Hellwig 已提交
456
	trace_xfs_getattr(ip);
457 458 459 460 461 462 463 464 465 466 467 468

	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;
	stat->atime = inode->i_atime;
469 470
	stat->mtime = inode->i_mtime;
	stat->ctime = inode->i_ctime;
471 472 473 474 475 476 477 478 479 480 481 482
	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:
483
		if (XFS_IS_REALTIME_INODE(ip)) {
484 485 486 487 488 489 490 491 492 493 494
			/*
			 * 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;
495
	}
496 497

	return 0;
L
Linus Torvalds 已提交
498 499 500
}

STATIC int
501
xfs_vn_setattr(
L
Linus Torvalds 已提交
502
	struct dentry	*dentry,
503
	struct iattr	*iattr)
L
Linus Torvalds 已提交
504
{
C
Christoph Hellwig 已提交
505
	return -xfs_setattr(XFS_I(dentry->d_inode), iattr, 0);
L
Linus Torvalds 已提交
506 507
}

D
David Chinner 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
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);
530 531 532 533 534 535 536 537 538 539

	/* check the new inode size is valid before allocating */
	if (!(mode & FALLOC_FL_KEEP_SIZE) &&
	    offset + len > i_size_read(inode)) {
		new_size = offset + len;
		error = inode_newsize_ok(inode, new_size);
		if (error)
			goto out_unlock;
	}

540 541
	error = -xfs_change_file_space(ip, XFS_IOC_RESVSP, &bf,
				       0, XFS_ATTR_NOLOCK);
542 543
	if (error)
		goto out_unlock;
D
David Chinner 已提交
544 545 546

	/* Change file size if needed */
	if (new_size) {
547
		struct iattr iattr;
D
David Chinner 已提交
548

549 550
		iattr.ia_valid = ATTR_SIZE;
		iattr.ia_size = new_size;
551
		error = -xfs_setattr(ip, &iattr, XFS_ATTR_NOLOCK);
D
David Chinner 已提交
552 553
	}

554
out_unlock:
D
David Chinner 已提交
555 556 557 558
	xfs_iunlock(ip, XFS_IOLOCK_EXCL);
out_error:
	return error;
}
L
Linus Torvalds 已提交
559

E
Eric Sandeen 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
#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) {
		fiemap_flags |= FIEMAP_EXTENT_DELALLOC;
		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 */
	}

	return -error;
}

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 */
	bm.bmv_offset = BTOBB(start);
	/* Special case for whole file */
	if (length == FIEMAP_MAX_OFFSET)
		bm.bmv_length = -1LL;
	else
		bm.bmv_length = BTOBB(length);

627
	/* We add one because in getbmap world count includes the header */
T
Tao Ma 已提交
628 629 630 631
	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 已提交
632
	bm.bmv_iflags = BMV_IF_PREALLOC | BMV_IF_NO_HOLES;
E
Eric Sandeen 已提交
633 634 635 636 637 638 639 640 641 642 643 644
	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)
		return -error;

	return 0;
}

645
static const struct inode_operations xfs_inode_operations = {
646
	.check_acl		= xfs_check_acl,
647 648
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
649 650 651
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
652
	.listxattr		= xfs_vn_listxattr,
D
David Chinner 已提交
653
	.fallocate		= xfs_vn_fallocate,
E
Eric Sandeen 已提交
654
	.fiemap			= xfs_vn_fiemap,
L
Linus Torvalds 已提交
655 656
};

657
static const struct inode_operations xfs_dir_inode_operations = {
658 659 660 661 662 663
	.create			= xfs_vn_create,
	.lookup			= xfs_vn_lookup,
	.link			= xfs_vn_link,
	.unlink			= xfs_vn_unlink,
	.symlink		= xfs_vn_symlink,
	.mkdir			= xfs_vn_mkdir,
664 665 666 667 668 669 670
	/*
	 * 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,
671 672
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
673
	.check_acl		= xfs_check_acl,
674 675
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
676 677 678
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
679
	.listxattr		= xfs_vn_listxattr,
L
Linus Torvalds 已提交
680 681
};

682
static const struct inode_operations xfs_dir_ci_inode_operations = {
683 684 685 686 687 688
	.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,
689 690 691 692 693 694 695
	/*
	 * 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,
696 697
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
698
	.check_acl		= xfs_check_acl,
699 700
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
701 702 703
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
704 705 706
	.listxattr		= xfs_vn_listxattr,
};

707
static const struct inode_operations xfs_symlink_inode_operations = {
L
Linus Torvalds 已提交
708
	.readlink		= generic_readlink,
709 710
	.follow_link		= xfs_vn_follow_link,
	.put_link		= xfs_vn_put_link,
711
	.check_acl		= xfs_check_acl,
712 713
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
714 715 716
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
717
	.listxattr		= xfs_vn_listxattr,
L
Linus Torvalds 已提交
718
};
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749

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.
750 751 752 753
 *
 * We are always called with an uninitialised linux inode here.
 * We need to initialise the necessary fields and take a reference
 * on it.
754 755 756 757 758
 */
void
xfs_setup_inode(
	struct xfs_inode	*ip)
{
759 760 761
	struct inode		*inode = &ip->i_vnode;

	inode->i_ino = ip->i_ino;
C
Christoph Hellwig 已提交
762
	inode->i_state = I_NEW;
763 764

	inode_sb_list_add(inode);
C
Christoph Hellwig 已提交
765 766
	/* make the inode look hashed for the writeback code */
	hlist_add_fake(&inode->i_hash);
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823

	inode->i_mode	= ip->i_d.di_mode;
	inode->i_nlink	= ip->i_d.di_nlink;
	inode->i_uid	= ip->i_d.di_uid;
	inode->i_gid	= ip->i_d.di_gid;

	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);

	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:
		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;
		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;
	}

	xfs_iflags_clear(ip, XFS_INEW);
	barrier();

	unlock_new_inode(inode);
}