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