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_btree_sblock_v5hdr_verify(bp)) 297 return false; 298 /* fall through */ 299 case cpu_to_be32(XFS_ABTB_MAGIC): 300 if (pag && pag->pagf_init) { 301 if (level >= pag->pagf_levels[XFS_BTNUM_BNOi]) 302 return false; 303 } else if (level >= mp->m_ag_maxlevels) 304 return false; 305 break; 306 case cpu_to_be32(XFS_ABTC_CRC_MAGIC): 307 if (!xfs_btree_sblock_v5hdr_verify(bp)) 308 return false; 309 /* fall through */ 310 case cpu_to_be32(XFS_ABTC_MAGIC): 311 if (pag && pag->pagf_init) { 312 if (level >= pag->pagf_levels[XFS_BTNUM_CNTi]) 313 return false; 314 } else if (level >= mp->m_ag_maxlevels) 315 return false; 316 break; 317 default: 318 return false; 319 } 320 321 return xfs_btree_sblock_verify(bp, mp->m_alloc_mxr[level != 0]); 322 } 323 324 static void 325 xfs_allocbt_read_verify( 326 struct xfs_buf *bp) 327 { 328 if (!xfs_btree_sblock_verify_crc(bp)) 329 xfs_buf_ioerror(bp, -EFSBADCRC); 330 else if (!xfs_allocbt_verify(bp)) 331 xfs_buf_ioerror(bp, -EFSCORRUPTED); 332 333 if (bp->b_error) { 334 trace_xfs_btree_corrupt(bp, _RET_IP_); 335 xfs_verifier_error(bp); 336 } 337 } 338 339 static void 340 xfs_allocbt_write_verify( 341 struct xfs_buf *bp) 342 { 343 if (!xfs_allocbt_verify(bp)) { 344 trace_xfs_btree_corrupt(bp, _RET_IP_); 345 xfs_buf_ioerror(bp, -EFSCORRUPTED); 346 xfs_verifier_error(bp); 347 return; 348 } 349 xfs_btree_sblock_calc_crc(bp); 350 351 } 352 353 const struct xfs_buf_ops xfs_allocbt_buf_ops = { 354 .name = "xfs_allocbt", 355 .verify_read = xfs_allocbt_read_verify, 356 .verify_write = xfs_allocbt_write_verify, 357 }; 358 359 360 #if defined(DEBUG) || defined(XFS_WARN) 361 STATIC int 362 xfs_allocbt_keys_inorder( 363 struct xfs_btree_cur *cur, 364 union xfs_btree_key *k1, 365 union xfs_btree_key *k2) 366 { 367 if (cur->bc_btnum == XFS_BTNUM_BNO) { 368 return be32_to_cpu(k1->alloc.ar_startblock) < 369 be32_to_cpu(k2->alloc.ar_startblock); 370 } else { 371 return be32_to_cpu(k1->alloc.ar_blockcount) < 372 be32_to_cpu(k2->alloc.ar_blockcount) || 373 (k1->alloc.ar_blockcount == k2->alloc.ar_blockcount && 374 be32_to_cpu(k1->alloc.ar_startblock) < 375 be32_to_cpu(k2->alloc.ar_startblock)); 376 } 377 } 378 379 STATIC int 380 xfs_allocbt_recs_inorder( 381 struct xfs_btree_cur *cur, 382 union xfs_btree_rec *r1, 383 union xfs_btree_rec *r2) 384 { 385 if (cur->bc_btnum == XFS_BTNUM_BNO) { 386 return be32_to_cpu(r1->alloc.ar_startblock) + 387 be32_to_cpu(r1->alloc.ar_blockcount) <= 388 be32_to_cpu(r2->alloc.ar_startblock); 389 } else { 390 return be32_to_cpu(r1->alloc.ar_blockcount) < 391 be32_to_cpu(r2->alloc.ar_blockcount) || 392 (r1->alloc.ar_blockcount == r2->alloc.ar_blockcount && 393 be32_to_cpu(r1->alloc.ar_startblock) < 394 be32_to_cpu(r2->alloc.ar_startblock)); 395 } 396 } 397 #endif /* DEBUG */ 398 399 static const struct xfs_btree_ops xfs_allocbt_ops = { 400 .rec_len = sizeof(xfs_alloc_rec_t), 401 .key_len = sizeof(xfs_alloc_key_t), 402 403 .dup_cursor = xfs_allocbt_dup_cursor, 404 .set_root = xfs_allocbt_set_root, 405 .alloc_block = xfs_allocbt_alloc_block, 406 .free_block = xfs_allocbt_free_block, 407 .update_lastrec = xfs_allocbt_update_lastrec, 408 .get_minrecs = xfs_allocbt_get_minrecs, 409 .get_maxrecs = xfs_allocbt_get_maxrecs, 410 .init_key_from_rec = xfs_allocbt_init_key_from_rec, 411 .init_rec_from_key = xfs_allocbt_init_rec_from_key, 412 .init_rec_from_cur = xfs_allocbt_init_rec_from_cur, 413 .init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur, 414 .key_diff = xfs_allocbt_key_diff, 415 .buf_ops = &xfs_allocbt_buf_ops, 416 #if defined(DEBUG) || defined(XFS_WARN) 417 .keys_inorder = xfs_allocbt_keys_inorder, 418 .recs_inorder = xfs_allocbt_recs_inorder, 419 #endif 420 }; 421 422 /* 423 * Allocate a new allocation btree cursor. 424 */ 425 struct xfs_btree_cur * /* new alloc btree cursor */ 426 xfs_allocbt_init_cursor( 427 struct xfs_mount *mp, /* file system mount point */ 428 struct xfs_trans *tp, /* transaction pointer */ 429 struct xfs_buf *agbp, /* buffer for agf structure */ 430 xfs_agnumber_t agno, /* allocation group number */ 431 xfs_btnum_t btnum) /* btree identifier */ 432 { 433 struct xfs_agf *agf = XFS_BUF_TO_AGF(agbp); 434 struct xfs_btree_cur *cur; 435 436 ASSERT(btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT); 437 438 cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP); 439 440 cur->bc_tp = tp; 441 cur->bc_mp = mp; 442 cur->bc_btnum = btnum; 443 cur->bc_blocklog = mp->m_sb.sb_blocklog; 444 cur->bc_ops = &xfs_allocbt_ops; 445 446 if (btnum == XFS_BTNUM_CNT) { 447 cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]); 448 cur->bc_flags = XFS_BTREE_LASTREC_UPDATE; 449 } else { 450 cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]); 451 } 452 453 cur->bc_private.a.agbp = agbp; 454 cur->bc_private.a.agno = agno; 455 456 if (xfs_sb_version_hascrc(&mp->m_sb)) 457 cur->bc_flags |= XFS_BTREE_CRC_BLOCKS; 458 459 return cur; 460 } 461 462 /* 463 * Calculate number of records in an alloc btree block. 464 */ 465 int 466 xfs_allocbt_maxrecs( 467 struct xfs_mount *mp, 468 int blocklen, 469 int leaf) 470 { 471 blocklen -= XFS_ALLOC_BLOCK_LEN(mp); 472 473 if (leaf) 474 return blocklen / sizeof(xfs_alloc_rec_t); 475 return blocklen / (sizeof(xfs_alloc_key_t) + sizeof(xfs_alloc_ptr_t)); 476 } 477