]> git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blame - include/xfs_sb.h
projects / thirdparty / xfsprogs-dev.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Userspace support for lazy superblock counters
[thirdparty/xfsprogs-dev.git] / include / xfs_sb.h
CommitLineData
2bd0ea18 1/*
f302e9e4
NS		 2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
5000d01d 4 *
f302e9e4
NS		 5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
2bd0ea18 7 * published by the Free Software Foundation.
5000d01d 8 *
f302e9e4
NS		 9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
5000d01d 13 *
f302e9e4
NS		 14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2bd0ea18
NS		 17 */
18#ifndef __XFS_SB_H__
dfc130f3 19#define __XFS_SB_H__
2bd0ea18
NS		 20
21/*
22 * Super block
9440d84d 23 * Fits into a sector-sized buffer at address 0 of each allocation group.
2bd0ea18
NS		 24 * Only the first of these is ever updated except during growfs.
25 */
26
27struct xfs_buf;
28struct xfs_mount;
29
dfc130f3
RC		 30#define XFS_SB_MAGIC 0x58465342 /* 'XFSB' */
31#define XFS_SB_VERSION_1 1 /* 5.3, 6.0.1, 6.1 */
32#define XFS_SB_VERSION_2 2 /* 6.2 - attributes */
33#define XFS_SB_VERSION_3 3 /* 6.2 - new inode version */
34#define XFS_SB_VERSION_4 4 /* 6.2+ - bitmask version */
35#define XFS_SB_VERSION_NUMBITS 0x000f
36#define XFS_SB_VERSION_ALLFBITS 0xfff0
37#define XFS_SB_VERSION_SASHFBITS 0xf000
38#define XFS_SB_VERSION_REALFBITS 0x0ff0
39#define XFS_SB_VERSION_ATTRBIT 0x0010
40#define XFS_SB_VERSION_NLINKBIT 0x0020
41#define XFS_SB_VERSION_QUOTABIT 0x0040
42#define XFS_SB_VERSION_ALIGNBIT 0x0080
43#define XFS_SB_VERSION_DALIGNBIT 0x0100
44#define XFS_SB_VERSION_SHAREDBIT 0x0200
73bf5988 45#define XFS_SB_VERSION_LOGV2BIT 0x0400
9440d84d 46#define XFS_SB_VERSION_SECTORBIT 0x0800
dfc130f3
RC		 47#define XFS_SB_VERSION_EXTFLGBIT 0x1000
48#define XFS_SB_VERSION_DIRV2BIT 0x2000
465e76a9 49#define XFS_SB_VERSION_MOREBITSBIT 0x8000
dfc130f3 50#define XFS_SB_VERSION_OKSASHFBITS \
2bd0ea18
NS		 51 (XFS_SB_VERSION_EXTFLGBIT | \
52 XFS_SB_VERSION_DIRV2BIT)
dfc130f3 53#define XFS_SB_VERSION_OKREALFBITS \
2bd0ea18
NS		 54 (XFS_SB_VERSION_ATTRBIT | \
55 XFS_SB_VERSION_NLINKBIT | \
56 XFS_SB_VERSION_QUOTABIT | \
57 XFS_SB_VERSION_ALIGNBIT | \
58 XFS_SB_VERSION_DALIGNBIT | \
73bf5988 59 XFS_SB_VERSION_SHAREDBIT | \
9440d84d 60 XFS_SB_VERSION_LOGV2BIT | \
46eca962
NS		 61 XFS_SB_VERSION_SECTORBIT | \
62 XFS_SB_VERSION_MOREBITSBIT)
dfc130f3 63#define XFS_SB_VERSION_OKSASHBITS \
2bd0ea18
NS		 64 (XFS_SB_VERSION_NUMBITS | \
65 XFS_SB_VERSION_REALFBITS | \
66 XFS_SB_VERSION_OKSASHFBITS)
dfc130f3 67#define XFS_SB_VERSION_OKREALBITS \
2bd0ea18
NS		 68 (XFS_SB_VERSION_NUMBITS | \
69 XFS_SB_VERSION_OKREALFBITS | \
70 XFS_SB_VERSION_OKSASHFBITS)
2bd0ea18 71
465e76a9
GO		 72/*
73 * There are two words to hold XFS "feature" bits: the original
74 * word, sb_versionnum, and sb_features2. Whenever a bit is set in
75 * sb_features2, the feature bit XFS_SB_VERSION_MOREBITSBIT must be set.
76 *
77 * These defines represent bits in sb_features2.
78 */
79#define XFS_SB_VERSION2_REALFBITS 0x00ffffff /* Mask: features */
6e3140c7
NS		 80#define XFS_SB_VERSION2_DONOTUSEBIT1 0x00000001
81#define XFS_SB_VERSION2_LAZYSBCOUNTBIT 0x00000002 /* Lazy SB counters */
82#define XFS_SB_VERSION2_DONOTUSEBIT2 0x00000004
ca86e759 83#define XFS_SB_VERSION2_ATTR2BIT 0x00000008 /* Inline attr rework */
6e3140c7 84#define XFS_SB_VERSION2_PARENTBIT 0x00000010 /* Parent pointers */
465e76a9
GO		 85#define XFS_SB_VERSION2_SASHFBITS 0xff000000 /* Mask: features that
86 require changing
87 PROM and SASH */
88
89#define XFS_SB_VERSION2_OKREALFBITS \
cdded3d8
DC		 90 (XFS_SB_VERSION2_ATTR2BIT | \
91 XFS_SB_VERSION2_LAZYSBCOUNTBIT)
465e76a9
GO		 92#define XFS_SB_VERSION2_OKSASHFBITS \
93 (0)
94#define XFS_SB_VERSION2_OKREALBITS \
95 (XFS_SB_VERSION2_OKREALFBITS | \
96 XFS_SB_VERSION2_OKSASHFBITS )
97
2bd0ea18
NS		 98typedef struct xfs_sb
99{
100 __uint32_t sb_magicnum; /* magic number == XFS_SB_MAGIC */
101 __uint32_t sb_blocksize; /* logical block size, bytes */
102 xfs_drfsbno_t sb_dblocks; /* number of data blocks */
103 xfs_drfsbno_t sb_rblocks; /* number of realtime blocks */
104 xfs_drtbno_t sb_rextents; /* number of realtime extents */
105 uuid_t sb_uuid; /* file system unique id */
106 xfs_dfsbno_t sb_logstart; /* starting block of log if internal */
107 xfs_ino_t sb_rootino; /* root inode number */
108 xfs_ino_t sb_rbmino; /* bitmap inode for realtime extents */
109 xfs_ino_t sb_rsumino; /* summary inode for rt bitmap */
110 xfs_agblock_t sb_rextsize; /* realtime extent size, blocks */
111 xfs_agblock_t sb_agblocks; /* size of an allocation group */
112 xfs_agnumber_t sb_agcount; /* number of allocation groups */
113 xfs_extlen_t sb_rbmblocks; /* number of rt bitmap blocks */
114 xfs_extlen_t sb_logblocks; /* number of log blocks */
115 __uint16_t sb_versionnum; /* header version == XFS_SB_VERSION */
116 __uint16_t sb_sectsize; /* volume sector size, bytes */
117 __uint16_t sb_inodesize; /* inode size, bytes */
118 __uint16_t sb_inopblock; /* inodes per block */
119 char sb_fname[12]; /* file system name */
120 __uint8_t sb_blocklog; /* log2 of sb_blocksize */
121 __uint8_t sb_sectlog; /* log2 of sb_sectsize */
122 __uint8_t sb_inodelog; /* log2 of sb_inodesize */
123 __uint8_t sb_inopblog; /* log2 of sb_inopblock */
124 __uint8_t sb_agblklog; /* log2 of sb_agblocks (rounded up) */
125 __uint8_t sb_rextslog; /* log2 of sb_rextents */
126 __uint8_t sb_inprogress; /* mkfs is in progress, don't mount */
127 __uint8_t sb_imax_pct; /* max % of fs for inode space */
128 /* statistics */
129 /*
dfc130f3 130 * These fields must remain contiguous. If you really
2bd0ea18
NS		 131 * want to change their layout, make sure you fix the
132 * code in xfs_trans_apply_sb_deltas().
133 */
134 __uint64_t sb_icount; /* allocated inodes */
135 __uint64_t sb_ifree; /* free inodes */
136 __uint64_t sb_fdblocks; /* free data blocks */
137 __uint64_t sb_frextents; /* free realtime extents */
138 /*
139 * End contiguous fields.
140 */
141 xfs_ino_t sb_uquotino; /* user quota inode */
b36eef04 142 xfs_ino_t sb_gquotino; /* group quota inode */
2bd0ea18
NS		 143 __uint16_t sb_qflags; /* quota flags */
144 __uint8_t sb_flags; /* misc. flags */
145 __uint8_t sb_shared_vn; /* shared version number */
146 xfs_extlen_t sb_inoalignmt; /* inode chunk alignment, fsblocks */
147 __uint32_t sb_unit; /* stripe or raid unit */
5000d01d 148 __uint32_t sb_width; /* stripe or raid width */
2bd0ea18 149 __uint8_t sb_dirblklog; /* log2 of dir block size (fsbs) */
9440d84d
NS		 150 __uint8_t sb_logsectlog; /* log2 of the log sector size */
151 __uint16_t sb_logsectsize; /* sector size for the log, bytes */
73bf5988 152 __uint32_t sb_logsunit; /* stripe unit size for the log */
ca86e759 153 __uint32_t sb_features2; /* additional feature bits */
2bd0ea18
NS		 154} xfs_sb_t;
155
156/*
157 * Sequence number values for the fields.
158 */
159typedef enum {
160 XFS_SBS_MAGICNUM, XFS_SBS_BLOCKSIZE, XFS_SBS_DBLOCKS, XFS_SBS_RBLOCKS,
161 XFS_SBS_REXTENTS, XFS_SBS_UUID, XFS_SBS_LOGSTART, XFS_SBS_ROOTINO,
162 XFS_SBS_RBMINO, XFS_SBS_RSUMINO, XFS_SBS_REXTSIZE, XFS_SBS_AGBLOCKS,
163 XFS_SBS_AGCOUNT, XFS_SBS_RBMBLOCKS, XFS_SBS_LOGBLOCKS,
164 XFS_SBS_VERSIONNUM, XFS_SBS_SECTSIZE, XFS_SBS_INODESIZE,
165 XFS_SBS_INOPBLOCK, XFS_SBS_FNAME, XFS_SBS_BLOCKLOG,
166 XFS_SBS_SECTLOG, XFS_SBS_INODELOG, XFS_SBS_INOPBLOG, XFS_SBS_AGBLKLOG,
167 XFS_SBS_REXTSLOG, XFS_SBS_INPROGRESS, XFS_SBS_IMAX_PCT, XFS_SBS_ICOUNT,
168 XFS_SBS_IFREE, XFS_SBS_FDBLOCKS, XFS_SBS_FREXTENTS, XFS_SBS_UQUOTINO,
b36eef04 169 XFS_SBS_GQUOTINO, XFS_SBS_QFLAGS, XFS_SBS_FLAGS, XFS_SBS_SHARED_VN,
2bd0ea18 170 XFS_SBS_INOALIGNMT, XFS_SBS_UNIT, XFS_SBS_WIDTH, XFS_SBS_DIRBLKLOG,
9440d84d 171 XFS_SBS_LOGSECTLOG, XFS_SBS_LOGSECTSIZE, XFS_SBS_LOGSUNIT,
465e76a9 172 XFS_SBS_FEATURES2,
2bd0ea18
NS		 173 XFS_SBS_FIELDCOUNT
174} xfs_sb_field_t;
175
176/*
177 * Mask values, defined based on the xfs_sb_field_t values.
178 * Only define the ones we're using.
179 */
dfc130f3
RC		 180#define XFS_SB_MVAL(x) (1LL << XFS_SBS_ ## x)
181#define XFS_SB_UUID XFS_SB_MVAL(UUID)
182#define XFS_SB_FNAME XFS_SB_MVAL(FNAME)
183#define XFS_SB_ROOTINO XFS_SB_MVAL(ROOTINO)
184#define XFS_SB_RBMINO XFS_SB_MVAL(RBMINO)
185#define XFS_SB_RSUMINO XFS_SB_MVAL(RSUMINO)
186#define XFS_SB_VERSIONNUM XFS_SB_MVAL(VERSIONNUM)
2bd0ea18 187#define XFS_SB_UQUOTINO XFS_SB_MVAL(UQUOTINO)
b36eef04 188#define XFS_SB_GQUOTINO XFS_SB_MVAL(GQUOTINO)
2bd0ea18
NS		 189#define XFS_SB_QFLAGS XFS_SB_MVAL(QFLAGS)
190#define XFS_SB_SHARED_VN XFS_SB_MVAL(SHARED_VN)
191#define XFS_SB_UNIT XFS_SB_MVAL(UNIT)
192#define XFS_SB_WIDTH XFS_SB_MVAL(WIDTH)
cdded3d8
DC		 193#define XFS_SB_ICOUNT XFS_SB_MVAL(ICOUNT)
194#define XFS_SB_IFREE XFS_SB_MVAL(IFREE)
195#define XFS_SB_FDBLOCKS XFS_SB_MVAL(FDBLOCKS)
ca86e759 196#define XFS_SB_FEATURES2 XFS_SB_MVAL(FEATURES2)
dfc130f3
RC		 197#define XFS_SB_NUM_BITS ((int)XFS_SBS_FIELDCOUNT)
198#define XFS_SB_ALL_BITS ((1LL << XFS_SB_NUM_BITS) - 1)
199#define XFS_SB_MOD_BITS \
2bd0ea18 200 (XFS_SB_UUID | XFS_SB_ROOTINO | XFS_SB_RBMINO | XFS_SB_RSUMINO | \
b36eef04 201 XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
ca86e759 202 XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
cdded3d8 203 XFS_SB_ICOUNT | XFS_SB_IFREE | XFS_SB_FDBLOCKS | XFS_SB_FEATURES2)
ca86e759 204
2bd0ea18
NS		 205
206/*
207 * Misc. Flags - warning - these will be cleared by xfs_repair unless
208 * a feature bit is set when the flag is used.
209 */
210#define XFS_SBF_NOFLAGS 0x00 /* no flags set */
211#define XFS_SBF_READONLY 0x01 /* only read-only mounts allowed */
212
213/*
214 * define max. shared version we can interoperate with
215 */
216#define XFS_SB_MAX_SHARED_VN 0
217
dfc130f3 218#define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
2bd0ea18 219
dfc130f3 220#define XFS_SB_GOOD_VERSION(sbp) xfs_sb_good_version(sbp)
2bd0ea18 221#ifdef __KERNEL__
f302e9e4
NS		 222static inline int xfs_sb_good_version(xfs_sb_t *sbp)
223{
224 return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
225 (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
226 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
227 !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
228 ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
229 (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
230 (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)));
231}
232#else
233static inline int xfs_sb_good_version(xfs_sb_t *sbp)
234{
235 return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
236 (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
237 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
238 !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
239 ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
240 (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
241 (!(sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
242 (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN))));
243}
2bd0ea18 244#endif /* __KERNEL__ */
2bd0ea18 245
dfc130f3 246#define XFS_SB_GOOD_SASH_VERSION(sbp) \
2bd0ea18
NS		 247 ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
248 ((sbp)->sb_versionnum <= XFS_SB_VERSION_3)) || \
249 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
250 !((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKSASHBITS)))
251
dfc130f3 252#define XFS_SB_VERSION_TONEW(v) xfs_sb_version_tonew(v)
f302e9e4
NS		 253static inline unsigned xfs_sb_version_tonew(unsigned v)
254{
255 return ((((v) == XFS_SB_VERSION_1) ? \
2bd0ea18
NS		 256 0 : \
257 (((v) == XFS_SB_VERSION_2) ? \
258 XFS_SB_VERSION_ATTRBIT : \
259 (XFS_SB_VERSION_ATTRBIT | XFS_SB_VERSION_NLINKBIT))) | \
f302e9e4
NS		 260 XFS_SB_VERSION_4);
261}
2bd0ea18 262
dfc130f3 263#define XFS_SB_VERSION_TOOLD(v) xfs_sb_version_toold(v)
f302e9e4
NS		 264static inline unsigned xfs_sb_version_toold(unsigned v)
265{
266 return (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
2bd0ea18
NS		 267 0 : \
268 (((v) & XFS_SB_VERSION_NLINKBIT) ? \
269 XFS_SB_VERSION_3 : \
270 (((v) & XFS_SB_VERSION_ATTRBIT) ? \
271 XFS_SB_VERSION_2 : \
f302e9e4
NS		 272 XFS_SB_VERSION_1)));
273}
2bd0ea18 274
dfc130f3 275#define XFS_SB_VERSION_HASATTR(sbp) xfs_sb_version_hasattr(sbp)
f302e9e4
NS		 276static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
277{
278 return ((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
279 ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
280 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
281 ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
282}
2bd0ea18 283
dfc130f3 284#define XFS_SB_VERSION_ADDATTR(sbp) xfs_sb_version_addattr(sbp)
f302e9e4
NS		 285static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
286{
287 (sbp)->sb_versionnum = (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
2bd0ea18
NS		 288 XFS_SB_VERSION_2 : \
289 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) ? \
290 ((sbp)->sb_versionnum | XFS_SB_VERSION_ATTRBIT) : \
f302e9e4
NS		 291 (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT)));
292}
2bd0ea18 293
dfc130f3 294#define XFS_SB_VERSION_HASNLINK(sbp) xfs_sb_version_hasnlink(sbp)
f302e9e4
NS		 295static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
296{
297 return ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
298 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
299 ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
300}
2bd0ea18 301
dfc130f3 302#define XFS_SB_VERSION_ADDNLINK(sbp) xfs_sb_version_addnlink(sbp)
f302e9e4
NS		 303static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
304{
305 (sbp)->sb_versionnum = ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
2bd0ea18 306 XFS_SB_VERSION_3 : \
f302e9e4
NS		 307 ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT));
308}
2bd0ea18 309
dfc130f3 310#define XFS_SB_VERSION_HASQUOTA(sbp) xfs_sb_version_hasquota(sbp)
f302e9e4
NS		 311static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
312{
313 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
314 ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
315}
2bd0ea18 316
dfc130f3 317#define XFS_SB_VERSION_ADDQUOTA(sbp) xfs_sb_version_addquota(sbp)
f302e9e4
NS		 318static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
319{
320 (sbp)->sb_versionnum = \
321 (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
322 ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
323 (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
324 XFS_SB_VERSION_QUOTABIT));
325}
326
dfc130f3 327#define XFS_SB_VERSION_HASALIGN(sbp) xfs_sb_version_hasalign(sbp)
f302e9e4
NS		 328static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
329{
330 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
331 ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
332}
2bd0ea18 333
dfc130f3 334#define XFS_SB_VERSION_SUBALIGN(sbp) xfs_sb_version_subalign(sbp)
f302e9e4
NS		 335static inline void xfs_sb_version_subalign(xfs_sb_t *sbp)
336{
337 (sbp)->sb_versionnum = \
338 XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT);
339}
2bd0ea18 340
2bd0ea18 341#define XFS_SB_VERSION_HASDALIGN(sbp) xfs_sb_version_hasdalign(sbp)
f302e9e4
NS		 342static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
343{
344 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
345 ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
346}
2bd0ea18 347
2bd0ea18 348#define XFS_SB_VERSION_ADDDALIGN(sbp) xfs_sb_version_adddalign(sbp)
f302e9e4
NS		 349static inline int xfs_sb_version_adddalign(xfs_sb_t *sbp)
350{
351 return (sbp)->sb_versionnum = \
352 ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT);
353}
2bd0ea18 354
2bd0ea18 355#define XFS_SB_VERSION_HASSHARED(sbp) xfs_sb_version_hasshared(sbp)
f302e9e4
NS		 356static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
357{
358 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
359 ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
360}
2bd0ea18 361
2bd0ea18 362#define XFS_SB_VERSION_ADDSHARED(sbp) xfs_sb_version_addshared(sbp)
f302e9e4
NS		 363static inline int xfs_sb_version_addshared(xfs_sb_t *sbp)
364{
365 return (sbp)->sb_versionnum = \
366 ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT);
367}
2bd0ea18 368
2bd0ea18 369#define XFS_SB_VERSION_SUBSHARED(sbp) xfs_sb_version_subshared(sbp)
f302e9e4
NS		 370static inline int xfs_sb_version_subshared(xfs_sb_t *sbp)
371{
372 return (sbp)->sb_versionnum = \
373 ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT);
374}
2bd0ea18 375
2bd0ea18 376#define XFS_SB_VERSION_HASDIRV2(sbp) xfs_sb_version_hasdirv2(sbp)
f302e9e4
NS		 377static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
378{
379 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
380 ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
381}
2bd0ea18 382
73bf5988 383#define XFS_SB_VERSION_HASLOGV2(sbp) xfs_sb_version_haslogv2(sbp)
f302e9e4
NS		 384static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
385{
386 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
387 ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
388}
73bf5988 389
2bd0ea18 390#define XFS_SB_VERSION_HASEXTFLGBIT(sbp) xfs_sb_version_hasextflgbit(sbp)
f302e9e4
NS		 391static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
392{
393 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
394 ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
395}
2bd0ea18 396
2bd0ea18 397#define XFS_SB_VERSION_ADDEXTFLGBIT(sbp) xfs_sb_version_addextflgbit(sbp)
f302e9e4
NS		 398static inline int xfs_sb_version_addextflgbit(xfs_sb_t *sbp)
399{
400 return (sbp)->sb_versionnum = \
401 ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT);
402}
2bd0ea18 403
2bd0ea18 404#define XFS_SB_VERSION_SUBEXTFLGBIT(sbp) xfs_sb_version_subextflgbit(sbp)
f302e9e4
NS		 405static inline int xfs_sb_version_subextflgbit(xfs_sb_t *sbp)
406{
407 return (sbp)->sb_versionnum = \
408 ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT);
409}
2bd0ea18 410
9440d84d 411#define XFS_SB_VERSION_HASSECTOR(sbp) xfs_sb_version_hassector(sbp)
f302e9e4
NS		 412static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
413{
414 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
415 ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
416}
9440d84d 417
465e76a9 418#define XFS_SB_VERSION_HASMOREBITS(sbp) xfs_sb_version_hasmorebits(sbp)
f302e9e4
NS		 419static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
420{
421 return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
422 ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
423}
465e76a9
GO		 424
425/*
426 * sb_features2 bit version macros.
427 *
5012120b 428 * For example, for a bit defined as XFS_SB_VERSION2_FUNBIT, has a macro:
465e76a9 429 *
46eca962 430 * SB_VERSION_HASFUNBIT(xfs_sb_t *sbp)
465e76a9 431 * ((XFS_SB_VERSION_HASMOREBITS(sbp) &&
46eca962 432 * ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
465e76a9 433 */
f302e9e4 434
cdded3d8
DC		 435#define XFS_SB_VERSION_LAZYSBCOUNT(sbp) xfs_sb_version_haslazysbcount(sbp)
436static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
437{
438 return (XFS_SB_VERSION_HASMOREBITS(sbp) &&
439 ((sbp)->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT));
440}
441
ca86e759 442#define XFS_SB_VERSION_HASATTR2(sbp) xfs_sb_version_hasattr2(sbp)
f302e9e4
NS		 443static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
444{
445 return (XFS_SB_VERSION_HASMOREBITS(sbp)) && \
446 ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
447}
ca86e759 448
ca86e759 449#define XFS_SB_VERSION_ADDATTR2(sbp) xfs_sb_version_addattr2(sbp)
f302e9e4
NS		 450static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
451{
ca86e759
NS		 452 ((sbp)->sb_versionnum = \
453 ((sbp)->sb_versionnum | XFS_SB_VERSION_MOREBITSBIT), \
454 ((sbp)->sb_features2 = \
f302e9e4
NS		 455 ((sbp)->sb_features2 | XFS_SB_VERSION2_ATTR2BIT)));
456}
457
2bd0ea18
NS		 458/*
459 * end of superblock version macros
460 */
461
f302e9e4 462#define XFS_SB_DADDR ((xfs_daddr_t)0) /* daddr in filesystem/ag */
dfc130f3 463#define XFS_SB_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
9440d84d 464#define XFS_BUF_TO_SBP(bp) ((xfs_sb_t *)XFS_BUF_PTR(bp))
f302e9e4
NS		 465
466#define XFS_HDR_BLOCK(mp,d) ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
467#define XFS_DADDR_TO_FSB(mp,d) XFS_AGB_TO_FSB(mp, \
468 XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
469#define XFS_FSB_TO_DADDR(mp,fsbno) XFS_AGB_TO_DADDR(mp, \
470 XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
9440d84d
NS		 471
472/*
473 * File system sector to basic block conversions.
474 */
475#define XFS_FSS_TO_BB(mp,sec) ((sec) << (mp)->m_sectbb_log)
476#define XFS_BB_TO_FSS(mp,bb) \
477 (((bb) + (XFS_FSS_TO_BB(mp,1) - 1)) >> (mp)->m_sectbb_log)
478#define XFS_BB_TO_FSST(mp,bb) ((bb) >> (mp)->m_sectbb_log)
479
480/*
481 * File system sector to byte conversions.
482 */
483#define XFS_FSS_TO_B(mp,sectno) ((xfs_fsize_t)(sectno) << (mp)->m_sb.sb_sectlog)
484#define XFS_B_TO_FSST(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_sectlog)
485
2bd0ea18
NS		 486/*
487 * File system block to basic block conversions.
488 */
dfc130f3
RC		 489#define XFS_FSB_TO_BB(mp,fsbno) ((fsbno) << (mp)->m_blkbb_log)
490#define XFS_BB_TO_FSB(mp,bb) \
2bd0ea18 491 (((bb) + (XFS_FSB_TO_BB(mp,1) - 1)) >> (mp)->m_blkbb_log)
dfc130f3
RC		 492#define XFS_BB_TO_FSBT(mp,bb) ((bb) >> (mp)->m_blkbb_log)
493#define XFS_BB_FSB_OFFSET(mp,bb) ((bb) & ((mp)->m_bsize - 1))
2bd0ea18
NS		 494
495/*
496 * File system block to byte conversions.
497 */
9440d84d 498#define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
5000d01d 499#define XFS_B_TO_FSB(mp,b) \
2bd0ea18 500 ((((__uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
5000d01d
SL		 501#define XFS_B_TO_FSBT(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
502#define XFS_B_FSB_OFFSET(mp,b) ((b) & (mp)->m_blockmask)
2bd0ea18 503
2bd0ea18 504#endif /* __XFS_SB_H__ */
Unnamed repository; edit this file 'description' to name the repository.