← Back to branch summary

~ubuntu-branches/ubuntu/edgy/xfsprogs/edgy

« back to all changes in this revision

Viewing changes to include/xfs_sb.h

  • Committer: Bazaar Package Importer
  • Author(s): Nathan Scott
  • Date: 2005-11-16 16:32:35 UTC
  • Revision ID: james.westby@ubuntu.com-20051116163235-synnef6xjj18ny42
Tags: 2.7.7-1
http://bugs.debian.org/336350
http://bugs.debian.org/249429
http://bugs.debian.org/338207
* New upstream release.
* Add support for (optional) ATTR2 format extension (closes: #336350)
* Allow gcc -pedantic option for C++ <xfs.h> users (closes: #249429)
* Fix segv in xfs_db frag command (closes: #338207)

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/xfs_sb.h
1
1
/*
2
 
 * Copyright (c) 2000-2001 Silicon Graphics, Inc.  All Rights Reserved.
 
2
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 
3
 * All Rights Reserved.
3
4
 *
4
 
 * This program is free software; you can redistribute it and/or modify it
5
 
 * under the terms of version 2 of the GNU General Public License as
 
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
6
7
 * published by the Free Software Foundation.
7
8
 *
8
 
 * This program is distributed in the hope that it would be useful, but
9
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11
 
 *
12
 
 * Further, this software is distributed without any warranty that it is
13
 
 * free of the rightful claim of any third person regarding infringement
14
 
 * or the like.  Any license provided herein, whether implied or
15
 
 * otherwise, applies only to this software file.  Patent licenses, if
16
 
 * any, provided herein do not apply to combinations of this program with
17
 
 * other software, or any other product whatsoever.
18
 
 *
19
 
 * You should have received a copy of the GNU General Public License along
20
 
 * with this program; if not, write the Free Software Foundation, Inc., 59
21
 
 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22
 
 *
23
 
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24
 
 * Mountain View, CA  94043, or:
25
 
 *
26
 
 * http://www.sgi.com
27
 
 *
28
 
 * For further information regarding this notice, see:
29
 
 *
30
 
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 
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.
 
13
 *
 
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
31
17
 */
32
18
#ifndef __XFS_SB_H__
33
19
#define __XFS_SB_H__
72
58
         XFS_SB_VERSION_DALIGNBIT | \
73
59
         XFS_SB_VERSION_SHAREDBIT | \
74
60
         XFS_SB_VERSION_LOGV2BIT | \
75
 
         XFS_SB_VERSION_SECTORBIT)
 
61
         XFS_SB_VERSION_SECTORBIT | \
 
62
         XFS_SB_VERSION_MOREBITSBIT)
76
63
#define XFS_SB_VERSION_OKSASHBITS       \
77
64
        (XFS_SB_VERSION_NUMBITS | \
78
65
         XFS_SB_VERSION_REALFBITS | \
81
68
        (XFS_SB_VERSION_NUMBITS | \
82
69
         XFS_SB_VERSION_OKREALFBITS | \
83
70
         XFS_SB_VERSION_OKSASHFBITS)
84
 
#define XFS_SB_VERSION_MKFS(ia,dia,extflag,dirv2,na,sflag,morebits)     \
85
 
        (((ia) || (dia) || (extflag) || (dirv2) || (na) || (sflag) || \
86
 
          (morebits)) ? \
 
71
#define XFS_SB_VERSION_MKFS(ia,dia,extflag,dirv2,logv2,attrv1,sflag,morebits) \
 
72
        (((ia) || (dia) || (extflag) || (dirv2) || (logv2) || (attrv1) || \
 
73
          (sflag) || (morebits)) ? \
87
74
                (XFS_SB_VERSION_4 | \
88
75
                 ((ia) ? XFS_SB_VERSION_ALIGNBIT : 0) | \
89
76
                 ((dia) ? XFS_SB_VERSION_DALIGNBIT : 0) | \
90
77
                 ((extflag) ? XFS_SB_VERSION_EXTFLGBIT : 0) | \
91
78
                 ((dirv2) ? XFS_SB_VERSION_DIRV2BIT : 0) | \
92
 
                 ((na) ? XFS_SB_VERSION_LOGV2BIT : 0) | \
 
79
                 ((logv2) ? XFS_SB_VERSION_LOGV2BIT : 0) | \
 
80
                 ((attrv1) ? XFS_SB_VERSION_ATTRBIT : 0) | \
93
81
                 ((sflag) ? XFS_SB_VERSION_SECTORBIT : 0) | \
94
82
                 ((morebits) ? XFS_SB_VERSION_MOREBITSBIT : 0)) : \
95
83
                XFS_SB_VERSION_1)
103
91
 */
104
92
#define XFS_SB_VERSION2_REALFBITS       0x00ffffff      /* Mask: features */
105
93
#define XFS_SB_VERSION2_RESERVED1BIT    0x00000001
 
94
#define XFS_SB_VERSION2_RESERVED2BIT    0x00000002
 
95
#define XFS_SB_VERSION2_RESERVED4BIT    0x00000004
 
96
#define XFS_SB_VERSION2_ATTR2BIT        0x00000008      /* Inline attr rework */
106
97
#define XFS_SB_VERSION2_SASHFBITS       0xff000000      /* Mask: features that
107
98
                                                           require changing
108
99
                                                           PROM and SASH */
109
100
 
110
101
#define XFS_SB_VERSION2_OKREALFBITS     \
111
 
        (0)
 
102
        (XFS_SB_VERSION2_ATTR2BIT)
112
103
#define XFS_SB_VERSION2_OKSASHFBITS     \
113
104
        (0)
114
105
#define XFS_SB_VERSION2_OKREALBITS      \
118
109
/*
119
110
 * mkfs macro to set up sb_features2 word
120
111
 */
121
 
#define XFS_SB_VERSION2_MKFS(xyz)       \
122
 
        ((xyz) ? 0 : 0)
 
112
#define XFS_SB_VERSION2_MKFS(resvd1, sbcntr, attrv2)            \
 
113
        (((attrv2) ? XFS_SB_VERSION2_ATTR2BIT : 0))
123
114
 
124
115
typedef struct xfs_sb
125
116
{
176
167
        __uint8_t       sb_logsectlog;  /* log2 of the log sector size */
177
168
        __uint16_t      sb_logsectsize; /* sector size for the log, bytes */
178
169
        __uint32_t      sb_logsunit;    /* stripe unit size for the log */
179
 
        __uint32_t      sb_features2;   /* additonal feature bits */
 
170
        __uint32_t      sb_features2;   /* additional feature bits */
180
171
} xfs_sb_t;
181
172
 
182
173
/*
216
207
#define XFS_SB_SHARED_VN        XFS_SB_MVAL(SHARED_VN)
217
208
#define XFS_SB_UNIT             XFS_SB_MVAL(UNIT)
218
209
#define XFS_SB_WIDTH            XFS_SB_MVAL(WIDTH)
 
210
#define XFS_SB_FEATURES2        XFS_SB_MVAL(FEATURES2)
219
211
#define XFS_SB_NUM_BITS         ((int)XFS_SBS_FIELDCOUNT)
220
212
#define XFS_SB_ALL_BITS         ((1LL << XFS_SB_NUM_BITS) - 1)
221
213
#define XFS_SB_MOD_BITS         \
222
214
        (XFS_SB_UUID | XFS_SB_ROOTINO | XFS_SB_RBMINO | XFS_SB_RSUMINO | \
223
215
         XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
224
 
         XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH)
 
216
         XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
 
217
         XFS_SB_FEATURES2)
 
218
 
225
219
 
226
220
/*
227
221
 * Misc. Flags - warning - these will be cleared by xfs_repair unless
235
229
 */
236
230
#define XFS_SB_MAX_SHARED_VN    0
237
231
 
238
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_NUM)
239
 
int xfs_sb_version_num(xfs_sb_t *sbp);
240
 
#define XFS_SB_VERSION_NUM(sbp) xfs_sb_version_num(sbp)
241
 
#else
242
232
#define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
243
 
#endif
244
233
 
245
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_GOOD_VERSION)
246
 
int xfs_sb_good_version(xfs_sb_t *sbp);
247
234
#define XFS_SB_GOOD_VERSION(sbp)        xfs_sb_good_version(sbp)
248
 
#else
249
 
#define XFS_SB_GOOD_VERSION_INT(sbp)    \
250
 
        ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
251
 
          ((sbp)->sb_versionnum <= XFS_SB_VERSION_3)) || \
