| blob | 2778258fcfa239e07dbc79edf6cb4750b7e13dd8 |
1 /*
2 * Copyright (c) 2000-2006 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 <linux/log2.h>
52 /*
53 * Used in xfs_itruncate_extents(). This is the maximum number of extents
54 * freed from a file in a single transaction.
55 */
56 #define XFS_ITRUNC_MAX_EXTENTS 2
63 /*
64 * helper function to extract extent size hint from inode
65 */
66 xfs_extlen_t
69 {
75 }
77 #ifdef DEBUG
78 /*
79 * Make sure that the extents in the given memory buffer
80 * are valid.
81 */
82 STATIC void
86 xfs_exntfmt_t fmt)
87 {
88 xfs_bmbt_irec_t irec;
89 xfs_bmbt_rec_host_t rec;
99 }
100 }
102 #define xfs_validate_extents(ifp, nrecs, fmt)
105 /*
106 * Check that none of the inode's in the buffer have a next
107 * unlinked field of 0.
108 */
109 #if defined(DEBUG)
110 void
114 {
127 bp);
129 }
130 }
131 }
132 #endif
134 /*
135 * This routine is called to map an inode to the buffer containing the on-disk
136 * version of the inode. It returns a pointer to the buffer containing the
137 * on-disk inode in the bpp parameter, and in the dipp parameter it returns a
138 * pointer to the on-disk inode within that buffer.
139 *
140 * If a non-zero error is returned, then the contents of bpp and dipp are
141 * undefined.
142 */
143 int
150 uint buf_flags,
151 uint iget_flags)
152 {
168 }
170 }
172 /*
173 * Validate the magic number and version of every inode in the buffer
174 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
175 */
176 #ifdef DEBUG
180 #endif
191 XFS_ERRTAG_ITOBP_INOTOBP,
192 XFS_RANDOM_ITOBP_INOTOBP))) {
196 }
199 #ifdef DEBUG
205 #endif
208 }
209 }
216 }
218 /*
219 * Move inode type and inode format specific information from the
220 * on-disk inode to the in-core inode. For fifos, devs, and sockets
221 * this means set if_rdev to the proper value. For files, directories,
222 * and symlinks this means to bring in the in-line data or extent
223 * pointers. For a file in B-tree format, only the root is immediately
224 * brought in-core. The rest will be in-lined in if_extents when it
225 * is first referenced (see xfs_iread_extents()).
226 */
227 STATIC int
231 {
235 xfs_fsize_t di_size;
250 }
259 }
269 }
280 }
290 /*
291 * no local regular files yet
292 */
298 XFS_ERRLEVEL_LOW,
301 }
310 XFS_ERRLEVEL_LOW,
313 }
328 }
334 }
337 }
355 XFS_ERRLEVEL_LOW,
358 }
371 }
376 }
378 }
380 /*
381 * The file is in-lined in the on-disk inode.
382 * If it fits into if_inline_data, then copy
383 * it there, otherwise allocate a buffer for it
384 * and copy the data there. Either way, set
385 * if_data to point at the data.
386 * If we allocate a buffer for the data, make
387 * sure that its size is a multiple of 4 and
388 * record the real size in i_real_bytes.
389 */
390 STATIC int
396 {
400 /*
401 * If the size is unreasonable, then something
402 * is wrong and we just bail out rather than crash in
403 * kmem_alloc() or memcpy() below.
404 */
413 }
423 }
431 }
433 /*
434 * The file consists of a set of extents all
435 * of which fit into the on-disk inode.
436 * If there are few enough extents to fit into
437 * the if_inline_ext, then copy them there.
438 * Otherwise allocate a buffer for them and copy
439 * them into it. Either way, set if_extents
440 * to point at the extents.
441 */
442 STATIC int
447 {
458 /*
459 * If the number of extents is unreasonable, then something
460 * is wrong and we just bail out rather than crash in
461 * kmem_alloc() or memcpy() below.
462 */
469 }
476 else
487 }
494 XFS_ERRLEVEL_LOW,
497 }
498 }
501 }
503 /*
504 * The file has too many extents to fit into
505 * the inode, so they are in B-tree format.
506 * Allocate a buffer for the root of the B-tree
507 * and copy the root into it. The i_extents
508 * field will remain NULL until all of the
509 * extents are read in (when they are needed).
510 */
511 STATIC int
516 {
519 /* REFERENCED */
528 /*
529 * blow out if -- fork has less extents than can fit in
530 * fork (fork shouldn't be a btree format), root btree
531 * block has more records than can fit into the fork,
532 * or the number of extents is greater than the number of
533 * blocks.
534 */
545 }
550 /*
551 * Copy and convert from the on-disk structure
552 * to the in-memory structure.
553 */
561 }
563 STATIC void
567 {
597 }
599 void
603 {
633 }
635 STATIC uint
637 __uint16_t di_flags)
638 {
670 }
673 }
675 uint
678 {
683 }
685 uint
688 {
691 }
693 /*
694 * Read the disk inode attributes into the in-core inode structure.
695 */
696 int
701 uint iget_flags)
702 {
707 /*
708 * Fill in the location information in the in-core inode.
709 */
714 /*
715 * Get pointers to the on-disk inode and the buffer containing it.
716 */
721 /*
722 * If we got something that isn't an inode it means someone
723 * (nfs or dmi) has a stale handle.
724 */
726 #ifdef DEBUG
733 }
735 /*
736 * If the on-disk inode is already linked to a directory
737 * entry, copy all of the inode into the in-core inode.
738 * xfs_iformat() handles copying in the inode format
739 * specific information.
740 * Otherwise, just get the truly permanent information.
741 */
746 #ifdef DEBUG
751 }
757 /*
758 * Make sure to pull in the mode here as well in
759 * case the inode is released without being used.
760 * This ensures that xfs_inactive() will see that
761 * the inode is already free and not try to mess
762 * with the uninitialized part of it.
763 */
765 }
767 /*
768 * The inode format changed when we moved the link count and
769 * made it 32 bits long. If this is an old format inode,
770 * convert it in memory to look like a new one. If it gets
771 * flushed to disk we will convert back before flushing or
772 * logging it. We zero out the new projid field and the old link
773 * count field. We'll handle clearing the pad field (the remains
774 * of the old uuid field) when we actually convert the inode to
775 * the new format. We don't change the version number so that we
776 * can distinguish this from a real new format inode.
777 */
782 }
786 /*
787 * Mark the buffer containing the inode as something to keep
788 * around for a while. This helps to keep recently accessed
789 * meta-data in-core longer.
790 */
793 /*
794 * Use xfs_trans_brelse() to release the buffer containing the
795 * on-disk inode, because it was acquired with xfs_trans_read_buf()
796 * in xfs_imap_to_bp() above. If tp is NULL, this is just a normal
797 * brelse(). If we're within a transaction, then xfs_trans_brelse()
798 * will only release the buffer if it is not dirty within the
799 * transaction. It will be OK to release the buffer in this case,
800 * because inodes on disk are never destroyed and we will be
801 * locking the new in-core inode before putting it in the hash
802 * table where other processes can find it. Thus we don't have
803 * to worry about the inode being changed just because we released
804 * the buffer.
805 */
806 out_brelse:
809 }
811 /*
812 * Read in extents from a btree-format inode.
813 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
814 */
815 int
820 {
823 xfs_extnum_t nextents;
829 }
833 /*
834 * We know that the size is valid (it's checked in iformat_btree)
835 */
844 }
847 }
849 /*
850 * Allocate an inode on disk and return a copy of its in-core version.
851 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
852 * appropriately within the inode. The uid and gid for the inode are
853 * set according to the contents of the given cred structure.
854 *
855 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
856 * has a free inode available, call xfs_iget()
857 * to obtain the in-core version of the allocated inode. Finally,
858 * fill in the inode and log its initial contents. In this case,
859 * ialloc_context would be set to NULL and call_again set to false.
860 *
861 * If xfs_dialloc() does not have an available inode,
862 * it will replenish its supply by doing an allocation. Since we can
863 * only do one allocation within a transaction without deadlocks, we
864 * must commit the current transaction before returning the inode itself.
865 * In this case, therefore, we will set call_again to true and return.
866 * The caller should then commit the current transaction, start a new
867 * transaction, and call xfs_ialloc() again to actually get the inode.
868 *
869 * To ensure that some other process does not grab the inode that
870 * was allocated during the first call to xfs_ialloc(), this routine
871 * also returns the [locked] bp pointing to the head of the freelist
872 * as ialloc_context. The caller should hold this buffer across
873 * the commit and pass it back into this routine on the second call.
874 *
875 * If we are allocating quota inodes, we do not have a parent inode
876 * to attach to or associate with (i.e. pip == NULL) because they
877 * are not linked into the directory structure - they are attached
878 * directly to the superblock - and so have no parent.
879 */
880 int
884 umode_t mode,
885 xfs_nlink_t nlink,
886 xfs_dev_t rdev,
887 prid_t prid,
891 {
892 xfs_ino_t ino;
894 uint flags;
896 timespec_t tv;
899 /*
900 * Call the space management code to pick
901 * the on-disk inode to be allocated.
902 */
910 }
913 /*
914 * Get the in-core inode with the lock held exclusively.
915 * This is because we're setting fields here we need
916 * to prevent others from looking at until we're done.
917 */
933 /*
934 * If the superblock version is up to where we support new format
935 * inodes and this is currently an old format inode, then change
936 * the inode version number now. This way we only do the conversion
937 * here rather than here and in the flush/logging code.
938 */
942 /*
943 * We've already zeroed the old link count, the projid field,
944 * and the pad field.
945 */
946 }
948 /*
949 * Project ids won't be stored on disk if we are using a version 1 inode.
950 */
958 }
959 }
961 /*
962 * If the group ID of the new file does not match the effective group
963 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
964 * (and only if the irix_sgid_inherit compatibility variable is set).
965 */
970 }
982 /*
983 * di_gen will have been taken care of in xfs_iread.
984 */
1001 /*
1002 * we can't set up filestreams until after the VFS inode
1003 * is set up properly.
1004 */
1007 /* fall through */
1018 }
1025 }
1026 }
1028 xfs_inherit_noatime)
1031 xfs_inherit_nodump)
1034 xfs_inherit_sync)
1037 xfs_inherit_nosymlinks)
1042 xfs_inherit_nodefrag)
1047 }
1048 /* FALLTHROUGH */
1057 }
1058 /*
1059 * Attribute fork settings for new inode.
1060 */
1064 /*
1065 * Log the new values stuffed into the inode.
1066 */
1070 /* now that we have an i_mode we can setup inode ops and unlock */
1073 /* now we have set up the vfs inode we can associate the filestream */
1080 }
1084 }
1086 /*
1087 * Free up the underlying blocks past new_size. The new size must be smaller
1088 * than the current size. This routine can be used both for the attribute and
1089 * data fork, and does not modify the inode size, which is left to the caller.
1090 *
1091 * The transaction passed to this routine must have made a permanent log
1092 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1093 * given transaction and start new ones, so make sure everything involved in
1094 * the transaction is tidy before calling here. Some transaction will be
1095 * returned to the caller to be committed. The incoming transaction must
1096 * already include the inode, and both inode locks must be held exclusively.
1097 * The inode must also be "held" within the transaction. On return the inode
1098 * will be "held" within the returned transaction. This routine does NOT
1099 * require any disk space to be reserved for it within the transaction.
1100 *
1101 * If we get an error, we must return with the inode locked and linked into the
1102 * current transaction. This keeps things simple for the higher level code,
1103 * because it always knows that the inode is locked and held in the transaction
1104 * that returns to it whether errors occur or not. We don't mark the inode
1105 * dirty on error so that transactions can be easily aborted if possible.
1106 */
1107 int
1112 xfs_fsize_t new_size)
1113 {
1117 xfs_bmap_free_t free_list;
1118 xfs_fsblock_t first_block;
1119 xfs_fileoff_t first_unmap_block;
1120 xfs_fileoff_t last_block;
1121 xfs_filblks_t unmap_len;
1137 /*
1138 * Since it is possible for space to become allocated beyond
1139 * the end of the file (in a crash where the space is allocated
1140 * but the inode size is not yet updated), simply remove any
1141 * blocks which show up between the new EOF and the maximum
1142 * possible file size. If the first block to be removed is
1143 * beyond the maximum file size (ie it is the same as last_block),
1144 * then there is nothing to do.
1145 */
1158 XFS_ITRUNC_MAX_EXTENTS,
1164 /*
1165 * Duplicate the transaction that has the permanent
1166 * reservation and commit the old transaction.
1167 */
1175 /*
1176 * Mark the inode dirty so it will be logged and
1177 * moved forward in the log as part of every commit.
1178 */
1180 }
1191 /*
1192 * Transaction commit worked ok so we can drop the extra ticket
1193 * reference that we gained in xfs_trans_dup()
1194 */
1198 XFS_TRANS_PERM_LOG_RES,
1199 XFS_ITRUNCATE_LOG_COUNT);
1202 }
1204 /*
1205 * Always re-log the inode so that our permanent transaction can keep
1206 * on rolling it forward in the log.
1207 */
1212 out:
1215 out_bmap_cancel:
1216 /*
1217 * If the bunmapi call encounters an error, return to the caller where
1218 * the transaction can be properly aborted. We just need to make sure
1219 * we're not holding any resources that we were not when we came in.
1220 */
1223 }
1225 /*
1226 * This is called when the inode's link count goes to 0.
1227 * We place the on-disk inode on a list in the AGI. It
1228 * will be pulled from this list when the inode is freed.
1229 */
1230 int
1234 {
1240 xfs_agino_t agino;
1250 /*
1251 * Get the agi buffer first. It ensures lock ordering
1252 * on the list.
1253 */
1259 /*
1260 * Get the index into the agi hash table for the
1261 * list this inode will go on.
1262 */
1270 /*
1271 * There is already another inode in the bucket we need
1272 * to add ourselves to. Add us at the front of the list.
1273 * Here we put the head pointer into our next pointer,
1274 * and then we fall through to point the head at us.
1275 */
1289 }
1291 /*
1292 * Point the bucket head pointer at the inode being inserted.
1293 */
1301 }
1303 /*
1304 * Pull the on-disk inode from the AGI unlinked list.
1305 */
1306 STATIC int
1310 {
1311 xfs_ino_t next_ino;
1317 xfs_agnumber_t agno;
1318 xfs_agino_t agino;
1319 xfs_agino_t next_agino;
1329 /*
1330 * Get the agi buffer first. It ensures lock ordering
1331 * on the list.
1332 */
1339 /*
1340 * Get the index into the agi hash table for the
1341 * list this inode will go on.
1342 */
1350 /*
1351 * We're at the head of the list. Get the inode's on-disk
1352 * buffer to see if there is anyone after us on the list.
1353 * Only modify our next pointer if it is not already NULLAGINO.
1354 * This saves us the overhead of dealing with the buffer when
1355 * there is no need to change it.
1356 */
1363 }
1376 }
1377 /*
1378 * Point the bucket head pointer at the next inode.
1379 */
1388 /*
1389 * We need to search the list for the inode being freed.
1390 */
1408 }
1417 }
1423 }
1425 /*
1426 * Now last_ibp points to the buffer previous to us on the
1427 * unlinked list. Pull us from the list.
1428 */
1435 }
1449 }
1450 /*
1451 * Point the previous inode on the list to the next inode.
1452 */
1460 }
1462 }
1464 /*
1465 * A big issue when freeing the inode cluster is is that we _cannot_ skip any
1466 * inodes that are in memory - they all must be marked stale and attached to
1467 * the cluster buffer.
1468 */
1469 STATIC int
1473 xfs_ino_t inum)
1474 {
1480 xfs_daddr_t blkno;
1497 }
1503 /*
1504 * We obtain and lock the backing buffer first in the process
1505 * here, as we have to ensure that any dirty inode that we
1506 * can't get the flush lock on is attached to the buffer.
1507 * If we scan the in-memory inodes first, then buffer IO can
1508 * complete before we get a lock on it, and hence we may fail
1509 * to mark all the active inodes on the buffer stale.
1510 */
1516 /*
1517 * Walk the inodes already attached to the buffer and mark them
1518 * stale. These will all have the flush locks held, so an
1519 * in-memory inode walk can't lock them. By marking them all
1520 * stale first, we will not attempt to lock them in the loop
1521 * below as the XFS_ISTALE flag will be set.
1522 */
1533 }
1535 }
1538 /*
1539 * For each inode in memory attempt to add it to the inode
1540 * buffer and set it up for being staled on buffer IO
1541 * completion. This is safe as we've locked out tail pushing
1542 * and flushing by locking the buffer.
1543 *
1544 * We have already marked every inode that was part of a
1545 * transaction stale above, which means there is no point in
1546 * even trying to lock them.
1547 */
1549 retry:
1554 /* Inode not in memory, nothing to do */
1558 }
1560 /*
1561 * because this is an RCU protected lookup, we could
1562 * find a recently freed or even reallocated inode
1563 * during the lookup. We need to check under the
1564 * i_flags_lock for a valid inode here. Skip it if it
1565 * is not valid, the wrong inode or stale.
1566 */
1573 }
1576 /*
1577 * Don't try to lock/unlock the current inode, but we
1578 * _cannot_ skip the other inodes that we did not find
1579 * in the list attached to the buffer and are not
1580 * already marked stale. If we can't lock it, back off
1581 * and retry.
1582 */
1588 }
1594 /*
1595 * we don't need to attach clean inodes or those only
1596 * with unlogged changes (which we throw away, anyway).
1597 */
1604 }
1617 }
1621 }
1625 }
1627 /*
1628 * This is called to return an inode to the inode free list.
1629 * The inode should already be truncated to 0 length and have
1630 * no pages associated with it. This routine also assumes that
1631 * the inode is already a part of the transaction.
1632 *
1633 * The on-disk copy of the inode will have been added to the list
1634 * of unlinked inodes in the AGI. We need to remove the inode from
1635 * that list atomically with respect to freeing it here.
1636 */
1637 int
1642 {
1645 xfs_ino_t first_ino;
1656 /*
1657 * Pull the on-disk inode from the AGI unlinked list.
1658 */
1662 }
1667 }
1674 /*
1675 * Bump the generation count so no one will be confused
1676 * by reincarnations of this inode.
1677 */
1687 /*
1688 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
1689 * from picking up this inode when it is reclaimed (its incore state
1690 * initialzed but not flushed to disk yet). The in-core di_mode is
1691 * already cleared and a corresponding transaction logged.
1692 * The hack here just synchronizes the in-core to on-disk
1693 * di_mode value in advance before the actual inode sync to disk.
1694 * This is OK because the inode is already unlinked and would never
1695 * change its di_mode again for this inode generation.
1696 * This is a temporary hack that would require a proper fix
1697 * in the future.
1698 */
1703 }
1706 }
1708 /*
1709 * Reallocate the space for if_broot based on the number of records
1710 * being added or deleted as indicated in rec_diff. Move the records
1711 * and pointers in if_broot to fit the new size. When shrinking this
1712 * will eliminate holes between the records and pointers created by
1713 * the caller. When growing this will create holes to be filled in
1714 * by the caller.
1715 *
1716 * The caller must not request to add more records than would fit in
1717 * the on-disk inode root. If the if_broot is currently NULL, then
1718 * if we adding records one will be allocated. The caller must also
1719 * not request that the number of records go below zero, although
1720 * it can go to zero.
1721 *
1722 * ip -- the inode whose if_broot area is changing
1723 * ext_diff -- the change in the number of records, positive or negative,
1724 * requested for the if_broot array.
1725 */
1726 void
1731 {
1741 /*
1742 * Handle the degenerate case quietly.
1743 */
1746 }
1750 /*
1751 * If there wasn't any memory allocated before, just
1752 * allocate it now and get out.
1753 */
1759 }
1761 /*
1762 * If there is already an existing if_broot, then we need
1763 * to realloc() it and shift the pointers to their new
1764 * location. The records don't change location because
1765 * they are kept butted up against the btree block header.
1766 */
1782 }
1784 /*
1785 * rec_diff is less than 0. In this case, we are shrinking the
1786 * if_broot buffer. It must already exist. If we go to zero
1787 * records, just get rid of the root and clear the status bit.
1788 */
1795 else
1799 /*
1800 * First copy over the btree block header.
1801 */
1806 }
1808 /*
1809 * Only copy the records and pointers if there are any.
1810 */
1812 /*
1813 * First copy the records.
1814 */
1819 /*
1820 * Then copy the pointers.
1821 */
1827 }
1834 }
1837 /*
1838 * This is called when the amount of space needed for if_data
1839 * is increased or decreased. The change in size is indicated by
1840 * the number of bytes that need to be added or deleted in the
1841 * byte_diff parameter.
1842 *
1843 * If the amount of space needed has decreased below the size of the
1844 * inline buffer, then switch to using the inline buffer. Otherwise,
1845 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
1846 * to what is needed.
1847 *
1848 * ip -- the inode whose if_data area is changing
1849 * byte_diff -- the change in the number of bytes, positive or negative,
1850 * requested for the if_data array.
1851 */
1852 void
1857 {
1864 }
1873 }
1877 /*
1878 * If the valid extents/data can fit in if_inline_ext/data,
1879 * copy them from the malloc'd vector and free it.
1880 */
1886 new_size);
1889 }
1892 /*
1893 * Stuck with malloc/realloc.
1894 * For inline data, the underlying buffer must be
1895 * a multiple of 4 bytes in size so that it can be
1896 * logged and stay on word boundaries. We enforce
1897 * that here.
1898 */
1905 /*
1906 * Only do the realloc if the underlying size
1907 * is really changing.
1908 */
1912 real_size,
1915 }
1922 }
1923 }
1927 }
1929 void
1933 {
1940 }
1942 /*
1943 * If the format is local, then we can't have an extents
1944 * array so just look for an inline data array. If we're
1945 * not local then we may or may not have an extents list,
1946 * so check and free it up if we do.
1947 */
1955 }
1962 }
1969 }
1970 }
1972 /*
1973 * This is called to unpin an inode. The caller must have the inode locked
1974 * in at least shared mode so that the buffer cannot be subsequently pinned
1975 * once someone is waiting for it to be unpinned.
1976 */
1977 static void
1980 {
1985 /* Give the log a push to start the unpinning I/O */
1988 }
1990 static void
1993 {
2005 }
2007 void
2010 {
2013 }
2015 /*
2016 * xfs_iextents_copy()
2017 *
2018 * This is called to copy the REAL extents (as opposed to the delayed
2019 * allocation extents) from the inode into the given buffer. It
2020 * returns the number of bytes copied into the buffer.
2021 *
2022 * If there are no delayed allocation extents, then we can just
2023 * memcpy() the extents into the buffer. Otherwise, we need to
2024 * examine each extent in turn and skip those which are delayed.
2025 */
2026 int
2031 {
2036 xfs_fsblock_t start_block;
2046 /*
2047 * There are some delayed allocation extents in the
2048 * inode, so copy the extents one at a time and skip
2049 * the delayed ones. There must be at least one
2050 * non-delayed extent.
2051 */
2057 /*
2058 * It's a delayed allocation extent, so skip it.
2059 */
2061 }
2063 /* Translate to on disk format */
2066 dp++;
2067 copied++;
2068 }
2073 }
2075 /*
2076 * Each of the following cases stores data into the same region
2077 * of the on-disk inode, so only one of them can be valid at
2078 * any given time. While it is possible to have conflicting formats
2079 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2080 * in EXTENTS format, this can only happen when the fork has
2081 * changed formats after being modified but before being flushed.
2082 * In these cases, the format always takes precedence, because the
2083 * format indicates the current state of the fork.
2084 */
2085 /*ARGSUSED*/
2086 STATIC void
2093 {
2097 #ifdef XFS_TRANS_DEBUG
2099 #endif
2110 /*
2111 * This can happen if we gave up in iformat in an error path,
2112 * for the attribute fork.
2113 */
2117 }
2127 }
2138 whichfork);
2139 }
2148 XFS_BROOT_SIZE_ADJ));
2152 }
2159 }
2168 }
2174 }
2175 }
2177 STATIC int
2181 {
2205 /* really need a gang lookup range call here */
2216 /*
2217 * because this is an RCU protected lookup, we could find a
2218 * recently freed or even reallocated inode during the lookup.
2219 * We need to check under the i_flags_lock for a valid inode
2220 * here. Skip it if it is not valid or the wrong inode.
2221 */
2227 }
2230 /*
2231 * Do an un-protected check to see if the inode is dirty and
2232 * is a candidate for flushing. These checks will be repeated
2233 * later after the appropriate locks are acquired.
2234 */
2238 /*
2239 * Try to get locks. If any are unavailable or it is pinned,
2240 * then this inode cannot be flushed and is skipped.
2241 */
2248 }
2253 }
2255 /*
2256 * arriving here means that this inode can be flushed. First
2257 * re-check that it's dirty before flushing.
2258 */
2265 }
2266 clcount++;
2269 }
2271 }
2276 }
2278 out_free:
2281 out_put:
2286 cluster_corrupt_out:
2287 /*
2288 * Corruption detected in the clustering loop. Invalidate the
2289 * inode buffer and shut down the filesystem.
2290 */
2292 /*
2293 * Clean up the buffer. If it was delwri, just release it --
2294 * brelse can handle it with no problems. If not, shut down the
2295 * filesystem before releasing the buffer.
2296 */
2304 /*
2305 * Just like incore_relse: if we have b_iodone functions,
2306 * mark the buffer as an error and call them. Otherwise
2307 * mark it as stale and brelse.
2308 */
2317 }
2318 }
2320 /*
2321 * Unlocks the flush lock
2322 */
2327 }
2329 /*
2330 * Flush dirty inode metadata into the backing buffer.
2331 *
2332 * The caller must have the inode lock and the inode flush lock held. The
2333 * inode lock will still be held upon return to the caller, and the inode
2334 * flush lock will be released after the inode has reached the disk.
2335 *
2336 * The caller must write out the buffer returned in *bpp and release it.
2337 */
2338 int
2342 {
2359 /*
2360 * For stale inodes we cannot rely on the backing buffer remaining
2361 * stale in cache for the remaining life of the stale inode and so
2362 * xfs_imap_to_bp() below may give us a buffer that no longer contains
2363 * inodes below. We have to check this after ensuring the inode is
2364 * unpinned so that it is safe to reclaim the stale inode after the
2365 * flush call.
2366 */
2370 }
2372 /*
2373 * This may have been unpinned because the filesystem is shutting
2374 * down forcibly. If that's the case we must not write this inode
2375 * to disk, because the log record didn't make it to disk.
2376 *
2377 * We also have to remove the log item from the AIL in this case,
2378 * as we wait for an empty AIL as part of the unmount process.
2379 */
2383 }
2385 /*
2386 * Get the buffer containing the on-disk inode.
2387 */
2393 }
2395 /*
2396 * First flush out the inode that xfs_iflush was called with.
2397 */
2402 /*
2403 * If the buffer is pinned then push on the log now so we won't
2404 * get stuck waiting in the write for too long.
2405 */
2409 /*
2410 * inode clustering:
2411 * see if other inodes can be gathered into this write
2412 */
2420 corrupt_out:
2423 cluster_corrupt_out:
2425 abort_out:
2426 /*
2427 * Unlocks the flush lock
2428 */
2431 }
2434 STATIC int
2438 {
2442 #ifdef XFS_TRANS_DEBUG
2444 #endif
2454 /* set *dip = inode's place in the buffer */
2463 }
2470 }
2480 }
2491 }
2492 }
2495 XFS_RANDOM_IFLUSH_5)) {
2497 "%s: detected corrupt incore inode %Lu, "
2503 }
2510 }
2511 /*
2512 * bump the flush iteration count, used to detect flushes which
2513 * postdate a log record during recovery.
2514 */
2518 /*
2519 * Copy the dirty parts of the inode into the on-disk
2520 * inode. We always copy out the core of the inode,
2521 * because if the inode is dirty at all the core must
2522 * be.
2523 */
2526 /* Wrap, we never let the log put out DI_MAX_FLUSH */
2530 /*
2531 * If this is really an old format inode and the superblock version
2532 * has not been updated to support only new format inodes, then
2533 * convert back to the old inode format. If the superblock version
2534 * has been updated, then make the conversion permanent.
2535 */
2539 /*
2540 * Convert it back.
2541 */
2545 /*
2546 * The superblock version has already been bumped,
2547 * so just make the conversion to the new inode
2548 * format permanent.
2549 */
2558 }
2559 }
2566 /*
2567 * We've recorded everything logged in the inode, so we'd like to clear
2568 * the ili_fields bits so we don't log and flush things unnecessarily.
2569 * However, we can't stop logging all this information until the data
2570 * we've copied into the disk buffer is written to disk. If we did we
2571 * might overwrite the copy of the inode in the log with all the data
2572 * after re-logging only part of it, and in the face of a crash we
2573 * wouldn't have all the data we need to recover.
2574 *
2575 * What we do is move the bits to the ili_last_fields field. When
2576 * logging the inode, these bits are moved back to the ili_fields field.
2577 * In the xfs_iflush_done() routine we clear ili_last_fields, since we
2578 * know that the information those bits represent is permanently on
2579 * disk. As long as the flush completes before the inode is logged
2580 * again, then both ili_fields and ili_last_fields will be cleared.
2581 *
2582 * We can play with the ili_fields bits here, because the inode lock
2583 * must be held exclusively in order to set bits there and the flush
2584 * lock protects the ili_last_fields bits. Set ili_logged so the flush
2585 * done routine can tell whether or not to look in the AIL. Also, store
2586 * the current LSN of the inode so that we can tell whether the item has
2587 * moved in the AIL from xfs_iflush_done(). In order to read the lsn we
2588 * need the AIL lock, because it is a 64 bit value that cannot be read
2589 * atomically.
2590 */
2599 /*
2600 * Attach the function xfs_iflush_done to the inode's
2601 * buffer. This will remove the inode from the AIL
2602 * and unlock the inode's flush lock when the inode is
2603 * completely written to disk.
2604 */
2610 /*
2611 * We're flushing an inode which is not in the AIL and has
2612 * not been logged. For this case we can immediately drop
2613 * the inode flush lock because we can avoid the whole
2614 * AIL state thing. It's OK to drop the flush lock now,
2615 * because we've already locked the buffer and to do anything
2616 * you really need both.
2617 */
2622 }
2624 }
2628 corrupt_out:
2630 }
2632 /*
2633 * Return a pointer to the extent record at file index idx.
2634 */
2635 xfs_bmbt_rec_host_t *
2639 {
2656 }
2657 }
2659 /*
2660 * Insert new item(s) into the extent records for incore inode
2661 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
2662 */
2663 void
2670 {
2680 }
2682 /*
2683 * This is called when the amount of space required for incore file
2684 * extents needs to be increased. The ext_diff parameter stores the
2685 * number of new extents being added and the idx parameter contains
2686 * the extent index where the new extents will be added. If the new
2687 * extents are being appended, then we just need to (re)allocate and
2688 * initialize the space. Otherwise, if the new extents are being
2689 * inserted into the middle of the existing entries, a bit more work
2690 * is required to make room for the new extents to be inserted. The
2691 * caller is responsible for filling in the new extent entries upon
2692 * return.
2693 */
2694 void
2699 {
2708 /*
2709 * If the new number of extents (nextents + ext_diff)
2710 * fits inside the inode, then continue to use the inline
2711 * extent buffer.
2712 */
2719 }
2722 }
2723 /*
2724 * Otherwise use a linear (direct) extent list.
2725 * If the extents are currently inside the inode,
2726 * xfs_iext_realloc_direct will switch us from
2727 * inline to direct extent allocation mode.
2728 */
2736 }
2737 }
2738 /* Indirection array */
2751 }
2752 /* Extents fit in target extent page */
2760 }
2763 }
2764 /* Insert a new extent page */
2768 }
2769 /*
2770 * If extent(s) are being appended to the last page in
2771 * the indirection array and the new extent(s) don't fit
2772 * in the page, then erp is NULL and erp_idx is set to
2773 * the next index needed in the indirection array.
2774 */
2783 erp_idx++;
2784 }
2785 }
2786 }
2787 }
2789 }
2791 /*
2792 * This is called when incore extents are being added to the indirection
2793 * array and the new extents do not fit in the target extent list. The
2794 * erp_idx parameter contains the irec index for the target extent list
2795 * in the indirection array, and the idx parameter contains the extent
2796 * index within the list. The number of extents being added is stored
2797 * in the count parameter.
2798 *
2799 * |-------| |-------|
2800 * | | | | idx - number of extents before idx
2801 * | idx | | count |
2802 * | | | | count - number of extents being inserted at idx
2803 * |-------| |-------|
2804 * | count | | nex2 | nex2 - number of extents after idx + count
2805 * |-------| |-------|
2806 */
2807 void
2813 {
2827 /*
2828 * Save second part of target extent list
2829 * (all extents past */
2837 }
2839 /*
2840 * Add the new extents to the end of the target
2841 * list, then allocate new irec record(s) and
2842 * extent buffer(s) as needed to store the rest
2843 * of the new extents.
2844 */
2851 }
2853 erp_idx++;
2859 }
2861 /* Add nex2 extents back to indirection array */
2863 xfs_extnum_t ext_avail;
2869 /*
2870 * If nex2 extents fit in the current page, append
2871 * nex2_ep after the new extents.
2872 */
2875 }
2876 /*
2877 * Otherwise, check if space is available in the
2878 * next page.
2879 */
2883 erp_idx++;
2884 erp++;
2885 /* Create a hole for nex2 extents */
2888 }
2889 /*
2890 * Final choice, create a new extent page for
2891 * nex2 extents.
2892 */
2894 erp_idx++;
2896 }
2901 }
2902 }
2904 /*
2905 * This is called when the amount of space required for incore file
2906 * extents needs to be decreased. The ext_diff parameter stores the
2907 * number of extents to be removed and the idx parameter contains
2908 * the extent index where the extents will be removed from.
2909 *
2910 * If the amount of space needed has decreased below the linear
2911 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
2912 * extent array. Otherwise, use kmem_realloc() to adjust the
2913 * size to what is needed.
2914 */
2915 void
2921 {
2940 }
2942 }
2944 /*
2945 * This removes ext_diff extents from the inline buffer, beginning
2946 * at extent index idx.
2947 */
2948 void
2953 {
2972 }
2973 }
2975 /*
2976 * This removes ext_diff extents from a linear (direct) extent list,
2977 * beginning at extent index idx. If the extents are being removed
2978 * from the end of the list (ie. truncate) then we just need to re-
2979 * allocate the list to remove the extra space. Otherwise, if the
2980 * extents are being removed from the middle of the existing extent
2981 * entries, then we first need to move the extent records beginning
2982 * at idx + ext_diff up in the list to overwrite the records being
2983 * removed, then remove the extra space via kmem_realloc.
2984 */
2985 void
2990 {
3002 }
3003 /* Move extents up in the list (if needed) */
3009 }
3012 /*
3013 * Reallocate the direct extent list. If the extents
3014 * will fit inside the inode then xfs_iext_realloc_direct
3015 * will switch from direct to inline extent allocation
3016 * mode for us.
3017 */
3020 }
3022 /*
3023 * This is called when incore extents are being removed from the
3024 * indirection array and the extents being removed span multiple extent
3025 * buffers. The idx parameter contains the file extent index where we
3026 * want to begin removing extents, and the count parameter contains
3027 * how many extents need to be removed.
3028 *
3029 * |-------| |-------|
3030 * | nex1 | | | nex1 - number of extents before idx
3031 * |-------| | count |
3032 * | | | | count - number of extents being removed at idx
3033 * | count | |-------|
3034 * | | | nex2 | nex2 - number of extents after idx + count
3035 * |-------| |-------|
3036 */
3037 void
3042 {
3059 /*
3060 * Check for deletion of entire list;
3061 * xfs_iext_irec_remove() updates extent offsets.
3062 */
3069 XFS_IEXT_BUFSZ);
3075 }
3076 }
3077 /* Move extents up (if needed) */
3082 }
3083 /* Zero out rest of page */
3086 /* Update remaining counters */
3091 erp_idx++;
3092 erp++;
3093 }
3096 }
3098 /*
3099 * Create, destroy, or resize a linear (direct) block of extents.
3100 */
3101 void
3105 {
3114 /* Free extent records */
3117 }
3118 /* Resize direct extent list and zero any new bytes */
3120 /* Check if extents will fit inside the inode */
3126 }
3129 }
3133 rnew_size,
3135 }
3140 }
3141 }
3142 /*
3143 * Switch from the inline extent buffer to a direct
3144 * extent list. Be sure to include the inline extent
3145 * bytes in new_size.
3146 */
3151 }
3153 }
3156 }
3158 /*
3159 * Switch from linear (direct) extent records to inline buffer.
3160 */
3161 void
3165 {
3168 /*
3169 * The inline buffer was zeroed when we switched
3170 * from inline to direct extent allocation mode,
3171 * so we don't need to clear it here.
3172 */
3178 }
3180 /*
3181 * Switch from inline buffer to linear (direct) extent records.
3182 * new_size should already be rounded up to the next power of 2
3183 * by the caller (when appropriate), so use new_size as it is.
3184 * However, since new_size may be rounded up, we can't update
3185 * if_bytes here. It is the caller's responsibility to update
3186 * if_bytes upon return.
3187 */
3188 void
3192 {
3200 }
3202 }
3204 /*
3205 * Resize an extent indirection array to new_size bytes.
3206 */
3207 STATIC void
3211 {
3226 }
3227 }
3229 /*
3230 * Switch from indirection array to linear (direct) extent allocations.
3231 */
3232 STATIC void
3235 {
3255 }
3256 }
3258 /*
3259 * Free incore file extents.
3260 */
3261 void
3264 {
3272 }
3279 }
3283 }
3285 /*
3286 * Return a pointer to the extent record for file system block bno.
3287 */
3293 {
3308 }
3311 /* Find target extent list */
3319 }
3320 /* Binary search extent records */
3331 /* Convert back to file-based extent index */
3334 }
3337 }
3338 }
3339 /* Convert back to file-based extent index */
3342 }
3348 }
3349 }
3352 }
3354 /*
3355 * Return a pointer to the indirection array entry containing the
3356 * extent record for filesystem block bno. Store the index of the
3357 * target irec in *erp_idxp.
3358 */
3364 {
3388 }
3389 }
3392 }
3394 /*
3395 * Return a pointer to the indirection array entry containing the
3396 * extent record at file extent index *idxp. Store the index of the
3397 * target irec in *erp_idxp and store the page index of the target
3398 * extent record in *idxp.
3399 */
3400 xfs_ext_irec_t *
3406 {
3425 /* Binary search extent irec's */
3441 erp_idx++;
3447 }
3448 }
3452 }
3454 /*
3455 * Allocate and initialize an indirection array once the space needed
3456 * for incore extents increases above XFS_IEXT_BUFSZ.
3457 */
3458 void
3461 {
3477 }
3488 }
3490 /*
3491 * Allocate and initialize a new entry in the indirection array.
3492 */
3493 xfs_ext_irec_t *
3497 {
3505 /* Resize indirection array */
3508 /*
3509 * Move records down in the array so the
3510 * new page can use erp_idx.
3511 */
3515 }
3518 /* Initialize new extent record */
3527 }
3529 /*
3530 * Remove a record from the indirection array.
3531 */
3532 void
3536 {
3548 }
3549 /* Compact extent records */
3553 }
3554 /*
3555 * Manually free the last extent record from the indirection
3556 * array. A call to xfs_iext_realloc_indirect() with a size
3557 * of zero would result in a call to xfs_iext_destroy() which
3558 * would in turn call this function again, creating a nasty
3559 * infinite loop.
3560 */
3566 }
3568 }
3570 /*
3571 * This is called to clean up large amounts of unused memory allocated
3572 * by the indirection array. Before compacting anything though, verify
3573 * that the indirection array is still needed and switch back to the
3574 * linear extent list (or even the inline buffer) if possible. The
3575 * compaction policy is as follows:
3576 *
3577 * Full Compaction: Extents fit into a single page (or inline buffer)
3578 * Partial Compaction: Extents occupy less than 50% of allocated space
3579 * No Compaction: Extents occupy at least 50% of allocated space
3580 */
3581 void
3584 {
3601 }
3602 }
3604 /*
3605 * Combine extents from neighboring extent pages.
3606 */
3607 void
3610 {
3626 /*
3627 * Free page before removing extent record
3628 * so er_extoffs don't get modified in
3629 * xfs_iext_irec_remove.
3630 */
3636 erp_idx++;
3637 }
3638 }
3639 }
3641 /*
3642 * This is called to update the er_extoff field in the indirection
3643 * array when extents have been added or removed from one of the
3644 * extent lists. erp_idx contains the irec index to begin updating
3645 * at and ext_diff contains the number of extents that were added
3646 * or removed.
3647 */
3648 void
3653 {
3661 }
3662 }