fs/xfs/libxfs/xfs_rmap.h

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2016 Oracle.  All Rights Reserved.
   4  * Author: Darrick J. Wong <darrick.wong@oracle.com>
   5  */
   6 #ifndef __XFS_RMAP_H__
   7 #define __XFS_RMAP_H__
   8
   9 struct xfs_perag;
  10
  11 static inline void
  12 xfs_rmap_ino_bmbt_owner(
  13         struct xfs_owner_info   *oi,
  14         xfs_ino_t               ino,
  15         int                     whichfork)
  16 {
  17         oi->oi_owner = ino;
  18         oi->oi_offset = 0;
  19         oi->oi_flags = XFS_OWNER_INFO_BMBT_BLOCK;
  20         if (whichfork == XFS_ATTR_FORK)
  21                 oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
  22 }
  23
  24 static inline void
  25 xfs_rmap_ino_owner(
  26         struct xfs_owner_info   *oi,
  27         xfs_ino_t               ino,
  28         int                     whichfork,
  29         xfs_fileoff_t           offset)
  30 {
  31         oi->oi_owner = ino;
  32         oi->oi_offset = offset;
  33         oi->oi_flags = 0;
  34         if (whichfork == XFS_ATTR_FORK)
  35                 oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
  36 }
  37
  38 static inline bool
  39 xfs_rmap_should_skip_owner_update(
  40         const struct xfs_owner_info     *oi)
  41 {
  42         return oi->oi_owner == XFS_RMAP_OWN_NULL;
  43 }
  44
  45 /* Reverse mapping functions. */
  46
  47 struct xfs_buf;
  48
  49 static inline __u64
  50 xfs_rmap_irec_offset_pack(
  51         const struct xfs_rmap_irec      *irec)
  52 {
  53         __u64                   x;
  54
  55         x = XFS_RMAP_OFF(irec->rm_offset);
  56         if (irec->rm_flags & XFS_RMAP_ATTR_FORK)
  57                 x |= XFS_RMAP_OFF_ATTR_FORK;
  58         if (irec->rm_flags & XFS_RMAP_BMBT_BLOCK)
  59                 x |= XFS_RMAP_OFF_BMBT_BLOCK;
  60         if (irec->rm_flags & XFS_RMAP_UNWRITTEN)
  61                 x |= XFS_RMAP_OFF_UNWRITTEN;
  62         return x;
  63 }
  64
  65 static inline xfs_failaddr_t
  66 xfs_rmap_irec_offset_unpack(
  67         __u64                   offset,
  68         struct xfs_rmap_irec    *irec)
  69 {
  70         if (offset & ~(XFS_RMAP_OFF_MASK | XFS_RMAP_OFF_FLAGS))
  71                 return __this_address;
  72
  73         irec->rm_offset = XFS_RMAP_OFF(offset);
  74         irec->rm_flags = 0;
  75         if (offset & XFS_RMAP_OFF_ATTR_FORK)
  76                 irec->rm_flags |= XFS_RMAP_ATTR_FORK;
  77         if (offset & XFS_RMAP_OFF_BMBT_BLOCK)
  78                 irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
  79         if (offset & XFS_RMAP_OFF_UNWRITTEN)
  80                 irec->rm_flags |= XFS_RMAP_UNWRITTEN;
  81         return NULL;
  82 }
  83
  84 static inline void
  85 xfs_owner_info_unpack(
  86         const struct xfs_owner_info     *oinfo,
  87         uint64_t                        *owner,
  88         uint64_t                        *offset,
  89         unsigned int                    *flags)
  90 {
  91         unsigned int                    r = 0;
  92
  93         *owner = oinfo->oi_owner;
  94         *offset = oinfo->oi_offset;
  95         if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)
  96                 r |= XFS_RMAP_ATTR_FORK;
  97         if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)
  98                 r |= XFS_RMAP_BMBT_BLOCK;
  99         *flags = r;
 100 }
 101
 102 static inline void
 103 xfs_owner_info_pack(
 104         struct xfs_owner_info   *oinfo,
 105         uint64_t                owner,
 106         uint64_t                offset,
 107         unsigned int            flags)
 108 {
 109         oinfo->oi_owner = owner;
 110         oinfo->oi_offset = XFS_RMAP_OFF(offset);
 111         oinfo->oi_flags = 0;
 112         if (flags & XFS_RMAP_ATTR_FORK)
 113                 oinfo->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
 114         if (flags & XFS_RMAP_BMBT_BLOCK)
 115                 oinfo->oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
 116 }
 117
 118 int xfs_rmap_alloc(struct xfs_trans *tp, struct xfs_buf *agbp,
 119                    struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
 120                    const struct xfs_owner_info *oinfo);
 121 int xfs_rmap_free(struct xfs_trans *tp, struct xfs_buf *agbp,
 122                   struct xfs_perag *pag, xfs_agblock_t bno, xfs_extlen_t len,
 123                   const struct xfs_owner_info *oinfo);
 124
 125 int xfs_rmap_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 126                 uint64_t owner, uint64_t offset, unsigned int flags,
 127                 struct xfs_rmap_irec *irec, int *stat);
 128 int xfs_rmap_lookup_eq(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 129                 xfs_extlen_t len, uint64_t owner, uint64_t offset,
 130                 unsigned int flags, int *stat);
 131 int xfs_rmap_insert(struct xfs_btree_cur *rcur, xfs_agblock_t agbno,
 132                 xfs_extlen_t len, uint64_t owner, uint64_t offset,
 133                 unsigned int flags);
 134 int xfs_rmap_get_rec(struct xfs_btree_cur *cur, struct xfs_rmap_irec *irec,
 135                 int *stat);
 136
 137 typedef int (*xfs_rmap_query_range_fn)(
 138         struct xfs_btree_cur            *cur,
 139         const struct xfs_rmap_irec      *rec,
 140         void                            *priv);
 141
 142 int xfs_rmap_query_range(struct xfs_btree_cur *cur,
 143                 const struct xfs_rmap_irec *low_rec,
 144                 const struct xfs_rmap_irec *high_rec,
 145                 xfs_rmap_query_range_fn fn, void *priv);
 146 int xfs_rmap_query_all(struct xfs_btree_cur *cur, xfs_rmap_query_range_fn fn,
 147                 void *priv);
 148
 149 enum xfs_rmap_intent_type {
 150         XFS_RMAP_MAP,
 151         XFS_RMAP_MAP_SHARED,
 152         XFS_RMAP_UNMAP,
 153         XFS_RMAP_UNMAP_SHARED,
 154         XFS_RMAP_CONVERT,
 155         XFS_RMAP_CONVERT_SHARED,
 156         XFS_RMAP_ALLOC,
 157         XFS_RMAP_FREE,
 158 };
 159
 160 struct xfs_rmap_intent {
 161         struct list_head                        ri_list;
 162         enum xfs_rmap_intent_type               ri_type;
 163         int                                     ri_whichfork;
 164         uint64_t                                ri_owner;
 165         struct xfs_bmbt_irec                    ri_bmap;
 166         struct xfs_perag                        *ri_pag;
 167 };
 168
 169 void xfs_rmap_update_get_group(struct xfs_mount *mp,
 170                 struct xfs_rmap_intent *ri);
 171
 172 /* functions for updating the rmapbt based on bmbt map/unmap operations */
 173 void xfs_rmap_map_extent(struct xfs_trans *tp, struct xfs_inode *ip,
 174                 int whichfork, struct xfs_bmbt_irec *imap);
 175 void xfs_rmap_unmap_extent(struct xfs_trans *tp, struct xfs_inode *ip,
 176                 int whichfork, struct xfs_bmbt_irec *imap);
 177 void xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_trans *tp,
 178                 struct xfs_inode *ip, int whichfork,
 179                 struct xfs_bmbt_irec *imap);
 180 void xfs_rmap_alloc_extent(struct xfs_trans *tp, xfs_agnumber_t agno,
 181                 xfs_agblock_t bno, xfs_extlen_t len, uint64_t owner);
 182 void xfs_rmap_free_extent(struct xfs_trans *tp, xfs_agnumber_t agno,
 183                 xfs_agblock_t bno, xfs_extlen_t len, uint64_t owner);
 184
 185 void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp,
 186                 struct xfs_btree_cur *rcur, int error);
 187 int xfs_rmap_finish_one(struct xfs_trans *tp, struct xfs_rmap_intent *ri,
 188                 struct xfs_btree_cur **pcur);
 189
 190 int xfs_rmap_lookup_le_range(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 191                 uint64_t owner, uint64_t offset, unsigned int flags,
 192                 struct xfs_rmap_irec *irec, int *stat);
 193 int xfs_rmap_compare(const struct xfs_rmap_irec *a,
 194                 const struct xfs_rmap_irec *b);
 195 union xfs_btree_rec;
 196 xfs_failaddr_t xfs_rmap_btrec_to_irec(const union xfs_btree_rec *rec,
 197                 struct xfs_rmap_irec *irec);
 198 xfs_failaddr_t xfs_rmap_check_irec(struct xfs_btree_cur *cur,
 199                 const struct xfs_rmap_irec *irec);
 200
 201 int xfs_rmap_has_records(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 202                 xfs_extlen_t len, enum xbtree_recpacking *outcome);
 203
 204 struct xfs_rmap_matches {
 205         /* Number of owner matches. */
 206         unsigned long long      matches;
 207
 208         /* Number of non-owner matches. */
 209         unsigned long long      non_owner_matches;
 210
 211         /* Number of non-owner matches that conflict with the owner matches. */
 212         unsigned long long      bad_non_owner_matches;
 213 };
 214
 215 int xfs_rmap_count_owners(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 216                 xfs_extlen_t len, const struct xfs_owner_info *oinfo,
 217                 struct xfs_rmap_matches *rmatch);
 218 int xfs_rmap_has_other_keys(struct xfs_btree_cur *cur, xfs_agblock_t bno,
 219                 xfs_extlen_t len, const struct xfs_owner_info *oinfo,
 220                 bool *has_other);
 221 int xfs_rmap_map_raw(struct xfs_btree_cur *cur, struct xfs_rmap_irec *rmap);
 222
 223 extern const struct xfs_owner_info XFS_RMAP_OINFO_SKIP_UPDATE;
 224 extern const struct xfs_owner_info XFS_RMAP_OINFO_ANY_OWNER;
 225 extern const struct xfs_owner_info XFS_RMAP_OINFO_FS;
 226 extern const struct xfs_owner_info XFS_RMAP_OINFO_LOG;
 227 extern const struct xfs_owner_info XFS_RMAP_OINFO_AG;
 228 extern const struct xfs_owner_info XFS_RMAP_OINFO_INOBT;
 229 extern const struct xfs_owner_info XFS_RMAP_OINFO_INODES;
 230 extern const struct xfs_owner_info XFS_RMAP_OINFO_REFC;
 231 extern const struct xfs_owner_info XFS_RMAP_OINFO_COW;
 232
 233 extern struct kmem_cache        *xfs_rmap_intent_cache;
 234
 235 int __init xfs_rmap_intent_init_cache(void);
 236 void xfs_rmap_intent_destroy_cache(void);
 237
 238 #endif  /* __XFS_RMAP_H__ */