252
 
           ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
253
 
            !(((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
254
 
              (((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
255
 
               ((sbp)->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS)))
256
 
 
257
235
#ifdef __KERNEL__
258
 
#define XFS_SB_GOOD_VERSION(sbp)        \
259
 
        (XFS_SB_GOOD_VERSION_INT(sbp) && \
260
 
          (sbp)->sb_shared_vn <= XFS_SB_MAX_SHARED_VN) ))
 
236
static inline int xfs_sb_good_version(xfs_sb_t *sbp)
 
237
{
 
238
        return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
 
239
                  (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
 
240
                   ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
241
                    !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
 
242
                      ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
 
243
                       (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
 
244
                    (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)));
 
245
}
261
246
#else
262
 
/*
263
 
 * extra 2 paren's here (( to unconfuse paren-matching editors
264
 
 * like vi because XFS_SB_GOOD_VERSION_INT is a partial expression
265
 
 * and the two XFS_SB_GOOD_VERSION's each 2 more close paren's to
266
 
 * complete the expression.
267
 
 */
268
 
#define XFS_SB_GOOD_VERSION(sbp)        \
269
 
        (XFS_SB_GOOD_VERSION_INT(sbp) && \
270
 
          (!((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
271
 
           (sbp)->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)) ))
 
247
static inline int xfs_sb_good_version(xfs_sb_t *sbp)
 
248
{
 
249
        return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
 
250
                  (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
 
251
                   ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
252
                    !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
 
253
                      ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
 
254
                       (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
 
255
                  (!(sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
 
256
                   (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN))));
 
257
}
272
258
#endif /* __KERNEL__ */
273
 
#endif
274
259
 
275
260
#define XFS_SB_GOOD_SASH_VERSION(sbp)   \
276
261
        ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
278
263
         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
279
264
          !((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKSASHBITS)))
280
265
 
281
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_TONEW)
282
 
unsigned xfs_sb_version_tonew(unsigned v);
283
266
#define XFS_SB_VERSION_TONEW(v) xfs_sb_version_tonew(v)
284
 
#else
285
 
#define XFS_SB_VERSION_TONEW(v) \
286
 
        ((((v) == XFS_SB_VERSION_1) ? \
 
267
static inline unsigned xfs_sb_version_tonew(unsigned v)
 
268
{
 
269
        return ((((v) == XFS_SB_VERSION_1) ? \
287
270
                0 : \
288
271
                (((v) == XFS_SB_VERSION_2) ? \
289
272
                        XFS_SB_VERSION_ATTRBIT : \
290
273
                        (XFS_SB_VERSION_ATTRBIT | XFS_SB_VERSION_NLINKBIT))) | \
291
 
         XFS_SB_VERSION_4)
292
 
#endif
 
274
                XFS_SB_VERSION_4);
 
275
}
293
276
 
294
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_TOOLD)
295
 
unsigned xfs_sb_version_toold(unsigned v);
296
277
#define XFS_SB_VERSION_TOOLD(v) xfs_sb_version_toold(v)
297
 
#else
298
 
#define XFS_SB_VERSION_TOOLD(v) \
299
 
        (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
 
278
static inline unsigned xfs_sb_version_toold(unsigned v)
 
279
{
 
280
        return (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
300
281
                0 : \
301
282
                (((v) & XFS_SB_VERSION_NLINKBIT) ? \
302
283
                        XFS_SB_VERSION_3 : \
303
284
                        (((v) & XFS_SB_VERSION_ATTRBIT) ?  \
304
285
                                XFS_SB_VERSION_2 : \
305
 
                                XFS_SB_VERSION_1)))
306
 
#endif
 
286
                                XFS_SB_VERSION_1)));
 
