OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [xfs/] [xfs_macros.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix 
/*
2 
 * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
3 
 *
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
6 
 * published by the Free Software Foundation.
7 
 *
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/
31 
 */
32 
 
33 
#define XFS_MACRO_C
34 
 
35 
#include "xfs.h"
36 
#include "xfs_macros.h"
37 
#include "xfs_types.h"
38 
#include "xfs_inum.h"
39 
#include "xfs_log.h"
40 
#include "xfs_trans.h"
41 
#include "xfs_sb.h"
42 
#include "xfs_ag.h"
43 
#include "xfs_dir.h"
44 
#include "xfs_dir2.h"
45 
#include "xfs_dmapi.h"
46 
#include "xfs_mount.h"
47 
#include "xfs_alloc_btree.h"
48 
#include "xfs_ialloc_btree.h"
49 
#include "xfs_bmap_btree.h"
50 
#include "xfs_btree.h"
51 
#include "xfs_attr_sf.h"
52 
#include "xfs_dir_sf.h"
53 
#include "xfs_dir2_sf.h"
54 
#include "xfs_dinode.h"
55 
#include "xfs_ialloc.h"
56 
#include "xfs_inode_item.h"
57 
#include "xfs_inode.h"
58 
#include "xfs_bmap.h"
59 
#include "xfs_rw.h"
60 
#include "xfs_log_priv.h"
61 
#include "xfs_da_btree.h"
62 
#include "xfs_attr_leaf.h"
63 
#include "xfs_dir_leaf.h"
64 
#include "xfs_dir2_data.h"
65 
#include "xfs_dir2_leaf.h"
66 
#include "xfs_dir2_block.h"
67 
#include "xfs_dir2_node.h"
68 
#include "xfs_bit.h"
69 
 
70 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_ISNULLDSTARTBLOCK)
71 
int
72 
isnulldstartblock(xfs_dfsbno_t x)
73 
{
74 
        return ISNULLDSTARTBLOCK(x);
75 
}
76 
#endif
77 
 
78 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_ISNULLSTARTBLOCK)
79 
int
80 
isnullstartblock(xfs_fsblock_t x)
81 
{
82 
        return ISNULLSTARTBLOCK(x);
83 
}
84 
#endif
85 
 
86 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_NULLSTARTBLOCK)
87 
xfs_fsblock_t
88 
nullstartblock(int k)
89 
{
90 
        return NULLSTARTBLOCK(k);
91 
}
92 
#endif
93 
 
94 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_STARTBLOCKVAL)
95 
xfs_filblks_t
96 
startblockval(xfs_fsblock_t x)
97 
{
98 
        return STARTBLOCKVAL(x);
99 
}
100 
#endif
101 
 
102 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AG_CHECK_DADDR)
103 
void
104 
xfs_ag_check_daddr(xfs_mount_t *mp, xfs_daddr_t d, xfs_extlen_t len)
105 
{
106 
        XFS_AG_CHECK_DADDR(mp, d, len);
107 
}
108 
#endif
109 
 
110 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AG_DADDR)
111 
xfs_daddr_t
112 
xfs_ag_daddr(xfs_mount_t *mp, xfs_agnumber_t agno, xfs_daddr_t d)
113 
{
114 
        return XFS_AG_DADDR(mp, agno, d);
115 
}
116 
#endif
117 
 
118 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AG_MAXLEVELS)
119 
int
120 
xfs_ag_maxlevels(xfs_mount_t *mp)
121 
{
122 
        return XFS_AG_MAXLEVELS(mp);
123 
}
124 
#endif
125 
 
126 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGB_TO_DADDR)
127 
xfs_daddr_t
128 
xfs_agb_to_daddr(xfs_mount_t *mp, xfs_agnumber_t agno, xfs_agblock_t agbno)
129 
{
130 
        return XFS_AGB_TO_DADDR(mp, agno, agbno);
131 
}
132 
#endif
133 
 
134 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGB_TO_FSB)
135 
xfs_fsblock_t
136 
xfs_agb_to_fsb(xfs_mount_t *mp, xfs_agnumber_t agno, xfs_agblock_t agbno)
137 
{
138 
        return XFS_AGB_TO_FSB(mp, agno, agbno);
139 
}
140 
#endif
141 
 
142 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGBLOCK_MAX)
143 
xfs_agblock_t
144 
xfs_agblock_max(xfs_agblock_t a, xfs_agblock_t b)
145 
{
146 
        return XFS_AGBLOCK_MAX(a, b);
147 
}
148 
#endif
149 
 
150 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGBLOCK_MIN)
151 
xfs_agblock_t
152 
xfs_agblock_min(xfs_agblock_t a, xfs_agblock_t b)
153 
{
154 
        return XFS_AGBLOCK_MIN(a, b);
155 
}
156 
#endif
157 
 
158 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGF_BLOCK)
159 
xfs_agblock_t
160 
xfs_agf_block(xfs_mount_t *mp)
161 
{
162 
        return XFS_AGF_BLOCK(mp);
163 
}
164 
#endif
165 
 
166 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGF_GOOD_VERSION)
167 
int
168 
xfs_agf_good_version(unsigned v)
169 
{
170 
        return XFS_AGF_GOOD_VERSION(v);
171 
}
172 
#endif
173 
 
174 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGFL_BLOCK)
175 
xfs_agblock_t
176 
xfs_agfl_block(xfs_mount_t *mp)
177 
{
178 
        return XFS_AGFL_BLOCK(mp);
179 
}
180 
#endif
181 
 
182 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGI_BLOCK)
183 
xfs_agblock_t
184 
xfs_agi_block(xfs_mount_t *mp)
185 
{
186 
        return XFS_AGI_BLOCK(mp);
187 
}
188 
#endif
189 
 
190 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGI_GOOD_VERSION)
191 
int
192 
xfs_agi_good_version(unsigned v)
193 
{
194 
        return XFS_AGI_GOOD_VERSION(v);
195 
}
196 
#endif
197 
 
198 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGINO_TO_AGBNO)
199 
xfs_agblock_t
200 
xfs_agino_to_agbno(xfs_mount_t *mp, xfs_agino_t i)
201 
{
202 
        return XFS_AGINO_TO_AGBNO(mp, i);
203 
}
204 
#endif
205 
 
206 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGINO_TO_INO)
207 
xfs_ino_t
208 
xfs_agino_to_ino(xfs_mount_t *mp, xfs_agnumber_t a, xfs_agino_t i)
209 
{
210 
        return XFS_AGINO_TO_INO(mp, a, i);
211 
}
212 
#endif
213 
 
214 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_AGINO_TO_OFFSET)
215 
int
216 
xfs_agino_to_offset(xfs_mount_t *mp, xfs_agino_t i)
217 
{
218 
        return XFS_AGINO_TO_OFFSET(mp, i);
219 
}
220 
#endif
221 
 
222 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_BLOCK_MAXRECS)
223 
int
224 
xfs_alloc_block_maxrecs(int lev, xfs_btree_cur_t *cur)
225 
{
226 
        return XFS_ALLOC_BLOCK_MAXRECS(lev, cur);
227 
}
228 
#endif
229 
 
230 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_BLOCK_MINRECS)
231 
int
232 
xfs_alloc_block_minrecs(int lev, xfs_btree_cur_t *cur)
233 
{
234 
        return XFS_ALLOC_BLOCK_MINRECS(lev, cur);
235 
}
236 
#endif
237 
 
238 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_BLOCK_SIZE)
239 
/*ARGSUSED1*/
240 
int
241 
xfs_alloc_block_size(int lev, xfs_btree_cur_t *cur)
242 
{
243 
        return XFS_ALLOC_BLOCK_SIZE(lev, cur);
244 
}
245 
#endif
246 
 
247 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_KEY_ADDR)
248 
/*ARGSUSED3*/
249 
xfs_alloc_key_t *
250 
xfs_alloc_key_addr(xfs_alloc_block_t *bb, int i, xfs_btree_cur_t *cur)
251 
{
252 
        return XFS_ALLOC_KEY_ADDR(bb, i, cur);
253 
}
254 
#endif
255 
 
256 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_PTR_ADDR)
257 
xfs_alloc_ptr_t *
258 
xfs_alloc_ptr_addr(xfs_alloc_block_t *bb, int i, xfs_btree_cur_t *cur)
259 
{
260 
        return XFS_ALLOC_PTR_ADDR(bb, i, cur);
261 
}
262 
#endif
263 
 
264 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ALLOC_REC_ADDR)
265 
/*ARGSUSED3*/
266 
xfs_alloc_rec_t *
267 
xfs_alloc_rec_addr(xfs_alloc_block_t *bb, int i, xfs_btree_cur_t *cur)
268 
{
269 
        return XFS_ALLOC_REC_ADDR(bb, i, cur);
270 
}
271 
#endif
272 
 
273 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_ENTSIZE_LOCAL)
274 
int
275 
xfs_attr_leaf_entsize_local(int nlen, int vlen)
276 
{
277 
        return XFS_ATTR_LEAF_ENTSIZE_LOCAL(nlen, vlen);
278 
}
279 
#endif
280 
 
281 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_ENTSIZE_LOCAL_MAX)
282 
int
283 
xfs_attr_leaf_entsize_local_max(int bsize)
284 
{
285 
        return XFS_ATTR_LEAF_ENTSIZE_LOCAL_MAX(bsize);
286 
}
287 
#endif
288 
 
289 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_ENTSIZE_REMOTE)
290 
int
291 
xfs_attr_leaf_entsize_remote(int nlen)
292 
{
293 
        return XFS_ATTR_LEAF_ENTSIZE_REMOTE(nlen);
294 
}
295 
#endif
296 
 
297 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_NAME)
298 
char *
299 
xfs_attr_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
300 
{
301 
        return XFS_ATTR_LEAF_NAME(leafp, idx);
302 
}
303 
#endif
304 
 
