xfs_iops.c 20.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_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
#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"
33
#include "xfs_alloc_btree.h"
L
Linus Torvalds 已提交
34 35
#include "xfs_ialloc_btree.h"
#include "xfs_dir2_sf.h"
36
#include "xfs_attr_sf.h"
L
Linus Torvalds 已提交
37 38 39
#include "xfs_dinode.h"
#include "xfs_inode.h"
#include "xfs_bmap.h"
40 41
#include "xfs_btree.h"
#include "xfs_ialloc.h"
L
Linus Torvalds 已提交
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_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/posix_acl.h>
55
#include <linux/security.h>
D
David Chinner 已提交
56
#include <linux/falloc.h>
E
Eric Sandeen 已提交
57
#include <linux/fiemap.h>
L
Linus Torvalds 已提交
58

59 60 61 62 63 64 65 66
/*
 * 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)
{
67
	struct inode	*inode = VFS_I(ip);
68

69
	if (!(inode->i_state & I_CLEAR)) {
70 71
		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;
72 73 74
	}
}

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

86
	if (!(inode->i_state & (I_WILL_FREE|I_FREEING|I_CLEAR)))
87
		mark_inode_dirty_sync(inode);
88 89
}

90 91 92 93 94 95 96 97 98 99
/*
 * 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.
 */
void
xfs_ichgtime(
	xfs_inode_t	*ip,
	int		flags)
{
100
	struct inode	*inode = VFS_I(ip);
101
	timespec_t	tv;
C
Christoph Hellwig 已提交
102
	int		sync_it = 0;
103

C
Christoph Hellwig 已提交
104 105 106 107
	tv = current_fs_time(inode->i_sb);

	if ((flags & XFS_ICHGTIME_MOD) &&
	    !timespec_equal(&inode->i_mtime, &tv)) {
108 109 110
		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;
C
Christoph Hellwig 已提交
111
		sync_it = 1;
112
	}
C
Christoph Hellwig 已提交
113 114
	if ((flags & XFS_ICHGTIME_CHG) &&
	    !timespec_equal(&inode->i_ctime, &tv)) {
115 116 117
		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;
C
Christoph Hellwig 已提交
118
		sync_it = 1;
119 120 121 122 123 124 125 126 127 128 129
	}

	/*
	 * 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.
	 */
C
Christoph Hellwig 已提交
130 131 132
	if (sync_it) {
		SYNCHRONIZE();
		ip->i_update_core = 1;
133
		xfs_mark_inode_dirty_sync(ip);
C
Christoph Hellwig 已提交
134
	}
135 136
}

137 138 139 140 141 142 143
/*
 * 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
144
xfs_init_security(
145
	struct inode	*inode,
146 147
	struct inode	*dir)
{
148
	struct xfs_inode *ip = XFS_I(inode);
149 150 151 152 153
	size_t		length;
	void		*value;
	char		*name;
	int		error;

154 155
	error = security_inode_init_security(inode, dir, &name,
					     &value, &length);
156 157 158 159 160 161
	if (error) {
		if (error == -EOPNOTSUPP)
			return 0;
		return -error;
	}

162
	error = xfs_attr_set(ip, name, value, length, ATTR_SECURE);
163 164 165 166 167 168

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

169 170 171 172 173 174 175 176 177
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;
}

178
STATIC void
179
xfs_cleanup_inode(
180
	struct inode	*dir,
181
	struct inode	*inode,
182
	struct dentry	*dentry)
183
{
184
	struct xfs_name	teardown;
185 186

	/* Oh, the horror.
187
	 * If we can't add the ACL or we fail in
188
	 * xfs_init_security we must back out.
189 190
	 * ENOSPC can hit here, among other things.
	 */
191
	xfs_dentry_to_name(&teardown, dentry);
192

193
	xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
194
	iput(inode);
195 196
}

L
Linus Torvalds 已提交
197
STATIC int
198
xfs_vn_mknod(
L
Linus Torvalds 已提交
199 200 201 202 203
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	dev_t		rdev)
{
C
Christoph Hellwig 已提交
204
	struct inode	*inode;
205
	struct xfs_inode *ip = NULL;
206
	struct posix_acl *default_acl = NULL;
207
	struct xfs_name	name;
L
Linus Torvalds 已提交
208 209 210 211 212 213
	int		error;

	/*
	 * Irix uses Missed'em'V split, but doesn't want to see
	 * the upper 5 bits of (14bit) major.
	 */
214 215 216 217 218 219 220
	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 已提交
221

222 223 224 225
	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 已提交
226

227 228
		if (!default_acl)
			mode &= ~current_umask();
229
	}