287
}
307
288
 
308
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASATTR)
309
 
int xfs_sb_version_hasattr(xfs_sb_t *sbp);
310
289
#define XFS_SB_VERSION_HASATTR(sbp)     xfs_sb_version_hasattr(sbp)
311
 
#else
312
 
#define XFS_SB_VERSION_HASATTR(sbp)     \
313
 
        (((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
314
 
         ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
315
 
         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
316
 
          ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT)))
317
 
#endif
 
290
static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
 
291
{
 
292
        return ((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
 
293
                 ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
 
294
                 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
295
                  ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
 
296
}
318
297
 
319
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDATTR)
320
 
void xfs_sb_version_addattr(xfs_sb_t *sbp);
321
298
#define XFS_SB_VERSION_ADDATTR(sbp)     xfs_sb_version_addattr(sbp)
322
 
#else
323
 
#define XFS_SB_VERSION_ADDATTR(sbp)     \
324
 
        ((sbp)->sb_versionnum = \
325
 
         (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
 
299
static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
 
300
{
 
301
        (sbp)->sb_versionnum = (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
326
302
                XFS_SB_VERSION_2 : \
327
303
                ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) ? \
328
304
                        ((sbp)->sb_versionnum | XFS_SB_VERSION_ATTRBIT) : \
329
 
                        (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT))))
330
 
#endif
 
305
                        (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT)));
 
