2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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
7 * published by the Free Software Foundation.
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.
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
23 * Fits into a sector-sized buffer at address 0 of each allocation group.
24 * Only the first of these is ever updated except during growfs.
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
45 #define XFS_SB_VERSION_LOGV2BIT 0x0400
46 #define XFS_SB_VERSION_SECTORBIT 0x0800
47 #define XFS_SB_VERSION_EXTFLGBIT 0x1000
48 #define XFS_SB_VERSION_DIRV2BIT 0x2000
49 #define XFS_SB_VERSION_MOREBITSBIT 0x8000
50 #define XFS_SB_VERSION_OKSASHFBITS \
51 (XFS_SB_VERSION_EXTFLGBIT | \
52 XFS_SB_VERSION_DIRV2BIT)
53 #define XFS_SB_VERSION_OKREALFBITS \
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 | \
59 XFS_SB_VERSION_SHAREDBIT | \
60 XFS_SB_VERSION_LOGV2BIT | \
61 XFS_SB_VERSION_SECTORBIT | \
62 XFS_SB_VERSION_MOREBITSBIT)
63 #define XFS_SB_VERSION_OKSASHBITS \
64 (XFS_SB_VERSION_NUMBITS | \
65 XFS_SB_VERSION_REALFBITS | \
66 XFS_SB_VERSION_OKSASHFBITS)
67 #define XFS_SB_VERSION_OKREALBITS \
68 (XFS_SB_VERSION_NUMBITS | \
69 XFS_SB_VERSION_OKREALFBITS | \
70 XFS_SB_VERSION_OKSASHFBITS)
71 #define XFS_SB_VERSION_MKFS(ia,dia,extflag,dirv2,na,sflag,morebits) \
72 (((ia) || (dia) || (extflag) || (dirv2) || (na) || (sflag) || \
75 ((ia) ? XFS_SB_VERSION_ALIGNBIT : 0) | \
76 ((dia) ? XFS_SB_VERSION_DALIGNBIT : 0) | \
77 ((extflag) ? XFS_SB_VERSION_EXTFLGBIT : 0) | \
78 ((dirv2) ? XFS_SB_VERSION_DIRV2BIT : 0) | \
79 ((na) ? XFS_SB_VERSION_LOGV2BIT : 0) | \
80 ((sflag) ? XFS_SB_VERSION_SECTORBIT : 0) | \
81 ((morebits) ? XFS_SB_VERSION_MOREBITSBIT : 0)) : \
85 * There are two words to hold XFS "feature" bits: the original
86 * word, sb_versionnum, and sb_features2. Whenever a bit is set in
87 * sb_features2, the feature bit XFS_SB_VERSION_MOREBITSBIT must be set.
89 * These defines represent bits in sb_features2.
91 #define XFS_SB_VERSION2_REALFBITS 0x00ffffff /* Mask: features */
92 #define XFS_SB_VERSION2_RESERVED1BIT 0x00000001
93 #define XFS_SB_VERSION2_RESERVED2BIT 0x00000002
94 #define XFS_SB_VERSION2_RESERVED4BIT 0x00000004
95 #define XFS_SB_VERSION2_ATTR2BIT 0x00000008 /* Inline attr rework */
96 #define XFS_SB_VERSION2_SASHFBITS 0xff000000 /* Mask: features that
100 #define XFS_SB_VERSION2_OKREALFBITS \
101 (XFS_SB_VERSION2_ATTR2BIT)
102 #define XFS_SB_VERSION2_OKSASHFBITS \
104 #define XFS_SB_VERSION2_OKREALBITS \
105 (XFS_SB_VERSION2_OKREALFBITS | \
106 XFS_SB_VERSION2_OKSASHFBITS )
109 * mkfs macro to set up sb_features2 word
111 #define XFS_SB_VERSION2_MKFS(resvd1, sbcntr) 0
113 typedef struct xfs_sb
115 __uint32_t sb_magicnum
; /* magic number == XFS_SB_MAGIC */
116 __uint32_t sb_blocksize
; /* logical block size, bytes */
117 xfs_drfsbno_t sb_dblocks
; /* number of data blocks */
118 xfs_drfsbno_t sb_rblocks
; /* number of realtime blocks */
119 xfs_drtbno_t sb_rextents
; /* number of realtime extents */
120 uuid_t sb_uuid
; /* file system unique id */
121 xfs_dfsbno_t sb_logstart
; /* starting block of log if internal */
122 xfs_ino_t sb_rootino
; /* root inode number */
123 xfs_ino_t sb_rbmino
; /* bitmap inode for realtime extents */
124 xfs_ino_t sb_rsumino
; /* summary inode for rt bitmap */
125 xfs_agblock_t sb_rextsize
; /* realtime extent size, blocks */
126 xfs_agblock_t sb_agblocks
; /* size of an allocation group */
127 xfs_agnumber_t sb_agcount
; /* number of allocation groups */
128 xfs_extlen_t sb_rbmblocks
; /* number of rt bitmap blocks */
129 xfs_extlen_t sb_logblocks
; /* number of log blocks */
130 __uint16_t sb_versionnum
; /* header version == XFS_SB_VERSION */
131 __uint16_t sb_sectsize
; /* volume sector size, bytes */
132 __uint16_t sb_inodesize
; /* inode size, bytes */
133 __uint16_t sb_inopblock
; /* inodes per block */
134 char sb_fname
[12]; /* file system name */
135 __uint8_t sb_blocklog
; /* log2 of sb_blocksize */
136 __uint8_t sb_sectlog
; /* log2 of sb_sectsize */
137 __uint8_t sb_inodelog
; /* log2 of sb_inodesize */
138 __uint8_t sb_inopblog
; /* log2 of sb_inopblock */
139 __uint8_t sb_agblklog
; /* log2 of sb_agblocks (rounded up) */
140 __uint8_t sb_rextslog
; /* log2 of sb_rextents */
141 __uint8_t sb_inprogress
; /* mkfs is in progress, don't mount */
142 __uint8_t sb_imax_pct
; /* max % of fs for inode space */
145 * These fields must remain contiguous. If you really
146 * want to change their layout, make sure you fix the
147 * code in xfs_trans_apply_sb_deltas().
149 __uint64_t sb_icount
; /* allocated inodes */
150 __uint64_t sb_ifree
; /* free inodes */
151 __uint64_t sb_fdblocks
; /* free data blocks */
152 __uint64_t sb_frextents
; /* free realtime extents */
154 * End contiguous fields.
156 xfs_ino_t sb_uquotino
; /* user quota inode */
157 xfs_ino_t sb_gquotino
; /* group quota inode */
158 __uint16_t sb_qflags
; /* quota flags */
159 __uint8_t sb_flags
; /* misc. flags */
160 __uint8_t sb_shared_vn
; /* shared version number */
161 xfs_extlen_t sb_inoalignmt
; /* inode chunk alignment, fsblocks */
162 __uint32_t sb_unit
; /* stripe or raid unit */
163 __uint32_t sb_width
; /* stripe or raid width */
164 __uint8_t sb_dirblklog
; /* log2 of dir block size (fsbs) */
165 __uint8_t sb_logsectlog
; /* log2 of the log sector size */
166 __uint16_t sb_logsectsize
; /* sector size for the log, bytes */
167 __uint32_t sb_logsunit
; /* stripe unit size for the log */
168 __uint32_t sb_features2
; /* additional feature bits */
172 * Sequence number values for the fields.
175 XFS_SBS_MAGICNUM
, XFS_SBS_BLOCKSIZE
, XFS_SBS_DBLOCKS
, XFS_SBS_RBLOCKS
,
176 XFS_SBS_REXTENTS
, XFS_SBS_UUID
, XFS_SBS_LOGSTART
, XFS_SBS_ROOTINO
,
177 XFS_SBS_RBMINO
, XFS_SBS_RSUMINO
, XFS_SBS_REXTSIZE
, XFS_SBS_AGBLOCKS
,
178 XFS_SBS_AGCOUNT
, XFS_SBS_RBMBLOCKS
, XFS_SBS_LOGBLOCKS
,
179 XFS_SBS_VERSIONNUM
, XFS_SBS_SECTSIZE
, XFS_SBS_INODESIZE
,
180 XFS_SBS_INOPBLOCK
, XFS_SBS_FNAME
, XFS_SBS_BLOCKLOG
,
181 XFS_SBS_SECTLOG
, XFS_SBS_INODELOG
, XFS_SBS_INOPBLOG
, XFS_SBS_AGBLKLOG
,
182 XFS_SBS_REXTSLOG
, XFS_SBS_INPROGRESS
, XFS_SBS_IMAX_PCT
, XFS_SBS_ICOUNT
,
183 XFS_SBS_IFREE
, XFS_SBS_FDBLOCKS
, XFS_SBS_FREXTENTS
, XFS_SBS_UQUOTINO
,
184 XFS_SBS_GQUOTINO
, XFS_SBS_QFLAGS
, XFS_SBS_FLAGS
, XFS_SBS_SHARED_VN
,
185 XFS_SBS_INOALIGNMT
, XFS_SBS_UNIT
, XFS_SBS_WIDTH
, XFS_SBS_DIRBLKLOG
,
186 XFS_SBS_LOGSECTLOG
, XFS_SBS_LOGSECTSIZE
, XFS_SBS_LOGSUNIT
,
192 * Mask values, defined based on the xfs_sb_field_t values.
193 * Only define the ones we're using.
195 #define XFS_SB_MVAL(x) (1LL << XFS_SBS_ ## x)
196 #define XFS_SB_UUID XFS_SB_MVAL(UUID)
197 #define XFS_SB_FNAME XFS_SB_MVAL(FNAME)
198 #define XFS_SB_ROOTINO XFS_SB_MVAL(ROOTINO)
199 #define XFS_SB_RBMINO XFS_SB_MVAL(RBMINO)
200 #define XFS_SB_RSUMINO XFS_SB_MVAL(RSUMINO)
201 #define XFS_SB_VERSIONNUM XFS_SB_MVAL(VERSIONNUM)
202 #define XFS_SB_UQUOTINO XFS_SB_MVAL(UQUOTINO)
203 #define XFS_SB_GQUOTINO XFS_SB_MVAL(GQUOTINO)
204 #define XFS_SB_QFLAGS XFS_SB_MVAL(QFLAGS)
205 #define XFS_SB_SHARED_VN XFS_SB_MVAL(SHARED_VN)
206 #define XFS_SB_UNIT XFS_SB_MVAL(UNIT)
207 #define XFS_SB_WIDTH XFS_SB_MVAL(WIDTH)
208 #define XFS_SB_FEATURES2 XFS_SB_MVAL(FEATURES2)
209 #define XFS_SB_NUM_BITS ((int)XFS_SBS_FIELDCOUNT)
210 #define XFS_SB_ALL_BITS ((1LL << XFS_SB_NUM_BITS) - 1)
211 #define XFS_SB_MOD_BITS \
212 (XFS_SB_UUID | XFS_SB_ROOTINO | XFS_SB_RBMINO | XFS_SB_RSUMINO | \
213 XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
214 XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
219 * Misc. Flags - warning - these will be cleared by xfs_repair unless
220 * a feature bit is set when the flag is used.
222 #define XFS_SBF_NOFLAGS 0x00 /* no flags set */
223 #define XFS_SBF_READONLY 0x01 /* only read-only mounts allowed */
226 * define max. shared version we can interoperate with
228 #define XFS_SB_MAX_SHARED_VN 0
230 #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
232 #define XFS_SB_GOOD_VERSION(sbp) xfs_sb_good_version(sbp)
234 static inline int xfs_sb_good_version(xfs_sb_t
*sbp
)
236 return (((sbp
->sb_versionnum
>= XFS_SB_VERSION_1
) && \
237 (sbp
->sb_versionnum
<= XFS_SB_VERSION_3
)) || \
238 ((XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
239 !((sbp
->sb_versionnum
& ~XFS_SB_VERSION_OKREALBITS
) || \
240 ((sbp
->sb_versionnum
& XFS_SB_VERSION_MOREBITSBIT
) && \
241 (sbp
->sb_features2
& ~XFS_SB_VERSION2_OKREALBITS
))) && \
242 (sbp
->sb_shared_vn
<= XFS_SB_MAX_SHARED_VN
)));
245 static inline int xfs_sb_good_version(xfs_sb_t
*sbp
)
247 return (((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_OKREALBITS
) || \
251 ((sbp
->sb_versionnum
& XFS_SB_VERSION_MOREBITSBIT
) && \
252 (sbp
->sb_features2
& ~XFS_SB_VERSION2_OKREALBITS
))) && \
253 (!(sbp
->sb_versionnum
& XFS_SB_VERSION_SHAREDBIT
) || \
254 (sbp
->sb_shared_vn
<= XFS_SB_MAX_SHARED_VN
))));
256 #endif /* __KERNEL__ */
258 #define XFS_SB_GOOD_SASH_VERSION(sbp) \
259 ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
260 ((sbp)->sb_versionnum <= XFS_SB_VERSION_3)) || \
261 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
262 !((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKSASHBITS)))
264 #define XFS_SB_VERSION_TONEW(v) xfs_sb_version_tonew(v)
265 static inline unsigned xfs_sb_version_tonew(unsigned v
)
267 return ((((v
) == XFS_SB_VERSION_1
) ? \
269 (((v
) == XFS_SB_VERSION_2
) ? \
270 XFS_SB_VERSION_ATTRBIT
: \
271 (XFS_SB_VERSION_ATTRBIT
| XFS_SB_VERSION_NLINKBIT
))) | \
275 #define XFS_SB_VERSION_TOOLD(v) xfs_sb_version_toold(v)
276 static inline unsigned xfs_sb_version_toold(unsigned v
)
278 return (((v
) & (XFS_SB_VERSION_QUOTABIT
| XFS_SB_VERSION_ALIGNBIT
)) ? \
280 (((v
) & XFS_SB_VERSION_NLINKBIT
) ? \
282 (((v
) & XFS_SB_VERSION_ATTRBIT
) ? \
287 #define XFS_SB_VERSION_HASATTR(sbp) xfs_sb_version_hasattr(sbp)
288 static inline int xfs_sb_version_hasattr(xfs_sb_t
*sbp
)
290 return ((sbp
)->sb_versionnum
== XFS_SB_VERSION_2
) || \
291 ((sbp
)->sb_versionnum
== XFS_SB_VERSION_3
) || \
292 ((XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
293 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_ATTRBIT
));
296 #define XFS_SB_VERSION_ADDATTR(sbp) xfs_sb_version_addattr(sbp)
297 static inline void xfs_sb_version_addattr(xfs_sb_t
*sbp
)
299 (sbp
)->sb_versionnum
= (((sbp
)->sb_versionnum
== XFS_SB_VERSION_1
) ? \
301 ((XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) ? \
302 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_ATTRBIT
) : \
303 (XFS_SB_VERSION_4
| XFS_SB_VERSION_ATTRBIT
)));
306 #define XFS_SB_VERSION_HASNLINK(sbp) xfs_sb_version_hasnlink(sbp)
307 static inline int xfs_sb_version_hasnlink(xfs_sb_t
*sbp
)
309 return ((sbp
)->sb_versionnum
== XFS_SB_VERSION_3
) || \
310 ((XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
311 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_NLINKBIT
));
314 #define XFS_SB_VERSION_ADDNLINK(sbp) xfs_sb_version_addnlink(sbp)
315 static inline void xfs_sb_version_addnlink(xfs_sb_t
*sbp
)
317 (sbp
)->sb_versionnum
= ((sbp
)->sb_versionnum
<= XFS_SB_VERSION_2
? \
319 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_NLINKBIT
));
322 #define XFS_SB_VERSION_HASQUOTA(sbp) xfs_sb_version_hasquota(sbp)
323 static inline int xfs_sb_version_hasquota(xfs_sb_t
*sbp
)
325 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
326 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_QUOTABIT
);
329 #define XFS_SB_VERSION_ADDQUOTA(sbp) xfs_sb_version_addquota(sbp)
330 static inline void xfs_sb_version_addquota(xfs_sb_t
*sbp
)
332 (sbp
)->sb_versionnum
= \
333 (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
? \
334 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_QUOTABIT
) : \
335 (XFS_SB_VERSION_TONEW((sbp
)->sb_versionnum
) | \
336 XFS_SB_VERSION_QUOTABIT
));
339 #define XFS_SB_VERSION_HASALIGN(sbp) xfs_sb_version_hasalign(sbp)
340 static inline int xfs_sb_version_hasalign(xfs_sb_t
*sbp
)
342 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
343 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_ALIGNBIT
);
346 #define XFS_SB_VERSION_SUBALIGN(sbp) xfs_sb_version_subalign(sbp)
347 static inline void xfs_sb_version_subalign(xfs_sb_t
*sbp
)
349 (sbp
)->sb_versionnum
= \
350 XFS_SB_VERSION_TOOLD((sbp
)->sb_versionnum
& ~XFS_SB_VERSION_ALIGNBIT
);
353 #define XFS_SB_VERSION_HASDALIGN(sbp) xfs_sb_version_hasdalign(sbp)
354 static inline int xfs_sb_version_hasdalign(xfs_sb_t
*sbp
)
356 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
357 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_DALIGNBIT
);
360 #define XFS_SB_VERSION_ADDDALIGN(sbp) xfs_sb_version_adddalign(sbp)
361 static inline int xfs_sb_version_adddalign(xfs_sb_t
*sbp
)
363 return (sbp
)->sb_versionnum
= \
364 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_DALIGNBIT
);
367 #define XFS_SB_VERSION_HASSHARED(sbp) xfs_sb_version_hasshared(sbp)
368 static inline int xfs_sb_version_hasshared(xfs_sb_t
*sbp
)
370 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
371 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_SHAREDBIT
);
374 #define XFS_SB_VERSION_ADDSHARED(sbp) xfs_sb_version_addshared(sbp)
375 static inline int xfs_sb_version_addshared(xfs_sb_t
*sbp
)
377 return (sbp
)->sb_versionnum
= \
378 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_SHAREDBIT
);
381 #define XFS_SB_VERSION_SUBSHARED(sbp) xfs_sb_version_subshared(sbp)
382 static inline int xfs_sb_version_subshared(xfs_sb_t
*sbp
)
384 return (sbp
)->sb_versionnum
= \
385 ((sbp
)->sb_versionnum
& ~XFS_SB_VERSION_SHAREDBIT
);
388 #define XFS_SB_VERSION_HASDIRV2(sbp) xfs_sb_version_hasdirv2(sbp)
389 static inline int xfs_sb_version_hasdirv2(xfs_sb_t
*sbp
)
391 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
392 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_DIRV2BIT
);
395 #define XFS_SB_VERSION_HASLOGV2(sbp) xfs_sb_version_haslogv2(sbp)
396 static inline int xfs_sb_version_haslogv2(xfs_sb_t
*sbp
)
398 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
399 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_LOGV2BIT
);
402 #define XFS_SB_VERSION_HASEXTFLGBIT(sbp) xfs_sb_version_hasextflgbit(sbp)
403 static inline int xfs_sb_version_hasextflgbit(xfs_sb_t
*sbp
)
405 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
406 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_EXTFLGBIT
);
409 #define XFS_SB_VERSION_ADDEXTFLGBIT(sbp) xfs_sb_version_addextflgbit(sbp)
410 static inline int xfs_sb_version_addextflgbit(xfs_sb_t
*sbp
)
412 return (sbp
)->sb_versionnum
= \
413 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_EXTFLGBIT
);
416 #define XFS_SB_VERSION_SUBEXTFLGBIT(sbp) xfs_sb_version_subextflgbit(sbp)
417 static inline int xfs_sb_version_subextflgbit(xfs_sb_t
*sbp
)
419 return (sbp
)->sb_versionnum
= \
420 ((sbp
)->sb_versionnum
& ~XFS_SB_VERSION_EXTFLGBIT
);
423 #define XFS_SB_VERSION_HASSECTOR(sbp) xfs_sb_version_hassector(sbp)
424 static inline int xfs_sb_version_hassector(xfs_sb_t
*sbp
)
426 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
427 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_SECTORBIT
);
430 #define XFS_SB_VERSION_HASMOREBITS(sbp) xfs_sb_version_hasmorebits(sbp)
431 static inline int xfs_sb_version_hasmorebits(xfs_sb_t
*sbp
)
433 return (XFS_SB_VERSION_NUM(sbp
) == XFS_SB_VERSION_4
) && \
434 ((sbp
)->sb_versionnum
& XFS_SB_VERSION_MOREBITSBIT
);
438 * sb_features2 bit version macros.
440 * For example, for a bit defined as XFS_SB_VERSION2_FUNBIT, has a macro:
442 * SB_VERSION_HASFUNBIT(xfs_sb_t *sbp)
443 * ((XFS_SB_VERSION_HASMOREBITS(sbp) &&
444 * ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
447 #define XFS_SB_VERSION_HASATTR2(sbp) xfs_sb_version_hasattr2(sbp)
448 static inline int xfs_sb_version_hasattr2(xfs_sb_t
*sbp
)
450 return (XFS_SB_VERSION_HASMOREBITS(sbp
)) && \
451 ((sbp
)->sb_features2
& XFS_SB_VERSION2_ATTR2BIT
);
454 #define XFS_SB_VERSION_ADDATTR2(sbp) xfs_sb_version_addattr2(sbp)
455 static inline void xfs_sb_version_addattr2(xfs_sb_t
*sbp
)
457 ((sbp
)->sb_versionnum
= \
458 ((sbp
)->sb_versionnum
| XFS_SB_VERSION_MOREBITSBIT
), \
459 ((sbp
)->sb_features2
= \
460 ((sbp
)->sb_features2
| XFS_SB_VERSION2_ATTR2BIT
)));
464 * end of superblock version macros
467 #define XFS_SB_DADDR ((xfs_daddr_t)0) /* daddr in filesystem/ag */
468 #define XFS_SB_BLOCK(mp) XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
469 #define XFS_BUF_TO_SBP(bp) ((xfs_sb_t *)XFS_BUF_PTR(bp))
471 #define XFS_HDR_BLOCK(mp,d) ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
472 #define XFS_DADDR_TO_FSB(mp,d) XFS_AGB_TO_FSB(mp, \
473 XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
474 #define XFS_FSB_TO_DADDR(mp,fsbno) XFS_AGB_TO_DADDR(mp, \
475 XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
478 * File system sector to basic block conversions.
480 #define XFS_FSS_TO_BB(mp,sec) ((sec) << (mp)->m_sectbb_log)
481 #define XFS_BB_TO_FSS(mp,bb) \
482 (((bb) + (XFS_FSS_TO_BB(mp,1) - 1)) >> (mp)->m_sectbb_log)
483 #define XFS_BB_TO_FSST(mp,bb) ((bb) >> (mp)->m_sectbb_log)
486 * File system sector to byte conversions.
488 #define XFS_FSS_TO_B(mp,sectno) ((xfs_fsize_t)(sectno) << (mp)->m_sb.sb_sectlog)
489 #define XFS_B_TO_FSST(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_sectlog)
492 * File system block to basic block conversions.
494 #define XFS_FSB_TO_BB(mp,fsbno) ((fsbno) << (mp)->m_blkbb_log)
495 #define XFS_BB_TO_FSB(mp,bb) \
496 (((bb) + (XFS_FSB_TO_BB(mp,1) - 1)) >> (mp)->m_blkbb_log)
497 #define XFS_BB_TO_FSBT(mp,bb) ((bb) >> (mp)->m_blkbb_log)
498 #define XFS_BB_FSB_OFFSET(mp,bb) ((bb) & ((mp)->m_bsize - 1))
501 * File system block to byte conversions.
503 #define XFS_FSB_TO_B(mp,fsbno) ((xfs_fsize_t)(fsbno) << (mp)->m_sb.sb_blocklog)
504 #define XFS_B_TO_FSB(mp,b) \
505 ((((__uint64_t)(b)) + (mp)->m_blockmask) >> (mp)->m_sb.sb_blocklog)
506 #define XFS_B_TO_FSBT(mp,b) (((__uint64_t)(b)) >> (mp)->m_sb.sb_blocklog)
507 #define XFS_B_FSB_OFFSET(mp,b) ((b) & (mp)->m_blockmask)
509 #endif /* __XFS_SB_H__ */