L
Linus Torvalds 已提交
230

231 232
	xfs_dentry_to_name(&name, dentry);
	error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip, NULL);
C
Christoph Hellwig 已提交
233 234
	if (unlikely(error))
		goto out_free_acl;
235

236
	inode = VFS_I(ip);
237 238

	error = xfs_init_security(inode, dir);
C
Christoph Hellwig 已提交
239 240 241 242
	if (unlikely(error))
		goto out_cleanup_inode;

	if (default_acl) {
243
		error = -xfs_inherit_acl(inode, default_acl);
C
Christoph Hellwig 已提交
244 245
		if (unlikely(error))
			goto out_cleanup_inode;
246
		posix_acl_release(default_acl);
L
Linus Torvalds 已提交
247 248 249
	}


C
Christoph Hellwig 已提交
250 251 252 253
	d_instantiate(dentry, inode);
	return -error;

 out_cleanup_inode:
254
	xfs_cleanup_inode(dir, inode, dentry);
C
Christoph Hellwig 已提交
255
 out_free_acl:
256
	posix_acl_release(default_acl);
L
Linus Torvalds 已提交
257 258 259 260
	return -error;
}

STATIC int
261
xfs_vn_create(
L
Linus Torvalds 已提交
262 263 264 265 266
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode,
	struct nameidata *nd)
{
267
	return xfs_vn_mknod(dir, dentry, mode, 0);
L
Linus Torvalds 已提交
268 269 270
}

STATIC int
271
xfs_vn_mkdir(
L
Linus Torvalds 已提交
272 273 274 275
	struct inode	*dir,
	struct dentry	*dentry,
	int		mode)
{
276
	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
L
Linus Torvalds 已提交
277 278 279
}

STATIC struct dentry *
280
xfs_vn_lookup(
L
Linus Torvalds 已提交
281 282 283 284
	struct inode	*dir,
	struct dentry	*dentry,
	struct nameidata *nd)
{
285
	struct xfs_inode *cip;
286
	struct xfs_name	name;
L
Linus Torvalds 已提交
287 288 289 290 291
	int		error;

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

292
	xfs_dentry_to_name(&name, dentry);
293
	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
294
	if (unlikely(error)) {
L
Linus Torvalds 已提交
295 296 297 298 299 300
		if (unlikely(error != ENOENT))
			return ERR_PTR(-error);
		d_add(dentry, NULL);
		return NULL;
	}

301
	return d_splice_alias(VFS_I(cip), dentry);
L
Linus Torvalds 已提交
302 303
}

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
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);
324 325 326 327 328
		/*
		 * call d_add(dentry, NULL) here when d_drop_negative_children
		 * is called in xfs_vn_mknod (ie. allow negative dentries
		 * with CI filesystems).
		 */
329 330 331 332 333
		return NULL;
	}

	/* if exact match, just splice and exit */
	if (!ci_name.name)
334
		return d_splice_alias(VFS_I(ip), dentry);
335 336 337 338

	/* else case-insensitive match... */
	dname.name = ci_name.name;
	dname.len = ci_name.len;
339
	dentry = d_add_ci(dentry, VFS_I(ip), &dname);
340 341 342 343
	kmem_free(ci_name.name);
	return dentry;
}

L
Linus Torvalds 已提交
344
STATIC int
345
xfs_vn_link(
L
Linus Torvalds 已提交
346 347 348 349
	struct dentry	*old_dentry,
	struct inode	*dir,
	struct dentry	*dentry)
{
350
	struct inode	*inode = old_dentry->d_inode;
351
	struct xfs_name	name;
L
Linus Torvalds 已提交
352 353
	int		error;

354
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
355

356
	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
357
	if (unlikely(error))
358 359
		return -error;

360
	atomic_inc(&inode->i_count);
361 362
	d_instantiate(dentry, inode);
	return 0;
L
Linus Torvalds 已提交
363 364 365
}

