1 /* 2 * Copyright (c) 2000-2002,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_sb.h" 26 #include "xfs_mount.h" 27 #include "xfs_inode.h" 28 #include "xfs_btree.h" 29 #include "xfs_ialloc.h" 30 #include "xfs_ialloc_btree.h" 31 #include "xfs_alloc.h" 32 #include "xfs_rtalloc.h" 33 #include "xfs_error.h" 34 #include "xfs_bmap.h" 35 #include "xfs_cksum.h" 36 #include "xfs_trans.h" 37 #include "xfs_buf_item.h" 38 #include "xfs_icreate_item.h" 39 #include "xfs_icache.h" 40 #include "xfs_trace.h" 41 42 43 /* 44 * Allocation group level functions. 45 */ 46 static inline int 47 xfs_ialloc_cluster_alignment( 48 struct xfs_mount *mp) 49 { 50 if (xfs_sb_version_hasalign(&mp->m_sb) && 51 mp->m_sb.sb_inoalignmt >= 52 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 53 return mp->m_sb.sb_inoalignmt; 54 return 1; 55 } 56 57 /* 58 * Lookup a record by ino in the btree given by cur. 59 */ 60 int /* error */ 61 xfs_inobt_lookup( 62 struct xfs_btree_cur *cur, /* btree cursor */ 63 xfs_agino_t ino, /* starting inode of chunk */ 64 xfs_lookup_t dir, /* <=, >=, == */ 65 int *stat) /* success/failure */ 66 { 67 cur->bc_rec.i.ir_startino = ino; 68 cur->bc_rec.i.ir_holemask = 0; 69 cur->bc_rec.i.ir_count = 0; 70 cur->bc_rec.i.ir_freecount = 0; 71 cur->bc_rec.i.ir_free = 0; 72 return xfs_btree_lookup(cur, dir, stat); 73 } 74 75 /* 76 * Update the record referred to by cur to the value given. 77 * This either works (return 0) or gets an EFSCORRUPTED error. 78 */ 79 STATIC int /* error */ 80 xfs_inobt_update( 81 struct xfs_btree_cur *cur, /* btree cursor */ 82 xfs_inobt_rec_incore_t *irec) /* btree record */ 83 { 84 union xfs_btree_rec rec; 85 86 rec.inobt.ir_startino = cpu_to_be32(irec->ir_startino); 87 if (xfs_sb_version_hassparseinodes(&cur->bc_mp->m_sb)) { 88 rec.inobt.ir_u.sp.ir_holemask = cpu_to_be16(irec->ir_holemask); 89 rec.inobt.ir_u.sp.ir_count = irec->ir_count; 90 rec.inobt.ir_u.sp.ir_freecount = irec->ir_freecount; 91 } else { 92 /* ir_holemask/ir_count not supported on-disk */ 93 rec.inobt.ir_u.f.ir_freecount = cpu_to_be32(irec->ir_freecount); 94 } 95 rec.inobt.ir_free = cpu_to_be64(irec->ir_free); 96 return xfs_btree_update(cur, &rec); 97 } 98 99 /* 100 * Get the data from the pointed-to record. 101 */ 102 int /* error */ 103 xfs_inobt_get_rec( 104 struct xfs_btree_cur *cur, /* btree cursor */ 105 xfs_inobt_rec_incore_t *irec, /* btree record */ 106 int *stat) /* output: success/failure */ 107 { 108 union xfs_btree_rec *rec; 109 int error; 110 111 error = xfs_btree_get_rec(cur, &rec, stat); 112 if (error || *stat == 0) 113 return error; 114 115 irec->ir_startino = be32_to_cpu(rec->inobt.ir_startino); 116 if (xfs_sb_version_hassparseinodes(&cur->bc_mp->m_sb)) { 117 irec->ir_holemask = be16_to_cpu(rec->inobt.ir_u.sp.ir_holemask); 118 irec->ir_count = rec->inobt.ir_u.sp.ir_count; 119 irec->ir_freecount = rec->inobt.ir_u.sp.ir_freecount; 120 } else { 121 /* 122 * ir_holemask/ir_count not supported on-disk. Fill in hardcoded 123 * values for full inode chunks. 124 */ 125 irec->ir_holemask = XFS_INOBT_HOLEMASK_FULL; 126 irec->ir_count = XFS_INODES_PER_CHUNK; 127 irec->ir_freecount = 128 be32_to_cpu(rec->inobt.ir_u.f.ir_freecount); 129 } 130 irec->ir_free = be64_to_cpu(rec->inobt.ir_free); 131 132 return 0; 133 } 134 135 /* 136 * Insert a single inobt record. Cursor must already point to desired location. 137 */ 138 STATIC int 139 xfs_inobt_insert_rec( 140 struct xfs_btree_cur *cur, 141 __uint16_t holemask, 142 __uint8_t count, 143 __int32_t freecount, 144 xfs_inofree_t free, 145 int *stat) 146 { 147 cur->bc_rec.i.ir_holemask = holemask; 148 cur->bc_rec.i.ir_count = count; 149 cur->bc_rec.i.ir_freecount = freecount; 150 cur->bc_rec.i.ir_free = free; 151 return xfs_btree_insert(cur, stat); 152 } 153 154 /* 155 * Insert records describing a newly allocated inode chunk into the inobt. 156 */ 157 STATIC int 158 xfs_inobt_insert( 159 struct xfs_mount *mp, 160 struct xfs_trans *tp, 161 struct xfs_buf *agbp, 162 xfs_agino_t newino, 163 xfs_agino_t newlen, 164 xfs_btnum_t btnum) 165 { 166 struct xfs_btree_cur *cur; 167 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 168 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 169 xfs_agino_t thisino; 170 int i; 171 int error; 172 173 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, btnum); 174 175 for (thisino = newino; 176 thisino < newino + newlen; 177 thisino += XFS_INODES_PER_CHUNK) { 178 error = xfs_inobt_lookup(cur, thisino, XFS_LOOKUP_EQ, &i); 179 if (error) { 180 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 181 return error; 182 } 183 ASSERT(i == 0); 184 185 error = xfs_inobt_insert_rec(cur, XFS_INOBT_HOLEMASK_FULL, 186 XFS_INODES_PER_CHUNK, 187 XFS_INODES_PER_CHUNK, 188 XFS_INOBT_ALL_FREE, &i); 189 if (error) { 190 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 191 return error; 192 } 193 ASSERT(i == 1); 194 } 195 196 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 197 198 return 0; 199 } 200 201 /* 202 * Verify that the number of free inodes in the AGI is correct. 203 */ 204 #ifdef DEBUG 205 STATIC int 206 xfs_check_agi_freecount( 207 struct xfs_btree_cur *cur, 208 struct xfs_agi *agi) 209 { 210 if (cur->bc_nlevels == 1) { 211 xfs_inobt_rec_incore_t rec; 212 int freecount = 0; 213 int error; 214 int i; 215 216 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); 217 if (error) 218 return error; 219 220 do { 221 error = xfs_inobt_get_rec(cur, &rec, &i); 222 if (error) 223 return error; 224 225 if (i) { 226 freecount += rec.ir_freecount; 227 error = xfs_btree_increment(cur, 0, &i); 228 if (error) 229 return error; 230 } 231 } while (i == 1); 232 233 if (!XFS_FORCED_SHUTDOWN(cur->bc_mp)) 234 ASSERT(freecount == be32_to_cpu(agi->agi_freecount)); 235 } 236 return 0; 237 } 238 #else 239 #define xfs_check_agi_freecount(cur, agi) 0 240 #endif 241 242 /* 243 * Initialise a new set of inodes. When called without a transaction context 244 * (e.g. from recovery) we initiate a delayed write of the inode buffers rather 245 * than logging them (which in a transaction context puts them into the AIL 246 * for writeback rather than the xfsbufd queue). 247 */ 248 int 249 xfs_ialloc_inode_init( 250 struct xfs_mount *mp, 251 struct xfs_trans *tp, 252 struct list_head *buffer_list, 253 int icount, 254 xfs_agnumber_t agno, 255 xfs_agblock_t agbno, 256 xfs_agblock_t length, 257 unsigned int gen) 258 { 259 struct xfs_buf *fbuf; 260 struct xfs_dinode *free; 261 int nbufs, blks_per_cluster, inodes_per_cluster; 262 int version; 263 int i, j; 264 xfs_daddr_t d; 265 xfs_ino_t ino = 0; 266 267 /* 268 * Loop over the new block(s), filling in the inodes. For small block 269 * sizes, manipulate the inodes in buffers which are multiples of the 270 * blocks size. 271 */ 272 blks_per_cluster = xfs_icluster_size_fsb(mp); 273 inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog; 274 nbufs = length / blks_per_cluster; 275 276 /* 277 * Figure out what version number to use in the inodes we create. If 278 * the superblock version has caught up to the one that supports the new 279 * inode format, then use the new inode version. Otherwise use the old 280 * version so that old kernels will continue to be able to use the file 281 * system. 282 * 283 * For v3 inodes, we also need to write the inode number into the inode, 284 * so calculate the first inode number of the chunk here as 285 * XFS_OFFBNO_TO_AGINO() only works within a filesystem block, not 286 * across multiple filesystem blocks (such as a cluster) and so cannot 287 * be used in the cluster buffer loop below. 288 * 289 * Further, because we are writing the inode directly into the buffer 290 * and calculating a CRC on the entire inode, we have ot log the entire 291 * inode so that the entire range the CRC covers is present in the log. 292 * That means for v3 inode we log the entire buffer rather than just the 293 * inode cores. 294 */ 295 if (xfs_sb_version_hascrc(&mp->m_sb)) { 296 version = 3; 297 ino = XFS_AGINO_TO_INO(mp, agno, 298 XFS_OFFBNO_TO_AGINO(mp, agbno, 0)); 299 300 /* 301 * log the initialisation that is about to take place as an 302 * logical operation. This means the transaction does not 303 * need to log the physical changes to the inode buffers as log 304 * recovery will know what initialisation is actually needed. 305 * Hence we only need to log the buffers as "ordered" buffers so 306 * they track in the AIL as if they were physically logged. 307 */ 308 if (tp) 309 xfs_icreate_log(tp, agno, agbno, icount, 310 mp->m_sb.sb_inodesize, length, gen); 311 } else 312 version = 2; 313 314 for (j = 0; j < nbufs; j++) { 315 /* 316 * Get the block. 317 */ 318 d = XFS_AGB_TO_DADDR(mp, agno, agbno + (j * blks_per_cluster)); 319 fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, 320 mp->m_bsize * blks_per_cluster, 321 XBF_UNMAPPED); 322 if (!fbuf) 323 return -ENOMEM; 324 325 /* Initialize the inode buffers and log them appropriately. */ 326 fbuf->b_ops = &xfs_inode_buf_ops; 327 xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length)); 328 for (i = 0; i < inodes_per_cluster; i++) { 329 int ioffset = i << mp->m_sb.sb_inodelog; 330 uint isize = xfs_dinode_size(version); 331 332 free = xfs_make_iptr(mp, fbuf, i); 333 free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC); 334 free->di_version = version; 335 free->di_gen = cpu_to_be32(gen); 336 free->di_next_unlinked = cpu_to_be32(NULLAGINO); 337 338 if (version == 3) { 339 free->di_ino = cpu_to_be64(ino); 340 ino++; 341 uuid_copy(&free->di_uuid, &mp->m_sb.sb_uuid); 342 xfs_dinode_calc_crc(mp, free); 343 } else if (tp) { 344 /* just log the inode core */ 345 xfs_trans_log_buf(tp, fbuf, ioffset, 346 ioffset + isize - 1); 347 } 348 } 349 350 if (tp) { 351 /* 352 * Mark the buffer as an inode allocation buffer so it 353 * sticks in AIL at the point of this allocation 354 * transaction. This ensures the they are on disk before 355 * the tail of the log can be moved past this 356 * transaction (i.e. by preventing relogging from moving 357 * it forward in the log). 358 */ 359 xfs_trans_inode_alloc_buf(tp, fbuf); 360 if (version == 3) { 361 /* 362 * Mark the buffer as ordered so that they are 363 * not physically logged in the transaction but 364 * still tracked in the AIL as part of the 365 * transaction and pin the log appropriately. 366 */ 367 xfs_trans_ordered_buf(tp, fbuf); 368 xfs_trans_log_buf(tp, fbuf, 0, 369 BBTOB(fbuf->b_length) - 1); 370 } 371 } else { 372 fbuf->b_flags |= XBF_DONE; 373 xfs_buf_delwri_queue(fbuf, buffer_list); 374 xfs_buf_relse(fbuf); 375 } 376 } 377 return 0; 378 } 379 380 /* 381 * Align startino and allocmask for a recently allocated sparse chunk such that 382 * they are fit for insertion (or merge) into the on-disk inode btrees. 383 * 384 * Background: 385 * 386 * When enabled, sparse inode support increases the inode alignment from cluster 387 * size to inode chunk size. This means that the minimum range between two 388 * non-adjacent inode records in the inobt is large enough for a full inode 389 * record. This allows for cluster sized, cluster aligned block allocation 390 * without need to worry about whether the resulting inode record overlaps with 391 * another record in the tree. Without this basic rule, we would have to deal 392 * with the consequences of overlap by potentially undoing recent allocations in 393 * the inode allocation codepath. 394 * 395 * Because of this alignment rule (which is enforced on mount), there are two 396 * inobt possibilities for newly allocated sparse chunks. One is that the 397 * aligned inode record for the chunk covers a range of inodes not already 398 * covered in the inobt (i.e., it is safe to insert a new sparse record). The 399 * other is that a record already exists at the aligned startino that considers 400 * the newly allocated range as sparse. In the latter case, record content is 401 * merged in hope that sparse inode chunks fill to full chunks over time. 402 */ 403 STATIC void 404 xfs_align_sparse_ino( 405 struct xfs_mount *mp, 406 xfs_agino_t *startino, 407 uint16_t *allocmask) 408 { 409 xfs_agblock_t agbno; 410 xfs_agblock_t mod; 411 int offset; 412 413 agbno = XFS_AGINO_TO_AGBNO(mp, *startino); 414 mod = agbno % mp->m_sb.sb_inoalignmt; 415 if (!mod) 416 return; 417 418 /* calculate the inode offset and align startino */ 419 offset = mod << mp->m_sb.sb_inopblog; 420 *startino -= offset; 421 422 /* 423 * Since startino has been aligned down, left shift allocmask such that 424 * it continues to represent the same physical inodes relative to the 425 * new startino. 426 */ 427 *allocmask <<= offset / XFS_INODES_PER_HOLEMASK_BIT; 428 } 429 430 /* 431 * Determine whether the source inode record can merge into the target. Both 432 * records must be sparse, the inode ranges must match and there must be no 433 * allocation overlap between the records. 434 */ 435 STATIC bool 436 __xfs_inobt_can_merge( 437 struct xfs_inobt_rec_incore *trec, /* tgt record */ 438 struct xfs_inobt_rec_incore *srec) /* src record */ 439 { 440 uint64_t talloc; 441 uint64_t salloc; 442 443 /* records must cover the same inode range */ 444 if (trec->ir_startino != srec->ir_startino) 445 return false; 446 447 /* both records must be sparse */ 448 if (!xfs_inobt_issparse(trec->ir_holemask) || 449 !xfs_inobt_issparse(srec->ir_holemask)) 450 return false; 451 452 /* both records must track some inodes */ 453 if (!trec->ir_count || !srec->ir_count) 454 return false; 455 456 /* can't exceed capacity of a full record */ 457 if (trec->ir_count + srec->ir_count > XFS_INODES_PER_CHUNK) 458 return false; 459 460 /* verify there is no allocation overlap */ 461 talloc = xfs_inobt_irec_to_allocmask(trec); 462 salloc = xfs_inobt_irec_to_allocmask(srec); 463 if (talloc & salloc) 464 return false; 465 466 return true; 467 } 468 469 /* 470 * Merge the source inode record into the target. The caller must call 471 * __xfs_inobt_can_merge() to ensure the merge is valid. 472 */ 473 STATIC void 474 __xfs_inobt_rec_merge( 475 struct xfs_inobt_rec_incore *trec, /* target */ 476 struct xfs_inobt_rec_incore *srec) /* src */ 477 { 478 ASSERT(trec->ir_startino == srec->ir_startino); 479 480 /* combine the counts */ 481 trec->ir_count += srec->ir_count; 482 trec->ir_freecount += srec->ir_freecount; 483 484 /* 485 * Merge the holemask and free mask. For both fields, 0 bits refer to 486 * allocated inodes. We combine the allocated ranges with bitwise AND. 487 */ 488 trec->ir_holemask &= srec->ir_holemask; 489 trec->ir_free &= srec->ir_free; 490 } 491 492 /* 493 * Insert a new sparse inode chunk into the associated inode btree. The inode 494 * record for the sparse chunk is pre-aligned to a startino that should match 495 * any pre-existing sparse inode record in the tree. This allows sparse chunks 496 * to fill over time. 497 * 498 * This function supports two modes of handling preexisting records depending on 499 * the merge flag. If merge is true, the provided record is merged with the 500 * existing record and updated in place. The merged record is returned in nrec. 501 * If merge is false, an existing record is replaced with the provided record. 502 * If no preexisting record exists, the provided record is always inserted. 503 * 504 * It is considered corruption if a merge is requested and not possible. Given 505 * the sparse inode alignment constraints, this should never happen. 506 */ 507 STATIC int 508 xfs_inobt_insert_sprec( 509 struct xfs_mount *mp, 510 struct xfs_trans *tp, 511 struct xfs_buf *agbp, 512 int btnum, 513 struct xfs_inobt_rec_incore *nrec, /* in/out: new/merged rec. */ 514 bool merge) /* merge or replace */ 515 { 516 struct xfs_btree_cur *cur; 517 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 518 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 519 int error; 520 int i; 521 struct xfs_inobt_rec_incore rec; 522 523 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, btnum); 524 525 /* the new record is pre-aligned so we know where to look */ 526 error = xfs_inobt_lookup(cur, nrec->ir_startino, XFS_LOOKUP_EQ, &i); 527 if (error) 528 goto error; 529 /* if nothing there, insert a new record and return */ 530 if (i == 0) { 531 error = xfs_inobt_insert_rec(cur, nrec->ir_holemask, 532 nrec->ir_count, nrec->ir_freecount, 533 nrec->ir_free, &i); 534 if (error) 535 goto error; 536 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error); 537 538 goto out; 539 } 540 541 /* 542 * A record exists at this startino. Merge or replace the record 543 * depending on what we've been asked to do. 544 */ 545 if (merge) { 546 error = xfs_inobt_get_rec(cur, &rec, &i); 547 if (error) 548 goto error; 549 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error); 550 XFS_WANT_CORRUPTED_GOTO(mp, 551 rec.ir_startino == nrec->ir_startino, 552 error); 553 554 /* 555 * This should never fail. If we have coexisting records that 556 * cannot merge, something is seriously wrong. 557 */ 558 XFS_WANT_CORRUPTED_GOTO(mp, __xfs_inobt_can_merge(nrec, &rec), 559 error); 560 561 trace_xfs_irec_merge_pre(mp, agno, rec.ir_startino, 562 rec.ir_holemask, nrec->ir_startino, 563 nrec->ir_holemask); 564 565 /* merge to nrec to output the updated record */ 566 __xfs_inobt_rec_merge(nrec, &rec); 567 568 trace_xfs_irec_merge_post(mp, agno, nrec->ir_startino, 569 nrec->ir_holemask); 570 571 error = xfs_inobt_rec_check_count(mp, nrec); 572 if (error) 573 goto error; 574 } 575 576 error = xfs_inobt_update(cur, nrec); 577 if (error) 578 goto error; 579 580 out: 581 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 582 return 0; 583 error: 584 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 585 return error; 586 } 587 588 /* 589 * Allocate new inodes in the allocation group specified by agbp. 590 * Return 0 for success, else error code. 591 */ 592 STATIC int /* error code or 0 */ 593 xfs_ialloc_ag_alloc( 594 xfs_trans_t *tp, /* transaction pointer */ 595 xfs_buf_t *agbp, /* alloc group buffer */ 596 int *alloc) 597 { 598 xfs_agi_t *agi; /* allocation group header */ 599 xfs_alloc_arg_t args; /* allocation argument structure */ 600 xfs_agnumber_t agno; 601 int error; 602 xfs_agino_t newino; /* new first inode's number */ 603 xfs_agino_t newlen; /* new number of inodes */ 604 int isaligned = 0; /* inode allocation at stripe unit */ 605 /* boundary */ 606 uint16_t allocmask = (uint16_t) -1; /* init. to full chunk */ 607 struct xfs_inobt_rec_incore rec; 608 struct xfs_perag *pag; 609 int do_sparse = 0; 610 611 memset(&args, 0, sizeof(args)); 612 args.tp = tp; 613 args.mp = tp->t_mountp; 614 args.fsbno = NULLFSBLOCK; 615 616 #ifdef DEBUG 617 /* randomly do sparse inode allocations */ 618 if (xfs_sb_version_hassparseinodes(&tp->t_mountp->m_sb) && 619 args.mp->m_ialloc_min_blks < args.mp->m_ialloc_blks) 620 do_sparse = prandom_u32() & 1; 621 #endif 622 623 /* 624 * Locking will ensure that we don't have two callers in here 625 * at one time. 626 */ 627 newlen = args.mp->m_ialloc_inos; 628 if (args.mp->m_maxicount && 629 percpu_counter_read_positive(&args.mp->m_icount) + newlen > 630 args.mp->m_maxicount) 631 return -ENOSPC; 632 args.minlen = args.maxlen = args.mp->m_ialloc_blks; 633 /* 634 * First try to allocate inodes contiguous with the last-allocated 635 * chunk of inodes. If the filesystem is striped, this will fill 636 * an entire stripe unit with inodes. 637 */ 638 agi = XFS_BUF_TO_AGI(agbp); 639 newino = be32_to_cpu(agi->agi_newino); 640 agno = be32_to_cpu(agi->agi_seqno); 641 args.agbno = XFS_AGINO_TO_AGBNO(args.mp, newino) + 642 args.mp->m_ialloc_blks; 643 if (do_sparse) 644 goto sparse_alloc; 645 if (likely(newino != NULLAGINO && 646 (args.agbno < be32_to_cpu(agi->agi_length)))) { 647 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); 648 args.type = XFS_ALLOCTYPE_THIS_BNO; 649 args.prod = 1; 650 651 /* 652 * We need to take into account alignment here to ensure that 653 * we don't modify the free list if we fail to have an exact 654 * block. If we don't have an exact match, and every oher 655 * attempt allocation attempt fails, we'll end up cancelling 656 * a dirty transaction and shutting down. 657 * 658 * For an exact allocation, alignment must be 1, 659 * however we need to take cluster alignment into account when 660 * fixing up the freelist. Use the minalignslop field to 661 * indicate that extra blocks might be required for alignment, 662 * but not to use them in the actual exact allocation. 663 */ 664 args.alignment = 1; 665 args.minalignslop = xfs_ialloc_cluster_alignment(args.mp) - 1; 666 667 /* Allow space for the inode btree to split. */ 668 args.minleft = args.mp->m_in_maxlevels - 1; 669 if ((error = xfs_alloc_vextent(&args))) 670 return error; 671 672 /* 673 * This request might have dirtied the transaction if the AG can 674 * satisfy the request, but the exact block was not available. 675 * If the allocation did fail, subsequent requests will relax 676 * the exact agbno requirement and increase the alignment 677 * instead. It is critical that the total size of the request 678 * (len + alignment + slop) does not increase from this point 679 * on, so reset minalignslop to ensure it is not included in 680 * subsequent requests. 681 */ 682 args.minalignslop = 0; 683 } 684 685 if (unlikely(args.fsbno == NULLFSBLOCK)) { 686 /* 687 * Set the alignment for the allocation. 688 * If stripe alignment is turned on then align at stripe unit 689 * boundary. 690 * If the cluster size is smaller than a filesystem block 691 * then we're doing I/O for inodes in filesystem block size 692 * pieces, so don't need alignment anyway. 693 */ 694 isaligned = 0; 695 if (args.mp->m_sinoalign) { 696 ASSERT(!(args.mp->m_flags & XFS_MOUNT_NOALIGN)); 697 args.alignment = args.mp->m_dalign; 698 isaligned = 1; 699 } else 700 args.alignment = xfs_ialloc_cluster_alignment(args.mp); 701 /* 702 * Need to figure out where to allocate the inode blocks. 703 * Ideally they should be spaced out through the a.g. 704 * For now, just allocate blocks up front. 705 */ 706 args.agbno = be32_to_cpu(agi->agi_root); 707 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); 708 /* 709 * Allocate a fixed-size extent of inodes. 710 */ 711 args.type = XFS_ALLOCTYPE_NEAR_BNO; 712 args.prod = 1; 713 /* 714 * Allow space for the inode btree to split. 715 */ 716 args.minleft = args.mp->m_in_maxlevels - 1; 717 if ((error = xfs_alloc_vextent(&args))) 718 return error; 719 } 720 721 /* 722 * If stripe alignment is turned on, then try again with cluster 723 * alignment. 724 */ 725 if (isaligned && args.fsbno == NULLFSBLOCK) { 726 args.type = XFS_ALLOCTYPE_NEAR_BNO; 727 args.agbno = be32_to_cpu(agi->agi_root); 728 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); 729 args.alignment = xfs_ialloc_cluster_alignment(args.mp); 730 if ((error = xfs_alloc_vextent(&args))) 731 return error; 732 } 733 734 /* 735 * Finally, try a sparse allocation if the filesystem supports it and 736 * the sparse allocation length is smaller than a full chunk. 737 */ 738 if (xfs_sb_version_hassparseinodes(&args.mp->m_sb) && 739 args.mp->m_ialloc_min_blks < args.mp->m_ialloc_blks && 740 args.fsbno == NULLFSBLOCK) { 741 sparse_alloc: 742 args.type = XFS_ALLOCTYPE_NEAR_BNO; 743 args.agbno = be32_to_cpu(agi->agi_root); 744 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); 745 args.alignment = args.mp->m_sb.sb_spino_align; 746 args.prod = 1; 747 748 args.minlen = args.mp->m_ialloc_min_blks; 749 args.maxlen = args.minlen; 750 751 /* 752 * The inode record will be aligned to full chunk size. We must 753 * prevent sparse allocation from AG boundaries that result in 754 * invalid inode records, such as records that start at agbno 0 755 * or extend beyond the AG. 756 * 757 * Set min agbno to the first aligned, non-zero agbno and max to 758 * the last aligned agbno that is at least one full chunk from 759 * the end of the AG. 760 */ 761 args.min_agbno = args.mp->m_sb.sb_inoalignmt; 762 args.max_agbno = round_down(args.mp->m_sb.sb_agblocks, 763 args.mp->m_sb.sb_inoalignmt) - 764 args.mp->m_ialloc_blks; 765 766 error = xfs_alloc_vextent(&args); 767 if (error) 768 return error; 769 770 newlen = args.len << args.mp->m_sb.sb_inopblog; 771 ASSERT(newlen <= XFS_INODES_PER_CHUNK); 772 allocmask = (1 << (newlen / XFS_INODES_PER_HOLEMASK_BIT)) - 1; 773 } 774 775 if (args.fsbno == NULLFSBLOCK) { 776 *alloc = 0; 777 return 0; 778 } 779 ASSERT(args.len == args.minlen); 780 781 /* 782 * Stamp and write the inode buffers. 783 * 784 * Seed the new inode cluster with a random generation number. This 785 * prevents short-term reuse of generation numbers if a chunk is 786 * freed and then immediately reallocated. We use random numbers 787 * rather than a linear progression to prevent the next generation 788 * number from being easily guessable. 789 */ 790 error = xfs_ialloc_inode_init(args.mp, tp, NULL, newlen, agno, 791 args.agbno, args.len, prandom_u32()); 792 793 if (error) 794 return error; 795 /* 796 * Convert the results. 797 */ 798 newino = XFS_OFFBNO_TO_AGINO(args.mp, args.agbno, 0); 799 800 if (xfs_inobt_issparse(~allocmask)) { 801 /* 802 * We've allocated a sparse chunk. Align the startino and mask. 803 */ 804 xfs_align_sparse_ino(args.mp, &newino, &allocmask); 805 806 rec.ir_startino = newino; 807 rec.ir_holemask = ~allocmask; 808 rec.ir_count = newlen; 809 rec.ir_freecount = newlen; 810 rec.ir_free = XFS_INOBT_ALL_FREE; 811 812 /* 813 * Insert the sparse record into the inobt and allow for a merge 814 * if necessary. If a merge does occur, rec is updated to the 815 * merged record. 816 */ 817 error = xfs_inobt_insert_sprec(args.mp, tp, agbp, XFS_BTNUM_INO, 818 &rec, true); 819 if (error == -EFSCORRUPTED) { 820 xfs_alert(args.mp, 821 "invalid sparse inode record: ino 0x%llx holemask 0x%x count %u", 822 XFS_AGINO_TO_INO(args.mp, agno, 823 rec.ir_startino), 824 rec.ir_holemask, rec.ir_count); 825 xfs_force_shutdown(args.mp, SHUTDOWN_CORRUPT_INCORE); 826 } 827 if (error) 828 return error; 829 830 /* 831 * We can't merge the part we've just allocated as for the inobt 832 * due to finobt semantics. The original record may or may not 833 * exist independent of whether physical inodes exist in this 834 * sparse chunk. 835 * 836 * We must update the finobt record based on the inobt record. 837 * rec contains the fully merged and up to date inobt record 838 * from the previous call. Set merge false to replace any 839 * existing record with this one. 840 */ 841 if (xfs_sb_version_hasfinobt(&args.mp->m_sb)) { 842 error = xfs_inobt_insert_sprec(args.mp, tp, agbp, 843 XFS_BTNUM_FINO, &rec, 844 false); 845 if (error) 846 return error; 847 } 848 } else { 849 /* full chunk - insert new records to both btrees */ 850 error = xfs_inobt_insert(args.mp, tp, agbp, newino, newlen, 851 XFS_BTNUM_INO); 852 if (error) 853 return error; 854 855 if (xfs_sb_version_hasfinobt(&args.mp->m_sb)) { 856 error = xfs_inobt_insert(args.mp, tp, agbp, newino, 857 newlen, XFS_BTNUM_FINO); 858 if (error) 859 return error; 860 } 861 } 862 863 /* 864 * Update AGI counts and newino. 865 */ 866 be32_add_cpu(&agi->agi_count, newlen); 867 be32_add_cpu(&agi->agi_freecount, newlen); 868 pag = xfs_perag_get(args.mp, agno); 869 pag->pagi_freecount += newlen; 870 xfs_perag_put(pag); 871 agi->agi_newino = cpu_to_be32(newino); 872 873 /* 874 * Log allocation group header fields 875 */ 876 xfs_ialloc_log_agi(tp, agbp, 877 XFS_AGI_COUNT | XFS_AGI_FREECOUNT | XFS_AGI_NEWINO); 878 /* 879 * Modify/log superblock values for inode count and inode free count. 880 */ 881 xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, (long)newlen); 882 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, (long)newlen); 883 *alloc = 1; 884 return 0; 885 } 886 887 STATIC xfs_agnumber_t 888 xfs_ialloc_next_ag( 889 xfs_mount_t *mp) 890 { 891 xfs_agnumber_t agno; 892 893 spin_lock(&mp->m_agirotor_lock); 894 agno = mp->m_agirotor; 895 if (++mp->m_agirotor >= mp->m_maxagi) 896 mp->m_agirotor = 0; 897 spin_unlock(&mp->m_agirotor_lock); 898 899 return agno; 900 } 901 902 /* 903 * Select an allocation group to look for a free inode in, based on the parent 904 * inode and the mode. Return the allocation group buffer. 905 */ 906 STATIC xfs_agnumber_t 907 xfs_ialloc_ag_select( 908 xfs_trans_t *tp, /* transaction pointer */ 909 xfs_ino_t parent, /* parent directory inode number */ 910 umode_t mode, /* bits set to indicate file type */ 911 int okalloc) /* ok to allocate more space */ 912 { 913 xfs_agnumber_t agcount; /* number of ag's in the filesystem */ 914 xfs_agnumber_t agno; /* current ag number */ 915 int flags; /* alloc buffer locking flags */ 916 xfs_extlen_t ineed; /* blocks needed for inode allocation */ 917 xfs_extlen_t longest = 0; /* longest extent available */ 918 xfs_mount_t *mp; /* mount point structure */ 919 int needspace; /* file mode implies space allocated */ 920 xfs_perag_t *pag; /* per allocation group data */ 921 xfs_agnumber_t pagno; /* parent (starting) ag number */ 922 int error; 923 924 /* 925 * Files of these types need at least one block if length > 0 926 * (and they won't fit in the inode, but that's hard to figure out). 927 */ 928 needspace = S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode); 929 mp = tp->t_mountp; 930 agcount = mp->m_maxagi; 931 if (S_ISDIR(mode)) 932 pagno = xfs_ialloc_next_ag(mp); 933 else { 934 pagno = XFS_INO_TO_AGNO(mp, parent); 935 if (pagno >= agcount) 936 pagno = 0; 937 } 938 939 ASSERT(pagno < agcount); 940 941 /* 942 * Loop through allocation groups, looking for one with a little 943 * free space in it. Note we don't look for free inodes, exactly. 944 * Instead, we include whether there is a need to allocate inodes 945 * to mean that blocks must be allocated for them, 946 * if none are currently free. 947 */ 948 agno = pagno; 949 flags = XFS_ALLOC_FLAG_TRYLOCK; 950 for (;;) { 951 pag = xfs_perag_get(mp, agno); 952 if (!pag->pagi_inodeok) { 953 xfs_ialloc_next_ag(mp); 954 goto nextag; 955 } 956 957 if (!pag->pagi_init) { 958 error = xfs_ialloc_pagi_init(mp, tp, agno); 959 if (error) 960 goto nextag; 961 } 962 963 if (pag->pagi_freecount) { 964 xfs_perag_put(pag); 965 return agno; 966 } 967 968 if (!okalloc) 969 goto nextag; 970 971 if (!pag->pagf_init) { 972 error = xfs_alloc_pagf_init(mp, tp, agno, flags); 973 if (error) 974 goto nextag; 975 } 976 977 /* 978 * Check that there is enough free space for the file plus a 979 * chunk of inodes if we need to allocate some. If this is the 980 * first pass across the AGs, take into account the potential 981 * space needed for alignment of inode chunks when checking the 982 * longest contiguous free space in the AG - this prevents us 983 * from getting ENOSPC because we have free space larger than 984 * m_ialloc_blks but alignment constraints prevent us from using 985 * it. 986 * 987 * If we can't find an AG with space for full alignment slack to 988 * be taken into account, we must be near ENOSPC in all AGs. 989 * Hence we don't include alignment for the second pass and so 990 * if we fail allocation due to alignment issues then it is most 991 * likely a real ENOSPC condition. 992 */ 993 ineed = mp->m_ialloc_min_blks; 994 if (flags && ineed > 1) 995 ineed += xfs_ialloc_cluster_alignment(mp); 996 longest = pag->pagf_longest; 997 if (!longest) 998 longest = pag->pagf_flcount > 0; 999 1000 if (pag->pagf_freeblks >= needspace + ineed && 1001 longest >= ineed) { 1002 xfs_perag_put(pag); 1003 return agno; 1004 } 1005 nextag: 1006 xfs_perag_put(pag); 1007 /* 1008 * No point in iterating over the rest, if we're shutting 1009 * down. 1010 */ 1011 if (XFS_FORCED_SHUTDOWN(mp)) 1012 return NULLAGNUMBER; 1013 agno++; 1014 if (agno >= agcount) 1015 agno = 0; 1016 if (agno == pagno) { 1017 if (flags == 0) 1018 return NULLAGNUMBER; 1019 flags = 0; 1020 } 1021 } 1022 } 1023 1024 /* 1025 * Try to retrieve the next record to the left/right from the current one. 1026 */ 1027 STATIC int 1028 xfs_ialloc_next_rec( 1029 struct xfs_btree_cur *cur, 1030 xfs_inobt_rec_incore_t *rec, 1031 int *done, 1032 int left) 1033 { 1034 int error; 1035 int i; 1036 1037 if (left) 1038 error = xfs_btree_decrement(cur, 0, &i); 1039 else 1040 error = xfs_btree_increment(cur, 0, &i); 1041 1042 if (error) 1043 return error; 1044 *done = !i; 1045 if (i) { 1046 error = xfs_inobt_get_rec(cur, rec, &i); 1047 if (error) 1048 return error; 1049 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1050 } 1051 1052 return 0; 1053 } 1054 1055 STATIC int 1056 xfs_ialloc_get_rec( 1057 struct xfs_btree_cur *cur, 1058 xfs_agino_t agino, 1059 xfs_inobt_rec_incore_t *rec, 1060 int *done) 1061 { 1062 int error; 1063 int i; 1064 1065 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_EQ, &i); 1066 if (error) 1067 return error; 1068 *done = !i; 1069 if (i) { 1070 error = xfs_inobt_get_rec(cur, rec, &i); 1071 if (error) 1072 return error; 1073 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1074 } 1075 1076 return 0; 1077 } 1078 1079 /* 1080 * Return the offset of the first free inode in the record. If the inode chunk 1081 * is sparsely allocated, we convert the record holemask to inode granularity 1082 * and mask off the unallocated regions from the inode free mask. 1083 */ 1084 STATIC int 1085 xfs_inobt_first_free_inode( 1086 struct xfs_inobt_rec_incore *rec) 1087 { 1088 xfs_inofree_t realfree; 1089 1090 /* if there are no holes, return the first available offset */ 1091 if (!xfs_inobt_issparse(rec->ir_holemask)) 1092 return xfs_lowbit64(rec->ir_free); 1093 1094 realfree = xfs_inobt_irec_to_allocmask(rec); 1095 realfree &= rec->ir_free; 1096 1097 return xfs_lowbit64(realfree); 1098 } 1099 1100 /* 1101 * Allocate an inode using the inobt-only algorithm. 1102 */ 1103 STATIC int 1104 xfs_dialloc_ag_inobt( 1105 struct xfs_trans *tp, 1106 struct xfs_buf *agbp, 1107 xfs_ino_t parent, 1108 xfs_ino_t *inop) 1109 { 1110 struct xfs_mount *mp = tp->t_mountp; 1111 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 1112 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 1113 xfs_agnumber_t pagno = XFS_INO_TO_AGNO(mp, parent); 1114 xfs_agino_t pagino = XFS_INO_TO_AGINO(mp, parent); 1115 struct xfs_perag *pag; 1116 struct xfs_btree_cur *cur, *tcur; 1117 struct xfs_inobt_rec_incore rec, trec; 1118 xfs_ino_t ino; 1119 int error; 1120 int offset; 1121 int i, j; 1122 1123 pag = xfs_perag_get(mp, agno); 1124 1125 ASSERT(pag->pagi_init); 1126 ASSERT(pag->pagi_inodeok); 1127 ASSERT(pag->pagi_freecount > 0); 1128 1129 restart_pagno: 1130 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_INO); 1131 /* 1132 * If pagino is 0 (this is the root inode allocation) use newino. 1133 * This must work because we've just allocated some. 1134 */ 1135 if (!pagino) 1136 pagino = be32_to_cpu(agi->agi_newino); 1137 1138 error = xfs_check_agi_freecount(cur, agi); 1139 if (error) 1140 goto error0; 1141 1142 /* 1143 * If in the same AG as the parent, try to get near the parent. 1144 */ 1145 if (pagno == agno) { 1146 int doneleft; /* done, to the left */ 1147 int doneright; /* done, to the right */ 1148 int searchdistance = 10; 1149 1150 error = xfs_inobt_lookup(cur, pagino, XFS_LOOKUP_LE, &i); 1151 if (error) 1152 goto error0; 1153 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1154 1155 error = xfs_inobt_get_rec(cur, &rec, &j); 1156 if (error) 1157 goto error0; 1158 XFS_WANT_CORRUPTED_GOTO(mp, j == 1, error0); 1159 1160 if (rec.ir_freecount > 0) { 1161 /* 1162 * Found a free inode in the same chunk 1163 * as the parent, done. 1164 */ 1165 goto alloc_inode; 1166 } 1167 1168 1169 /* 1170 * In the same AG as parent, but parent's chunk is full. 1171 */ 1172 1173 /* duplicate the cursor, search left & right simultaneously */ 1174 error = xfs_btree_dup_cursor(cur, &tcur); 1175 if (error) 1176 goto error0; 1177 1178 /* 1179 * Skip to last blocks looked up if same parent inode. 1180 */ 1181 if (pagino != NULLAGINO && 1182 pag->pagl_pagino == pagino && 1183 pag->pagl_leftrec != NULLAGINO && 1184 pag->pagl_rightrec != NULLAGINO) { 1185 error = xfs_ialloc_get_rec(tcur, pag->pagl_leftrec, 1186 &trec, &doneleft); 1187 if (error) 1188 goto error1; 1189 1190 error = xfs_ialloc_get_rec(cur, pag->pagl_rightrec, 1191 &rec, &doneright); 1192 if (error) 1193 goto error1; 1194 } else { 1195 /* search left with tcur, back up 1 record */ 1196 error = xfs_ialloc_next_rec(tcur, &trec, &doneleft, 1); 1197 if (error) 1198 goto error1; 1199 1200 /* search right with cur, go forward 1 record. */ 1201 error = xfs_ialloc_next_rec(cur, &rec, &doneright, 0); 1202 if (error) 1203 goto error1; 1204 } 1205 1206 /* 1207 * Loop until we find an inode chunk with a free inode. 1208 */ 1209 while (!doneleft || !doneright) { 1210 int useleft; /* using left inode chunk this time */ 1211 1212 if (!--searchdistance) { 1213 /* 1214 * Not in range - save last search 1215 * location and allocate a new inode 1216 */ 1217 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); 1218 pag->pagl_leftrec = trec.ir_startino; 1219 pag->pagl_rightrec = rec.ir_startino; 1220 pag->pagl_pagino = pagino; 1221 goto newino; 1222 } 1223 1224 /* figure out the closer block if both are valid. */ 1225 if (!doneleft && !doneright) { 1226 useleft = pagino - 1227 (trec.ir_startino + XFS_INODES_PER_CHUNK - 1) < 1228 rec.ir_startino - pagino; 1229 } else { 1230 useleft = !doneleft; 1231 } 1232 1233 /* free inodes to the left? */ 1234 if (useleft && trec.ir_freecount) { 1235 rec = trec; 1236 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 1237 cur = tcur; 1238 1239 pag->pagl_leftrec = trec.ir_startino; 1240 pag->pagl_rightrec = rec.ir_startino; 1241 pag->pagl_pagino = pagino; 1242 goto alloc_inode; 1243 } 1244 1245 /* free inodes to the right? */ 1246 if (!useleft && rec.ir_freecount) { 1247 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); 1248 1249 pag->pagl_leftrec = trec.ir_startino; 1250 pag->pagl_rightrec = rec.ir_startino; 1251 pag->pagl_pagino = pagino; 1252 goto alloc_inode; 1253 } 1254 1255 /* get next record to check */ 1256 if (useleft) { 1257 error = xfs_ialloc_next_rec(tcur, &trec, 1258 &doneleft, 1); 1259 } else { 1260 error = xfs_ialloc_next_rec(cur, &rec, 1261 &doneright, 0); 1262 } 1263 if (error) 1264 goto error1; 1265 } 1266 1267 /* 1268 * We've reached the end of the btree. because 1269 * we are only searching a small chunk of the 1270 * btree each search, there is obviously free 1271 * inodes closer to the parent inode than we 1272 * are now. restart the search again. 1273 */ 1274 pag->pagl_pagino = NULLAGINO; 1275 pag->pagl_leftrec = NULLAGINO; 1276 pag->pagl_rightrec = NULLAGINO; 1277 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); 1278 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 1279 goto restart_pagno; 1280 } 1281 1282 /* 1283 * In a different AG from the parent. 1284 * See if the most recently allocated block has any free. 1285 */ 1286 newino: 1287 if (agi->agi_newino != cpu_to_be32(NULLAGINO)) { 1288 error = xfs_inobt_lookup(cur, be32_to_cpu(agi->agi_newino), 1289 XFS_LOOKUP_EQ, &i); 1290 if (error) 1291 goto error0; 1292 1293 if (i == 1) { 1294 error = xfs_inobt_get_rec(cur, &rec, &j); 1295 if (error) 1296 goto error0; 1297 1298 if (j == 1 && rec.ir_freecount > 0) { 1299 /* 1300 * The last chunk allocated in the group 1301 * still has a free inode. 1302 */ 1303 goto alloc_inode; 1304 } 1305 } 1306 } 1307 1308 /* 1309 * None left in the last group, search the whole AG 1310 */ 1311 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); 1312 if (error) 1313 goto error0; 1314 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1315 1316 for (;;) { 1317 error = xfs_inobt_get_rec(cur, &rec, &i); 1318 if (error) 1319 goto error0; 1320 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1321 if (rec.ir_freecount > 0) 1322 break; 1323 error = xfs_btree_increment(cur, 0, &i); 1324 if (error) 1325 goto error0; 1326 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1327 } 1328 1329 alloc_inode: 1330 offset = xfs_inobt_first_free_inode(&rec); 1331 ASSERT(offset >= 0); 1332 ASSERT(offset < XFS_INODES_PER_CHUNK); 1333 ASSERT((XFS_AGINO_TO_OFFSET(mp, rec.ir_startino) % 1334 XFS_INODES_PER_CHUNK) == 0); 1335 ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino + offset); 1336 rec.ir_free &= ~XFS_INOBT_MASK(offset); 1337 rec.ir_freecount--; 1338 error = xfs_inobt_update(cur, &rec); 1339 if (error) 1340 goto error0; 1341 be32_add_cpu(&agi->agi_freecount, -1); 1342 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT); 1343 pag->pagi_freecount--; 1344 1345 error = xfs_check_agi_freecount(cur, agi); 1346 if (error) 1347 goto error0; 1348 1349 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 1350 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -1); 1351 xfs_perag_put(pag); 1352 *inop = ino; 1353 return 0; 1354 error1: 1355 xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR); 1356 error0: 1357 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 1358 xfs_perag_put(pag); 1359 return error; 1360 } 1361 1362 /* 1363 * Use the free inode btree to allocate an inode based on distance from the 1364 * parent. Note that the provided cursor may be deleted and replaced. 1365 */ 1366 STATIC int 1367 xfs_dialloc_ag_finobt_near( 1368 xfs_agino_t pagino, 1369 struct xfs_btree_cur **ocur, 1370 struct xfs_inobt_rec_incore *rec) 1371 { 1372 struct xfs_btree_cur *lcur = *ocur; /* left search cursor */ 1373 struct xfs_btree_cur *rcur; /* right search cursor */ 1374 struct xfs_inobt_rec_incore rrec; 1375 int error; 1376 int i, j; 1377 1378 error = xfs_inobt_lookup(lcur, pagino, XFS_LOOKUP_LE, &i); 1379 if (error) 1380 return error; 1381 1382 if (i == 1) { 1383 error = xfs_inobt_get_rec(lcur, rec, &i); 1384 if (error) 1385 return error; 1386 XFS_WANT_CORRUPTED_RETURN(lcur->bc_mp, i == 1); 1387 1388 /* 1389 * See if we've landed in the parent inode record. The finobt 1390 * only tracks chunks with at least one free inode, so record 1391 * existence is enough. 1392 */ 1393 if (pagino >= rec->ir_startino && 1394 pagino < (rec->ir_startino + XFS_INODES_PER_CHUNK)) 1395 return 0; 1396 } 1397 1398 error = xfs_btree_dup_cursor(lcur, &rcur); 1399 if (error) 1400 return error; 1401 1402 error = xfs_inobt_lookup(rcur, pagino, XFS_LOOKUP_GE, &j); 1403 if (error) 1404 goto error_rcur; 1405 if (j == 1) { 1406 error = xfs_inobt_get_rec(rcur, &rrec, &j); 1407 if (error) 1408 goto error_rcur; 1409 XFS_WANT_CORRUPTED_GOTO(lcur->bc_mp, j == 1, error_rcur); 1410 } 1411 1412 XFS_WANT_CORRUPTED_GOTO(lcur->bc_mp, i == 1 || j == 1, error_rcur); 1413 if (i == 1 && j == 1) { 1414 /* 1415 * Both the left and right records are valid. Choose the closer 1416 * inode chunk to the target. 1417 */ 1418 if ((pagino - rec->ir_startino + XFS_INODES_PER_CHUNK - 1) > 1419 (rrec.ir_startino - pagino)) { 1420 *rec = rrec; 1421 xfs_btree_del_cursor(lcur, XFS_BTREE_NOERROR); 1422 *ocur = rcur; 1423 } else { 1424 xfs_btree_del_cursor(rcur, XFS_BTREE_NOERROR); 1425 } 1426 } else if (j == 1) { 1427 /* only the right record is valid */ 1428 *rec = rrec; 1429 xfs_btree_del_cursor(lcur, XFS_BTREE_NOERROR); 1430 *ocur = rcur; 1431 } else if (i == 1) { 1432 /* only the left record is valid */ 1433 xfs_btree_del_cursor(rcur, XFS_BTREE_NOERROR); 1434 } 1435 1436 return 0; 1437 1438 error_rcur: 1439 xfs_btree_del_cursor(rcur, XFS_BTREE_ERROR); 1440 return error; 1441 } 1442 1443 /* 1444 * Use the free inode btree to find a free inode based on a newino hint. If 1445 * the hint is NULL, find the first free inode in the AG. 1446 */ 1447 STATIC int 1448 xfs_dialloc_ag_finobt_newino( 1449 struct xfs_agi *agi, 1450 struct xfs_btree_cur *cur, 1451 struct xfs_inobt_rec_incore *rec) 1452 { 1453 int error; 1454 int i; 1455 1456 if (agi->agi_newino != cpu_to_be32(NULLAGINO)) { 1457 error = xfs_inobt_lookup(cur, be32_to_cpu(agi->agi_newino), 1458 XFS_LOOKUP_EQ, &i); 1459 if (error) 1460 return error; 1461 if (i == 1) { 1462 error = xfs_inobt_get_rec(cur, rec, &i); 1463 if (error) 1464 return error; 1465 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1466 return 0; 1467 } 1468 } 1469 1470 /* 1471 * Find the first inode available in the AG. 1472 */ 1473 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); 1474 if (error) 1475 return error; 1476 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1477 1478 error = xfs_inobt_get_rec(cur, rec, &i); 1479 if (error) 1480 return error; 1481 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1482 1483 return 0; 1484 } 1485 1486 /* 1487 * Update the inobt based on a modification made to the finobt. Also ensure that 1488 * the records from both trees are equivalent post-modification. 1489 */ 1490 STATIC int 1491 xfs_dialloc_ag_update_inobt( 1492 struct xfs_btree_cur *cur, /* inobt cursor */ 1493 struct xfs_inobt_rec_incore *frec, /* finobt record */ 1494 int offset) /* inode offset */ 1495 { 1496 struct xfs_inobt_rec_incore rec; 1497 int error; 1498 int i; 1499 1500 error = xfs_inobt_lookup(cur, frec->ir_startino, XFS_LOOKUP_EQ, &i); 1501 if (error) 1502 return error; 1503 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1504 1505 error = xfs_inobt_get_rec(cur, &rec, &i); 1506 if (error) 1507 return error; 1508 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, i == 1); 1509 ASSERT((XFS_AGINO_TO_OFFSET(cur->bc_mp, rec.ir_startino) % 1510 XFS_INODES_PER_CHUNK) == 0); 1511 1512 rec.ir_free &= ~XFS_INOBT_MASK(offset); 1513 rec.ir_freecount--; 1514 1515 XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, (rec.ir_free == frec->ir_free) && 1516 (rec.ir_freecount == frec->ir_freecount)); 1517 1518 return xfs_inobt_update(cur, &rec); 1519 } 1520 1521 /* 1522 * Allocate an inode using the free inode btree, if available. Otherwise, fall 1523 * back to the inobt search algorithm. 1524 * 1525 * The caller selected an AG for us, and made sure that free inodes are 1526 * available. 1527 */ 1528 STATIC int 1529 xfs_dialloc_ag( 1530 struct xfs_trans *tp, 1531 struct xfs_buf *agbp, 1532 xfs_ino_t parent, 1533 xfs_ino_t *inop) 1534 { 1535 struct xfs_mount *mp = tp->t_mountp; 1536 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 1537 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 1538 xfs_agnumber_t pagno = XFS_INO_TO_AGNO(mp, parent); 1539 xfs_agino_t pagino = XFS_INO_TO_AGINO(mp, parent); 1540 struct xfs_perag *pag; 1541 struct xfs_btree_cur *cur; /* finobt cursor */ 1542 struct xfs_btree_cur *icur; /* inobt cursor */ 1543 struct xfs_inobt_rec_incore rec; 1544 xfs_ino_t ino; 1545 int error; 1546 int offset; 1547 int i; 1548 1549 if (!xfs_sb_version_hasfinobt(&mp->m_sb)) 1550 return xfs_dialloc_ag_inobt(tp, agbp, parent, inop); 1551 1552 pag = xfs_perag_get(mp, agno); 1553 1554 /* 1555 * If pagino is 0 (this is the root inode allocation) use newino. 1556 * This must work because we've just allocated some. 1557 */ 1558 if (!pagino) 1559 pagino = be32_to_cpu(agi->agi_newino); 1560 1561 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_FINO); 1562 1563 error = xfs_check_agi_freecount(cur, agi); 1564 if (error) 1565 goto error_cur; 1566 1567 /* 1568 * The search algorithm depends on whether we're in the same AG as the 1569 * parent. If so, find the closest available inode to the parent. If 1570 * not, consider the agi hint or find the first free inode in the AG. 1571 */ 1572 if (agno == pagno) 1573 error = xfs_dialloc_ag_finobt_near(pagino, &cur, &rec); 1574 else 1575 error = xfs_dialloc_ag_finobt_newino(agi, cur, &rec); 1576 if (error) 1577 goto error_cur; 1578 1579 offset = xfs_inobt_first_free_inode(&rec); 1580 ASSERT(offset >= 0); 1581 ASSERT(offset < XFS_INODES_PER_CHUNK); 1582 ASSERT((XFS_AGINO_TO_OFFSET(mp, rec.ir_startino) % 1583 XFS_INODES_PER_CHUNK) == 0); 1584 ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino + offset); 1585 1586 /* 1587 * Modify or remove the finobt record. 1588 */ 1589 rec.ir_free &= ~XFS_INOBT_MASK(offset); 1590 rec.ir_freecount--; 1591 if (rec.ir_freecount) 1592 error = xfs_inobt_update(cur, &rec); 1593 else 1594 error = xfs_btree_delete(cur, &i); 1595 if (error) 1596 goto error_cur; 1597 1598 /* 1599 * The finobt has now been updated appropriately. We haven't updated the 1600 * agi and superblock yet, so we can create an inobt cursor and validate 1601 * the original freecount. If all is well, make the equivalent update to 1602 * the inobt using the finobt record and offset information. 1603 */ 1604 icur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_INO); 1605 1606 error = xfs_check_agi_freecount(icur, agi); 1607 if (error) 1608 goto error_icur; 1609 1610 error = xfs_dialloc_ag_update_inobt(icur, &rec, offset); 1611 if (error) 1612 goto error_icur; 1613 1614 /* 1615 * Both trees have now been updated. We must update the perag and 1616 * superblock before we can check the freecount for each btree. 1617 */ 1618 be32_add_cpu(&agi->agi_freecount, -1); 1619 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT); 1620 pag->pagi_freecount--; 1621 1622 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -1); 1623 1624 error = xfs_check_agi_freecount(icur, agi); 1625 if (error) 1626 goto error_icur; 1627 error = xfs_check_agi_freecount(cur, agi); 1628 if (error) 1629 goto error_icur; 1630 1631 xfs_btree_del_cursor(icur, XFS_BTREE_NOERROR); 1632 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 1633 xfs_perag_put(pag); 1634 *inop = ino; 1635 return 0; 1636 1637 error_icur: 1638 xfs_btree_del_cursor(icur, XFS_BTREE_ERROR); 1639 error_cur: 1640 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 1641 xfs_perag_put(pag); 1642 return error; 1643 } 1644 1645 /* 1646 * Allocate an inode on disk. 1647 * 1648 * Mode is used to tell whether the new inode will need space, and whether it 1649 * is a directory. 1650 * 1651 * This function is designed to be called twice if it has to do an allocation 1652 * to make more free inodes. On the first call, *IO_agbp should be set to NULL. 1653 * If an inode is available without having to performn an allocation, an inode 1654 * number is returned. In this case, *IO_agbp is set to NULL. If an allocation 1655 * needs to be done, xfs_dialloc returns the current AGI buffer in *IO_agbp. 1656 * The caller should then commit the current transaction, allocate a 1657 * new transaction, and call xfs_dialloc() again, passing in the previous value 1658 * of *IO_agbp. IO_agbp should be held across the transactions. Since the AGI 1659 * buffer is locked across the two calls, the second call is guaranteed to have 1660 * a free inode available. 1661 * 1662 * Once we successfully pick an inode its number is returned and the on-disk 1663 * data structures are updated. The inode itself is not read in, since doing so 1664 * would break ordering constraints with xfs_reclaim. 1665 */ 1666 int 1667 xfs_dialloc( 1668 struct xfs_trans *tp, 1669 xfs_ino_t parent, 1670 umode_t mode, 1671 int okalloc, 1672 struct xfs_buf **IO_agbp, 1673 xfs_ino_t *inop) 1674 { 1675 struct xfs_mount *mp = tp->t_mountp; 1676 struct xfs_buf *agbp; 1677 xfs_agnumber_t agno; 1678 int error; 1679 int ialloced; 1680 int noroom = 0; 1681 xfs_agnumber_t start_agno; 1682 struct xfs_perag *pag; 1683 1684 if (*IO_agbp) { 1685 /* 1686 * If the caller passes in a pointer to the AGI buffer, 1687 * continue where we left off before. In this case, we 1688 * know that the allocation group has free inodes. 1689 */ 1690 agbp = *IO_agbp; 1691 goto out_alloc; 1692 } 1693 1694 /* 1695 * We do not have an agbp, so select an initial allocation 1696 * group for inode allocation. 1697 */ 1698 start_agno = xfs_ialloc_ag_select(tp, parent, mode, okalloc); 1699 if (start_agno == NULLAGNUMBER) { 1700 *inop = NULLFSINO; 1701 return 0; 1702 } 1703 1704 /* 1705 * If we have already hit the ceiling of inode blocks then clear 1706 * okalloc so we scan all available agi structures for a free 1707 * inode. 1708 * 1709 * Read rough value of mp->m_icount by percpu_counter_read_positive, 1710 * which will sacrifice the preciseness but improve the performance. 1711 */ 1712 if (mp->m_maxicount && 1713 percpu_counter_read_positive(&mp->m_icount) + mp->m_ialloc_inos 1714 > mp->m_maxicount) { 1715 noroom = 1; 1716 okalloc = 0; 1717 } 1718 1719 /* 1720 * Loop until we find an allocation group that either has free inodes 1721 * or in which we can allocate some inodes. Iterate through the 1722 * allocation groups upward, wrapping at the end. 1723 */ 1724 agno = start_agno; 1725 for (;;) { 1726 pag = xfs_perag_get(mp, agno); 1727 if (!pag->pagi_inodeok) { 1728 xfs_ialloc_next_ag(mp); 1729 goto nextag; 1730 } 1731 1732 if (!pag->pagi_init) { 1733 error = xfs_ialloc_pagi_init(mp, tp, agno); 1734 if (error) 1735 goto out_error; 1736 } 1737 1738 /* 1739 * Do a first racy fast path check if this AG is usable. 1740 */ 1741 if (!pag->pagi_freecount && !okalloc) 1742 goto nextag; 1743 1744 /* 1745 * Then read in the AGI buffer and recheck with the AGI buffer 1746 * lock held. 1747 */ 1748 error = xfs_ialloc_read_agi(mp, tp, agno, &agbp); 1749 if (error) 1750 goto out_error; 1751 1752 if (pag->pagi_freecount) { 1753 xfs_perag_put(pag); 1754 goto out_alloc; 1755 } 1756 1757 if (!okalloc) 1758 goto nextag_relse_buffer; 1759 1760 1761 error = xfs_ialloc_ag_alloc(tp, agbp, &ialloced); 1762 if (error) { 1763 xfs_trans_brelse(tp, agbp); 1764 1765 if (error != -ENOSPC) 1766 goto out_error; 1767 1768 xfs_perag_put(pag); 1769 *inop = NULLFSINO; 1770 return 0; 1771 } 1772 1773 if (ialloced) { 1774 /* 1775 * We successfully allocated some inodes, return 1776 * the current context to the caller so that it 1777 * can commit the current transaction and call 1778 * us again where we left off. 1779 */ 1780 ASSERT(pag->pagi_freecount > 0); 1781 xfs_perag_put(pag); 1782 1783 *IO_agbp = agbp; 1784 *inop = NULLFSINO; 1785 return 0; 1786 } 1787 1788 nextag_relse_buffer: 1789 xfs_trans_brelse(tp, agbp); 1790 nextag: 1791 xfs_perag_put(pag); 1792 if (++agno == mp->m_sb.sb_agcount) 1793 agno = 0; 1794 if (agno == start_agno) { 1795 *inop = NULLFSINO; 1796 return noroom ? -ENOSPC : 0; 1797 } 1798 } 1799 1800 out_alloc: 1801 *IO_agbp = NULL; 1802 return xfs_dialloc_ag(tp, agbp, parent, inop); 1803 out_error: 1804 xfs_perag_put(pag); 1805 return error; 1806 } 1807 1808 /* 1809 * Free the blocks of an inode chunk. We must consider that the inode chunk 1810 * might be sparse and only free the regions that are allocated as part of the 1811 * chunk. 1812 */ 1813 STATIC void 1814 xfs_difree_inode_chunk( 1815 struct xfs_mount *mp, 1816 xfs_agnumber_t agno, 1817 struct xfs_inobt_rec_incore *rec, 1818 struct xfs_bmap_free *flist) 1819 { 1820 xfs_agblock_t sagbno = XFS_AGINO_TO_AGBNO(mp, rec->ir_startino); 1821 int startidx, endidx; 1822 int nextbit; 1823 xfs_agblock_t agbno; 1824 int contigblk; 1825 DECLARE_BITMAP(holemask, XFS_INOBT_HOLEMASK_BITS); 1826 1827 if (!xfs_inobt_issparse(rec->ir_holemask)) { 1828 /* not sparse, calculate extent info directly */ 1829 xfs_bmap_add_free(XFS_AGB_TO_FSB(mp, agno, 1830 XFS_AGINO_TO_AGBNO(mp, rec->ir_startino)), 1831 mp->m_ialloc_blks, flist, mp); 1832 return; 1833 } 1834 1835 /* holemask is only 16-bits (fits in an unsigned long) */ 1836 ASSERT(sizeof(rec->ir_holemask) <= sizeof(holemask[0])); 1837 holemask[0] = rec->ir_holemask; 1838 1839 /* 1840 * Find contiguous ranges of zeroes (i.e., allocated regions) in the 1841 * holemask and convert the start/end index of each range to an extent. 1842 * We start with the start and end index both pointing at the first 0 in 1843 * the mask. 1844 */ 1845 startidx = endidx = find_first_zero_bit(holemask, 1846 XFS_INOBT_HOLEMASK_BITS); 1847 nextbit = startidx + 1; 1848 while (startidx < XFS_INOBT_HOLEMASK_BITS) { 1849 nextbit = find_next_zero_bit(holemask, XFS_INOBT_HOLEMASK_BITS, 1850 nextbit); 1851 /* 1852 * If the next zero bit is contiguous, update the end index of 1853 * the current range and continue. 1854 */ 1855 if (nextbit != XFS_INOBT_HOLEMASK_BITS && 1856 nextbit == endidx + 1) { 1857 endidx = nextbit; 1858 goto next; 1859 } 1860 1861 /* 1862 * nextbit is not contiguous with the current end index. Convert 1863 * the current start/end to an extent and add it to the free 1864 * list. 1865 */ 1866 agbno = sagbno + (startidx * XFS_INODES_PER_HOLEMASK_BIT) / 1867 mp->m_sb.sb_inopblock; 1868 contigblk = ((endidx - startidx + 1) * 1869 XFS_INODES_PER_HOLEMASK_BIT) / 1870 mp->m_sb.sb_inopblock; 1871 1872 ASSERT(agbno % mp->m_sb.sb_spino_align == 0); 1873 ASSERT(contigblk % mp->m_sb.sb_spino_align == 0); 1874 xfs_bmap_add_free(XFS_AGB_TO_FSB(mp, agno, agbno), contigblk, 1875 flist, mp); 1876 1877 /* reset range to current bit and carry on... */ 1878 startidx = endidx = nextbit; 1879 1880 next: 1881 nextbit++; 1882 } 1883 } 1884 1885 STATIC int 1886 xfs_difree_inobt( 1887 struct xfs_mount *mp, 1888 struct xfs_trans *tp, 1889 struct xfs_buf *agbp, 1890 xfs_agino_t agino, 1891 struct xfs_bmap_free *flist, 1892 struct xfs_icluster *xic, 1893 struct xfs_inobt_rec_incore *orec) 1894 { 1895 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 1896 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 1897 struct xfs_perag *pag; 1898 struct xfs_btree_cur *cur; 1899 struct xfs_inobt_rec_incore rec; 1900 int ilen; 1901 int error; 1902 int i; 1903 int off; 1904 1905 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC)); 1906 ASSERT(XFS_AGINO_TO_AGBNO(mp, agino) < be32_to_cpu(agi->agi_length)); 1907 1908 /* 1909 * Initialize the cursor. 1910 */ 1911 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_INO); 1912 1913 error = xfs_check_agi_freecount(cur, agi); 1914 if (error) 1915 goto error0; 1916 1917 /* 1918 * Look for the entry describing this inode. 1919 */ 1920 if ((error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &i))) { 1921 xfs_warn(mp, "%s: xfs_inobt_lookup() returned error %d.", 1922 __func__, error); 1923 goto error0; 1924 } 1925 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1926 error = xfs_inobt_get_rec(cur, &rec, &i); 1927 if (error) { 1928 xfs_warn(mp, "%s: xfs_inobt_get_rec() returned error %d.", 1929 __func__, error); 1930 goto error0; 1931 } 1932 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error0); 1933 /* 1934 * Get the offset in the inode chunk. 1935 */ 1936 off = agino - rec.ir_startino; 1937 ASSERT(off >= 0 && off < XFS_INODES_PER_CHUNK); 1938 ASSERT(!(rec.ir_free & XFS_INOBT_MASK(off))); 1939 /* 1940 * Mark the inode free & increment the count. 1941 */ 1942 rec.ir_free |= XFS_INOBT_MASK(off); 1943 rec.ir_freecount++; 1944 1945 /* 1946 * When an inode chunk is free, it becomes eligible for removal. Don't 1947 * remove the chunk if the block size is large enough for multiple inode 1948 * chunks (that might not be free). 1949 */ 1950 if (!(mp->m_flags & XFS_MOUNT_IKEEP) && 1951 rec.ir_free == XFS_INOBT_ALL_FREE && 1952 mp->m_sb.sb_inopblock <= XFS_INODES_PER_CHUNK) { 1953 xic->deleted = 1; 1954 xic->first_ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino); 1955 xic->alloc = xfs_inobt_irec_to_allocmask(&rec); 1956 1957 /* 1958 * Remove the inode cluster from the AGI B+Tree, adjust the 1959 * AGI and Superblock inode counts, and mark the disk space 1960 * to be freed when the transaction is committed. 1961 */ 1962 ilen = rec.ir_freecount; 1963 be32_add_cpu(&agi->agi_count, -ilen); 1964 be32_add_cpu(&agi->agi_freecount, -(ilen - 1)); 1965 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_COUNT | XFS_AGI_FREECOUNT); 1966 pag = xfs_perag_get(mp, agno); 1967 pag->pagi_freecount -= ilen - 1; 1968 xfs_perag_put(pag); 1969 xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, -ilen); 1970 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -(ilen - 1)); 1971 1972 if ((error = xfs_btree_delete(cur, &i))) { 1973 xfs_warn(mp, "%s: xfs_btree_delete returned error %d.", 1974 __func__, error); 1975 goto error0; 1976 } 1977 1978 xfs_difree_inode_chunk(mp, agno, &rec, flist); 1979 } else { 1980 xic->deleted = 0; 1981 1982 error = xfs_inobt_update(cur, &rec); 1983 if (error) { 1984 xfs_warn(mp, "%s: xfs_inobt_update returned error %d.", 1985 __func__, error); 1986 goto error0; 1987 } 1988 1989 /* 1990 * Change the inode free counts and log the ag/sb changes. 1991 */ 1992 be32_add_cpu(&agi->agi_freecount, 1); 1993 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT); 1994 pag = xfs_perag_get(mp, agno); 1995 pag->pagi_freecount++; 1996 xfs_perag_put(pag); 1997 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, 1); 1998 } 1999 2000 error = xfs_check_agi_freecount(cur, agi); 2001 if (error) 2002 goto error0; 2003 2004 *orec = rec; 2005 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 2006 return 0; 2007 2008 error0: 2009 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 2010 return error; 2011 } 2012 2013 /* 2014 * Free an inode in the free inode btree. 2015 */ 2016 STATIC int 2017 xfs_difree_finobt( 2018 struct xfs_mount *mp, 2019 struct xfs_trans *tp, 2020 struct xfs_buf *agbp, 2021 xfs_agino_t agino, 2022 struct xfs_inobt_rec_incore *ibtrec) /* inobt record */ 2023 { 2024 struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); 2025 xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); 2026 struct xfs_btree_cur *cur; 2027 struct xfs_inobt_rec_incore rec; 2028 int offset = agino - ibtrec->ir_startino; 2029 int error; 2030 int i; 2031 2032 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_FINO); 2033 2034 error = xfs_inobt_lookup(cur, ibtrec->ir_startino, XFS_LOOKUP_EQ, &i); 2035 if (error) 2036 goto error; 2037 if (i == 0) { 2038 /* 2039 * If the record does not exist in the finobt, we must have just 2040 * freed an inode in a previously fully allocated chunk. If not, 2041 * something is out of sync. 2042 */ 2043 XFS_WANT_CORRUPTED_GOTO(mp, ibtrec->ir_freecount == 1, error); 2044 2045 error = xfs_inobt_insert_rec(cur, ibtrec->ir_holemask, 2046 ibtrec->ir_count, 2047 ibtrec->ir_freecount, 2048 ibtrec->ir_free, &i); 2049 if (error) 2050 goto error; 2051 ASSERT(i == 1); 2052 2053 goto out; 2054 } 2055 2056 /* 2057 * Read and update the existing record. We could just copy the ibtrec 2058 * across here, but that would defeat the purpose of having redundant 2059 * metadata. By making the modifications independently, we can catch 2060 * corruptions that we wouldn't see if we just copied from one record 2061 * to another. 2062 */ 2063 error = xfs_inobt_get_rec(cur, &rec, &i); 2064 if (error) 2065 goto error; 2066 XFS_WANT_CORRUPTED_GOTO(mp, i == 1, error); 2067 2068 rec.ir_free |= XFS_INOBT_MASK(offset); 2069 rec.ir_freecount++; 2070 2071 XFS_WANT_CORRUPTED_GOTO(mp, (rec.ir_free == ibtrec->ir_free) && 2072 (rec.ir_freecount == ibtrec->ir_freecount), 2073 error); 2074 2075 /* 2076 * The content of inobt records should always match between the inobt 2077 * and finobt. The lifecycle of records in the finobt is different from 2078 * the inobt in that the finobt only tracks records with at least one 2079 * free inode. Hence, if all of the inodes are free and we aren't 2080 * keeping inode chunks permanently on disk, remove the record. 2081 * Otherwise, update the record with the new information. 2082 * 2083 * Note that we currently can't free chunks when the block size is large 2084 * enough for multiple chunks. Leave the finobt record to remain in sync 2085 * with the inobt. 2086 */ 2087 if (rec.ir_free == XFS_INOBT_ALL_FREE && 2088 mp->m_sb.sb_inopblock <= XFS_INODES_PER_CHUNK && 2089 !(mp->m_flags & XFS_MOUNT_IKEEP)) { 2090 error = xfs_btree_delete(cur, &i); 2091 if (error) 2092 goto error; 2093 ASSERT(i == 1); 2094 } else { 2095 error = xfs_inobt_update(cur, &rec); 2096 if (error) 2097 goto error; 2098 } 2099 2100 out: 2101 error = xfs_check_agi_freecount(cur, agi); 2102 if (error) 2103 goto error; 2104 2105 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 2106 return 0; 2107 2108 error: 2109 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); 2110 return error; 2111 } 2112 2113 /* 2114 * Free disk inode. Carefully avoids touching the incore inode, all 2115 * manipulations incore are the caller's responsibility. 2116 * The on-disk inode is not changed by this operation, only the 2117 * btree (free inode mask) is changed. 2118 */ 2119 int 2120 xfs_difree( 2121 struct xfs_trans *tp, /* transaction pointer */ 2122 xfs_ino_t inode, /* inode to be freed */ 2123 struct xfs_bmap_free *flist, /* extents to free */ 2124 struct xfs_icluster *xic) /* cluster info if deleted */ 2125 { 2126 /* REFERENCED */ 2127 xfs_agblock_t agbno; /* block number containing inode */ 2128 struct xfs_buf *agbp; /* buffer for allocation group header */ 2129 xfs_agino_t agino; /* allocation group inode number */ 2130 xfs_agnumber_t agno; /* allocation group number */ 2131 int error; /* error return value */ 2132 struct xfs_mount *mp; /* mount structure for filesystem */ 2133 struct xfs_inobt_rec_incore rec;/* btree record */ 2134 2135 mp = tp->t_mountp; 2136 2137 /* 2138 * Break up inode number into its components. 2139 */ 2140 agno = XFS_INO_TO_AGNO(mp, inode); 2141 if (agno >= mp->m_sb.sb_agcount) { 2142 xfs_warn(mp, "%s: agno >= mp->m_sb.sb_agcount (%d >= %d).", 2143 __func__, agno, mp->m_sb.sb_agcount); 2144 ASSERT(0); 2145 return -EINVAL; 2146 } 2147 agino = XFS_INO_TO_AGINO(mp, inode); 2148 if (inode != XFS_AGINO_TO_INO(mp, agno, agino)) { 2149 xfs_warn(mp, "%s: inode != XFS_AGINO_TO_INO() (%llu != %llu).", 2150 __func__, (unsigned long long)inode, 2151 (unsigned long long)XFS_AGINO_TO_INO(mp, agno, agino)); 2152 ASSERT(0); 2153 return -EINVAL; 2154 } 2155 agbno = XFS_AGINO_TO_AGBNO(mp, agino); 2156 if (agbno >= mp->m_sb.sb_agblocks) { 2157 xfs_warn(mp, "%s: agbno >= mp->m_sb.sb_agblocks (%d >= %d).", 2158 __func__, agbno, mp->m_sb.sb_agblocks); 2159 ASSERT(0); 2160 return -EINVAL; 2161 } 2162 /* 2163 * Get the allocation group header. 2164 */ 2165 error = xfs_ialloc_read_agi(mp, tp, agno, &agbp); 2166 if (error) { 2167 xfs_warn(mp, "%s: xfs_ialloc_read_agi() returned error %d.", 2168 __func__, error); 2169 return error; 2170 } 2171 2172 /* 2173 * Fix up the inode allocation btree. 2174 */ 2175 error = xfs_difree_inobt(mp, tp, agbp, agino, flist, xic, &rec); 2176 if (error) 2177 goto error0; 2178 2179 /* 2180 * Fix up the free inode btree. 2181 */ 2182 if (xfs_sb_version_hasfinobt(&mp->m_sb)) { 2183 error = xfs_difree_finobt(mp, tp, agbp, agino, &rec); 2184 if (error) 2185 goto error0; 2186 } 2187 2188 return 0; 2189 2190 error0: 2191 return error; 2192 } 2193 2194 STATIC int 2195 xfs_imap_lookup( 2196 struct xfs_mount *mp, 2197 struct xfs_trans *tp, 2198 xfs_agnumber_t agno, 2199 xfs_agino_t agino, 2200 xfs_agblock_t agbno, 2201 xfs_agblock_t *chunk_agbno, 2202 xfs_agblock_t *offset_agbno, 2203 int flags) 2204 { 2205 struct xfs_inobt_rec_incore rec; 2206 struct xfs_btree_cur *cur; 2207 struct xfs_buf *agbp; 2208 int error; 2209 int i; 2210 2211 error = xfs_ialloc_read_agi(mp, tp, agno, &agbp); 2212 if (error) { 2213 xfs_alert(mp, 2214 "%s: xfs_ialloc_read_agi() returned error %d, agno %d", 2215 __func__, error, agno); 2216 return error; 2217 } 2218 2219 /* 2220 * Lookup the inode record for the given agino. If the record cannot be 2221 * found, then it's an invalid inode number and we should abort. Once 2222 * we have a record, we need to ensure it contains the inode number 2223 * we are looking up. 2224 */ 2225 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_INO); 2226 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &i); 2227 if (!error) { 2228 if (i) 2229 error = xfs_inobt_get_rec(cur, &rec, &i); 2230 if (!error && i == 0) 2231 error = -EINVAL; 2232 } 2233 2234 xfs_trans_brelse(tp, agbp); 2235 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); 2236 if (error) 2237 return error; 2238 2239 /* check that the returned record contains the required inode */ 2240 if (rec.ir_startino > agino || 2241 rec.ir_startino + mp->m_ialloc_inos <= agino) 2242 return -EINVAL; 2243 2244 /* for untrusted inodes check it is allocated first */ 2245 if ((flags & XFS_IGET_UNTRUSTED) && 2246 (rec.ir_free & XFS_INOBT_MASK(agino - rec.ir_startino))) 2247 return -EINVAL; 2248 2249 *chunk_agbno = XFS_AGINO_TO_AGBNO(mp, rec.ir_startino); 2250 *offset_agbno = agbno - *chunk_agbno; 2251 return 0; 2252 } 2253 2254 /* 2255 * Return the location of the inode in imap, for mapping it into a buffer. 2256 */ 2257 int 2258 xfs_imap( 2259 xfs_mount_t *mp, /* file system mount structure */ 2260 xfs_trans_t *tp, /* transaction pointer */ 2261 xfs_ino_t ino, /* inode to locate */ 2262 struct xfs_imap *imap, /* location map structure */ 2263 uint flags) /* flags for inode btree lookup */ 2264 { 2265 xfs_agblock_t agbno; /* block number of inode in the alloc group */ 2266 xfs_agino_t agino; /* inode number within alloc group */ 2267 xfs_agnumber_t agno; /* allocation group number */ 2268 int blks_per_cluster; /* num blocks per inode cluster */ 2269 xfs_agblock_t chunk_agbno; /* first block in inode chunk */ 2270 xfs_agblock_t cluster_agbno; /* first block in inode cluster */ 2271 int error; /* error code */ 2272 int offset; /* index of inode in its buffer */ 2273 xfs_agblock_t offset_agbno; /* blks from chunk start to inode */ 2274 2275 ASSERT(ino != NULLFSINO); 2276 2277 /* 2278 * Split up the inode number into its parts. 2279 */ 2280 agno = XFS_INO_TO_AGNO(mp, ino); 2281 agino = XFS_INO_TO_AGINO(mp, ino); 2282 agbno = XFS_AGINO_TO_AGBNO(mp, agino); 2283 if (agno >= mp->m_sb.sb_agcount || agbno >= mp->m_sb.sb_agblocks || 2284 ino != XFS_AGINO_TO_INO(mp, agno, agino)) { 2285 #ifdef DEBUG 2286 /* 2287 * Don't output diagnostic information for untrusted inodes 2288 * as they can be invalid without implying corruption. 2289 */ 2290 if (flags & XFS_IGET_UNTRUSTED) 2291 return -EINVAL; 2292 if (agno >= mp->m_sb.sb_agcount) { 2293 xfs_alert(mp, 2294 "%s: agno (%d) >= mp->m_sb.sb_agcount (%d)", 2295 __func__, agno, mp->m_sb.sb_agcount); 2296 } 2297 if (agbno >= mp->m_sb.sb_agblocks) { 2298 xfs_alert(mp, 2299 "%s: agbno (0x%llx) >= mp->m_sb.sb_agblocks (0x%lx)", 2300 __func__, (unsigned long long)agbno, 2301 (unsigned long)mp->m_sb.sb_agblocks); 2302 } 2303 if (ino != XFS_AGINO_TO_INO(mp, agno, agino)) { 2304 xfs_alert(mp, 2305 "%s: ino (0x%llx) != XFS_AGINO_TO_INO() (0x%llx)", 2306 __func__, ino, 2307 XFS_AGINO_TO_INO(mp, agno, agino)); 2308 } 2309 xfs_stack_trace(); 2310 #endif /* DEBUG */ 2311 return -EINVAL; 2312 } 2313 2314 blks_per_cluster = xfs_icluster_size_fsb(mp); 2315 2316 /* 2317 * For bulkstat and handle lookups, we have an untrusted inode number 2318 * that we have to verify is valid. We cannot do this just by reading 2319 * the inode buffer as it may have been unlinked and removed leaving 2320 * inodes in stale state on disk. Hence we have to do a btree lookup 2321 * in all cases where an untrusted inode number is passed. 2322 */ 2323 if (flags & XFS_IGET_UNTRUSTED) { 2324 error = xfs_imap_lookup(mp, tp, agno, agino, agbno, 2325 &chunk_agbno, &offset_agbno, flags); 2326 if (error) 2327 return error; 2328 goto out_map; 2329 } 2330 2331 /* 2332 * If the inode cluster size is the same as the blocksize or 2333 * smaller we get to the buffer by simple arithmetics. 2334 */ 2335 if (blks_per_cluster == 1) { 2336 offset = XFS_INO_TO_OFFSET(mp, ino); 2337 ASSERT(offset < mp->m_sb.sb_inopblock); 2338 2339 imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, agbno); 2340 imap->im_len = XFS_FSB_TO_BB(mp, 1); 2341 imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog); 2342 return 0; 2343 } 2344 2345 /* 2346 * If the inode chunks are aligned then use simple maths to 2347 * find the location. Otherwise we have to do a btree 2348 * lookup to find the location. 2349 */ 2350 if (mp->m_inoalign_mask) { 2351 offset_agbno = agbno & mp->m_inoalign_mask; 2352 chunk_agbno = agbno - offset_agbno; 2353 } else { 2354 error = xfs_imap_lookup(mp, tp, agno, agino, agbno, 2355 &chunk_agbno, &offset_agbno, flags); 2356 if (error) 2357 return error; 2358 } 2359 2360 out_map: 2361 ASSERT(agbno >= chunk_agbno); 2362 cluster_agbno = chunk_agbno + 2363 ((offset_agbno / blks_per_cluster) * blks_per_cluster); 2364 offset = ((agbno - cluster_agbno) * mp->m_sb.sb_inopblock) + 2365 XFS_INO_TO_OFFSET(mp, ino); 2366 2367 imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, cluster_agbno); 2368 imap->im_len = XFS_FSB_TO_BB(mp, blks_per_cluster); 2369 imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog); 2370 2371 /* 2372 * If the inode number maps to a block outside the bounds 2373 * of the file system then return NULL rather than calling 2374 * read_buf and panicing when we get an error from the 2375 * driver. 2376 */ 2377 if ((imap->im_blkno + imap->im_len) > 2378 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) { 2379 xfs_alert(mp, 2380 "%s: (im_blkno (0x%llx) + im_len (0x%llx)) > sb_dblocks (0x%llx)", 2381 __func__, (unsigned long long) imap->im_blkno, 2382 (unsigned long long) imap->im_len, 2383 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)); 2384 return -EINVAL; 2385 } 2386 return 0; 2387 } 2388 2389 /* 2390 * Compute and fill in value of m_in_maxlevels. 2391 */ 2392 void 2393 xfs_ialloc_compute_maxlevels( 2394 xfs_mount_t *mp) /* file system mount structure */ 2395 { 2396 int level; 2397 uint maxblocks; 2398 uint maxleafents; 2399 int minleafrecs; 2400 int minnoderecs; 2401 2402 maxleafents = (1LL << XFS_INO_AGINO_BITS(mp)) >> 2403 XFS_INODES_PER_CHUNK_LOG; 2404 minleafrecs = mp->m_alloc_mnr[0]; 2405 minnoderecs = mp->m_alloc_mnr[1]; 2406 maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs; 2407 for (level = 1; maxblocks > 1; level++) 2408 maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs; 2409 mp->m_in_maxlevels = level; 2410 } 2411 2412 /* 2413 * Log specified fields for the ag hdr (inode section). The growth of the agi 2414 * structure over time requires that we interpret the buffer as two logical 2415 * regions delineated by the end of the unlinked list. This is due to the size 2416 * of the hash table and its location in the middle of the agi. 2417 * 2418 * For example, a request to log a field before agi_unlinked and a field after 2419 * agi_unlinked could cause us to log the entire hash table and use an excessive 2420 * amount of log space. To avoid this behavior, log the region up through 2421 * agi_unlinked in one call and the region after agi_unlinked through the end of 2422 * the structure in another. 2423 */ 2424 void 2425 xfs_ialloc_log_agi( 2426 xfs_trans_t *tp, /* transaction pointer */ 2427 xfs_buf_t *bp, /* allocation group header buffer */ 2428 int fields) /* bitmask of fields to log */ 2429 { 2430 int first; /* first byte number */ 2431 int last; /* last byte number */ 2432 static const short offsets[] = { /* field starting offsets */ 2433 /* keep in sync with bit definitions */ 2434 offsetof(xfs_agi_t, agi_magicnum), 2435 offsetof(xfs_agi_t, agi_versionnum), 2436 offsetof(xfs_agi_t, agi_seqno), 2437 offsetof(xfs_agi_t, agi_length), 2438 offsetof(xfs_agi_t, agi_count), 2439 offsetof(xfs_agi_t, agi_root), 2440 offsetof(xfs_agi_t, agi_level), 2441 offsetof(xfs_agi_t, agi_freecount), 2442 offsetof(xfs_agi_t, agi_newino), 2443 offsetof(xfs_agi_t, agi_dirino), 2444 offsetof(xfs_agi_t, agi_unlinked), 2445 offsetof(xfs_agi_t, agi_free_root), 2446 offsetof(xfs_agi_t, agi_free_level), 2447 sizeof(xfs_agi_t) 2448 }; 2449 #ifdef DEBUG 2450 xfs_agi_t *agi; /* allocation group header */ 2451 2452 agi = XFS_BUF_TO_AGI(bp); 2453 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC)); 2454 #endif 2455 2456 xfs_trans_buf_set_type(tp, bp, XFS_BLFT_AGI_BUF); 2457 2458 /* 2459 * Compute byte offsets for the first and last fields in the first 2460 * region and log the agi buffer. This only logs up through 2461 * agi_unlinked. 2462 */ 2463 if (fields & XFS_AGI_ALL_BITS_R1) { 2464 xfs_btree_offsets(fields, offsets, XFS_AGI_NUM_BITS_R1, 2465 &first, &last); 2466 xfs_trans_log_buf(tp, bp, first, last); 2467 } 2468 2469 /* 2470 * Mask off the bits in the first region and calculate the first and 2471 * last field offsets for any bits in the second region. 2472 */ 2473 fields &= ~XFS_AGI_ALL_BITS_R1; 2474 if (fields) { 2475 xfs_btree_offsets(fields, offsets, XFS_AGI_NUM_BITS_R2, 2476 &first, &last); 2477 xfs_trans_log_buf(tp, bp, first, last); 2478 } 2479 } 2480 2481 #ifdef DEBUG 2482 STATIC void 2483 xfs_check_agi_unlinked( 2484 struct xfs_agi *agi) 2485 { 2486 int i; 2487 2488 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) 2489 ASSERT(agi->agi_unlinked[i]); 2490 } 2491 #else 2492 #define xfs_check_agi_unlinked(agi) 2493 #endif 2494 2495 static bool 2496 xfs_agi_verify( 2497 struct xfs_buf *bp) 2498 { 2499 struct xfs_mount *mp = bp->b_target->bt_mount; 2500 struct xfs_agi *agi = XFS_BUF_TO_AGI(bp); 2501 2502 if (xfs_sb_version_hascrc(&mp->m_sb) && 2503 !uuid_equal(&agi->agi_uuid, &mp->m_sb.sb_uuid)) 2504 return false; 2505 /* 2506 * Validate the magic number of the agi block. 2507 */ 2508 if (agi->agi_magicnum != cpu_to_be32(XFS_AGI_MAGIC)) 2509 return false; 2510 if (!XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum))) 2511 return false; 2512 2513 if (be32_to_cpu(agi->agi_level) > XFS_BTREE_MAXLEVELS) 2514 return false; 2515 /* 2516 * during growfs operations, the perag is not fully initialised, 2517 * so we can't use it for any useful checking. growfs ensures we can't 2518 * use it by using uncached buffers that don't have the perag attached 2519 * so we can detect and avoid this problem. 2520 */ 2521 if (bp->b_pag && be32_to_cpu(agi->agi_seqno) != bp->b_pag->pag_agno) 2522 return false; 2523 2524 xfs_check_agi_unlinked(agi); 2525 return true; 2526 } 2527 2528 static void 2529 xfs_agi_read_verify( 2530 struct xfs_buf *bp) 2531 { 2532 struct xfs_mount *mp = bp->b_target->bt_mount; 2533 2534 if (xfs_sb_version_hascrc(&mp->m_sb) && 2535 !xfs_buf_verify_cksum(bp, XFS_AGI_CRC_OFF)) 2536 xfs_buf_ioerror(bp, -EFSBADCRC); 2537 else if (XFS_TEST_ERROR(!xfs_agi_verify(bp), mp, 2538 XFS_ERRTAG_IALLOC_READ_AGI, 2539 XFS_RANDOM_IALLOC_READ_AGI)) 2540 xfs_buf_ioerror(bp, -EFSCORRUPTED); 2541 2542 if (bp->b_error) 2543 xfs_verifier_error(bp); 2544 } 2545 2546 static void 2547 xfs_agi_write_verify( 2548 struct xfs_buf *bp) 2549 { 2550 struct xfs_mount *mp = bp->b_target->bt_mount; 2551 struct xfs_buf_log_item *bip = bp->b_fspriv; 2552 2553 if (!xfs_agi_verify(bp)) { 2554 xfs_buf_ioerror(bp, -EFSCORRUPTED); 2555 xfs_verifier_error(bp); 2556 return; 2557 } 2558 2559 if (!xfs_sb_version_hascrc(&mp->m_sb)) 2560 return; 2561 2562 if (bip) 2563 XFS_BUF_TO_AGI(bp)->agi_lsn = cpu_to_be64(bip->bli_item.li_lsn); 2564 xfs_buf_update_cksum(bp, XFS_AGI_CRC_OFF); 2565 } 2566 2567 const struct xfs_buf_ops xfs_agi_buf_ops = { 2568 .verify_read = xfs_agi_read_verify, 2569 .verify_write = xfs_agi_write_verify, 2570 }; 2571 2572 /* 2573 * Read in the allocation group header (inode allocation section) 2574 */ 2575 int 2576 xfs_read_agi( 2577 struct xfs_mount *mp, /* file system mount structure */ 2578 struct xfs_trans *tp, /* transaction pointer */ 2579 xfs_agnumber_t agno, /* allocation group number */ 2580 struct xfs_buf **bpp) /* allocation group hdr buf */ 2581 { 2582 int error; 2583 2584 trace_xfs_read_agi(mp, agno); 2585 2586 ASSERT(agno != NULLAGNUMBER); 2587 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, 2588 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)), 2589 XFS_FSS_TO_BB(mp, 1), 0, bpp, &xfs_agi_buf_ops); 2590 if (error) 2591 return error; 2592 2593 xfs_buf_set_ref(*bpp, XFS_AGI_REF); 2594 return 0; 2595 } 2596 2597 int 2598 xfs_ialloc_read_agi( 2599 struct xfs_mount *mp, /* file system mount structure */ 2600 struct xfs_trans *tp, /* transaction pointer */ 2601 xfs_agnumber_t agno, /* allocation group number */ 2602 struct xfs_buf **bpp) /* allocation group hdr buf */ 2603 { 2604 struct xfs_agi *agi; /* allocation group header */ 2605 struct xfs_perag *pag; /* per allocation group data */ 2606 int error; 2607 2608 trace_xfs_ialloc_read_agi(mp, agno); 2609 2610 error = xfs_read_agi(mp, tp, agno, bpp); 2611 if (error) 2612 return error; 2613 2614 agi = XFS_BUF_TO_AGI(*bpp); 2615 pag = xfs_perag_get(mp, agno); 2616 if (!pag->pagi_init) { 2617 pag->pagi_freecount = be32_to_cpu(agi->agi_freecount); 2618 pag->pagi_count = be32_to_cpu(agi->agi_count); 2619 pag->pagi_init = 1; 2620 } 2621 2622 /* 2623 * It's possible for these to be out of sync if 2624 * we are in the middle of a forced shutdown. 2625 */ 2626 ASSERT(pag->pagi_freecount == be32_to_cpu(agi->agi_freecount) || 2627 XFS_FORCED_SHUTDOWN(mp)); 2628 xfs_perag_put(pag); 2629 return 0; 2630 } 2631 2632 /* 2633 * Read in the agi to initialise the per-ag data in the mount structure 2634 */ 2635 int 2636 xfs_ialloc_pagi_init( 2637 xfs_mount_t *mp, /* file system mount structure */ 2638 xfs_trans_t *tp, /* transaction pointer */ 2639 xfs_agnumber_t agno) /* allocation group number */ 2640 { 2641 xfs_buf_t *bp = NULL; 2642 int error; 2643 2644 error = xfs_ialloc_read_agi(mp, tp, agno, &bp); 2645 if (error) 2646 return error; 2647 if (bp) 2648 xfs_trans_brelse(tp, bp); 2649 return 0; 2650 } 2651