305 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_NAME_LOCAL)
306 
xfs_attr_leaf_name_local_t *
307 
xfs_attr_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)
308 
{
309 
        return XFS_ATTR_LEAF_NAME_LOCAL(leafp, idx);
310 
}
311 
#endif
312 
 
313 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_LEAF_NAME_REMOTE)
314 
xfs_attr_leaf_name_remote_t *
315 
xfs_attr_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
316 
{
317 
        return XFS_ATTR_LEAF_NAME_REMOTE(leafp, idx);
318 
}
319 
#endif
320 
 
321 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_SF_ENTSIZE)
322 
int
323 
xfs_attr_sf_entsize(xfs_attr_sf_entry_t *sfep)
324 
{
325 
        return XFS_ATTR_SF_ENTSIZE(sfep);
326 
}
327 
#endif
328 
 
329 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_SF_ENTSIZE_BYNAME)
330 
int
331 
xfs_attr_sf_entsize_byname(int nlen, int vlen)
332 
{
333 
        return XFS_ATTR_SF_ENTSIZE_BYNAME(nlen, vlen);
334 
}
335 
#endif
336 
 
337 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_SF_NEXTENTRY)
338 
xfs_attr_sf_entry_t *
339 
xfs_attr_sf_nextentry(xfs_attr_sf_entry_t *sfep)
340 
{
341 
        return XFS_ATTR_SF_NEXTENTRY(sfep);
342 
}
343 
#endif
344 
 
345 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ATTR_SF_TOTSIZE)
346 
int
347 
xfs_attr_sf_totsize(xfs_inode_t *dp)
348 
{
349 
        return XFS_ATTR_SF_TOTSIZE(dp);
350 
}
351 
#endif
352 
 
353 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BHVTOI)
354 
xfs_inode_t *
355 
xfs_bhvtoi(bhv_desc_t *bhvp)
356 
{
357 
        return XFS_BHVTOI(bhvp);
358 
}
359 
#endif
360 
 
361 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BHVTOM)
362 
xfs_mount_t *
363 
xfs_bhvtom(bhv_desc_t *bdp)
364 
{
365 
        return XFS_BHVTOM(bdp);
366 
}
367 
#endif
368 
 
369 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_VFSTOM)
370 
xfs_mount_t *
371 
xfs_vfstom(vfs_t *vfs)
372 
{
373 
        return XFS_VFSTOM(vfs);
374 
}
375 
#endif
376 
 
377 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BM_MAXLEVELS)
378 
int
379 
xfs_bm_maxlevels(xfs_mount_t *mp, int w)
380 
{
381 
        return XFS_BM_MAXLEVELS(mp, w);
382 
}
383 
#endif
384 
 
385 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_DMAXRECS)
386 
int
387 
xfs_bmap_block_dmaxrecs(int lev, xfs_btree_cur_t *cur)
388 
{
389 
        return XFS_BMAP_BLOCK_DMAXRECS(lev, cur);
390 
}
391 
#endif
392 
 
393 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_DMINRECS)
394 
int
395 
xfs_bmap_block_dminrecs(int lev, xfs_btree_cur_t *cur)
396 
{
397 
        return XFS_BMAP_BLOCK_DMINRECS(lev, cur);
398 
}
399 
#endif
400 
 
401 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_DSIZE)
402 
int
403 
xfs_bmap_block_dsize(int lev, xfs_btree_cur_t *cur)
404 
{
405 
        return XFS_BMAP_BLOCK_DSIZE(lev, cur);
406 
}
407 
#endif
408 
 
409 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_IMAXRECS)
410 
int
411 
xfs_bmap_block_imaxrecs(int lev, xfs_btree_cur_t *cur)
412 
{
413 
        return XFS_BMAP_BLOCK_IMAXRECS(lev, cur);
414 
}
415 
#endif
416 
 
417 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_IMINRECS)
418 
int
419 
xfs_bmap_block_iminrecs(int lev, xfs_btree_cur_t *cur)
420 
{
421 
        return XFS_BMAP_BLOCK_IMINRECS(lev, cur);
422 
}
423 
#endif
424 
 
425 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BLOCK_ISIZE)
426 
int
427 
xfs_bmap_block_isize(int lev, xfs_btree_cur_t *cur)
428 
{
429 
        return XFS_BMAP_BLOCK_ISIZE(lev, cur);
430 
}
431 
#endif
432 
 
433 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_KEY_ADDR)
434 
/*ARGSUSED3*/
435 
xfs_bmbt_key_t *
436 
xfs_bmap_broot_key_addr(xfs_bmbt_block_t *bb, int i, int sz)
437 
{
438 
        return XFS_BMAP_BROOT_KEY_ADDR(bb, i, sz);
439 
}
440 
#endif
441 
 
442 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_MAXRECS)
443 
int
444 
xfs_bmap_broot_maxrecs(int sz)
445 
{
446 
        return XFS_BMAP_BROOT_MAXRECS(sz);
447 
}
448 
#endif
449 
 
450 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_NUMRECS)
451 
int
452 
xfs_bmap_broot_numrecs(xfs_bmdr_block_t *bb)
453 
{
454 
        return XFS_BMAP_BROOT_NUMRECS(bb);
455 
}
456 
#endif
457 
 
458 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_PTR_ADDR)
459 
xfs_bmbt_ptr_t *
460 
xfs_bmap_broot_ptr_addr(xfs_bmbt_block_t *bb, int i, int sz)
461 
{
462 
        return XFS_BMAP_BROOT_PTR_ADDR(bb, i, sz);
463 
}
464 
#endif
465 
 
466 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_REC_ADDR)
467 
/*ARGSUSED3*/
468 
xfs_bmbt_rec_t *
469 
xfs_bmap_broot_rec_addr(xfs_bmbt_block_t *bb, int i, int sz)
470 
{
471 
        return XFS_BMAP_BROOT_REC_ADDR(bb, i, sz);
472 
}
473 
#endif
474 
 
475 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_SPACE)
476 
int
477 
xfs_bmap_broot_space(xfs_bmdr_block_t *bb)
478 
{
479 
        return XFS_BMAP_BROOT_SPACE(bb);
480 
}
481 
#endif
482 
 
483 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_BROOT_SPACE_CALC)
484 
int
485 
xfs_bmap_broot_space_calc(int nrecs)
486 
{
487 
        return XFS_BMAP_BROOT_SPACE_CALC(nrecs);
488 
}
489 
#endif
490 
 
491 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_IBLOCK_SIZE)
492 
/*ARGSUSED1*/
493 
int
494 
xfs_bmap_iblock_size(int lev, xfs_btree_cur_t *cur)
495 
{
496 
        return XFS_BMAP_IBLOCK_SIZE(lev, cur);
497 
}
498 
#endif
499 
 
500 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_INIT)
501 
void
502 
xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp)
503 
{
504 
        XFS_BMAP_INIT(flp, fbp);
505 
}
506 
#endif
507 
 
508 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_KEY_DADDR)
509 
/*ARGSUSED3*/
510 
xfs_bmbt_key_t *
511 
xfs_bmap_key_daddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
512 
{
513 
        return XFS_BMAP_KEY_DADDR(bb, i, cur);
514 
}
515 
#endif
516 
 
517 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_KEY_IADDR)
518 
/*ARGSUSED3*/
519 
xfs_bmbt_key_t *
520 
xfs_bmap_key_iaddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
521 
{
522 
        return XFS_BMAP_KEY_IADDR(bb, i, cur);
523 
}
524 
#endif
525 
 
526 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_PTR_DADDR)
527 
xfs_bmbt_ptr_t *
528 
xfs_bmap_ptr_daddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
529 
{
530 
        return XFS_BMAP_PTR_DADDR(bb, i, cur);
531 
}
532 
#endif
533 
 
534 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_PTR_IADDR)
535 
xfs_bmbt_ptr_t *
536 
xfs_bmap_ptr_iaddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
537 
{
538 
        return XFS_BMAP_PTR_IADDR(bb, i, cur);
539 
}
540 
#endif
541 
 
542 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_RBLOCK_DSIZE)
543 
/*ARGSUSED1*/
544 
int
545 
xfs_bmap_rblock_dsize(int lev, xfs_btree_cur_t *cur)
546 
{
547 
        return XFS_BMAP_RBLOCK_DSIZE(lev, cur);
548 
}
549 
#endif
550 
 
551 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_RBLOCK_ISIZE)
552 
/*ARGSUSED1*/
553 
int
554 
xfs_bmap_rblock_isize(int lev, xfs_btree_cur_t *cur)
555 
{
556 
        return XFS_BMAP_RBLOCK_ISIZE(lev, cur);
557 
}
558 
#endif
559 
 
560 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_REC_DADDR)
561 
/*ARGSUSED3*/
562 
xfs_bmbt_rec_t *
563 
xfs_bmap_rec_daddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
564 
{
565 
        return XFS_BMAP_REC_DADDR(bb, i, cur);
566 
}
567 
#endif
568 
 
569 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_REC_IADDR)
570 
/*ARGSUSED3*/
571 
xfs_bmbt_rec_t *
572 
xfs_bmap_rec_iaddr(xfs_bmbt_block_t *bb, int i, xfs_btree_cur_t *cur)
573 
{
574 
        return XFS_BMAP_REC_IADDR(bb, i, cur);
575 
}
576 
#endif
577 
 
578 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAP_SANITY_CHECK)
579 
int
580 
xfs_bmap_sanity_check(xfs_mount_t *mp, xfs_bmbt_block_t *bb, int level)
581 
{
582 
        return XFS_BMAP_SANITY_CHECK(mp, bb, level);
583 
}
584 
#endif
585 
 
586 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMAPI_AFLAG)
587 
int
588 
xfs_bmapi_aflag(int w)
589 
{
590 
        return XFS_BMAPI_AFLAG(w);
591 
}
592 
#endif
593 
 
594 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BMDR_SPACE_CALC)
595 
int
596 
xfs_bmdr_space_calc(int nrecs)
597 
{
598 
        return XFS_BMDR_SPACE_CALC(nrecs);
599 
}
600 
#endif
601 
 
