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 #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_sb.h" 25 #include "xfs_mount.h" 26 #include "xfs_btree.h" 27 #include "xfs_alloc_btree.h" 28 #include "xfs_alloc.h" 29 #include "xfs_extent_busy.h" 30 #include "xfs_error.h" 31 #include "xfs_trace.h" 32 #include "xfs_cksum.h" 33 #include "xfs_trans.h" 34 35 36 STATIC struct xfs_btree_cur * 37 xfs_allocbt_dup_cursor( 38 struct xfs_btree_cur *cur) 39 { 40 return xfs_allocbt_init_cursor(cur->bc_mp, cur->bc_tp, 41 cur->bc_private.a.agbp, cur->bc_private.a.agno, 42 cur->bc_btnum); 43 } 44 45 STATIC void 46 xfs_allocbt_set_root( 47 struct xfs_btree_cur *cur, 48 union xfs_btree_ptr *ptr, 49 int inc) 50 { 51 struct xfs_buf *agbp = cur->bc_private.a.agbp; 52 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp); 53 xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno); 54 int btnum = cur->bc_btnum; 55 struct xfs_perag *pag = xfs_perag_get(cur->bc_mp, seqno); 56 57 ASSERT(ptr->s != 0); 58 59 agf->agf_roots[btnum] = ptr->s; 60 be32_add_cpu(&agf->agf_levels[btnum], inc); 61 pag->pagf_levels[btnum] += inc; 62 xfs_perag_put(pag); 63 64 xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_ROOTS | XFS_AGF_LEVELS); 65 } 66 67 STATIC int 68 xfs_allocbt_alloc_block( 69 struct xfs_btree_cur *cur, 70 union xfs_btree_ptr *start, 71 union xfs_btree_ptr *new, 72 int *stat) 73 { 74 int error; 75 xfs_agblock_t bno; 76 77 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY); 78 79 /* Allocate the new block from the freelist. If we can't, give up. */ 80 error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp, 81 &bno, 1); 82 if (error) { 83 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR); 84 return error; 85 } 86 87 if (bno == NULLAGBLOCK) { 88 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT); 89 *stat = 0; 90 return 0; 91 } 92 93 xfs_extent_busy_reuse(cur->bc_mp, cur->bc_private.a.agno, bno, 1, false); 94 95 xfs_trans_agbtree_delta(cur->bc_tp, 1); 96 new->s = cpu_to_be32(bno); 97 98 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT); 99 *stat = 1; 100 return 0; 101 } 102 103 STATIC int 104 xfs_allocbt_free_block( 105 struct xfs_btree_cur *cur, 106 struct xfs_buf *bp) 107 { 108 struct xfs_buf *agbp = cur->bc_private.a.agbp; 109 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp); 110 xfs_agblock_t bno; 111 int error; 112 113 bno = xfs_daddr_to_agbno(cur->bc_mp, XFS_BUF_ADDR(bp)); 114 error = xfs_alloc_put_freelist(cur->bc_tp, agbp, NULL, bno, 1); 115 if (error) 116 return error; 117 118 xfs_extent_busy_insert(cur->bc_tp, be32_to_cpu(agf->agf_seqno), bno, 1, 119 XFS_EXTENT_BUSY_SKIP_DISCARD); 120 xfs_trans_agbtree_delta(cur->bc_tp, -1); 121 122 xfs_trans_binval(cur->bc_tp, bp); 123 return 0; 124 } 125 126 /* 127 * Update the longest extent in the AGF 128 */ 129 STATIC void 130 xfs_allocbt_update_lastrec( 131 struct xfs_btree_cur *cur, 132 struct xfs_btree_block *block, 133 union xfs_btree_rec *rec, 134 int ptr, 135 int reason) 136 { 137 struct xfs_agf *agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp); 138 xfs_agnumber_t seqno = be32_to_cpu(agf->agf_seqno); 139 struct xfs_perag *pag; 140 __be32 len; 141 int numrecs; 142 143 ASSERT(cur->bc_btnum == XFS_BTNUM_CNT); 144 145 switch (reason) { 146 case LASTREC_UPDATE: 147 /* 148 * If this is the last leaf block and it's the last record, 149 * then update the size of the longest extent in the AG. 150 */ 151 if (ptr != xfs_btree_get_numrecs(block)) 152 return; 153 len = rec->alloc.ar_blockcount; 154 break; 155 case LASTREC_INSREC: 156 if (be32_to_cpu(rec->alloc.ar_blockcount) <= 157 be32_to_cpu(agf->agf_longest)) 158 return; 159 len = rec->alloc.ar_blockcount; 160 break; 161 case LASTREC_DELREC: 162 numrecs = xfs_btree_get_numrecs(block); 163 if (ptr <= numrecs) 164 return; 165 ASSERT(ptr == numrecs + 1); 166 167 if (numrecs) { 168 xfs_alloc_rec_t *rrp; 169 170 rrp = XFS_ALLOC_REC_ADDR(cur->bc_mp, block, numrecs); 171 len = rrp->ar_blockcount; 172 } else { 173 len = 0; 174 } 175 176 break; 177 default: 178 ASSERT(0); 179 return; 180 } 181 182 agf->agf_longest = len; 183 pag = xfs_perag_get(cur->bc_mp, seqno); 184 pag->pagf_longest = be32_to_cpu(len); 185 xfs_perag_put(pag); 186 xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp, XFS_AGF_LONGEST); 187 } 188 189 STATIC int 190 xfs_allocbt_get_minrecs( 191 struct xfs_btree_cur *cur, 192 int level) 193 { 194 return cur->bc_mp->m_alloc_mnr[level != 0]; 195 } 196 197 STATIC int 198 xfs_allocbt_get_maxrecs( 199 struct xfs_btree_cur *cur, 200 int level) 201 { 202 return cur->bc_mp->m_alloc_mxr[level != 0]; 203 } 204 205 STATIC void 206 xfs_allocbt_init_key_from_rec( 207 union xfs_btree_key *key, 208 union xfs_btree_rec *rec) 209 { 210 ASSERT(rec->alloc.ar_startblock != 0); 211 212 key->alloc.ar_startblock = rec->alloc.ar_startblock; 213 key->alloc.ar_blockcount = rec->alloc.ar_blockcount; 214 } 215 216 STATIC void 217 xfs_allocbt_init_rec_from_key( 218 union xfs_btree_key *key, 219 union xfs_btree_rec *rec) 220 { 221 ASSERT(key->alloc.ar_startblock != 0); 222 223 rec->alloc.ar_startblock = key->alloc.ar_startblock; 224 rec->alloc.ar_blockcount = key->alloc.ar_blockcount; 225 } 226 227 STATIC void 228 xfs_allocbt_init_rec_from_cur( 229 struct xfs_btree_cur *cur, 230 union xfs_btree_rec *rec) 231 { 232 ASSERT(cur->bc_rec.a.ar_startblock != 0); 233 234 rec->alloc.ar_startblock = cpu_to_be32(cur->bc_rec.a.ar_startblock); 235 rec->alloc.ar_blockcount = cpu_to_be32(cur->bc_rec.a.ar_blockcount); 236 } 237 238 STATIC void 239 xfs_allocbt_init_ptr_from_cur( 240 struct xfs_btree_cur *cur, 241 union xfs_btree_ptr *ptr) 242 { 243 struct xfs_agf *agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp); 244 245 ASSERT(cur->bc_private.a.agno == be32_to_cpu(agf->agf_seqno)); 246 ASSERT(agf->agf_roots[cur->bc_btnum] != 0); 247 248 ptr->s = agf->agf_roots[cur->bc_btnum]; 249 } 250 251 STATIC __int64_t 252 xfs_allocbt_key_diff( 253 struct xfs_btree_cur *cur, 254 union xfs_btree_key *key) 255 { 256 xfs_alloc_rec_incore_t *rec = &cur->bc_rec.a; 257 xfs_alloc_key_t *kp = &key->alloc; 258 __int64_t diff; 259 260 if (cur->bc_btnum == XFS_BTNUM_BNO) { 261 return (__int64_t)be32_to_cpu(kp->ar_startblock) - 262 rec->ar_startblock; 263 } 264 265 diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount; 266 if (diff) 267 return diff; 268 269 return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock; 270 } 271 272 static bool 273 xfs_allocbt_verify( 274 struct xfs_buf *bp) 275 { 276 struct xfs_mount *mp = bp->b_target->bt_mount; 277 struct xfs_btree_block *block = XFS_BUF_TO_BLOCK(bp); 278 struct xfs_perag *pag = bp->b_pag; 279 unsigned int level; 280 281 /* 282 * magic number and level verification 283 * 284 * During growfs operations, we can't verify the exact level or owner as 285 * the perag is not fully initialised and hence not attached to the 286 * buffer. In this case, check against the maximum tree depth. 287 * 288 * Similarly, during log recovery we will have a perag structure 289 * attached, but the agf information will not yet have been initialised 290 * from the on disk AGF. Again, we can only check against maximum limits 291 * in this case. 292 */ 293 level = be16_to_cpu(block->bb_level); 294 switch (block->bb_magic) { 295 case cpu_to_be32(XFS_ABTB_CRC_MAGIC): 296 if (!xfs_sb_version_hascrc(&mp->m_sb)) 297 return false; 298 if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_uuid)) 299 return false; 300 if (block->bb_u.s.bb_blkno != cpu_to_be64(bp->b_bn)) 301 return false; 302 if (pag && 303 be32_to_cpu(block->bb_u.s.bb_owner) != pag->pag_agno) 304 return false; 305 /* fall through */ 306 case cpu_to_be32(XFS_ABTB_MAGIC): 307 if (pag && pag->pagf_init) { 308 if (level >= pag->pagf_levels[XFS_BTNUM_BNOi]) 309 return false; 310 } else if (level >= mp->m_ag_maxlevels) 311 return false; 312 break; 313 case cpu_to_be32(XFS_ABTC_CRC_MAGIC): 314 if (!xfs_sb_version_hascrc(&mp->m_sb)) 315 return false; 316 if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_uuid)) 317 return false; 318 if (block->bb_u.s.bb_blkno != cpu_to_be64(bp->b_bn)) 319 return false; 320 if (pag && 321 be32_to_cpu(block->bb_u.s.bb_owner) != pag->pag_agno) 322 return false; 323 /* fall through */ 324 case cpu_to_be32(XFS_ABTC_MAGIC): 325 if (pag && pag->pagf_init) { 326 if (level >= pag->pagf_levels[XFS_BTNUM_CNTi]) 327 return false; 328 } else if (level >= mp->m_ag_maxlevels) 329 return false; 330 break; 331 default: 332 return false; 333 } 334 335 /* numrecs verification */ 336 if (be16_to_cpu(block->bb_numrecs) > mp->m_alloc_mxr[level != 0]) 337 return false; 338 339 /* sibling pointer verification */ 340 if (!block->bb_u.s.bb_leftsib || 341 (be32_to_cpu(block->bb_u.s.bb_leftsib) >= mp->m_sb.sb_agblocks && 342 block->bb_u.s.bb_leftsib != cpu_to_be32(NULLAGBLOCK))) 343 return false; 344 if (!block->bb_u.s.bb_rightsib || 345 (be32_to_cpu(block->bb_u.s.bb_rightsib) >= mp->m_sb.sb_agblocks && 346 block->bb_u.s.bb_rightsib != cpu_to_be32(NULLAGBLOCK))) 347 return false; 348 349 return true; 350 } 351 352 static void 353 xfs_allocbt_read_verify( 354 struct xfs_buf *bp) 355 { 356 if (!xfs_btree_sblock_verify_crc(bp)) 357 xfs_buf_ioerror(bp, -EFSBADCRC); 358 else if (!xfs_allocbt_verify(bp)) 359 xfs_buf_ioerror(bp, -EFSCORRUPTED); 360 361 if (bp->b_error) { 362 trace_xfs_btree_corrupt(bp, _RET_IP_); 363 xfs_verifier_error(bp); 364 } 365 } 366 367 static void 368 xfs_allocbt_write_verify( 369 struct xfs_buf *bp) 370 { 371 if (!xfs_allocbt_verify(bp)) { 372 trace_xfs_btree_corrupt(bp, _RET_IP_); 373 xfs_buf_ioerror(bp, -EFSCORRUPTED); 374 xfs_verifier_error(bp); 375 return; 376 } 377 xfs_btree_sblock_calc_crc(bp); 378 379 } 380 381 const struct xfs_buf_ops xfs_allocbt_buf_ops = { 382 .verify_read = xfs_allocbt_read_verify, 383 .verify_write = xfs_allocbt_write_verify, 384 }; 385 386 387 #if defined(DEBUG) || defined(XFS_WARN) 388 STATIC int 389 xfs_allocbt_keys_inorder( 390 struct xfs_btree_cur *cur, 391 union xfs_btree_key *k1, 392 union xfs_btree_key *k2) 393 { 394 if (cur->bc_btnum == XFS_BTNUM_BNO) { 395 return be32_to_cpu(k1->alloc.ar_startblock) < 396 be32_to_cpu(k2->alloc.ar_startblock); 397 } else { 398 return be32_to_cpu(k1->alloc.ar_blockcount) < 399 be32_to_cpu(k2->alloc.ar_blockcount) || 400 (k1->alloc.ar_blockcount == k2->alloc.ar_blockcount && 401 be32_to_cpu(k1->alloc.ar_startblock) < 402 be32_to_cpu(k2->alloc.ar_startblock)); 403 } 404 } 405 406 STATIC int 407 xfs_allocbt_recs_inorder( 408 struct xfs_btree_cur *cur, 409 union xfs_btree_rec *r1, 410 union xfs_btree_rec *r2) 411 { 412 if (cur->bc_btnum == XFS_BTNUM_BNO) { 413 return be32_to_cpu(r1->alloc.ar_startblock) + 414 be32_to_cpu(r1->alloc.ar_blockcount) <= 415 be32_to_cpu(r2->alloc.ar_startblock); 416 } else { 417 return be32_to_cpu(r1->alloc.ar_blockcount) < 418 be32_to_cpu(r2->alloc.ar_blockcount) || 419 (r1->alloc.ar_blockcount == r2->alloc.ar_blockcount && 420 be32_to_cpu(r1->alloc.ar_startblock) < 421 be32_to_cpu(r2->alloc.ar_startblock)); 422 } 423 } 424 #endif /* DEBUG */ 425 426 static const struct xfs_btree_ops xfs_allocbt_ops = { 427 .rec_len = sizeof(xfs_alloc_rec_t), 428 .key_len = sizeof(xfs_alloc_key_t), 429 430 .dup_cursor = xfs_allocbt_dup_cursor, 431 .set_root = xfs_allocbt_set_root, 432 .alloc_block = xfs_allocbt_alloc_block, 433 .free_block = xfs_allocbt_free_block, 434 .update_lastrec = xfs_allocbt_update_lastrec, 435 .get_minrecs = xfs_allocbt_get_minrecs, 436 .get_maxrecs = xfs_allocbt_get_maxrecs, 437 .init_key_from_rec = xfs_allocbt_init_key_from_rec, 438 .init_rec_from_key = xfs_allocbt_init_rec_from_key, 439 .init_rec_from_cur = xfs_allocbt_init_rec_from_cur, 440 .init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur, 441 .key_diff = xfs_allocbt_key_diff, 442 .buf_ops = &xfs_allocbt_buf_ops, 443 #if defined(DEBUG) || defined(XFS_WARN) 444 .keys_inorder = xfs_allocbt_keys_inorder, 445 .recs_inorder = xfs_allocbt_recs_inorder, 446 #endif 447 }; 448 449 /* 450 * Allocate a new allocation btree cursor. 451 */ 452 struct xfs_btree_cur * /* new alloc btree cursor */ 453 xfs_allocbt_init_cursor( 454 struct xfs_mount *mp, /* file system mount point */ 455 struct xfs_trans *tp, /* transaction pointer */ 456 struct xfs_buf *agbp, /* buffer for agf structure */ 457 xfs_agnumber_t agno, /* allocation group number */ 458 xfs_btnum_t btnum) /* btree identifier */ 459 { 460 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp); 461 struct xfs_btree_cur *cur; 462 463 ASSERT(btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT); 464 465 cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP); 466 467 cur->bc_tp = tp; 468 cur->bc_mp = mp; 469 cur->bc_btnum = btnum; 470 cur->bc_blocklog = mp->m_sb.sb_blocklog; 471 cur->bc_ops = &xfs_allocbt_ops; 472 473 if (btnum == XFS_BTNUM_CNT) { 474 cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]); 475 cur->bc_flags = XFS_BTREE_LASTREC_UPDATE; 476 } else { 477 cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]); 478 } 479 480 cur->bc_private.a.agbp = agbp; 481 cur->bc_private.a.agno = agno; 482 483 if (xfs_sb_version_hascrc(&mp->m_sb)) 484 cur->bc_flags |= XFS_BTREE_CRC_BLOCKS; 485 486 return cur; 487 } 488 489 /* 490 * Calculate number of records in an alloc btree block. 491 */ 492 int 493 xfs_allocbt_maxrecs( 494 struct xfs_mount *mp, 495 int blocklen, 496 int leaf) 497 { 498 blocklen -= XFS_ALLOC_BLOCK_LEN(mp); 499 500 if (leaf) 501 return blocklen / sizeof(xfs_alloc_rec_t); 502 return blocklen / (sizeof(xfs_alloc_key_t) + sizeof(xfs_alloc_ptr_t)); 503 } 504