xref: /openbmc/linux/fs/xfs/xfs_iops.c (revision 9ac17575)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_mount.h"
13 #include "xfs_inode.h"
14 #include "xfs_acl.h"
15 #include "xfs_quota.h"
16 #include "xfs_attr.h"
17 #include "xfs_trans.h"
18 #include "xfs_trace.h"
19 #include "xfs_icache.h"
20 #include "xfs_symlink.h"
21 #include "xfs_dir2.h"
22 #include "xfs_iomap.h"
23 #include "xfs_error.h"
24 
25 #include <linux/posix_acl.h>
26 #include <linux/security.h>
27 #include <linux/iversion.h>
28 
29 /*
30  * Directories have different lock order w.r.t. mmap_sem compared to regular
31  * files. This is due to readdir potentially triggering page faults on a user
32  * buffer inside filldir(), and this happens with the ilock on the directory
33  * held. For regular files, the lock order is the other way around - the
34  * mmap_sem is taken during the page fault, and then we lock the ilock to do
35  * block mapping. Hence we need a different class for the directory ilock so
36  * that lockdep can tell them apart.
37  */
38 static struct lock_class_key xfs_nondir_ilock_class;
39 static struct lock_class_key xfs_dir_ilock_class;
40 
41 static int
42 xfs_initxattrs(
43 	struct inode		*inode,
44 	const struct xattr	*xattr_array,
45 	void			*fs_info)
46 {
47 	const struct xattr	*xattr;
48 	struct xfs_inode	*ip = XFS_I(inode);
49 	int			error = 0;
50 
51 	for (xattr = xattr_array; xattr->name != NULL; xattr++) {
52 		struct xfs_da_args	args = {
53 			.dp		= ip,
54 			.attr_filter	= XFS_ATTR_SECURE,
55 			.name		= xattr->name,
56 			.namelen	= strlen(xattr->name),
57 			.value		= xattr->value,
58 			.valuelen	= xattr->value_len,
59 		};
60 		error = xfs_attr_set(&args);
61 		if (error < 0)
62 			break;
63 	}
64 	return error;
65 }
66 
67 /*
68  * Hook in SELinux.  This is not quite correct yet, what we really need
69  * here (as we do for default ACLs) is a mechanism by which creation of
70  * these attrs can be journalled at inode creation time (along with the
71  * inode, of course, such that log replay can't cause these to be lost).
72  */
73 
74 STATIC int
75 xfs_init_security(
76 	struct inode	*inode,
77 	struct inode	*dir,
78 	const struct qstr *qstr)
79 {
80 	return security_inode_init_security(inode, dir, qstr,
81 					     &xfs_initxattrs, NULL);
82 }
83 
84 static void
85 xfs_dentry_to_name(
86 	struct xfs_name	*namep,
87 	struct dentry	*dentry)
88 {
89 	namep->name = dentry->d_name.name;
90 	namep->len = dentry->d_name.len;
91 	namep->type = XFS_DIR3_FT_UNKNOWN;
92 }
93 
94 static int
95 xfs_dentry_mode_to_name(
96 	struct xfs_name	*namep,
97 	struct dentry	*dentry,
98 	int		mode)
99 {
100 	namep->name = dentry->d_name.name;
101 	namep->len = dentry->d_name.len;
102 	namep->type = xfs_mode_to_ftype(mode);
103 
104 	if (unlikely(namep->type == XFS_DIR3_FT_UNKNOWN))
105 		return -EFSCORRUPTED;
106 
107 	return 0;
108 }
109 
110 STATIC void
111 xfs_cleanup_inode(
112 	struct inode	*dir,
113 	struct inode	*inode,
114 	struct dentry	*dentry)
115 {
116 	struct xfs_name	teardown;
117 
118 	/* Oh, the horror.
119 	 * If we can't add the ACL or we fail in
120 	 * xfs_init_security we must back out.
121 	 * ENOSPC can hit here, among other things.
122 	 */
123 	xfs_dentry_to_name(&teardown, dentry);
124 
125 	xfs_remove(XFS_I(dir), &teardown, XFS_I(inode));
126 }
127 
128 STATIC int
129 xfs_generic_create(
130 	struct inode	*dir,
131 	struct dentry	*dentry,
132 	umode_t		mode,
133 	dev_t		rdev,
134 	bool		tmpfile)	/* unnamed file */
135 {
136 	struct inode	*inode;
137 	struct xfs_inode *ip = NULL;
138 	struct posix_acl *default_acl, *acl;
139 	struct xfs_name	name;
140 	int		error;
141 
142 	/*
143 	 * Irix uses Missed'em'V split, but doesn't want to see
144 	 * the upper 5 bits of (14bit) major.
145 	 */
146 	if (S_ISCHR(mode) || S_ISBLK(mode)) {
147 		if (unlikely(!sysv_valid_dev(rdev) || MAJOR(rdev) & ~0x1ff))
148 			return -EINVAL;
149 	} else {
150 		rdev = 0;
151 	}
152 
153 	error = posix_acl_create(dir, &mode, &default_acl, &acl);
154 	if (error)
155 		return error;
156 
157 	/* Verify mode is valid also for tmpfile case */
158 	error = xfs_dentry_mode_to_name(&name, dentry, mode);
159 	if (unlikely(error))
160 		goto out_free_acl;
161 
162 	if (!tmpfile) {
163 		error = xfs_create(XFS_I(dir), &name, mode, rdev, &ip);
164 	} else {
165 		error = xfs_create_tmpfile(XFS_I(dir), mode, &ip);
166 	}
167 	if (unlikely(error))
168 		goto out_free_acl;
169 
170 	inode = VFS_I(ip);
171 
172 	error = xfs_init_security(inode, dir, &dentry->d_name);
173 	if (unlikely(error))
174 		goto out_cleanup_inode;
175 
176 #ifdef CONFIG_XFS_POSIX_ACL
177 	if (default_acl) {
178 		error = __xfs_set_acl(inode, default_acl, ACL_TYPE_DEFAULT);
179 		if (error)
180 			goto out_cleanup_inode;
181 	}
182 	if (acl) {
183 		error = __xfs_set_acl(inode, acl, ACL_TYPE_ACCESS);
184 		if (error)
185 			goto out_cleanup_inode;
186 	}
187 #endif
188 
189 	xfs_setup_iops(ip);
190 
191 	if (tmpfile) {
192 		/*
193 		 * The VFS requires that any inode fed to d_tmpfile must have
194 		 * nlink == 1 so that it can decrement the nlink in d_tmpfile.
195 		 * However, we created the temp file with nlink == 0 because
196 		 * we're not allowed to put an inode with nlink > 0 on the
197 		 * unlinked list.  Therefore we have to set nlink to 1 so that
198 		 * d_tmpfile can immediately set it back to zero.
199 		 */
200 		set_nlink(inode, 1);
201 		d_tmpfile(dentry, inode);
202 	} else
203 		d_instantiate(dentry, inode);
204 
205 	xfs_finish_inode_setup(ip);
206 
207  out_free_acl:
208 	if (default_acl)
209 		posix_acl_release(default_acl);
210 	if (acl)
211 		posix_acl_release(acl);
212 	return error;
213 
214  out_cleanup_inode:
215 	xfs_finish_inode_setup(ip);
216 	if (!tmpfile)
217 		xfs_cleanup_inode(dir, inode, dentry);
218 	xfs_irele(ip);
219 	goto out_free_acl;
220 }
221 
222 STATIC int
223 xfs_vn_mknod(
224 	struct inode	*dir,
225 	struct dentry	*dentry,
226 	umode_t		mode,
227 	dev_t		rdev)
228 {
229 	return xfs_generic_create(dir, dentry, mode, rdev, false);
230 }
231 
232 STATIC int
233 xfs_vn_create(
234 	struct inode	*dir,
235 	struct dentry	*dentry,
236 	umode_t		mode,
237 	bool		flags)
238 {
239 	return xfs_vn_mknod(dir, dentry, mode, 0);
240 }
241 
242 STATIC int
243 xfs_vn_mkdir(
244 	struct inode	*dir,
245 	struct dentry	*dentry,
246 	umode_t		mode)
247 {
248 	return xfs_vn_mknod(dir, dentry, mode|S_IFDIR, 0);
249 }
250 
251 STATIC struct dentry *
252 xfs_vn_lookup(
253 	struct inode	*dir,
254 	struct dentry	*dentry,
255 	unsigned int flags)
256 {
257 	struct inode *inode;
258 	struct xfs_inode *cip;
259 	struct xfs_name	name;
260 	int		error;
261 
262 	if (dentry->d_name.len >= MAXNAMELEN)
263 		return ERR_PTR(-ENAMETOOLONG);
264 
265 	xfs_dentry_to_name(&name, dentry);
266 	error = xfs_lookup(XFS_I(dir), &name, &cip, NULL);
267 	if (likely(!error))
268 		inode = VFS_I(cip);
269 	else if (likely(error == -ENOENT))
270 		inode = NULL;
271 	else
272 		inode = ERR_PTR(error);
273 	return d_splice_alias(inode, dentry);
274 }
275 
276 STATIC struct dentry *
277 xfs_vn_ci_lookup(
278 	struct inode	*dir,
279 	struct dentry	*dentry,
280 	unsigned int flags)
281 {
282 	struct xfs_inode *ip;
283 	struct xfs_name	xname;
284 	struct xfs_name ci_name;
285 	struct qstr	dname;
286 	int		error;
287 
288 	if (dentry->d_name.len >= MAXNAMELEN)
289 		return ERR_PTR(-ENAMETOOLONG);
290 
291 	xfs_dentry_to_name(&xname, dentry);
292 	error = xfs_lookup(XFS_I(dir), &xname, &ip, &ci_name);
293 	if (unlikely(error)) {
294 		if (unlikely(error != -ENOENT))
295 			return ERR_PTR(error);
296 		/*
297 		 * call d_add(dentry, NULL) here when d_drop_negative_children
298 		 * is called in xfs_vn_mknod (ie. allow negative dentries
299 		 * with CI filesystems).
300 		 */
301 		return NULL;
302 	}
303 
304 	/* if exact match, just splice and exit */
305 	if (!ci_name.name)
306 		return d_splice_alias(VFS_I(ip), dentry);
307 
308 	/* else case-insensitive match... */
309 	dname.name = ci_name.name;
310 	dname.len = ci_name.len;
311 	dentry = d_add_ci(dentry, VFS_I(ip), &dname);
312 	kmem_free(ci_name.name);
313 	return dentry;
314 }
315 
316 STATIC int
317 xfs_vn_link(
318 	struct dentry	*old_dentry,
319 	struct inode	*dir,
320 	struct dentry	*dentry)
321 {
322 	struct inode	*inode = d_inode(old_dentry);
323 	struct xfs_name	name;
324 	int		error;
325 
326 	error = xfs_dentry_mode_to_name(&name, dentry, inode->i_mode);
327 	if (unlikely(error))
328 		return error;
329 
330 	error = xfs_link(XFS_I(dir), XFS_I(inode), &name);
331 	if (unlikely(error))
332 		return error;
333 
334 	ihold(inode);
335 	d_instantiate(dentry, inode);
336 	return 0;
337 }
338 
339 STATIC int
340 xfs_vn_unlink(
341 	struct inode	*dir,
342 	struct dentry	*dentry)
343 {
344 	struct xfs_name	name;
345 	int		error;
346 
347 	xfs_dentry_to_name(&name, dentry);
348 
349 	error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry)));
350 	if (error)
351 		return error;
352 
353 	/*
354 	 * With unlink, the VFS makes the dentry "negative": no inode,
355 	 * but still hashed. This is incompatible with case-insensitive
356 	 * mode, so invalidate (unhash) the dentry in CI-mode.
357 	 */
358 	if (xfs_sb_version_hasasciici(&XFS_M(dir->i_sb)->m_sb))
359 		d_invalidate(dentry);
360 	return 0;
361 }
362 
363 STATIC int
364 xfs_vn_symlink(
365 	struct inode	*dir,
366 	struct dentry	*dentry,
367 	const char	*symname)
368 {
369 	struct inode	*inode;
370 	struct xfs_inode *cip = NULL;
371 	struct xfs_name	name;
372 	int		error;
373 	umode_t		mode;
374 
375 	mode = S_IFLNK |
376 		(irix_symlink_mode ? 0777 & ~current_umask() : S_IRWXUGO);
377 	error = xfs_dentry_mode_to_name(&name, dentry, mode);
378 	if (unlikely(error))
379 		goto out;
380 
381 	error = xfs_symlink(XFS_I(dir), &name, symname, mode, &cip);
382 	if (unlikely(error))
383 		goto out;
384 
385 	inode = VFS_I(cip);
386 
387 	error = xfs_init_security(inode, dir, &dentry->d_name);
388 	if (unlikely(error))
389 		goto out_cleanup_inode;
390 
391 	xfs_setup_iops(cip);
392 
393 	d_instantiate(dentry, inode);
394 	xfs_finish_inode_setup(cip);
395 	return 0;
396 
397  out_cleanup_inode:
398 	xfs_finish_inode_setup(cip);
399 	xfs_cleanup_inode(dir, inode, dentry);
400 	xfs_irele(cip);
401  out:
402 	return error;
403 }
404 
405 STATIC int
406 xfs_vn_rename(
407 	struct inode	*odir,
408 	struct dentry	*odentry,
409 	struct inode	*ndir,
410 	struct dentry	*ndentry,
411 	unsigned int	flags)
412 {
413 	struct inode	*new_inode = d_inode(ndentry);
414 	int		omode = 0;
415 	int		error;
416 	struct xfs_name	oname;
417 	struct xfs_name	nname;
418 
419 	if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT))
420 		return -EINVAL;
421 
422 	/* if we are exchanging files, we need to set i_mode of both files */
423 	if (flags & RENAME_EXCHANGE)
424 		omode = d_inode(ndentry)->i_mode;
425 
426 	error = xfs_dentry_mode_to_name(&oname, odentry, omode);
427 	if (omode && unlikely(error))
428 		return error;
429 
430 	error = xfs_dentry_mode_to_name(&nname, ndentry,
431 					d_inode(odentry)->i_mode);
432 	if (unlikely(error))
433 		return error;
434 
435 	return xfs_rename(XFS_I(odir), &oname, XFS_I(d_inode(odentry)),
436 			  XFS_I(ndir), &nname,
437 			  new_inode ? XFS_I(new_inode) : NULL, flags);
438 }
439 
440 /*
441  * careful here - this function can get called recursively, so
442  * we need to be very careful about how much stack we use.
443  * uio is kmalloced for this reason...
444  */
445 STATIC const char *
446 xfs_vn_get_link(
447 	struct dentry		*dentry,
448 	struct inode		*inode,
449 	struct delayed_call	*done)
450 {
451 	char			*link;
452 	int			error = -ENOMEM;
453 
454 	if (!dentry)
455 		return ERR_PTR(-ECHILD);
456 
457 	link = kmalloc(XFS_SYMLINK_MAXLEN+1, GFP_KERNEL);
458 	if (!link)
459 		goto out_err;
460 
461 	error = xfs_readlink(XFS_I(d_inode(dentry)), link);
462 	if (unlikely(error))
463 		goto out_kfree;
464 
465 	set_delayed_call(done, kfree_link, link);
466 	return link;
467 
468  out_kfree:
469 	kfree(link);
470  out_err:
471 	return ERR_PTR(error);
472 }
473 
474 STATIC const char *
475 xfs_vn_get_link_inline(
476 	struct dentry		*dentry,
477 	struct inode		*inode,
478 	struct delayed_call	*done)
479 {
480 	struct xfs_inode	*ip = XFS_I(inode);
481 	char			*link;
482 
483 	ASSERT(ip->i_df.if_flags & XFS_IFINLINE);
484 
485 	/*
486 	 * The VFS crashes on a NULL pointer, so return -EFSCORRUPTED if
487 	 * if_data is junk.
488 	 */
489 	link = ip->i_df.if_u1.if_data;
490 	if (XFS_IS_CORRUPT(ip->i_mount, !link))
491 		return ERR_PTR(-EFSCORRUPTED);
492 	return link;
493 }
494 
495 static uint32_t
496 xfs_stat_blksize(
497 	struct xfs_inode	*ip)
498 {
499 	struct xfs_mount	*mp = ip->i_mount;
500 
501 	/*
502 	 * If the file blocks are being allocated from a realtime volume, then
503 	 * always return the realtime extent size.
504 	 */
505 	if (XFS_IS_REALTIME_INODE(ip))
506 		return xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
507 
508 	/*
509 	 * Allow large block sizes to be reported to userspace programs if the
510 	 * "largeio" mount option is used.
511 	 *
512 	 * If compatibility mode is specified, simply return the basic unit of
513 	 * caching so that we don't get inefficient read/modify/write I/O from
514 	 * user apps. Otherwise....
515 	 *
516 	 * If the underlying volume is a stripe, then return the stripe width in
517 	 * bytes as the recommended I/O size. It is not a stripe and we've set a
518 	 * default buffered I/O size, return that, otherwise return the compat
519 	 * default.
520 	 */
521 	if (mp->m_flags & XFS_MOUNT_LARGEIO) {
522 		if (mp->m_swidth)
523 			return mp->m_swidth << mp->m_sb.sb_blocklog;
524 		if (mp->m_flags & XFS_MOUNT_ALLOCSIZE)
525 			return 1U << mp->m_allocsize_log;
526 	}
527 
528 	return PAGE_SIZE;
529 }
530 
531 STATIC int
532 xfs_vn_getattr(
533 	const struct path	*path,
534 	struct kstat		*stat,
535 	u32			request_mask,
536 	unsigned int		query_flags)
537 {
538 	struct inode		*inode = d_inode(path->dentry);
539 	struct xfs_inode	*ip = XFS_I(inode);
540 	struct xfs_mount	*mp = ip->i_mount;
541 
542 	trace_xfs_getattr(ip);
543 
544 	if (XFS_FORCED_SHUTDOWN(mp))
545 		return -EIO;
546 
547 	stat->size = XFS_ISIZE(ip);
548 	stat->dev = inode->i_sb->s_dev;
549 	stat->mode = inode->i_mode;
550 	stat->nlink = inode->i_nlink;
551 	stat->uid = inode->i_uid;
552 	stat->gid = inode->i_gid;
553 	stat->ino = ip->i_ino;
554 	stat->atime = inode->i_atime;
555 	stat->mtime = inode->i_mtime;
556 	stat->ctime = inode->i_ctime;
557 	stat->blocks =
558 		XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
559 
560 	if (xfs_sb_version_has_v3inode(&mp->m_sb)) {
561 		if (request_mask & STATX_BTIME) {
562 			stat->result_mask |= STATX_BTIME;
563 			stat->btime = ip->i_d.di_crtime;
564 		}
565 	}
566 
567 	/*
568 	 * Note: If you add another clause to set an attribute flag, please
569 	 * update attributes_mask below.
570 	 */
571 	if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
572 		stat->attributes |= STATX_ATTR_IMMUTABLE;
573 	if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
574 		stat->attributes |= STATX_ATTR_APPEND;
575 	if (ip->i_d.di_flags & XFS_DIFLAG_NODUMP)
576 		stat->attributes |= STATX_ATTR_NODUMP;
577 
578 	stat->attributes_mask |= (STATX_ATTR_IMMUTABLE |
579 				  STATX_ATTR_APPEND |
580 				  STATX_ATTR_NODUMP);
581 
582 	switch (inode->i_mode & S_IFMT) {
583 	case S_IFBLK:
584 	case S_IFCHR:
585 		stat->blksize = BLKDEV_IOSIZE;
586 		stat->rdev = inode->i_rdev;
587 		break;
588 	default:
589 		stat->blksize = xfs_stat_blksize(ip);
590 		stat->rdev = 0;
591 		break;
592 	}
593 
594 	return 0;
595 }
596 
597 static void
598 xfs_setattr_mode(
599 	struct xfs_inode	*ip,
600 	struct iattr		*iattr)
601 {
602 	struct inode		*inode = VFS_I(ip);
603 	umode_t			mode = iattr->ia_mode;
604 
605 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
606 
607 	inode->i_mode &= S_IFMT;
608 	inode->i_mode |= mode & ~S_IFMT;
609 }
610 
611 void
612 xfs_setattr_time(
613 	struct xfs_inode	*ip,
614 	struct iattr		*iattr)
615 {
616 	struct inode		*inode = VFS_I(ip);
617 
618 	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
619 
620 	if (iattr->ia_valid & ATTR_ATIME)
621 		inode->i_atime = iattr->ia_atime;
622 	if (iattr->ia_valid & ATTR_CTIME)
623 		inode->i_ctime = iattr->ia_ctime;
624 	if (iattr->ia_valid & ATTR_MTIME)
625 		inode->i_mtime = iattr->ia_mtime;
626 }
627 
628 static int
629 xfs_vn_change_ok(
630 	struct dentry	*dentry,
631 	struct iattr	*iattr)
632 {
633 	struct xfs_mount	*mp = XFS_I(d_inode(dentry))->i_mount;
634 
635 	if (mp->m_flags & XFS_MOUNT_RDONLY)
636 		return -EROFS;
637 
638 	if (XFS_FORCED_SHUTDOWN(mp))
639 		return -EIO;
640 
641 	return setattr_prepare(dentry, iattr);
642 }
643 
644 /*
645  * Set non-size attributes of an inode.
646  *
647  * Caution: The caller of this function is responsible for calling
648  * setattr_prepare() or otherwise verifying the change is fine.
649  */
650 int
651 xfs_setattr_nonsize(
652 	struct xfs_inode	*ip,
653 	struct iattr		*iattr,
654 	int			flags)
655 {
656 	xfs_mount_t		*mp = ip->i_mount;
657 	struct inode		*inode = VFS_I(ip);
658 	int			mask = iattr->ia_valid;
659 	xfs_trans_t		*tp;
660 	int			error;
661 	kuid_t			uid = GLOBAL_ROOT_UID, iuid = GLOBAL_ROOT_UID;
662 	kgid_t			gid = GLOBAL_ROOT_GID, igid = GLOBAL_ROOT_GID;
663 	struct xfs_dquot	*udqp = NULL, *gdqp = NULL;
664 	struct xfs_dquot	*olddquot1 = NULL, *olddquot2 = NULL;
665 
666 	ASSERT((mask & ATTR_SIZE) == 0);
667 
668 	/*
669 	 * If disk quotas is on, we make sure that the dquots do exist on disk,
670 	 * before we start any other transactions. Trying to do this later
671 	 * is messy. We don't care to take a readlock to look at the ids
672 	 * in inode here, because we can't hold it across the trans_reserve.
673 	 * If the IDs do change before we take the ilock, we're covered
674 	 * because the i_*dquot fields will get updated anyway.
675 	 */
676 	if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
677 		uint	qflags = 0;
678 
679 		if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
680 			uid = iattr->ia_uid;
681 			qflags |= XFS_QMOPT_UQUOTA;
682 		} else {
683 			uid = inode->i_uid;
684 		}
685 		if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
686 			gid = iattr->ia_gid;
687 			qflags |= XFS_QMOPT_GQUOTA;
688 		}  else {
689 			gid = inode->i_gid;
690 		}
691 
692 		/*
693 		 * We take a reference when we initialize udqp and gdqp,
694 		 * so it is important that we never blindly double trip on
695 		 * the same variable. See xfs_create() for an example.
696 		 */
697 		ASSERT(udqp == NULL);
698 		ASSERT(gdqp == NULL);
699 		error = xfs_qm_vop_dqalloc(ip, uid, gid, ip->i_d.di_projid,
700 					   qflags, &udqp, &gdqp, NULL);
701 		if (error)
702 			return error;
703 	}
704 
705 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_ichange, 0, 0, 0, &tp);
706 	if (error)
707 		goto out_dqrele;
708 
709 	xfs_ilock(ip, XFS_ILOCK_EXCL);
710 	xfs_trans_ijoin(tp, ip, 0);
711 
712 	/*
713 	 * Change file ownership.  Must be the owner or privileged.
714 	 */
715 	if (mask & (ATTR_UID|ATTR_GID)) {
716 		/*
717 		 * These IDs could have changed since we last looked at them.
718 		 * But, we're assured that if the ownership did change
719 		 * while we didn't have the inode locked, inode's dquot(s)
720 		 * would have changed also.
721 		 */
722 		iuid = inode->i_uid;
723 		igid = inode->i_gid;
724 		gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
725 		uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;
726 
727 		/*
728 		 * Do a quota reservation only if uid/gid is actually
729 		 * going to change.
730 		 */
731 		if (XFS_IS_QUOTA_RUNNING(mp) &&
732 		    ((XFS_IS_UQUOTA_ON(mp) && !uid_eq(iuid, uid)) ||
733 		     (XFS_IS_GQUOTA_ON(mp) && !gid_eq(igid, gid)))) {
734 			ASSERT(tp);
735 			error = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,
736 						NULL, capable(CAP_FOWNER) ?
737 						XFS_QMOPT_FORCE_RES : 0);
738 			if (error)	/* out of quota */
739 				goto out_cancel;
740 		}
741 
742 		/*
743 		 * CAP_FSETID overrides the following restrictions:
744 		 *
745 		 * The set-user-ID and set-group-ID bits of a file will be
746 		 * cleared upon successful return from chown()
747 		 */
748 		if ((inode->i_mode & (S_ISUID|S_ISGID)) &&
749 		    !capable(CAP_FSETID))
750 			inode->i_mode &= ~(S_ISUID|S_ISGID);
751 
752 		/*
753 		 * Change the ownerships and register quota modifications
754 		 * in the transaction.
755 		 */
756 		if (!uid_eq(iuid, uid)) {
757 			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {
758 				ASSERT(mask & ATTR_UID);
759 				ASSERT(udqp);
760 				olddquot1 = xfs_qm_vop_chown(tp, ip,
761 							&ip->i_udquot, udqp);
762 			}
763 			inode->i_uid = uid;
764 		}
765 		if (!gid_eq(igid, gid)) {
766 			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
767 				ASSERT(xfs_sb_version_has_pquotino(&mp->m_sb) ||
768 				       !XFS_IS_PQUOTA_ON(mp));
769 				ASSERT(mask & ATTR_GID);
770 				ASSERT(gdqp);
771 				olddquot2 = xfs_qm_vop_chown(tp, ip,
772 							&ip->i_gdquot, gdqp);
773 			}
774 			inode->i_gid = gid;
775 		}
776 	}
777 
778 	if (mask & ATTR_MODE)
779 		xfs_setattr_mode(ip, iattr);
780 	if (mask & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
781 		xfs_setattr_time(ip, iattr);
782 
783 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
784 
785 	XFS_STATS_INC(mp, xs_ig_attrchg);
786 
787 	if (mp->m_flags & XFS_MOUNT_WSYNC)
788 		xfs_trans_set_sync(tp);
789 	error = xfs_trans_commit(tp);
790 
791 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
792 
793 	/*
794 	 * Release any dquot(s) the inode had kept before chown.
795 	 */
796 	xfs_qm_dqrele(olddquot1);
797 	xfs_qm_dqrele(olddquot2);
798 	xfs_qm_dqrele(udqp);
799 	xfs_qm_dqrele(gdqp);
800 
801 	if (error)
802 		return error;
803 
804 	/*
805 	 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
806 	 * 	     update.  We could avoid this with linked transactions
807 	 * 	     and passing down the transaction pointer all the way
808 	 *	     to attr_set.  No previous user of the generic
809 	 * 	     Posix ACL code seems to care about this issue either.
810 	 */
811 	if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
812 		error = posix_acl_chmod(inode, inode->i_mode);
813 		if (error)
814 			return error;
815 	}
816 
817 	return 0;
818 
819 out_cancel:
820 	xfs_trans_cancel(tp);
821 	xfs_iunlock(ip, XFS_ILOCK_EXCL);
822 out_dqrele:
823 	xfs_qm_dqrele(udqp);
824 	xfs_qm_dqrele(gdqp);
825 	return error;
826 }
827 
828 int
829 xfs_vn_setattr_nonsize(
830 	struct dentry		*dentry,
831 	struct iattr		*iattr)
832 {
833 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
834 	int error;
835 
836 	trace_xfs_setattr(ip);
837 
838 	error = xfs_vn_change_ok(dentry, iattr);
839 	if (error)
840 		return error;
841 	return xfs_setattr_nonsize(ip, iattr, 0);
842 }
843 
844 /*
845  * Truncate file.  Must have write permission and not be a directory.
846  *
847  * Caution: The caller of this function is responsible for calling
848  * setattr_prepare() or otherwise verifying the change is fine.
849  */
850 STATIC int
851 xfs_setattr_size(
852 	struct xfs_inode	*ip,
853 	struct iattr		*iattr)
854 {
855 	struct xfs_mount	*mp = ip->i_mount;
856 	struct inode		*inode = VFS_I(ip);
857 	xfs_off_t		oldsize, newsize;
858 	struct xfs_trans	*tp;
859 	int			error;
860 	uint			lock_flags = 0;
861 	bool			did_zeroing = false;
862 
863 	ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
864 	ASSERT(xfs_isilocked(ip, XFS_MMAPLOCK_EXCL));
865 	ASSERT(S_ISREG(inode->i_mode));
866 	ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
867 		ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
868 
869 	oldsize = inode->i_size;
870 	newsize = iattr->ia_size;
871 
872 	/*
873 	 * Short circuit the truncate case for zero length files.
874 	 */
875 	if (newsize == 0 && oldsize == 0 && ip->i_df.if_nextents == 0) {
876 		if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
877 			return 0;
878 
879 		/*
880 		 * Use the regular setattr path to update the timestamps.
881 		 */
882 		iattr->ia_valid &= ~ATTR_SIZE;
883 		return xfs_setattr_nonsize(ip, iattr, 0);
884 	}
885 
886 	/*
887 	 * Make sure that the dquots are attached to the inode.
888 	 */
889 	error = xfs_qm_dqattach(ip);
890 	if (error)
891 		return error;
892 
893 	/*
894 	 * Wait for all direct I/O to complete.
895 	 */
896 	inode_dio_wait(inode);
897 
898 	/*
899 	 * File data changes must be complete before we start the transaction to
900 	 * modify the inode.  This needs to be done before joining the inode to
901 	 * the transaction because the inode cannot be unlocked once it is a
902 	 * part of the transaction.
903 	 *
904 	 * Start with zeroing any data beyond EOF that we may expose on file
905 	 * extension, or zeroing out the rest of the block on a downward
906 	 * truncate.
907 	 */
908 	if (newsize > oldsize) {
909 		trace_xfs_zero_eof(ip, oldsize, newsize - oldsize);
910 		error = iomap_zero_range(inode, oldsize, newsize - oldsize,
911 				&did_zeroing, &xfs_buffered_write_iomap_ops);
912 	} else {
913 		error = iomap_truncate_page(inode, newsize, &did_zeroing,
914 				&xfs_buffered_write_iomap_ops);
915 	}
916 
917 	if (error)
918 		return error;
919 
920 	/*
921 	 * We've already locked out new page faults, so now we can safely remove
922 	 * pages from the page cache knowing they won't get refaulted until we
923 	 * drop the XFS_MMAP_EXCL lock after the extent manipulations are
924 	 * complete. The truncate_setsize() call also cleans partial EOF page
925 	 * PTEs on extending truncates and hence ensures sub-page block size
926 	 * filesystems are correctly handled, too.
927 	 *
928 	 * We have to do all the page cache truncate work outside the
929 	 * transaction context as the "lock" order is page lock->log space
930 	 * reservation as defined by extent allocation in the writeback path.
931 	 * Hence a truncate can fail with ENOMEM from xfs_trans_alloc(), but
932 	 * having already truncated the in-memory version of the file (i.e. made
933 	 * user visible changes). There's not much we can do about this, except
934 	 * to hope that the caller sees ENOMEM and retries the truncate
935 	 * operation.
936 	 *
937 	 * And we update in-core i_size and truncate page cache beyond newsize
938 	 * before writeback the [di_size, newsize] range, so we're guaranteed
939 	 * not to write stale data past the new EOF on truncate down.
940 	 */
941 	truncate_setsize(inode, newsize);
942 
943 	/*
944 	 * We are going to log the inode size change in this transaction so
945 	 * any previous writes that are beyond the on disk EOF and the new
946 	 * EOF that have not been written out need to be written here.  If we
947 	 * do not write the data out, we expose ourselves to the null files
948 	 * problem. Note that this includes any block zeroing we did above;
949 	 * otherwise those blocks may not be zeroed after a crash.
950 	 */
951 	if (did_zeroing ||
952 	    (newsize > ip->i_d.di_size && oldsize != ip->i_d.di_size)) {
953 		error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
954 						ip->i_d.di_size, newsize - 1);
955 		if (error)
956 			return error;
957 	}
958 
959 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
960 	if (error)
961 		return error;
962 
963 	lock_flags |= XFS_ILOCK_EXCL;
964 	xfs_ilock(ip, XFS_ILOCK_EXCL);
965 	xfs_trans_ijoin(tp, ip, 0);
966 
967 	/*
968 	 * Only change the c/mtime if we are changing the size or we are
969 	 * explicitly asked to change it.  This handles the semantic difference
970 	 * between truncate() and ftruncate() as implemented in the VFS.
971 	 *
972 	 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
973 	 * special case where we need to update the times despite not having
974 	 * these flags set.  For all other operations the VFS set these flags
975 	 * explicitly if it wants a timestamp update.
976 	 */
977 	if (newsize != oldsize &&
978 	    !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
979 		iattr->ia_ctime = iattr->ia_mtime =
980 			current_time(inode);
981 		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
982 	}
983 
984 	/*
985 	 * The first thing we do is set the size to new_size permanently on
986 	 * disk.  This way we don't have to worry about anyone ever being able
987 	 * to look at the data being freed even in the face of a crash.
988 	 * What we're getting around here is the case where we free a block, it
989 	 * is allocated to another file, it is written to, and then we crash.
990 	 * If the new data gets written to the file but the log buffers
991 	 * containing the free and reallocation don't, then we'd end up with
992 	 * garbage in the blocks being freed.  As long as we make the new size
993 	 * permanent before actually freeing any blocks it doesn't matter if
994 	 * they get written to.
995 	 */
996 	ip->i_d.di_size = newsize;
997 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
998 
999 	if (newsize <= oldsize) {
1000 		error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
1001 		if (error)
1002 			goto out_trans_cancel;
1003 
1004 		/*
1005 		 * Truncated "down", so we're removing references to old data
1006 		 * here - if we delay flushing for a long time, we expose
1007 		 * ourselves unduly to the notorious NULL files problem.  So,
1008 		 * we mark this inode and flush it when the file is closed,
1009 		 * and do not wait the usual (long) time for writeout.
1010 		 */
1011 		xfs_iflags_set(ip, XFS_ITRUNCATED);
1012 
1013 		/* A truncate down always removes post-EOF blocks. */
1014 		xfs_inode_clear_eofblocks_tag(ip);
1015 	}
1016 
1017 	if (iattr->ia_valid & ATTR_MODE)
1018 		xfs_setattr_mode(ip, iattr);
1019 	if (iattr->ia_valid & (ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
1020 		xfs_setattr_time(ip, iattr);
1021 
1022 	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1023 
1024 	XFS_STATS_INC(mp, xs_ig_attrchg);
1025 
1026 	if (mp->m_flags & XFS_MOUNT_WSYNC)
1027 		xfs_trans_set_sync(tp);
1028 
1029 	error = xfs_trans_commit(tp);
1030 out_unlock:
1031 	if (lock_flags)
1032 		xfs_iunlock(ip, lock_flags);
1033 	return error;
1034 
1035 out_trans_cancel:
1036 	xfs_trans_cancel(tp);
1037 	goto out_unlock;
1038 }
1039 
1040 int
1041 xfs_vn_setattr_size(
1042 	struct dentry		*dentry,
1043 	struct iattr		*iattr)
1044 {
1045 	struct xfs_inode	*ip = XFS_I(d_inode(dentry));
1046 	int error;
1047 
1048 	trace_xfs_setattr(ip);
1049 
1050 	error = xfs_vn_change_ok(dentry, iattr);
1051 	if (error)
1052 		return error;
1053 	return xfs_setattr_size(ip, iattr);
1054 }
1055 
1056 STATIC int
1057 xfs_vn_setattr(
1058 	struct dentry		*dentry,
1059 	struct iattr		*iattr)
1060 {
1061 	int			error;
1062 
1063 	if (iattr->ia_valid & ATTR_SIZE) {
1064 		struct inode		*inode = d_inode(dentry);
1065 		struct xfs_inode	*ip = XFS_I(inode);
1066 		uint			iolock;
1067 
1068 		xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
1069 		iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
1070 
1071 		error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
1072 		if (error) {
1073 			xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
1074 			return error;
1075 		}
1076 
1077 		error = xfs_vn_setattr_size(dentry, iattr);
1078 		xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
1079 	} else {
1080 		error = xfs_vn_setattr_nonsize(dentry, iattr);
1081 	}
1082 
1083 	return error;
1084 }
1085 
1086 STATIC int
1087 xfs_vn_update_time(
1088 	struct inode		*inode,
1089 	struct timespec64	*now,
1090 	int			flags)
1091 {
1092 	struct xfs_inode	*ip = XFS_I(inode);
1093 	struct xfs_mount	*mp = ip->i_mount;
1094 	int			log_flags = XFS_ILOG_TIMESTAMP;
1095 	struct xfs_trans	*tp;
1096 	int			error;
1097 
1098 	trace_xfs_update_time(ip);
1099 
1100 	if (inode->i_sb->s_flags & SB_LAZYTIME) {
1101 		if (!((flags & S_VERSION) &&
1102 		      inode_maybe_inc_iversion(inode, false)))
1103 			return generic_update_time(inode, now, flags);
1104 
1105 		/* Capture the iversion update that just occurred */
1106 		log_flags |= XFS_ILOG_CORE;
1107 	}
1108 
1109 	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
1110 	if (error)
1111 		return error;
1112 
1113 	xfs_ilock(ip, XFS_ILOCK_EXCL);
1114 	if (flags & S_CTIME)
1115 		inode->i_ctime = *now;
1116 	if (flags & S_MTIME)
1117 		inode->i_mtime = *now;
1118 	if (flags & S_ATIME)
1119 		inode->i_atime = *now;
1120 
1121 	xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1122 	xfs_trans_log_inode(tp, ip, log_flags);
1123 	return xfs_trans_commit(tp);
1124 }
1125 
1126 STATIC int
1127 xfs_vn_fiemap(
1128 	struct inode		*inode,
1129 	struct fiemap_extent_info *fieinfo,
1130 	u64			start,
1131 	u64			length)
1132 {
1133 	int			error;
1134 
1135 	xfs_ilock(XFS_I(inode), XFS_IOLOCK_SHARED);
1136 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
1137 		fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
1138 		error = iomap_fiemap(inode, fieinfo, start, length,
1139 				&xfs_xattr_iomap_ops);
1140 	} else {
1141 		error = iomap_fiemap(inode, fieinfo, start, length,
1142 				&xfs_read_iomap_ops);
1143 	}
1144 	xfs_iunlock(XFS_I(inode), XFS_IOLOCK_SHARED);
1145 
1146 	return error;
1147 }
1148 
1149 STATIC int
1150 xfs_vn_tmpfile(
1151 	struct inode	*dir,
1152 	struct dentry	*dentry,
1153 	umode_t		mode)
1154 {
1155 	return xfs_generic_create(dir, dentry, mode, 0, true);
1156 }
1157 
1158 static const struct inode_operations xfs_inode_operations = {
1159 	.get_acl		= xfs_get_acl,
1160 	.set_acl		= xfs_set_acl,
1161 	.getattr		= xfs_vn_getattr,
1162 	.setattr		= xfs_vn_setattr,
1163 	.listxattr		= xfs_vn_listxattr,
1164 	.fiemap			= xfs_vn_fiemap,
1165 	.update_time		= xfs_vn_update_time,
1166 };
1167 
1168 static const struct inode_operations xfs_dir_inode_operations = {
1169 	.create			= xfs_vn_create,
1170 	.lookup			= xfs_vn_lookup,
1171 	.link			= xfs_vn_link,
1172 	.unlink			= xfs_vn_unlink,
1173 	.symlink		= xfs_vn_symlink,
1174 	.mkdir			= xfs_vn_mkdir,
1175 	/*
1176 	 * Yes, XFS uses the same method for rmdir and unlink.
1177 	 *
1178 	 * There are some subtile differences deeper in the code,
1179 	 * but we use S_ISDIR to check for those.
1180 	 */
1181 	.rmdir			= xfs_vn_unlink,
1182 	.mknod			= xfs_vn_mknod,
1183 	.rename			= xfs_vn_rename,
1184 	.get_acl		= xfs_get_acl,
1185 	.set_acl		= xfs_set_acl,
1186 	.getattr		= xfs_vn_getattr,
1187 	.setattr		= xfs_vn_setattr,
1188 	.listxattr		= xfs_vn_listxattr,
1189 	.update_time		= xfs_vn_update_time,
1190 	.tmpfile		= xfs_vn_tmpfile,
1191 };
1192 
1193 static const struct inode_operations xfs_dir_ci_inode_operations = {
1194 	.create			= xfs_vn_create,
1195 	.lookup			= xfs_vn_ci_lookup,
1196 	.link			= xfs_vn_link,
1197 	.unlink			= xfs_vn_unlink,
1198 	.symlink		= xfs_vn_symlink,
1199 	.mkdir			= xfs_vn_mkdir,
1200 	/*
1201 	 * Yes, XFS uses the same method for rmdir and unlink.
1202 	 *
1203 	 * There are some subtile differences deeper in the code,
1204 	 * but we use S_ISDIR to check for those.
1205 	 */
1206 	.rmdir			= xfs_vn_unlink,
1207 	.mknod			= xfs_vn_mknod,
1208 	.rename			= xfs_vn_rename,
1209 	.get_acl		= xfs_get_acl,
1210 	.set_acl		= xfs_set_acl,
1211 	.getattr		= xfs_vn_getattr,
1212 	.setattr		= xfs_vn_setattr,
1213 	.listxattr		= xfs_vn_listxattr,
1214 	.update_time		= xfs_vn_update_time,
1215 	.tmpfile		= xfs_vn_tmpfile,
1216 };
1217 
1218 static const struct inode_operations xfs_symlink_inode_operations = {
1219 	.get_link		= xfs_vn_get_link,
1220 	.getattr		= xfs_vn_getattr,
1221 	.setattr		= xfs_vn_setattr,
1222 	.listxattr		= xfs_vn_listxattr,
1223 	.update_time		= xfs_vn_update_time,
1224 };
1225 
1226 static const struct inode_operations xfs_inline_symlink_inode_operations = {
1227 	.get_link		= xfs_vn_get_link_inline,
1228 	.getattr		= xfs_vn_getattr,
1229 	.setattr		= xfs_vn_setattr,
1230 	.listxattr		= xfs_vn_listxattr,
1231 	.update_time		= xfs_vn_update_time,
1232 };
1233 
1234 /* Figure out if this file actually supports DAX. */
1235 static bool
1236 xfs_inode_supports_dax(
1237 	struct xfs_inode	*ip)
1238 {
1239 	struct xfs_mount	*mp = ip->i_mount;
1240 
1241 	/* Only supported on regular files. */
1242 	if (!S_ISREG(VFS_I(ip)->i_mode))
1243 		return false;
1244 
1245 	/* Only supported on non-reflinked files. */
1246 	if (xfs_is_reflink_inode(ip))
1247 		return false;
1248 
1249 	/* Block size must match page size */
1250 	if (mp->m_sb.sb_blocksize != PAGE_SIZE)
1251 		return false;
1252 
1253 	/* Device has to support DAX too. */
1254 	return xfs_inode_buftarg(ip)->bt_daxdev != NULL;
1255 }
1256 
1257 static bool
1258 xfs_inode_should_enable_dax(
1259 	struct xfs_inode *ip)
1260 {
1261 	if (!IS_ENABLED(CONFIG_FS_DAX))
1262 		return false;
1263 	if (ip->i_mount->m_flags & XFS_MOUNT_DAX_NEVER)
1264 		return false;
1265 	if (!xfs_inode_supports_dax(ip))
1266 		return false;
1267 	if (ip->i_mount->m_flags & XFS_MOUNT_DAX_ALWAYS)
1268 		return true;
1269 	if (ip->i_d.di_flags2 & XFS_DIFLAG2_DAX)
1270 		return true;
1271 	return false;
1272 }
1273 
1274 void
1275 xfs_diflags_to_iflags(
1276 	struct xfs_inode	*ip,
1277 	bool init)
1278 {
1279 	struct inode            *inode = VFS_I(ip);
1280 	unsigned int            xflags = xfs_ip2xflags(ip);
1281 	unsigned int            flags = 0;
1282 
1283 	ASSERT(!(IS_DAX(inode) && init));
1284 
1285 	if (xflags & FS_XFLAG_IMMUTABLE)
1286 		flags |= S_IMMUTABLE;
1287 	if (xflags & FS_XFLAG_APPEND)
1288 		flags |= S_APPEND;
1289 	if (xflags & FS_XFLAG_SYNC)
1290 		flags |= S_SYNC;
1291 	if (xflags & FS_XFLAG_NOATIME)
1292 		flags |= S_NOATIME;
1293 	if (init && xfs_inode_should_enable_dax(ip))
1294 		flags |= S_DAX;
1295 
1296 	/*
1297 	 * S_DAX can only be set during inode initialization and is never set by
1298 	 * the VFS, so we cannot mask off S_DAX in i_flags.
1299 	 */
1300 	inode->i_flags &= ~(S_IMMUTABLE | S_APPEND | S_SYNC | S_NOATIME);
1301 	inode->i_flags |= flags;
1302 }
1303 
1304 /*
1305  * Initialize the Linux inode.
1306  *
1307  * When reading existing inodes from disk this is called directly from xfs_iget,
1308  * when creating a new inode it is called from xfs_ialloc after setting up the
1309  * inode. These callers have different criteria for clearing XFS_INEW, so leave
1310  * it up to the caller to deal with unlocking the inode appropriately.
1311  */
1312 void
1313 xfs_setup_inode(
1314 	struct xfs_inode	*ip)
1315 {
1316 	struct inode		*inode = &ip->i_vnode;
1317 	gfp_t			gfp_mask;
1318 
1319 	inode->i_ino = ip->i_ino;
1320 	inode->i_state = I_NEW;
1321 
1322 	inode_sb_list_add(inode);
1323 	/* make the inode look hashed for the writeback code */
1324 	inode_fake_hash(inode);
1325 
1326 	i_size_write(inode, ip->i_d.di_size);
1327 	xfs_diflags_to_iflags(ip, true);
1328 
1329 	if (S_ISDIR(inode->i_mode)) {
1330 		/*
1331 		 * We set the i_rwsem class here to avoid potential races with
1332 		 * lockdep_annotate_inode_mutex_key() reinitialising the lock
1333 		 * after a filehandle lookup has already found the inode in
1334 		 * cache before it has been unlocked via unlock_new_inode().
1335 		 */
1336 		lockdep_set_class(&inode->i_rwsem,
1337 				  &inode->i_sb->s_type->i_mutex_dir_key);
1338 		lockdep_set_class(&ip->i_lock.mr_lock, &xfs_dir_ilock_class);
1339 	} else {
1340 		lockdep_set_class(&ip->i_lock.mr_lock, &xfs_nondir_ilock_class);
1341 	}
1342 
1343 	/*
1344 	 * Ensure all page cache allocations are done from GFP_NOFS context to
1345 	 * prevent direct reclaim recursion back into the filesystem and blowing
1346 	 * stacks or deadlocking.
1347 	 */
1348 	gfp_mask = mapping_gfp_mask(inode->i_mapping);
1349 	mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));
1350 
1351 	/*
1352 	 * If there is no attribute fork no ACL can exist on this inode,
1353 	 * and it can't have any file capabilities attached to it either.
1354 	 */
1355 	if (!XFS_IFORK_Q(ip)) {
1356 		inode_has_no_xattr(inode);
1357 		cache_no_acl(inode);
1358 	}
1359 }
1360 
1361 void
1362 xfs_setup_iops(
1363 	struct xfs_inode	*ip)
1364 {
1365 	struct inode		*inode = &ip->i_vnode;
1366 
1367 	switch (inode->i_mode & S_IFMT) {
1368 	case S_IFREG:
1369 		inode->i_op = &xfs_inode_operations;
1370 		inode->i_fop = &xfs_file_operations;
1371 		if (IS_DAX(inode))
1372 			inode->i_mapping->a_ops = &xfs_dax_aops;
1373 		else
1374 			inode->i_mapping->a_ops = &xfs_address_space_operations;
1375 		break;
1376 	case S_IFDIR:
1377 		if (xfs_sb_version_hasasciici(&XFS_M(inode->i_sb)->m_sb))
1378 			inode->i_op = &xfs_dir_ci_inode_operations;
1379 		else
1380 			inode->i_op = &xfs_dir_inode_operations;
1381 		inode->i_fop = &xfs_dir_file_operations;
1382 		break;
1383 	case S_IFLNK:
1384 		if (ip->i_df.if_flags & XFS_IFINLINE)
1385 			inode->i_op = &xfs_inline_symlink_inode_operations;
1386 		else
1387 			inode->i_op = &xfs_symlink_inode_operations;
1388 		break;
1389 	default:
1390 		inode->i_op = &xfs_inode_operations;
1391 		init_special_inode(inode, inode->i_mode, inode->i_rdev);
1392 		break;
1393 	}
1394 }
1395