602 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BNO_BLOCK)
603 
xfs_agblock_t
604 
xfs_bno_block(xfs_mount_t *mp)
605 
{
606 
        return XFS_BNO_BLOCK(mp);
607 
}
608 
#endif
609 
 
610 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BTREE_LONG_PTRS)
611 
int
612 
xfs_btree_long_ptrs(xfs_btnum_t btnum)
613 
{
614 
        return XFS_BTREE_LONG_PTRS(btnum);
615 
}
616 
#endif
617 
 
618 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_AGF)
619 
xfs_agf_t *
620 
xfs_buf_to_agf(xfs_buf_t *bp)
621 
{
622 
        return XFS_BUF_TO_AGF(bp);
623 
}
624 
#endif
625 
 
626 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_AGFL)
627 
xfs_agfl_t *
628 
xfs_buf_to_agfl(xfs_buf_t *bp)
629 
{
630 
        return XFS_BUF_TO_AGFL(bp);
631 
}
632 
#endif
633 
 
634 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_AGI)
635 
xfs_agi_t *
636 
xfs_buf_to_agi(xfs_buf_t *bp)
637 
{
638 
        return XFS_BUF_TO_AGI(bp);
639 
}
640 
#endif
641 
 
642 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_ALLOC_BLOCK)
643 
xfs_alloc_block_t *
644 
xfs_buf_to_alloc_block(xfs_buf_t *bp)
645 
{
646 
        return XFS_BUF_TO_ALLOC_BLOCK(bp);
647 
}
648 
#endif
649 
 
650 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_BLOCK)
651 
xfs_btree_block_t *
652 
xfs_buf_to_block(xfs_buf_t *bp)
653 
{
654 
        return XFS_BUF_TO_BLOCK(bp);
655 
}
656 
#endif
657 
 
658 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_BMBT_BLOCK)
659 
xfs_bmbt_block_t *
660 
xfs_buf_to_bmbt_block(xfs_buf_t *bp)
661 
{
662 
        return XFS_BUF_TO_BMBT_BLOCK(bp);
663 
}
664 
#endif
665 
 
666 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_DINODE)
667 
xfs_dinode_t *
668 
xfs_buf_to_dinode(xfs_buf_t *bp)
669 
{
670 
        return XFS_BUF_TO_DINODE(bp);
671 
}
672 
#endif
673 
 
674 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_INOBT_BLOCK)
675 
xfs_inobt_block_t *
676 
xfs_buf_to_inobt_block(xfs_buf_t *bp)
677 
{
678 
        return XFS_BUF_TO_INOBT_BLOCK(bp);
679 
}
680 
#endif
681 
 
682 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_LBLOCK)
683 
xfs_btree_lblock_t *
684 
xfs_buf_to_lblock(xfs_buf_t *bp)
685 
{
686 
        return XFS_BUF_TO_LBLOCK(bp);
687 
}
688 
#endif
689 
 
690 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_SBLOCK)
691 
xfs_btree_sblock_t *
692 
xfs_buf_to_sblock(xfs_buf_t *bp)
693 
{
694 
        return XFS_BUF_TO_SBLOCK(bp);
695 
}
696 
#endif
697 
 
698 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_BUF_TO_SBP)
699 
xfs_sb_t *
700 
xfs_buf_to_sbp(xfs_buf_t *bp)
701 
{
702 
        return XFS_BUF_TO_SBP(bp);
703 
}
704 
#endif
705 
 
706 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_ASIZE)
707 
int
708 
xfs_cfork_asize_arch(xfs_dinode_core_t *dcp, xfs_mount_t *mp, xfs_arch_t arch)
709 
{
710 
        return XFS_CFORK_ASIZE_ARCH(dcp, mp, arch);
711 
}
712 
int
713 
xfs_cfork_asize(xfs_dinode_core_t *dcp, xfs_mount_t *mp)
714 
{
715 
        return XFS_CFORK_ASIZE(dcp, mp);
716 
}
717 
#endif
718 
 
719 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_BOFF)
720 
int
721 
xfs_cfork_boff_arch(xfs_dinode_core_t *dcp, xfs_arch_t arch)
722 
{
723 
        return XFS_CFORK_BOFF_ARCH(dcp, arch);
724 
}
725 
int
726 
xfs_cfork_boff(xfs_dinode_core_t *dcp)
727 
{
728 
        return XFS_CFORK_BOFF(dcp);
729 
}
730 
#endif
731 
 
732 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_DSIZE)
733 
int
734 
xfs_cfork_dsize_arch(xfs_dinode_core_t *dcp, xfs_mount_t *mp, xfs_arch_t arch)
735 
{
736 
        return XFS_CFORK_DSIZE_ARCH(dcp, mp, arch);
737 
}
738 
int
739 
xfs_cfork_dsize(xfs_dinode_core_t *dcp, xfs_mount_t *mp)
740 
{
741 
        return XFS_CFORK_DSIZE(dcp, mp);
742 
}
743 
#endif
744 
 
745 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_FMT_SET)
746 
void
747 
xfs_cfork_fmt_set_arch(xfs_dinode_core_t *dcp, int w, int n, xfs_arch_t arch)
748 
{
749 
        XFS_CFORK_FMT_SET_ARCH(dcp, w, n, arch);
750 
}
751 
void
752 
xfs_cfork_fmt_set(xfs_dinode_core_t *dcp, int w, int n)
753 
{
754 
        XFS_CFORK_FMT_SET(dcp, w, n);
755 
}
756 
#endif
757 
 
758 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_FORMAT)
759 
int
760 
xfs_cfork_format_arch(xfs_dinode_core_t *dcp, int w, xfs_arch_t arch)
761 
{
762 
        return XFS_CFORK_FORMAT_ARCH(dcp, w, arch);
763 
}
764 
int
765 
xfs_cfork_format(xfs_dinode_core_t *dcp, int w)
766 
{
767 
        return XFS_CFORK_FORMAT(dcp, w);
768 
}
769 
#endif
770 
 
771 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_NEXT_SET)
772 
void
773 
xfs_cfork_next_set_arch(xfs_dinode_core_t *dcp, int w, int n, xfs_arch_t arch)
774 
{
775 
        XFS_CFORK_NEXT_SET_ARCH(dcp, w, n, arch);
776 
}
777 
void
778 
xfs_cfork_next_set(xfs_dinode_core_t *dcp, int w, int n)
779 
{
780 
        XFS_CFORK_NEXT_SET(dcp, w, n);
781 
}
782 
#endif
783 
 
784 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_NEXTENTS)
785 
int
786 
xfs_cfork_nextents_arch(xfs_dinode_core_t *dcp, int w, xfs_arch_t arch)
787 
{
788 
        return XFS_CFORK_NEXTENTS_ARCH(dcp, w, arch);
789 
}
790 
int
791 
xfs_cfork_nextents(xfs_dinode_core_t *dcp, int w)
792 
{
793 
        return XFS_CFORK_NEXTENTS(dcp, w);
794 
}
795 
#endif
796 
 
797 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_Q)
798 
int
799 
xfs_cfork_q_arch(xfs_dinode_core_t *dcp, xfs_arch_t arch)
800 
{
801 
        return XFS_CFORK_Q_ARCH(dcp, arch);
802 
}
803 
int
804 
xfs_cfork_q(xfs_dinode_core_t *dcp)
805 
{
806 
        return XFS_CFORK_Q(dcp);
807 
}
808 
#endif
809 
 
810 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CFORK_SIZE)
811 
int
812 
xfs_cfork_size_arch(xfs_dinode_core_t *dcp, xfs_mount_t *mp, int w, xfs_arch_t arch)
813 
{
814 
        return XFS_CFORK_SIZE_ARCH(dcp, mp, w, arch);
815 
}
816 
int
817 
xfs_cfork_size(xfs_dinode_core_t *dcp, xfs_mount_t *mp, int w)
818 
{
819 
        return XFS_CFORK_SIZE(dcp, mp, w);
820 
}
821 
#endif
822 
 
823 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_CNT_BLOCK)
824 
xfs_agblock_t
825 
xfs_cnt_block(xfs_mount_t *mp)
826 
{
827 
        return XFS_CNT_BLOCK(mp);
828 
}
829 
#endif
830 
 
831 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DA_COOKIE_BNO)
832 
xfs_dablk_t
833 
xfs_da_cookie_bno(xfs_mount_t *mp, xfs_off_t cookie)
834 
{
835 
        return XFS_DA_COOKIE_BNO(mp, cookie);
836 
}
837 
#endif
838 
 
839 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DA_COOKIE_ENTRY)
840 
int
841 
xfs_da_cookie_entry(xfs_mount_t *mp, xfs_off_t cookie)
842 
{
843 
        return XFS_DA_COOKIE_ENTRY(mp, cookie);
844 
}
845 
#endif
846 
 
847 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DA_COOKIE_HASH)
848 
/*ARGSUSED1*/
849 
xfs_dahash_t
850 
xfs_da_cookie_hash(xfs_mount_t *mp, xfs_off_t cookie)
851 
{
852 
        return XFS_DA_COOKIE_HASH(mp, cookie);
853 
}
854 
#endif
855 
 
856 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DA_MAKE_BNOENTRY)
857 
__uint32_t
858 
xfs_da_make_bnoentry(xfs_mount_t *mp, xfs_dablk_t bno, int entry)
859 
{
860 
        return XFS_DA_MAKE_BNOENTRY(mp, bno, entry);
861 
}
862 
#endif
863 
 
864 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DA_MAKE_COOKIE)
865 
xfs_off_t
866 
xfs_da_make_cookie(xfs_mount_t *mp, xfs_dablk_t bno, int entry,
867 
                   xfs_dahash_t hash)
868 
{
869 
        return XFS_DA_MAKE_COOKIE(mp, bno, entry, hash);
870 
}
871 
#endif
872 
 
