]>
Commit | Line | Data |
---|---|---|
49b31417 BN |
1 | /* |
2 | * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc. | |
3 | * All Rights Reserved. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License as | |
7 | * published by the Free Software Foundation. | |
8 | * | |
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 | |
17 | */ | |
18 | ||
6b803e5a | 19 | #include "libxfs.h" |
49b31417 BN |
20 | #include "type.h" |
21 | #include "faddr.h" | |
22 | #include "fprint.h" | |
23 | #include "field.h" | |
24 | #include "btblock.h" | |
25 | #include "print.h" | |
26 | #include "bit.h" | |
27 | #include "init.h" | |
58615a7a DW |
28 | #include "io.h" |
29 | #include "output.h" | |
49b31417 | 30 | |
49b31417 BN |
31 | /* |
32 | * Definition of the possible btree block layouts. | |
33 | */ | |
34 | struct xfs_db_btree { | |
4e503735 | 35 | uint32_t magic; |
49b31417 BN |
36 | size_t block_len; |
37 | size_t key_len; | |
38 | size_t rec_len; | |
39 | size_t ptr_len; | |
40 | } btrees[] = { | |
4e503735 | 41 | { XFS_BMAP_MAGIC, |
b3563c19 | 42 | XFS_BTREE_LBLOCK_LEN, |
49b31417 BN |
43 | sizeof(xfs_bmbt_key_t), |
44 | sizeof(xfs_bmbt_rec_t), | |
45 | sizeof(__be64), | |
46 | }, | |
4e503735 | 47 | { XFS_ABTB_MAGIC, |
b3563c19 | 48 | XFS_BTREE_SBLOCK_LEN, |
49b31417 BN |
49 | sizeof(xfs_alloc_key_t), |
50 | sizeof(xfs_alloc_rec_t), | |
51 | sizeof(__be32), | |
52 | }, | |
4e503735 | 53 | { XFS_ABTC_MAGIC, |
b3563c19 | 54 | XFS_BTREE_SBLOCK_LEN, |
49b31417 BN |
55 | sizeof(xfs_alloc_key_t), |
56 | sizeof(xfs_alloc_rec_t), | |
57 | sizeof(__be32), | |
58 | }, | |
4e503735 | 59 | { XFS_IBT_MAGIC, |
b3563c19 | 60 | XFS_BTREE_SBLOCK_LEN, |
49b31417 BN |
61 | sizeof(xfs_inobt_key_t), |
62 | sizeof(xfs_inobt_rec_t), | |
63 | sizeof(__be32), | |
64 | }, | |
2a0cd7ad BF |
65 | { XFS_FIBT_MAGIC, |
66 | XFS_BTREE_SBLOCK_LEN, | |
67 | sizeof(xfs_inobt_key_t), | |
68 | sizeof(xfs_inobt_rec_t), | |
69 | sizeof(__be32), | |
70 | }, | |
4e503735 | 71 | { XFS_BMAP_CRC_MAGIC, |
c2907bd7 DC |
72 | XFS_BTREE_LBLOCK_CRC_LEN, |
73 | sizeof(xfs_bmbt_key_t), | |
74 | sizeof(xfs_bmbt_rec_t), | |
75 | sizeof(__be64), | |
76 | }, | |
4e503735 | 77 | { XFS_ABTB_CRC_MAGIC, |
c2907bd7 DC |
78 | XFS_BTREE_SBLOCK_CRC_LEN, |
79 | sizeof(xfs_alloc_key_t), | |
80 | sizeof(xfs_alloc_rec_t), | |
81 | sizeof(__be32), | |
82 | }, | |
4e503735 | 83 | { XFS_ABTC_CRC_MAGIC, |
c2907bd7 DC |
84 | XFS_BTREE_SBLOCK_CRC_LEN, |
85 | sizeof(xfs_alloc_key_t), | |
86 | sizeof(xfs_alloc_rec_t), | |
87 | sizeof(__be32), | |
88 | }, | |
4e503735 | 89 | { XFS_IBT_CRC_MAGIC, |
c2907bd7 DC |
90 | XFS_BTREE_SBLOCK_CRC_LEN, |
91 | sizeof(xfs_inobt_key_t), | |
92 | sizeof(xfs_inobt_rec_t), | |
93 | sizeof(__be32), | |
94 | }, | |
2a0cd7ad BF |
95 | { XFS_FIBT_CRC_MAGIC, |
96 | XFS_BTREE_SBLOCK_CRC_LEN, | |
97 | sizeof(xfs_inobt_key_t), | |
98 | sizeof(xfs_inobt_rec_t), | |
99 | sizeof(__be32), | |
100 | }, | |
a9d7b986 DW |
101 | { XFS_RMAP_CRC_MAGIC, |
102 | XFS_BTREE_SBLOCK_CRC_LEN, | |
103 | 2 * sizeof(struct xfs_rmap_key), | |
104 | sizeof(struct xfs_rmap_rec), | |
105 | sizeof(__be32), | |
106 | }, | |
9fb2cb27 DW |
107 | { XFS_REFC_CRC_MAGIC, |
108 | XFS_BTREE_SBLOCK_CRC_LEN, | |
109 | sizeof(struct xfs_refcount_key), | |
110 | sizeof(struct xfs_refcount_rec), | |
111 | sizeof(__be32), | |
112 | }, | |
4e503735 DC |
113 | { 0, |
114 | }, | |
49b31417 BN |
115 | }; |
116 | ||
117 | /* | |
58615a7a | 118 | * Find the right block definition for a given ondisk block. |
49b31417 | 119 | */ |
4e503735 DC |
120 | static struct xfs_db_btree * |
121 | block_to_bt( | |
122 | struct xfs_btree_block *bb) | |
123 | { | |
58615a7a DW |
124 | struct xfs_db_btree *btp; |
125 | uint32_t magic; | |
126 | bool crc; | |
127 | ||
128 | magic = be32_to_cpu((bb)->bb_magic); | |
129 | for (btp = &btrees[0]; btp->magic != 0; btp++) { | |
130 | if (magic == btp->magic) | |
131 | return btp; | |
132 | } | |
133 | ||
134 | /* Magic is invalid/unknown. Guess based on iocur type */ | |
135 | crc = xfs_sb_version_hascrc(&mp->m_sb); | |
136 | switch (iocur_top->typ->typnm) { | |
137 | case TYP_BMAPBTA: | |
138 | case TYP_BMAPBTD: | |
139 | magic = crc ? XFS_BMAP_CRC_MAGIC : XFS_BMAP_MAGIC; | |
140 | break; | |
141 | case TYP_BNOBT: | |
142 | magic = crc ? XFS_ABTB_CRC_MAGIC : XFS_ABTB_MAGIC; | |
143 | break; | |
144 | case TYP_CNTBT: | |
145 | magic = crc ? XFS_ABTC_CRC_MAGIC : XFS_ABTC_MAGIC; | |
146 | break; | |
147 | case TYP_INOBT: | |
148 | magic = crc ? XFS_IBT_CRC_MAGIC : XFS_IBT_MAGIC; | |
149 | break; | |
150 | case TYP_FINOBT: | |
151 | magic = crc ? XFS_FIBT_CRC_MAGIC : XFS_FIBT_MAGIC; | |
152 | break; | |
153 | case TYP_RMAPBT: | |
154 | magic = crc ? XFS_RMAP_CRC_MAGIC : 0; | |
155 | break; | |
156 | case TYP_REFCBT: | |
157 | magic = crc ? XFS_REFC_CRC_MAGIC : 0; | |
158 | break; | |
159 | default: | |
160 | ASSERT(0); | |
161 | } | |
162 | ||
163 | ASSERT(magic); | |
164 | dbprintf(_("Bad btree magic 0x%x; coercing to %s.\n"), | |
165 | be32_to_cpu((bb)->bb_magic), | |
166 | iocur_top->typ->name); | |
4e503735 | 167 | |
58615a7a DW |
168 | for (btp = &btrees[0]; btp->magic != 0; btp++) { |
169 | if (magic == btp->magic) | |
4e503735 | 170 | return btp; |
58615a7a | 171 | } |
4e503735 DC |
172 | |
173 | return NULL; | |
174 | } | |
49b31417 BN |
175 | |
176 | /* calculate max records. Only for non-leaves. */ | |
177 | static int | |
178 | btblock_maxrecs(struct xfs_db_btree *bt, int blocksize) | |
179 | { | |
180 | blocksize -= bt->block_len; | |
181 | ||
182 | return blocksize / (bt->key_len + bt->ptr_len); | |
183 | } | |
184 | ||
185 | /* | |
186 | * Get the number of keys in a btree block. | |
187 | * | |
188 | * Note: can also be used to get the number of ptrs because there are | |
189 | * always the same number of keys and ptrs in a block. | |
190 | */ | |
191 | static int | |
192 | btblock_key_count( | |
193 | void *obj, | |
194 | int startoff) | |
195 | { | |
196 | struct xfs_btree_block *block = obj; | |
197 | ||
198 | ASSERT(startoff == 0); | |
199 | ||
200 | if (block->bb_level == 0) | |
201 | return 0; | |
202 | return be16_to_cpu(block->bb_numrecs); | |
203 | } | |
204 | ||
205 | /* | |
206 | * Get the number of keys in a btree block. | |
207 | */ | |
208 | static int | |
209 | btblock_rec_count( | |
210 | void *obj, | |
211 | int startoff) | |
212 | { | |
213 | struct xfs_btree_block *block = obj; | |
214 | ||
215 | ASSERT(startoff == 0); | |
216 | ||
217 | if (block->bb_level != 0) | |
218 | return 0; | |
219 | return be16_to_cpu(block->bb_numrecs); | |
220 | } | |
221 | ||
222 | /* | |
223 | * Get the offset of the key at idx in a btree block. | |
224 | */ | |
225 | static int | |
226 | btblock_key_offset( | |
227 | void *obj, | |
228 | int startoff, | |
229 | int idx) | |
230 | { | |
231 | struct xfs_btree_block *block = obj; | |
232 | struct xfs_db_btree *bt = block_to_bt(block); | |
233 | int offset; | |
234 | ||
235 | ASSERT(startoff == 0); | |
236 | ASSERT(block->bb_level != 0); | |
237 | ||
238 | offset = bt->block_len + (idx - 1) * bt->key_len; | |
239 | return bitize(offset); | |
240 | } | |
241 | ||
242 | /* | |
243 | * Get the offset of the ptr at idx in a btree block. | |
244 | */ | |
245 | static int | |
246 | btblock_ptr_offset( | |
247 | void *obj, | |
248 | int startoff, | |
249 | int idx) | |
250 | { | |
251 | struct xfs_btree_block *block = obj; | |
252 | struct xfs_db_btree *bt = block_to_bt(block); | |
253 | int offset; | |
254 | int maxrecs; | |
255 | ||
256 | ASSERT(startoff == 0); | |
257 | ASSERT(block->bb_level != 0); | |
258 | ||
259 | maxrecs = btblock_maxrecs(bt, mp->m_sb.sb_blocksize); | |
260 | offset = bt->block_len + | |
261 | maxrecs * bt->key_len + | |
262 | (idx - 1) * bt->ptr_len; | |
263 | ||
264 | return bitize(offset); | |
265 | } | |
266 | ||
267 | /* | |
268 | * Get the offset of the record at idx in a btree block. | |
269 | */ | |
270 | static int | |
271 | btblock_rec_offset( | |
272 | void *obj, | |
273 | int startoff, | |
274 | int idx) | |
275 | { | |
276 | struct xfs_btree_block *block = obj; | |
277 | struct xfs_db_btree *bt = block_to_bt(block); | |
278 | int offset; | |
279 | ||
280 | ASSERT(startoff == 0); | |
281 | ASSERT(block->bb_level == 0); | |
282 | ||
283 | offset = bt->block_len + (idx - 1) * bt->rec_len; | |
284 | return bitize(offset); | |
285 | } | |
286 | ||
287 | /* | |
288 | * Get the size of a btree block. | |
289 | */ | |
290 | int | |
291 | btblock_size( | |
292 | void *obj, | |
293 | int startoff, | |
294 | int idx) | |
295 | { | |
296 | return bitize(mp->m_sb.sb_blocksize); | |
297 | } | |
298 | ||
299 | ||
300 | /* | |
301 | * Bmap btree. | |
302 | */ | |
303 | ||
304 | const field_t bmapbta_hfld[] = { | |
305 | { "", FLDT_BMAPBTA, OI(0), C1, 0, TYP_NONE }, | |
306 | { NULL } | |
307 | }; | |
308 | const field_t bmapbtd_hfld[] = { | |
309 | { "", FLDT_BMAPBTD, OI(0), C1, 0, TYP_NONE }, | |
310 | { NULL } | |
311 | }; | |
312 | ||
c2907bd7 DC |
313 | const field_t bmapbta_crc_hfld[] = { |
314 | { "", FLDT_BMAPBTA_CRC, OI(0), C1, 0, TYP_NONE }, | |
315 | { NULL } | |
316 | }; | |
317 | const field_t bmapbtd_crc_hfld[] = { | |
318 | { "", FLDT_BMAPBTD_CRC, OI(0), C1, 0, TYP_NONE }, | |
319 | { NULL } | |
320 | }; | |
321 | ||
b3563c19 | 322 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) |
49b31417 BN |
323 | const field_t bmapbta_flds[] = { |
324 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
325 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
326 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
b3563c19 BN |
327 | { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA }, |
328 | { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA }, | |
49b31417 BN |
329 | { "recs", FLDT_BMAPBTAREC, btblock_rec_offset, btblock_rec_count, |
330 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
331 | { "keys", FLDT_BMAPBTAKEY, btblock_key_offset, btblock_key_count, | |
332 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
333 | { "ptrs", FLDT_BMAPBTAPTR, btblock_ptr_offset, btblock_key_count, | |
334 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTA }, | |
335 | { NULL } | |
336 | }; | |
337 | const field_t bmapbtd_flds[] = { | |
338 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
339 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
340 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
c77d2d02 CH |
341 | { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTD }, |
342 | { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTD }, | |
49b31417 BN |
343 | { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count, |
344 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
345 | { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count, | |
346 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
347 | { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count, | |
348 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD }, | |
349 | { NULL } | |
350 | }; | |
c2907bd7 DC |
351 | /* crc enabled versions */ |
352 | const field_t bmapbta_crc_flds[] = { | |
353 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
354 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
355 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
356 | { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTA }, | |
357 | { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTA }, | |
358 | { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD }, | |
359 | { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE }, | |
360 | { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE }, | |
361 | { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE }, | |
0522f1cc | 362 | { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE }, |
c2907bd7 DC |
363 | { "recs", FLDT_BMAPBTAREC, btblock_rec_offset, btblock_rec_count, |
364 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
365 | { "keys", FLDT_BMAPBTAKEY, btblock_key_offset, btblock_key_count, | |
366 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
367 | { "ptrs", FLDT_BMAPBTAPTR, btblock_ptr_offset, btblock_key_count, | |
368 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTA }, | |
369 | { NULL } | |
370 | }; | |
371 | const field_t bmapbtd_crc_flds[] = { | |
372 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
373 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
374 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
375 | { "leftsib", FLDT_DFSBNO, OI(OFF(u.l.bb_leftsib)), C1, 0, TYP_BMAPBTD }, | |
376 | { "rightsib", FLDT_DFSBNO, OI(OFF(u.l.bb_rightsib)), C1, 0, TYP_BMAPBTD }, | |
377 | { "bno", FLDT_DFSBNO, OI(OFF(u.l.bb_blkno)), C1, 0, TYP_BMAPBTD }, | |
378 | { "lsn", FLDT_UINT64X, OI(OFF(u.l.bb_lsn)), C1, 0, TYP_NONE }, | |
379 | { "uuid", FLDT_UUID, OI(OFF(u.l.bb_uuid)), C1, 0, TYP_NONE }, | |
380 | { "owner", FLDT_INO, OI(OFF(u.l.bb_owner)), C1, 0, TYP_NONE }, | |
0522f1cc | 381 | { "crc", FLDT_CRC, OI(OFF(u.l.bb_crc)), C1, 0, TYP_NONE }, |
c2907bd7 DC |
382 | { "recs", FLDT_BMAPBTDREC, btblock_rec_offset, btblock_rec_count, |
383 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
384 | { "keys", FLDT_BMAPBTDKEY, btblock_key_offset, btblock_key_count, | |
385 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
386 | { "ptrs", FLDT_BMAPBTDPTR, btblock_ptr_offset, btblock_key_count, | |
387 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BMAPBTD }, | |
388 | { NULL } | |
389 | }; | |
49b31417 BN |
390 | #undef OFF |
391 | ||
392 | #define KOFF(f) bitize(offsetof(xfs_bmbt_key_t, br_ ## f)) | |
393 | const field_t bmapbta_key_flds[] = { | |
394 | { "startoff", FLDT_DFILOFFA, OI(KOFF(startoff)), C1, 0, TYP_ATTR }, | |
395 | { NULL } | |
396 | }; | |
397 | const field_t bmapbtd_key_flds[] = { | |
398 | { "startoff", FLDT_DFILOFFD, OI(KOFF(startoff)), C1, 0, TYP_INODATA }, | |
399 | { NULL } | |
400 | }; | |
401 | #undef KOFF | |
402 | ||
49b31417 BN |
403 | #define BMBT_EXNTFLAG_BITOFF 0 |
404 | #define BMBT_STARTOFF_BITOFF (BMBT_EXNTFLAG_BITOFF + BMBT_EXNTFLAG_BITLEN) | |
405 | #define BMBT_STARTBLOCK_BITOFF (BMBT_STARTOFF_BITOFF + BMBT_STARTOFF_BITLEN) | |
406 | #define BMBT_BLOCKCOUNT_BITOFF \ | |
407 | (BMBT_STARTBLOCK_BITOFF + BMBT_STARTBLOCK_BITLEN) | |
408 | ||
49b31417 BN |
409 | const field_t bmapbta_rec_flds[] = { |
410 | { "startoff", FLDT_CFILEOFFA, OI(BMBT_STARTOFF_BITOFF), C1, 0, | |
411 | TYP_ATTR }, | |
412 | { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0, | |
413 | TYP_ATTR }, | |
414 | { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0, | |
415 | TYP_NONE }, | |
416 | { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0, | |
417 | TYP_NONE }, | |
418 | { NULL } | |
419 | }; | |
420 | const field_t bmapbtd_rec_flds[] = { | |
421 | { "startoff", FLDT_CFILEOFFD, OI(BMBT_STARTOFF_BITOFF), C1, 0, | |
422 | TYP_INODATA }, | |
423 | { "startblock", FLDT_CFSBLOCK, OI(BMBT_STARTBLOCK_BITOFF), C1, 0, | |
424 | TYP_INODATA }, | |
425 | { "blockcount", FLDT_CEXTLEN, OI(BMBT_BLOCKCOUNT_BITOFF), C1, 0, | |
426 | TYP_NONE }, | |
427 | { "extentflag", FLDT_CEXTFLG, OI(BMBT_EXNTFLAG_BITOFF), C1, 0, | |
428 | TYP_NONE }, | |
429 | { NULL } | |
430 | }; | |
431 | ||
432 | ||
433 | /* | |
434 | * Inode allocation btree. | |
435 | */ | |
436 | ||
437 | const field_t inobt_hfld[] = { | |
438 | { "", FLDT_INOBT, OI(0), C1, 0, TYP_NONE }, | |
439 | { NULL } | |
440 | }; | |
441 | ||
c2907bd7 DC |
442 | const field_t inobt_crc_hfld[] = { |
443 | { "", FLDT_INOBT_CRC, OI(0), C1, 0, TYP_NONE }, | |
444 | { NULL } | |
445 | }; | |
446 | ||
061e316e BF |
447 | const field_t inobt_spcrc_hfld[] = { |
448 | { "", FLDT_INOBT_SPCRC, OI(0), C1, 0, TYP_NONE }, | |
449 | { NULL } | |
450 | }; | |
451 | ||
b3563c19 | 452 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) |
49b31417 BN |
453 | const field_t inobt_flds[] = { |
454 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
455 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
456 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
b3563c19 BN |
457 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT }, |
458 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT }, | |
49b31417 BN |
459 | { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count, |
460 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
461 | { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count, | |
462 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
463 | { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count, | |
464 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT }, | |
465 | { NULL } | |
466 | }; | |
c2907bd7 DC |
467 | const field_t inobt_crc_flds[] = { |
468 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
469 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
470 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
471 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT }, | |
472 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT }, | |
473 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT }, | |
474 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
475 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
476 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
0522f1cc | 477 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, |
c2907bd7 DC |
478 | { "recs", FLDT_INOBTREC, btblock_rec_offset, btblock_rec_count, |
479 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
480 | { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count, | |
481 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
482 | { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count, | |
483 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT }, | |
484 | { NULL } | |
485 | }; | |
061e316e BF |
486 | const field_t inobt_spcrc_flds[] = { |
487 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
488 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
489 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
490 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_INOBT }, | |
491 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_INOBT }, | |
492 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_INOBT }, | |
493 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
494 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
495 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
496 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, | |
497 | { "recs", FLDT_INOBTSPREC, btblock_rec_offset, btblock_rec_count, | |
498 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
499 | { "keys", FLDT_INOBTKEY, btblock_key_offset, btblock_key_count, | |
500 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
501 | { "ptrs", FLDT_INOBTPTR, btblock_ptr_offset, btblock_key_count, | |
502 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_INOBT }, | |
503 | { NULL } | |
504 | }; | |
505 | ||
49b31417 BN |
506 | #undef OFF |
507 | ||
508 | #define KOFF(f) bitize(offsetof(xfs_inobt_key_t, ir_ ## f)) | |
509 | const field_t inobt_key_flds[] = { | |
510 | { "startino", FLDT_AGINO, OI(KOFF(startino)), C1, 0, TYP_INODE }, | |
511 | { NULL } | |
512 | }; | |
513 | #undef KOFF | |
514 | ||
11640e30 | 515 | #define ROFF(f) bitize(offsetof(xfs_inobt_rec_t, f)) |
49b31417 | 516 | const field_t inobt_rec_flds[] = { |
11640e30 BF |
517 | { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE }, |
518 | { "freecount", FLDT_INT32D, OI(ROFF(ir_u.f.ir_freecount)), C1, 0, TYP_NONE }, | |
519 | { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE }, | |
49b31417 BN |
520 | { NULL } |
521 | }; | |
061e316e BF |
522 | /* sparse inode on-disk format */ |
523 | const field_t inobt_sprec_flds[] = { | |
524 | { "startino", FLDT_AGINO, OI(ROFF(ir_startino)), C1, 0, TYP_INODE }, | |
525 | { "holemask", FLDT_UINT16X, OI(ROFF(ir_u.sp.ir_holemask)), C1, 0, | |
526 | TYP_NONE }, | |
527 | { "count", FLDT_UINT8D, OI(ROFF(ir_u.sp.ir_count)), C1, 0, TYP_NONE }, | |
528 | { "freecount", FLDT_INT8D, OI(ROFF(ir_u.sp.ir_freecount)), C1, 0, | |
529 | TYP_NONE }, | |
530 | { "free", FLDT_INOFREE, OI(ROFF(ir_free)), C1, 0, TYP_NONE }, | |
531 | { NULL } | |
532 | }; | |
49b31417 BN |
533 | #undef ROFF |
534 | ||
535 | ||
536 | /* | |
537 | * Allocation btrees. | |
538 | */ | |
539 | const field_t bnobt_hfld[] = { | |
540 | { "", FLDT_BNOBT, OI(0), C1, 0, TYP_NONE }, | |
541 | { NULL } | |
542 | }; | |
543 | ||
c2907bd7 DC |
544 | const field_t bnobt_crc_hfld[] = { |
545 | { "", FLDT_BNOBT_CRC, OI(0), C1, 0, TYP_NONE }, | |
546 | { NULL } | |
547 | }; | |
548 | ||
b3563c19 | 549 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) |
49b31417 BN |
550 | const field_t bnobt_flds[] = { |
551 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
552 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
553 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
b3563c19 BN |
554 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT }, |
555 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT }, | |
49b31417 BN |
556 | { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count, |
557 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
558 | { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count, | |
559 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
560 | { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count, | |
561 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT }, | |
562 | { NULL } | |
563 | }; | |
c2907bd7 DC |
564 | const field_t bnobt_crc_flds[] = { |
565 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
566 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
567 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
568 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_BNOBT }, | |
569 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_BNOBT }, | |
570 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_BNOBT }, | |
571 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
572 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
573 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
0522f1cc | 574 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, |
c2907bd7 DC |
575 | { "recs", FLDT_BNOBTREC, btblock_rec_offset, btblock_rec_count, |
576 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
577 | { "keys", FLDT_BNOBTKEY, btblock_key_offset, btblock_key_count, | |
578 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
579 | { "ptrs", FLDT_BNOBTPTR, btblock_ptr_offset, btblock_key_count, | |
580 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_BNOBT }, | |
581 | { NULL } | |
582 | }; | |
49b31417 BN |
583 | #undef OFF |
584 | ||
585 | #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f)) | |
586 | const field_t bnobt_key_flds[] = { | |
587 | { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA }, | |
588 | { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE }, | |
589 | { NULL } | |
590 | }; | |
591 | #undef KOFF | |
592 | ||
593 | #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f)) | |
594 | const field_t bnobt_rec_flds[] = { | |
595 | { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA }, | |
596 | { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE }, | |
597 | { NULL } | |
598 | }; | |
599 | #undef ROFF | |
600 | ||
601 | const field_t cntbt_hfld[] = { | |
602 | { "", FLDT_CNTBT, OI(0), C1, 0, TYP_NONE }, | |
603 | { NULL } | |
604 | }; | |
605 | ||
c2907bd7 DC |
606 | const field_t cntbt_crc_hfld[] = { |
607 | { "", FLDT_CNTBT_CRC, OI(0), C1, 0, TYP_NONE }, | |
608 | { NULL } | |
609 | }; | |
610 | ||
b3563c19 | 611 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) |
49b31417 BN |
612 | const field_t cntbt_flds[] = { |
613 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
614 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
615 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
b3563c19 BN |
616 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT }, |
617 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT }, | |
49b31417 BN |
618 | { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count, |
619 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
620 | { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count, | |
621 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
622 | { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count, | |
623 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT }, | |
624 | { NULL } | |
625 | }; | |
c2907bd7 DC |
626 | const field_t cntbt_crc_flds[] = { |
627 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
628 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
629 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
630 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_CNTBT }, | |
631 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_CNTBT }, | |
632 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_CNTBT }, | |
633 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
634 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
635 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
0522f1cc | 636 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, |
c2907bd7 DC |
637 | { "recs", FLDT_CNTBTREC, btblock_rec_offset, btblock_rec_count, |
638 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
639 | { "keys", FLDT_CNTBTKEY, btblock_key_offset, btblock_key_count, | |
640 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
641 | { "ptrs", FLDT_CNTBTPTR, btblock_ptr_offset, btblock_key_count, | |
642 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_CNTBT }, | |
643 | { NULL } | |
644 | }; | |
49b31417 BN |
645 | #undef OFF |
646 | ||
647 | #define KOFF(f) bitize(offsetof(xfs_alloc_key_t, ar_ ## f)) | |
648 | const field_t cntbt_key_flds[] = { | |
649 | { "blockcount", FLDT_EXTLEN, OI(KOFF(blockcount)), C1, 0, TYP_NONE }, | |
650 | { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA }, | |
651 | { NULL } | |
652 | }; | |
653 | #undef KOFF | |
654 | ||
655 | #define ROFF(f) bitize(offsetof(xfs_alloc_rec_t, ar_ ## f)) | |
656 | const field_t cntbt_rec_flds[] = { | |
657 | { "startblock", FLDT_AGBLOCK, OI(ROFF(startblock)), C1, 0, TYP_DATA }, | |
658 | { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE }, | |
659 | { NULL } | |
660 | }; | |
661 | #undef ROFF | |
a9d7b986 DW |
662 | |
663 | /* RMAP btree blocks */ | |
664 | const field_t rmapbt_crc_hfld[] = { | |
665 | { "", FLDT_RMAPBT_CRC, OI(0), C1, 0, TYP_NONE }, | |
666 | { NULL } | |
667 | }; | |
668 | ||
669 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) | |
670 | const field_t rmapbt_crc_flds[] = { | |
671 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
672 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
673 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
674 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_RMAPBT }, | |
675 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_RMAPBT }, | |
676 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_RMAPBT }, | |
677 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
678 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
679 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
680 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, | |
681 | { "recs", FLDT_RMAPBTREC, btblock_rec_offset, btblock_rec_count, | |
682 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
683 | { "keys", FLDT_RMAPBTKEY, btblock_key_offset, btblock_key_count, | |
684 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
685 | { "ptrs", FLDT_RMAPBTPTR, btblock_ptr_offset, btblock_key_count, | |
686 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_RMAPBT }, | |
687 | { NULL } | |
688 | }; | |
689 | #undef OFF | |
690 | ||
691 | #define KOFF(f) bitize(offsetof(struct xfs_rmap_key, rm_ ## f)) | |
692 | ||
693 | #define RMAPBK_STARTBLOCK_BITOFF 0 | |
694 | #define RMAPBK_OWNER_BITOFF (RMAPBK_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN) | |
695 | #define RMAPBK_ATTRFLAG_BITOFF (RMAPBK_OWNER_BITOFF + RMAPBT_OWNER_BITLEN) | |
696 | #define RMAPBK_BMBTFLAG_BITOFF (RMAPBK_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN) | |
697 | #define RMAPBK_EXNTFLAG_BITOFF (RMAPBK_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN) | |
698 | #define RMAPBK_UNUSED_OFFSET_BITOFF (RMAPBK_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN) | |
699 | #define RMAPBK_OFFSET_BITOFF (RMAPBK_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN) | |
700 | ||
701 | #define HI_KOFF(f) bitize(sizeof(struct xfs_rmap_key) + offsetof(struct xfs_rmap_key, rm_ ## f)) | |
702 | ||
703 | #define RMAPBK_STARTBLOCKHI_BITOFF (bitize(sizeof(struct xfs_rmap_key))) | |
704 | #define RMAPBK_OWNERHI_BITOFF (RMAPBK_STARTBLOCKHI_BITOFF + RMAPBT_STARTBLOCK_BITLEN) | |
705 | #define RMAPBK_ATTRFLAGHI_BITOFF (RMAPBK_OWNERHI_BITOFF + RMAPBT_OWNER_BITLEN) | |
706 | #define RMAPBK_BMBTFLAGHI_BITOFF (RMAPBK_ATTRFLAGHI_BITOFF + RMAPBT_ATTRFLAG_BITLEN) | |
707 | #define RMAPBK_EXNTFLAGHI_BITOFF (RMAPBK_BMBTFLAGHI_BITOFF + RMAPBT_BMBTFLAG_BITLEN) | |
708 | #define RMAPBK_UNUSED_OFFSETHI_BITOFF (RMAPBK_EXNTFLAGHI_BITOFF + RMAPBT_EXNTFLAG_BITLEN) | |
709 | #define RMAPBK_OFFSETHI_BITOFF (RMAPBK_UNUSED_OFFSETHI_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN) | |
710 | ||
711 | const field_t rmapbt_key_flds[] = { | |
712 | { "startblock", FLDT_AGBLOCK, OI(KOFF(startblock)), C1, 0, TYP_DATA }, | |
713 | { "owner", FLDT_INT64D, OI(KOFF(owner)), C1, 0, TYP_NONE }, | |
714 | { "offset", FLDT_RFILEOFFD, OI(RMAPBK_OFFSET_BITOFF), C1, 0, TYP_NONE }, | |
715 | { "attrfork", FLDT_RATTRFORKFLG, OI(RMAPBK_ATTRFLAG_BITOFF), C1, 0, | |
716 | TYP_NONE }, | |
717 | { "bmbtblock", FLDT_RBMBTFLG, OI(RMAPBK_BMBTFLAG_BITOFF), C1, 0, | |
718 | TYP_NONE }, | |
719 | { "startblock_hi", FLDT_AGBLOCK, OI(HI_KOFF(startblock)), C1, 0, TYP_DATA }, | |
720 | { "owner_hi", FLDT_INT64D, OI(HI_KOFF(owner)), C1, 0, TYP_NONE }, | |
721 | { "offset_hi", FLDT_RFILEOFFD, OI(RMAPBK_OFFSETHI_BITOFF), C1, 0, TYP_NONE }, | |
722 | { "attrfork_hi", FLDT_RATTRFORKFLG, OI(RMAPBK_ATTRFLAGHI_BITOFF), C1, 0, | |
723 | TYP_NONE }, | |
724 | { "bmbtblock_hi", FLDT_RBMBTFLG, OI(RMAPBK_BMBTFLAGHI_BITOFF), C1, 0, | |
725 | TYP_NONE }, | |
726 | { NULL } | |
727 | }; | |
728 | #undef HI_KOFF | |
729 | #undef KOFF | |
730 | ||
731 | #define ROFF(f) bitize(offsetof(struct xfs_rmap_rec, rm_ ## f)) | |
732 | ||
733 | #define RMAPBT_STARTBLOCK_BITOFF 0 | |
734 | #define RMAPBT_BLOCKCOUNT_BITOFF (RMAPBT_STARTBLOCK_BITOFF + RMAPBT_STARTBLOCK_BITLEN) | |
735 | #define RMAPBT_OWNER_BITOFF (RMAPBT_BLOCKCOUNT_BITOFF + RMAPBT_BLOCKCOUNT_BITLEN) | |
736 | #define RMAPBT_ATTRFLAG_BITOFF (RMAPBT_OWNER_BITOFF + RMAPBT_OWNER_BITLEN) | |
737 | #define RMAPBT_BMBTFLAG_BITOFF (RMAPBT_ATTRFLAG_BITOFF + RMAPBT_ATTRFLAG_BITLEN) | |
738 | #define RMAPBT_EXNTFLAG_BITOFF (RMAPBT_BMBTFLAG_BITOFF + RMAPBT_BMBTFLAG_BITLEN) | |
739 | #define RMAPBT_UNUSED_OFFSET_BITOFF (RMAPBT_EXNTFLAG_BITOFF + RMAPBT_EXNTFLAG_BITLEN) | |
740 | #define RMAPBT_OFFSET_BITOFF (RMAPBT_UNUSED_OFFSET_BITOFF + RMAPBT_UNUSED_OFFSET_BITLEN) | |
741 | ||
742 | const field_t rmapbt_rec_flds[] = { | |
743 | { "startblock", FLDT_AGBLOCK, OI(RMAPBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA }, | |
744 | { "blockcount", FLDT_REXTLEN, OI(RMAPBT_BLOCKCOUNT_BITOFF), C1, 0, TYP_NONE }, | |
745 | { "owner", FLDT_INT64D, OI(RMAPBT_OWNER_BITOFF), C1, 0, TYP_NONE }, | |
746 | { "offset", FLDT_RFILEOFFD, OI(RMAPBT_OFFSET_BITOFF), C1, 0, TYP_NONE }, | |
747 | { "extentflag", FLDT_REXTFLG, OI(RMAPBT_EXNTFLAG_BITOFF), C1, 0, | |
748 | TYP_NONE }, | |
749 | { "attrfork", FLDT_RATTRFORKFLG, OI(RMAPBT_ATTRFLAG_BITOFF), C1, 0, | |
750 | TYP_NONE }, | |
751 | { "bmbtblock", FLDT_RBMBTFLG, OI(RMAPBT_BMBTFLAG_BITOFF), C1, 0, | |
752 | TYP_NONE }, | |
753 | { NULL } | |
754 | }; | |
755 | #undef ROFF | |
9fb2cb27 DW |
756 | |
757 | /* refcount btree blocks */ | |
758 | const field_t refcbt_crc_hfld[] = { | |
759 | { "", FLDT_REFCBT_CRC, OI(0), C1, 0, TYP_NONE }, | |
760 | { NULL } | |
761 | }; | |
762 | ||
763 | #define OFF(f) bitize(offsetof(struct xfs_btree_block, bb_ ## f)) | |
764 | const field_t refcbt_crc_flds[] = { | |
765 | { "magic", FLDT_UINT32X, OI(OFF(magic)), C1, 0, TYP_NONE }, | |
766 | { "level", FLDT_UINT16D, OI(OFF(level)), C1, 0, TYP_NONE }, | |
767 | { "numrecs", FLDT_UINT16D, OI(OFF(numrecs)), C1, 0, TYP_NONE }, | |
768 | { "leftsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_leftsib)), C1, 0, TYP_REFCBT }, | |
769 | { "rightsib", FLDT_AGBLOCK, OI(OFF(u.s.bb_rightsib)), C1, 0, TYP_REFCBT }, | |
770 | { "bno", FLDT_DFSBNO, OI(OFF(u.s.bb_blkno)), C1, 0, TYP_REFCBT }, | |
771 | { "lsn", FLDT_UINT64X, OI(OFF(u.s.bb_lsn)), C1, 0, TYP_NONE }, | |
772 | { "uuid", FLDT_UUID, OI(OFF(u.s.bb_uuid)), C1, 0, TYP_NONE }, | |
773 | { "owner", FLDT_AGNUMBER, OI(OFF(u.s.bb_owner)), C1, 0, TYP_NONE }, | |
774 | { "crc", FLDT_CRC, OI(OFF(u.s.bb_crc)), C1, 0, TYP_NONE }, | |
775 | { "recs", FLDT_REFCBTREC, btblock_rec_offset, btblock_rec_count, | |
776 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
777 | { "keys", FLDT_REFCBTKEY, btblock_key_offset, btblock_key_count, | |
778 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_NONE }, | |
779 | { "ptrs", FLDT_REFCBTPTR, btblock_ptr_offset, btblock_key_count, | |
780 | FLD_ARRAY|FLD_ABASE1|FLD_COUNT|FLD_OFFSET, TYP_REFCBT }, | |
781 | { NULL } | |
782 | }; | |
783 | #undef OFF | |
784 | ||
785 | #define REFCNTBT_COWFLAG_BITOFF 0 | |
786 | #define REFCNTBT_STARTBLOCK_BITOFF (REFCNTBT_COWFLAG_BITOFF + REFCNTBT_COWFLAG_BITLEN) | |
787 | ||
788 | #define KOFF(f) bitize(offsetof(struct xfs_refcount_key, rc_ ## f)) | |
789 | const field_t refcbt_key_flds[] = { | |
790 | { "startblock", FLDT_CAGBLOCK, OI(REFCNTBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA }, | |
791 | { "cowflag", FLDT_CCOWFLG, OI(REFCNTBT_COWFLAG_BITOFF), C1, 0, TYP_DATA }, | |
792 | { NULL } | |
793 | }; | |
794 | #undef KOFF | |
795 | ||
796 | #define ROFF(f) bitize(offsetof(struct xfs_refcount_rec, rc_ ## f)) | |
797 | const field_t refcbt_rec_flds[] = { | |
798 | { "startblock", FLDT_CAGBLOCK, OI(REFCNTBT_STARTBLOCK_BITOFF), C1, 0, TYP_DATA }, | |
799 | { "blockcount", FLDT_EXTLEN, OI(ROFF(blockcount)), C1, 0, TYP_NONE }, | |
800 | { "refcount", FLDT_UINT32D, OI(ROFF(refcount)), C1, 0, TYP_DATA }, | |
801 | { "cowflag", FLDT_CCOWFLG, OI(REFCNTBT_COWFLAG_BITOFF), C1, 0, TYP_DATA }, | |
802 | { NULL } | |
803 | }; | |
804 | #undef ROFF |