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