include/xfs_mount.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6
   7 #ifndef __XFS_MOUNT_H__
   8 #define __XFS_MOUNT_H__
   9
  10 struct xfs_inode;
  11 struct xfs_buftarg;
  12 struct xfs_da_geometry;
  13 struct libxfs_init;
  14 struct xfs_group;
  15
  16 typedef void (*buf_writeback_fn)(struct xfs_buf *bp);
  17
  18 /* dynamic preallocation free space thresholds, 5% down to 1% */
  19 enum {
  20         XFS_LOWSP_1_PCNT = 0,
  21         XFS_LOWSP_2_PCNT,
  22         XFS_LOWSP_3_PCNT,
  23         XFS_LOWSP_4_PCNT,
  24         XFS_LOWSP_5_PCNT,
  25         XFS_LOWSP_MAX,
  26 };
  27
  28 struct xfs_groups {
  29         struct xarray           xa;
  30
  31         /*
  32          * Maximum capacity of the group in FSBs.
  33          *
  34          * Each group is laid out densely in the daddr space.  For the
  35          * degenerate case of a pre-rtgroups filesystem, the incore rtgroup
  36          * pretends to have a zero-block and zero-blklog rtgroup.
  37          */
  38         uint32_t                blocks;
  39
  40         /*
  41          * Log(2) of the logical size of each group.
  42          *
  43          * Compared to the blocks field above this is rounded up to the next
  44          * power of two, and thus lays out the xfs_fsblock_t/xfs_rtblock_t
  45          * space sparsely with a hole from blocks to (1 << blklog) at the end
  46          * of each group.
  47          */
  48         uint8_t                 blklog;
  49
  50         /*
  51          * Zoned devices can have gaps beyoned the usable capacity of a zone
  52          * and the end in the LBA/daddr address space.  In other words, the
  53          * hardware equivalent to the RT groups already takes care of the power
  54          * of 2 alignment for us.  In this case the sparse FSB/RTB address space
  55          * maps 1:1 to the device address space.
  56          */
  57         bool                    has_daddr_gaps;
  58
  59         /*
  60          * Mask to extract the group-relative block number from a FSB.
  61          * For a pre-rtgroups filesystem we pretend to have one very large
  62          * rtgroup, so this mask must be 64-bit.
  63          */
  64         uint64_t                blkmask;
  65
  66         /*
  67          * Start of the first group in the device.  This is used to support a
  68          * RT device following the data device on the same block device for
  69          * SMR hard drives.
  70          */
  71         xfs_fsblock_t           start_fsb;
  72 };
  73
  74 /*
  75  * Define a user-level mount structure with all we need
  76  * in order to make use of the numerous XFS_* macros.
  77  */
  78 typedef struct xfs_mount {
  79         xfs_sb_t                m_sb;           /* copy of fs superblock */
  80 #define m_icount        m_sb.sb_icount
  81 #define m_ifree         m_sb.sb_ifree
  82         spinlock_t              m_sb_lock;
  83
  84         /*
  85          * Bitsets of per-fs metadata that have been checked and/or are sick.
  86          * Callers must hold m_sb_lock to access these two fields.
  87          */
  88         uint8_t                 m_fs_checked;
  89         uint8_t                 m_fs_sick;
  90
  91         char                    *m_fsname;      /* filesystem name */
  92         int                     m_bsize;        /* fs logical block size */
  93         spinlock_t              m_agirotor_lock;
  94         xfs_agnumber_t          m_agfrotor;     /* last ag where space found */
  95         xfs_agnumber_t          m_agirotor;     /* last ag dir inode alloced */
  96         xfs_agnumber_t          m_maxagi;       /* highest inode alloc group */
  97         struct xfs_ino_geometry m_ino_geo;      /* inode geometry */
  98         uint                    m_rsumlevels;   /* rt summary levels */
  99         xfs_filblks_t           m_rsumblocks;   /* size of rt summary, FSBs */
 100         struct xfs_inode        *m_metadirip;   /* ptr to metadata directory */
 101         struct xfs_inode        *m_rtdirip;     /* ptr to realtime metadir */
 102         struct xfs_buftarg      *m_ddev_targp;
 103         struct xfs_buftarg      *m_logdev_targp;
 104         struct xfs_buftarg      *m_rtdev_targp;
 105 #define m_dev           m_ddev_targp
 106 #define m_logdev        m_logdev_targp
 107 #define m_rtdev         m_rtdev_targp
 108         uint8_t                 m_dircook_elog; /* log d-cookie entry bits */
 109         uint8_t                 m_blkbit_log;   /* blocklog + NBBY */
 110         uint8_t                 m_blkbb_log;    /* blocklog - BBSHIFT */
 111         uint8_t                 m_sectbb_log;   /* sectorlog - BBSHIFT */
 112         uint8_t                 m_agno_log;     /* log #ag's */
 113         int8_t                  m_rtxblklog;    /* log2 of rextsize, if possible */
 114
 115         uint                    m_blockmask;    /* sb_blocksize-1 */
 116         uint                    m_blockwsize;   /* sb_blocksize in words */
 117         /* number of rt extents per rt bitmap block if rtgroups enabled */
 118         unsigned int            m_rtx_per_rbmblock;
 119         uint                    m_alloc_mxr[2]; /* XFS_ALLOC_BLOCK_MAXRECS */
 120         uint                    m_alloc_mnr[2]; /* XFS_ALLOC_BLOCK_MINRECS */
 121         uint                    m_bmap_dmxr[2]; /* XFS_BMAP_BLOCK_DMAXRECS */
 122         uint                    m_bmap_dmnr[2]; /* XFS_BMAP_BLOCK_DMINRECS */
 123         uint                    m_rmap_mxr[2];  /* max rmap btree records */
 124         uint                    m_rmap_mnr[2];  /* min rmap btree records */
 125         uint                    m_rtrmap_mxr[2]; /* max rtrmap btree records */
 126         uint                    m_rtrmap_mnr[2]; /* min rtrmap btree records */
 127         uint                    m_refc_mxr[2];  /* max refc btree records */
 128         uint                    m_refc_mnr[2];  /* min refc btree records */
 129         unsigned int            m_rtrefc_mxr[2]; /* max rtrefc btree records */
 130         unsigned int            m_rtrefc_mnr[2]; /* min rtrefc btree records */
 131         uint                    m_alloc_maxlevels; /* max alloc btree levels */
 132         uint                    m_bm_maxlevels[2];  /* max bmap btree levels */
 133         uint                    m_rmap_maxlevels; /* max rmap btree levels */
 134         uint                    m_rtrmap_maxlevels; /* max rtrmap btree level */
 135         uint                    m_refc_maxlevels; /* max refc btree levels */
 136         unsigned int            m_rtrefc_maxlevels; /* max rtrefc btree level */
 137         unsigned int            m_agbtree_maxlevels; /* max level of all AG btrees */
 138         unsigned int            m_rtbtree_maxlevels; /* max level of all rt btrees */
 139         xfs_extlen_t            m_ag_prealloc_blocks; /* reserved ag blocks */
 140         uint                    m_alloc_set_aside; /* space we can't use */
 141         uint                    m_ag_max_usable; /* max space per AG */
 142         struct xfs_groups       m_groups[XG_TYPE_MAX];
 143         uint64_t                m_features;     /* active filesystem features */
 144         uint64_t                m_low_space[XFS_LOWSP_MAX];
 145         uint64_t                m_rtxblkmask;   /* rt extent block mask */
 146         unsigned long           m_opstate;      /* dynamic state flags */
 147         bool                    m_finobt_nores; /* no per-AG finobt resv. */
 148         uint                    m_qflags;       /* quota status flags */
 149         uint                    m_attroffset;   /* inode attribute offset */
 150         struct xfs_trans_resv   m_resv;         /* precomputed res values */
 151         int                     m_dalign;       /* stripe unit */
 152         int                     m_swidth;       /* stripe width */
 153         const struct xfs_nameops *m_dirnameops; /* vector of dir name ops */
 154
 155         struct xfs_da_geometry  *m_dir_geo;     /* directory block geometry */
 156         struct xfs_da_geometry  *m_attr_geo;    /* attribute block geometry */
 157
 158         /*
 159          * anonymous struct to allow xfs_dquot_buf.c to compile.
 160          * Pointer is always null in userspace, so code does not use it at all
 161          */
 162         struct {
 163                 int     qi_dqperchunk;
 164         }                       *m_quotainfo;
 165
 166         buf_writeback_fn        m_buf_writeback_fn;
 167
 168         /*
 169          * xlog is defined in libxlog and thus is not intialized by libxfs. This
 170          * allows an application to initialize and store a reference to the log
 171          * if warranted.
 172          */
 173         struct xlog             *m_log;         /* log specific stuff */
 174
 175         /*
 176          * Global count of allocation btree blocks in use across all AGs. Only
 177          * used when perag reservation is enabled. Helps prevent block
 178          * reservation from attempting to reserve allocation btree blocks.
 179          */
 180         atomic64_t              m_allocbt_blks;
 181         spinlock_t              m_perag_lock;   /* lock for m_perag_tree */
 182
 183         pthread_mutex_t         m_metafile_resv_lock;
 184         uint64_t                m_metafile_resv_target;
 185         uint64_t                m_metafile_resv_used;
 186         uint64_t                m_metafile_resv_avail;
 187 } xfs_mount_t;
 188
 189 #define M_IGEO(mp)              (&(mp)->m_ino_geo)
 190
 191 /*
 192  * Flags for m_features.
 193  *
 194  * These are all the active features in the filesystem, regardless of how
 195  * they are configured.
 196  */
 197 #define XFS_FEAT_ATTR           (1ULL << 0)     /* xattrs present in fs */
 198 #define XFS_FEAT_NLINK          (1ULL << 1)     /* 32 bit link counts */
 199 #define XFS_FEAT_QUOTA          (1ULL << 2)     /* quota active */
 200 #define XFS_FEAT_ALIGN          (1ULL << 3)     /* inode alignment */
 201 #define XFS_FEAT_DALIGN         (1ULL << 4)     /* data alignment */
 202 #define XFS_FEAT_LOGV2          (1ULL << 5)     /* version 2 logs */
 203 #define XFS_FEAT_SECTOR         (1ULL << 6)     /* sector size > 512 bytes */
 204 #define XFS_FEAT_EXTFLG         (1ULL << 7)     /* unwritten extents */
 205 #define XFS_FEAT_ASCIICI        (1ULL << 8)     /* ASCII only case-insens. */
 206 #define XFS_FEAT_LAZYSBCOUNT    (1ULL << 9)     /* Superblk counters */
 207 #define XFS_FEAT_ATTR2          (1ULL << 10)    /* dynamic attr fork */
 208 #define XFS_FEAT_PARENT         (1ULL << 11)    /* parent pointers */
 209 #define XFS_FEAT_PROJID32       (1ULL << 12)    /* 32 bit project id */
 210 #define XFS_FEAT_CRC            (1ULL << 13)    /* metadata CRCs */
 211 #define XFS_FEAT_V3INODES       (1ULL << 14)    /* Version 3 inodes */
 212 #define XFS_FEAT_PQUOTINO       (1ULL << 15)    /* non-shared proj/grp quotas */
 213 #define XFS_FEAT_FTYPE          (1ULL << 16)    /* inode type in dir */
 214 #define XFS_FEAT_FINOBT         (1ULL << 17)    /* free inode btree */
 215 #define XFS_FEAT_RMAPBT         (1ULL << 18)    /* reverse map btree */
 216 #define XFS_FEAT_REFLINK        (1ULL << 19)    /* reflinked files */
 217 #define XFS_FEAT_SPINODES       (1ULL << 20)    /* sparse inode chunks */
 218 #define XFS_FEAT_META_UUID      (1ULL << 21)    /* metadata UUID */
 219 #define XFS_FEAT_REALTIME       (1ULL << 22)    /* realtime device present */
 220 #define XFS_FEAT_INOBTCNT       (1ULL << 23)    /* inobt block counts */
 221 #define XFS_FEAT_BIGTIME        (1ULL << 24)    /* large timestamps */
 222 #define XFS_FEAT_NEEDSREPAIR    (1ULL << 25)    /* needs xfs_repair */
 223 #define XFS_FEAT_NREXT64        (1ULL << 26)    /* large extent counters */
 224 #define XFS_FEAT_EXCHANGE_RANGE (1ULL << 27)    /* exchange range */
 225 #define XFS_FEAT_METADIR        (1ULL << 28)    /* metadata directory tree */
 226 #define XFS_FEAT_ZONED          (1ULL << 29)    /* zoned RT device */
 227
 228 #define __XFS_HAS_FEAT(name, NAME) \
 229 static inline bool xfs_has_ ## name (const struct xfs_mount *mp) \
 230 { \
 231         return mp->m_features & XFS_FEAT_ ## NAME; \
 232 }
 233
 234 /* Some features can be added dynamically so they need a set wrapper, too. */
 235 #define __XFS_ADD_FEAT(name, NAME) \
 236         __XFS_HAS_FEAT(name, NAME); \
 237 static inline void xfs_add_ ## name (struct xfs_mount *mp) \
 238 { \
 239         mp->m_features |= XFS_FEAT_ ## NAME; \
 240         xfs_sb_version_add ## name(&mp->m_sb); \
 241 }
 242
 243 /* Superblock features */
 244 __XFS_ADD_FEAT(attr, ATTR)
 245 __XFS_HAS_FEAT(nlink, NLINK)
 246 __XFS_ADD_FEAT(quota, QUOTA)
 247 __XFS_HAS_FEAT(align, ALIGN)
 248 __XFS_HAS_FEAT(dalign, DALIGN)
 249 __XFS_HAS_FEAT(logv2, LOGV2)
 250 __XFS_HAS_FEAT(sector, SECTOR)
 251 __XFS_HAS_FEAT(extflg, EXTFLG)
 252 __XFS_HAS_FEAT(asciici, ASCIICI)
 253 __XFS_HAS_FEAT(lazysbcount, LAZYSBCOUNT)
 254 __XFS_ADD_FEAT(attr2, ATTR2)
 255 __XFS_HAS_FEAT(parent, PARENT)
 256 __XFS_ADD_FEAT(projid32, PROJID32)
 257 __XFS_HAS_FEAT(crc, CRC)
 258 __XFS_HAS_FEAT(v3inodes, V3INODES)
 259 __XFS_HAS_FEAT(pquotino, PQUOTINO)
 260 __XFS_HAS_FEAT(ftype, FTYPE)
 261 __XFS_HAS_FEAT(finobt, FINOBT)
 262 __XFS_HAS_FEAT(rmapbt, RMAPBT)
 263 __XFS_HAS_FEAT(reflink, REFLINK)
 264 __XFS_HAS_FEAT(sparseinodes, SPINODES)
 265 __XFS_HAS_FEAT(metauuid, META_UUID)
 266 __XFS_HAS_FEAT(realtime, REALTIME)
 267 __XFS_HAS_FEAT(inobtcounts, INOBTCNT)
 268 __XFS_HAS_FEAT(bigtime, BIGTIME)
 269 __XFS_HAS_FEAT(needsrepair, NEEDSREPAIR)
 270 __XFS_HAS_FEAT(large_extent_counts, NREXT64)
 271 __XFS_HAS_FEAT(exchange_range, EXCHANGE_RANGE)
 272 __XFS_HAS_FEAT(metadir, METADIR)
 273 __XFS_HAS_FEAT(zoned, ZONED)
 274
 275 static inline bool xfs_has_rtgroups(const struct xfs_mount *mp)
 276 {
 277         /* all metadir file systems also allow rtgroups */
 278         return xfs_has_metadir(mp);
 279 }
 280
 281 static inline bool xfs_has_rtsb(const struct xfs_mount *mp)
 282 {
 283         /* all rtgroups filesystems with an rt section have an rtsb */
 284         return xfs_has_rtgroups(mp) &&
 285                 xfs_has_realtime(mp) &&
 286                 !xfs_has_zoned(mp);
 287 }
 288
 289 static inline bool xfs_has_rtrmapbt(const struct xfs_mount *mp)
 290 {
 291         return xfs_has_rtgroups(mp) && xfs_has_realtime(mp) &&
 292                xfs_has_rmapbt(mp);
 293 }
 294
 295 static inline bool xfs_has_rtreflink(const struct xfs_mount *mp)
 296 {
 297         return xfs_has_metadir(mp) && xfs_has_realtime(mp) &&
 298                xfs_has_reflink(mp);
 299 }
 300
 301 static inline bool xfs_has_nonzoned(const struct xfs_mount *mp)
 302 {
 303         return !xfs_has_zoned(mp);
 304 }
 305
 306 /* Kernel mount features that we don't support */
 307 #define __XFS_UNSUPP_FEAT(name) \
 308 static inline bool xfs_has_ ## name (const struct xfs_mount *mp) \
 309 { \
 310         return false; \
 311 }
 312 __XFS_UNSUPP_FEAT(wsync)
 313 __XFS_UNSUPP_FEAT(noattr2)
 314 __XFS_UNSUPP_FEAT(ikeep)
 315 __XFS_UNSUPP_FEAT(swalloc)
 316 __XFS_UNSUPP_FEAT(small_inums)
 317 __XFS_UNSUPP_FEAT(readonly)
 318 __XFS_UNSUPP_FEAT(grpid)
 319
 320 /* Operational mount state flags */
 321 #define XFS_OPSTATE_INODE32             0       /* inode32 allocator active */
 322 #define XFS_OPSTATE_DEBUGGER            1       /* is this the debugger? */
 323 #define XFS_OPSTATE_REPORT_CORRUPTION   2       /* report buffer corruption? */
 324 #define XFS_OPSTATE_PERAG_DATA_LOADED   3       /* per-AG data initialized? */
 325 #define XFS_OPSTATE_RTGROUP_DATA_LOADED 4       /* rtgroup data initialized? */
 326
 327 #define __XFS_IS_OPSTATE(name, NAME) \
 328 static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
 329 { \
 330         return (mp)->m_opstate & (1UL << XFS_OPSTATE_ ## NAME); \
 331 } \
 332 static inline bool xfs_clear_ ## name (struct xfs_mount *mp) \
 333 { \
 334         bool    ret = xfs_is_ ## name(mp); \
 335 \
 336         (mp)->m_opstate &= ~(1UL << XFS_OPSTATE_ ## NAME); \
 337         return ret; \
 338 } \
 339 static inline bool xfs_set_ ## name (struct xfs_mount *mp) \
 340 { \
 341         bool    ret = xfs_is_ ## name(mp); \
 342 \
 343         (mp)->m_opstate |= (1UL << XFS_OPSTATE_ ## NAME); \
 344         return ret; \
 345 }
 346
 347 __XFS_IS_OPSTATE(inode32, INODE32)
 348 __XFS_IS_OPSTATE(debugger, DEBUGGER)
 349 __XFS_IS_OPSTATE(reporting_corruption, REPORT_CORRUPTION)
 350 __XFS_IS_OPSTATE(perag_data_loaded, PERAG_DATA_LOADED)
 351 __XFS_IS_OPSTATE(rtgroup_data_loaded, RTGROUP_DATA_LOADED)
 352
 353 #define __XFS_UNSUPP_OPSTATE(name) \
 354 static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
 355 { \
 356         return false; \
 357 }
 358 __XFS_UNSUPP_OPSTATE(readonly)
 359 __XFS_UNSUPP_OPSTATE(shutdown)
 360
 361 static inline int64_t xfs_sum_freecounter(struct xfs_mount *mp,
 362                 enum xfs_free_counter ctr)
 363 {
 364         if (ctr == XC_FREE_RTEXTENTS)
 365                 return mp->m_sb.sb_frextents;
 366         return mp->m_sb.sb_fdblocks;
 367 }
 368
 369 static inline int64_t xfs_estimate_freecounter(struct xfs_mount *mp,
 370                 enum xfs_free_counter ctr)
 371 {
 372         return xfs_sum_freecounter(mp, ctr);
 373 }
 374
 375 static inline int xfs_compare_freecounter(struct xfs_mount *mp,
 376                 enum xfs_free_counter ctr, int64_t rhs, int32_t batch)
 377 {
 378         uint64_t count;
 379
 380         if (ctr == XC_FREE_RTEXTENTS)
 381                 count = mp->m_sb.sb_frextents;
 382         else
 383                 count = mp->m_sb.sb_fdblocks;
 384         if (count > rhs)
 385                 return 1;
 386         else if (count < rhs)
 387                 return -1;
 388         return 0;
 389 }
 390
 391 /* don't fail on device size or AG count checks */
 392 #define LIBXFS_MOUNT_DEBUGGER           (1U << 0)
 393 /* report metadata corruption to stdout */
 394 #define LIBXFS_MOUNT_REPORT_CORRUPTION  (1U << 1)
 395
 396 #define LIBXFS_BHASHSIZE(sbp)           (1<<10)
 397
 398 void libxfs_compute_all_maxlevels(struct xfs_mount *mp);
 399 struct xfs_mount *libxfs_mount(struct xfs_mount *mp, struct xfs_sb *sb,
 400                 struct libxfs_init *xi, unsigned int flags);
 401 int libxfs_flush_mount(struct xfs_mount *mp);
 402 int             libxfs_umount(struct xfs_mount *mp);
 403 extern void     libxfs_rtmount_destroy (xfs_mount_t *);
 404
 405 /* Dummy xfs_dquot so that libxfs compiles. */
 406 struct xfs_dquot {
 407         int             q_type;
 408 };
 409
 410 typedef struct wait_queue_head {
 411 } wait_queue_head_t;
 412
 413 static inline void wake_up(wait_queue_head_t *wq) {}
 414
 415 struct xfs_defer_drain { /* empty */ };
 416
 417 #define xfs_defer_drain_init(dr)                ((void)0)
 418 #define xfs_defer_drain_free(dr)                ((void)0)
 419
 420 #define xfs_group_intent_get(mp, fsbno, type) \
 421         xfs_group_get_by_fsb((mp), (fsbno), (type))
 422 #define xfs_group_intent_put(xg)                xfs_group_put(xg)
 423
 424 static inline void xfs_group_intent_hold(struct xfs_group *xg) {}
 425 static inline void xfs_group_intent_rele(struct xfs_group *xg) {}
 426
 427 static inline void libxfs_buftarg_drain(struct xfs_buftarg *btp)
 428 {
 429         cache_purge(btp->bcache);
 430 }
 431
 432 struct mnt_idmap {
 433         /* empty */
 434 };
 435
 436 /* bogus idmapping so that mkfs can do directory inheritance correctly */
 437 #define libxfs_nop_idmap        ((struct mnt_idmap *)1)
 438
 439 #endif  /* __XFS_MOUNT_H__ */