← Back to branch summary

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

« back to all changes in this revision

Viewing changes to include/xfs_dinode.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_dinode.h
1
1
/*
2
 
 * Copyright (c) 2000, 2002 Silicon Graphics, Inc.  All Rights Reserved.
 
2
 * Copyright (c) 2000,2002,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_DINODE_H__
33
19
#define __XFS_DINODE_H__
37
23
 
38
24
#define XFS_DINODE_VERSION_1    1
39
25
#define XFS_DINODE_VERSION_2    2
40
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DINODE_GOOD_VERSION)
41
 
int xfs_dinode_good_version(int v);
42
 
#define XFS_DINODE_GOOD_VERSION(v)      xfs_dinode_good_version(v)
43
 
#else
44
 
#define XFS_DINODE_GOOD_VERSION(v)      (((v) == XFS_DINODE_VERSION_1) || \
45
 
                                         ((v) == XFS_DINODE_VERSION_2))
46
 
#endif
 
26
#define XFS_DINODE_GOOD_VERSION(v)      \
 
27
        (((v) == XFS_DINODE_VERSION_1 || (v) == XFS_DINODE_VERSION_2))
47
28
#define XFS_DINODE_MAGIC        0x494e  /* 'IN' */
48
29
 
49
30
/*
184
165
/*
185
166
 * Inode size for given fs.
186
167
 */
187
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LITINO)
188
 
int xfs_litino(struct xfs_mount *mp);
189
 
#define XFS_LITINO(mp)          xfs_litino(mp)
190
 
#else
191
168
#define XFS_LITINO(mp)  ((mp)->m_litino)
192
 
#endif
193
169
#define XFS_BROOT_SIZE_ADJ      \
194
170
        (sizeof(xfs_bmbt_block_t) - sizeof(xfs_bmdr_block_t))
195
171
 
196
172
/*
197
 
 * Fork identifiers.  Here so utilities can use them without including
198
 
 * xfs_inode.h.
199
 
 */
200
 
#define XFS_DATA_FORK   0
201
 
#define XFS_ATTR_FORK   1
202
 
 
203
 
/*
204
173
 * Inode data & attribute fork sizes, per inode.
205
174
 */
206
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_Q)
207
 
int xfs_cfork_q_arch(xfs_dinode_core_t *dcp, xfs_arch_t arch);
208
 
int xfs_cfork_q(xfs_dinode_core_t *dcp);
209
 
#define XFS_CFORK_Q_ARCH(dcp,arch)          xfs_cfork_q_arch(dcp,arch)
210
 
#define XFS_CFORK_Q(dcp)                    xfs_cfork_q(dcp)
211
 
#else
212
 
#define XFS_CFORK_Q_ARCH(dcp,arch)          (!INT_ISZERO((dcp)->di_forkoff, arch))
213
175
#define XFS_CFORK_Q(dcp)                    ((dcp)->di_forkoff != 0)
 
176
#define XFS_CFORK_Q_DISK(dcp)               ((dcp)->di_forkoff != 0)
214
177
 
215
 
#endif
216
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_BOFF)
217
 
int xfs_cfork_boff_arch(xfs_dinode_core_t *dcp, xfs_arch_t arch);
218
 
int xfs_cfork_boff(xfs_dinode_core_t *dcp);
219
 
#define XFS_CFORK_BOFF_ARCH(dcp,arch)       xfs_cfork_boff_arch(dcp,arch)
220
 
#define XFS_CFORK_BOFF(dcp)                 xfs_cfork_boff(dcp)
221
 
#else
222
 
#define XFS_CFORK_BOFF_ARCH(dcp,arch)       ((int)(INT_GET((dcp)->di_forkoff, arch) << 3))
223
178
#define XFS_CFORK_BOFF(dcp)                 ((int)((dcp)->di_forkoff << 3))
 
179
#define XFS_CFORK_BOFF_DISK(dcp) \
 
180
        ((int)(INT_GET((dcp)->di_forkoff, ARCH_CONVERT) << 3))
224
181
 
225
 
#endif
226
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_DSIZE)
227
 
int xfs_cfork_dsize_arch(xfs_dinode_core_t *dcp, struct xfs_mount *mp, xfs_arch_t arch);
228
 