873 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DADDR_TO_AGBNO)
874 
xfs_agblock_t
875 
xfs_daddr_to_agbno(xfs_mount_t *mp, xfs_daddr_t d)
876 
{
877 
        return XFS_DADDR_TO_AGBNO(mp, d);
878 
}
879 
#endif
880 
 
881 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DADDR_TO_AGNO)
882 
xfs_agnumber_t
883 
xfs_daddr_to_agno(xfs_mount_t *mp, xfs_daddr_t d)
884 
{
885 
        return XFS_DADDR_TO_AGNO(mp, d);
886 
}
887 
#endif
888 
 
889 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DADDR_TO_FSB)
890 
xfs_fsblock_t
891 
xfs_daddr_to_fsb(xfs_mount_t *mp, xfs_daddr_t d)
892 
{
893 
        return XFS_DADDR_TO_FSB(mp, d);
894 
}
895 
#endif
896 
 
897 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_APTR)
898 
char *
899 
xfs_dfork_aptr_arch(xfs_dinode_t *dip, xfs_arch_t arch)
900 
{
901 
        return XFS_DFORK_APTR_ARCH(dip, arch);
902 
}
903 
char *
904 
xfs_dfork_aptr(xfs_dinode_t *dip)
905 
{
906 
        return XFS_DFORK_APTR(dip);
907 
}
908 
#endif
909 
 
910 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_ASIZE)
911 
int
912 
xfs_dfork_asize_arch(xfs_dinode_t *dip, xfs_mount_t *mp, xfs_arch_t arch)
913 
{
914 
        return XFS_DFORK_ASIZE_ARCH(dip, mp, arch);
915 
}
916 
int
917 
xfs_dfork_asize(xfs_dinode_t *dip, xfs_mount_t *mp)
918 
{
919 
        return XFS_DFORK_ASIZE(dip, mp);
920 
}
921 
#endif
922 
 
923 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_BOFF)
924 
int
925 
xfs_dfork_boff_arch(xfs_dinode_t *dip, xfs_arch_t arch)
926 
{
927 
        return XFS_DFORK_BOFF_ARCH(dip, arch);
928 
}
929 
int
930 
xfs_dfork_boff(xfs_dinode_t *dip)
931 
{
932 
        return XFS_DFORK_BOFF(dip);
933 
}
934 
#endif
935 
 
936 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_DPTR)
937 
char *
938 
xfs_dfork_dptr_arch(xfs_dinode_t *dip, xfs_arch_t arch)
939 
{
940 
        return XFS_DFORK_DPTR_ARCH(dip, arch);
941 
}
942 
char *
943 
xfs_dfork_dptr(xfs_dinode_t *dip)
944 
{
945 
        return XFS_DFORK_DPTR(dip);
946 
}
947 
#endif
948 
 
949 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_DSIZE)
950 
int
951 
xfs_dfork_dsize_arch(xfs_dinode_t *dip, xfs_mount_t *mp, xfs_arch_t arch)
952 
{
953 
        return XFS_DFORK_DSIZE_ARCH(dip, mp, arch);
954 
}
955 
int
956 
xfs_dfork_dsize(xfs_dinode_t *dip, xfs_mount_t *mp)
957 
{
958 
        return XFS_DFORK_DSIZE(dip, mp);
959 
}
960 
#endif
961 
 
962 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_FMT_SET)
963 
void
964 
xfs_dfork_fmt_set_arch(xfs_dinode_t *dip, int w, int n, xfs_arch_t arch)
965 
{
966 
        XFS_DFORK_FMT_SET_ARCH(dip, w, n, arch);
967 
}
968 
void
969 
xfs_dfork_fmt_set(xfs_dinode_t *dip, int w, int n)
970 
{
971 
        XFS_DFORK_FMT_SET(dip, w, n);
972 
}
973 
#endif
974 
 
975 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_FORMAT)
976 
int
977 
xfs_dfork_format_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch)
978 
{
979 
        return XFS_DFORK_FORMAT_ARCH(dip, w, arch);
980 
}
981 
int
982 
xfs_dfork_format(xfs_dinode_t *dip, int w)
983 
{
984 
        return XFS_DFORK_FORMAT(dip, w);
985 
}
986 
#endif
987 
 
988 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_NEXT_SET)
989 
void
990 
xfs_dfork_next_set_arch(xfs_dinode_t *dip, int w, int n, xfs_arch_t arch)
991 
{
992 
        XFS_DFORK_NEXT_SET_ARCH(dip, w, n, arch);
993 
}
994 
void
995 
xfs_dfork_next_set(xfs_dinode_t *dip, int w, int n)
996 
{
997 
        XFS_DFORK_NEXT_SET(dip, w, n);
998 
}
999 
#endif
1000 
 
1001 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_NEXTENTS)
1002 
int
1003 
xfs_dfork_nextents_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch)
1004 
{
1005 
        return XFS_DFORK_NEXTENTS_ARCH(dip, w, arch);
1006 
}
1007 
int
1008 
xfs_dfork_nextents(xfs_dinode_t *dip, int w)
1009 
{
1010 
        return XFS_DFORK_NEXTENTS(dip, w);
1011 
}
1012 
#endif
1013 
 
1014 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_PTR)
1015 
char *
1016 
xfs_dfork_ptr_arch(xfs_dinode_t *dip, int w, xfs_arch_t arch)
1017 
{
1018 
        return XFS_DFORK_PTR_ARCH(dip, w, arch);
1019 
}
1020 
char *
1021 
xfs_dfork_ptr(xfs_dinode_t *dip, int w)
1022 
{
1023 
        return XFS_DFORK_PTR(dip, w);
1024 
}
1025 
#endif
1026 
 
1027 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_Q)
1028 
int
1029 
xfs_dfork_q_arch(xfs_dinode_t *dip, xfs_arch_t arch)
1030 
{
1031 
        return XFS_DFORK_Q_ARCH(dip, arch);
1032 
}
1033 
int
1034 
xfs_dfork_q(xfs_dinode_t *dip)
1035 
{
1036 
        return XFS_DFORK_Q(dip);
1037 
}
1038 
#endif
1039 
 
1040 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DFORK_SIZE)
1041 
int
1042 
xfs_dfork_size_arch(xfs_dinode_t *dip, xfs_mount_t *mp, int w, xfs_arch_t arch)
1043 
{
1044 
        return XFS_DFORK_SIZE_ARCH(dip, mp, w, arch);
1045 
}
1046 
int
1047 
xfs_dfork_size(xfs_dinode_t *dip, xfs_mount_t *mp, int w)
1048 
{
1049 
        return XFS_DFORK_SIZE(dip, mp, w);
1050 
}
1051 
#endif
1052 
 
1053 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DINODE_GOOD_VERSION)
1054 
int
1055 
xfs_dinode_good_version(int v)
1056 
{
1057 
        return XFS_DINODE_GOOD_VERSION(v);
1058 
}
1059 
#endif
1060 
 
1061 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_LEAF_ENTSIZE_BYENTRY)
1062 
int
1063 
xfs_dir_leaf_entsize_byentry(xfs_dir_leaf_entry_t *entry)
1064 
{
1065 
        return XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry);
1066 
}
1067 
#endif
1068 
 
1069 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_LEAF_ENTSIZE_BYNAME)
1070 
int
1071 
xfs_dir_leaf_entsize_byname(int len)
1072 
{
1073 
        return XFS_DIR_LEAF_ENTSIZE_BYNAME(len);
1074 
}
1075 
#endif
1076 
 
1077 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_LEAF_NAMESTRUCT)
1078 
xfs_dir_leaf_name_t *
1079 
xfs_dir_leaf_namestruct(xfs_dir_leafblock_t *leafp, int offset)
1080 
{
1081 
        return XFS_DIR_LEAF_NAMESTRUCT(leafp, offset);
1082 
}
1083 
#endif
1084 
 
1085 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_ALLFIT)
1086 
int
1087 
xfs_dir_sf_allfit(int count, int totallen)
1088 
{
1089 
        return XFS_DIR_SF_ALLFIT(count, totallen);
1090 
}
1091 
#endif
1092 
 
1093 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_ENTSIZE_BYENTRY)
1094 
int
1095 
xfs_dir_sf_entsize_byentry(xfs_dir_sf_entry_t *sfep)
1096 
{
1097 
        return XFS_DIR_SF_ENTSIZE_BYENTRY(sfep);
1098 
}
1099 
#endif
1100 
 
1101 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_ENTSIZE_BYNAME)
1102 
int
1103 
xfs_dir_sf_entsize_byname(int len)
1104 
{
1105 
        return XFS_DIR_SF_ENTSIZE_BYNAME(len);
1106 
}
1107 
#endif
1108 
 
1109 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_GET_DIRINO)
1110 
void
1111 
xfs_dir_sf_get_dirino_arch(xfs_dir_ino_t *from, xfs_ino_t *to, xfs_arch_t arch)
1112 
{
1113 
        XFS_DIR_SF_GET_DIRINO_ARCH(from, to, arch);
1114 
}
1115 
void
1116 
xfs_dir_sf_get_dirino(xfs_dir_ino_t *from, xfs_ino_t *to)
1117 
{
1118 
        XFS_DIR_SF_GET_DIRINO(from, to);
1119 
}
1120 
#endif
1121 
 
1122 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_NEXTENTRY)
1123 
xfs_dir_sf_entry_t *
1124 
xfs_dir_sf_nextentry(xfs_dir_sf_entry_t *sfep)
1125 
{
1126 
        return XFS_DIR_SF_NEXTENTRY(sfep);
1127 
}
1128 
#endif
1129 
 
1130 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR_SF_PUT_DIRINO)
1131 
void
1132 
xfs_dir_sf_put_dirino_arch(xfs_ino_t *from, xfs_dir_ino_t *to, xfs_arch_t arch)
1133 
{
1134 
        XFS_DIR_SF_PUT_DIRINO_ARCH(from, to, arch);
1135 
}
1136 
void
1137 
xfs_dir_sf_put_dirino(xfs_ino_t *from, xfs_dir_ino_t *to)
1138 
{
1139 
        XFS_DIR_SF_PUT_DIRINO(from, to);
1140 
}
1141 
#endif
1142 
 
