?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / fs / xfs / xfs_btree.c
blob9dd22dd95487d82343d40265f1874adfa2c03fc5
1 /*
2 * Copyright (c) 2000-2002 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 /*
34 * This file contains common code for the space manager's btree implementations.
35 */
36
37 #include "xfs.h"
38
39 #include "xfs_macros.h"
40 #include "xfs_types.h"
41 #include "xfs_inum.h"
42 #include "xfs_log.h"
43 #include "xfs_trans.h"
44 #include "xfs_sb.h"
45 #include "xfs_ag.h"
46 #include "xfs_dir.h"
47 #include "xfs_dir2.h"
48 #include "xfs_dmapi.h"
49 #include "xfs_mount.h"
50 #include "xfs_alloc_btree.h"
51 #include "xfs_bmap_btree.h"
52 #include "xfs_ialloc_btree.h"
53 #include "xfs_btree.h"
54 #include "xfs_ialloc.h"
55 #include "xfs_attr_sf.h"
56 #include "xfs_dir_sf.h"
57 #include "xfs_dir2_sf.h"
58 #include "xfs_dinode.h"
59 #include "xfs_inode.h"
60 #include "xfs_bit.h"
61 #include "xfs_error.h"
62
63 /*
64 * Cursor allocation zone.
65 */
66 kmem_zone_t *xfs_btree_cur_zone;
67
68 /*
69 * Btree magic numbers.
70 */
71 const __uint32_t xfs_magics[XFS_BTNUM_MAX] =
72 {
73 XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, XFS_BMAP_MAGIC, XFS_IBT_MAGIC
74 };
75
76 /*
77 * Prototypes for internal routines.
78 */
79
80 /*
81 * Checking routine: return maxrecs for the block.
82 */
83 STATIC int /* number of records fitting in block */
84 xfs_btree_maxrecs(
85 xfs_btree_cur_t *cur, /* btree cursor */
86 xfs_btree_block_t *block);/* generic btree block pointer */
87
88 /*
89 * Internal routines.
90 */
91
92 /*
93 * Checking routine: return maxrecs for the block.
94 */
95 STATIC int /* number of records fitting in block */
96 xfs_btree_maxrecs(
97 xfs_btree_cur_t *cur, /* btree cursor */
98 xfs_btree_block_t *block) /* generic btree block pointer */
99 {
100 switch (cur->bc_btnum) {
101 case XFS_BTNUM_BNO:
102 case XFS_BTNUM_CNT:
103 return (int)XFS_ALLOC_BLOCK_MAXRECS(INT_GET(block->bb_h.bb_level, ARCH_CONVERT), cur);
104 case XFS_BTNUM_BMAP:
105 return (int)XFS_BMAP_BLOCK_IMAXRECS(INT_GET(block->bb_h.bb_level, ARCH_CONVERT), cur);
106 case XFS_BTNUM_INO:
107 return (int)XFS_INOBT_BLOCK_MAXRECS(INT_GET(block->bb_h.bb_level, ARCH_CONVERT), cur);
108 default:
109 ASSERT(0);
110 return 0;
111 }
112 }
113
114 /*
115 * External routines.
116 */
117
118 #ifdef DEBUG
119 /*
120 * Debug routine: check that block header is ok.
121 */
122 void
123 xfs_btree_check_block(
124 xfs_btree_cur_t *cur, /* btree cursor */
125 xfs_btree_block_t *block, /* generic btree block pointer */
126 int level, /* level of the btree block */
127 xfs_buf_t *bp) /* buffer containing block, if any */
128 {
129 if (XFS_BTREE_LONG_PTRS(cur->bc_btnum))
130 xfs_btree_check_lblock(cur, (xfs_btree_lblock_t *)block, level,
131 bp);
132 else
133 xfs_btree_check_sblock(cur, (xfs_btree_sblock_t *)block, level,
134 bp);
135 }
136
137 /*
138 * Debug routine: check that keys are in the right order.
139 */
140 void
141 xfs_btree_check_key(
142 xfs_btnum_t btnum, /* btree identifier */
143 void *ak1, /* pointer to left (lower) key */
144 void *ak2) /* pointer to right (higher) key */
145 {
146 switch (btnum) {
147 case XFS_BTNUM_BNO: {
148 xfs_alloc_key_t *k1;
149 xfs_alloc_key_t *k2;
150
151 k1 = ak1;
152 k2 = ak2;
153 ASSERT(INT_GET(k1->ar_startblock, ARCH_CONVERT) < INT_GET(k2->ar_startblock, ARCH_CONVERT));
154 break;
155 }
156 case XFS_BTNUM_CNT: {
157 xfs_alloc_key_t *k1;
158 xfs_alloc_key_t *k2;
159
160 k1 = ak1;
161 k2 = ak2;
162 ASSERT(INT_GET(k1->ar_blockcount, ARCH_CONVERT) < INT_GET(k2->ar_blockcount, ARCH_CONVERT) ||
163 (INT_GET(k1->ar_blockcount, ARCH_CONVERT) == INT_GET(k2->ar_blockcount, ARCH_CONVERT) &&
164 INT_GET(k1->ar_startblock, ARCH_CONVERT) < INT_GET(k2->ar_startblock, ARCH_CONVERT)));
165 break;
166 }
167 case XFS_BTNUM_BMAP: {
168 xfs_bmbt_key_t *k1;
169 xfs_bmbt_key_t *k2;
170
171 k1 = ak1;
172 k2 = ak2;
173 ASSERT(INT_GET(k1->br_startoff, ARCH_CONVERT) < INT_GET(k2->br_startoff, ARCH_CONVERT));
174 break;
175 }
176 case XFS_BTNUM_INO: {
177 xfs_inobt_key_t *k1;
178 xfs_inobt_key_t *k2;
179
180 k1 = ak1;
181 k2 = ak2;
182 ASSERT(INT_GET(k1->ir_startino, ARCH_CONVERT) < INT_GET(k2->ir_startino, ARCH_CONVERT));
183 break;
184 }
185 default:
186 ASSERT(0);
187 }
188 }
189 #endif /* DEBUG */
190
191 /*
192 * Checking routine: check that long form block header is ok.
193 */
194 /* ARGSUSED */
195 int /* error (0 or EFSCORRUPTED) */
196 xfs_btree_check_lblock(
197 xfs_btree_cur_t *cur, /* btree cursor */
198 xfs_btree_lblock_t *block, /* btree long form block pointer */
199 int level, /* level of the btree block */
200 xfs_buf_t *bp) /* buffer for block, if any */
201 {
202 int lblock_ok; /* block passes checks */
203 xfs_mount_t *mp; /* file system mount point */
204
205 mp = cur->bc_mp;
206 lblock_ok =
207 INT_GET(block->bb_magic, ARCH_CONVERT) == xfs_magics[cur->bc_btnum] &&
208 INT_GET(block->bb_level, ARCH_CONVERT) == level &&
209 INT_GET(block->bb_numrecs, ARCH_CONVERT) <=
210 xfs_btree_maxrecs(cur, (xfs_btree_block_t *)block) &&
211 block->bb_leftsib &&
212 (INT_GET(block->bb_leftsib, ARCH_CONVERT) == NULLDFSBNO ||
213 XFS_FSB_SANITY_CHECK(mp, INT_GET(block->bb_leftsib, ARCH_CONVERT))) &&
214 block->bb_rightsib &&
215 (INT_GET(block->bb_rightsib, ARCH_CONVERT) == NULLDFSBNO ||
216 XFS_FSB_SANITY_CHECK(mp, INT_GET(block->bb_rightsib, ARCH_CONVERT)));
217 if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK,
218 XFS_RANDOM_BTREE_CHECK_LBLOCK))) {
219 if (bp)
220 xfs_buftrace("LBTREE ERROR", bp);
221 XFS_ERROR_REPORT("xfs_btree_check_lblock", XFS_ERRLEVEL_LOW,
222 mp);
223 return XFS_ERROR(EFSCORRUPTED);
224 }
225 return 0;
226 }
227
228 /*
229 * Checking routine: check that (long) pointer is ok.
230 */
231 int /* error (0 or EFSCORRUPTED) */
232 xfs_btree_check_lptr(
233 xfs_btree_cur_t *cur, /* btree cursor */
234 xfs_dfsbno_t ptr, /* btree block disk address */
235 int level) /* btree block level */
236 {
237 xfs_mount_t *mp; /* file system mount point */
238
239 mp = cur->bc_mp;
240 XFS_WANT_CORRUPTED_RETURN(
241 level > 0 &&
242 ptr != NULLDFSBNO &&
243 XFS_FSB_SANITY_CHECK(mp, ptr));
244 return 0;
245 }
246
247 #ifdef DEBUG
248 /*
249 * Debug routine: check that records are in the right order.
250 */
251 void
252 xfs_btree_check_rec(
253 xfs_btnum_t btnum, /* btree identifier */
254 void *ar1, /* pointer to left (lower) record */
255 void *ar2) /* pointer to right (higher) record */
256 {
257 switch (btnum) {
258 case XFS_BTNUM_BNO: {
259 xfs_alloc_rec_t *r1;
260 xfs_alloc_rec_t *r2;
261
262 r1 = ar1;
263 r2 = ar2;
264 ASSERT(INT_GET(r1->ar_startblock, ARCH_CONVERT) + INT_GET(r1->ar_blockcount, ARCH_CONVERT) <=
265 INT_GET(r2->ar_startblock, ARCH_CONVERT));
266 break;
267 }
268 case XFS_BTNUM_CNT: {
269 xfs_alloc_rec_t *r1;
270 xfs_alloc_rec_t *r2;
271
272 r1 = ar1;
273 r2 = ar2;
274 ASSERT(INT_GET(r1->ar_blockcount, ARCH_CONVERT) < INT_GET(r2->ar_blockcount, ARCH_CONVERT) ||
275 (INT_GET(r1->ar_blockcount, ARCH_CONVERT) == INT_GET(r2->ar_blockcount, ARCH_CONVERT) &&
276 INT_GET(r1->ar_startblock, ARCH_CONVERT) < INT_GET(r2->ar_startblock, ARCH_CONVERT)));
277 break;
278 }
279 case XFS_BTNUM_BMAP: {
280 xfs_bmbt_rec_t *r1;
281 xfs_bmbt_rec_t *r2;
282
283 r1 = ar1;
284 r2 = ar2;
285 ASSERT(xfs_bmbt_disk_get_startoff(r1) +
286 xfs_bmbt_disk_get_blockcount(r1) <=
287 xfs_bmbt_disk_get_startoff(r2));
288 break;
289 }
290 case XFS_BTNUM_INO: {
291 xfs_inobt_rec_t *r1;
292 xfs_inobt_rec_t *r2;
293
294 r1 = ar1;
295 r2 = ar2;
296 ASSERT(INT_GET(r1->ir_startino, ARCH_CONVERT) + XFS_INODES_PER_CHUNK <=
297 INT_GET(r2->ir_startino, ARCH_CONVERT));
298 break;
299 }
300 default:
301 ASSERT(0);
302 }
303 }
304 #endif /* DEBUG */
305
306 /*
307 * Checking routine: check that block header is ok.
308 */
309 /* ARGSUSED */
310 int /* error (0 or EFSCORRUPTED) */
311 xfs_btree_check_sblock(
312 xfs_btree_cur_t *cur, /* btree cursor */
313 xfs_btree_sblock_t *block, /* btree short form block pointer */
314 int level, /* level of the btree block */
315 xfs_buf_t *bp) /* buffer containing block */
316 {
317 xfs_buf_t *agbp; /* buffer for ag. freespace struct */
318 xfs_agf_t *agf; /* ag. freespace structure */
319 xfs_agblock_t agflen; /* native ag. freespace length */
320 int sblock_ok; /* block passes checks */
321
322 agbp = cur->bc_private.a.agbp;
323 agf = XFS_BUF_TO_AGF(agbp);
324 agflen = INT_GET(agf->agf_length, ARCH_CONVERT);
325 sblock_ok =
326 INT_GET(block->bb_magic, ARCH_CONVERT) == xfs_magics[cur->bc_btnum] &&
327 INT_GET(block->bb_level, ARCH_CONVERT) == level &&
328 INT_GET(block->bb_numrecs, ARCH_CONVERT) <=
329 xfs_btree_maxrecs(cur, (xfs_btree_block_t *)block) &&
330 (INT_GET(block->bb_leftsib, ARCH_CONVERT) == NULLAGBLOCK ||
331 INT_GET(block->bb_leftsib, ARCH_CONVERT) < agflen) &&
332 block->bb_leftsib &&
333 (INT_GET(block->bb_rightsib, ARCH_CONVERT) == NULLAGBLOCK ||
334 INT_GET(block->bb_rightsib, ARCH_CONVERT) < agflen) &&
335 block->bb_rightsib;
336 if (unlikely(XFS_TEST_ERROR(!sblock_ok, cur->bc_mp,
337 XFS_ERRTAG_BTREE_CHECK_SBLOCK,
338 XFS_RANDOM_BTREE_CHECK_SBLOCK))) {
339 if (bp)
340 xfs_buftrace("SBTREE ERROR", bp);
341 XFS_ERROR_REPORT("xfs_btree_check_sblock", XFS_ERRLEVEL_LOW,
342 cur->bc_mp);
343 return XFS_ERROR(EFSCORRUPTED);
344 }
345 return 0;
346 }
347
348 /*
349 * Checking routine: check that (short) pointer is ok.
350 */
351 int /* error (0 or EFSCORRUPTED) */
352 xfs_btree_check_sptr(
353 xfs_btree_cur_t *cur, /* btree cursor */
354 xfs_agblock_t ptr, /* btree block disk address */
355 int level) /* btree block level */
356 {
357 xfs_buf_t *agbp; /* buffer for ag. freespace struct */
358 xfs_agf_t *agf; /* ag. freespace structure */
359
360 agbp = cur->bc_private.a.agbp;
361 agf = XFS_BUF_TO_AGF(agbp);
362 XFS_WANT_CORRUPTED_RETURN(
363 level > 0 &&
364 ptr != NULLAGBLOCK && ptr != 0 &&
365 ptr < INT_GET(agf->agf_length, ARCH_CONVERT));
366 return 0;
367 }
368
369 /*
370 * Delete the btree cursor.
371 */
372 void
373 xfs_btree_del_cursor(
374 xfs_btree_cur_t *cur, /* btree cursor */
375 int error) /* del because of error */
376 {
377 int i; /* btree level */
378
379 /*
380 * Clear the buffer pointers, and release the buffers.
381 * If we're doing this in the face of an error, we
382 * need to make sure to inspect all of the entries
383 * in the bc_bufs array for buffers to be unlocked.
384 * This is because some of the btree code works from
385 * level n down to 0, and if we get an error along
386 * the way we won't have initialized all the entries
387 * down to 0.
388 */
389 for (i = 0; i < cur->bc_nlevels; i++) {
390 if (cur->bc_bufs[i])
391 xfs_btree_setbuf(cur, i, NULL);
392 else if (!error)
393 break;
394 }
395 /*
396 * Can't free a bmap cursor without having dealt with the
397 * allocated indirect blocks' accounting.
398 */
399 ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP ||
400 cur->bc_private.b.allocated == 0);
401 /*
402 * Free the cursor.
403 */
404 kmem_zone_free(xfs_btree_cur_zone, cur);
405 }
406
407 /*
408 * Duplicate the btree cursor.
409 * Allocate a new one, copy the record, re-get the buffers.
410 */
411 int /* error */
412 xfs_btree_dup_cursor(
413 xfs_btree_cur_t *cur, /* input cursor */
414 xfs_btree_cur_t **ncur) /* output cursor */
415 {
416 xfs_buf_t *bp; /* btree block's buffer pointer */
417 int error; /* error return value */
418 int i; /* level number of btree block */
419 xfs_mount_t *mp; /* mount structure for filesystem */
420 xfs_btree_cur_t *new; /* new cursor value */
421 xfs_trans_t *tp; /* transaction pointer, can be NULL */
422
423 tp = cur->bc_tp;
424 mp = cur->bc_mp;
425 /*
426 * Allocate a new cursor like the old one.
427 */
428 new = xfs_btree_init_cursor(mp, tp, cur->bc_private.a.agbp,
429 cur->bc_private.a.agno, cur->bc_btnum, cur->bc_private.b.ip,
430 cur->bc_private.b.whichfork);
431 /*
432 * Copy the record currently in the cursor.
433 */
434 new->bc_rec = cur->bc_rec;
435 /*
436 * For each level current, re-get the buffer and copy the ptr value.
437 */
438 for (i = 0; i < new->bc_nlevels; i++) {
439 new->bc_ptrs[i] = cur->bc_ptrs[i];
440 new->bc_ra[i] = cur->bc_ra[i];
441 if ((bp = cur->bc_bufs[i])) {
442 if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
443 XFS_BUF_ADDR(bp), mp->m_bsize, 0, &bp))) {
444 xfs_btree_del_cursor(new, error);
445 *ncur = NULL;
446 return error;
447 }
448 new->bc_bufs[i] = bp;
449 ASSERT(bp);
450 ASSERT(!XFS_BUF_GETERROR(bp));
451 } else
452 new->bc_bufs[i] = NULL;
453 }
454 /*
455 * For bmap btrees, copy the firstblock, flist, and flags values,
456 * since init cursor doesn't get them.
457 */
458 if (new->bc_btnum == XFS_BTNUM_BMAP) {
459 new->bc_private.b.firstblock = cur->bc_private.b.firstblock;
460 new->bc_private.b.flist = cur->bc_private.b.flist;
461 new->bc_private.b.flags = cur->bc_private.b.flags;
462 }
463 *ncur = new;
464 return 0;
465 }
466
467 /*
468 * Change the cursor to point to the first record at the given level.
469 * Other levels are unaffected.
470 */
471 int /* success=1, failure=0 */
472 xfs_btree_firstrec(
473 xfs_btree_cur_t *cur, /* btree cursor */
474 int level) /* level to change */
475 {
476 xfs_btree_block_t *block; /* generic btree block pointer */
477 xfs_buf_t *bp; /* buffer containing block */
478
479 /*
480 * Get the block pointer for this level.
481 */
482 block = xfs_btree_get_block(cur, level, &bp);
483 xfs_btree_check_block(cur, block, level, bp);
484 /*
485 * It's empty, there is no such record.
486 */
487 if (!block->bb_h.bb_numrecs)
488 return 0;
489 /*
490 * Set the ptr value to 1, that's the first record/key.
491 */
492 cur->bc_ptrs[level] = 1;
493 return 1;
494 }
495
496 /*
497 * Retrieve the block pointer from the cursor at the given level.
498 * This may be a bmap btree root or from a buffer.
499 */
500 xfs_btree_block_t * /* generic btree block pointer */
501 xfs_btree_get_block(
502 xfs_btree_cur_t *cur, /* btree cursor */
503 int level, /* level in btree */
504 xfs_buf_t **bpp) /* buffer containing the block */
505 {
506 xfs_btree_block_t *block; /* return value */
507 xfs_buf_t *bp; /* return buffer */
508 xfs_ifork_t *ifp; /* inode fork pointer */
509 int whichfork; /* data or attr fork */
510
511 if (cur->bc_btnum == XFS_BTNUM_BMAP && level == cur->bc_nlevels - 1) {
512 whichfork = cur->bc_private.b.whichfork;
513 ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, whichfork);
514 block = (xfs_btree_block_t *)ifp->if_broot;
515 bp = NULL;
516 } else {
517 bp = cur->bc_bufs[level];
518 block = XFS_BUF_TO_BLOCK(bp);
519 }
520 ASSERT(block != NULL);
521 *bpp = bp;
522 return block;
523 }
524
525 /*
526 * Get a buffer for the block, return it with no data read.
527 * Long-form addressing.
528 */
529 xfs_buf_t * /* buffer for fsbno */
530 xfs_btree_get_bufl(
531 xfs_mount_t *mp, /* file system mount point */
532 xfs_trans_t *tp, /* transaction pointer */
533 xfs_fsblock_t fsbno, /* file system block number */
534 uint lock) /* lock flags for get_buf */
535 {
536 xfs_buf_t *bp; /* buffer pointer (return value) */
537 xfs_daddr_t d; /* real disk block address */
538
539 ASSERT(fsbno != NULLFSBLOCK);
540 d = XFS_FSB_TO_DADDR(mp, fsbno);
541 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
542 ASSERT(bp);
543 ASSERT(!XFS_BUF_GETERROR(bp));
544 return bp;
545 }
546
547 /*
548 * Get a buffer for the block, return it with no data read.
549 * Short-form addressing.
550 */
551 xfs_buf_t * /* buffer for agno/agbno */
552 xfs_btree_get_bufs(
553 xfs_mount_t *mp, /* file system mount point */
554 xfs_trans_t *tp, /* transaction pointer */
555 xfs_agnumber_t agno, /* allocation group number */
556 xfs_agblock_t agbno, /* allocation group block number */
557 uint lock) /* lock flags for get_buf */
558 {
559 xfs_buf_t *bp; /* buffer pointer (return value) */
560 xfs_daddr_t d; /* real disk block address */
561
562 ASSERT(agno != NULLAGNUMBER);
563 ASSERT(agbno != NULLAGBLOCK);
564 d = XFS_AGB_TO_DADDR(mp, agno, agbno);
565 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
566 ASSERT(bp);
567 ASSERT(!XFS_BUF_GETERROR(bp));
568 return bp;
569 }
570
571 /*
572 * Allocate a new btree cursor.
573 * The cursor is either for allocation (A) or bmap (B) or inodes (I).
574 */
575 xfs_btree_cur_t * /* new btree cursor */
576 xfs_btree_init_cursor(
577 xfs_mount_t *mp, /* file system mount point */
578 xfs_trans_t *tp, /* transaction pointer */
579 xfs_buf_t *agbp, /* (A only) buffer for agf structure */
580 /* (I only) buffer for agi structure */
581 xfs_agnumber_t agno, /* (AI only) allocation group number */
582 xfs_btnum_t btnum, /* btree identifier */
583 xfs_inode_t *ip, /* (B only) inode owning the btree */
584 int whichfork) /* (B only) data or attr fork */
585 {
586 xfs_agf_t *agf; /* (A) allocation group freespace */
587 xfs_agi_t *agi; /* (I) allocation group inodespace */
588 xfs_btree_cur_t *cur; /* return value */
589 xfs_ifork_t *ifp; /* (I) inode fork pointer */
590 int nlevels=0; /* number of levels in the btree */
591
592 ASSERT(xfs_btree_cur_zone != NULL);
593 /*
594 * Allocate a new cursor.
595 */
596 cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
597 /*
598 * Deduce the number of btree levels from the arguments.
599 */
600 switch (btnum) {
601 case XFS_BTNUM_BNO:
602 case XFS_BTNUM_CNT:
603 agf = XFS_BUF_TO_AGF(agbp);
604 nlevels = INT_GET(agf->agf_levels[btnum], ARCH_CONVERT);
605 break;
606 case XFS_BTNUM_BMAP:
607 ifp = XFS_IFORK_PTR(ip, whichfork);
608 nlevels = INT_GET(ifp->if_broot->bb_level, ARCH_CONVERT) + 1;
609 break;
610 case XFS_BTNUM_INO:
611 agi = XFS_BUF_TO_AGI(agbp);
612 nlevels = INT_GET(agi->agi_level, ARCH_CONVERT);
613 break;
614 default:
615 ASSERT(0);
616 }
617 /*
618 * Fill in the common fields.
619 */
620 cur->bc_tp = tp;
621 cur->bc_mp = mp;
622 cur->bc_nlevels = nlevels;
623 cur->bc_btnum = btnum;
624 cur->bc_blocklog = mp->m_sb.sb_blocklog;
625 /*
626 * Fill in private fields.
627 */
628 switch (btnum) {
629 case XFS_BTNUM_BNO:
630 case XFS_BTNUM_CNT:
631 /*
632 * Allocation btree fields.
633 */
634 cur->bc_private.a.agbp = agbp;
635 cur->bc_private.a.agno = agno;
636 break;
637 case XFS_BTNUM_BMAP:
638 /*
639 * Bmap btree fields.
640 */
641 cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork);
642 cur->bc_private.b.ip = ip;
643 cur->bc_private.b.firstblock = NULLFSBLOCK;
644 cur->bc_private.b.flist = NULL;
645 cur->bc_private.b.allocated = 0;
646 cur->bc_private.b.flags = 0;
647 cur->bc_private.b.whichfork = whichfork;
648 break;
649 case XFS_BTNUM_INO:
650 /*
651 * Inode allocation btree fields.
652 */
653 cur->bc_private.i.agbp = agbp;
654 cur->bc_private.i.agno = agno;
655 break;
656 default:
657 ASSERT(0);
658 }
659 return cur;
660 }
661
662 /*
663 * Check for the cursor referring to the last block at the given level.
664 */
665 int /* 1=is last block, 0=not last block */
666 xfs_btree_islastblock(
667 xfs_btree_cur_t *cur, /* btree cursor */
668 int level) /* level to check */
669 {
670 xfs_btree_block_t *block; /* generic btree block pointer */
671 xfs_buf_t *bp; /* buffer containing block */
672
673 block = xfs_btree_get_block(cur, level, &bp);
674 xfs_btree_check_block(cur, block, level, bp);
675 if (XFS_BTREE_LONG_PTRS(cur->bc_btnum))
676 return INT_GET(block->bb_u.l.bb_rightsib, ARCH_CONVERT) == NULLDFSBNO;
677 else
678 return INT_GET(block->bb_u.s.bb_rightsib, ARCH_CONVERT) == NULLAGBLOCK;
679 }
680
681 /*
682 * Change the cursor to point to the last record in the current block
683 * at the given level. Other levels are unaffected.
684 */
685 int /* success=1, failure=0 */
686 xfs_btree_lastrec(
687 xfs_btree_cur_t *cur, /* btree cursor */
688 int level) /* level to change */
689 {
690 xfs_btree_block_t *block; /* generic btree block pointer */
691 xfs_buf_t *bp; /* buffer containing block */
692
693 /*
694 * Get the block pointer for this level.
695 */
696 block = xfs_btree_get_block(cur, level, &bp);
697 xfs_btree_check_block(cur, block, level, bp);
698 /*
699 * It's empty, there is no such record.
700 */
701 if (!block->bb_h.bb_numrecs)
702 return 0;
703 /*
704 * Set the ptr value to numrecs, that's the last record/key.
705 */
706 cur->bc_ptrs[level] = INT_GET(block->bb_h.bb_numrecs, ARCH_CONVERT);
707 return 1;
708 }
709
710 /*
711 * Compute first and last byte offsets for the fields given.
712 * Interprets the offsets table, which contains struct field offsets.
713 */
714 void
715 xfs_btree_offsets(
716 __int64_t fields, /* bitmask of fields */
717 const short *offsets, /* table of field offsets */
718 int nbits, /* number of bits to inspect */
719 int *first, /* output: first byte offset */
720 int *last) /* output: last byte offset */
721 {
722 int i; /* current bit number */
723 __int64_t imask; /* mask for current bit number */
724
725 ASSERT(fields != 0);
726 /*
727 * Find the lowest bit, so the first byte offset.
728 */
729 for (i = 0, imask = 1LL; ; i++, imask <<= 1) {
730 if (imask & fields) {
731 *first = offsets[i];
732 break;
733 }
734 }
735 /*
736 * Find the highest bit, so the last byte offset.
737 */
738 for (i = nbits - 1, imask = 1LL << i; ; i--, imask >>= 1) {
739 if (imask & fields) {
740 *last = offsets[i + 1] - 1;
741 break;
742 }
743 }
744 }
745
746 /*
747 * Get a buffer for the block, return it read in.
748 * Long-form addressing.
749 */
750 int /* error */
751 xfs_btree_read_bufl(
752 xfs_mount_t *mp, /* file system mount point */
753 xfs_trans_t *tp, /* transaction pointer */
754 xfs_fsblock_t fsbno, /* file system block number */
755 uint lock, /* lock flags for read_buf */
756 xfs_buf_t **bpp, /* buffer for fsbno */
757 int refval) /* ref count value for buffer */
758 {
759 xfs_buf_t *bp; /* return value */
760 xfs_daddr_t d; /* real disk block address */
761 int error;
762
763 ASSERT(fsbno != NULLFSBLOCK);
764 d = XFS_FSB_TO_DADDR(mp, fsbno);
765 if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
766 mp->m_bsize, lock, &bp))) {
767 return error;
768 }
769 ASSERT(!bp || !XFS_BUF_GETERROR(bp));
770 if (bp != NULL) {
771 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
772 }
773 *bpp = bp;
774 return 0;
775 }
776
777 /*
778 * Get a buffer for the block, return it read in.
779 * Short-form addressing.
780 */
781 int /* error */
782 xfs_btree_read_bufs(
783 xfs_mount_t *mp, /* file system mount point */
784 xfs_trans_t *tp, /* transaction pointer */
785 xfs_agnumber_t agno, /* allocation group number */
786 xfs_agblock_t agbno, /* allocation group block number */
787 uint lock, /* lock flags for read_buf */
788 xfs_buf_t **bpp, /* buffer for agno/agbno */
789 int refval) /* ref count value for buffer */
790 {
791 xfs_buf_t *bp; /* return value */
792 xfs_daddr_t d; /* real disk block address */
793 int error;
794
795 ASSERT(agno != NULLAGNUMBER);
796 ASSERT(agbno != NULLAGBLOCK);
797 d = XFS_AGB_TO_DADDR(mp, agno, agbno);
798 if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
799 mp->m_bsize, lock, &bp))) {
800 return error;
801 }
802 ASSERT(!bp || !XFS_BUF_GETERROR(bp));
803 if (bp != NULL) {
804 switch (refval) {
805 case XFS_ALLOC_BTREE_REF:
806 XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
807 break;
808 case XFS_INO_BTREE_REF:
809 XFS_BUF_SET_VTYPE_REF(bp, B_FS_INOMAP, refval);
810 break;
811 }
812 }
813 *bpp = bp;
814 return 0;
815 }
816
817 /*
818 * Read-ahead the block, don't wait for it, don't return a buffer.
819 * Long-form addressing.
820 */
821 /* ARGSUSED */
822 void
823 xfs_btree_reada_bufl(
824 xfs_mount_t *mp, /* file system mount point */
825 xfs_fsblock_t fsbno, /* file system block number */
826 xfs_extlen_t count) /* count of filesystem blocks */
827 {
828 xfs_daddr_t d;
829
830 ASSERT(fsbno != NULLFSBLOCK);
831 d = XFS_FSB_TO_DADDR(mp, fsbno);
832 xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
833 }
834
835 /*
836 * Read-ahead the block, don't wait for it, don't return a buffer.
837 * Short-form addressing.
838 */
839 /* ARGSUSED */
840 void
841 xfs_btree_reada_bufs(
842 xfs_mount_t *mp, /* file system mount point */
843 xfs_agnumber_t agno, /* allocation group number */
844 xfs_agblock_t agbno, /* allocation group block number */
845 xfs_extlen_t count) /* count of filesystem blocks */
846 {
847 xfs_daddr_t d;
848
849 ASSERT(agno != NULLAGNUMBER);
850 ASSERT(agbno != NULLAGBLOCK);
851 d = XFS_AGB_TO_DADDR(mp, agno, agbno);
852 xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
853 }
854
855 /*
856 * Read-ahead btree blocks, at the given level.
857 * Bits in lr are set from XFS_BTCUR_{LEFT,RIGHT}RA.
858 */
859 int
860 xfs_btree_readahead_core(
861 xfs_btree_cur_t *cur, /* btree cursor */
862 int lev, /* level in btree */
863 int lr) /* left/right bits */
864 {
865 xfs_alloc_block_t *a;
866 xfs_bmbt_block_t *b;
867 xfs_inobt_block_t *i;
868 int rval = 0;
869
870 ASSERT(cur->bc_bufs[lev] != NULL);
871 cur->bc_ra[lev] |= lr;
872 switch (cur->bc_btnum) {
873 case XFS_BTNUM_BNO:
874 case XFS_BTNUM_CNT:
875 a = XFS_BUF_TO_ALLOC_BLOCK(cur->bc_bufs[lev]);
876 if ((lr & XFS_BTCUR_LEFTRA) && INT_GET(a->bb_leftsib, ARCH_CONVERT) != NULLAGBLOCK) {
877 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
878 INT_GET(a->bb_leftsib, ARCH_CONVERT), 1);
879 rval++;
880 }
881 if ((lr & XFS_BTCUR_RIGHTRA) && INT_GET(a->bb_rightsib, ARCH_CONVERT) != NULLAGBLOCK) {
882 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
883 INT_GET(a->bb_rightsib, ARCH_CONVERT), 1);
884 rval++;
885 }
886 break;
887 case XFS_BTNUM_BMAP:
888 b = XFS_BUF_TO_BMBT_BLOCK(cur->bc_bufs[lev]);
889 if ((lr & XFS_BTCUR_LEFTRA) && INT_GET(b->bb_leftsib, ARCH_CONVERT) != NULLDFSBNO) {
890 xfs_btree_reada_bufl(cur->bc_mp, INT_GET(b->bb_leftsib, ARCH_CONVERT), 1);
891 rval++;
892 }
893 if ((lr & XFS_BTCUR_RIGHTRA) && INT_GET(b->bb_rightsib, ARCH_CONVERT) != NULLDFSBNO) {
894 xfs_btree_reada_bufl(cur->bc_mp, INT_GET(b->bb_rightsib, ARCH_CONVERT), 1);
895 rval++;
896 }
897 break;
898 case XFS_BTNUM_INO:
899 i = XFS_BUF_TO_INOBT_BLOCK(cur->bc_bufs[lev]);
900 if ((lr & XFS_BTCUR_LEFTRA) && INT_GET(i->bb_leftsib, ARCH_CONVERT) != NULLAGBLOCK) {
901 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.i.agno,
902 INT_GET(i->bb_leftsib, ARCH_CONVERT), 1);
903 rval++;
904 }
905 if ((lr & XFS_BTCUR_RIGHTRA) && INT_GET(i->bb_rightsib, ARCH_CONVERT) != NULLAGBLOCK) {
906 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.i.agno,
907 INT_GET(i->bb_rightsib, ARCH_CONVERT), 1);
908 rval++;
909 }
910 break;
911 default:
912 ASSERT(0);
913 }
914 return rval;
915 }
916
917 /*
918 * Set the buffer for level "lev" in the cursor to bp, releasing
919 * any previous buffer.
920 */
921 void
922 xfs_btree_setbuf(
923 xfs_btree_cur_t *cur, /* btree cursor */
924 int lev, /* level in btree */
925 xfs_buf_t *bp) /* new buffer to set */
926 {
927 xfs_btree_block_t *b; /* btree block */
928 xfs_buf_t *obp; /* old buffer pointer */
929
930 obp = cur->bc_bufs[lev];
931 if (obp)
932 xfs_trans_brelse(cur->bc_tp, obp);
933 cur->bc_bufs[lev] = bp;
934 cur->bc_ra[lev] = 0;
935 if (!bp)
936 return;
937 b = XFS_BUF_TO_BLOCK(bp);
938 if (XFS_BTREE_LONG_PTRS(cur->bc_btnum)) {
939 if (INT_GET(b->bb_u.l.bb_leftsib, ARCH_CONVERT) == NULLDFSBNO)
940 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
941 if (INT_GET(b->bb_u.l.bb_rightsib, ARCH_CONVERT) == NULLDFSBNO)
942 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
943 } else {
944 if (INT_GET(b->bb_u.s.bb_leftsib, ARCH_CONVERT) == NULLAGBLOCK)
945 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
946 if (INT_GET(b->bb_u.s.bb_rightsib, ARCH_CONVERT) == NULLAGBLOCK)
947 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
948 }
949 }
Verdex Pro support