fs/xfs/xfs_iops.c

   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
  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
  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
  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
 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
 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
 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
 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
 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
 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
 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 *
 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 *
 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
 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
 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
 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
 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 *
 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
 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
 576 xfs_get_atomic_write_attr(
 577         struct xfs_inode        *ip,
 578         unsigned int            *unit_min,
 579         unsigned int            *unit_max)
 580 {
 581         if (!xfs_inode_can_atomicwrite(ip)) {
 582                 *unit_min = *unit_max = 0;
 583                 return;
 584         }
 585
 586         *unit_min = *unit_max = ip->i_mount->m_sb.sb_blocksize;
 587 }
 588
 589 STATIC int
 590 xfs_vn_getattr(
 591         struct mnt_idmap        *idmap,
 592         const struct path       *path,
 593         struct kstat            *stat,
 594         u32                     request_mask,
 595         unsigned int            query_flags)
 596 {
 597         struct inode            *inode = d_inode(path->dentry);
 598         struct xfs_inode        *ip = XFS_I(inode);
 599         struct xfs_mount        *mp = ip->i_mount;
 600         vfsuid_t                vfsuid = i_uid_into_vfsuid(idmap, inode);
 601         vfsgid_t                vfsgid = i_gid_into_vfsgid(idmap, inode);
 602
 603         trace_xfs_getattr(ip);
 604
 605         if (xfs_is_shutdown(mp))
 606                 return -EIO;
 607
 608         stat->size = XFS_ISIZE(ip);
 609         stat->dev = inode->i_sb->s_dev;
 610         stat->mode = inode->i_mode;
 611         stat->nlink = inode->i_nlink;
 612         stat->uid = vfsuid_into_kuid(vfsuid);
 613         stat->gid = vfsgid_into_kgid(vfsgid);
 614         stat->ino = ip->i_ino;
 615         stat->atime = inode_get_atime(inode);
 616
 617         fill_mg_cmtime(stat, request_mask, inode);
 618
 619         stat->blocks = XFS_FSB_TO_BB(mp, ip->i_nblocks + ip->i_delayed_blks);
 620
 621         if (xfs_has_v3inodes(mp)) {
 622                 if (request_mask & STATX_BTIME) {
 623                         stat->result_mask |= STATX_BTIME;
 624                         stat->btime = ip->i_crtime;
 625                 }
 626         }
 627
 628         /*
 629          * Note: If you add another clause to set an attribute flag, please
 630          * update attributes_mask below.
 631          */
 632         if (ip->i_diflags & XFS_DIFLAG_IMMUTABLE)
 633                 stat->attributes |= STATX_ATTR_IMMUTABLE;
 634         if (ip->i_diflags & XFS_DIFLAG_APPEND)
 635                 stat->attributes |= STATX_ATTR_APPEND;
 636         if (ip->i_diflags & XFS_DIFLAG_NODUMP)
 637                 stat->attributes |= STATX_ATTR_NODUMP;
 638
 639         stat->attributes_mask |= (STATX_ATTR_IMMUTABLE |
 640                                   STATX_ATTR_APPEND |
 641                                   STATX_ATTR_NODUMP);
 642
 643         switch (inode->i_mode & S_IFMT) {
 644         case S_IFBLK:
 645         case S_IFCHR:
 646                 stat->blksize = BLKDEV_IOSIZE;
 647                 stat->rdev = inode->i_rdev;
 648                 break;
 649         case S_IFREG:
 650                 if (request_mask & STATX_DIOALIGN) {
 651                         struct xfs_buftarg      *target = xfs_inode_buftarg(ip);
 652                         struct block_device     *bdev = target->bt_bdev;
 653
 654                         stat->result_mask |= STATX_DIOALIGN;
 655                         stat->dio_mem_align = bdev_dma_alignment(bdev) + 1;
 656                         stat->dio_offset_align = bdev_logical_block_size(bdev);
 657                 }
 658                 if (request_mask & STATX_WRITE_ATOMIC) {
 659                         unsigned int    unit_min, unit_max;
 660
 661                         xfs_get_atomic_write_attr(ip, &unit_min,
 662                                         &unit_max);
 663                         generic_fill_statx_atomic_writes(stat,
 664                                         unit_min, unit_max);
 665                 }
 666                 fallthrough;
 667         default:
 668                 stat->blksize = xfs_stat_blksize(ip);
 669                 stat->rdev = 0;
 670                 break;
 671         }
 672
 673         return 0;
 674 }
 675
 676 static int
 677 xfs_vn_change_ok(
 678         struct mnt_idmap        *idmap,
 679         struct dentry           *dentry,
 680         struct iattr            *iattr)
 681 {
 682         struct xfs_mount        *mp = XFS_I(d_inode(dentry))->i_mount;
 683
 684         if (xfs_is_readonly(mp))
 685                 return -EROFS;
 686
 687         if (xfs_is_shutdown(mp))
 688                 return -EIO;
 689
 690         return setattr_prepare(idmap, dentry, iattr);
 691 }
 692
 693 /*
 694  * Set non-size attributes of an inode.
 695  *
 696  * Caution: The caller of this function is responsible for calling
 697  * setattr_prepare() or otherwise verifying the change is fine.
 698  */
 699 static int
 700 xfs_setattr_nonsize(
 701         struct mnt_idmap        *idmap,
 702         struct dentry           *dentry,
 703         struct xfs_inode        *ip,
 704         struct iattr            *iattr)
 705 {
 706         xfs_mount_t             *mp = ip->i_mount;
 707         struct inode            *inode = VFS_I(ip);
 708         int                     mask = iattr->ia_valid;
 709         xfs_trans_t             *tp;
 710         int                     error;
 711         kuid_t                  uid = GLOBAL_ROOT_UID;
 712         kgid_t                  gid = GLOBAL_ROOT_GID;
 713         struct xfs_dquot        *udqp = NULL, *gdqp = NULL;
 714         struct xfs_dquot        *old_udqp = NULL, *old_gdqp = NULL;
 715
 716         ASSERT((mask & ATTR_SIZE) == 0);
 717
 718         /*
 719          * If disk quotas is on, we make sure that the dquots do exist on disk,
 720          * before we start any other transactions. Trying to do this later
 721          * is messy. We don't care to take a readlock to look at the ids
 722          * in inode here, because we can't hold it across the trans_reserve.
 723          * If the IDs do change before we take the ilock, we're covered
 724          * because the i_*dquot fields will get updated anyway.
 725          */
 726         if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
 727                 uint    qflags = 0;
 728
 729                 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
 730                         uid = from_vfsuid(idmap, i_user_ns(inode),
 731                                           iattr->ia_vfsuid);
 732                         qflags |= XFS_QMOPT_UQUOTA;
 733                 } else {
 734                         uid = inode->i_uid;
 735                 }
 736                 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
 737                         gid = from_vfsgid(idmap, i_user_ns(inode),
 738                                           iattr->ia_vfsgid);
 739                         qflags |= XFS_QMOPT_GQUOTA;
 740                 }  else {
 741                         gid = inode->i_gid;
 742                 }
 743
 744                 /*
 745                  * We take a reference when we initialize udqp and gdqp,
 746                  * so it is important that we never blindly double trip on
 747                  * the same variable. See xfs_create() for an example.
 748                  */
 749                 ASSERT(udqp == NULL);
 750                 ASSERT(gdqp == NULL);
 751                 error = xfs_qm_vop_dqalloc(ip, uid, gid, ip->i_projid,
 752                                            qflags, &udqp, &gdqp, NULL);
 753                 if (error)
 754                         return error;
 755         }
 756
 757         error = xfs_trans_alloc_ichange(ip, udqp, gdqp, NULL,
 758                         has_capability_noaudit(current, CAP_FOWNER), &tp);
 759         if (error)
 760                 goto out_dqrele;
 761
 762         /*
 763          * Register quota modifications in the transaction.  Must be the owner
 764          * or privileged.  These IDs could have changed since we last looked at
 765          * them.  But, we're assured that if the ownership did change while we
 766          * didn't have the inode locked, inode's dquot(s) would have changed
 767          * also.
 768          */
 769         if (XFS_IS_UQUOTA_ON(mp) &&
 770             i_uid_needs_update(idmap, iattr, inode)) {
 771                 ASSERT(udqp);
 772                 old_udqp = xfs_qm_vop_chown(tp, ip, &ip->i_udquot, udqp);
 773         }
 774         if (XFS_IS_GQUOTA_ON(mp) &&
 775             i_gid_needs_update(idmap, iattr, inode)) {
 776                 ASSERT(xfs_has_pquotino(mp) || !XFS_IS_PQUOTA_ON(mp));
 777                 ASSERT(gdqp);
 778                 old_gdqp = xfs_qm_vop_chown(tp, ip, &ip->i_gdquot, gdqp);
 779         }
 780
 781         setattr_copy(idmap, inode, iattr);
 782         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 783
 784         XFS_STATS_INC(mp, xs_ig_attrchg);
 785
 786         if (xfs_has_wsync(mp))
 787                 xfs_trans_set_sync(tp);
 788         error = xfs_trans_commit(tp);
 789
 790         /*
 791          * Release any dquot(s) the inode had kept before chown.
 792          */
 793         xfs_qm_dqrele(old_udqp);
 794         xfs_qm_dqrele(old_gdqp);
 795         xfs_qm_dqrele(udqp);
 796         xfs_qm_dqrele(gdqp);
 797
 798         if (error)
 799                 return error;
 800
 801         /*
 802          * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
 803          *           update.  We could avoid this with linked transactions
 804          *           and passing down the transaction pointer all the way
 805          *           to attr_set.  No previous user of the generic
 806          *           Posix ACL code seems to care about this issue either.
 807          */
 808         if (mask & ATTR_MODE) {
 809                 error = posix_acl_chmod(idmap, dentry, inode->i_mode);
 810                 if (error)
 811                         return error;
 812         }
 813
 814         return 0;
 815
 816 out_dqrele:
 817         xfs_qm_dqrele(udqp);
 818         xfs_qm_dqrele(gdqp);
 819         return error;
 820 }
 821
 822 /*
 823  * Truncate file.  Must have write permission and not be a directory.
 824  *
 825  * Caution: The caller of this function is responsible for calling
 826  * setattr_prepare() or otherwise verifying the change is fine.
 827  */
 828 STATIC int
 829 xfs_setattr_size(
 830         struct mnt_idmap        *idmap,
 831         struct dentry           *dentry,
 832         struct xfs_inode        *ip,
 833         struct iattr            *iattr)
 834 {
 835         struct xfs_mount        *mp = ip->i_mount;
 836         struct inode            *inode = VFS_I(ip);
 837         xfs_off_t               oldsize, newsize;
 838         struct xfs_trans        *tp;
 839         int                     error;
 840         uint                    lock_flags = 0;
 841         uint                    resblks = 0;
 842         bool                    did_zeroing = false;
 843
 844         xfs_assert_ilocked(ip, XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL);
 845         ASSERT(S_ISREG(inode->i_mode));
 846         ASSERT((iattr->ia_valid & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
 847                 ATTR_MTIME_SET|ATTR_TIMES_SET)) == 0);
 848
 849         oldsize = inode->i_size;
 850         newsize = iattr->ia_size;
 851
 852         /*
 853          * Short circuit the truncate case for zero length files.
 854          */
 855         if (newsize == 0 && oldsize == 0 && ip->i_df.if_nextents == 0) {
 856                 if (!(iattr->ia_valid & (ATTR_CTIME|ATTR_MTIME)))
 857                         return 0;
 858
 859                 /*
 860                  * Use the regular setattr path to update the timestamps.
 861                  */
 862                 iattr->ia_valid &= ~ATTR_SIZE;
 863                 return xfs_setattr_nonsize(idmap, dentry, ip, iattr);
 864         }
 865
 866         /*
 867          * Make sure that the dquots are attached to the inode.
 868          */
 869         error = xfs_qm_dqattach(ip);
 870         if (error)
 871                 return error;
 872
 873         /*
 874          * Wait for all direct I/O to complete.
 875          */
 876         inode_dio_wait(inode);
 877
 878         /*
 879          * File data changes must be complete before we start the transaction to
 880          * modify the inode.  This needs to be done before joining the inode to
 881          * the transaction because the inode cannot be unlocked once it is a
 882          * part of the transaction.
 883          *
 884          * Start with zeroing any data beyond EOF that we may expose on file
 885          * extension, or zeroing out the rest of the block on a downward
 886          * truncate.
 887          */
 888         if (newsize > oldsize) {
 889                 trace_xfs_zero_eof(ip, oldsize, newsize - oldsize);
 890                 error = xfs_zero_range(ip, oldsize, newsize - oldsize,
 891                                 &did_zeroing);
 892         } else {
 893                 error = xfs_truncate_page(ip, newsize, &did_zeroing);
 894         }
 895
 896         if (error)
 897                 return error;
 898
 899         /*
 900          * We've already locked out new page faults, so now we can safely remove
 901          * pages from the page cache knowing they won't get refaulted until we
 902          * drop the XFS_MMAP_EXCL lock after the extent manipulations are
 903          * complete. The truncate_setsize() call also cleans partial EOF page
 904          * PTEs on extending truncates and hence ensures sub-page block size
 905          * filesystems are correctly handled, too.
 906          *
 907          * We have to do all the page cache truncate work outside the
 908          * transaction context as the "lock" order is page lock->log space
 909          * reservation as defined by extent allocation in the writeback path.
 910          * Hence a truncate can fail with ENOMEM from xfs_trans_alloc(), but
 911          * having already truncated the in-memory version of the file (i.e. made
 912          * user visible changes). There's not much we can do about this, except
 913          * to hope that the caller sees ENOMEM and retries the truncate
 914          * operation.
 915          *
 916          * And we update in-core i_size and truncate page cache beyond newsize
 917          * before writeback the [i_disk_size, newsize] range, so we're
 918          * guaranteed not to write stale data past the new EOF on truncate down.
 919          */
 920         truncate_setsize(inode, newsize);
 921
 922         /*
 923          * We are going to log the inode size change in this transaction so
 924          * any previous writes that are beyond the on disk EOF and the new
 925          * EOF that have not been written out need to be written here.  If we
 926          * do not write the data out, we expose ourselves to the null files
 927          * problem. Note that this includes any block zeroing we did above;
 928          * otherwise those blocks may not be zeroed after a crash.
 929          */
 930         if (did_zeroing ||
 931             (newsize > ip->i_disk_size && oldsize != ip->i_disk_size)) {
 932                 error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
 933                                                 ip->i_disk_size, newsize - 1);
 934                 if (error)
 935                         return error;
 936         }
 937
 938         /*
 939          * For realtime inode with more than one block rtextsize, we need the
 940          * block reservation for bmap btree block allocations/splits that can
 941          * happen since it could split the tail written extent and convert the
 942          * right beyond EOF one to unwritten.
 943          */
 944         if (xfs_inode_has_bigrtalloc(ip))
 945                 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
 946
 947         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, resblks,
 948                                 0, 0, &tp);
 949         if (error)
 950                 return error;
 951
 952         lock_flags |= XFS_ILOCK_EXCL;
 953         xfs_ilock(ip, XFS_ILOCK_EXCL);
 954         xfs_trans_ijoin(tp, ip, 0);
 955
 956         /*
 957          * Only change the c/mtime if we are changing the size or we are
 958          * explicitly asked to change it.  This handles the semantic difference
 959          * between truncate() and ftruncate() as implemented in the VFS.
 960          *
 961          * The regular truncate() case without ATTR_CTIME and ATTR_MTIME is a
 962          * special case where we need to update the times despite not having
 963          * these flags set.  For all other operations the VFS set these flags
 964          * explicitly if it wants a timestamp update.
 965          */
 966         if (newsize != oldsize &&
 967             !(iattr->ia_valid & (ATTR_CTIME | ATTR_MTIME))) {
 968                 iattr->ia_ctime = iattr->ia_mtime =
 969                         current_time(inode);
 970                 iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME;
 971         }
 972
 973         /*
 974          * The first thing we do is set the size to new_size permanently on
 975          * disk.  This way we don't have to worry about anyone ever being able
 976          * to look at the data being freed even in the face of a crash.
 977          * What we're getting around here is the case where we free a block, it
 978          * is allocated to another file, it is written to, and then we crash.
 979          * If the new data gets written to the file but the log buffers
 980          * containing the free and reallocation don't, then we'd end up with
 981          * garbage in the blocks being freed.  As long as we make the new size
 982          * permanent before actually freeing any blocks it doesn't matter if
 983          * they get written to.
 984          */
 985         ip->i_disk_size = newsize;
 986         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 987
 988         if (newsize <= oldsize) {
 989                 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, newsize);
 990                 if (error)
 991                         goto out_trans_cancel;
 992
 993                 /*
 994                  * Truncated "down", so we're removing references to old data
 995                  * here - if we delay flushing for a long time, we expose
 996                  * ourselves unduly to the notorious NULL files problem.  So,
 997                  * we mark this inode and flush it when the file is closed,
 998                  * and do not wait the usual (long) time for writeout.
 999                  */