306
}
331
307
 
332
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASNLINK)
333
 
int xfs_sb_version_hasnlink(xfs_sb_t *sbp);
334
308
#define XFS_SB_VERSION_HASNLINK(sbp)    xfs_sb_version_hasnlink(sbp)
335
 
#else
336
 
#define XFS_SB_VERSION_HASNLINK(sbp)    \
337
 
        (((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
338
 
         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
339
 
          ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT)))
340
 
#endif
 
309
static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
 
310
{
 
311
        return ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
 
312
                 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
313
                  ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
 
314
}
341
315
 
342
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDNLINK)
343
 
void xfs_sb_version_addnlink(xfs_sb_t *sbp);
344
316
#define XFS_SB_VERSION_ADDNLINK(sbp)    xfs_sb_version_addnlink(sbp)
345
 
#else
346
 
#define XFS_SB_VERSION_ADDNLINK(sbp)    \
347
 
        ((sbp)->sb_versionnum = \
348
 
         ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
 
317
static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
 
318
{
 
319
        (sbp)->sb_versionnum = ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
349
320
                XFS_SB_VERSION_3 : \
350
 
                ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT)))
351
 
#endif
 
321
                ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT));
 
322
}
352
323
 
353
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASQUOTA)
354
 
int xfs_sb_version_hasquota(xfs_sb_t *sbp);
355
324
#define XFS_SB_VERSION_HASQUOTA(sbp)    xfs_sb_version_hasquota(sbp)
356
 
#else
357
 
#define XFS_SB_VERSION_HASQUOTA(sbp)    \
358
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
359
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT))
360
 
#endif
 
325
static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
 
326
{
 
327
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
328
                ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
 
329
}
361
330
 
362
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDQUOTA)
363
 
void xfs_sb_version_addquota(xfs_sb_t *sbp);
364
331
#define XFS_SB_VERSION_ADDQUOTA(sbp)    xfs_sb_version_addquota(sbp)
365
 
#else
366
 
#define XFS_SB_VERSION_ADDQUOTA(sbp)    \
367
 
        ((sbp)->sb_versionnum = \
368
 
         (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
369
 
                ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
370
 
                (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
371
 
                 XFS_SB_VERSION_QUOTABIT)))
372
 
#endif
 
332
static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
 
333
{
 
334
        (sbp)->sb_versionnum = \
 
335
                 (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
 
336
                        ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
 
337
                        (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
 
338
                         XFS_SB_VERSION_QUOTABIT));
 
339
}
373
340
 
374
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASALIGN)
375
 
int xfs_sb_version_hasalign(xfs_sb_t *sbp);
376
341
#define XFS_SB_VERSION_HASALIGN(sbp)    xfs_sb_version_hasalign(sbp)
377
 