int xfs_cfork_dsize(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
229
 
#define XFS_CFORK_DSIZE_ARCH(dcp,mp,arch)   xfs_cfork_dsize_arch(dcp,mp,arch)
230
 
#define XFS_CFORK_DSIZE(dcp,mp)             xfs_cfork_dsize(dcp,mp)
231
 
#else
232
 
#define XFS_CFORK_DSIZE_ARCH(dcp,mp,arch) \
233
 
        (XFS_CFORK_Q_ARCH(dcp, arch) ? XFS_CFORK_BOFF_ARCH(dcp, arch) : XFS_LITINO(mp))
 
182
#define XFS_CFORK_DSIZE_DISK(dcp,mp) \
 
183
        (XFS_CFORK_Q_DISK(dcp) ? XFS_CFORK_BOFF_DISK(dcp) : XFS_LITINO(mp))
234
184
#define XFS_CFORK_DSIZE(dcp,mp) \
235
185
        (XFS_CFORK_Q(dcp) ? XFS_CFORK_BOFF(dcp) : XFS_LITINO(mp))
236
186
 
237
 
#endif
238
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_ASIZE)
239
 
int xfs_cfork_asize_arch(xfs_dinode_core_t *dcp, struct xfs_mount *mp, xfs_arch_t arch);
240
 
int xfs_cfork_asize(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
241
 
#define XFS_CFORK_ASIZE_ARCH(dcp,mp,arch)   xfs_cfork_asize_arch(dcp,mp,arch)
242
 
#define XFS_CFORK_ASIZE(dcp,mp)             xfs_cfork_asize(dcp,mp)
243
 
#else
244
 
#define XFS_CFORK_ASIZE_ARCH(dcp,mp,arch) \
245
 
        (XFS_CFORK_Q_ARCH(dcp, arch) ? XFS_LITINO(mp) - XFS_CFORK_BOFF_ARCH(dcp, arch) : 0)
 
187
#define XFS_CFORK_ASIZE_DISK(dcp,mp) \
 
188
        (XFS_CFORK_Q_DISK(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF_DISK(dcp) : 0)
246
189
#define XFS_CFORK_ASIZE(dcp,mp) \
247
190
        (XFS_CFORK_Q(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF(dcp) : 0)
248
191
 
249
 
#endif
250
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_SIZE)
251
 
int xfs_cfork_size_arch(xfs_dinode_core_t *dcp, struct xfs_mount *mp, int w, xfs_arch_t arch);
252
 
int xfs_cfork_size(xfs_dinode_core_t *dcp, struct xfs_mount *mp, int w);
253
 
#define XFS_CFORK_SIZE_ARCH(dcp,mp,w,arch)  xfs_cfork_size_arch(dcp,mp,w,arch)
254
 
#define XFS_CFORK_SIZE(dcp,mp,w)            xfs_cfork_size(dcp,mp,w)
255
 
#else
256
 
#define XFS_CFORK_SIZE_ARCH(dcp,mp,w,arch) \
 
192
#define XFS_CFORK_SIZE_DISK(dcp,mp,w) \
257
193
        ((w) == XFS_DATA_FORK ? \
258
 
                XFS_CFORK_DSIZE_ARCH(dcp, mp, arch) : XFS_CFORK_ASIZE_ARCH(dcp, mp, arch))
 
194
                XFS_CFORK_DSIZE_DISK(dcp, mp) : \
 
195
                XFS_CFORK_ASIZE_DISK(dcp, mp))
259
196
#define XFS_CFORK_SIZE(dcp,mp,w) \
260
197
        ((w) == XFS_DATA_FORK ? \
261
198
                XFS_CFORK_DSIZE(dcp, mp) : XFS_CFORK_ASIZE(dcp, mp))
262
199
 
263
 
#endif
264
 
 
265
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_DSIZE)
266
 
int xfs_dfork_dsize_arch(xfs_dinode_t *dip, struct xfs_mount *mp, xfs_arch_t arch);
267
 
int xfs_dfork_dsize(xfs_dinode_t *dip, struct xfs_mount *mp);
268
 
#define XFS_DFORK_DSIZE_ARCH(dip,mp,arch)   xfs_dfork_dsize_arch(dip,mp,arch)
269
 