1143 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BLOCK_LEAF_P)
1144 
xfs_dir2_leaf_entry_t *
1145 
xfs_dir2_block_leaf_p_arch(xfs_dir2_block_tail_t *btp, xfs_arch_t arch)
1146 
{
1147 
        return XFS_DIR2_BLOCK_LEAF_P_ARCH(btp,arch);
1148 
}
1149 
#endif
1150 
 
1151 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BLOCK_TAIL_P)
1152 
xfs_dir2_block_tail_t *
1153 
xfs_dir2_block_tail_p(xfs_mount_t *mp, xfs_dir2_block_t *block)
1154 
{
1155 
        return XFS_DIR2_BLOCK_TAIL_P(mp, block);
1156 
}
1157 
#endif
1158 
 
1159 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BYTE_TO_DA)
1160 
xfs_dablk_t
1161 
xfs_dir2_byte_to_da(xfs_mount_t *mp, xfs_dir2_off_t by)
1162 
{
1163 
        return XFS_DIR2_BYTE_TO_DA(mp, by);
1164 
}
1165 
#endif
1166 
 
1167 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BYTE_TO_DATAPTR)
1168 
/* ARGSUSED */
1169 
xfs_dir2_dataptr_t
1170 
xfs_dir2_byte_to_dataptr(xfs_mount_t *mp, xfs_dir2_off_t by)
1171 
{
1172 
        return XFS_DIR2_BYTE_TO_DATAPTR(mp, by);
1173 
}
1174 
#endif
1175 
 
1176 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BYTE_TO_DB)
1177 
xfs_dir2_db_t
1178 
xfs_dir2_byte_to_db(xfs_mount_t *mp, xfs_dir2_off_t by)
1179 
{
1180 
        return XFS_DIR2_BYTE_TO_DB(mp, by);
1181 
}
1182 
#endif
1183 
 
1184 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_BYTE_TO_OFF)
1185 
xfs_dir2_data_aoff_t
1186 
xfs_dir2_byte_to_off(xfs_mount_t *mp, xfs_dir2_off_t by)
1187 
{
1188 
        return XFS_DIR2_BYTE_TO_OFF(mp, by);
1189 
}
1190 
#endif
1191 
 
1192 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DA_TO_BYTE)
1193 
xfs_dir2_off_t
1194 
xfs_dir2_da_to_byte(xfs_mount_t *mp, xfs_dablk_t da)
1195 
{
1196 
        return XFS_DIR2_DA_TO_BYTE(mp, da);
1197 
}
1198 
#endif
1199 
 
1200 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DA_TO_DB)
1201 
xfs_dir2_db_t
1202 
xfs_dir2_da_to_db(xfs_mount_t *mp, xfs_dablk_t da)
1203 
{
1204 
        return XFS_DIR2_DA_TO_DB(mp, da);
1205 
}
1206 
#endif
1207 
 
1208 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATA_ENTRY_TAG_P)
1209 
xfs_dir2_data_off_t *
1210 
xfs_dir2_data_entry_tag_p(xfs_dir2_data_entry_t *dep)
1211 
{
1212 
        return XFS_DIR2_DATA_ENTRY_TAG_P(dep);
1213 
}
1214 
#endif
1215 
 
1216 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATA_ENTSIZE)
1217 
int
1218 
xfs_dir2_data_entsize(int n)
1219 
{
1220 
        return XFS_DIR2_DATA_ENTSIZE(n);
1221 
}
1222 
#endif
1223 
 
1224 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATA_UNUSED_TAG_P)
1225 
xfs_dir2_data_off_t *
1226 
xfs_dir2_data_unused_tag_p_arch(xfs_dir2_data_unused_t *dup, xfs_arch_t arch)
1227 
{
1228 
        return XFS_DIR2_DATA_UNUSED_TAG_P_ARCH(dup,arch);
1229 
}
1230 
#endif
1231 
 
1232 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATAPTR_TO_BYTE)
1233 
/* ARGSUSED */
1234 
xfs_dir2_off_t
1235 
xfs_dir2_dataptr_to_byte(xfs_mount_t *mp, xfs_dir2_dataptr_t dp)
1236 
{
1237 
        return XFS_DIR2_DATAPTR_TO_BYTE(mp, dp);
1238 
}
1239 
#endif
1240 
 
1241 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATAPTR_TO_DB)
1242 
xfs_dir2_db_t
1243 
xfs_dir2_dataptr_to_db(xfs_mount_t *mp, xfs_dir2_dataptr_t dp)
1244 
{
1245 
        return XFS_DIR2_DATAPTR_TO_DB(mp, dp);
1246 
}
1247 
#endif
1248 
 
1249 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DATAPTR_TO_OFF)
1250 
xfs_dir2_data_aoff_t
1251 
xfs_dir2_dataptr_to_off(xfs_mount_t *mp, xfs_dir2_dataptr_t dp)
1252 
{
1253 
        return XFS_DIR2_DATAPTR_TO_OFF(mp, dp);
1254 
}
1255 
#endif
1256 
 
1257 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DB_OFF_TO_BYTE)
1258 
xfs_dir2_off_t
1259 
xfs_dir2_db_off_to_byte(xfs_mount_t *mp, xfs_dir2_db_t db,
1260 
                        xfs_dir2_data_aoff_t o)
1261 
{
1262 
        return XFS_DIR2_DB_OFF_TO_BYTE(mp, db, o);
1263 
}
1264 
#endif
1265 
 
1266 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DB_OFF_TO_DATAPTR)
1267 
xfs_dir2_dataptr_t
1268 
xfs_dir2_db_off_to_dataptr(xfs_mount_t *mp, xfs_dir2_db_t db,
1269 
                           xfs_dir2_data_aoff_t o)
1270 
{
1271 
        return XFS_DIR2_DB_OFF_TO_DATAPTR(mp, db, o);
1272 
}
1273 
#endif
1274 
 
1275 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DB_TO_DA)
1276 
xfs_dablk_t
1277 
xfs_dir2_db_to_da(xfs_mount_t *mp, xfs_dir2_db_t db)
1278 
{
1279 
        return XFS_DIR2_DB_TO_DA(mp, db);
1280 
}
1281 
#endif
1282 
 
1283 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DB_TO_FDB)
1284 
xfs_dir2_db_t
1285 
xfs_dir2_db_to_fdb(xfs_mount_t *mp, xfs_dir2_db_t db)
1286 
{
1287 
        return XFS_DIR2_DB_TO_FDB(mp, db);
1288 
}
1289 
#endif
1290 
 
1291 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_DB_TO_FDINDEX)
1292 
int
1293 
xfs_dir2_db_to_fdindex(xfs_mount_t *mp, xfs_dir2_db_t db)
1294 
{
1295 
        return XFS_DIR2_DB_TO_FDINDEX(mp, db);
1296 
}
1297 
#endif
1298 
 
1299 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_LEAF_BESTS_P)
1300 
xfs_dir2_data_off_t *
1301 
xfs_dir2_leaf_bests_p_arch(xfs_dir2_leaf_tail_t *ltp, xfs_arch_t arch)
1302 
{
1303 
        return XFS_DIR2_LEAF_BESTS_P_ARCH(ltp, arch);
1304 
}
1305 
#endif
1306 
 
1307 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_LEAF_TAIL_P)
1308 
xfs_dir2_leaf_tail_t *
1309 
xfs_dir2_leaf_tail_p(xfs_mount_t *mp, xfs_dir2_leaf_t *lp)
1310 
{
1311 
        return XFS_DIR2_LEAF_TAIL_P(mp, lp);
1312 
}
1313 
#endif
1314 
 
1315 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_MAX_LEAF_ENTS)
1316 
int
1317 
xfs_dir2_max_leaf_ents(xfs_mount_t *mp)
1318 
{
1319 
        return XFS_DIR2_MAX_LEAF_ENTS(mp);
1320 
}
1321 
#endif
1322 
 
1323 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_ENTSIZE_BYENTRY)
1324 
int
1325 
xfs_dir2_sf_entsize_byentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
1326 
{
1327 
        return XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp, sfep);
1328 
}
1329 
#endif
1330 
 
1331 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_FIRSTENTRY)
1332 
xfs_dir2_sf_entry_t *
1333 
xfs_dir2_sf_firstentry(xfs_dir2_sf_t *sfp)
1334 
{
1335 
        return XFS_DIR2_SF_FIRSTENTRY(sfp);
1336 
}
1337 
#endif
1338 
 
1339 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_ENTSIZE_BYNAME)
1340 
int
1341 
xfs_dir2_sf_entsize_byname(xfs_dir2_sf_t *sfp, int len)
1342 
{
1343 
        return XFS_DIR2_SF_ENTSIZE_BYNAME(sfp, len);
1344 
}
1345 
#endif
1346 
 
1347 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_GET_INUMBER)
1348 
xfs_intino_t
1349 
xfs_dir2_sf_get_inumber_arch(xfs_dir2_sf_t *sfp, xfs_dir2_inou_t *from, xfs_arch_t arch)
1350 
{
1351 
        return XFS_DIR2_SF_GET_INUMBER_ARCH(sfp, from, arch);
1352 
}
1353 
#endif
1354 
 
1355 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_GET_OFFSET)
1356 
xfs_dir2_data_aoff_t
1357 
xfs_dir2_sf_get_offset_arch(xfs_dir2_sf_entry_t *sfep, xfs_arch_t arch)
1358 
{
1359 
        return XFS_DIR2_SF_GET_OFFSET_ARCH(sfep, arch);
1360 
}
1361 
#endif
1362 
 