#else
378
 
#define XFS_SB_VERSION_HASALIGN(sbp)    \
379
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
380
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT))
381
 
#endif
 
342
static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
 
343
{
 
344
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
345
                ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
 
346
}
382
347
 
383
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBALIGN)
384
 
void xfs_sb_version_subalign(xfs_sb_t *sbp);
385
348
#define XFS_SB_VERSION_SUBALIGN(sbp)    xfs_sb_version_subalign(sbp)
386
 
#else
387
 
#define XFS_SB_VERSION_SUBALIGN(sbp)    \
388
 
        ((sbp)->sb_versionnum = \
389
 
         XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT))
390
 
#endif
 
349
static inline void xfs_sb_version_subalign(xfs_sb_t *sbp)
 
350
{
 
351
        (sbp)->sb_versionnum = \
 
352
         XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT);
 
353
}
391
354
 
392
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASDALIGN)
393
 
int xfs_sb_version_hasdalign(xfs_sb_t *sbp);
394
355
#define XFS_SB_VERSION_HASDALIGN(sbp)   xfs_sb_version_hasdalign(sbp)
395
 
#else
396
 
#define XFS_SB_VERSION_HASDALIGN(sbp)   \
397
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
398
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT))
399
 
#endif
 
356
static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
 
357
{
 
358
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
359
                ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
 
360
}
400
361
 
401
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDDALIGN)
402
 
int xfs_sb_version_adddalign(xfs_sb_t *sbp);
403
362
#define XFS_SB_VERSION_ADDDALIGN(sbp)   xfs_sb_version_adddalign(sbp)
404
 
#else
405
 
#define XFS_SB_VERSION_ADDDALIGN(sbp)   \
406
 
        ((sbp)->sb_versionnum = \
407
 
                ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT))
408
 
#endif
 
363
static inline int xfs_sb_version_adddalign(xfs_sb_t *sbp)
 
364
{
 
365
        return (sbp)->sb_versionnum = \
 
366
                ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT);
 
367
}
409
368
 
410
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASSHARED)
411
 
int xfs_sb_version_hasshared(xfs_sb_t *sbp);
412
369
#define XFS_SB_VERSION_HASSHARED(sbp)   xfs_sb_version_hasshared(sbp)
413
 
#else
414
 
#define XFS_SB_VERSION_HASSHARED(sbp)   \
415
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
416
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT))
417
 
#endif
 
370
static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
 
371
{
 
372
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
373
                ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
 
374
}
418
375
 
419
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDSHARED)
420
 
int xfs_sb_version_addshared(xfs_sb_t *sbp);
421
376
#define XFS_SB_VERSION_ADDSHARED(sbp)   xfs_sb_version_addshared(sbp)
422
 
#else
423
 
#define XFS_SB_VERSION_ADDSHARED(sbp)   \
424
 
        ((sbp)->sb_versionnum = \
425
 
                ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT))
426
 
#endif
 
377
static inline int xfs_sb_version_addshared(xfs_sb_t *sbp)
 
378
{
 
379
        return (sbp)->sb_versionnum = \
 
380
                ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT);
 
381
}
427
382
 
428
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBSHARED)
429
 
int xfs_sb_version_subshared(xfs_sb_t *sbp);
430
383
#define XFS_SB_VERSION_SUBSHARED(sbp)   xfs_sb_version_subshared(sbp)
431
 
#else
432
 
#define XFS_SB_VERSION_SUBSHARED(sbp)   \
433
 
        ((sbp)->sb_versionnum = \
434
 
                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT))
435
 
#endif
 
384
static inline int xfs_sb_version_subshared(xfs_sb_t *sbp)
 
385
{
 
386
        return (sbp)->sb_versionnum = \
 
387
                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT);
 
388
}
436
389
 
437
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASDIRV2)
438
 
int xfs_sb_version_hasdirv2(xfs_sb_t *sbp);
439
390
#define XFS_SB_VERSION_HASDIRV2(sbp)    xfs_sb_version_hasdirv2(sbp)
440
 
#else
441
 
