fs/xfs/libxfs/xfs_inode_fork.h

   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_FORK_H__
   7 #define __XFS_INODE_FORK_H__
   8
   9 struct xfs_inode_log_item;
  10 struct xfs_dinode;
  11
  12 /*
  13  * File incore extent information, present for each of data & attr forks.
  14  */
  15 struct xfs_ifork {
  16         int64_t                 if_bytes;       /* bytes in if_data */
  17         struct xfs_btree_block  *if_broot;      /* file's incore btree root */
  18         unsigned int            if_seq;         /* fork mod counter */
  19         int                     if_height;      /* height of the extent tree */
  20         void                    *if_data;       /* extent tree root or
  21                                                    inline data */
  22         xfs_extnum_t            if_nextents;    /* # of extents in this fork */
  23         short                   if_broot_bytes; /* bytes allocated for root */
  24         int8_t                  if_format;      /* format of this fork */
  25         uint8_t                 if_needextents; /* extents have not been read */
  26 };
  27
  28 /*
  29  * Worst-case increase in the fork extent count when we're adding a single
  30  * extent to a fork and there's no possibility of splitting an existing mapping.
  31  */
  32 #define XFS_IEXT_ADD_NOSPLIT_CNT        (1)
  33
  34 /*
  35  * Punching out an extent from the middle of an existing extent can cause the
  36  * extent count to increase by 1.
  37  * i.e. | Old extent | Hole | Old extent |
  38  */
  39 #define XFS_IEXT_PUNCH_HOLE_CNT         (1)
  40
  41 /*
  42  * Adding/removing an xattr can cause XFS_DA_NODE_MAXDEPTH extents to
  43  * be added. One extra extent for dabtree in case a local attr is
  44  * large enough to cause a double split.  It can also cause extent
  45  * count to increase proportional to the size of a remote xattr's
  46  * value.
  47  */
  48 #define XFS_IEXT_ATTR_MANIP_CNT(rmt_blks) \
  49         (XFS_DA_NODE_MAXDEPTH + max(1, rmt_blks))
  50
  51 /*
  52  * A write to a sub-interval of an existing unwritten extent causes the original
  53  * extent to be split into 3 extents
  54  * i.e. | Unwritten | Real | Unwritten |
  55  * Hence extent count can increase by 2.
  56  */
  57 #define XFS_IEXT_WRITE_UNWRITTEN_CNT    (2)
  58
  59
  60 /*
  61  * Moving an extent to data fork can cause a sub-interval of an existing extent
  62  * to be unmapped. This will increase extent count by 1. Mapping in the new
  63  * extent can increase the extent count by 1 again i.e.
  64  * | Old extent | New extent | Old extent |
  65  * Hence number of extents increases by 2.
  66  */
  67 #define XFS_IEXT_REFLINK_END_COW_CNT    (2)
  68
  69 /*
  70  * Removing an initial range of source/donor file's extent and adding a new
  71  * extent (from donor/source file) in its place will cause extent count to
  72  * increase by 1.
  73  */
  74 #define XFS_IEXT_SWAP_RMAP_CNT          (1)
  75
  76 /*
  77  * Fork handling.
  78  */
  79 #define XFS_IFORK_MAXEXT(ip, w) \
  80         (xfs_inode_fork_size(ip, w) / sizeof(xfs_bmbt_rec_t))
  81
  82 static inline bool xfs_ifork_has_extents(struct xfs_ifork *ifp)
  83 {
  84         return ifp->if_format == XFS_DINODE_FMT_EXTENTS ||
  85                 ifp->if_format == XFS_DINODE_FMT_BTREE;
  86 }
  87
  88 static inline xfs_extnum_t xfs_ifork_nextents(struct xfs_ifork *ifp)
  89 {
  90         if (!ifp)
  91                 return 0;
  92         return ifp->if_nextents;
  93 }
  94
  95 static inline int8_t xfs_ifork_format(struct xfs_ifork *ifp)
  96 {
  97         if (!ifp)
  98                 return XFS_DINODE_FMT_EXTENTS;
  99         return ifp->if_format;
 100 }
 101
 102 static inline xfs_extnum_t xfs_iext_max_nextents(bool has_large_extent_counts,
 103                                 int whichfork)
 104 {
 105         switch (whichfork) {
 106         case XFS_DATA_FORK:
 107         case XFS_COW_FORK:
 108                 if (has_large_extent_counts)
 109                         return XFS_MAX_EXTCNT_DATA_FORK_LARGE;
 110                 return XFS_MAX_EXTCNT_DATA_FORK_SMALL;
 111
 112         case XFS_ATTR_FORK:
 113                 if (has_large_extent_counts)
 114                         return XFS_MAX_EXTCNT_ATTR_FORK_LARGE;
 115                 return XFS_MAX_EXTCNT_ATTR_FORK_SMALL;
 116
 117         default:
 118                 ASSERT(0);
 119                 return 0;
 120         }
 121 }
 122
 123 static inline xfs_extnum_t
 124 xfs_dfork_data_extents(
 125         struct xfs_dinode       *dip)
 126 {
 127         if (xfs_dinode_has_large_extent_counts(dip))
 128                 return be64_to_cpu(dip->di_big_nextents);
 129
 130         return be32_to_cpu(dip->di_nextents);
 131 }
 132
 133 static inline xfs_extnum_t
 134 xfs_dfork_attr_extents(
 135         struct xfs_dinode       *dip)
 136 {
 137         if (xfs_dinode_has_large_extent_counts(dip))
 138                 return be32_to_cpu(dip->di_big_anextents);
 139
 140         return be16_to_cpu(dip->di_anextents);
 141 }
 142
 143 static inline xfs_extnum_t
 144 xfs_dfork_nextents(
 145         struct xfs_dinode       *dip,
 146         int                     whichfork)
 147 {
 148         switch (whichfork) {
 149         case XFS_DATA_FORK:
 150                 return xfs_dfork_data_extents(dip);
 151         case XFS_ATTR_FORK:
 152                 return xfs_dfork_attr_extents(dip);
 153         default:
 154                 ASSERT(0);
 155                 break;
 156         }
 157
 158         return 0;
 159 }
 160
 161 void xfs_ifork_zap_attr(struct xfs_inode *ip);
 162 void xfs_ifork_init_attr(struct xfs_inode *ip, enum xfs_dinode_fmt format,
 163                 xfs_extnum_t nextents);
 164 struct xfs_ifork *xfs_iext_state_to_fork(struct xfs_inode *ip, int state);
 165
 166 int             xfs_iformat_data_fork(struct xfs_inode *, struct xfs_dinode *);
 167 int             xfs_iformat_attr_fork(struct xfs_inode *, struct xfs_dinode *);
 168 void            xfs_iflush_fork(struct xfs_inode *, struct xfs_dinode *,
 169                                 struct xfs_inode_log_item *, int);
 170 void            xfs_idestroy_fork(struct xfs_ifork *ifp);
 171 void *          xfs_idata_realloc(struct xfs_inode *ip, int64_t byte_diff,
 172                                 int whichfork);
 173 void            xfs_iroot_realloc(struct xfs_inode *, int, int);
 174 int             xfs_iread_extents(struct xfs_trans *, struct xfs_inode *, int);
 175 int             xfs_iextents_copy(struct xfs_inode *, struct xfs_bmbt_rec *,
 176                                   int);
 177 void            xfs_init_local_fork(struct xfs_inode *ip, int whichfork,
 178                                 const void *data, int64_t size);
 179
 180 xfs_extnum_t    xfs_iext_count(struct xfs_ifork *ifp);
 181 void            xfs_iext_insert_raw(struct xfs_ifork *ifp,
 182                         struct xfs_iext_cursor *cur,
 183                         struct xfs_bmbt_irec *irec);
 184 void            xfs_iext_insert(struct xfs_inode *, struct xfs_iext_cursor *cur,
 185                         struct xfs_bmbt_irec *, int);
 186 void            xfs_iext_remove(struct xfs_inode *, struct xfs_iext_cursor *,
 187                         int);
 188 void            xfs_iext_destroy(struct xfs_ifork *);
 189
 190 bool            xfs_iext_lookup_extent(struct xfs_inode *ip,
 191                         struct xfs_ifork *ifp, xfs_fileoff_t bno,
 192                         struct xfs_iext_cursor *cur,
 193                         struct xfs_bmbt_irec *gotp);
 194 bool            xfs_iext_lookup_extent_before(struct xfs_inode *ip,
 195                         struct xfs_ifork *ifp, xfs_fileoff_t *end,
 196                         struct xfs_iext_cursor *cur,
 197                         struct xfs_bmbt_irec *gotp);
 198 bool            xfs_iext_get_extent(struct xfs_ifork *ifp,
 199                         struct xfs_iext_cursor *cur,
 200                         struct xfs_bmbt_irec *gotp);
 201 void            xfs_iext_update_extent(struct xfs_inode *ip, int state,
 202                         struct xfs_iext_cursor *cur,
 203                         struct xfs_bmbt_irec *gotp);
 204
 205 void            xfs_iext_first(struct xfs_ifork *, struct xfs_iext_cursor *);
 206 void            xfs_iext_last(struct xfs_ifork *, struct xfs_iext_cursor *);
 207 void            xfs_iext_next(struct xfs_ifork *, struct xfs_iext_cursor *);
 208 void            xfs_iext_prev(struct xfs_ifork *, struct xfs_iext_cursor *);
 209
 210 static inline bool xfs_iext_next_extent(struct xfs_ifork *ifp,
 211                 struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *gotp)
 212 {
 213         xfs_iext_next(ifp, cur);
 214         return xfs_iext_get_extent(ifp, cur, gotp);
 215 }
 216
 217 static inline bool xfs_iext_prev_extent(struct xfs_ifork *ifp,
 218                 struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *gotp)
 219 {
 220         xfs_iext_prev(ifp, cur);
 221         return xfs_iext_get_extent(ifp, cur, gotp);
 222 }
 223
 224 /*
 225  * Return the extent after cur in gotp without updating the cursor.
 226  */
 227 static inline bool xfs_iext_peek_next_extent(struct xfs_ifork *ifp,
 228                 struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *gotp)
 229 {
 230         struct xfs_iext_cursor ncur = *cur;
 231
 232         xfs_iext_next(ifp, &ncur);
 233         return xfs_iext_get_extent(ifp, &ncur, gotp);
 234 }
 235
 236 /*
 237  * Return the extent before cur in gotp without updating the cursor.
 238  */
 239 static inline bool xfs_iext_peek_prev_extent(struct xfs_ifork *ifp,
 240                 struct xfs_iext_cursor *cur, struct xfs_bmbt_irec *gotp)
 241 {
 242         struct xfs_iext_cursor ncur = *cur;
 243
 244         xfs_iext_prev(ifp, &ncur);
 245         return xfs_iext_get_extent(ifp, &ncur, gotp);
 246 }
 247
 248 #define for_each_xfs_iext(ifp, ext, got)                \
 249         for (xfs_iext_first((ifp), (ext));              \
 250              xfs_iext_get_extent((ifp), (ext), (got));  \
 251              xfs_iext_next((ifp), (ext)))
 252
 253 extern struct kmem_cache        *xfs_ifork_cache;
 254
 255 extern void xfs_ifork_init_cow(struct xfs_inode *ip);
 256
 257 int xfs_ifork_verify_local_data(struct xfs_inode *ip);
 258 int xfs_ifork_verify_local_attr(struct xfs_inode *ip);
 259 int xfs_iext_count_extend(struct xfs_trans *tp, struct xfs_inode *ip,
 260                 int whichfork, uint nr_to_add);
 261 bool xfs_ifork_is_realtime(struct xfs_inode *ip, int whichfork);
 262
 263 /* returns true if the fork has extents but they are not read in yet. */
 264 static inline bool xfs_need_iread_extents(const struct xfs_ifork *ifp)
 265 {
 266         /* see xfs_iformat_{data,attr}_fork() for needextents semantics */
 267         return smp_load_acquire(&ifp->if_needextents) != 0;
 268 }
 269
 270 #endif  /* __XFS_INODE_FORK_H__ */