1363 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_HDR_SIZE)
1364 
int
1365 
xfs_dir2_sf_hdr_size(int i8count)
1366 
{
1367 
        return XFS_DIR2_SF_HDR_SIZE(i8count);
1368 
}
1369 
#endif
1370 
 
1371 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_INUMBERP)
1372 
xfs_dir2_inou_t *
1373 
xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep)
1374 
{
1375 
        return XFS_DIR2_SF_INUMBERP(sfep);
1376 
}
1377 
#endif
1378 
 
1379 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_NEXTENTRY)
1380 
xfs_dir2_sf_entry_t *
1381 
xfs_dir2_sf_nextentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
1382 
{
1383 
        return XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
1384 
}
1385 
#endif
1386 
 
1387 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_PUT_INUMBER)
1388 
void
1389 
xfs_dir2_sf_put_inumber_arch(xfs_dir2_sf_t *sfp, xfs_ino_t *from, xfs_dir2_inou_t *to, xfs_arch_t arch)
1390 
{
1391 
        XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, from, to, arch);
1392 
}
1393 
#endif
1394 
 
1395 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_DIR2_SF_PUT_OFFSET)
1396 
void
1397 
xfs_dir2_sf_put_offset_arch(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off, xfs_arch_t arch)
1398 
{
1399 
        XFS_DIR2_SF_PUT_OFFSET_ARCH(sfep, off, arch);
1400 
}
1401 
#endif
1402 
 
1403 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_EXTFMT_INODE )
1404 
xfs_exntfmt_t
1405 
xfs_extfmt_inode(struct xfs_inode *ip)
1406 
{
1407 
        return XFS_EXTFMT_INODE(ip);
1408 
}
1409 
#endif
1410 
 
1411 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_EXTLEN_MAX)
1412 
xfs_extlen_t
1413 
xfs_extlen_max(xfs_extlen_t a, xfs_extlen_t b)
1414 
{
1415 
        return XFS_EXTLEN_MAX(a, b);
1416 
}
1417 
#endif
1418 
 
1419 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_EXTLEN_MIN)
1420 
xfs_extlen_t
1421 
xfs_extlen_min(xfs_extlen_t a, xfs_extlen_t b)
1422 
{
1423 
        return XFS_EXTLEN_MIN(a, b);
1424 
}
1425 
#endif
1426 
 
1427 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FILBLKS_MAX)
1428 
xfs_filblks_t
1429 
xfs_filblks_max(xfs_filblks_t a, xfs_filblks_t b)
1430 
{
1431 
        return XFS_FILBLKS_MAX(a, b);
1432 
}
1433 
#endif
1434 
 
1435 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FILBLKS_MIN)
1436 
xfs_filblks_t
1437 
xfs_filblks_min(xfs_filblks_t a, xfs_filblks_t b)
1438 
{
1439 
        return XFS_FILBLKS_MIN(a, b);
1440 
}
1441 
#endif
1442 
 
1443 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FILEOFF_MAX)
1444 
xfs_fileoff_t
1445 
xfs_fileoff_max(xfs_fileoff_t a, xfs_fileoff_t b)
1446 
{
1447 
        return XFS_FILEOFF_MAX(a, b);
1448 
}
1449 
#endif
1450 
 
1451 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FILEOFF_MIN)
1452 
xfs_fileoff_t
1453 
xfs_fileoff_min(xfs_fileoff_t a, xfs_fileoff_t b)
1454 
{
1455 
        return XFS_FILEOFF_MIN(a, b);
1456 
}
1457 
#endif
1458 
 
1459 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FSB_SANITY_CHECK)
1460 
int
1461 
xfs_fsb_sanity_check(xfs_mount_t *mp, xfs_fsblock_t fsbno)
1462 
{
1463 
        return XFS_FSB_SANITY_CHECK(mp, fsbno);
1464 
}
1465 
#endif
1466 
 
1467 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FSB_TO_AGBNO)
1468 
xfs_agblock_t
1469 
xfs_fsb_to_agbno(xfs_mount_t *mp, xfs_fsblock_t fsbno)
1470 
{
1471 
        return XFS_FSB_TO_AGBNO(mp, fsbno);
1472 
}
1473 
#endif
1474 
 
1475 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FSB_TO_AGNO)
1476 
xfs_agnumber_t
1477 
xfs_fsb_to_agno(xfs_mount_t *mp, xfs_fsblock_t fsbno)
1478 
{
1479 
        return XFS_FSB_TO_AGNO(mp, fsbno);
1480 
}
1481 
#endif
1482 
 
1483 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FSB_TO_DADDR)
1484 
xfs_daddr_t
1485 
xfs_fsb_to_daddr(xfs_mount_t *mp, xfs_fsblock_t fsbno)
1486 
{
1487 
        return XFS_FSB_TO_DADDR(mp, fsbno);
1488 
}
1489 
#endif
1490 
 
1491 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_FSB_TO_DB)
1492 
xfs_daddr_t
1493 
xfs_fsb_to_db(xfs_inode_t *ip, xfs_fsblock_t fsb)
1494 
{
1495 
        return XFS_FSB_TO_DB(ip, fsb);
1496 
}
1497 
#endif
1498 
 
1499 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_HDR_BLOCK)
1500 
xfs_agblock_t
1501 
xfs_hdr_block(xfs_mount_t *mp, xfs_daddr_t d)
1502 
{
1503 
        return XFS_HDR_BLOCK(mp, d);
1504 
}
1505 
#endif
1506 
 
1507 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IALLOC_BLOCKS)
1508 
xfs_extlen_t
1509 
xfs_ialloc_blocks(xfs_mount_t *mp)
1510 
{
1511 
        return XFS_IALLOC_BLOCKS(mp);
1512 
}
1513 
#endif
1514 
 
1515 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IALLOC_FIND_FREE)
1516 
int
1517 
xfs_ialloc_find_free(xfs_inofree_t *fp)
1518 
{
1519 
        return XFS_IALLOC_FIND_FREE(fp);
1520 
}
1521 
#endif
1522 
 
1523 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IALLOC_INODES)
1524 
int
1525 
xfs_ialloc_inodes(xfs_mount_t *mp)
1526 
{
1527 
        return XFS_IALLOC_INODES(mp);
1528 
}
1529 
#endif
1530 
 
1531 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IBT_BLOCK)
1532 
xfs_agblock_t
1533 
xfs_ibt_block(xfs_mount_t *mp)
1534 
{
1535 
        return XFS_IBT_BLOCK(mp);
1536 
}
1537 
#endif
1538 
 
1539 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_ASIZE)
1540 
int
1541 
xfs_ifork_asize(xfs_inode_t *ip)
1542 
{
1543 
        return XFS_IFORK_ASIZE(ip);
1544 
}
1545 
#endif
1546 
 
1547 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_DSIZE)
1548 
int
1549 
xfs_ifork_dsize(xfs_inode_t *ip)
1550 
{
1551 
        return XFS_IFORK_DSIZE(ip);
1552 
}
1553 
#endif
1554 
 
1555 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_FMT_SET)
1556 
void
1557 
xfs_ifork_fmt_set(xfs_inode_t *ip, int w, int n)
1558 
{
1559 
        XFS_IFORK_FMT_SET(ip, w, n);
1560 
}
1561 
#endif
1562 
 
1563 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_FORMAT)
1564 
int
1565 
xfs_ifork_format(xfs_inode_t *ip, int w)
1566 
{
1567 
        return XFS_IFORK_FORMAT(ip, w);
1568 
}
1569 
#endif
1570 
 
1571 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_NEXT_SET)
1572 
void
1573 
xfs_ifork_next_set(xfs_inode_t *ip, int w, int n)
1574 
{
1575 
        XFS_IFORK_NEXT_SET(ip, w, n);
1576 
}
1577 
#endif
1578 
 
1579 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_NEXTENTS)
1580 
int
1581 
xfs_ifork_nextents(xfs_inode_t *ip, int w)
1582 
{
1583 
        return XFS_IFORK_NEXTENTS(ip, w);
1584 
}
1585 
#endif
1586 
 
1587 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_PTR)
1588 
xfs_ifork_t *
1589 
xfs_ifork_ptr(xfs_inode_t *ip, int w)
1590 
{
1591 
        return XFS_IFORK_PTR(ip, w);
1592 
}
1593 
#endif
1594 
 
1595 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_Q)
1596 
int
1597 
xfs_ifork_q(xfs_inode_t *ip)
1598 
{
1599 
        return XFS_IFORK_Q(ip);
1600 
}
1601 
#endif
1602 
 
1603 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IFORK_SIZE)
1604 
int
1605 
xfs_ifork_size(xfs_inode_t *ip, int w)
1606 
{
1607 
        return XFS_IFORK_SIZE(ip, w);
1608 
}
1609 
#endif
1610 
 
1611 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ILOG_FBROOT)
1612 
int
1613 
xfs_ilog_fbroot(int w)
1614 
{
1615 
        return XFS_ILOG_FBROOT(w);
1616 
}
1617 
#endif
1618 
 
1619 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ILOG_FDATA)
1620 
int
1621 
xfs_ilog_fdata(int w)
1622 
{
1623 
        return XFS_ILOG_FDATA(w);
1624 
}
1625 
#endif
1626 
 
1627 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ILOG_FEXT)
1628 
int
1629 
xfs_ilog_fext(int w)
1630 
{
1631 
        return XFS_ILOG_FEXT(w);
1632 
}
1633 
#endif
1634 
 
1635 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_IN_MAXLEVELS)
1636 
int
1637 
xfs_in_maxlevels(xfs_mount_t *mp)
1638 
{
1639 
        return XFS_IN_MAXLEVELS(mp);
1640 
}
1641 
#endif
1642 
 
1643 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_AGBNO_BITS)
1644 
int
1645 
xfs_ino_agbno_bits(xfs_mount_t *mp)
1646 
{
1647 
        return XFS_INO_AGBNO_BITS(mp);
1648 
}
1649 
#endif
1650 
 