#define XFS_DFORK_DSIZE(dip,mp)             xfs_dfork_dsize(dip,mp)
270
 
#else
271
 
#define XFS_DFORK_DSIZE_ARCH(dip,mp,arch)   XFS_CFORK_DSIZE_ARCH(&(dip)->di_core, mp, arch)
272
 
#define XFS_DFORK_DSIZE(dip,mp)             XFS_DFORK_DSIZE_ARCH(dip,mp,ARCH_NOCONVERT)
273
 
 
274
 
#endif
275
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_ASIZE)
276
 
int xfs_dfork_asize_arch(xfs_dinode_t *dip, struct xfs_mount *mp, xfs_arch_t arch);
277
 
int xfs_dfork_asize(xfs_dinode_t *dip, struct xfs_mount *mp);
278
 
#define XFS_DFORK_ASIZE_ARCH(dip,mp,arch)   xfs_dfork_asize_arch(dip,mp,arch)
279
 
#define XFS_DFORK_ASIZE(dip,mp)             xfs_dfork_asize(dip,mp)
280
 
#else
281
 
#define XFS_DFORK_ASIZE_ARCH(dip,mp,arch)   XFS_CFORK_ASIZE_ARCH(&(dip)->di_core, mp, arch)
282
 
#define XFS_DFORK_ASIZE(dip,mp)             XFS_DFORK_ASIZE_ARCH(dip,mp,ARCH_NOCONVERT)
283
 
 
284
 
#endif
285
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_SIZE)
286
 
int xfs_dfork_size_arch(xfs_dinode_t *dip, struct xfs_mount *mp, int w, xfs_arch_t arch);
287
 
int xfs_dfork_size(xfs_dinode_t *dip, struct xfs_mount *mp, int w);
288
 
#define XFS_DFORK_SIZE_ARCH(dip,mp,w,arch)  xfs_dfork_size_arch(dip,mp,w,arch)
289
 
#define XFS_DFORK_SIZE(dip,mp,w)            xfs_dfork_size(dip,mp,w)
290
 
#else
291
 
#define XFS_DFORK_SIZE_ARCH(dip,mp,w,arch)  XFS_CFORK_SIZE_ARCH(&(dip)->di_core, mp, w, arch)
292
 
#define XFS_DFORK_SIZE(dip,mp,w)            XFS_DFORK_SIZE_ARCH(dip,mp,w,ARCH_NOCONVERT)
293
 
 
294
 
#endif
295
 
 
296
 
/*
297
 
 * Macros for accessing per-fork disk inode information.
298
 
 */
299
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_Q)
300
 
int xfs_dfork_q_arch(xfs_dinode_t *dip, xfs_arch_t arch);
301
 
int xfs_dfork_q(xfs_dinode_t *dip);
302
 
#define XFS_DFORK_Q_ARCH(dip,arch)          xfs_dfork_q_arch(dip,arch)
303
 
#define XFS_DFORK_Q(dip)                    xfs_dfork_q(dip)
304
 
#else
305
 
#define XFS_DFORK_Q_ARCH(dip,arch)          XFS_CFORK_Q_ARCH(&(dip)->di_core, arch)
306
 
#define XFS_DFORK_Q(dip)                    XFS_DFORK_Q_ARCH(dip,ARCH_NOCONVERT)
307
 
 
308
 
#endif
309
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_BOFF)
310
 
int xfs_dfork_boff_arch(xfs_dinode_t *dip, xfs_arch_t arch);
311
 
int xfs_dfork_boff(xfs_dinode_t *dip);
312
 
#define XFS_DFORK_BOFF_ARCH(dip,arch)       xfs_dfork_boff_arch(dip,arch)
313
 
#define XFS_DFORK_BOFF(dip)                 xfs_dfork_boff(dip)
314
 
#else
315
 
#define XFS_DFORK_BOFF_ARCH(dip,arch)       XFS_CFORK_BOFF_ARCH(&(dip)->di_core, arch)
316
 
#define XFS_DFORK_BOFF(dip)                 XFS_DFORK_BOFF_ARCH(dip,ARCH_NOCONVERT)
317
 
 
318
 
#endif
319
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_DPTR)
320
 
char *xfs_dfork_dptr_arch(xfs_dinode_t *dip, xfs_arch_t arch);
321
 
