| blob | 69b228fce81a2b0b99cceca949fe6700c049b3de |
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
4 * All Rights Reserved.
5 */
31 /*
32 * Lookup a record by ino in the btree given by cur.
33 */
40 {
47 }
49 /*
50 * Update the record referred to by cur to the value given.
51 * This either works (return 0) or gets an EFSCORRUPTED error.
52 */
57 {
66 /* ir_holemask/ir_count not supported on-disk */
68 }
71 }
73 /* Convert on-disk btree record to incore inobt record. */
74 void
79 {
86 /*
87 * ir_holemask/ir_count not supported on-disk. Fill in hardcoded
88 * values for full inode chunks.
89 */
94 }
96 }
98 /*
99 * Get the data from the pointed-to record.
100 */
101 int
106 {
127 /* if there are no holes, return the first available offset */
130 else
137 out_bad_rec:
146 }
148 /*
149 * Insert a single inobt record. Cursor must already point to desired location.
150 */
151 int
157 xfs_inofree_t free,
159 {
165 }
167 /*
168 * Insert records describing a newly allocated inode chunk into the inobt.
169 */
170 STATIC int
175 xfs_agino_t newino,
176 xfs_agino_t newlen,
177 xfs_btnum_t btnum)
178 {
182 xfs_agino_t thisino;
195 }
199 XFS_INODES_PER_CHUNK,
200 XFS_INODES_PER_CHUNK,
205 }
207 }
212 }
214 /*
215 * Verify that the number of free inodes in the AGI is correct.
216 */
217 #ifdef DEBUG
218 STATIC int
222 {
224 xfs_inobt_rec_incore_t rec;
243 }
248 }
250 }
251 #else
252 #define xfs_check_agi_freecount(cur, agi) 0
253 #endif
255 /*
256 * Initialise a new set of inodes. When called without a transaction context
257 * (e.g. from recovery) we initiate a delayed write of the inode buffers rather
258 * than logging them (which in a transaction context puts them into the AIL
259 * for writeback rather than the xfsbufd queue).
260 */
261 int
267 xfs_agnumber_t agno,
268 xfs_agblock_t agbno,
269 xfs_agblock_t length,
271 {
277 xfs_daddr_t d;
281 /*
282 * Loop over the new block(s), filling in the inodes. For small block
283 * sizes, manipulate the inodes in buffers which are multiples of the
284 * blocks size.
285 */
288 /*
289 * Figure out what version number to use in the inodes we create. If
290 * the superblock version has caught up to the one that supports the new
291 * inode format, then use the new inode version. Otherwise use the old
292 * version so that old kernels will continue to be able to use the file
293 * system.
294 *
295 * For v3 inodes, we also need to write the inode number into the inode,
296 * so calculate the first inode number of the chunk here as
297 * XFS_AGB_TO_AGINO() only works within a filesystem block, not
298 * across multiple filesystem blocks (such as a cluster) and so cannot
299 * be used in the cluster buffer loop below.
300 *
301 * Further, because we are writing the inode directly into the buffer
302 * and calculating a CRC on the entire inode, we have ot log the entire
303 * inode so that the entire range the CRC covers is present in the log.
304 * That means for v3 inode we log the entire buffer rather than just the
305 * inode cores.
306 */
311 /*
312 * log the initialisation that is about to take place as an
313 * logical operation. This means the transaction does not
314 * need to log the physical changes to the inode buffers as log
315 * recovery will know what initialisation is actually needed.
316 * Hence we only need to log the buffers as "ordered" buffers so
317 * they track in the AIL as if they were physically logged.
318 */
326 /*
327 * Get the block.
328 */
337 /* Initialize the inode buffers and log them appropriately. */
352 ino++;
357 /* just log the inode core */
360 }
361 }
364 /*
365 * Mark the buffer as an inode allocation buffer so it
366 * sticks in AIL at the point of this allocation
367 * transaction. This ensures the they are on disk before
368 * the tail of the log can be moved past this
369 * transaction (i.e. by preventing relogging from moving
370 * it forward in the log).
371 */
374 /*
375 * Mark the buffer as ordered so that they are
376 * not physically logged in the transaction but
377 * still tracked in the AIL as part of the
378 * transaction and pin the log appropriately.
379 */
381 }
386 }
387 }
389 }
391 /*
392 * Align startino and allocmask for a recently allocated sparse chunk such that
393 * they are fit for insertion (or merge) into the on-disk inode btrees.
394 *
395 * Background:
396 *
397 * When enabled, sparse inode support increases the inode alignment from cluster
398 * size to inode chunk size. This means that the minimum range between two
399 * non-adjacent inode records in the inobt is large enough for a full inode
400 * record. This allows for cluster sized, cluster aligned block allocation
401 * without need to worry about whether the resulting inode record overlaps with
402 * another record in the tree. Without this basic rule, we would have to deal
403 * with the consequences of overlap by potentially undoing recent allocations in
404 * the inode allocation codepath.
405 *
406 * Because of this alignment rule (which is enforced on mount), there are two
407 * inobt possibilities for newly allocated sparse chunks. One is that the
408 * aligned inode record for the chunk covers a range of inodes not already
409 * covered in the inobt (i.e., it is safe to insert a new sparse record). The
410 * other is that a record already exists at the aligned startino that considers
411 * the newly allocated range as sparse. In the latter case, record content is
412 * merged in hope that sparse inode chunks fill to full chunks over time.
413 */
414 STATIC void
419 {
420 xfs_agblock_t agbno;
421 xfs_agblock_t mod;
429 /* calculate the inode offset and align startino */
433 /*
434 * Since startino has been aligned down, left shift allocmask such that
435 * it continues to represent the same physical inodes relative to the
436 * new startino.
437 */
439 }
441 /*
442 * Determine whether the source inode record can merge into the target. Both
443 * records must be sparse, the inode ranges must match and there must be no
444 * allocation overlap between the records.
445 */
446 STATIC bool
450 {
454 /* records must cover the same inode range */
458 /* both records must be sparse */
463 /* both records must track some inodes */
467 /* can't exceed capacity of a full record */
471 /* verify there is no allocation overlap */
478 }
480 /*
481 * Merge the source inode record into the target. The caller must call
482 * __xfs_inobt_can_merge() to ensure the merge is valid.
483 */
484 STATIC void
488 {
491 /* combine the counts */
495 /*
496 * Merge the holemask and free mask. For both fields, 0 bits refer to
497 * allocated inodes. We combine the allocated ranges with bitwise AND.
498 */
501 }
503 /*
504 * Insert a new sparse inode chunk into the associated inode btree. The inode
505 * record for the sparse chunk is pre-aligned to a startino that should match
506 * any pre-existing sparse inode record in the tree. This allows sparse chunks
507 * to fill over time.
508 *
509 * This function supports two modes of handling preexisting records depending on
510 * the merge flag. If merge is true, the provided record is merged with the
511 * existing record and updated in place. The merged record is returned in nrec.
512 * If merge is false, an existing record is replaced with the provided record.
513 * If no preexisting record exists, the provided record is always inserted.
514 *
515 * It is considered corruption if a merge is requested and not possible. Given
516 * the sparse inode alignment constraints, this should never happen.
517 */
518 STATIC int
526 {
536 /* the new record is pre-aligned so we know where to look */
540 /* if nothing there, insert a new record and return */
550 }
553 }
555 /*
556 * A record exists at this startino. Merge or replace the record
557 * depending on what we've been asked to do.
558 */
566 }
570 }
572 /*
573 * This should never fail. If we have coexisting records that
574 * cannot merge, something is seriously wrong.
575 */
579 }
585 /* merge to nrec to output the updated record */
594 }
600 out:
603 error:
606 }
608 /*
609 * Allocate new inodes in the allocation group specified by agbp.
610 * Returns 0 if inodes were allocated in this AG; 1 if there was no space
611 * in this AG; or the usual negative error code.
612 */
613 STATIC int
617 {
620 xfs_agnumber_t agno;
625 /* unit boundary */
626 /* init. to full chunk */
639 #ifdef DEBUG
640 /* randomly do sparse inode allocations */
644 #endif
646 /*
647 * Locking will ensure that we don't have two callers in here
648 * at one time.
649 */
656 /*
657 * First try to allocate inodes contiguous with the last-allocated
658 * chunk of inodes. If the filesystem is striped, this will fill
659 * an entire stripe unit with inodes.
660 */
674 /*
675 * We need to take into account alignment here to ensure that
676 * we don't modify the free list if we fail to have an exact
677 * block. If we don't have an exact match, and every oher
678 * attempt allocation attempt fails, we'll end up cancelling
679 * a dirty transaction and shutting down.
680 *
681 * For an exact allocation, alignment must be 1,
682 * however we need to take cluster alignment into account when
683 * fixing up the freelist. Use the minalignslop field to
684 * indicate that extra blocks might be required for alignment,
685 * but not to use them in the actual exact allocation.
686 */
690 /* Allow space for the inode btree to split. */
695 /*
696 * This request might have dirtied the transaction if the AG can
697 * satisfy the request, but the exact block was not available.
698 * If the allocation did fail, subsequent requests will relax
699 * the exact agbno requirement and increase the alignment
700 * instead. It is critical that the total size of the request
701 * (len + alignment + slop) does not increase from this point
702 * on, so reset minalignslop to ensure it is not included in
703 * subsequent requests.
704 */
706 }
709 /*
710 * Set the alignment for the allocation.
711 * If stripe alignment is turned on then align at stripe unit
712 * boundary.
713 * If the cluster size is smaller than a filesystem block
714 * then we're doing I/O for inodes in filesystem block size
715 * pieces, so don't need alignment anyway.
716 */
724 /*
725 * Need to figure out where to allocate the inode blocks.
726 * Ideally they should be spaced out through the a.g.
727 * For now, just allocate blocks up front.
728 */
731 /*
732 * Allocate a fixed-size extent of inodes.
733 */
736 /*
737 * Allow space for the inode btree to split.
738 */
742 }
744 /*
745 * If stripe alignment is turned on, then try again with cluster
746 * alignment.
747 */
755 }
757 /*
758 * Finally, try a sparse allocation if the filesystem supports it and
759 * the sparse allocation length is smaller than a full chunk.
760 */
764 sparse_alloc:
774 /*
775 * The inode record will be aligned to full chunk size. We must
776 * prevent sparse allocation from AG boundaries that result in
777 * invalid inode records, such as records that start at agbno 0
778 * or extend beyond the AG.
779 *
780 * Set min agbno to the first aligned, non-zero agbno and max to
781 * the last aligned agbno that is at least one full chunk from
782 * the end of the AG.
783 */
796 }
803 /*
804 * Stamp and write the inode buffers.
805 *
806 * Seed the new inode cluster with a random generation number. This
807 * prevents short-term reuse of generation numbers if a chunk is
808 * freed and then immediately reallocated. We use random numbers
809 * rather than a linear progression to prevent the next generation
810 * number from being easily guessable.
811 */
817 /*
818 * Convert the results.
819 */
823 /*
824 * We've allocated a sparse chunk. Align the startino and mask.
825 */
834 /*
835 * Insert the sparse record into the inobt and allow for a merge
836 * if necessary. If a merge does occur, rec is updated to the
837 * merged record.
838 */
848 }
852 /*
853 * We can't merge the part we've just allocated as for the inobt
854 * due to finobt semantics. The original record may or may not
855 * exist independent of whether physical inodes exist in this
856 * sparse chunk.
857 *
858 * We must update the finobt record based on the inobt record.
859 * rec contains the fully merged and up to date inobt record
860 * from the previous call. Set merge false to replace any
861 * existing record with this one.
862 */
869 }
871 /* full chunk - insert new records to both btrees */
873 XFS_BTNUM_INO);
882 }
883 }
885 /*
886 * Update AGI counts and newino.
887 */
895 /*
896 * Log allocation group header fields
897 */
900 /*
901 * Modify/log superblock values for inode count and inode free count.
902 */
906 }
908 STATIC xfs_agnumber_t
911 {
912 xfs_agnumber_t agno;
921 }
923 /*
924 * Select an allocation group to look for a free inode in, based on the parent
925 * inode and the mode. Return the allocation group buffer.
926 */
927 STATIC xfs_agnumber_t
932 {
944 /*
945 * Files of these types need at least one block if length > 0
946 * (and they won't fit in the inode, but that's hard to figure out).
947 */
957 }
961 /*
962 * Loop through allocation groups, looking for one with a little
963 * free space in it. Note we don't look for free inodes, exactly.
964 * Instead, we include whether there is a need to allocate inodes
965 * to mean that blocks must be allocated for them,
966 * if none are currently free.
967 */
975 }
981 }
986 }
992 }
994 /*
995 * Check that there is enough free space for the file plus a
996 * chunk of inodes if we need to allocate some. If this is the
997 * first pass across the AGs, take into account the potential
998 * space needed for alignment of inode chunks when checking the
999 * longest contiguous free space in the AG - this prevents us
1000 * from getting ENOSPC because we have free space larger than
1001 * ialloc_blks but alignment constraints prevent us from using
1002 * it.
1003 *
1004 * If we can't find an AG with space for full alignment slack to
1005 * be taken into account, we must be near ENOSPC in all AGs.
1006 * Hence we don't include alignment for the second pass and so
1007 * if we fail allocation due to alignment issues then it is most
1008 * likely a real ENOSPC condition.
1009 */
1021 }
1022 nextag:
1024 /*
1025 * No point in iterating over the rest, if we're shutting
1026 * down.
1027 */
1030 agno++;
1037 }
1038 }
1039 }
1041 /*
1042 * Try to retrieve the next record to the left/right from the current one.
1043 */
1044 STATIC int
1050 {
1056 else
1068 }
1071 }
1073 STATIC int
1076 xfs_agino_t agino,
1079 {
1093 }
1096 }
1098 /*
1099 * Return the offset of the first free inode in the record. If the inode chunk
1100 * is sparsely allocated, we convert the record holemask to inode granularity
1101 * and mask off the unallocated regions from the inode free mask.
1102 */
1103 STATIC int
1106 {
1107 xfs_inofree_t realfree;
1109 /* if there are no holes, return the first available offset */
1117 }
1119 /*
1120 * Allocate an inode using the inobt-only algorithm.
1121 */
1122 STATIC int
1126 xfs_ino_t parent,
1128 {
1137 xfs_ino_t ino;
1147 restart_pagno:
1149 /*
1150 * If pagino is 0 (this is the root inode allocation) use newino.
1151 * This must work because we've just allocated some.
1152 */
1160 /*
1161 * If in the same AG as the parent, try to get near the parent.
1162 */
1173 }
1181 }
1184 /*
1185 * Found a free inode in the same chunk
1186 * as the parent, done.
1187 */
1189 }
1192 /*
1193 * In the same AG as parent, but parent's chunk is full.
1194 */
1196 /* duplicate the cursor, search left & right simultaneously */
1201 /*
1202 * Skip to last blocks looked up if same parent inode.
1203 */
1218 /* search left with tcur, back up 1 record */
1223 /* search right with cur, go forward 1 record. */
1227 }
1229 /*
1230 * Loop until we find an inode chunk with a free inode.
1231 */
1235 /* figure out the closer block if both are valid. */
1242 }
1244 /* free inodes to the left? */
1254 }
1256 /* free inodes to the right? */
1264 }
1266 /* get next record to check */
1273 }
1276 }
1279 /*
1280 * Not in range - save last search
1281 * location and allocate a new inode
1282 */
1289 /*
1290 * We've reached the end of the btree. because
1291 * we are only searching a small chunk of the
1292 * btree each search, there is obviously free
1293 * inodes closer to the parent inode than we
1294 * are now. restart the search again.
1295 */
1302 }
1303 }
1305 /*
1306 * In a different AG from the parent.
1307 * See if the most recently allocated block has any free.
1308 */
1321 /*
1322 * The last chunk allocated in the group
1323 * still has a free inode.
1324 */
1326 }
1327 }
1328 }
1330 /*
1331 * None left in the last group, search the whole AG
1332 */
1339 }
1348 }
1357 }
1358 }
1360 alloc_inode:
1384 error1:
1386 error0:
1389 }
1391 /*
1392 * Use the free inode btree to allocate an inode based on distance from the
1393 * parent. Note that the provided cursor may be deleted and replaced.
1394 */
1395 STATIC int
1397 xfs_agino_t pagino,
1400 {
1418 /*
1419 * See if we've landed in the parent inode record. The finobt
1420 * only tracks chunks with at least one free inode, so record
1421 * existence is enough.
1422 */
1426 }
1442 }
1443 }
1448 }
1450 /*
1451 * Both the left and right records are valid. Choose the closer
1452 * inode chunk to the target.
1453 */
1461 }
1463 /* only the right record is valid */
1468 /* only the left record is valid */
1470 }
1474 error_rcur:
1477 }
1479 /*
1480 * Use the free inode btree to find a free inode based on a newino hint. If
1481 * the hint is NULL, find the first free inode in the AG.
1482 */
1483 STATIC int
1488 {
1504 }
1505 }
1507 /*
1508 * Find the first inode available in the AG.
1509 */
1523 }
1525 /*
1526 * Update the inobt based on a modification made to the finobt. Also ensure that
1527 * the records from both trees are equivalent post-modification.
1528 */
1529 STATIC int
1534 {
1562 }
1564 /*
1565 * Allocate an inode using the free inode btree, if available. Otherwise, fall
1566 * back to the inobt search algorithm.
1567 *
1568 * The caller selected an AG for us, and made sure that free inodes are
1569 * available.
1570 */
1571 int
1575 xfs_ino_t parent,
1577 {
1586 xfs_ino_t ino;
1594 /*
1595 * If pagino is 0 (this is the root inode allocation) use newino.
1596 * This must work because we've just allocated some.
1597 */
1607 /*
1608 * The search algorithm depends on whether we're in the same AG as the
1609 * parent. If so, find the closest available inode to the parent. If
1610 * not, consider the agi hint or find the first free inode in the AG.
1611 */
1614 else
1626 /*
1627 * Modify or remove the finobt record.
1628 */
1633 else
1638 /*
1639 * The finobt has now been updated appropriately. We haven't updated the
1640 * agi and superblock yet, so we can create an inobt cursor and validate
1641 * the original freecount. If all is well, make the equivalent update to
1642 * the inobt using the finobt record and offset information.
1643 */
1654 /*
1655 * Both trees have now been updated. We must update the perag and
1656 * superblock before we can check the freecount for each btree.
1657 */
1676 error_icur:
1678 error_cur:
1681 }
1683 static int
1687 {
1692 /*
1693 * Hold to on to the agibp across the commit so no other allocation can
1694 * come in and take the free inodes we just allocated for our caller.
1695 */
1698 /*
1699 * We want the quota changes to be associated with the next transaction,
1700 * NOT this one. So, detach the dqinfo from this and attach it to the
1701 * next transaction.
1702 */
1708 /* Re-attach the quota info that we detached from prev trx. */
1716 }
1718 /*
1719 * Select and prepare an AG for inode allocation.
1720 *
1721 * Mode is used to tell whether the new inode is a directory and hence where to
1722 * locate it.
1723 *
1724 * This function will ensure that the selected AG has free inodes available to
1725 * allocate from. The selected AGI will be returned locked to the caller, and it
1726 * will allocate more free inodes if required. If no free inodes are found or
1727 * can be allocated, no AGI will be returned.
1728 */
1729 int
1732 xfs_ino_t parent,
1733 umode_t mode,
1735 {
1738 xfs_agnumber_t agno;
1741 xfs_agnumber_t start_agno;
1748 /*
1749 * We do not have an agbp, so select an initial allocation
1750 * group for inode allocation.
1751 */
1756 /*
1757 * If we have already hit the ceiling of inode blocks then clear
1758 * okalloc so we scan all available agi structures for a free
1759 * inode.
1760 *
1761 * Read rough value of mp->m_icount by percpu_counter_read_positive,
1762 * which will sacrifice the preciseness but improve the performance.
1763 */
1769 }
1771 /*
1772 * Loop until we find an allocation group that either has free inodes
1773 * or in which we can allocate some inodes. Iterate through the
1774 * allocation groups upward, wrapping at the end.
1775 */
1782 }
1788 }
1790 /*
1791 * Do a first racy fast path check if this AG is usable.
1792 */
1796 /*
1797 * Then read in the AGI buffer and recheck with the AGI buffer
1798 * lock held.
1799 */
1807 }
1819 }
1822 /*
1823 * We successfully allocated space for an inode cluster
1824 * in this AG. Roll the transaction so that we can
1825 * allocate one of the new inodes.
1826 */
1834 }
1836 }
1838 nextag_relse_buffer:
1840 nextag:
1846 }
1850 found_ag:
1853 }
1855 /*
1856 * Free the blocks of an inode chunk. We must consider that the inode chunk
1857 * might be sparse and only free the regions that are allocated as part of the
1858 * chunk.
1859 */
1860 STATIC void
1863 xfs_agnumber_t agno,
1865 {
1871 xfs_agblock_t agbno;
1876 /* not sparse, calculate extent info directly */
1881 }
1883 /* holemask is only 16-bits (fits in an unsigned long) */
1887 /*
1888 * Find contiguous ranges of zeroes (i.e., allocated regions) in the
1889 * holemask and convert the start/end index of each range to an extent.
1890 * We start with the start and end index both pointing at the first 0 in
1891 * the mask.
1892 */
1894 XFS_INOBT_HOLEMASK_BITS);
1898 nextbit);
1899 /*
1900 * If the next zero bit is contiguous, update the end index of
1901 * the current range and continue.
1902 */
1907 }
1909 /*
1910 * nextbit is not contiguous with the current end index. Convert
1911 * the current start/end to an extent and add it to the free
1912 * list.
1913 */
1917 XFS_INODES_PER_HOLEMASK_BIT) /
1925 /* reset range to current bit and carry on... */
1928 next:
1929 nextbit++;
1930 }
1931 }
1933 STATIC int
1938 xfs_agino_t agino,
1941 {
1954 /*
1955 * Initialize the cursor.
1956 */
1963 /*
1964 * Look for the entry describing this inode.
1965 */
1970 }
1974 }
1980 }
1984 }
1985 /*
1986 * Get the offset in the inode chunk.
1987 */
1991 /*
1992 * Mark the inode free & increment the count.
1993 */
1997 /*
1998 * When an inode chunk is free, it becomes eligible for removal. Don't
1999 * remove the chunk if the block size is large enough for multiple inode
2000 * chunks (that might not be free).
2001 */
2011 /*
2012 * Remove the inode cluster from the AGI B+Tree, adjust the
2013 * AGI and Superblock inode counts, and mark the disk space
2014 * to be freed when the transaction is committed.
2015 */
2029 }
2040 }
2042 /*
2043 * Change the inode free counts and log the ag/sb changes.
2044 */
2049 }
2059 error0:
2062 }
2064 /*
2065 * Free an inode in the free inode btree.
2066 */
2067 STATIC int
2072 xfs_agino_t agino,
2074 {
2089 /*
2090 * If the record does not exist in the finobt, we must have just
2091 * freed an inode in a previously fully allocated chunk. If not,
2092 * something is out of sync.
2093 */
2097 }
2108 }
2110 /*
2111 * Read and update the existing record. We could just copy the ibtrec
2112 * across here, but that would defeat the purpose of having redundant
2113 * metadata. By making the modifications independently, we can catch
2114 * corruptions that we wouldn't see if we just copied from one record
2115 * to another.
2116 */
2123 }
2133 }
2135 /*
2136 * The content of inobt records should always match between the inobt
2137 * and finobt. The lifecycle of records in the finobt is different from
2138 * the inobt in that the finobt only tracks records with at least one
2139 * free inode. Hence, if all of the inodes are free and we aren't
2140 * keeping inode chunks permanently on disk, remove the record.
2141 * Otherwise, update the record with the new information.
2142 *
2143 * Note that we currently can't free chunks when the block size is large
2144 * enough for multiple chunks. Leave the finobt record to remain in sync
2145 * with the inobt.
2146 */
2158 }
2160 out:
2168 error:
2171 }
2173 /*
2174 * Free disk inode. Carefully avoids touching the incore inode, all
2175 * manipulations incore are the caller's responsibility.
2176 * The on-disk inode is not changed by this operation, only the
2177 * btree (free inode mask) is changed.
2178 */
2179 int
2184 {
2185 /* REFERENCED */
2196 /*
2197 * Break up inode number into its components.
2198 */
2205 }
2213 }
2220 }
2221 /*
2222 * Get the allocation group header.
2223 */
2229 }
2231 /*
2232 * Fix up the inode allocation btree.
2233 */
2238 /*
2239 * Fix up the free inode btree.
2240 */
2245 }
2249 error0:
2251 }
2253 STATIC int
2257 xfs_agnumber_t agno,
2258 xfs_agino_t agino,
2259 xfs_agblock_t agbno,
2263 {
2276 }
2278 /*
2279 * Lookup the inode record for the given agino. If the record cannot be
2280 * found, then it's an invalid inode number and we should abort. Once
2281 * we have a record, we need to ensure it contains the inode number
2282 * we are looking up.
2283 */
2291 }
2298 /* check that the returned record contains the required inode */
2303 /* for untrusted inodes check it is allocated first */
2311 }
2313 /*
2314 * Return the location of the inode in imap, for mapping it into a buffer.
2315 */
2316 int
2323 {
2335 /*
2336 * Split up the inode number into its parts.
2337 */
2343 #ifdef DEBUG
2344 /*
2345 * Don't output diagnostic information for untrusted inodes
2346 * as they can be invalid without implying corruption.
2347 */
2354 }
2360 }
2366 }
2370 }
2372 /*
2373 * For bulkstat and handle lookups, we have an untrusted inode number
2374 * that we have to verify is valid. We cannot do this just by reading
2375 * the inode buffer as it may have been unlinked and removed leaving
2376 * inodes in stale state on disk. Hence we have to do a btree lookup
2377 * in all cases where an untrusted inode number is passed.
2378 */
2385 }
2387 /*
2388 * If the inode cluster size is the same as the blocksize or
2389 * smaller we get to the buffer by simple arithmetics.
2390 */
2400 }
2402 /*
2403 * If the inode chunks are aligned then use simple maths to
2404 * find the location. Otherwise we have to do a btree
2405 * lookup to find the location.
2406 */
2415 }
2417 out_map:
2429 /*
2430 * If the inode number maps to a block outside the bounds
2431 * of the file system then return NULL rather than calling
2432 * read_buf and panicing when we get an error from the
2433 * driver.
2434 */
2443 }
2445 }
2447 /*
2448 * Log specified fields for the ag hdr (inode section). The growth of the agi
2449 * structure over time requires that we interpret the buffer as two logical
2450 * regions delineated by the end of the unlinked list. This is due to the size
2451 * of the hash table and its location in the middle of the agi.
2452 *
2453 * For example, a request to log a field before agi_unlinked and a field after
2454 * agi_unlinked could cause us to log the entire hash table and use an excessive
2455 * amount of log space. To avoid this behavior, log the region up through
2456 * agi_unlinked in one call and the region after agi_unlinked through the end of
2457 * the structure in another.
2458 */
2459 void
2464 {
2468 /* keep in sync with bit definitions */
2484 };
2485 #ifdef DEBUG
2489 #endif
2491 /*
2492 * Compute byte offsets for the first and last fields in the first
2493 * region and log the agi buffer. This only logs up through
2494 * agi_unlinked.
2495 */
2500 }
2502 /*
2503 * Mask off the bits in the first region and calculate the first and
2504 * last field offsets for any bits in the second region.
2505 */
2511 }
2512 }
2514 static xfs_failaddr_t
2517 {
2527 }
2529 /*
2530 * Validate the magic number of the agi block.
2531 */
2546 /*
2547 * during growfs operations, the perag is not fully initialised,
2548 * so we can't use it for any useful checking. growfs ensures we can't
2549 * use it by using uncached buffers that don't have the perag attached
2550 * so we can detect and avoid this problem.
2551 */
2560 }
2563 }
2565 static void
2568 {
2570 xfs_failaddr_t fa;
2579 }
2580 }
2582 static void
2585 {
2589 xfs_failaddr_t fa;
2595 }
2603 }
2611 };
2613 /*
2614 * Read in the allocation group header (inode allocation section)
2615 */
2616 int
2622 {
2638 }
2640 int
2646 {
2663 }
2665 /*
2666 * It's possible for these to be out of sync if
2667 * we are in the middle of a forced shutdown.
2668 */
2672 }
2674 /*
2675 * Read in the agi to initialise the per-ag data in the mount structure
2676 */
2677 int
2682 {
2692 }
2694 /* Is there an inode record covering a given range of inode numbers? */
2695 int
2698 xfs_agino_t low,
2699 xfs_agino_t high,
2701 {
2703 xfs_agino_t agino;
2726 }
2727 }
2730 }
2732 }
2734 /* Is there an inode record covering a given extent? */
2735 int
2738 xfs_agblock_t bno,
2739 xfs_extlen_t len,
2741 {
2742 xfs_agino_t low;
2743 xfs_agino_t high;
2749 }
2752 xfs_agino_t count;
2753 xfs_agino_t freecount;
2754 };
2756 /* Record inode counts across all inobt records. */
2757 STATIC int
2762 {
2771 }
2773 /* Count allocated and free inodes under an inobt. */
2774 int
2779 {
2791 }
2793 /*
2794 * Initialize inode-related geometry information.
2795 *
2796 * Compute the inode btree min and max levels and set maxicount.
2797 *
2798 * Set the inode cluster size. This may still be overridden by the file
2799 * system block size if it is larger than the chosen cluster size.
2800 *
2801 * For v5 filesystems, scale the cluster size with the inode size to keep a
2802 * constant ratio of inode per cluster buffer, but only if mkfs has set the
2803 * inode alignment value appropriately for larger cluster sizes.
2804 *
2805 * Then compute the inode cluster alignment information.
2806 */
2807 void
2810 {
2814 uint inodes;
2820 /* Compute inode btree geometry. */
2833 else
2836 /* Compute and fill in value of m_ino_geo.inobt_maxlevels. */
2839 inodes);
2841 /*
2842 * Set the maximum inode count for this filesystem, being careful not
2843 * to use obviously garbage sb_inopblog/sb_inopblock values. Regular
2844 * users should never get here due to failing sb verification, but
2845 * certain users (xfs_db) need to be usable even with corrupt metadata.
2846 */
2848 /*
2849 * Make sure the maximum inode count is a multiple
2850 * of the units we allocate inodes in.
2851 */
2859 }
2861 /*
2862 * Compute the desired size of an inode cluster buffer size, which
2863 * starts at 8K and (on v5 filesystems) scales up with larger inode
2864 * sizes.
2865 *
2866 * Preserve the desired inode cluster size because the sparse inodes
2867 * feature uses that desired size (not the actual size) to compute the
2868 * sparse inode alignment. The mount code validates this value, so we
2869 * cannot change the behavior.
2870 */
2878 }
2880 /* Calculate inode cluster ratios. */
2884 else
2889 /* Calculate inode cluster alignment. */
2893 else
2898 /*
2899 * If we are using stripe alignment, check whether
2900 * the stripe unit is a multiple of the inode alignment
2901 */
2905 else
2907 }
2909 /* Compute the location of the root directory inode that is laid out by mkfs. */
2910 xfs_ino_t
2914 {
2916 xfs_agblock_t first_bno;
2918 /*
2919 * Pre-calculate the geometry of AG 0. We know what it looks like
2920 * because libxfs knows how to create allocation groups now.
2921 *
2922 * first_bno is the first block in which mkfs could possibly have
2923 * allocated the root directory inode, once we factor in the metadata
2924 * that mkfs formats before it. Namely, the four AG headers...
2925 */
2928 /* ...the two free space btree roots... */
2931 /* ...the inode btree root... */
2934 /* ...the initial AGFL... */
2937 /* ...the free inode btree root... */
2939 first_bno++;
2941 /* ...the reverse mapping btree root... */
2943 first_bno++;
2945 /* ...the reference count btree... */
2947 first_bno++;
2949 /*
2950 * ...and the log, if it is allocated in the first allocation group.
2951 *
2952 * This can happen with filesystems that only have a single
2953 * allocation group, or very odd geometries created by old mkfs
2954 * versions on very small filesystems.
2955 */
2960 /*
2961 * Now round first_bno up to whatever allocation alignment is given
2962 * by the filesystem or was passed in.
2963 */
2971 }