1651 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_AGINO_BITS)
1652 
int
1653 
xfs_ino_agino_bits(xfs_mount_t *mp)
1654 
{
1655 
        return XFS_INO_AGINO_BITS(mp);
1656 
}
1657 
#endif
1658 
 
1659 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_AGNO_BITS)
1660 
int
1661 
xfs_ino_agno_bits(xfs_mount_t *mp)
1662 
{
1663 
        return XFS_INO_AGNO_BITS(mp);
1664 
}
1665 
#endif
1666 
 
1667 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_BITS)
1668 
int
1669 
xfs_ino_bits(xfs_mount_t *mp)
1670 
{
1671 
        return XFS_INO_BITS(mp);
1672 
}
1673 
#endif
1674 
 
1675 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_MASK)
1676 
__uint32_t
1677 
xfs_ino_mask(int k)
1678 
{
1679 
        return XFS_INO_MASK(k);
1680 
}
1681 
#endif
1682 
 
1683 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_OFFSET_BITS)
1684 
int
1685 
xfs_ino_offset_bits(xfs_mount_t *mp)
1686 
{
1687 
        return XFS_INO_OFFSET_BITS(mp);
1688 
}
1689 
#endif
1690 
 
1691 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_TO_AGBNO)
1692 
xfs_agblock_t
1693 
xfs_ino_to_agbno(xfs_mount_t *mp, xfs_ino_t i)
1694 
{
1695 
        return XFS_INO_TO_AGBNO(mp, i);
1696 
}
1697 
#endif
1698 
 
1699 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_TO_AGINO)
1700 
xfs_agino_t
1701 
xfs_ino_to_agino(xfs_mount_t *mp, xfs_ino_t i)
1702 
{
1703 
        return XFS_INO_TO_AGINO(mp, i);
1704 
}
1705 
#endif
1706 
 
1707 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_TO_AGNO)
1708 
xfs_agnumber_t
1709 
xfs_ino_to_agno(xfs_mount_t *mp, xfs_ino_t i)
1710 
{
1711 
        return XFS_INO_TO_AGNO(mp, i);
1712 
}
1713 
#endif
1714 
 
1715 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_TO_FSB)
1716 
xfs_fsblock_t
1717 
xfs_ino_to_fsb(xfs_mount_t *mp, xfs_ino_t i)
1718 
{
1719 
        return XFS_INO_TO_FSB(mp, i);
1720 
}
1721 
#endif
1722 
 
1723 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INO_TO_OFFSET)
1724 
int
1725 
xfs_ino_to_offset(xfs_mount_t *mp, xfs_ino_t i)
1726 
{
1727 
        return XFS_INO_TO_OFFSET(mp, i);
1728 
}
1729 
#endif
1730 
 
1731 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_BLOCK_MAXRECS)
1732 
int
1733 
xfs_inobt_block_maxrecs(int lev, xfs_btree_cur_t *cur)
1734 
{
1735 
        return XFS_INOBT_BLOCK_MAXRECS(lev, cur);
1736 
}
1737 
#endif
1738 
 
1739 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_BLOCK_MINRECS)
1740 
int
1741 
xfs_inobt_block_minrecs(int lev, xfs_btree_cur_t *cur)
1742 
{
1743 
        return XFS_INOBT_BLOCK_MINRECS(lev, cur);
1744 
}
1745 
#endif
1746 
 
1747 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_BLOCK_SIZE)
1748 
/*ARGSUSED1*/
1749 
int
1750 
xfs_inobt_block_size(int lev, xfs_btree_cur_t *cur)
1751 
{
1752 
        return XFS_INOBT_BLOCK_SIZE(lev, cur);
1753 
}
1754 
#endif
1755 
 
1756 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_CLR_FREE)
1757 
void
1758 
xfs_inobt_clr_free(xfs_inobt_rec_t *rp, int i, xfs_arch_t arch)
1759 
{
1760 
        XFS_INOBT_CLR_FREE(rp, i, arch);
1761 
}
1762 
#endif
1763 
 
1764 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_IS_FREE)
1765 
int
1766 
xfs_inobt_is_free(xfs_inobt_rec_t *rp, int i, xfs_arch_t arch)
1767 
{
1768 
        return XFS_INOBT_IS_FREE(rp, i, arch);
1769 
}
1770 
#endif
1771 
 
1772 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_IS_LAST_REC)
1773 
int
1774 
xfs_inobt_is_last_rec(xfs_btree_cur_t *cur)
1775 
{
1776 
        return XFS_INOBT_IS_LAST_REC(cur);
1777 
}
1778 
#endif
1779 
 
1780 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_KEY_ADDR)
1781 
/*ARGSUSED3*/
1782 
xfs_inobt_key_t *
1783 
xfs_inobt_key_addr(xfs_inobt_block_t *bb, int i, xfs_btree_cur_t *cur)
1784 
{
1785 
        return XFS_INOBT_KEY_ADDR(bb, i, cur);
1786 
}
1787 
#endif
1788 
 
1789 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_MASK)
1790 
xfs_inofree_t
1791 
xfs_inobt_mask(int i)
1792 
{
1793 
        return XFS_INOBT_MASK(i);
1794 
}
1795 
#endif
1796 
 
1797 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_MASKN)
1798 
xfs_inofree_t
1799 
xfs_inobt_maskn(int i, int n)
1800 
{
1801 
        return XFS_INOBT_MASKN(i, n);
1802 
}
1803 
#endif
1804 
 
1805 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_PTR_ADDR)
1806 
xfs_inobt_ptr_t *
1807 
xfs_inobt_ptr_addr(xfs_inobt_block_t *bb, int i, xfs_btree_cur_t *cur)
1808 
{
1809 
        return XFS_INOBT_PTR_ADDR(bb, i, cur);
1810 
}
1811 
#endif
1812 
 
1813 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_REC_ADDR)
1814 
/*ARGSUSED3*/
1815 
xfs_inobt_rec_t *
1816 
xfs_inobt_rec_addr(xfs_inobt_block_t *bb, int i, xfs_btree_cur_t *cur)
1817 
{
1818 
        return XFS_INOBT_REC_ADDR(bb, i, cur);
1819 
}
1820 
#endif
1821 
 
1822 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_INOBT_SET_FREE)
1823 
void
1824 
xfs_inobt_set_free(xfs_inobt_rec_t *rp, int i, xfs_arch_t arch)
1825 
{
1826 
        XFS_INOBT_SET_FREE(rp, i, arch);
1827 
}
1828 
#endif
1829 
 
1830 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ITOBHV)
1831 
bhv_desc_t *
1832 
xfs_itobhv(xfs_inode_t *ip)
1833 
{
1834 
        return XFS_ITOBHV(ip);
1835 
}
1836 
#endif
1837 
 
1838 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_ITOV)
1839 
vnode_t *
1840 
xfs_itov(xfs_inode_t *ip)
1841 
{
1842 
        return XFS_ITOV(ip);
1843 
}
1844 
#endif
1845 
 
1846 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LBLOG)
1847 
int
1848 
xfs_lblog(xfs_mount_t *mp)
1849 
{
1850 
        return XFS_LBLOG(mp);
1851 
}
1852 
#endif
1853 
 
1854 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LBSIZE)
1855 
int
1856 
xfs_lbsize(xfs_mount_t *mp)
1857 
{
1858 
        return XFS_LBSIZE(mp);
1859 
}
1860 
#endif
1861 
 
1862 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_ALL_FREE)
1863 
void
1864 
xfs_lic_all_free(xfs_log_item_chunk_t *cp)
1865 
{
1866 
        XFS_LIC_ALL_FREE(cp);
1867 
}
1868 
#endif
1869 
 
1870 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_ARE_ALL_FREE)
1871 
int
1872 
xfs_lic_are_all_free(xfs_log_item_chunk_t *cp)
1873 
{
1874 
        return XFS_LIC_ARE_ALL_FREE(cp);
1875 
}
1876 
#endif
1877 
 
1878 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_CLAIM)
1879 
void
1880 
xfs_lic_claim(xfs_log_item_chunk_t *cp, int slot)
1881 
{
1882 
        XFS_LIC_CLAIM(cp, slot);
1883 
}
1884 
#endif
1885 
 
1886 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_DESC_TO_CHUNK)
1887 
xfs_log_item_chunk_t *
1888 
xfs_lic_desc_to_chunk(xfs_log_item_desc_t *dp)
1889 
{
1890 
        return XFS_LIC_DESC_TO_CHUNK(dp);
1891 
}
1892 
#endif
1893 
 
1894 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_DESC_TO_SLOT)
1895 
int
1896 
xfs_lic_desc_to_slot(xfs_log_item_desc_t *dp)
1897 
{
1898 
        return XFS_LIC_DESC_TO_SLOT(dp);
1899 
}
1900 
#endif
1901 
 
1902 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_INIT)
1903 
void
1904 
xfs_lic_init(xfs_log_item_chunk_t *cp)
1905 
{
1906 
        XFS_LIC_INIT(cp);
1907 
}
1908 
#endif
1909 
 
1910 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_INIT_SLOT)
1911 
void
1912 
xfs_lic_init_slot(xfs_log_item_chunk_t *cp, int slot)
1913 
{
1914 
        XFS_LIC_INIT_SLOT(cp, slot);
1915 
}
1916 
#endif
1917 
 
1918 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_ISFREE)
1919 
int
1920 
xfs_lic_isfree(xfs_log_item_chunk_t *cp, int slot)
1921 
{
1922 
        return XFS_LIC_ISFREE(cp, slot);
1923 
}
1924 
#endif
1925 
 
1926 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_RELSE)
1927 
void
1928 
xfs_lic_relse(xfs_log_item_chunk_t *cp, int slot)
1929 
{
1930 
        XFS_LIC_RELSE(cp, slot);
1931 
}
1932 
#endif
1933 
 