char *xfs_dfork_dptr(xfs_dinode_t *dip);
322
 
#define XFS_DFORK_DPTR_ARCH(dip,arch)       xfs_dfork_dptr_arch(dip,arch)
323
 
#define XFS_DFORK_DPTR(dip)                 xfs_dfork_dptr(dip)
324
 
#else
325
 
#define XFS_DFORK_DPTR_ARCH(dip,arch)       ((dip)->di_u.di_c)
326
 
#define XFS_DFORK_DPTR(dip)                 XFS_DFORK_DPTR_ARCH(dip,ARCH_NOCONVERT)
327
 
 
328
 
#endif
329
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_APTR)
330
 
char *xfs_dfork_aptr_arch(xfs_dinode_t *dip, xfs_arch_t arch);
331
 
char *xfs_dfork_aptr(xfs_dinode_t *dip);
332
 
#define XFS_DFORK_APTR_ARCH(dip,arch)       xfs_dfork_aptr_arch(dip,arch)
333
 
#define XFS_DFORK_APTR(dip)                 xfs_dfork_aptr(dip)
334
 
#else
335
 
#define XFS_DFORK_APTR_ARCH(dip,arch)       ((dip)->di_u.di_c + XFS_DFORK_BOFF_ARCH(dip, arch))
336
 
#define XFS_DFORK_APTR(dip)                 XFS_DFORK_APTR_ARCH(dip,ARCH_NOCONVERT)
337
 
 
338
 
#endif
339
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_PTR)
340
 
char *xfs_dfork_ptr_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch);
341
 
char *xfs_dfork_ptr(xfs_dinode_t *dip, int w);
342
 
#define XFS_DFORK_PTR_ARCH(dip,w,arch)      xfs_dfork_ptr_arch(dip,w,arch)
343
 
#define XFS_DFORK_PTR(dip,w)                xfs_dfork_ptr(dip,w)
344
 
#else
345
 
#define XFS_DFORK_PTR_ARCH(dip,w,arch)  \
346
 
        ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR_ARCH(dip, arch) : XFS_DFORK_APTR_ARCH(dip, arch))
347
 
#define XFS_DFORK_PTR(dip,w)                XFS_DFORK_PTR_ARCH(dip,w,ARCH_NOCONVERT)
348
 
 
349
 
#endif
350
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_FORMAT)
351
 
int xfs_cfork_format_arch(xfs_dinode_core_t *dcp, int w, xfs_arch_t arch);
352
 
int xfs_cfork_format(xfs_dinode_core_t *dcp, int w);
353
 
#define XFS_CFORK_FORMAT_ARCH(dcp,w,arch)   xfs_cfork_format_arch(dcp,w,arch)
354
 
#define XFS_CFORK_FORMAT(dcp,w)             xfs_cfork_format(dcp,w)
355
 
#else
356
 
#define XFS_CFORK_FORMAT_ARCH(dcp,w,arch) \
357
 
        ((w) == XFS_DATA_FORK ? INT_GET((dcp)->di_format, arch) : INT_GET((dcp)->di_aformat, arch))
358
 
#define XFS_CFORK_FORMAT(dcp,w)             XFS_CFORK_FORMAT_ARCH(dcp,w,ARCH_NOCONVERT)
359
 
 
360
 
#endif
361
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_FMT_SET)
362
 
void xfs_cfork_fmt_set_arch(xfs_dinode_core_t *dcp, int w, int n, xfs_arch_t arch);
363
 
void xfs_cfork_fmt_set(xfs_dinode_core_t *dcp, int w, int n);
364
 
#define XFS_CFORK_FMT_SET_ARCH(dcp,w,n,arch) xfs_cfork_fmt_set_arch(dcp,w,n,arch)
365
 
#define XFS_CFORK_FMT_SET(dcp,w,n)           xfs_cfork_fmt_set(dcp,w,n)
366
 
#else
367
 
#define XFS_CFORK_FMT_SET_ARCH(dcp,w,n,arch) \
368
 
        ((w) == XFS_DATA_FORK ? \
369
 
                (INT_SET((dcp)->di_format, arch, (n))) : \
370
 
                (INT_SET((dcp)->di_aformat, arch, (n))))