#define XFS_SB_VERSION_HASDIRV2(sbp)    \
442
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
443
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT))
444
 
#endif
 
391
static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
 
392
{
 
393
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
394
                ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
 
395
}
445
396
 
446
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASLOGV2)
447
 
int xfs_sb_version_haslogv2(xfs_sb_t *sbp);
448
397
#define XFS_SB_VERSION_HASLOGV2(sbp)   xfs_sb_version_haslogv2(sbp)
449
 
#else
450
 
#define XFS_SB_VERSION_HASLOGV2(sbp)   \
451
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
452
 
        ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT))
453
 
#endif
 
398
static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
 
399
{
 
400
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
401
                ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
 
402
}
454
403
 
455
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASEXTFLGBIT)
456
 
int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp);
457
404
#define XFS_SB_VERSION_HASEXTFLGBIT(sbp)        xfs_sb_version_hasextflgbit(sbp)
458
 
#else
459
 
#define XFS_SB_VERSION_HASEXTFLGBIT(sbp)        \
460
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
461
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT))
462
 
#endif
 
405
static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
 
406
{
 
407
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
408
                ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
 
409
}
463
410
 
464
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDEXTFLGBIT)
465
 
int xfs_sb_version_addextflgbit(xfs_sb_t *sbp);
466
411
#define XFS_SB_VERSION_ADDEXTFLGBIT(sbp)        xfs_sb_version_addextflgbit(sbp)
467
 
#else
468
 
#define XFS_SB_VERSION_ADDEXTFLGBIT(sbp)        \
469
 
        ((sbp)->sb_versionnum = \
470
 
                ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT))
471
 
#endif
 
412
static inline int xfs_sb_version_addextflgbit(xfs_sb_t *sbp)
 
413
{
 
414
        return (sbp)->sb_versionnum = \
 
415
                ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT);
 
416
}
472
417
 
473
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBEXTFLGBIT)
474
 
int xfs_sb_version_subextflgbit(xfs_sb_t *sbp);
475
418
#define XFS_SB_VERSION_SUBEXTFLGBIT(sbp)        xfs_sb_version_subextflgbit(sbp)
476
 
#else
477
 
#define XFS_SB_VERSION_SUBEXTFLGBIT(sbp)        \
478
 
        ((sbp)->sb_versionnum = \
479
 
                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT))
480
 
#endif
 
419
static inline int xfs_sb_version_subextflgbit(xfs_sb_t *sbp)
 
420
{
 
421
        return (sbp)->sb_versionnum = \
 
422
                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT);
 
423
}
481
424
 
482
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASSECTOR)
483
 
int xfs_sb_version_hassector(xfs_sb_t *sbp);
484
425
#define XFS_SB_VERSION_HASSECTOR(sbp)   xfs_sb_version_hassector(sbp)
485
 
#else
486
 
#define XFS_SB_VERSION_HASSECTOR(sbp)   \
487
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
488
 
        ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT))
489
 
#endif
 
426
static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
 
427
{
 
428
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
429
                ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
 
430
}
490
431
 
491
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASMOREBITSBIT)
492
 
int xfs_sb_version_hasmorebits(xfs_sb_t *sbp);
493
432
#define XFS_SB_VERSION_HASMOREBITS(sbp) xfs_sb_version_hasmorebits(sbp)
494
 
#else
495
 
#define XFS_SB_VERSION_HASMOREBITS(sbp) \
496
 
        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
497
 
         ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT))
498
 
#endif
 
433
static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
 
434
{
 
435
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
 
436
                ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
 
437
}
499
438
 
500
439
/*
501
440
 * sb_features2 bit version macros.
502
441
 *
503
 
 * For example, for a bit defined as XFS_SB_VERSION2_YBIT, has a macro:
 
442
 * For example, for a bit defined as XFS_SB_VERSION2_FUNBIT, has a macro:
504
443
 *
505
 
 * SB_VERSION_HASYBIT(xfs_sb_t *sbp)
 
444
 * SB_VERSION_HASFUNBIT(xfs_sb_t *sbp)
506
445
 *      ((XFS_SB_VERSION_HASMOREBITS(sbp) &&
507
 
 *       ((sbp)->sb_versionnum & XFS_SB_VERSION2_YBIT)
 
446
 *       ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
508
447
 */
