xref: /openbmc/linux/fs/xfs/xfs_iops.c (revision c819e2cf)
1 /*
2  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it would be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write the Free Software Foundation,
16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17  */
18 #include "xfs.h"
19 #include "xfs_fs.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_da_format.h"
26 #include "xfs_inode.h"
27 #include "xfs_bmap.h"
28 #include "xfs_bmap_util.h"
29 #include "xfs_acl.h"
30 #include "xfs_quota.h"
31 #include "xfs_error.h"
32 #include "xfs_attr.h"
33 #include "xfs_trans.h"
34 #include "xfs_trace.h"
35 #include "xfs_icache.h"
36 #include "xfs_symlink.h"
37 #include "xfs_da_btree.h"
38 #include "xfs_dir2.h"
39 #include "xfs_trans_space.h"
40 
41 #include <linux/capability.h>
42 #include <linux/xattr.h>
43 #include <linux/namei.h>
44 #include <linux/posix_acl.h>
45 #include <linux/security.h>
46 #include <linux/fiemap.h>
47 #include <linux/slab.h>
48 
49 /*
50  * Directories have different lock order w.r.t. mmap_sem compared to regular
51  * files. This is due to readdir potentially triggering page faults on a user
52  * buffer inside filldir(), and this happens with the ilock on the directory
53  * held. For regular files, the lock order is the other way around - the
54  * mmap_sem is taken during the page fault, and then we lock the ilock to do
55  * block mapping. Hence we need a different class for the directory ilock so
56  * that lockdep can tell them apart.
57  */
58 static struct lock_class_key xfs_nondir_ilock_class;
59 static struct lock_class_key xfs_dir_ilock_class;
60 
61 static int
62 xfs_initxattrs(
63 	struct inode		*inode,
64 	const struct xattr	*xattr_array,
65 	void			*fs_info)
66 {
67 	const struct xattr	*xattr;
68 	struct xfs_inode	*ip = XFS_I(inode);
69 	int			error = 0;
70 
71 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
72 		error = xfs_attr_set(ip, xattr->name, xattr->value,
73 				      xattr->value_len, ATTR_SECURE);
74 		if (error < 0)
75 			break;
76 	}
77 	return error;
78 }
79 
80 /*
81  * Hook in SELinux.  This is not quite correct yet, what we really need
82  * here (as we do for default ACLs) is a mechanism by which creation of
83  * these attrs can be journalled at inode creation time (along with the
84  * inode, of course, such that log replay can't cause these to be lost).
85  */
86 
87 STATIC int
88 xfs_init_security(
89 	struct inode	*inode,
90 	struct inode	*dir,
91 	const struct qstr *qstr)
92 {
93 	return security_inode_init_security(inode, dir, qstr,
94 					     &xfs_initxattrs, NULL);
95 }
96 
97 static void
98 xfs_dentry_to_name(
99 	struct xfs_name	*namep,
100 	struct dentry	*dentry,
101 	int		mode)
102 {
103 	namep->name = dentry->d_name.name;
104 	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 	 * ENOSPC can hit here, among other things.
120 	 */
121 	xfs_dentry_to_name(&teardown, dentry, 0);
122 
123 	xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
124 }
125 
126 STATIC int
127 xfs_generic_create(
128 	struct inode	*dir,
129 	struct dentry	*dentry,
130 	umode_t		mode,
131 	dev_t		rdev,
132 	bool		tmpfile)	/* unnamed file */
133 {
134 	struct inode	*inode;
135 	struct xfs_inode *ip = NULL;
136 	struct posix_acl *default_acl, *acl;
137 	struct xfs_name	name;
138 	int		error;
139 
140 	/*
141 	 * Irix uses Missed'em'V split, but doesn't want to see
142 	 * the upper 5 bits of (14bit) major.
143 	 */
144 	if (S_ISCHR(mode) || S_ISBLK(mode)) {
145 		if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
146 			return -EINVAL;
147 		rdev = sysv_encode_dev(rdev);
148 	} else {
149 		rdev = 0;
150 	}
151 
152 	error = posix_acl_create(dir, &mode, &default_acl, &acl);
153 	if (error)
154 		return error;
155 
156 	if (!tmpfile) {
157 		xfs_dentry_to_name(&name, dentry, mode);
158 		error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
159 	} else {
160 		error = xfs_create_tmpfile(XFS_I(dir), dentry, mode, &ip);
161 	}
162 	if (unlikely(error))
163 		goto out_free_acl;
164 
165 	inode = VFS_I(ip);
166 
167 	error = xfs_init_security(inode, dir, &dentry->d_name);
168 	if (unlikely(error))
169 		goto out_cleanup_inode;
170 
171 #ifdef CONFIG_XFS_POSIX_ACL
172 	if (default_acl) {
173 		error = xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
174 		if (error)
175 			goto out_cleanup_inode;
176 	}
177 	if (acl) {
178 		error = xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
179 		if (error)
180 			goto out_cleanup_inode;
181 	}
182 #endif
183 
184 	if (tmpfile)
185 		d_tmpfile(dentry, inode);
186 	else
187 		d_instantiate(dentry, inode);
188 
189  out_free_acl:
190 	if (default_acl)
191 		posix_acl_release(default_acl);
192 	if (acl)
193 		posix_acl_release(acl);
194 	return error;
195 
196  out_cleanup_inode:
197 	if (!tmpfile)
198 		xfs_cleanup_inode(dir, inode, dentry);
199 	iput(inode);
200 	goto out_free_acl;
201 }
202 
203 STATIC int
204 xfs_vn_mknod(
205 	struct inode	*dir,
206 	struct dentry	*dentry,
207 	umode_t		mode,
208 	dev_t		rdev)
209 {
210 	return xfs_generic_create(dir, dentry, mode, rdev, false);
211 }
212 
213 STATIC int
214 xfs_vn_create(
215 	struct inode	*dir,
216 	struct dentry	*dentry,
217 	umode_t		mode,
218 	bool		flags)
219 {
220 	return xfs_vn_mknod(dir, dentry, mode, 0);
221 }
222 
223 STATIC int
224 xfs_vn_mkdir(
225 	struct inode	*dir,
226 	struct dentry	*dentry,
227 	umode_t		mode)
228 {
229 	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
230 }
231 
232 STATIC struct dentry *
233 xfs_vn_lookup(
234 	struct inode	*dir,
235 	struct dentry	*dentry,
236 	unsigned int flags)
237 {
238 	struct xfs_inode *cip;
239 	struct xfs_name	name;
240 	int		error;
241 
242 	if (dentry->d_name.len >= MAXNAMELEN)
243 		return ERR_PTR(-ENAMETOOLONG);
244 
245 	xfs_dentry_to_name(&name, dentry, 0);
246 	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
247 	if (unlikely(error)) {
248 		if (unlikely(error != -ENOENT))
249 			return ERR_PTR(error);
250 		d_add(dentry, NULL);
251 		return NULL;
252 	}
253 
254 	return d_splice_alias(VFS_I(cip), dentry);
255 }
256 
257 STATIC struct dentry *
258 xfs_vn_ci_lookup(
259 	struct inode	*dir,
260 	struct dentry	*dentry,
261 	unsigned int flags)
262 {
263 	struct xfs_inode *ip;
264 	struct xfs_name	xname;
265 	struct xfs_name ci_name;
266 	struct qstr	dname;
267 	int		error;
268 
269 	if (dentry->d_name.len >= MAXNAMELEN)
270 		return ERR_PTR(-ENAMETOOLONG);
271 
272 	xfs_dentry_to_name(&xname, dentry, 0);
273 	error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
274 	if (unlikely(error)) {
275 		if (unlikely(error != -ENOENT))
276 			return ERR_PTR(error);
277 		/*
278 		 * call d_add(dentry, NULL) here when d_drop_negative_children
279 		 * is called in xfs_vn_mknod (ie. allow negative dentries
280 		 * with CI filesystems).
281 		 */
282 		return NULL;
283 	}
284 
285 	/* if exact match, just splice and exit */
286 	if (!ci_name.name)
287 		return d_splice_alias(VFS_I(ip), dentry);
288 
289 	/* else case-insensitive match... */
290 	dname.name = ci_name.name;
291 	dname.len = ci_name.len;
292 	dentry = d_add_ci(dentry, VFS_I(ip), &dname);
293 	kmem_free(ci_name.name);
294 	return dentry;
295 }
296 
297 STATIC int
298 xfs_vn_link(
299 	struct dentry	*old_dentry,
300 	struct inode	*dir,
301 	struct dentry	*dentry)
302 {
303 	struct inode	*inode = old_dentry->d_inode;
304 	struct xfs_name	name;
305 	int		error;
306 
307 	xfs_dentry_to_name(&name, dentry, inode->i_mode);
308 
309 	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
310 	if (unlikely(error))
311 		return error;
312 
313 	ihold(inode);
314 	d_instantiate(dentry, inode);
315 	return 0;
316 }
317 
318 STATIC int
319 xfs_vn_unlink(
320 	struct inode	*dir,
321 	struct dentry	*dentry)
322 {
323 	struct xfs_name	name;
324 	int		error;
325 
326 	xfs_dentry_to_name(&name, dentry, 0);
327 
328 	error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode));
329 	if (error)
330 		return error;
331 
332 	/*
333 	 * With unlink, the VFS makes the dentry "negative": no inode,
334 	 * but still hashed. This is incompatible with case-insensitive
335 	 * mode, so invalidate (unhash) the dentry in CI-mode.
336 	 */
337 	if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
338 		d_invalidate(dentry);
339 	return 0;
340 }
341 
342 STATIC int
343 xfs_vn_symlink(
344 	struct inode	*dir,
345 	struct dentry	*dentry,
346 	const char	*symname)
347 {
348 	struct inode	*inode;
349 	struct xfs_inode *cip = NULL;
350 	struct xfs_name	name;
351 	int		error;
352 	umode_t		mode;
353 
354 	mode = S_IFLNK |
355 		(irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
356 	xfs_dentry_to_name(&name, dentry, mode);
357 
358 	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
359 	if (unlikely(error))
360 		goto out;
361 
362 	inode = VFS_I(cip);
363 
364 	error = xfs_init_security(inode, dir, &dentry->d_name);
365 	if (unlikely(error))
366 		goto out_cleanup_inode;
367 
368 	d_instantiate(dentry, inode);
369 	return 0;
370 
371  out_cleanup_inode:
372 	xfs_cleanup_inode(dir, inode, dentry);
373 	iput(inode);
374  out:
375 	return error;
376 }
377 
378 STATIC int
379 xfs_vn_rename(
380 	struct inode	*odir,
381 	struct dentry	*odentry,
382 	struct inode	*ndir,
383 	struct dentry	*ndentry)
384 {
385 	struct inode	*new_inode = ndentry->d_inode;
386 	struct xfs_name	oname;
387 	struct xfs_name	nname;
388 
389 	xfs_dentry_to_name(&oname, odentry, 0);
390 	xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode);
391 
392 	return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode),
393 			  XFS_I(ndir), &nname, new_inode ?
394 						XFS_I(new_inode) : NULL);
395 }
396 
397 /*
398  * careful here - this function can get called recursively, so
399  * we need to be very careful about how much stack we use.
400  * uio is kmalloced for this reason...
401  */
402 STATIC void *
403 xfs_vn_follow_link(
404 	struct dentry		*dentry,
405 	struct nameidata	*nd)
406 {
407 	char			*link;
408 	int			error = -ENOMEM;
409 
410 	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);
411 	if (!link)
412 		goto out_err;
413 
414 	error = xfs_readlink(XFS_I(dentry->d_inode), link);
415 	if (unlikely(error))
416 		goto out_kfree;
417 
418 	nd_set_link(nd, link);
419 	return NULL;
420 
421  out_kfree:
422 	kfree(link);
423  out_err:
424 	nd_set_link(nd, ERR_PTR(error));
425 	return NULL;
426 }
427 
428 STATIC int
429 xfs_vn_getattr(
430 	struct vfsmount		*mnt,
431 	struct dentry		*dentry,
432 	struct kstat		*stat)
433 {
434 	struct inode		*inode = dentry->d_inode;
435 	struct xfs_inode	*ip = XFS_I(inode);
436 	struct xfs_mount	*mp = ip->i_mount;
437 
438 	trace_xfs_getattr(ip);
439 
440 	if (XFS_FORCED_SHUTDOWN(mp))
441 		return -EIO;
442 
443 	stat->size = XFS_ISIZE(ip);
444 	stat->dev = inode->i_sb->s_dev;
445 	stat->mode = ip->i_d.di_mode;
446 	stat->nlink = ip->i_d.di_nlink;
447 	stat->uid = inode->i_uid;
448 	stat->gid = inode->i_gid;
449 	stat->ino = ip->i_ino;
450 	stat->atime = inode->i_atime;
451 	stat->mtime = inode->i_mtime;
452 	stat->ctime = inode->i_ctime;
453 	stat->blocks =
454 		XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
455 
456 
457 	switch (inode->i_mode & S_IFMT) {
458 	case S_IFBLK:
459 	case S_IFCHR:
460 		stat->blksize = BLKDEV_IOSIZE;
461 		stat->rdev = MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
462 				   sysv_minor(ip->i_df.if_u2.if_rdev));
463 		break;
464 	default:
465 		if (XFS_IS_REALTIME_INODE(ip)) {
466 			/*
467 			 * If the file blocks are being allocated from a
468 			 * realtime volume, then return the inode's realtime
469 			 * extent size or the realtime volume's extent size.
470 			 */
471 			stat->blksize =
472 				xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
473 		} else
474 			stat->blksize = xfs_preferred_iosize(mp);
475 		stat->rdev = 0;
476 		break;
477 	}
478 
479 	return 0;
480 }
481 
482 static void
483 xfs_setattr_mode(
484 	struct xfs_inode	*ip,
485 	struct iattr		*iattr)
486 {
487 	struct inode		*inode = VFS_I(ip);
488 	umode_t			mode = iattr->ia_mode;
489 
490 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
491 
492 	ip->i_d.di_mode &= S_IFMT;
493 	ip->i_d.di_mode |= mode & ~S_IFMT;
494 
495 	inode->i_mode &= S_IFMT;
496 	inode->i_mode |= mode & ~S_IFMT;
497 }
498 
499 static void
500 xfs_setattr_time(
501 	struct xfs_inode	*ip,
502 	struct iattr		*iattr)
503 {
504 	struct inode		*inode = VFS_I(ip);
505 
506 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
507 
508 	if (iattr->ia_valid & ATTR_ATIME) {
509 		inode->i_atime = iattr->ia_atime;
510 		ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
511 		ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
512 	}
513 	if (iattr->ia_valid & ATTR_CTIME) {
514 		inode->i_ctime = iattr->ia_ctime;
515 		ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
516 		ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
517 	}
518 	if (iattr->ia_valid & ATTR_MTIME) {
519 		inode->i_mtime = iattr->ia_mtime;
520 		ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
521 		ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
522 	}
523 }
524 
525 int
526 xfs_setattr_nonsize(
527 	struct xfs_inode	*ip,
528 	struct iattr		*iattr,
529 	int			flags)
530 {
531 	xfs_mount_t		*mp = ip->i_mount;
532 	struct inode		*inode = VFS_I(ip);
533 	int			mask = iattr->ia_valid;
534 	xfs_trans_t		*tp;
535 	int			error;
536 	kuid_t			uid = GLOBAL_ROOT_UID, iuid = GLOBAL_ROOT_UID;
537 	kgid_t			gid = GLOBAL_ROOT_GID, igid = GLOBAL_ROOT_GID;
538 	struct xfs_dquot	*udqp = NULL, *gdqp = NULL;
539 	struct xfs_dquot	*olddquot1 = NULL, *olddquot2 = NULL;
540 
541 	trace_xfs_setattr(ip);
542 
543 	/* If acls are being inherited, we already have this checked */
544 	if (!(flags & XFS_ATTR_NOACL)) {
545 		if (mp->m_flags & XFS_MOUNT_RDONLY)
546 			return -EROFS;
547 
548 		if (XFS_FORCED_SHUTDOWN(mp))
549 			return -EIO;
550 
551 		error = inode_change_ok(inode, iattr);
552 		if (error)
553 			return error;
554 	}
555 
556 	ASSERT((mask & ATTR_SIZE) == 0);
557 
558 	/*
559 	 * If disk quotas is on, we make sure that the dquots do exist on disk,
560 	 * before we start any other transactions. Trying to do this later
561 	 * is messy. We don't care to take a readlock to look at the ids
562 	 * in inode here, because we can't hold it across the trans_reserve.
563 	 * If the IDs do change before we take the ilock, we're covered
564 	 * because the i_*dquot fields will get updated anyway.
565 	 */
566 	if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
567 		uint	qflags = 0;
568 
569 		if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
570 			uid = iattr->ia_uid;
571 			qflags |= XFS_QMOPT_UQUOTA;
572 		} else {
573 			uid = inode->i_uid;
574 		}
575 		if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
576 			gid = iattr->ia_gid;
577 			qflags |= XFS_QMOPT_GQUOTA;
578 		}  else {
579 			gid = inode->i_gid;
580 		}
581 
582 		/*
583 		 * We take a reference when we initialize udqp and gdqp,
584 		 * so it is important that we never blindly double trip on
585 		 * the same variable. See xfs_create() for an example.
586 		 */
587 		ASSERT(udqp == NULL);
588 		ASSERT(gdqp == NULL);
589 		error = xfs_qm_vop_dqalloc(ip, xfs_kuid_to_uid(uid),
590 					   xfs_kgid_to_gid(gid),
591 					   xfs_get_projid(ip),
592 					   qflags, &udqp, &gdqp, NULL);
593 		if (error)
594 			return error;
595 	}
596 
597 	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
598 	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);
599 	if (error)
600 		goto out_dqrele;
601 
602 	xfs_ilock(ip, XFS_ILOCK_EXCL);
603 
604 	/*
605 	 * Change file ownership.  Must be the owner or privileged.
606 	 */
607 	if (mask & (ATTR_UID|ATTR_GID)) {
608 		/*
609 		 * These IDs could have changed since we last looked at them.
610 		 * But, we're assured that if the ownership did change
611 		 * while we didn't have the inode locked, inode's dquot(s)
612 		 * would have changed also.
613 		 */
614 		iuid = inode->i_uid;
615 		igid = inode->i_gid;
616 		gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
617 		uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;
618 
619 		/*
620 		 * Do a quota reservation only if uid/gid is actually
621 		 * going to change.
622 		 */
623 		if (XFS_IS_QUOTA_RUNNING(mp) &&
624 		    ((XFS_IS_UQUOTA_ON(mp) && !uid_eq(iuid, uid)) ||
625 		     (XFS_IS_GQUOTA_ON(mp) && !gid_eq(igid, gid)))) {
626 			ASSERT(tp);
627 			error = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,
628 						NULL, capable(CAP_FOWNER) ?
629 						XFS_QMOPT_FORCE_RES : 0);
630 			if (error)	/* out of quota */
631 				goto out_trans_cancel;
632 		}
633 	}
634 
635 	xfs_trans_ijoin(tp, ip, 0);
636 
637 	/*
638 	 * Change file ownership.  Must be the owner or privileged.
639 	 */
640 	if (mask & (ATTR_UID|ATTR_GID)) {
641 		/*
642 		 * CAP_FSETID overrides the following restrictions:
643 		 *
644 		 * The set-user-ID and set-group-ID bits of a file will be
645 		 * cleared upon successful return from chown()
646 		 */
647 		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
648 		    !capable(CAP_FSETID))
649 			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
650 
651 		/*
652 		 * Change the ownerships and register quota modifications
653 		 * in the transaction.
654 		 */
655 		if (!uid_eq(iuid, uid)) {
656 			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {
657 				ASSERT(mask & ATTR_UID);
658 				ASSERT(udqp);
659 				olddquot1 = xfs_qm_vop_chown(tp, ip,
660 							&ip->i_udquot, udqp);
661 			}
662 			ip->i_d.di_uid = xfs_kuid_to_uid(uid);
663 			inode->i_uid = uid;
664 		}
665 		if (!gid_eq(igid, gid)) {
666 			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
667 				ASSERT(xfs_sb_version_has_pquotino(&mp->m_sb) ||
668 				       !XFS_IS_PQUOTA_ON(mp));
669 				ASSERT(mask & ATTR_GID);
670 				ASSERT(gdqp);
671 				olddquot2 = xfs_qm_vop_chown(tp, ip,
672 							&ip->i_gdquot, gdqp);
673 			}
674 			ip->i_d.di_gid = xfs_kgid_to_gid(gid);
675 			inode->i_gid = gid;
676 		}
677 	}
678 
679 	if (mask & ATTR_MODE)
680 		xfs_setattr_mode(ip, iattr);
681 	if (mask & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
682 		xfs_setattr_time(ip, iattr);
683 
684 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
685 
686 	XFS_STATS_INC(xs_ig_attrchg);
687 
688 	if (mp->m_flags & XFS_MOUNT_WSYNC)
689 		xfs_trans_set_sync(tp);
690 	error = xfs_trans_commit(tp, 0);
691 
692 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
693 
694 	/*
695 	 * Release any dquot(s) the inode had kept before chown.
696 	 */
697 	xfs_qm_dqrele(olddquot1);
698 	xfs_qm_dqrele(olddquot2);
699 	xfs_qm_dqrele(udqp);
700 	xfs_qm_dqrele(gdqp);
701 
702 	if (error)
703 		return error;
704 
705 	/*
706 	 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
707 	 * 	     update.  We could avoid this with linked transactions
708 	 * 	     and passing down the transaction pointer all the way
709 	 *	     to attr_set.  No previous user of the generic
710 	 * 	     Posix ACL code seems to care about this issue either.
711 	 */
712 	if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
713 		error = posix_acl_chmod(inode, inode->i_mode);
714 		if (error)
715 			return error;
716 	}
717 
718 	return 0;
719 
720 out_trans_cancel:
721 	xfs_trans_cancel(tp, 0);
722 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
723 out_dqrele:
724 	xfs_qm_dqrele(udqp);
725 	xfs_qm_dqrele(gdqp);
726 	return error;
727 }
728 
729 /*
730  * Truncate file.  Must have write permission and not be a directory.
731  */
732 int
733 xfs_setattr_size(
734 	struct xfs_inode	*ip,
735 	struct iattr		*iattr)
736 {
737 	struct xfs_mount	*mp = ip->i_mount;
738 	struct inode		*inode = VFS_I(ip);
739 	xfs_off_t		oldsize, newsize;
740 	struct xfs_trans	*tp;
741 	int			error;
742 	uint			lock_flags = 0;
743 	uint			commit_flags = 0;
744 
745 	trace_xfs_setattr(ip);
746 
747 	if (mp->m_flags & XFS_MOUNT_RDONLY)
748 		return -EROFS;
749 
750 	if (XFS_FORCED_SHUTDOWN(mp))
751 		return -EIO;
752 
753 	error = inode_change_ok(inode, iattr);
754 	if (error)
755 		return error;
756 
757 	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
758 	ASSERT(S_ISREG(ip->i_d.di_mode));
759 	ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
760 		ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
761 
762 	oldsize = inode->i_size;
763 	newsize = iattr->ia_size;
764 
765 	/*
766 	 * Short circuit the truncate case for zero length files.
767 	 */
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 		 * Use the regular setattr path to update the timestamps.
774 		 */
775 		iattr->ia_valid &= ~ATTR_SIZE;
776 		return xfs_setattr_nonsize(ip, iattr, 0);
777 	}
778 
779 	/*
780 	 * Make sure that the dquots are attached to the inode.
781 	 */
782 	error = xfs_qm_dqattach(ip, 0);
783 	if (error)
784 		return error;
785 
786 	/*
787 	 * Now we can make the changes.  Before we join the inode to the
788 	 * transaction, take care of the part of the truncation that must be
789 	 * done without the inode lock.  This needs to be done before joining
790 	 * the inode to the transaction, because the inode cannot be unlocked
791 	 * once it is a part of the transaction.
792 	 */
793 	if (newsize > oldsize) {
794 		/*
795 		 * Do the first part of growing a file: zero any data in the
796 		 * last block that is beyond the old EOF.  We need to do this
797 		 * before the inode is joined to the transaction to modify
798 		 * i_size.
799 		 */
800 		error = xfs_zero_eof(ip, newsize, oldsize);
801 		if (error)
802 			return error;
803 	}
804 
805 	/*
806 	 * We are going to log the inode size change in this transaction so
807 	 * any previous writes that are beyond the on disk EOF and the new
808 	 * EOF that have not been written out need to be written here.  If we
809 	 * do not write the data out, we expose ourselves to the null files
810 	 * problem.
811 	 *
812 	 * Only flush from the on disk size to the smaller of the in memory
813 	 * file size or the new size as that's the range we really care about
814 	 * here and prevents waiting for other data not within the range we
815 	 * care about here.
816 	 */
817 	if (oldsize != ip->i_d.di_size && newsize > ip->i_d.di_size) {
818 		error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
819 						      ip->i_d.di_size, newsize);
820 		if (error)
821 			return error;
822 	}
823 
824 	/*
825 	 * Wait for all direct I/O to complete.
826 	 */
827 	inode_dio_wait(inode);
828 
829 	/*
830 	 * Do all the page cache truncate work outside the transaction context
831 	 * as the "lock" order is page lock->log space reservation.  i.e.
832 	 * locking pages inside the transaction can ABBA deadlock with
833 	 * writeback. We have to do the VFS inode size update before we truncate
834 	 * the pagecache, however, to avoid racing with page faults beyond the
835 	 * new EOF they are not serialised against truncate operations except by
836 	 * page locks and size updates.
837 	 *
838 	 * Hence we are in a situation where a truncate can fail with ENOMEM
839 	 * from xfs_trans_reserve(), but having already truncated the in-memory
840 	 * version of the file (i.e. made user visible changes). There's not
841 	 * much we can do about this, except to hope that the caller sees ENOMEM
842 	 * and retries the truncate operation.
843 	 */
844 	error = block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
845 	if (error)
846 		return error;
847 	truncate_setsize(inode, newsize);
848 
849 	/*
850 	 * The "we can't serialise against page faults" pain gets worse.
851 	 *
852 	 * If the file is mapped then we have to clean the page at the old EOF
853 	 * when extending the file. Extending the file can expose changes the
854 	 * underlying page mapping (e.g. from beyond EOF to a hole or
855 	 * unwritten), and so on the next attempt to write to that page we need
856 	 * to remap it for write. i.e. we need .page_mkwrite() to be called.
857 	 * Hence we need to clean the page to clean the pte and so a new write
858 	 * fault will be triggered appropriately.
859 	 *
860 	 * If we do it before we change the inode size, then we can race with a
861 	 * page fault that maps the page with exactly the same problem. If we do
862 	 * it after we change the file size, then a new page fault can come in
863 	 * and allocate space before we've run the rest of the truncate
864 	 * transaction. That's kinda grotesque, but it's better than have data
865 	 * over a hole, and so that's the lesser evil that has been chosen here.
866 	 *
867 	 * The real solution, however, is to have some mechanism for locking out
868 	 * page faults while a truncate is in progress.
869 	 */
870 	if (newsize > oldsize && mapping_mapped(VFS_I(ip)->i_mapping)) {
871 		error = filemap_write_and_wait_range(
872 				VFS_I(ip)->i_mapping,
873 				round_down(oldsize, PAGE_CACHE_SIZE),
874 				round_up(oldsize, PAGE_CACHE_SIZE) - 1);
875 		if (error)
876 			return error;
877 	}
878 
879 	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
880 	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
881 	if (error)
882 		goto out_trans_cancel;
883 
884 	commit_flags = XFS_TRANS_RELEASE_LOG_RES;
885 	lock_flags |= XFS_ILOCK_EXCL;
886 	xfs_ilock(ip, XFS_ILOCK_EXCL);
887 	xfs_trans_ijoin(tp, ip, 0);
888 
889 	/*
890 	 * Only change the c/mtime if we are changing the size or we are
891 	 * explicitly asked to change it.  This handles the semantic difference
892 	 * between truncate() and ftruncate() as implemented in the VFS.
893 	 *
894 	 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
895 	 * special case where we need to update the times despite not having
896 	 * these flags set.  For all other operations the VFS set these flags
897 	 * explicitly if it wants a timestamp update.
898 	 */
899 	if (newsize != oldsize &&
900 	    !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
901 		iattr->ia_ctime = iattr->ia_mtime =
902 			current_fs_time(inode->i_sb);
903 		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
904 	}
905 
906 	/*
907 	 * The first thing we do is set the size to new_size permanently on
908 	 * disk.  This way we don't have to worry about anyone ever being able
909 	 * to look at the data being freed even in the face of a crash.
910 	 * What we're getting around here is the case where we free a block, it
911 	 * is allocated to another file, it is written to, and then we crash.
912 	 * If the new data gets written to the file but the log buffers
913 	 * containing the free and reallocation don't, then we'd end up with
914 	 * garbage in the blocks being freed.  As long as we make the new size
915 	 * permanent before actually freeing any blocks it doesn't matter if
916 	 * they get written to.
917 	 */
918 	ip->i_d.di_size = newsize;
919 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
920 
921 	if (newsize <= oldsize) {
922 		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
923 		if (error)
924 			goto out_trans_abort;
925 
926 		/*
927 		 * Truncated "down", so we're removing references to old data
928 		 * here - if we delay flushing for a long time, we expose
929 		 * ourselves unduly to the notorious NULL files problem.  So,
930 		 * we mark this inode and flush it when the file is closed,
931 		 * and do not wait the usual (long) time for writeout.
932 		 */
933 		xfs_iflags_set(ip, XFS_ITRUNCATED);
934 
935 		/* A truncate down always removes post-EOF blocks. */
936 		xfs_inode_clear_eofblocks_tag(ip);
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))
942 		xfs_setattr_time(ip, iattr);
943 
944 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
945 
946 	XFS_STATS_INC(xs_ig_attrchg);
947 
948 	if (mp->m_flags & XFS_MOUNT_WSYNC)
949 		xfs_trans_set_sync(tp);
950 
951 	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
952 out_unlock:
953 	if (lock_flags)
954 		xfs_iunlock(ip, lock_flags);
955 	return error;
956 
957 out_trans_abort:
958 	commit_flags |= XFS_TRANS_ABORT;
959 out_trans_cancel:
960 	xfs_trans_cancel(tp, commit_flags);
961 	goto out_unlock;
962 }
963 
964 STATIC int
965 xfs_vn_setattr(
966 	struct dentry		*dentry,
967 	struct iattr		*iattr)
968 {
969 	struct xfs_inode	*ip = XFS_I(dentry->d_inode);
970 	int			error;
971 
972 	if (iattr->ia_valid & ATTR_SIZE) {
973 		xfs_ilock(ip, XFS_IOLOCK_EXCL);
974 		error = xfs_setattr_size(ip, iattr);
975 		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
976 	} else {
977 		error = xfs_setattr_nonsize(ip, iattr, 0);
978 	}
979 
980 	return error;
981 }
982 
983 STATIC int
984 xfs_vn_update_time(
985 	struct inode		*inode,
986 	struct timespec		*now,
987 	int			flags)
988 {
989 	struct xfs_inode	*ip = XFS_I(inode);
990 	struct xfs_mount	*mp = ip->i_mount;
991 	struct xfs_trans	*tp;
992 	int			error;
993 
994 	trace_xfs_update_time(ip);
995 
996 	tp = xfs_trans_alloc(mp, XFS_TRANS_FSYNC_TS);
997 	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_fsyncts, 0, 0);
998 	if (error) {
999 		xfs_trans_cancel(tp, 0);
1000 		return error;
1001 	}
1002 
1003 	xfs_ilock(ip, XFS_ILOCK_EXCL);
1004 	if (flags & S_CTIME) {
1005 		inode->i_ctime = *now;
1006 		ip->i_d.di_ctime.t_sec = (__int32_t)now->tv_sec;
1007 		ip->i_d.di_ctime.t_nsec = (__int32_t)now->tv_nsec;
1008 	}
1009 	if (flags & S_MTIME) {
1010 		inode->i_mtime = *now;
1011 		ip->i_d.di_mtime.t_sec = (__int32_t)now->tv_sec;
1012 		ip->i_d.di_mtime.t_nsec = (__int32_t)now->tv_nsec;
1013 	}
1014 	if (flags & S_ATIME) {
1015 		inode->i_atime = *now;
1016 		ip->i_d.di_atime.t_sec = (__int32_t)now->tv_sec;
1017 		ip->i_d.di_atime.t_nsec = (__int32_t)now->tv_nsec;
1018 	}
1019 	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1020 	xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP);
1021 	return xfs_trans_commit(tp, 0);
1022 }
1023 
1024 #define XFS_FIEMAP_FLAGS	(FIEMAP_FLAG_SYNC|FIEMAP_FLAG_XATTR)
1025 
1026 /*
1027  * Call fiemap helper to fill in user data.
1028  * Returns positive errors to xfs_getbmap.
1029  */
1030 STATIC int
1031 xfs_fiemap_format(
1032 	void			**arg,
1033 	struct getbmapx		*bmv,
1034 	int			*full)
1035 {
1036 	int			error;
1037 	struct fiemap_extent_info *fieinfo = *arg;
1038 	u32			fiemap_flags = 0;
1039 	u64			logical, physical, length;
1040 
1041 	/* Do nothing for a hole */
1042 	if (bmv->bmv_block == -1LL)
1043 		return 0;
1044 
1045 	logical = BBTOB(bmv->bmv_offset);
1046 	physical = BBTOB(bmv->bmv_block);
1047 	length = BBTOB(bmv->bmv_length);
1048 
1049 	if (bmv->bmv_oflags & BMV_OF_PREALLOC)
1050 		fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;
1051 	else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {
1052 		fiemap_flags |= (FIEMAP_EXTENT_DELALLOC |
1053 				 FIEMAP_EXTENT_UNKNOWN);
1054 		physical = 0;   /* no block yet */
1055 	}
1056 	if (bmv->bmv_oflags & BMV_OF_LAST)
1057 		fiemap_flags |= FIEMAP_EXTENT_LAST;
1058 
1059 	error = fiemap_fill_next_extent(fieinfo, logical, physical,
1060 					length, fiemap_flags);
1061 	if (error > 0) {
1062 		error = 0;
1063 		*full = 1;	/* user array now full */
1064 	}
1065 
1066 	return error;
1067 }
1068 
1069 STATIC int
1070 xfs_vn_fiemap(
1071 	struct inode		*inode,
1072 	struct fiemap_extent_info *fieinfo,
1073 	u64			start,
1074 	u64			length)
1075 {
1076 	xfs_inode_t		*ip = XFS_I(inode);
1077 	struct getbmapx		bm;
1078 	int			error;
1079 
1080 	error = fiemap_check_flags(fieinfo, XFS_FIEMAP_FLAGS);
1081 	if (error)
1082 		return error;
1083 
1084 	/* Set up bmap header for xfs internal routine */
1085 	bm.bmv_offset = BTOBBT(start);
1086 	/* Special case for whole file */
1087 	if (length == FIEMAP_MAX_OFFSET)
1088 		bm.bmv_length = -1LL;
1089 	else
1090 		bm.bmv_length = BTOBB(start + length) - bm.bmv_offset;
1091 
1092 	/* We add one because in getbmap world count includes the header */
1093 	bm.bmv_count = !fieinfo->fi_extents_max ? MAXEXTNUM :
1094 					fieinfo->fi_extents_max + 1;
1095 	bm.bmv_count = min_t(__s32, bm.bmv_count,
1096 			     (PAGE_SIZE * 16 / sizeof(struct getbmapx)));
1097 	bm.bmv_iflags = BMV_IF_PREALLOC | BMV_IF_NO_HOLES;
1098 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR)
1099 		bm.bmv_iflags |= BMV_IF_ATTRFORK;
1100 	if (!(fieinfo->fi_flags & FIEMAP_FLAG_SYNC))
1101 		bm.bmv_iflags |= BMV_IF_DELALLOC;
1102 
1103 	error = xfs_getbmap(ip, &bm, xfs_fiemap_format, fieinfo);
1104 	if (error)
1105 		return error;
1106 
1107 	return 0;
1108 }
1109 
1110 STATIC int
1111 xfs_vn_tmpfile(
1112 	struct inode	*dir,
1113 	struct dentry	*dentry,
1114 	umode_t		mode)
1115 {
1116 	return xfs_generic_create(dir, dentry, mode, 0, true);
1117 }
1118 
1119 static const struct inode_operations xfs_inode_operations = {
1120 	.get_acl		= xfs_get_acl,
1121 	.set_acl		= xfs_set_acl,
1122 	.getattr		= xfs_vn_getattr,
1123 	.setattr		= xfs_vn_setattr,
1124 	.setxattr		= generic_setxattr,
1125 	.getxattr		= generic_getxattr,
1126 	.removexattr		= generic_removexattr,
1127 	.listxattr		= xfs_vn_listxattr,
1128 	.fiemap			= xfs_vn_fiemap,
1129 	.update_time		= xfs_vn_update_time,
1130 };
1131 
1132 static const struct inode_operations xfs_dir_inode_operations = {
1133 	.create			= xfs_vn_create,
1134 	.lookup			= xfs_vn_lookup,
1135 	.link			= xfs_vn_link,
1136 	.unlink			= xfs_vn_unlink,
1137 	.symlink		= xfs_vn_symlink,
1138 	.mkdir			= xfs_vn_mkdir,
1139 	/*
1140 	 * Yes, XFS uses the same method for rmdir and unlink.
1141 	 *
1142 	 * There are some subtile differences deeper in the code,
1143 	 * but we use S_ISDIR to check for those.
1144 	 */
1145 	.rmdir			= xfs_vn_unlink,
1146 	.mknod			= xfs_vn_mknod,
1147 	.rename			= xfs_vn_rename,
1148 	.get_acl		= xfs_get_acl,
1149 	.set_acl		= xfs_set_acl,
1150 	.getattr		= xfs_vn_getattr,
1151 	.setattr		= xfs_vn_setattr,
1152 	.setxattr		= generic_setxattr,
1153 	.getxattr		= generic_getxattr,
1154 	.removexattr		= generic_removexattr,
1155 	.listxattr		= xfs_vn_listxattr,
1156 	.update_time		= xfs_vn_update_time,
1157 	.tmpfile		= xfs_vn_tmpfile,
1158 };
1159 
1160 static const struct inode_operations xfs_dir_ci_inode_operations = {
1161 	.create			= xfs_vn_create,
1162 	.lookup			= xfs_vn_ci_lookup,
1163 	.link			= xfs_vn_link,
1164 	.unlink			= xfs_vn_unlink,
1165 	.symlink		= xfs_vn_symlink,
1166 	.mkdir			= xfs_vn_mkdir,
1167 	/*
1168 	 * Yes, XFS uses the same method for rmdir and unlink.
1169 	 *
1170 	 * There are some subtile differences deeper in the code,
1171 	 * but we use S_ISDIR to check for those.
1172 	 */
1173 	.rmdir			= xfs_vn_unlink,
1174 	.mknod			= xfs_vn_mknod,
1175 	.rename			= xfs_vn_rename,
1176 	.get_acl		= xfs_get_acl,
1177 	.set_acl		= xfs_set_acl,
1178 	.getattr		= xfs_vn_getattr,
1179 	.setattr		= xfs_vn_setattr,
1180 	.setxattr		= generic_setxattr,
1181 	.getxattr		= generic_getxattr,
1182 	.removexattr		= generic_removexattr,
1183 	.listxattr		= xfs_vn_listxattr,
1184 	.update_time		= xfs_vn_update_time,
1185 	.tmpfile		= xfs_vn_tmpfile,
1186 };
1187 
1188 static const struct inode_operations xfs_symlink_inode_operations = {
1189 	.readlink		= generic_readlink,
1190 	.follow_link		= xfs_vn_follow_link,
1191 	.put_link		= kfree_put_link,
1192 	.getattr		= xfs_vn_getattr,
1193 	.setattr		= xfs_vn_setattr,
1194 	.setxattr		= generic_setxattr,
1195 	.getxattr		= generic_getxattr,
1196 	.removexattr		= generic_removexattr,
1197 	.listxattr		= xfs_vn_listxattr,
1198 	.update_time		= xfs_vn_update_time,
1199 };
1200 
1201 STATIC void
1202 xfs_diflags_to_iflags(
1203 	struct inode		*inode,
1204 	struct xfs_inode	*ip)
1205 {
1206 	if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
1207 		inode->i_flags |= S_IMMUTABLE;
1208 	else
1209 		inode->i_flags &= ~S_IMMUTABLE;
1210 	if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
1211 		inode->i_flags |= S_APPEND;
1212 	else
1213 		inode->i_flags &= ~S_APPEND;
1214 	if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
1215 		inode->i_flags |= S_SYNC;
1216 	else
1217 		inode->i_flags &= ~S_SYNC;
1218 	if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
1219 		inode->i_flags |= S_NOATIME;
1220 	else
1221 		inode->i_flags &= ~S_NOATIME;
1222 }
1223 
1224 /*
1225  * Initialize the Linux inode, set up the operation vectors and
1226  * unlock the inode.
1227  *
1228  * When reading existing inodes from disk this is called directly
1229  * from xfs_iget, when creating a new inode it is called from
1230  * xfs_ialloc after setting up the inode.
1231  *
1232  * We are always called with an uninitialised linux inode here.
1233  * We need to initialise the necessary fields and take a reference
1234  * on it.
1235  */
1236 void
1237 xfs_setup_inode(
1238 	struct xfs_inode	*ip)
1239 {
1240 	struct inode		*inode = &ip->i_vnode;
1241 	gfp_t			gfp_mask;
1242 
1243 	inode->i_ino = ip->i_ino;
1244 	inode->i_state = I_NEW;
1245 
1246 	inode_sb_list_add(inode);
1247 	/* make the inode look hashed for the writeback code */
1248 	hlist_add_fake(&inode->i_hash);
1249 
1250 	inode->i_mode	= ip->i_d.di_mode;
1251 	set_nlink(inode, ip->i_d.di_nlink);
1252 	inode->i_uid    = xfs_uid_to_kuid(ip->i_d.di_uid);
1253 	inode->i_gid    = xfs_gid_to_kgid(ip->i_d.di_gid);
1254 
1255 	switch (inode->i_mode & S_IFMT) {
1256 	case S_IFBLK:
1257 	case S_IFCHR:
1258 		inode->i_rdev =
1259 			MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
1260 			      sysv_minor(ip->i_df.if_u2.if_rdev));
1261 		break;
1262 	default:
1263 		inode->i_rdev = 0;
1264 		break;
1265 	}
1266 
1267 	inode->i_generation = ip->i_d.di_gen;
1268 	i_size_write(inode, ip->i_d.di_size);
1269 	inode->i_atime.tv_sec	= ip->i_d.di_atime.t_sec;
1270 	inode->i_atime.tv_nsec	= ip->i_d.di_atime.t_nsec;
1271 	inode->i_mtime.tv_sec	= ip->i_d.di_mtime.t_sec;
1272 	inode->i_mtime.tv_nsec	= ip->i_d.di_mtime.t_nsec;
1273 	inode->i_ctime.tv_sec	= ip->i_d.di_ctime.t_sec;
1274 	inode->i_ctime.tv_nsec	= ip->i_d.di_ctime.t_nsec;
1275 	xfs_diflags_to_iflags(inode, ip);
1276 
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 	switch (inode->i_mode & S_IFMT) {
1280 	case S_IFREG:
1281 		inode->i_op = &xfs_inode_operations;
1282 		inode->i_fop = &xfs_file_operations;
1283 		inode->i_mapping->a_ops = &xfs_address_space_operations;
1284 		break;
1285 	case S_IFDIR:
1286 		lockdep_set_class(&ip->i_lock.mr_lock, &xfs_dir_ilock_class);
1287 		if (xfs_sb_version_hasasciici(&XFS_M(inode->i_sb)->m_sb))
1288 			inode->i_op = &xfs_dir_ci_inode_operations;
1289 		else
1290 			inode->i_op = &xfs_dir_inode_operations;
1291 		inode->i_fop = &xfs_dir_file_operations;
1292 		ip->d_ops = ip->i_mount->m_dir_inode_ops;
1293 		break;
1294 	case S_IFLNK:
1295 		inode->i_op = &xfs_symlink_inode_operations;
1296 		if (!(ip->i_df.if_flags & XFS_IFINLINE))
1297 			inode->i_mapping->a_ops = &xfs_address_space_operations;
1298 		break;
1299 	default:
1300 		inode->i_op = &xfs_inode_operations;
1301 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
1302 		break;
1303 	}
1304 
1305 	/*
1306 	 * Ensure all page cache allocations are done from GFP_NOFS context to
1307 	 * prevent direct reclaim recursion back into the filesystem and blowing
1308 	 * stacks or deadlocking.
1309 	 */
1310 	gfp_mask = mapping_gfp_mask(inode->i_mapping);
1311 	mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));
1312 
1313 	/*
1314 	 * If there is no attribute fork no ACL can exist on this inode,
1315 	 * and it can't have any file capabilities attached to it either.
1316 	 */
1317 	if (!XFS_IFORK_Q(ip)) {
1318 		inode_has_no_xattr(inode);
1319 		cache_no_acl(inode);
1320 	}
1321 
1322 	xfs_iflags_clear(ip, XFS_INEW);
1323 	barrier();
1324 
1325 	unlock_new_inode(inode);
1326 }
1327