STATIC int
366
xfs_vn_unlink(
L
Linus Torvalds 已提交
367 368 369
	struct inode	*dir,
	struct dentry	*dentry)
{
370
	struct xfs_name	name;
L
Linus Torvalds 已提交
371 372
	int		error;

373
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
374

375 376 377 378 379 380 381 382 383 384 385 386
	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 已提交
387 388 389
}

STATIC int
390
xfs_vn_symlink(
L
Linus Torvalds 已提交
391 392 393 394
	struct inode	*dir,
	struct dentry	*dentry,
	const char	*symname)
{
395 396
	struct inode	*inode;
	struct xfs_inode *cip = NULL;
397
	struct xfs_name	name;
L
Linus Torvalds 已提交
398
	int		error;
399
	mode_t		mode;
L
Linus Torvalds 已提交
400

401
	mode = S_IFLNK |
A
Al Viro 已提交
402
		(irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
403
	xfs_dentry_to_name(&name, dentry);
L
Linus Torvalds 已提交
404

405
	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip, NULL);
406 407 408
	if (unlikely(error))
		goto out;

409
	inode = VFS_I(cip);
410 411 412 413 414 415 416 417 418

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

	d_instantiate(dentry, inode);
	return 0;

 out_cleanup_inode:
419
	xfs_cleanup_inode(dir, inode, dentry);
420
 out:
L
Linus Torvalds 已提交
421 422 423 424
	return -error;
}

STATIC int
425
xfs_vn_rename(
L
Linus Torvalds 已提交
426 427 428 429 430 431
	struct inode	*odir,
	struct dentry	*odentry,
	struct inode	*ndir,
	struct dentry	*ndentry)
{
	struct inode	*new_inode = ndentry->d_inode;
432 433
	struct xfs_name	oname;
	struct xfs_name	nname;
L
Linus Torvalds 已提交
434

435 436 437
	xfs_dentry_to_name(&oname, odentry);
	xfs_dentry_to_name(&nname, ndentry);

438
	return -xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
439 440
			   XFS_I(ndir), &nname, new_inode ?
			   			XFS_I(new_inode) : NULL);
L
Linus Torvalds 已提交
441 442 443 444 445 446 447
}

/*
 * 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...
 */
448
STATIC void *
449
xfs_vn_follow_link(
L
Linus Torvalds 已提交
450 451 452 453
	struct dentry		*dentry,
	struct nameidata	*nd)
{
	char			*link;
454
	int			error = -ENOMEM;
L
Linus Torvalds 已提交
455

456
	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
457 458
	if (!link)
		goto out_err;
L
Linus Torvalds 已提交
459

460
	error = -xfs_readlink(XFS_I(dentry->d_inode), link);
461 462
	if (unlikely(error))
		goto out_kfree;
L
Linus Torvalds 已提交
463 464