509
448
 
 
449
#define XFS_SB_VERSION_HASATTR2(sbp)    xfs_sb_version_hasattr2(sbp)
 
450
static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
 
451
{
 
452
        return (XFS_SB_VERSION_HASMOREBITS(sbp)) &&     \
 
453
                ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
 
454
}
 
455
 
 
456
#define XFS_SB_VERSION_ADDATTR2(sbp)    xfs_sb_version_addattr2(sbp)
 
457
static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
 
458
{
 
459
        ((sbp)->sb_versionnum = \
 
460
                ((sbp)->sb_versionnum | XFS_SB_VERSION_MOREBITSBIT),    \
 
461
        ((sbp)->sb_features2 =  \
 
462
                ((sbp)->sb_features2 | XFS_SB_VERSION2_ATTR2BIT)));
 
463
}
 
464
 
510
465
/*
511
466
 * end of superblock version macros
512
467
 */
513
468
 
514
 
#define XFS_SB_DADDR    ((xfs_daddr_t)0)        /* daddr in filesystem/ag */
515
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_BLOCK)
516
 
xfs_agblock_t xfs_sb_block(struct xfs_mount *mp);
517
 
#define XFS_SB_BLOCK(mp)        xfs_sb_block(mp)
518
 
#else
 
469
#define XFS_SB_DADDR            ((xfs_daddr_t)0) /* daddr in filesystem/ag */
519
470
#define XFS_SB_BLOCK(mp)        XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
520
 
#endif
521
 
 
522
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_HDR_BLOCK)
523
 
xfs_agblock_t xfs_hdr_block(struct xfs_mount *mp, xfs_daddr_t d);
524
 
#define XFS_HDR_BLOCK(mp,d)     xfs_hdr_block(mp,d)
525
 
#else
526
 
#define XFS_HDR_BLOCK(mp,d)     ((xfs_agblock_t)(XFS_BB_TO_FSBT(mp,d)))
527
 
#endif
528
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DADDR_TO_FSB)
529
 
xfs_fsblock_t xfs_daddr_to_fsb(struct xfs_mount *mp, xfs_daddr_t d);
530
 
#define XFS_DADDR_TO_FSB(mp,d)          xfs_daddr_to_fsb(mp,d)
531
 
#else
532
 
#define XFS_DADDR_TO_FSB(mp,d) \
533
 
        XFS_AGB_TO_FSB(mp, XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
534
 
#endif
535
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_TO_DADDR)
536
 
xfs_daddr_t xfs_fsb_to_daddr(struct xfs_mount *mp, xfs_fsblock_t fsbno);
537
 
#define XFS_FSB_TO_DADDR(mp,fsbno)      xfs_fsb_to_daddr(mp,fsbno)
538
 
#else
539
 
#define XFS_FSB_TO_DADDR(mp,fsbno) \
540
 
        XFS_AGB_TO_DADDR(mp, XFS_FSB_TO_AGNO(mp,fsbno), \
541
 
                         XFS_FSB_TO_AGBNO(mp,fsbno))
542
 
#endif
543
 
 
544
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_SBP)
545
 
xfs_sb_t *xfs_buf_to_sbp(struct xfs_buf *bp);
546
 
#define XFS_BUF_TO_SBP(bp)      xfs_buf_to_sbp(bp)
547
 
#else
548
471
#define XFS_BUF_TO_SBP(bp)      ((xfs_sb_t *)XFS_BUF_PTR(bp))
549
 
#endif
 
472
 
 
473
#define XFS_HDR_BLOCK(mp,d)     ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
 
474
#define XFS_DADDR_TO_FSB(mp,d)  XFS_AGB_TO_FSB(mp, \
 
475
                        XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
 
476
#define XFS_FSB_TO_DADDR(mp,fsbno)      XFS_AGB_TO_DADDR(mp, \
 
477
                        XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
550
478
 
551
479
/*
552
480
 * File system sector to basic block conversions.