371
 
#define XFS_CFORK_FMT_SET(dcp,w,n)           XFS_CFORK_FMT_SET_ARCH(dcp,w,n,ARCH_NOCONVERT)
372
 
 
373
 
#endif
374
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_NEXTENTS)
375
 
int xfs_cfork_nextents_arch(xfs_dinode_core_t *dcp, int w, xfs_arch_t arch);
376
 
int xfs_cfork_nextents(xfs_dinode_core_t *dcp, int w);
377
 
#define XFS_CFORK_NEXTENTS_ARCH(dcp,w,arch)  xfs_cfork_nextents_arch(dcp,w,arch)
378
 
#define XFS_CFORK_NEXTENTS(dcp,w)            xfs_cfork_nextents(dcp,w)
379
 
#else
380
 
#define XFS_CFORK_NEXTENTS_ARCH(dcp,w,arch) \
381
 
        ((w) == XFS_DATA_FORK ? INT_GET((dcp)->di_nextents, arch) : INT_GET((dcp)->di_anextents, arch))
382
 
#define XFS_CFORK_NEXTENTS(dcp,w)            XFS_CFORK_NEXTENTS_ARCH(dcp,w,ARCH_NOCONVERT)
383
 
 
384
 
#endif
385
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_NEXT_SET)
386
 
void xfs_cfork_next_set_arch(xfs_dinode_core_t *dcp, int w, int n, xfs_arch_t arch);
387
 
void xfs_cfork_next_set(xfs_dinode_core_t *dcp, int w, int n);
388
 
#define XFS_CFORK_NEXT_SET_ARCH(dcp,w,n,arch)   xfs_cfork_next_set_arch(dcp,w,n,arch)
389
 
#define XFS_CFORK_NEXT_SET(dcp,w,n)             xfs_cfork_next_set(dcp,w,n)
390
 
#else
391
 
#define XFS_CFORK_NEXT_SET_ARCH(dcp,w,n,arch) \
392
 
        ((w) == XFS_DATA_FORK ? \
393
 
                (INT_SET((dcp)->di_nextents, arch, (n))) : \
394
 
                (INT_SET((dcp)->di_anextents, arch, (n))))
395
 
#define XFS_CFORK_NEXT_SET(dcp,w,n)             XFS_CFORK_NEXT_SET_ARCH(dcp,w,n,ARCH_NOCONVERT)
396
 
 
397
 
#endif
398
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_FORMAT)
399
 
int xfs_dfork_format_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch);
400
 
int xfs_dfork_format(xfs_dinode_t *dip, int w);
401
 
#define XFS_DFORK_FORMAT_ARCH(dip,w,arch)   xfs_dfork_format_arch(dip,w,arch)
402
 
#define XFS_DFORK_FORMAT(dip,w)             xfs_dfork_format(dip,w)
403
 
#else
404
 
#define XFS_DFORK_FORMAT_ARCH(dip,w,arch)   XFS_CFORK_FORMAT_ARCH(&(dip)->di_core, w, arch)
405
 
#define XFS_DFORK_FORMAT(dip,w)             XFS_DFORK_FORMAT_ARCH(dip,w,ARCH_NOCONVERT)
406
 
 
407
 
#endif
408
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_FMT_SET)
409
 
void xfs_dfork_fmt_set_arch(xfs_dinode_t *dip, int w, int n, xfs_arch_t arch);
410
 
void xfs_dfork_fmt_set(xfs_dinode_t *dip, int w, int n);
411
 
#define XFS_DFORK_FMT_SET_ARCH(dip,w,n,arch)    xfs_dfork_fmt_set_arch(dip,w,n,arch)
412
 
#define XFS_DFORK_FMT_SET(dip,w,n)              xfs_dfork_fmt_set(dip,w,n)
413
 
#else
414
 
#define XFS_DFORK_FMT_SET_ARCH(dip,w,n,arch)    XFS_CFORK_FMT_SET_ARCH(&(dip)->di_core, w, n, arch)
415
 
#define XFS_DFORK_FMT_SET(dip,w,n)              XFS_DFORK_FMT_SET_ARCH(dip,w,n,ARCH_NOCONVERT)
416
 
 
417
 
#endif
418
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_NEXTENTS)
419
 