1934 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_SLOT)
1935 
xfs_log_item_desc_t *
1936 
xfs_lic_slot(xfs_log_item_chunk_t *cp, int slot)
1937 
{
1938 
        return XFS_LIC_SLOT(cp, slot);
1939 
}
1940 
#endif
1941 
 
1942 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LIC_VACANCY)
1943 
int
1944 
xfs_lic_vacancy(xfs_log_item_chunk_t *cp)
1945 
{
1946 
        return XFS_LIC_VACANCY(cp);
1947 
}
1948 
#endif
1949 
 
1950 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_LITINO)
1951 
int
1952 
xfs_litino(xfs_mount_t *mp)
1953 
{
1954 
        return XFS_LITINO(mp);
1955 
}
1956 
#endif
1957 
 
1958 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MAKE_IPTR)
1959 
xfs_dinode_t *
1960 
xfs_make_iptr(xfs_mount_t *mp, xfs_buf_t *b, int o)
1961 
{
1962 
        return XFS_MAKE_IPTR(mp, b, o);
1963 
}
1964 
#endif
1965 
 
1966 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MASK32HI)
1967 
__uint32_t
1968 
xfs_mask32hi(int n)
1969 
{
1970 
        return XFS_MASK32HI(n);
1971 
}
1972 
#endif
1973 
 
1974 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MASK32LO)
1975 
__uint32_t
1976 
xfs_mask32lo(int n)
1977 
{
1978 
        return XFS_MASK32LO(n);
1979 
}
1980 
#endif
1981 
 
1982 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MASK64HI)
1983 
__uint64_t
1984 
xfs_mask64hi(int n)
1985 
{
1986 
        return XFS_MASK64HI(n);
1987 
}
1988 
#endif
1989 
 
1990 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MASK64LO)
1991 
__uint64_t
1992 
xfs_mask64lo(int n)
1993 
{
1994 
        return XFS_MASK64LO(n);
1995 
}
1996 
#endif
1997 
 
1998 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MIN_FREELIST)
1999 
int
2000 
xfs_min_freelist(xfs_agf_t *a, xfs_mount_t *mp)
2001 
{
2002 
        return XFS_MIN_FREELIST(a, mp);
2003 
}
2004 
#endif
2005 
 
2006 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MIN_FREELIST_PAG)
2007 
int
2008 
xfs_min_freelist_pag(xfs_perag_t *pag, xfs_mount_t *mp)
2009 
{
2010 
        return XFS_MIN_FREELIST_PAG(pag, mp);
2011 
}
2012 
#endif
2013 
 
2014 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MIN_FREELIST_RAW)
2015 
int
2016 
xfs_min_freelist_raw(uint bl, uint cl, xfs_mount_t *mp)
2017 
{
2018 
        return XFS_MIN_FREELIST_RAW(bl, cl, mp);
2019 
}
2020 
#endif
2021 
 
2022 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_MTOVFS)
2023 
vfs_t *
2024 
xfs_mtovfs(xfs_mount_t *mp)
2025 
{
2026 
        return XFS_MTOVFS(mp);
2027 
}
2028 
#endif
2029 
 
2030 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_OFFBNO_TO_AGINO)
2031 
xfs_agino_t
2032 
xfs_offbno_to_agino(xfs_mount_t *mp, xfs_agblock_t b, int o)
2033 
{
2034 
        return XFS_OFFBNO_TO_AGINO(mp, b, o);
2035 
}
2036 
#endif
2037 
 
2038 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_PREALLOC_BLOCKS)
2039 
xfs_agblock_t
2040 
xfs_prealloc_blocks(xfs_mount_t *mp)
2041 
{
2042 
        return XFS_PREALLOC_BLOCKS(mp);
2043 
}
2044 
#endif
2045 
 
2046 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_BLOCK)
2047 
xfs_agblock_t
2048 
xfs_sb_block(xfs_mount_t *mp)
2049 
{
2050 
        return XFS_SB_BLOCK(mp);
2051 
}
2052 
#endif
2053 
 
2054 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_GOOD_VERSION)
2055 
int
2056 
xfs_sb_good_version(xfs_sb_t *sbp)
2057 
{
2058 
        return XFS_SB_GOOD_VERSION(sbp);
2059 
}
2060 
#endif
2061 
 
2062 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_ADDATTR)
2063 
void
2064 
xfs_sb_version_addattr(xfs_sb_t *sbp)
2065 
{
2066 
        XFS_SB_VERSION_ADDATTR(sbp);
2067 
}
2068 
#endif
2069 
 
2070 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_ADDDALIGN)
2071 
void
2072 
xfs_sb_version_adddalign(xfs_sb_t *sbp)
2073 
{
2074 
        XFS_SB_VERSION_ADDDALIGN(sbp);
2075 
}
2076 
#endif
2077 
 
2078 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_ADDNLINK)
2079 
void
2080 
xfs_sb_version_addnlink(xfs_sb_t *sbp)
2081 
{
2082 
        XFS_SB_VERSION_ADDNLINK(sbp);
2083 
}
2084 
#endif
2085 
 
2086 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_ADDQUOTA)
2087 
void
2088 
xfs_sb_version_addquota(xfs_sb_t *sbp)
2089 
{
2090 
        XFS_SB_VERSION_ADDQUOTA(sbp);
2091 
}
2092 
#endif
2093 
 
2094 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_ADDSHARED)
2095 
void
2096 
xfs_sb_version_addshared(xfs_sb_t *sbp)
2097 
{
2098 
        XFS_SB_VERSION_ADDSHARED(sbp);
2099 
}
2100 
#endif
2101 
 
2102 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASALIGN)
2103 
int
2104 
xfs_sb_version_hasalign(xfs_sb_t *sbp)
2105 
{
2106 
        return XFS_SB_VERSION_HASALIGN(sbp);
2107 
}
2108 
#endif
2109 
 
2110 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASATTR)
2111 
int
2112 
xfs_sb_version_hasattr(xfs_sb_t *sbp)
2113 
{
2114 
        return XFS_SB_VERSION_HASATTR(sbp);
2115 
}
2116 
#endif
2117 
 
2118 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASDALIGN)
2119 
int
2120 
xfs_sb_version_hasdalign(xfs_sb_t *sbp)
2121 
{
2122 
        return XFS_SB_VERSION_HASDALIGN(sbp);
2123 
}
2124 
#endif
2125 
 
2126 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASDIRV2)
2127 
int
2128 
xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
2129 
{
2130 
        return XFS_SB_VERSION_HASDIRV2(sbp);
2131 
}
2132 
#endif
2133 
 
2134 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASEXTFLGBIT)
2135 
int
2136 
xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
2137 
{
2138 
        return XFS_SB_VERSION_HASEXTFLGBIT(sbp);
2139 
}
2140 
#endif
2141 
 
2142 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASNLINK)
2143 
int
2144 
xfs_sb_version_hasnlink(xfs_sb_t *sbp)
2145 
{
2146 
        return XFS_SB_VERSION_HASNLINK(sbp);
2147 
}
2148 
#endif
2149 
 
2150 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASQUOTA)
2151 
int
2152 
xfs_sb_version_hasquota(xfs_sb_t *sbp)
2153 
{
2154 
        return XFS_SB_VERSION_HASQUOTA(sbp);
2155 
}
2156 
#endif
2157 
 
2158 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASSHARED)
2159 
int
2160 
xfs_sb_version_hasshared(xfs_sb_t *sbp)
2161 
{
2162 
        return XFS_SB_VERSION_HASSHARED(sbp);
2163 
}
2164 
#endif
2165 
 
2166 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_NUM)
2167 
int
2168 
xfs_sb_version_num(xfs_sb_t *sbp)
2169 
{
2170 
        return XFS_SB_VERSION_NUM(sbp);
2171 
}
2172 
#endif
2173 
 
2174 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_SUBALIGN)
2175 
void
2176 
xfs_sb_version_subalign(xfs_sb_t *sbp)
2177 
{
2178 
        XFS_SB_VERSION_SUBALIGN(sbp);
2179 
}
2180 
#endif
2181 
 
2182 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_SUBSHARED)
2183 
void
2184 
xfs_sb_version_subshared(xfs_sb_t *sbp)
2185 
{
2186 
        XFS_SB_VERSION_SUBSHARED(sbp);
2187 
}
2188 
#endif
2189 
 
2190 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASLOGV2)
2191 
int
2192 
xfs_sb_version_haslogv2(xfs_sb_t *sbp)
2193 
{
2194 
        return XFS_SB_VERSION_HASLOGV2(sbp);
2195 
}
2196 
#endif
2197 
 
2198 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_HASSECTOR)
2199 
int
2200 
xfs_sb_version_hassector(xfs_sb_t *sbp)
2201 
{
2202 
        return XFS_SB_VERSION_HASSECTOR(sbp);
2203 
}
2204 
#endif
2205 
 
2206 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_TONEW)
2207 
unsigned
2208 
xfs_sb_version_tonew(unsigned v)
2209 
{
2210 
        return XFS_SB_VERSION_TONEW(v);
2211 
}
2212 
#endif
2213 
 
2214 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XFS_SB_VERSION_TOOLD)
2215 
unsigned
2216 
xfs_sb_version_toold(unsigned v)
2217 
{
2218 
        return XFS_SB_VERSION_TOOLD(v);
2219 
}
2220 
#endif
2221 
 
2222 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XLOG_GRANT_ADD_SPACE)
2223 
void
2224 
xlog_grant_add_space(xlog_t *log, int bytes, int type)
2225 
{
2226 
        XLOG_GRANT_ADD_SPACE(log, bytes, type);
2227 
}
2228 
#endif
2229 
 
2230 
#if XFS_WANT_FUNCS_C || (XFS_WANT_SPACE_C && XFSSO_XLOG_GRANT_SUB_SPACE)
2231 
void
2232 
xlog_grant_sub_space(xlog_t *log, int bytes, int type)
2233 
{
2234 
        XLOG_GRANT_SUB_SPACE(log, bytes, type);
2235 
}
2236 
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.