1 /* 2 * Copyright (c) 2000-2003,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 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_shared.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_trans_resv.h" 24 #include "xfs_bit.h" 25 #include "xfs_mount.h" 26 #include "xfs_defer.h" 27 #include "xfs_inode.h" 28 #include "xfs_trans.h" 29 #include "xfs_inode_item.h" 30 #include "xfs_alloc.h" 31 #include "xfs_btree.h" 32 #include "xfs_bmap_btree.h" 33 #include "xfs_bmap.h" 34 #include "xfs_error.h" 35 #include "xfs_quota.h" 36 #include "xfs_trace.h" 37 #include "xfs_cksum.h" 38 #include "xfs_rmap.h" 39 40 /* 41 * Convert on-disk form of btree root to in-memory form. 42 */ 43 void 44 xfs_bmdr_to_bmbt( 45 struct xfs_inode *ip, 46 xfs_bmdr_block_t *dblock, 47 int dblocklen, 48 struct xfs_btree_block *rblock, 49 int rblocklen) 50 { 51 struct xfs_mount *mp = ip->i_mount; 52 int dmxr; 53 xfs_bmbt_key_t *fkp; 54 __be64 *fpp; 55 xfs_bmbt_key_t *tkp; 56 __be64 *tpp; 57 58 xfs_btree_init_block_int(mp, rblock, XFS_BUF_DADDR_NULL, 59 XFS_BTNUM_BMAP, 0, 0, ip->i_ino, 60 XFS_BTREE_LONG_PTRS); 61 rblock->bb_level = dblock->bb_level; 62 ASSERT(be16_to_cpu(rblock->bb_level) > 0); 63 rblock->bb_numrecs = dblock->bb_numrecs; 64 dmxr = xfs_bmdr_maxrecs(dblocklen, 0); 65 fkp = XFS_BMDR_KEY_ADDR(dblock, 1); 66 tkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1); 67 fpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr); 68 tpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen); 69 dmxr = be16_to_cpu(dblock->bb_numrecs); 70 memcpy(tkp, fkp, sizeof(*fkp) * dmxr); 71 memcpy(tpp, fpp, sizeof(*fpp) * dmxr); 72 } 73 74 void 75 xfs_bmbt_disk_get_all( 76 struct xfs_bmbt_rec *rec, 77 struct xfs_bmbt_irec *irec) 78 { 79 uint64_t l0 = get_unaligned_be64(&rec->l0); 80 uint64_t l1 = get_unaligned_be64(&rec->l1); 81 82 irec->br_startoff = (l0 & xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9; 83 irec->br_startblock = ((l0 & xfs_mask64lo(9)) << 43) | (l1 >> 21); 84 irec->br_blockcount = l1 & xfs_mask64lo(21); 85 if (l0 >> (64 - BMBT_EXNTFLAG_BITLEN)) 86 irec->br_state = XFS_EXT_UNWRITTEN; 87 else 88 irec->br_state = XFS_EXT_NORM; 89 } 90 91 /* 92 * Extract the blockcount field from an on disk bmap extent record. 93 */ 94 xfs_filblks_t 95 xfs_bmbt_disk_get_blockcount( 96 xfs_bmbt_rec_t *r) 97 { 98 return (xfs_filblks_t)(be64_to_cpu(r->l1) & xfs_mask64lo(21)); 99 } 100 101 /* 102 * Extract the startoff field from a disk format bmap extent record. 103 */ 104 xfs_fileoff_t 105 xfs_bmbt_disk_get_startoff( 106 xfs_bmbt_rec_t *r) 107 { 108 return ((xfs_fileoff_t)be64_to_cpu(r->l0) & 109 xfs_mask64lo(64 - BMBT_EXNTFLAG_BITLEN)) >> 9; 110 } 111 112 /* 113 * Set all the fields in a bmap extent record from the uncompressed form. 114 */ 115 void 116 xfs_bmbt_disk_set_all( 117 struct xfs_bmbt_rec *r, 118 struct xfs_bmbt_irec *s) 119 { 120 int extent_flag = (s->br_state != XFS_EXT_NORM); 121 122 ASSERT(s->br_state == XFS_EXT_NORM || s->br_state == XFS_EXT_UNWRITTEN); 123 ASSERT(!(s->br_startoff & xfs_mask64hi(64-BMBT_STARTOFF_BITLEN))); 124 ASSERT(!(s->br_blockcount & xfs_mask64hi(64-BMBT_BLOCKCOUNT_BITLEN))); 125 ASSERT(!(s->br_startblock & xfs_mask64hi(64-BMBT_STARTBLOCK_BITLEN))); 126 127 put_unaligned_be64( 128 ((xfs_bmbt_rec_base_t)extent_flag << 63) | 129 ((xfs_bmbt_rec_base_t)s->br_startoff << 9) | 130 ((xfs_bmbt_rec_base_t)s->br_startblock >> 43), &r->l0); 131 put_unaligned_be64( 132 ((xfs_bmbt_rec_base_t)s->br_startblock << 21) | 133 ((xfs_bmbt_rec_base_t)s->br_blockcount & 134 (xfs_bmbt_rec_base_t)xfs_mask64lo(21)), &r->l1); 135 } 136 137 /* 138 * Convert in-memory form of btree root to on-disk form. 139 */ 140 void 141 xfs_bmbt_to_bmdr( 142 struct xfs_mount *mp, 143 struct xfs_btree_block *rblock, 144 int rblocklen, 145 xfs_bmdr_block_t *dblock, 146 int dblocklen) 147 { 148 int dmxr; 149 xfs_bmbt_key_t *fkp; 150 __be64 *fpp; 151 xfs_bmbt_key_t *tkp; 152 __be64 *tpp; 153 154 if (xfs_sb_version_hascrc(&mp->m_sb)) { 155 ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_CRC_MAGIC)); 156 ASSERT(uuid_equal(&rblock->bb_u.l.bb_uuid, 157 &mp->m_sb.sb_meta_uuid)); 158 ASSERT(rblock->bb_u.l.bb_blkno == 159 cpu_to_be64(XFS_BUF_DADDR_NULL)); 160 } else 161 ASSERT(rblock->bb_magic == cpu_to_be32(XFS_BMAP_MAGIC)); 162 ASSERT(rblock->bb_u.l.bb_leftsib == cpu_to_be64(NULLFSBLOCK)); 163 ASSERT(rblock->bb_u.l.bb_rightsib == cpu_to_be64(NULLFSBLOCK)); 164 ASSERT(rblock->bb_level != 0); 165 dblock->bb_level = rblock->bb_level; 166 dblock->bb_numrecs = rblock->bb_numrecs; 167 dmxr = xfs_bmdr_maxrecs(dblocklen, 0); 168 fkp = XFS_BMBT_KEY_ADDR(mp, rblock, 1); 169 tkp = XFS_BMDR_KEY_ADDR(dblock, 1); 170 fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen); 171 tpp = XFS_BMDR_PTR_ADDR(dblock, 1, dmxr); 172 dmxr = be16_to_cpu(dblock->bb_numrecs); 173 memcpy(tkp, fkp, sizeof(*fkp) * dmxr); 174 memcpy(tpp, fpp, sizeof(*fpp) * dmxr); 175 } 176 177 STATIC struct xfs_btree_cur * 178 xfs_bmbt_dup_cursor( 179 struct xfs_btree_cur *cur) 180 { 181 struct xfs_btree_cur *new; 182 183 new = xfs_bmbt_init_cursor(cur->bc_mp, cur->bc_tp, 184 cur->bc_private.b.ip, cur->bc_private.b.whichfork); 185 186 /* 187 * Copy the firstblock, dfops, and flags values, 188 * since init cursor doesn't get them. 189 */ 190 new->bc_private.b.firstblock = cur->bc_private.b.firstblock; 191 new->bc_private.b.dfops = cur->bc_private.b.dfops; 192 new->bc_private.b.flags = cur->bc_private.b.flags; 193 194 return new; 195 } 196 197 STATIC void 198 xfs_bmbt_update_cursor( 199 struct xfs_btree_cur *src, 200 struct xfs_btree_cur *dst) 201 { 202 ASSERT((dst->bc_private.b.firstblock != NULLFSBLOCK) || 203 (dst->bc_private.b.ip->i_d.di_flags & XFS_DIFLAG_REALTIME)); 204 ASSERT(dst->bc_private.b.dfops == src->bc_private.b.dfops); 205 206 dst->bc_private.b.allocated += src->bc_private.b.allocated; 207 dst->bc_private.b.firstblock = src->bc_private.b.firstblock; 208 209 src->bc_private.b.allocated = 0; 210 } 211 212 STATIC int 213 xfs_bmbt_alloc_block( 214 struct xfs_btree_cur *cur, 215 union xfs_btree_ptr *start, 216 union xfs_btree_ptr *new, 217 int *stat) 218 { 219 xfs_alloc_arg_t args; /* block allocation args */ 220 int error; /* error return value */ 221 222 memset(&args, 0, sizeof(args)); 223 args.tp = cur->bc_tp; 224 args.mp = cur->bc_mp; 225 args.fsbno = cur->bc_private.b.firstblock; 226 args.firstblock = args.fsbno; 227 xfs_rmap_ino_bmbt_owner(&args.oinfo, cur->bc_private.b.ip->i_ino, 228 cur->bc_private.b.whichfork); 229 230 if (args.fsbno == NULLFSBLOCK) { 231 args.fsbno = be64_to_cpu(start->l); 232 args.type = XFS_ALLOCTYPE_START_BNO; 233 /* 234 * Make sure there is sufficient room left in the AG to 235 * complete a full tree split for an extent insert. If 236 * we are converting the middle part of an extent then 237 * we may need space for two tree splits. 238 * 239 * We are relying on the caller to make the correct block 240 * reservation for this operation to succeed. If the 241 * reservation amount is insufficient then we may fail a 242 * block allocation here and corrupt the filesystem. 243 */ 244 args.minleft = args.tp->t_blk_res; 245 } else if (cur->bc_private.b.dfops->dop_low) { 246 args.type = XFS_ALLOCTYPE_START_BNO; 247 } else { 248 args.type = XFS_ALLOCTYPE_NEAR_BNO; 249 } 250 251 args.minlen = args.maxlen = args.prod = 1; 252 args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL; 253 if (!args.wasdel && args.tp->t_blk_res == 0) { 254 error = -ENOSPC; 255 goto error0; 256 } 257 error = xfs_alloc_vextent(&args); 258 if (error) 259 goto error0; 260 261 if (args.fsbno == NULLFSBLOCK && args.minleft) { 262 /* 263 * Could not find an AG with enough free space to satisfy 264 * a full btree split. Try again and if 265 * successful activate the lowspace algorithm. 266 */ 267 args.fsbno = 0; 268 args.type = XFS_ALLOCTYPE_FIRST_AG; 269 error = xfs_alloc_vextent(&args); 270 if (error) 271 goto error0; 272 cur->bc_private.b.dfops->dop_low = true; 273 } 274 if (WARN_ON_ONCE(args.fsbno == NULLFSBLOCK)) { 275 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT); 276 *stat = 0; 277 return 0; 278 } 279 ASSERT(args.len == 1); 280 cur->bc_private.b.firstblock = args.fsbno; 281 cur->bc_private.b.allocated++; 282 cur->bc_private.b.ip->i_d.di_nblocks++; 283 xfs_trans_log_inode(args.tp, cur->bc_private.b.ip, XFS_ILOG_CORE); 284 xfs_trans_mod_dquot_byino(args.tp, cur->bc_private.b.ip, 285 XFS_TRANS_DQ_BCOUNT, 1L); 286 287 new->l = cpu_to_be64(args.fsbno); 288 289 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT); 290 *stat = 1; 291 return 0; 292 293 error0: 294 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR); 295 return error; 296 } 297 298 STATIC int 299 xfs_bmbt_free_block( 300 struct xfs_btree_cur *cur, 301 struct xfs_buf *bp) 302 { 303 struct xfs_mount *mp = cur->bc_mp; 304 struct xfs_inode *ip = cur->bc_private.b.ip; 305 struct xfs_trans *tp = cur->bc_tp; 306 xfs_fsblock_t fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp)); 307 struct xfs_owner_info oinfo; 308 309 xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, cur->bc_private.b.whichfork); 310 xfs_bmap_add_free(mp, cur->bc_private.b.dfops, fsbno, 1, &oinfo); 311 ip->i_d.di_nblocks--; 312 313 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 314 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L); 315 return 0; 316 } 317 318 STATIC int 319 xfs_bmbt_get_minrecs( 320 struct xfs_btree_cur *cur, 321 int level) 322 { 323 if (level == cur->bc_nlevels - 1) { 324 struct xfs_ifork *ifp; 325 326 ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, 327 cur->bc_private.b.whichfork); 328 329 return xfs_bmbt_maxrecs(cur->bc_mp, 330 ifp->if_broot_bytes, level == 0) / 2; 331 } 332 333 return cur->bc_mp->m_bmap_dmnr[level != 0]; 334 } 335 336 int 337 xfs_bmbt_get_maxrecs( 338 struct xfs_btree_cur *cur, 339 int level) 340 { 341 if (level == cur->bc_nlevels - 1) { 342 struct xfs_ifork *ifp; 343 344 ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, 345 cur->bc_private.b.whichfork); 346 347 return xfs_bmbt_maxrecs(cur->bc_mp, 348 ifp->if_broot_bytes, level == 0); 349 } 350 351 return cur->bc_mp->m_bmap_dmxr[level != 0]; 352 353 } 354 355 /* 356 * Get the maximum records we could store in the on-disk format. 357 * 358 * For non-root nodes this is equivalent to xfs_bmbt_get_maxrecs, but 359 * for the root node this checks the available space in the dinode fork 360 * so that we can resize the in-memory buffer to match it. After a 361 * resize to the maximum size this function returns the same value 362 * as xfs_bmbt_get_maxrecs for the root node, too. 363 */ 364 STATIC int 365 xfs_bmbt_get_dmaxrecs( 366 struct xfs_btree_cur *cur, 367 int level) 368 { 369 if (level != cur->bc_nlevels - 1) 370 return cur->bc_mp->m_bmap_dmxr[level != 0]; 371 return xfs_bmdr_maxrecs(cur->bc_private.b.forksize, level == 0); 372 } 373 374 STATIC void 375 xfs_bmbt_init_key_from_rec( 376 union xfs_btree_key *key, 377 union xfs_btree_rec *rec) 378 { 379 key->bmbt.br_startoff = 380 cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt)); 381 } 382 383 STATIC void 384 xfs_bmbt_init_high_key_from_rec( 385 union xfs_btree_key *key, 386 union xfs_btree_rec *rec) 387 { 388 key->bmbt.br_startoff = cpu_to_be64( 389 xfs_bmbt_disk_get_startoff(&rec->bmbt) + 390 xfs_bmbt_disk_get_blockcount(&rec->bmbt) - 1); 391 } 392 393 STATIC void 394 xfs_bmbt_init_rec_from_cur( 395 struct xfs_btree_cur *cur, 396 union xfs_btree_rec *rec) 397 { 398 xfs_bmbt_disk_set_all(&rec->bmbt, &cur->bc_rec.b); 399 } 400 401 STATIC void 402 xfs_bmbt_init_ptr_from_cur( 403 struct xfs_btree_cur *cur, 404 union xfs_btree_ptr *ptr) 405 { 406 ptr->l = 0; 407 } 408 409 STATIC int64_t 410 xfs_bmbt_key_diff( 411 struct xfs_btree_cur *cur, 412 union xfs_btree_key *key) 413 { 414 return (int64_t)be64_to_cpu(key->bmbt.br_startoff) - 415 cur->bc_rec.b.br_startoff; 416 } 417 418 STATIC int64_t 419 xfs_bmbt_diff_two_keys( 420 struct xfs_btree_cur *cur, 421 union xfs_btree_key *k1, 422 union xfs_btree_key *k2) 423 { 424 return (int64_t)be64_to_cpu(k1->bmbt.br_startoff) - 425 be64_to_cpu(k2->bmbt.br_startoff); 426 } 427 428 static xfs_failaddr_t 429 xfs_bmbt_verify( 430 struct xfs_buf *bp) 431 { 432 struct xfs_mount *mp = bp->b_target->bt_mount; 433 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); 434 xfs_failaddr_t fa; 435 unsigned int level; 436 437 switch (block->bb_magic) { 438 case cpu_to_be32(XFS_BMAP_CRC_MAGIC): 439 /* 440 * XXX: need a better way of verifying the owner here. Right now 441 * just make sure there has been one set. 442 */ 443 fa = xfs_btree_lblock_v5hdr_verify(bp, XFS_RMAP_OWN_UNKNOWN); 444 if (fa) 445 return fa; 446 /* fall through */ 447 case cpu_to_be32(XFS_BMAP_MAGIC): 448 break; 449 default: 450 return __this_address; 451 } 452 453 /* 454 * numrecs and level verification. 455 * 456 * We don't know what fork we belong to, so just verify that the level 457 * is less than the maximum of the two. Later checks will be more 458 * precise. 459 */ 460 level = be16_to_cpu(block->bb_level); 461 if (level > max(mp->m_bm_maxlevels[0], mp->m_bm_maxlevels[1])) 462 return __this_address; 463 464 return xfs_btree_lblock_verify(bp, mp->m_bmap_dmxr[level != 0]); 465 } 466 467 static void 468 xfs_bmbt_read_verify( 469 struct xfs_buf *bp) 470 { 471 xfs_failaddr_t fa; 472 473 if (!xfs_btree_lblock_verify_crc(bp)) 474 xfs_verifier_error(bp, -EFSBADCRC, __this_address); 475 else { 476 fa = xfs_bmbt_verify(bp); 477 if (fa) 478 xfs_verifier_error(bp, -EFSCORRUPTED, fa); 479 } 480 481 if (bp->b_error) 482 trace_xfs_btree_corrupt(bp, _RET_IP_); 483 } 484 485 static void 486 xfs_bmbt_write_verify( 487 struct xfs_buf *bp) 488 { 489 xfs_failaddr_t fa; 490 491 fa = xfs_bmbt_verify(bp); 492 if (fa) { 493 trace_xfs_btree_corrupt(bp, _RET_IP_); 494 xfs_verifier_error(bp, -EFSCORRUPTED, fa); 495 return; 496 } 497 xfs_btree_lblock_calc_crc(bp); 498 } 499 500 const struct xfs_buf_ops xfs_bmbt_buf_ops = { 501 .name = "xfs_bmbt", 502 .verify_read = xfs_bmbt_read_verify, 503 .verify_write = xfs_bmbt_write_verify, 504 .verify_struct = xfs_bmbt_verify, 505 }; 506 507 508 STATIC int 509 xfs_bmbt_keys_inorder( 510 struct xfs_btree_cur *cur, 511 union xfs_btree_key *k1, 512 union xfs_btree_key *k2) 513 { 514 return be64_to_cpu(k1->bmbt.br_startoff) < 515 be64_to_cpu(k2->bmbt.br_startoff); 516 } 517 518 STATIC int 519 xfs_bmbt_recs_inorder( 520 struct xfs_btree_cur *cur, 521 union xfs_btree_rec *r1, 522 union xfs_btree_rec *r2) 523 { 524 return xfs_bmbt_disk_get_startoff(&r1->bmbt) + 525 xfs_bmbt_disk_get_blockcount(&r1->bmbt) <= 526 xfs_bmbt_disk_get_startoff(&r2->bmbt); 527 } 528 529 static const struct xfs_btree_ops xfs_bmbt_ops = { 530 .rec_len = sizeof(xfs_bmbt_rec_t), 531 .key_len = sizeof(xfs_bmbt_key_t), 532 533 .dup_cursor = xfs_bmbt_dup_cursor, 534 .update_cursor = xfs_bmbt_update_cursor, 535 .alloc_block = xfs_bmbt_alloc_block, 536 .free_block = xfs_bmbt_free_block, 537 .get_maxrecs = xfs_bmbt_get_maxrecs, 538 .get_minrecs = xfs_bmbt_get_minrecs, 539 .get_dmaxrecs = xfs_bmbt_get_dmaxrecs, 540 .init_key_from_rec = xfs_bmbt_init_key_from_rec, 541 .init_high_key_from_rec = xfs_bmbt_init_high_key_from_rec, 542 .init_rec_from_cur = xfs_bmbt_init_rec_from_cur, 543 .init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur, 544 .key_diff = xfs_bmbt_key_diff, 545 .diff_two_keys = xfs_bmbt_diff_two_keys, 546 .buf_ops = &xfs_bmbt_buf_ops, 547 .keys_inorder = xfs_bmbt_keys_inorder, 548 .recs_inorder = xfs_bmbt_recs_inorder, 549 }; 550 551 /* 552 * Allocate a new bmap btree cursor. 553 */ 554 struct xfs_btree_cur * /* new bmap btree cursor */ 555 xfs_bmbt_init_cursor( 556 struct xfs_mount *mp, /* file system mount point */ 557 struct xfs_trans *tp, /* transaction pointer */ 558 struct xfs_inode *ip, /* inode owning the btree */ 559 int whichfork) /* data or attr fork */ 560 { 561 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 562 struct xfs_btree_cur *cur; 563 ASSERT(whichfork != XFS_COW_FORK); 564 565 cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS); 566 567 cur->bc_tp = tp; 568 cur->bc_mp = mp; 569 cur->bc_nlevels = be16_to_cpu(ifp->if_broot->bb_level) + 1; 570 cur->bc_btnum = XFS_BTNUM_BMAP; 571 cur->bc_blocklog = mp->m_sb.sb_blocklog; 572 cur->bc_statoff = XFS_STATS_CALC_INDEX(xs_bmbt_2); 573 574 cur->bc_ops = &xfs_bmbt_ops; 575 cur->bc_flags = XFS_BTREE_LONG_PTRS | XFS_BTREE_ROOT_IN_INODE; 576 if (xfs_sb_version_hascrc(&mp->m_sb)) 577 cur->bc_flags |= XFS_BTREE_CRC_BLOCKS; 578 579 cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork); 580 cur->bc_private.b.ip = ip; 581 cur->bc_private.b.firstblock = NULLFSBLOCK; 582 cur->bc_private.b.dfops = NULL; 583 cur->bc_private.b.allocated = 0; 584 cur->bc_private.b.flags = 0; 585 cur->bc_private.b.whichfork = whichfork; 586 587 return cur; 588 } 589 590 /* 591 * Calculate number of records in a bmap btree block. 592 */ 593 int 594 xfs_bmbt_maxrecs( 595 struct xfs_mount *mp, 596 int blocklen, 597 int leaf) 598 { 599 blocklen -= XFS_BMBT_BLOCK_LEN(mp); 600 601 if (leaf) 602 return blocklen / sizeof(xfs_bmbt_rec_t); 603 return blocklen / (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t)); 604 } 605 606 /* 607 * Calculate number of records in a bmap btree inode root. 608 */ 609 int 610 xfs_bmdr_maxrecs( 611 int blocklen, 612 int leaf) 613 { 614 blocklen -= sizeof(xfs_bmdr_block_t); 615 616 if (leaf) 617 return blocklen / sizeof(xfs_bmdr_rec_t); 618 return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t)); 619 } 620 621 /* 622 * Change the owner of a btree format fork fo the inode passed in. Change it to 623 * the owner of that is passed in so that we can change owners before or after 624 * we switch forks between inodes. The operation that the caller is doing will 625 * determine whether is needs to change owner before or after the switch. 626 * 627 * For demand paged transactional modification, the fork switch should be done 628 * after reading in all the blocks, modifying them and pinning them in the 629 * transaction. For modification when the buffers are already pinned in memory, 630 * the fork switch can be done before changing the owner as we won't need to 631 * validate the owner until the btree buffers are unpinned and writes can occur 632 * again. 633 * 634 * For recovery based ownership change, there is no transactional context and 635 * so a buffer list must be supplied so that we can record the buffers that we 636 * modified for the caller to issue IO on. 637 */ 638 int 639 xfs_bmbt_change_owner( 640 struct xfs_trans *tp, 641 struct xfs_inode *ip, 642 int whichfork, 643 xfs_ino_t new_owner, 644 struct list_head *buffer_list) 645 { 646 struct xfs_btree_cur *cur; 647 int error; 648 649 ASSERT(tp || buffer_list); 650 ASSERT(!(tp && buffer_list)); 651 if (whichfork == XFS_DATA_FORK) 652 ASSERT(ip->i_d.di_format == XFS_DINODE_FMT_BTREE); 653 else 654 ASSERT(ip->i_d.di_aformat == XFS_DINODE_FMT_BTREE); 655 656 cur = xfs_bmbt_init_cursor(ip->i_mount, tp, ip, whichfork); 657 if (!cur) 658 return -ENOMEM; 659 cur->bc_private.b.flags |= XFS_BTCUR_BPRV_INVALID_OWNER; 660 661 error = xfs_btree_change_owner(cur, new_owner, buffer_list); 662 xfs_btree_del_cursor(cur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR); 663 return error; 664 } 665