int xfs_dfork_nextents_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch);
420
 
int xfs_dfork_nextents(xfs_dinode_t *dip, int w);
421
 
#define XFS_DFORK_NEXTENTS_ARCH(dip,w,arch) xfs_dfork_nextents_arch(dip,w,arch)
422
 
#define XFS_DFORK_NEXTENTS(dip,w)           xfs_dfork_nextents(dip,w)
423
 
#else
424
 
#define XFS_DFORK_NEXTENTS_ARCH(dip,w,arch) XFS_CFORK_NEXTENTS_ARCH(&(dip)->di_core, w, arch)
425
 
#define XFS_DFORK_NEXTENTS(dip,w)           XFS_DFORK_NEXTENTS_ARCH(dip,w,ARCH_NOCONVERT)
426
 
 
427
 
#endif
428
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_NEXT_SET)
429
 
void xfs_dfork_next_set_arch(xfs_dinode_t *dip, int w, int n, xfs_arch_t arch);
430
 
void xfs_dfork_next_set(xfs_dinode_t *dip, int w, int n);
431
 
#define XFS_DFORK_NEXT_SET_ARCH(dip,w,n,arch)   xfs_dfork_next_set_arch(dip,w,n,arch)
432
 
#define XFS_DFORK_NEXT_SET(dip,w,n)             xfs_dfork_next_set(dip,w,n)
433
 
#else
434
 
#define XFS_DFORK_NEXT_SET_ARCH(dip,w,n,arch)   XFS_CFORK_NEXT_SET_ARCH(&(dip)->di_core, w, n, arch)
435
 
#define XFS_DFORK_NEXT_SET(dip,w,n)             XFS_DFORK_NEXT_SET_ARCH(dip,w,n,ARCH_NOCONVERT)
436
 
 
437
 
#endif
438
 
 
439
 
#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_DINODE)
440
 
xfs_dinode_t *xfs_buf_to_dinode(struct xfs_buf *bp);
441
 
#define XFS_BUF_TO_DINODE(bp)   xfs_buf_to_dinode(bp)
442
 
#else
443
 
#define XFS_BUF_TO_DINODE(bp)   ((xfs_dinode_t *)(XFS_BUF_PTR(bp)))
444
 
#endif
 
200
#define XFS_DFORK_DSIZE(dip,mp) \
 
201
        XFS_CFORK_DSIZE_DISK(&(dip)->di_core, mp)
 
202
#define XFS_DFORK_DSIZE_HOST(dip,mp) \
 
203
        XFS_CFORK_DSIZE(&(dip)->di_core, mp)
 
204
#define XFS_DFORK_ASIZE(dip,mp) \
 
205
        XFS_CFORK_ASIZE_DISK(&(dip)->di_core, mp)
 
206
#define XFS_DFORK_ASIZE_HOST(dip,mp) \
 
207
        XFS_CFORK_ASIZE(&(dip)->di_core, mp)
 
208
#define XFS_DFORK_SIZE(dip,mp,w) \
 
209
        XFS_CFORK_SIZE_DISK(&(dip)->di_core, mp, w)
 
210
#define XFS_DFORK_SIZE_HOST(dip,mp,w) \
 
211
        XFS_CFORK_SIZE(&(dip)->di_core, mp, w)
 
212
 
 
213
#define XFS_DFORK_Q(dip)                    XFS_CFORK_Q_DISK(&(dip)->di_core)
 
214
#define XFS_DFORK_BOFF(dip)                 XFS_CFORK_BOFF_DISK(&(dip)->di_core)
 
215
#define XFS_DFORK_DPTR(dip)                 ((dip)->di_u.di_c)
 
216
#define XFS_DFORK_APTR(dip)     \
 
217
        ((dip)->di_u.di_c + XFS_DFORK_BOFF(dip))
 
218
#define XFS_DFORK_PTR(dip,w)    \
 
219
        ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
 
220
#define XFS_CFORK_FORMAT(dcp,w) \
 
221
        ((w) == XFS_DATA_FORK ? (dcp)->di_format : (dcp)->di_aformat)
 
222
#define XFS_CFORK_FMT_SET(dcp,w,n) \
 