	nd_set_link(nd, link);
465
	return NULL;
466 467 468 469 470 471

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

474
STATIC void
475
xfs_vn_put_link(
476 477 478
	struct dentry	*dentry,
	struct nameidata *nd,
	void		*p)
L
Linus Torvalds 已提交
479
{
480 481
	char		*s = nd_get_link(nd);

L
Linus Torvalds 已提交
482 483 484 485 486
	if (!IS_ERR(s))
		kfree(s);
}

STATIC int
487
xfs_vn_permission(
C
Christoph Hellwig 已提交
488
	struct inode		*inode,
489
	int			mask)
L
Linus Torvalds 已提交
490
{
C
Christoph Hellwig 已提交
491
	return generic_permission(inode, mask, xfs_check_acl);
L
Linus Torvalds 已提交
492 493 494
}

STATIC int
495
xfs_vn_getattr(
496 497 498
	struct vfsmount		*mnt,
	struct dentry		*dentry,
	struct kstat		*stat)
L
Linus Torvalds 已提交
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 525 526 527 528 529 530 531 532
	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;
	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:
533
		if (XFS_IS_REALTIME_INODE(ip)) {
534 535 536 537 538 539 540 541 542 543 544
			/*
			 * 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;
545
	}
546 547

	return 0;
L
Linus Torvalds 已提交
548 549 550
}

STATIC int
551
xfs_vn_setattr(
L
Linus Torvalds 已提交
552
	struct dentry	*dentry,
553
	struct iattr	*iattr)
L
Linus Torvalds 已提交
554
{
C
Christoph Hellwig 已提交
555
	return -xfs_setattr(XFS_I(dentry->d_inode), iattr, 0);
L
Linus Torvalds 已提交
556 557
}

558 559 560 561 562
/*
 * 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 已提交
563
STATIC void
564
xfs_vn_truncate(
L
Linus Torvalds 已提交
565 566
	struct inode	*inode)
{
567 568 569 570
	int	error;
	error = block_truncate_page(inode->i_mapping, inode->i_size,
							xfs_get_blocks);
	WARN_ON(error);
L
Linus Torvalds 已提交
571 572
}

D
David Chinner 已提交
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
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,
C
Christoph Hellwig 已提交
596
				      0, XFS_ATTR_NOLOCK);
D
David Chinner 已提交
597 598 599 600 601 602
	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) {
603
		struct iattr iattr;
D
David Chinner 已提交
604

605 606
		iattr.ia_valid = ATTR_SIZE;
		iattr.ia_size = new_size;
C
Christoph Hellwig 已提交
607
		error = xfs_setattr(ip, &iattr, XFS_ATTR_NOLOCK);
D
David Chinner 已提交
608 609 610 611 612 613
	}

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

E
Eric Sandeen 已提交
615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
#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);

682 683
	/* We add one because in getbmap world count includes the header */
	bm.bmv_count = fieinfo->fi_extents_max + 1;
E
Eric Sandeen 已提交
684 685 686 687 688 689 690 691 692 693 694 695 696
	bm.bmv_iflags = BMV_IF_PREALLOC;
	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;
}

697
static const struct inode_operations xfs_inode_operations = {
698 699 700 701
	.permission		= xfs_vn_permission,
	.truncate		= xfs_vn_truncate,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
702 703 704
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
705
	.listxattr		= xfs_vn_listxattr,
D
David Chinner 已提交
706
	.fallocate		= xfs_vn_fallocate,
E
Eric Sandeen 已提交
707
	.fiemap			= xfs_vn_fiemap,
L
Linus Torvalds 已提交
708 709
};

710
static const struct inode_operations xfs_dir_inode_operations = {
711 712 713 714 715 716
	.create			= xfs_vn_create,
	.lookup			= xfs_vn_lookup,
	.link			= xfs_vn_link,
	.unlink			= xfs_vn_unlink,
	.symlink		= xfs_vn_symlink,
	.mkdir			= xfs_vn_mkdir,
717 718 719 720 721 722 723
	/*
	 * 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,
724 725 726 727 728
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
729 730 731
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
732
	.listxattr		= xfs_vn_listxattr,
L
Linus Torvalds 已提交
733 734
};

735
static const struct inode_operations xfs_dir_ci_inode_operations = {
736 737 738 739 740 741
	.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,
742 743 744 745 746 747 748
	/*
	 * 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,
749 750 751 752 753
	.mknod			= xfs_vn_mknod,
	.rename			= xfs_vn_rename,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
754 755 756
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
757 758 759
	.listxattr		= xfs_vn_listxattr,
};

760
static const struct inode_operations xfs_symlink_inode_operations = {
L
Linus Torvalds 已提交
761
	.readlink		= generic_readlink,
762 763 764 765 766
	.follow_link		= xfs_vn_follow_link,
	.put_link		= xfs_vn_put_link,
	.permission		= xfs_vn_permission,
	.getattr		= xfs_vn_getattr,
	.setattr		= xfs_vn_setattr,
767 768 769
	.setxattr		= generic_setxattr,
	.getxattr		= generic_getxattr,
	.removexattr		= generic_removexattr,
770
	.listxattr		= xfs_vn_listxattr,
L
Linus Torvalds 已提交
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

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.
803 804 805 806
 *
 * We are always called with an uninitialised linux inode here.
 * We need to initialise the necessary fields and take a reference
 * on it.
807 808 809 810 811
 */
void
xfs_setup_inode(
	struct xfs_inode	*ip)
{
812 813 814 815 816
	struct inode		*inode = &ip->i_vnode;

	inode->i_ino = ip->i_ino;
	inode->i_state = I_NEW|I_LOCK;
	inode_add_to_lists(ip->i_mount->m_super, inode);
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 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

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