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