223
        ((w) == XFS_DATA_FORK ? \
 
224
                ((dcp)->di_format = (n)) : ((dcp)->di_aformat = (n)))
 
225
#define XFS_DFORK_FORMAT(dip,w) XFS_CFORK_FORMAT(&(dip)->di_core, w)
 
226
 
 
227
#define XFS_CFORK_NEXTENTS_DISK(dcp,w) \
 
228
        ((w) == XFS_DATA_FORK ? \
 
229
                INT_GET((dcp)->di_nextents, ARCH_CONVERT) : \
 
230
                INT_GET((dcp)->di_anextents, ARCH_CONVERT))
 
231
#define XFS_CFORK_NEXTENTS(dcp,w) \
 
232
        ((w) == XFS_DATA_FORK ? (dcp)->di_nextents : (dcp)->di_anextents)
 
233
#define XFS_DFORK_NEXTENTS(dip,w) XFS_CFORK_NEXTENTS_DISK(&(dip)->di_core, w)
 
234
#define XFS_DFORK_NEXTENTS_HOST(dip,w) XFS_CFORK_NEXTENTS(&(dip)->di_core, w)
 
235
 
 
236
#define XFS_CFORK_NEXT_SET(dcp,w,n) \
 
237
        ((w) == XFS_DATA_FORK ? \
 
238
                ((dcp)->di_nextents = (n)) : ((dcp)->di_anextents = (n)))
 
239
 
 
240
#define XFS_BUF_TO_DINODE(bp)   ((xfs_dinode_t *)XFS_BUF_PTR(bp))
445
241
 
446
242
/*
447
243
 * Values for di_flags
457
253
#define XFS_DIFLAG_NOATIME_BIT   6      /* do not update atime */
458
254
#define XFS_DIFLAG_NODUMP_BIT    7      /* do not dump */
459
255
#define XFS_DIFLAG_RTINHERIT_BIT 8      /* create with realtime bit set */
460
 
#define XFS_DIFLAG_PROJINHERIT_BIT  9   /* create with parents projid */
461
 
#define XFS_DIFLAG_NOSYMLINKS_BIT  10   /* disallow symlink creation */
 
256
#define XFS_DIFLAG_PROJINHERIT_BIT   9  /* create with parents projid */
 
257
#define XFS_DIFLAG_NOSYMLINKS_BIT   10  /* disallow symlink creation */
 
258
#define XFS_DIFLAG_EXTSIZE_BIT      11  /* inode extent size allocator hint */
 
259
#define XFS_DIFLAG_EXTSZINHERIT_BIT 12  /* inherit inode extent size */
462
260
#define XFS_DIFLAG_REALTIME      (1 << XFS_DIFLAG_REALTIME_BIT)
463
261
#define XFS_DIFLAG_PREALLOC      (1 << XFS_DIFLAG_PREALLOC_BIT)
464
262
#define XFS_DIFLAG_NEWRTBM       (1 << XFS_DIFLAG_NEWRTBM_BIT)
470
268
#define XFS_DIFLAG_RTINHERIT     (1 << XFS_DIFLAG_RTINHERIT_BIT)
471
269
#define XFS_DIFLAG_PROJINHERIT   (1 << XFS_DIFLAG_PROJINHERIT_BIT)
472
270
#define XFS_DIFLAG_NOSYMLINKS    (1 << XFS_DIFLAG_NOSYMLINKS_BIT)
 
271
#define XFS_DIFLAG_EXTSIZE       (1 << XFS_DIFLAG_EXTSIZE_BIT)
 
272
#define XFS_DIFLAG_EXTSZINHERIT  (1 << XFS_DIFLAG_EXTSZINHERIT_BIT)
473
273
 
474
274
#define XFS_DIFLAG_ANY \
475
275
        (XFS_DIFLAG_REALTIME | XFS_DIFLAG_PREALLOC | XFS_DIFLAG_NEWRTBM | \
476
276
         XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND | XFS_DIFLAG_SYNC | \
477
277
         XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP | XFS_DIFLAG_RTINHERIT | \
478
 
         XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS)
 
278
         XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS | XFS_DIFLAG_EXTSIZE | \
 
279
         XFS_DIFLAG_EXTSZINHERIT)
479
280
 
480
281
#endif  /* __XFS_DINODE_H__ */