LXR linux/fs/xfs/xfs

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#ifndef __XFS_INODE_H__
   7#define __XFS_INODE_H__
   8
   9#include "xfs_inode_buf.h"
  10#include "xfs_inode_fork.h"
  11
  12/*
  13 * Kernel only inode definitions
  14 */
  15struct xfs_dinode;
  16struct xfs_inode;
  17struct xfs_buf;
  18struct xfs_defer_ops;
  19struct xfs_bmbt_irec;
  20struct xfs_inode_log_item;
  21struct xfs_mount;
  22struct xfs_trans;
  23struct xfs_dquot;
  24
  25typedef struct xfs_inode {
  26        /* Inode linking and identification information. */
  27        struct xfs_mount        *i_mount;       /* fs mount struct ptr */
  28        struct xfs_dquot        *i_udquot;      /* user dquot */
  29        struct xfs_dquot        *i_gdquot;      /* group dquot */
  30        struct xfs_dquot        *i_pdquot;      /* project dquot */
  31
  32        /* Inode location stuff */
  33        xfs_ino_t               i_ino;          /* inode number (agno/agino)*/
  34        struct xfs_imap         i_imap;         /* location for xfs_imap() */
  35
  36        /* Extent information. */
  37        xfs_ifork_t             *i_afp;         /* attribute fork pointer */
  38        xfs_ifork_t             *i_cowfp;       /* copy on write extents */
  39        xfs_ifork_t             i_df;           /* data fork */
  40
  41        /* operations vectors */
  42        const struct xfs_dir_ops *d_ops;                /* directory ops vector */
  43
  44        /* Transaction and locking information. */
  45        struct xfs_inode_log_item *i_itemp;     /* logging information */
  46        mrlock_t                i_lock;         /* inode lock */
  47        mrlock_t                i_mmaplock;     /* inode mmap IO lock */
  48        atomic_t                i_pincount;     /* inode pin count */
  49        spinlock_t              i_flags_lock;   /* inode i_flags lock */
  50        /* Miscellaneous state. */
  51        unsigned long           i_flags;        /* see defined flags below */
  52        unsigned int            i_delayed_blks; /* count of delay alloc blks */
  53
  54        struct xfs_icdinode     i_d;            /* most of ondisk inode */
  55
  56        xfs_extnum_t            i_cnextents;    /* # of extents in cow fork */
  57        unsigned int            i_cformat;      /* format of cow fork */
  58
  59        /* VFS inode */
  60        struct inode            i_vnode;        /* embedded VFS inode */
  61} xfs_inode_t;
  62
  63/* Convert from vfs inode to xfs inode */
  64static inline struct xfs_inode *XFS_I(struct inode *inode)
  65{
  66        return container_of(inode, struct xfs_inode, i_vnode);
  67}
  68
  69/* convert from xfs inode to vfs inode */
  70static inline struct inode *VFS_I(struct xfs_inode *ip)
  71{
  72        return &ip->i_vnode;
  73}
  74
  75/*
  76 * For regular files we only update the on-disk filesize when actually
  77 * writing data back to disk.  Until then only the copy in the VFS inode
  78 * is uptodate.
  79 */
  80static inline xfs_fsize_t XFS_ISIZE(struct xfs_inode *ip)
  81{
  82        if (S_ISREG(VFS_I(ip)->i_mode))
  83                return i_size_read(VFS_I(ip));
  84        return ip->i_d.di_size;
  85}
  86
  87/*
  88 * If this I/O goes past the on-disk inode size update it unless it would
  89 * be past the current in-core inode size.
  90 */
  91static inline xfs_fsize_t
  92xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)
  93{
  94        xfs_fsize_t i_size = i_size_read(VFS_I(ip));
  95
  96        if (new_size > i_size || new_size < 0)
  97                new_size = i_size;
  98        return new_size > ip->i_d.di_size ? new_size : 0;
  99}
 100
 101/*
 102 * i_flags helper functions
 103 */
 104static inline void
 105__xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
 106{
 107        ip->i_flags |= flags;
 108}
 109
 110static inline void
 111xfs_iflags_set(xfs_inode_t *ip, unsigned short flags)
 112{
 113        spin_lock(&ip->i_flags_lock);
 114        __xfs_iflags_set(ip, flags);
 115        spin_unlock(&ip->i_flags_lock);
 116}
 117
 118static inline void
 119xfs_iflags_clear(xfs_inode_t *ip, unsigned short flags)
 120{
 121        spin_lock(&ip->i_flags_lock);
 122        ip->i_flags &= ~flags;
 123        spin_unlock(&ip->i_flags_lock);
 124}
 125
 126static inline int
 127__xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 128{
 129        return (ip->i_flags & flags);
 130}
 131
 132static inline int
 133xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 134{
 135        int ret;
 136        spin_lock(&ip->i_flags_lock);
 137        ret = __xfs_iflags_test(ip, flags);
 138        spin_unlock(&ip->i_flags_lock);
 139        return ret;
 140}
 141
 142static inline int
 143xfs_iflags_test_and_clear(xfs_inode_t *ip, unsigned short flags)
 144{
 145        int ret;
 146
 147        spin_lock(&ip->i_flags_lock);
 148        ret = ip->i_flags & flags;
 149        if (ret)
 150                ip->i_flags &= ~flags;
 151        spin_unlock(&ip->i_flags_lock);
 152        return ret;
 153}
 154
 155static inline int
 156xfs_iflags_test_and_set(xfs_inode_t *ip, unsigned short flags)
 157{
 158        int ret;
 159
 160        spin_lock(&ip->i_flags_lock);
 161        ret = ip->i_flags & flags;
 162        if (!ret)
 163                ip->i_flags |= flags;
 164        spin_unlock(&ip->i_flags_lock);
 165        return ret;
 166}
 167
 168/*
 169 * Project quota id helpers (previously projid was 16bit only
 170 * and using two 16bit values to hold new 32bit projid was chosen
 171 * to retain compatibility with "old" filesystems).
 172 */
 173static inline prid_t
 174xfs_get_projid(struct xfs_inode *ip)
 175{
 176        return (prid_t)ip->i_d.di_projid_hi << 16 | ip->i_d.di_projid_lo;
 177}
 178
 179static inline void
 180xfs_set_projid(struct xfs_inode *ip,
 181                prid_t projid)
 182{
 183        ip->i_d.di_projid_hi = (uint16_t) (projid >> 16);
 184        ip->i_d.di_projid_lo = (uint16_t) (projid & 0xffff);
 185}
 186
 187static inline prid_t
 188xfs_get_initial_prid(struct xfs_inode *dp)
 189{
 190        if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
 191                return xfs_get_projid(dp);
 192
 193        return XFS_PROJID_DEFAULT;
 194}
 195
 196static inline bool xfs_is_reflink_inode(struct xfs_inode *ip)
 197{
 198        return ip->i_d.di_flags2 & XFS_DIFLAG2_REFLINK;
 199}
 200
 201/*
 202 * In-core inode flags.
 203 */
 204#define XFS_IRECLAIM            (1 << 0) /* started reclaiming this inode */
 205#define XFS_ISTALE              (1 << 1) /* inode has been staled */
 206#define XFS_IRECLAIMABLE        (1 << 2) /* inode can be reclaimed */
 207#define __XFS_INEW_BIT          3        /* inode has just been allocated */
 208#define XFS_INEW                (1 << __XFS_INEW_BIT)
 209#define XFS_ITRUNCATED          (1 << 5) /* truncated down so flush-on-close */
 210#define XFS_IDIRTY_RELEASE      (1 << 6) /* dirty release already seen */
 211#define __XFS_IFLOCK_BIT        7        /* inode is being flushed right now */
 212#define XFS_IFLOCK              (1 << __XFS_IFLOCK_BIT)
 213#define __XFS_IPINNED_BIT       8        /* wakeup key for zero pin count */
 214#define XFS_IPINNED             (1 << __XFS_IPINNED_BIT)
 215#define XFS_IDONTCACHE          (1 << 9) /* don't cache the inode long term */
 216#define XFS_IEOFBLOCKS          (1 << 10)/* has the preallocblocks tag set */
 217/*
 218 * If this unlinked inode is in the middle of recovery, don't let drop_inode
 219 * truncate and free the inode.  This can happen if we iget the inode during
 220 * log recovery to replay a bmap operation on the inode.
 221 */
 222#define XFS_IRECOVERY           (1 << 11)
 223#define XFS_ICOWBLOCKS          (1 << 12)/* has the cowblocks tag set */
 224
 225/*
 226 * Per-lifetime flags need to be reset when re-using a reclaimable inode during
 227 * inode lookup. This prevents unintended behaviour on the new inode from
 228 * ocurring.
 229 */
 230#define XFS_IRECLAIM_RESET_FLAGS        \
 231        (XFS_IRECLAIMABLE | XFS_IRECLAIM | \
 232         XFS_IDIRTY_RELEASE | XFS_ITRUNCATED)
 233
 234/*
 235 * Synchronize processes attempting to flush the in-core inode back to disk.
 236 */
 237
 238static inline int xfs_isiflocked(struct xfs_inode *ip)
 239{
 240        return xfs_iflags_test(ip, XFS_IFLOCK);
 241}
 242
 243extern void __xfs_iflock(struct xfs_inode *ip);
 244
 245static inline int xfs_iflock_nowait(struct xfs_inode *ip)
 246{
 247        return !xfs_iflags_test_and_set(ip, XFS_IFLOCK);
 248}
 249
 250static inline void xfs_iflock(struct xfs_inode *ip)
 251{
 252        if (!xfs_iflock_nowait(ip))
 253                __xfs_iflock(ip);
 254}
 255
 256static inline void xfs_ifunlock(struct xfs_inode *ip)
 257{
 258        ASSERT(xfs_isiflocked(ip));
 259        xfs_iflags_clear(ip, XFS_IFLOCK);
 260        smp_mb();
 261        wake_up_bit(&ip->i_flags, __XFS_IFLOCK_BIT);
 262}
 263
 264/*
 265 * Flags for inode locking.
 266 * Bit ranges:  1<<1  - 1<<16-1 -- iolock/ilock modes (bitfield)
 267 *              1<<16 - 1<<32-1 -- lockdep annotation (integers)
 268 */
 269#define XFS_IOLOCK_EXCL         (1<<0)
 270#define XFS_IOLOCK_SHARED       (1<<1)
 271#define XFS_ILOCK_EXCL          (1<<2)
 272#define XFS_ILOCK_SHARED        (1<<3)
 273#define XFS_MMAPLOCK_EXCL       (1<<4)
 274#define XFS_MMAPLOCK_SHARED     (1<<5)
 275
 276#define XFS_LOCK_MASK           (XFS_IOLOCK_EXCL | XFS_IOLOCK_SHARED \
 277                                | XFS_ILOCK_EXCL | XFS_ILOCK_SHARED \
 278                                | XFS_MMAPLOCK_EXCL | XFS_MMAPLOCK_SHARED)
 279
 280#define XFS_LOCK_FLAGS \
 281        { XFS_IOLOCK_EXCL,      "IOLOCK_EXCL" }, \
 282        { XFS_IOLOCK_SHARED,    "IOLOCK_SHARED" }, \
 283        { XFS_ILOCK_EXCL,       "ILOCK_EXCL" }, \
 284        { XFS_ILOCK_SHARED,     "ILOCK_SHARED" }, \
 285        { XFS_MMAPLOCK_EXCL,    "MMAPLOCK_EXCL" }, \
 286        { XFS_MMAPLOCK_SHARED,  "MMAPLOCK_SHARED" }
 287
 288
 289/*
 290 * Flags for lockdep annotations.
 291 *
 292 * XFS_LOCK_PARENT - for directory operations that require locking a
 293 * parent directory inode and a child entry inode. IOLOCK requires nesting,
 294 * MMAPLOCK does not support this class, ILOCK requires a single subclass
 295 * to differentiate parent from child.
 296 *
 297 * XFS_LOCK_RTBITMAP/XFS_LOCK_RTSUM - the realtime device bitmap and summary
 298 * inodes do not participate in the normal lock order, and thus have their
 299 * own subclasses.
 300 *
 301 * XFS_LOCK_INUMORDER - for locking several inodes at the some time
 302 * with xfs_lock_inodes().  This flag is used as the starting subclass
 303 * and each subsequent lock acquired will increment the subclass by one.
 304 * However, MAX_LOCKDEP_SUBCLASSES == 8, which means we are greatly
 305 * limited to the subclasses we can represent via nesting. We need at least
 306 * 5 inodes nest depth for the ILOCK through rename, and we also have to support
 307 * XFS_ILOCK_PARENT, which gives 6 subclasses. Then we have XFS_ILOCK_RTBITMAP
 308 * and XFS_ILOCK_RTSUM, which are another 2 unique subclasses, so that's all
 309 * 8 subclasses supported by lockdep.
 310 *
 311 * This also means we have to number the sub-classes in the lowest bits of
 312 * the mask we keep, and we have to ensure we never exceed 3 bits of lockdep
 313 * mask and we can't use bit-masking to build the subclasses. What a mess.
 314 *
 315 * Bit layout:
 316 *
 317 * Bit          Lock Region
 318 * 16-19        XFS_IOLOCK_SHIFT dependencies
 319 * 20-23        XFS_MMAPLOCK_SHIFT dependencies
 320 * 24-31        XFS_ILOCK_SHIFT dependencies
 321 *
 322 * IOLOCK values
 323 *
 324 * 0-3          subclass value
 325 * 4-7          unused
 326 *
 327 * MMAPLOCK values
 328 *
 329 * 0-3          subclass value
 330 * 4-7          unused
 331 *
 332 * ILOCK values
 333 * 0-4          subclass values
 334 * 5            PARENT subclass (not nestable)
 335 * 6            RTBITMAP subclass (not nestable)
 336 * 7            RTSUM subclass (not nestable)
 337 * 
 338 */
 339#define XFS_IOLOCK_SHIFT                16
 340#define XFS_IOLOCK_MAX_SUBCLASS         3
 341#define XFS_IOLOCK_DEP_MASK             0x000f0000
 342
 343#define XFS_MMAPLOCK_SHIFT              20
 344#define XFS_MMAPLOCK_NUMORDER           0
 345#define XFS_MMAPLOCK_MAX_SUBCLASS       3
 346#define XFS_MMAPLOCK_DEP_MASK           0x00f00000
 347
 348#define XFS_ILOCK_SHIFT                 24
 349#define XFS_ILOCK_PARENT_VAL            5
 350#define XFS_ILOCK_MAX_SUBCLASS          (XFS_ILOCK_PARENT_VAL - 1)
 351#define XFS_ILOCK_RTBITMAP_VAL          6
 352#define XFS_ILOCK_RTSUM_VAL             7
 353#define XFS_ILOCK_DEP_MASK              0xff000000
 354#define XFS_ILOCK_PARENT                (XFS_ILOCK_PARENT_VAL << XFS_ILOCK_SHIFT)
 355#define XFS_ILOCK_RTBITMAP              (XFS_ILOCK_RTBITMAP_VAL << XFS_ILOCK_SHIFT)
 356#define XFS_ILOCK_RTSUM                 (XFS_ILOCK_RTSUM_VAL << XFS_ILOCK_SHIFT)
 357
 358#define XFS_LOCK_SUBCLASS_MASK  (XFS_IOLOCK_DEP_MASK | \
 359                                 XFS_MMAPLOCK_DEP_MASK | \
 360                                 XFS_ILOCK_DEP_MASK)
 361
 362#define XFS_IOLOCK_DEP(flags)   (((flags) & XFS_IOLOCK_DEP_MASK) \
 363                                        >> XFS_IOLOCK_SHIFT)
 364#define XFS_MMAPLOCK_DEP(flags) (((flags) & XFS_MMAPLOCK_DEP_MASK) \
 365                                        >> XFS_MMAPLOCK_SHIFT)
 366#define XFS_ILOCK_DEP(flags)    (((flags) & XFS_ILOCK_DEP_MASK) \
 367                                        >> XFS_ILOCK_SHIFT)
 368
 369/*
 370 * Layouts are broken in the BREAK_WRITE case to ensure that
 371 * layout-holders do not collide with local writes. Additionally,
 372 * layouts are broken in the BREAK_UNMAP case to make sure the
 373 * layout-holder has a consistent view of the file's extent map. While
 374 * BREAK_WRITE breaks can be satisfied by recalling FL_LAYOUT leases,
 375 * BREAK_UNMAP breaks additionally require waiting for busy dax-pages to
 376 * go idle.
 377 */
 378enum layout_break_reason {
 379        BREAK_WRITE,
 380        BREAK_UNMAP,
 381};
 382
 383/*
 384 * For multiple groups support: if S_ISGID bit is set in the parent
 385 * directory, group of new file is set to that of the parent, and
 386 * new subdirectory gets S_ISGID bit from parent.
 387 */
 388#define XFS_INHERIT_GID(pip)    \
 389        (((pip)->i_mount->m_flags & XFS_MOUNT_GRPID) || \
 390         (VFS_I(pip)->i_mode & S_ISGID))
 391
 392int             xfs_release(struct xfs_inode *ip);
 393void            xfs_inactive(struct xfs_inode *ip);
 394int             xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
 395                           struct xfs_inode **ipp, struct xfs_name *ci_name);
 396int             xfs_create(struct xfs_inode *dp, struct xfs_name *name,
 397                           umode_t mode, dev_t rdev, struct xfs_inode **ipp);
 398int             xfs_create_tmpfile(struct xfs_inode *dp, umode_t mode,
 399                           struct xfs_inode **ipp);
 400int             xfs_remove(struct xfs_inode *dp, struct xfs_name *name,
 401                           struct xfs_inode *ip);
 402int             xfs_link(struct xfs_inode *tdp, struct xfs_inode *sip,
 403                         struct xfs_name *target_name);
 404int             xfs_rename(struct xfs_inode *src_dp, struct xfs_name *src_name,
 405                           struct xfs_inode *src_ip, struct xfs_inode *target_dp,
 406                           struct xfs_name *target_name,
 407                           struct xfs_inode *target_ip, unsigned int flags);
 408
 409void            xfs_ilock(xfs_inode_t *, uint);
 410int             xfs_ilock_nowait(xfs_inode_t *, uint);
 411void            xfs_iunlock(xfs_inode_t *, uint);
 412void            xfs_ilock_demote(xfs_inode_t *, uint);
 413int             xfs_isilocked(xfs_inode_t *, uint);
 414uint            xfs_ilock_data_map_shared(struct xfs_inode *);
 415uint            xfs_ilock_attr_map_shared(struct xfs_inode *);
 416
 417uint            xfs_ip2xflags(struct xfs_inode *);
 418int             xfs_ifree(struct xfs_trans *, xfs_inode_t *,
 419                           struct xfs_defer_ops *);
 420int             xfs_itruncate_extents_flags(struct xfs_trans **,
 421                                struct xfs_inode *, int, xfs_fsize_t, int);
 422void            xfs_iext_realloc(xfs_inode_t *, int, int);
 423
 424void            xfs_iunpin_wait(xfs_inode_t *);
 425#define xfs_ipincount(ip)       ((unsigned int) atomic_read(&ip->i_pincount))
 426
 427int             xfs_iflush(struct xfs_inode *, struct xfs_buf **);
 428void            xfs_lock_two_inodes(struct xfs_inode *ip0, uint ip0_mode,
 429                                struct xfs_inode *ip1, uint ip1_mode);
 430
 431xfs_extlen_t    xfs_get_extsz_hint(struct xfs_inode *ip);
 432xfs_extlen_t    xfs_get_cowextsz_hint(struct xfs_inode *ip);
 433
 434int             xfs_dir_ialloc(struct xfs_trans **, struct xfs_inode *, umode_t,
 435                               xfs_nlink_t, dev_t, prid_t,
 436                               struct xfs_inode **);
 437
 438static inline int
 439xfs_itruncate_extents(
 440        struct xfs_trans        **tpp,
 441        struct xfs_inode        *ip,
 442        int                     whichfork,
 443        xfs_fsize_t             new_size)
 444{
 445        return xfs_itruncate_extents_flags(tpp, ip, whichfork, new_size, 0);
 446}
 447
 448/* from xfs_file.c */
 449enum xfs_prealloc_flags {
 450        XFS_PREALLOC_SET        = (1 << 1),
 451        XFS_PREALLOC_CLEAR      = (1 << 2),
 452        XFS_PREALLOC_SYNC       = (1 << 3),
 453        XFS_PREALLOC_INVISIBLE  = (1 << 4),
 454};
 455
 456int     xfs_update_prealloc_flags(struct xfs_inode *ip,
 457                                  enum xfs_prealloc_flags flags);
 458int     xfs_break_layouts(struct inode *inode, uint *iolock,
 459                enum layout_break_reason reason);
 460
 461/* from xfs_iops.c */
 462extern void xfs_setup_inode(struct xfs_inode *ip);
 463extern void xfs_setup_iops(struct xfs_inode *ip);
 464
 465/*
 466 * When setting up a newly allocated inode, we need to call
 467 * xfs_finish_inode_setup() once the inode is fully instantiated at
 468 * the VFS level to prevent the rest of the world seeing the inode
 469 * before we've completed instantiation. Otherwise we can do it
 470 * the moment the inode lookup is complete.
 471 */
 472static inline void xfs_finish_inode_setup(struct xfs_inode *ip)
 473{
 474        xfs_iflags_clear(ip, XFS_INEW);
 475        barrier();
 476        unlock_new_inode(VFS_I(ip));
 477        wake_up_bit(&ip->i_flags, __XFS_INEW_BIT);
 478}
 479
 480static inline void xfs_setup_existing_inode(struct xfs_inode *ip)
 481{
 482        xfs_setup_inode(ip);
 483        xfs_setup_iops(ip);
 484        xfs_finish_inode_setup(ip);
 485}
 486
 487#define IHOLD(ip) \
 488do { \
 489        ASSERT(atomic_read(&VFS_I(ip)->i_count) > 0) ; \
 490        ihold(VFS_I(ip)); \
 491        trace_xfs_ihold(ip, _THIS_IP_); \
 492} while (0)
 493
 494#define IRELE(ip) \
 495do { \
 496        trace_xfs_irele(ip, _THIS_IP_); \
 497        iput(VFS_I(ip)); \
 498} while (0)
 499
 500extern struct kmem_zone *xfs_inode_zone;
 501
 502/* The default CoW extent size hint. */
 503#define XFS_DEFAULT_COWEXTSZ_HINT 32
 504
 505bool xfs_inode_verify_forks(struct xfs_inode *ip);
 506
 507#endif  /* __XFS_INODE_H__ */
 508