2 * Copyright (c) 2000-2001 Silicon Graphics, Inc. All Rights Reserved.
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.
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.
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.
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.
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
28 * For further information regarding this notice, see:
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
43 static int attr_leaf_entries_count(void *obj
, int startoff
);
44 static int attr_leaf_hdr_count(void *obj
, int startoff
);
45 static int attr_leaf_name_local_count(void *obj
, int startoff
);
46 static int attr_leaf_name_local_name_count(void *obj
, int startoff
);
47 static int attr_leaf_name_local_value_count(void *obj
, int startoff
);
48 static int attr_leaf_name_local_value_offset(void *obj
, int startoff
,
50 static int attr_leaf_name_remote_count(void *obj
, int startoff
);
51 static int attr_leaf_name_remote_name_count(void *obj
, int startoff
);
52 static int attr_leaf_nvlist_count(void *obj
, int startoff
);
53 static int attr_leaf_nvlist_offset(void *obj
, int startoff
, int idx
);
54 static int attr_node_btree_count(void *obj
, int startoff
);
55 static int attr_node_hdr_count(void *obj
, int startoff
);
57 const field_t attr_hfld
[] = {
58 { "", FLDT_ATTR
, OI(0), C1
, 0, TYP_NONE
},
62 #define LOFF(f) bitize(offsetof(xfs_attr_leafblock_t, f))
63 #define NOFF(f) bitize(offsetof(xfs_da_intnode_t, f))
64 const field_t attr_flds
[] = {
65 { "hdr", FLDT_ATTR_LEAF_HDR
, OI(LOFF(hdr
)), attr_leaf_hdr_count
,
66 FLD_COUNT
, TYP_NONE
},
67 { "hdr", FLDT_ATTR_NODE_HDR
, OI(NOFF(hdr
)), attr_node_hdr_count
,
68 FLD_COUNT
, TYP_NONE
},
69 { "entries", FLDT_ATTR_LEAF_ENTRY
, OI(LOFF(entries
)),
70 attr_leaf_entries_count
, FLD_ARRAY
|FLD_COUNT
, TYP_NONE
},
71 { "btree", FLDT_ATTR_NODE_ENTRY
, OI(NOFF(btree
)), attr_node_btree_count
,
72 FLD_ARRAY
|FLD_COUNT
, TYP_NONE
},
73 { "nvlist", FLDT_ATTR_LEAF_NAME
, attr_leaf_nvlist_offset
,
74 attr_leaf_nvlist_count
, FLD_ARRAY
|FLD_OFFSET
|FLD_COUNT
, TYP_NONE
},
78 #define BOFF(f) bitize(offsetof(xfs_da_blkinfo_t, f))
79 const field_t attr_blkinfo_flds
[] = {
80 { "forw", FLDT_ATTRBLOCK
, OI(BOFF(forw
)), C1
, 0, TYP_ATTR
},
81 { "back", FLDT_ATTRBLOCK
, OI(BOFF(back
)), C1
, 0, TYP_ATTR
},
82 { "magic", FLDT_UINT16X
, OI(BOFF(magic
)), C1
, 0, TYP_NONE
},
83 { "pad", FLDT_UINT16X
, OI(BOFF(pad
)), C1
, FLD_SKIPALL
, TYP_NONE
},
87 #define LEOFF(f) bitize(offsetof(xfs_attr_leaf_entry_t, f))
88 const field_t attr_leaf_entry_flds
[] = {
89 { "hashval", FLDT_UINT32X
, OI(LEOFF(hashval
)), C1
, 0, TYP_NONE
},
90 { "nameidx", FLDT_UINT16D
, OI(LEOFF(nameidx
)), C1
, 0, TYP_NONE
},
91 { "flags", FLDT_UINT8X
, OI(LEOFF(flags
)), C1
, FLD_SKIPALL
, TYP_NONE
},
92 { "incomplete", FLDT_UINT1
,
93 OI(LEOFF(flags
) + bitsz(__uint8_t
) - XFS_ATTR_INCOMPLETE_BIT
- 1), C1
,
96 OI(LEOFF(flags
) + bitsz(__uint8_t
) - XFS_ATTR_ROOT_BIT
- 1), C1
, 0,
98 { "local", FLDT_UINT1
,
99 OI(LEOFF(flags
) + bitsz(__uint8_t
) - XFS_ATTR_LOCAL_BIT
- 1), C1
, 0,
101 { "pad2", FLDT_UINT8X
, OI(LEOFF(pad2
)), C1
, FLD_SKIPALL
, TYP_NONE
},
105 #define LHOFF(f) bitize(offsetof(xfs_attr_leaf_hdr_t, f))
106 const field_t attr_leaf_hdr_flds
[] = {
107 { "info", FLDT_ATTR_BLKINFO
, OI(LHOFF(info
)), C1
, 0, TYP_NONE
},
108 { "count", FLDT_UINT16D
, OI(LHOFF(count
)), C1
, 0, TYP_NONE
},
109 { "usedbytes", FLDT_UINT16D
, OI(LHOFF(usedbytes
)), C1
, 0, TYP_NONE
},
110 { "firstused", FLDT_UINT16D
, OI(LHOFF(firstused
)), C1
, 0, TYP_NONE
},
111 { "holes", FLDT_UINT8D
, OI(LHOFF(holes
)), C1
, 0, TYP_NONE
},
112 { "pad1", FLDT_UINT8X
, OI(LHOFF(pad1
)), C1
, FLD_SKIPALL
, TYP_NONE
},
113 { "freemap", FLDT_ATTR_LEAF_MAP
, OI(LHOFF(freemap
)),
114 CI(XFS_ATTR_LEAF_MAPSIZE
), FLD_ARRAY
, TYP_NONE
},
118 #define LMOFF(f) bitize(offsetof(xfs_attr_leaf_map_t, f))
119 const field_t attr_leaf_map_flds
[] = {
120 { "base", FLDT_UINT16D
, OI(LMOFF(base
)), C1
, 0, TYP_NONE
},
121 { "size", FLDT_UINT16D
, OI(LMOFF(size
)), C1
, 0, TYP_NONE
},
125 #define LNOFF(f) bitize(offsetof(xfs_attr_leaf_name_local_t, f))
126 #define LVOFF(f) bitize(offsetof(xfs_attr_leaf_name_remote_t, f))
127 const field_t attr_leaf_name_flds
[] = {
128 { "valuelen", FLDT_UINT16D
, OI(LNOFF(valuelen
)),
129 attr_leaf_name_local_count
, FLD_COUNT
, TYP_NONE
},
130 { "namelen", FLDT_UINT8D
, OI(LNOFF(namelen
)),
131 attr_leaf_name_local_count
, FLD_COUNT
, TYP_NONE
},
132 { "name", FLDT_CHARNS
, OI(LNOFF(nameval
)),
133 attr_leaf_name_local_name_count
, FLD_COUNT
, TYP_NONE
},
134 { "value", FLDT_CHARNS
, attr_leaf_name_local_value_offset
,
135 attr_leaf_name_local_value_count
, FLD_COUNT
|FLD_OFFSET
, TYP_NONE
},
136 { "valueblk", FLDT_UINT32X
, OI(LVOFF(valueblk
)),
137 attr_leaf_name_remote_count
, FLD_COUNT
, TYP_NONE
},
138 { "valuelen", FLDT_UINT32D
, OI(LVOFF(valuelen
)),
139 attr_leaf_name_remote_count
, FLD_COUNT
, TYP_NONE
},
140 { "namelen", FLDT_UINT8D
, OI(LVOFF(namelen
)),
141 attr_leaf_name_remote_count
, FLD_COUNT
, TYP_NONE
},
142 { "name", FLDT_CHARNS
, OI(LVOFF(name
)),
143 attr_leaf_name_remote_name_count
, FLD_COUNT
, TYP_NONE
},
147 #define EOFF(f) bitize(offsetof(xfs_da_node_entry_t, f))
148 const field_t attr_node_entry_flds
[] = {
149 { "hashval", FLDT_UINT32X
, OI(EOFF(hashval
)), C1
, 0, TYP_NONE
},
150 { "before", FLDT_ATTRBLOCK
, OI(EOFF(before
)), C1
, 0, TYP_ATTR
},
154 #define HOFF(f) bitize(offsetof(xfs_da_node_hdr_t, f))
155 const field_t attr_node_hdr_flds
[] = {
156 { "info", FLDT_ATTR_BLKINFO
, OI(HOFF(info
)), C1
, 0, TYP_NONE
},
157 { "count", FLDT_UINT16D
, OI(HOFF(count
)), C1
, 0, TYP_NONE
},
158 { "level", FLDT_UINT16D
, OI(HOFF(level
)), C1
, 0, TYP_NONE
},
164 attr_leaf_entries_count(
168 xfs_attr_leafblock_t
*block
;
170 ASSERT(startoff
== 0);
172 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
173 != XFS_ATTR_LEAF_MAGIC
) {
177 return INT_GET(block
->hdr
.count
, ARCH_CONVERT
);
186 xfs_attr_leafblock_t
*block
;
188 ASSERT(startoff
== 0);
190 return INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
191 == XFS_ATTR_LEAF_MAGIC
;
195 attr_leaf_name_local_count(
199 xfs_attr_leafblock_t
*block
;
200 xfs_attr_leaf_entry_t
*e
;
204 ASSERT(bitoffs(startoff
) == 0);
205 off
= byteize(startoff
);
207 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
208 != XFS_ATTR_LEAF_MAGIC
)
210 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
211 e
= &block
->entries
[i
];
212 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
)
213 return (INT_GET(e
->flags
, ARCH_CONVERT
)
214 & XFS_ATTR_LOCAL
) != 0;
220 attr_leaf_name_local_name_count(
224 xfs_attr_leafblock_t
*block
;
225 xfs_attr_leaf_entry_t
*e
;
227 xfs_attr_leaf_name_local_t
*l
;
230 ASSERT(bitoffs(startoff
) == 0);
231 off
= byteize(startoff
);
233 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
234 != XFS_ATTR_LEAF_MAGIC
)
236 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
237 e
= &block
->entries
[i
];
238 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
) {
239 if (INT_GET(e
->flags
, ARCH_CONVERT
) & XFS_ATTR_LOCAL
) {
240 l
= XFS_ATTR_LEAF_NAME_LOCAL(block
, i
);
241 return INT_GET(l
->namelen
, ARCH_CONVERT
);
250 attr_leaf_name_local_value_count(
254 xfs_attr_leafblock_t
*block
;
255 xfs_attr_leaf_entry_t
*e
;
257 xfs_attr_leaf_name_local_t
*l
;
260 ASSERT(bitoffs(startoff
) == 0);
261 off
= byteize(startoff
);
263 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
264 != XFS_ATTR_LEAF_MAGIC
)
266 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
267 e
= &block
->entries
[i
];
268 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
) {
269 if (INT_GET(e
->flags
, ARCH_CONVERT
) & XFS_ATTR_LOCAL
) {
270 l
= XFS_ATTR_LEAF_NAME_LOCAL(block
, i
);
271 return INT_GET(l
->valuelen
, ARCH_CONVERT
);
281 attr_leaf_name_local_value_offset(
286 xfs_attr_leafblock_t
*block
;
287 xfs_attr_leaf_name_local_t
*l
;
290 xfs_attr_leaf_entry_t
*e
;
293 ASSERT(bitoffs(startoff
) == 0);
294 off
= byteize(startoff
);
296 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
297 != XFS_ATTR_LEAF_MAGIC
)
300 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
301 e
= &block
->entries
[i
];
302 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
)
305 if (i
>=INT_GET(block
->hdr
.count
, ARCH_CONVERT
)) return 0;
307 l
= XFS_ATTR_LEAF_NAME_LOCAL(block
, i
);
308 vp
= (char *)&l
->nameval
[l
->namelen
];
309 return (int)bitize(vp
- (char *)l
);
313 attr_leaf_name_remote_count(
317 xfs_attr_leafblock_t
*block
;
318 xfs_attr_leaf_entry_t
*e
;
322 ASSERT(bitoffs(startoff
) == 0);
323 off
= byteize(startoff
);
325 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
326 != XFS_ATTR_LEAF_MAGIC
)
328 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
329 e
= &block
->entries
[i
];
330 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
)
331 return (INT_GET(e
->flags
, ARCH_CONVERT
) & XFS_ATTR_LOCAL
) == 0;
337 attr_leaf_name_remote_name_count(
341 xfs_attr_leafblock_t
*block
;
342 xfs_attr_leaf_entry_t
*e
;
345 xfs_attr_leaf_name_remote_t
*r
;
347 ASSERT(bitoffs(startoff
) == 0);
348 off
= byteize(startoff
);
350 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
351 != XFS_ATTR_LEAF_MAGIC
)
353 for (i
= 0; i
< INT_GET(block
->hdr
.count
, ARCH_CONVERT
); i
++) {
354 e
= &block
->entries
[i
];
355 if (INT_GET(e
->nameidx
, ARCH_CONVERT
) == off
) {
356 if (!(INT_GET(e
->flags
, ARCH_CONVERT
) & XFS_ATTR_LOCAL
)) {
357 r
= XFS_ATTR_LEAF_NAME_REMOTE(block
, i
);
358 return INT_GET(r
->namelen
, ARCH_CONVERT
);
373 xfs_attr_leafblock_t
*block
;
374 xfs_attr_leaf_entry_t
*e
;
375 xfs_attr_leaf_name_local_t
*l
;
376 xfs_attr_leaf_name_remote_t
*r
;
378 ASSERT(startoff
== 0);
380 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
381 != XFS_ATTR_LEAF_MAGIC
)
383 e
= &block
->entries
[idx
];
384 if (INT_GET(e
->flags
, ARCH_CONVERT
) & XFS_ATTR_LOCAL
) {
385 l
= XFS_ATTR_LEAF_NAME_LOCAL(block
, idx
);
386 return (int)bitize(XFS_ATTR_LEAF_ENTSIZE_LOCAL(INT_GET(l
->namelen
, ARCH_CONVERT
),
387 INT_GET(l
->valuelen
, ARCH_CONVERT
)));
389 r
= XFS_ATTR_LEAF_NAME_REMOTE(block
, idx
);
390 return (int)bitize(XFS_ATTR_LEAF_ENTSIZE_REMOTE(INT_GET(r
->namelen
, ARCH_CONVERT
)));
396 attr_leaf_nvlist_count(
400 xfs_attr_leafblock_t
*block
;
402 ASSERT(startoff
== 0);
404 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
405 != XFS_ATTR_LEAF_MAGIC
)
407 return INT_GET(block
->hdr
.count
, ARCH_CONVERT
);
412 attr_leaf_nvlist_offset(
417 xfs_attr_leafblock_t
*block
;
418 xfs_attr_leaf_entry_t
*e
;
420 ASSERT(startoff
== 0);
422 e
= &block
->entries
[idx
];
423 return bitize(INT_GET(e
->nameidx
, ARCH_CONVERT
));
428 attr_node_btree_count(
432 xfs_da_intnode_t
*block
;
434 ASSERT(startoff
== 0); /* this is a base structure */
436 if (INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
437 != XFS_DA_NODE_MAGIC
)
439 return INT_GET(block
->hdr
.count
, ARCH_CONVERT
);
448 xfs_da_intnode_t
*block
;
450 ASSERT(startoff
== 0);
452 return INT_GET(block
->hdr
.info
.magic
, ARCH_CONVERT
)
453 == XFS_DA_NODE_MAGIC
;
463 return bitize(mp
->m_sb
.sb_blocksize
);