1000                 xfs_iflags_set(ip, XFS_ITRUNCATED);
1001
1002                 /* A truncate down always removes post-EOF blocks. */
1003                 xfs_inode_clear_eofblocks_tag(ip);
1004         }
1005
1006         ASSERT(!(iattr->ia_valid & (ATTR_UID | ATTR_GID)));
1007         setattr_copy(idmap, inode, iattr);
1008         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1009
1010         XFS_STATS_INC(mp, xs_ig_attrchg);
1011
1012         if (xfs_has_wsync(mp))
1013                 xfs_trans_set_sync(tp);
1014
1015         error = xfs_trans_commit(tp);
1016 out_unlock:
1017         if (lock_flags)
1018                 xfs_iunlock(ip, lock_flags);
1019         return error;
1020
1021 out_trans_cancel:
1022         xfs_trans_cancel(tp);
1023         goto out_unlock;
1024 }
1025
1026 int
1027 xfs_vn_setattr_size(
1028         struct mnt_idmap        *idmap,
1029         struct dentry           *dentry,
1030         struct iattr            *iattr)
1031 {
1032         struct xfs_inode        *ip = XFS_I(d_inode(dentry));
1033         int error;
1034
1035         trace_xfs_setattr(ip);
1036
1037         error = xfs_vn_change_ok(idmap, dentry, iattr);
1038         if (error)
1039                 return error;
1040         return xfs_setattr_size(idmap, dentry, ip, iattr);
1041 }
1042
1043 STATIC int
1044 xfs_vn_setattr(
1045         struct mnt_idmap        *idmap,
1046         struct dentry           *dentry,
1047         struct iattr            *iattr)
1048 {
1049         struct inode            *inode = d_inode(dentry);
1050         struct xfs_inode        *ip = XFS_I(inode);
1051         int                     error;
1052
1053         if (iattr->ia_valid & ATTR_SIZE) {
1054                 uint                    iolock;
1055
1056                 xfs_ilock(ip, XFS_MMAPLOCK_EXCL);
1057                 iolock = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
1058
1059                 error = xfs_break_layouts(inode, &iolock, BREAK_UNMAP);
1060                 if (error) {
1061                         xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
1062                         return error;
1063                 }
1064
1065                 error = xfs_vn_setattr_size(idmap, dentry, iattr);
1066                 xfs_iunlock(ip, XFS_MMAPLOCK_EXCL);
1067         } else {
1068                 trace_xfs_setattr(ip);
1069
1070                 error = xfs_vn_change_ok(idmap, dentry, iattr);
1071                 if (!error)
1072                         error = xfs_setattr_nonsize(idmap, dentry, ip, iattr);
1073         }
1074
1075         return error;
1076 }
1077
1078 STATIC int
1079 xfs_vn_update_time(
1080         struct inode            *inode,
1081         int                     flags)
1082 {
1083         struct xfs_inode        *ip = XFS_I(inode);
1084         struct xfs_mount        *mp = ip->i_mount;
1085         int                     log_flags = XFS_ILOG_TIMESTAMP;
1086         struct xfs_trans        *tp;
1087         int                     error;
1088         struct timespec64       now;
1089
1090         trace_xfs_update_time(ip);
1091
1092         if (inode->i_sb->s_flags & SB_LAZYTIME) {
1093                 if (!((flags & S_VERSION) &&
1094                       inode_maybe_inc_iversion(inode, false))) {
1095                         generic_update_time(inode, flags);
1096                         return 0;
1097                 }
1098
1099                 /* Capture the iversion update that just occurred */
1100                 log_flags |= XFS_ILOG_CORE;
1101         }
1102
1103         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp);
1104         if (error)
1105                 return error;
1106
1107         xfs_ilock(ip, XFS_ILOCK_EXCL);
1108         if (flags & (S_CTIME|S_MTIME))
1109                 now = inode_set_ctime_current(inode);
1110         else
1111                 now = current_time(inode);
1112
1113         if (flags & S_MTIME)
1114                 inode_set_mtime_to_ts(inode, now);
1115         if (flags & S_ATIME)
1116                 inode_set_atime_to_ts(inode, now);
1117
1118         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1119         xfs_trans_log_inode(tp, ip, log_flags);
1120         return xfs_trans_commit(tp);
1121 }
1122
1123 STATIC int
1124 xfs_vn_fiemap(
1125         struct inode            *inode,
1126         struct fiemap_extent_info *fieinfo,
1127         u64                     start,
1128         u64                     length)
1129 {
1130         int                     error;
1131
1132         xfs_ilock(XFS_I(inode), XFS_IOLOCK_SHARED);
1133         if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
1134                 fieinfo->fi_flags &= ~FIEMAP_FLAG_XATTR;
1135                 error = iomap_fiemap(inode, fieinfo, start, length,
1136                                 &xfs_xattr_iomap_ops);
1137         } else {
1138                 error = iomap_fiemap(inode, fieinfo, start, length,
1139                                 &xfs_read_iomap_ops);
1140         }
1141         xfs_iunlock(XFS_I(inode), XFS_IOLOCK_SHARED);
1142
1143         return error;
1144 }
1145
1146 STATIC int
1147 xfs_vn_tmpfile(
1148         struct mnt_idmap        *idmap,
1149         struct inode            *dir,
1150         struct file             *file,
1151         umode_t                 mode)
1152 {
1153         int err = xfs_generic_create(idmap, dir, file->f_path.dentry, mode, 0, file);
1154
1155         return finish_open_simple(file, err);
1156 }
1157
1158 static const struct inode_operations xfs_inode_operations = {
1159         .get_inode_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         .fileattr_get           = xfs_fileattr_get,
1167         .fileattr_set           = xfs_fileattr_set,
1168 };
1169
1170 static const struct inode_operations xfs_dir_inode_operations = {
1171         .create                 = xfs_vn_create,
1172         .lookup                 = xfs_vn_lookup,
1173         .link                   = xfs_vn_link,
1174         .unlink                 = xfs_vn_unlink,
1175         .symlink                = xfs_vn_symlink,
1176         .mkdir                  = xfs_vn_mkdir,
1177         /*
1178          * Yes, XFS uses the same method for rmdir and unlink.
1179          *
1180          * There are some subtile differences deeper in the code,
1181          * but we use S_ISDIR to check for those.
1182          */
1183         .rmdir                  = xfs_vn_unlink,
1184         .mknod                  = xfs_vn_mknod,
1185         .rename                 = xfs_vn_rename,
1186         .get_inode_acl          = xfs_get_acl,
1187         .set_acl                = xfs_set_acl,
1188         .getattr                = xfs_vn_getattr,
1189         .setattr                = xfs_vn_setattr,
1190         .listxattr              = xfs_vn_listxattr,
1191         .update_time            = xfs_vn_update_time,
1192         .tmpfile                = xfs_vn_tmpfile,
1193         .fileattr_get           = xfs_fileattr_get,
1194         .fileattr_set           = xfs_fileattr_set,
1195 };
1196
1197 static const struct inode_operations xfs_dir_ci_inode_operations = {
1198         .create                 = xfs_vn_create,
1199         .lookup                 = xfs_vn_ci_lookup,
1200         .link                   = xfs_vn_link,
1201         .unlink                 = xfs_vn_unlink,
1202         .symlink                = xfs_vn_symlink,
1203         .mkdir                  = xfs_vn_mkdir,
1204         /*
1205          * Yes, XFS uses the same method for rmdir and unlink.
1206          *
1207          * There are some subtile differences deeper in the code,
1208          * but we use S_ISDIR to check for those.
1209          */
1210         .rmdir                  = xfs_vn_unlink,
1211         .mknod                  = xfs_vn_mknod,
1212         .rename                 = xfs_vn_rename,
1213         .get_inode_acl          = xfs_get_acl,
1214         .set_acl                = xfs_set_acl,
1215         .getattr                = xfs_vn_getattr,
1216         .setattr                = xfs_vn_setattr,
1217         .listxattr              = xfs_vn_listxattr,
1218         .update_time            = xfs_vn_update_time,
1219         .tmpfile                = xfs_vn_tmpfile,
1220         .fileattr_get           = xfs_fileattr_get,
1221         .fileattr_set           = xfs_fileattr_set,
1222 };
1223
1224 static const struct inode_operations xfs_symlink_inode_operations = {
1225         .get_link               = xfs_vn_get_link,
1226         .getattr                = xfs_vn_getattr,
1227         .setattr                = xfs_vn_setattr,
1228         .listxattr              = xfs_vn_listxattr,
1229         .update_time            = xfs_vn_update_time,
1230 };
1231
1232 /* Figure out if this file actually supports DAX. */
1233 static bool
1234 xfs_inode_supports_dax(
1235         struct xfs_inode        *ip)
1236 {
1237         struct xfs_mount        *mp = ip->i_mount;
1238
1239         /* Only supported on regular files. */
1240         if (!S_ISREG(VFS_I(ip)->i_mode))
1241                 return false;
1242
1243         /* Block size must match page size */
1244         if (mp->m_sb.sb_blocksize != PAGE_SIZE)
1245                 return false;
1246
1247         /* Device has to support DAX too. */
1248         return xfs_inode_buftarg(ip)->bt_daxdev != NULL;
1249 }
1250
1251 static bool
1252 xfs_inode_should_enable_dax(
1253         struct xfs_inode *ip)
1254 {
1255         if (!IS_ENABLED(CONFIG_FS_DAX))
1256                 return false;
1257         if (xfs_has_dax_never(ip->i_mount))
1258                 return false;
1259         if (!xfs_inode_supports_dax(ip))
1260                 return false;
1261         if (xfs_has_dax_always(ip->i_mount))
1262                 return true;
1263         if (ip->i_diflags2 & XFS_DIFLAG2_DAX)
1264                 return true;
1265         return false;
1266 }
1267
1268 void
1269 xfs_diflags_to_iflags(
1270         struct xfs_inode        *ip,
1271         bool init)
1272 {
1273         struct inode            *inode = VFS_I(ip);
1274         unsigned int            xflags = xfs_ip2xflags(ip);
1275         unsigned int            flags = 0;
1276
1277         ASSERT(!(IS_DAX(inode) && init));
1278
1279         if (xflags & FS_XFLAG_IMMUTABLE)
1280                 flags |= S_IMMUTABLE;
1281         if (xflags & FS_XFLAG_APPEND)
1282                 flags |= S_APPEND;
1283         if (xflags & FS_XFLAG_SYNC)
1284                 flags |= S_SYNC;
1285         if (xflags & FS_XFLAG_NOATIME)
1286                 flags |= S_NOATIME;
1287         if (init && xfs_inode_should_enable_dax(ip))
1288                 flags |= S_DAX;
1289
1290         /*
1291          * S_DAX can only be set during inode initialization and is never set by
1292          * the VFS, so we cannot mask off S_DAX in i_flags.
1293          */
1294         inode->i_flags &= ~(S_IMMUTABLE | S_APPEND | S_SYNC | S_NOATIME);
1295         inode->i_flags |= flags;
1296 }
1297
1298 /*
1299  * Initialize the Linux inode.
1300  *
1301  * When reading existing inodes from disk this is called directly from xfs_iget,
1302  * when creating a new inode it is called from xfs_init_new_inode after setting
1303  * up the inode. These callers have different criteria for clearing XFS_INEW, so
1304  * leave it up to the caller to deal with unlocking the inode appropriately.
1305  */
1306 void
1307 xfs_setup_inode(
1308         struct xfs_inode        *ip)
1309 {
1310         struct inode            *inode = &ip->i_vnode;
1311         gfp_t                   gfp_mask;
1312         bool                    is_meta = xfs_is_internal_inode(ip);
1313
1314         inode->i_ino = ip->i_ino;
1315         inode->i_state |= I_NEW;
1316
1317         inode_sb_list_add(inode);
1318         /* make the inode look hashed for the writeback code */
1319         inode_fake_hash(inode);
1320
1321         i_size_write(inode, ip->i_disk_size);
1322         xfs_diflags_to_iflags(ip, true);
1323
1324         /*
1325          * Mark our metadata files as private so that LSMs and the ACL code
1326          * don't try to add their own metadata or reason about these files,
1327          * and users cannot ever obtain file handles to them.
1328          */
1329         if (is_meta) {
1330                 inode->i_flags |= S_PRIVATE;
1331                 inode->i_opflags &= ~IOP_XATTR;
1332         }
1333
1334         if (S_ISDIR(inode->i_mode)) {
1335                 /*
1336                  * We set the i_rwsem class here to avoid potential races with
1337                  * lockdep_annotate_inode_mutex_key() reinitialising the lock
1338                  * after a filehandle lookup has already found the inode in
1339                  * cache before it has been unlocked via unlock_new_inode().
1340                  */
1341                 lockdep_set_class(&inode->i_rwsem,
1342                                   &inode->i_sb->s_type->i_mutex_dir_key);
1343                 lockdep_set_class(&ip->i_lock, &xfs_dir_ilock_class);
1344         } else {
1345                 lockdep_set_class(&ip->i_lock, &xfs_nondir_ilock_class);
1346         }
1347
1348         /*
1349          * Ensure all page cache allocations are done from GFP_NOFS context to
1350          * prevent direct reclaim recursion back into the filesystem and blowing
1351          * stacks or deadlocking.
1352          */
1353         gfp_mask = mapping_gfp_mask(inode->i_mapping);
1354         mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));
1355
1356         /*
1357          * For real-time inodes update the stable write flags to that of the RT
1358          * device instead of the data device.
1359          */
1360         if (S_ISREG(inode->i_mode) && XFS_IS_REALTIME_INODE(ip))
1361                 xfs_update_stable_writes(ip);
1362
1363         /*
1364          * If there is no attribute fork no ACL can exist on this inode,
1365          * and it can't have any file capabilities attached to it either.
1366          */
1367         if (!xfs_inode_has_attr_fork(ip)) {
1368                 inode_has_no_xattr(inode);
1369                 cache_no_acl(inode);
1370         }
1371 }
1372
1373 void
1374 xfs_setup_iops(
1375         struct xfs_inode        *ip)
1376 {
1377         struct inode            *inode = &ip->i_vnode;
1378
1379         switch (inode->i_mode & S_IFMT) {
1380         case S_IFREG:
1381                 inode->i_op = &xfs_inode_operations;
1382                 inode->i_fop = &xfs_file_operations;
1383                 if (IS_DAX(inode))
1384                         inode->i_mapping->a_ops = &xfs_dax_aops;
1385                 else
1386                         inode->i_mapping->a_ops = &xfs_address_space_operations;
1387                 break;
1388         case S_IFDIR:
1389                 if (xfs_has_asciici(XFS_M(inode->i_sb)))
1390                         inode->i_op = &xfs_dir_ci_inode_operations;
1391                 else
1392                         inode->i_op = &xfs_dir_inode_operations;
1393                 inode->i_fop = &xfs_dir_file_operations;
1394                 break;
1395         case S_IFLNK:
1396                 inode->i_op = &xfs_symlink_inode_operations;
1397                 break;
1398         default:
1399                 inode->i_op = &xfs_inode_operations;
1400                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
1401                 break;
1402         }
1403 }