| blob | f010ab4594f1ac9b8b7917ed31d61dcf6b400221 |
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>
54 /*
55 * Used in xfs_itruncate_extents(). This is the maximum number of extents
56 * freed from a file in a single transaction.
57 */
58 #define XFS_ITRUNC_MAX_EXTENTS 2
65 /*
66 * helper function to extract extent size hint from inode
67 */
68 xfs_extlen_t
71 {
77 }
79 /*
80 * This is a wrapper routine around the xfs_ilock() routine used to centralize
81 * some grungy code. It is used in places that wish to lock the inode solely
82 * for reading the extents. The reason these places can't just call
83 * xfs_ilock(SHARED) is that the inode lock also guards to bringing in of the
84 * extents from disk for a file in b-tree format. If the inode is in b-tree
85 * format, then we need to lock the inode exclusively until the extents are read
86 * in. Locking it exclusively all the time would limit our parallelism
87 * unnecessarily, though. What we do instead is check to see if the extents
88 * have been read in yet, and only lock the inode exclusively if they have not.
89 *
90 * The function returns a value which should be given to the corresponding
91 * xfs_iunlock_map_shared(). This value is the mode in which the lock was
92 * actually taken.
93 */
94 uint
97 {
98 uint lock_mode;
105 }
110 }
112 /*
113 * This is simply the unlock routine to go with xfs_ilock_map_shared().
114 * All it does is call xfs_iunlock() with the given lock_mode.
115 */
116 void
120 {
122 }
124 /*
125 * The xfs inode contains 2 locks: a multi-reader lock called the
126 * i_iolock and a multi-reader lock called the i_lock. This routine
127 * allows either or both of the locks to be obtained.
128 *
129 * The 2 locks should always be ordered so that the IO lock is
130 * obtained first in order to prevent deadlock.
131 *
132 * ip -- the inode being locked
133 * lock_flags -- this parameter indicates the inode's locks
134 * to be locked. It can be:
135 * XFS_IOLOCK_SHARED,
136 * XFS_IOLOCK_EXCL,
137 * XFS_ILOCK_SHARED,
138 * XFS_ILOCK_EXCL,
139 * XFS_IOLOCK_SHARED | XFS_ILOCK_SHARED,
140 * XFS_IOLOCK_SHARED | XFS_ILOCK_EXCL,
141 * XFS_IOLOCK_EXCL | XFS_ILOCK_SHARED,
142 * XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL
143 */
144 void
147 uint lock_flags)
148 {
151 /*
152 * You can't set both SHARED and EXCL for the same lock,
153 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
154 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
155 */
171 }
173 /*
174 * This is just like xfs_ilock(), except that the caller
175 * is guaranteed not to sleep. It returns 1 if it gets
176 * the requested locks and 0 otherwise. If the IO lock is
177 * obtained but the inode lock cannot be, then the IO lock
178 * is dropped before returning.
179 *
180 * ip -- the inode being locked
181 * lock_flags -- this parameter indicates the inode's locks to be
182 * to be locked. See the comment for xfs_ilock() for a list
183 * of valid values.
184 */
185 int
188 uint lock_flags)
189 {
192 /*
193 * You can't set both SHARED and EXCL for the same lock,
194 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
195 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
196 */
209 }
216 }
219 out_undo_iolock:
224 out:
226 }
228 /*
229 * xfs_iunlock() is used to drop the inode locks acquired with
230 * xfs_ilock() and xfs_ilock_nowait(). The caller must pass
231 * in the flags given to xfs_ilock() or xfs_ilock_nowait() so
232 * that we know which locks to drop.
233 *
234 * ip -- the inode being unlocked
235 * lock_flags -- this parameter indicates the inode's locks to be
236 * to be unlocked. See the comment for xfs_ilock() for a list
237 * of valid values for this parameter.
238 *
239 */
240 void
243 uint lock_flags)
244 {
245 /*
246 * You can't set both SHARED and EXCL for the same lock,
247 * and only XFS_IOLOCK_SHARED, XFS_IOLOCK_EXCL, XFS_ILOCK_SHARED,
248 * and XFS_ILOCK_EXCL are valid values to set in lock_flags.
249 */
268 }
270 /*
271 * give up write locks. the i/o lock cannot be held nested
272 * if it is being demoted.
273 */
274 void
277 uint lock_flags)
278 {
288 }
290 #if defined(DEBUG) || defined(XFS_WARN)
291 int
294 uint lock_flags)
295 {
300 }
306 }
310 }
311 #endif
313 void
316 {
327 }
329 #ifdef DEBUG
330 /*
331 * Make sure that the extents in the given memory buffer
332 * are valid.
333 */
334 STATIC void
338 xfs_exntfmt_t fmt)
339 {
340 xfs_bmbt_irec_t irec;
341 xfs_bmbt_rec_host_t rec;
351 }
352 }
354 #define xfs_validate_extents(ifp, nrecs, fmt)
357 /*
358 * Check that none of the inode's in the buffer have a next
359 * unlinked field of 0.
360 */
361 #if defined(DEBUG)
362 void
366 {
379 bp);
381 }
382 }
383 }
384 #endif
386 static void
389 {
394 /*
395 * Validate the magic number and version of every inode in the buffer
396 */
407 XFS_ERRTAG_ITOBP_INOTOBP,
408 XFS_RANDOM_ITOBP_INOTOBP))) {
412 #ifdef DEBUG
418 #endif
419 }
420 }
422 }
425 static void
428 {
430 }
432 static void
435 {
437 }
442 };
445 /*
446 * This routine is called to map an inode to the buffer containing the on-disk
447 * version of the inode. It returns a pointer to the buffer containing the
448 * on-disk inode in the bpp parameter, and in the dipp parameter it returns a
449 * pointer to the on-disk inode within that buffer.
450 *
451 * If a non-zero error is returned, then the contents of bpp and dipp are
452 * undefined.
453 */
454 int
461 uint buf_flags,
462 uint iget_flags)
463 {
475 }
484 }
489 }
491 /*
492 * Move inode type and inode format specific information from the
493 * on-disk inode to the in-core inode. For fifos, devs, and sockets
494 * this means set if_rdev to the proper value. For files, directories,
495 * and symlinks this means to bring in the in-line data or extent
496 * pointers. For a file in B-tree format, only the root is immediately
497 * brought in-core. The rest will be in-lined in if_extents when it
498 * is first referenced (see xfs_iread_extents()).
499 */
500 STATIC int
504 {
508 xfs_fsize_t di_size;
523 }
532 }
542 }
553 }
563 /*
564 * no local regular files yet
565 */
571 XFS_ERRLEVEL_LOW,
574 }
583 XFS_ERRLEVEL_LOW,
586 }
601 }
607 }
610 }
628 XFS_ERRLEVEL_LOW,
631 }
644 }
649 }
651 }
653 /*
654 * The file is in-lined in the on-disk inode.
655 * If it fits into if_inline_data, then copy
656 * it there, otherwise allocate a buffer for it
657 * and copy the data there. Either way, set
658 * if_data to point at the data.
659 * If we allocate a buffer for the data, make
660 * sure that its size is a multiple of 4 and
661 * record the real size in i_real_bytes.
662 */
663 STATIC int
669 {
673 /*
674 * If the size is unreasonable, then something
675 * is wrong and we just bail out rather than crash in
676 * kmem_alloc() or memcpy() below.
677 */
686 }
696 }
704 }
706 /*
707 * The file consists of a set of extents all
708 * of which fit into the on-disk inode.
709 * If there are few enough extents to fit into
710 * the if_inline_ext, then copy them there.
711 * Otherwise allocate a buffer for them and copy
712 * them into it. Either way, set if_extents
713 * to point at the extents.
714 */
715 STATIC int
720 {
731 /*
732 * If the number of extents is unreasonable, then something
733 * is wrong and we just bail out rather than crash in
734 * kmem_alloc() or memcpy() below.
735 */
742 }
749 else
760 }
767 XFS_ERRLEVEL_LOW,
770 }
771 }
774 }
776 /*
777 * The file has too many extents to fit into
778 * the inode, so they are in B-tree format.
779 * Allocate a buffer for the root of the B-tree
780 * and copy the root into it. The i_extents
781 * field will remain NULL until all of the
782 * extents are read in (when they are needed).
783 */
784 STATIC int
789 {
793 /* REFERENCED */
802 /*
803 * blow out if -- fork has less extents than can fit in
804 * fork (fork shouldn't be a btree format), root btree
805 * block has more records than can fit into the fork,
806 * or the number of extents is greater than the number of
807 * blocks.
808 */
819 }
824 /*
825 * Copy and convert from the on-disk structure
826 * to the in-memory structure.
827 */
834 }
836 STATIC void
840 {
880 }
881 }
883 void
887 {
927 }
928 }
930 STATIC uint
932 __uint16_t di_flags)
933 {
965 }
968 }
970 uint
973 {
978 }
980 uint
983 {
986 }
988 static bool
993 {
997 /* only version 3 or greater inodes are extensively verified here */
1011 }
1013 void
1017 {
1018 __uint32_t crc;
1027 }
1029 /*
1030 * Read the disk inode attributes into the in-core inode structure.
1031 */
1032 int
1037 uint iget_flags)
1038 {
1043 /*
1044 * Fill in the location information in the in-core inode.
1045 */
1050 /*
1051 * Get pointers to the on-disk inode and the buffer containing it.
1052 */
1057 /* even unallocated inodes are verified */
1065 }
1067 /*
1068 * If the on-disk inode is already linked to a directory
1069 * entry, copy all of the inode into the in-core inode.
1070 * xfs_iformat() handles copying in the inode format
1071 * specific information.
1072 * Otherwise, just get the truly permanent information.
1073 */
1078 #ifdef DEBUG
1083 }
1085 /*
1086 * Partial initialisation of the in-core inode. Just the bits
1087 * that xfs_ialloc won't overwrite or relies on being correct.
1088 */
1097 }
1099 /*
1100 * Make sure to pull in the mode here as well in
1101 * case the inode is released without being used.
1102 * This ensures that xfs_inactive() will see that
1103 * the inode is already free and not try to mess
1104 * with the uninitialized part of it.
1105 */
1107 }
1109 /*
1110 * The inode format changed when we moved the link count and
1111 * made it 32 bits long. If this is an old format inode,
1112 * convert it in memory to look like a new one. If it gets
1113 * flushed to disk we will convert back before flushing or
1114 * logging it. We zero out the new projid field and the old link
1115 * count field. We'll handle clearing the pad field (the remains
1116 * of the old uuid field) when we actually convert the inode to
1117 * the new format. We don't change the version number so that we
1118 * can distinguish this from a real new format inode.
1119 */
1124 }
1128 /*
1129 * Mark the buffer containing the inode as something to keep
1130 * around for a while. This helps to keep recently accessed
1131 * meta-data in-core longer.
1132 */
1135 /*
1136 * Use xfs_trans_brelse() to release the buffer containing the
1137 * on-disk inode, because it was acquired with xfs_trans_read_buf()
1138 * in xfs_imap_to_bp() above. If tp is NULL, this is just a normal
1139 * brelse(). If we're within a transaction, then xfs_trans_brelse()
1140 * will only release the buffer if it is not dirty within the
1141 * transaction. It will be OK to release the buffer in this case,
1142 * because inodes on disk are never destroyed and we will be
1143 * locking the new in-core inode before putting it in the hash
1144 * table where other processes can find it. Thus we don't have
1145 * to worry about the inode being changed just because we released
1146 * the buffer.
1147 */
1148 out_brelse:
1151 }
1153 /*
1154 * Read in extents from a btree-format inode.
1155 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
1156 */
1157 int
1162 {
1165 xfs_extnum_t nextents;
1171 }
1175 /*
1176 * We know that the size is valid (it's checked in iformat_btree)
1177 */
1186 }
1189 }
1191 /*
1192 * Allocate an inode on disk and return a copy of its in-core version.
1193 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1194 * appropriately within the inode. The uid and gid for the inode are
1195 * set according to the contents of the given cred structure.
1196 *
1197 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1198 * has a free inode available, call xfs_iget() to obtain the in-core
1199 * version of the allocated inode. Finally, fill in the inode and
1200 * log its initial contents. In this case, ialloc_context would be
1201 * set to NULL.
1202 *
1203 * If xfs_dialloc() does not have an available inode, it will replenish
1204 * its supply by doing an allocation. Since we can only do one
1205 * allocation within a transaction without deadlocks, we must commit
1206 * the current transaction before returning the inode itself.
1207 * In this case, therefore, we will set ialloc_context and return.
1208 * The caller should then commit the current transaction, start a new
1209 * transaction, and call xfs_ialloc() again to actually get the inode.
1210 *
1211 * To ensure that some other process does not grab the inode that
1212 * was allocated during the first call to xfs_ialloc(), this routine
1213 * also returns the [locked] bp pointing to the head of the freelist
1214 * as ialloc_context. The caller should hold this buffer across
1215 * the commit and pass it back into this routine on the second call.
1216 *
1217 * If we are allocating quota inodes, we do not have a parent inode
1218 * to attach to or associate with (i.e. pip == NULL) because they
1219 * are not linked into the directory structure - they are attached
1220 * directly to the superblock - and so have no parent.
1221 */
1222 int
1226 umode_t mode,
1227 xfs_nlink_t nlink,
1228 xfs_dev_t rdev,
1229 prid_t prid,
1233 {
1235 xfs_ino_t ino;
1237 uint flags;
1239 timespec_t tv;
1242 /*
1243 * Call the space management code to pick
1244 * the on-disk inode to be allocated.
1245 */
1253 }
1256 /*
1257 * Get the in-core inode with the lock held exclusively.
1258 * This is because we're setting fields here we need
1259 * to prevent others from looking at until we're done.
1260 */
1276 /*
1277 * If the superblock version is up to where we support new format
1278 * inodes and this is currently an old format inode, then change
1279 * the inode version number now. This way we only do the conversion
1280 * here rather than here and in the flush/logging code.
1281 */
1285 /*
1286 * We've already zeroed the old link count, the projid field,
1287 * and the pad field.
1288 */
1289 }
1291 /*
1292 * Project ids won't be stored on disk if we are using a version 1 inode.
1293 */
1301 }
1302 }
1304 /*
1305 * If the group ID of the new file does not match the effective group
1306 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1307 * (and only if the irix_sgid_inherit compatibility variable is set).
1308 */
1313 }
1325 /*
1326 * di_gen will have been taken care of in xfs_iread.
1327 */
1342 }
1357 /*
1358 * we can't set up filestreams until after the VFS inode
1359 * is set up properly.
1360 */
1363 /* fall through */
1374 }
1381 }
1382 }
1384 xfs_inherit_noatime)
1387 xfs_inherit_nodump)
1390 xfs_inherit_sync)
1393 xfs_inherit_nosymlinks)
1398 xfs_inherit_nodefrag)
1403 }
1404 /* FALLTHROUGH */
1413 }
1414 /*
1415 * Attribute fork settings for new inode.
1416 */
1420 /*
1421 * Log the new values stuffed into the inode.
1422 */
1426 /* now that we have an i_mode we can setup inode ops and unlock */
1429 /* now we have set up the vfs inode we can associate the filestream */
1436 }
1440 }
1442 /*
1443 * Free up the underlying blocks past new_size. The new size must be smaller
1444 * than the current size. This routine can be used both for the attribute and
1445 * data fork, and does not modify the inode size, which is left to the caller.
1446 *
1447 * The transaction passed to this routine must have made a permanent log
1448 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1449 * given transaction and start new ones, so make sure everything involved in
1450 * the transaction is tidy before calling here. Some transaction will be
1451 * returned to the caller to be committed. The incoming transaction must
1452 * already include the inode, and both inode locks must be held exclusively.
1453 * The inode must also be "held" within the transaction. On return the inode
1454 * will be "held" within the returned transaction. This routine does NOT
1455 * require any disk space to be reserved for it within the transaction.
1456 *
1457 * If we get an error, we must return with the inode locked and linked into the
1458 * current transaction. This keeps things simple for the higher level code,
1459 * because it always knows that the inode is locked and held in the transaction
1460 * that returns to it whether errors occur or not. We don't mark the inode
1461 * dirty on error so that transactions can be easily aborted if possible.
1462 */
1463 int
1468 xfs_fsize_t new_size)
1469 {
1473 xfs_bmap_free_t free_list;
1474 xfs_fsblock_t first_block;
1475 xfs_fileoff_t first_unmap_block;
1476 xfs_fileoff_t last_block;
1477 xfs_filblks_t unmap_len;
1493 /*
1494 * Since it is possible for space to become allocated beyond
1495 * the end of the file (in a crash where the space is allocated
1496 * but the inode size is not yet updated), simply remove any
1497 * blocks which show up between the new EOF and the maximum
1498 * possible file size. If the first block to be removed is
1499 * beyond the maximum file size (ie it is the same as last_block),
1500 * then there is nothing to do.
1501 */
1514 XFS_ITRUNC_MAX_EXTENTS,
1520 /*
1521 * Duplicate the transaction that has the permanent
1522 * reservation and commit the old transaction.
1523 */
1531 /*
1532 * Mark the inode dirty so it will be logged and
1533 * moved forward in the log as part of every commit.
1534 */
1536 }
1547 /*
1548 * Transaction commit worked ok so we can drop the extra ticket
1549 * reference that we gained in xfs_trans_dup()
1550 */
1554 XFS_TRANS_PERM_LOG_RES,
1555 XFS_ITRUNCATE_LOG_COUNT);
1558 }
1560 /*
1561 * Always re-log the inode so that our permanent transaction can keep
1562 * on rolling it forward in the log.
1563 */
1568 out:
1571 out_bmap_cancel:
1572 /*
1573 * If the bunmapi call encounters an error, return to the caller where
1574 * the transaction can be properly aborted. We just need to make sure
1575 * we're not holding any resources that we were not when we came in.
1576 */
1579 }
1581 /*
1582 * This is called when the inode's link count goes to 0.
1583 * We place the on-disk inode on a list in the AGI. It
1584 * will be pulled from this list when the inode is freed.
1585 */
1586 int
1590 {
1596 xfs_agino_t agino;
1606 /*
1607 * Get the agi buffer first. It ensures lock ordering
1608 * on the list.
1609 */
1615 /*
1616 * Get the index into the agi hash table for the
1617 * list this inode will go on.
1618 */
1626 /*
1627 * There is already another inode in the bucket we need
1628 * to add ourselves to. Add us at the front of the list.
1629 * Here we put the head pointer into our next pointer,
1630 * and then we fall through to point the head at us.
1631 */
1642 /* need to recalc the inode CRC if appropriate */
1649 }
1651 /*
1652 * Point the bucket head pointer at the inode being inserted.
1653 */
1662 }
1664 /*
1665 * Pull the on-disk inode from the AGI unlinked list.
1666 */
1667 STATIC int
1671 {
1672 xfs_ino_t next_ino;
1678 xfs_agnumber_t agno;
1679 xfs_agino_t agino;
1680 xfs_agino_t next_agino;
1690 /*
1691 * Get the agi buffer first. It ensures lock ordering
1692 * on the list.
1693 */
1700 /*
1701 * Get the index into the agi hash table for the
1702 * list this inode will go on.
1703 */
1711 /*
1712 * We're at the head of the list. Get the inode's on-disk
1713 * buffer to see if there is anyone after us on the list.
1714 * Only modify our next pointer if it is not already NULLAGINO.
1715 * This saves us the overhead of dealing with the buffer when
1716 * there is no need to change it.
1717 */
1724 }
1732 /* need to recalc the inode CRC if appropriate */
1741 }
1742 /*
1743 * Point the bucket head pointer at the next inode.
1744 */
1754 /*
1755 * We need to search the list for the inode being freed.
1756 */
1774 }
1783 }
1789 }
1791 /*
1792 * Now last_ibp points to the buffer previous to us on the
1793 * unlinked list. Pull us from the list.
1794 */
1801 }
1810 /* need to recalc the inode CRC if appropriate */
1819 }
1820 /*
1821 * Point the previous inode on the list to the next inode.
1822 */
1827 /* need to recalc the inode CRC if appropriate */
1834 }
1836 }
1838 /*
1839 * A big issue when freeing the inode cluster is is that we _cannot_ skip any
1840 * inodes that are in memory - they all must be marked stale and attached to
1841 * the cluster buffer.
1842 */
1843 STATIC int
1847 xfs_ino_t inum)
1848 {
1854 xfs_daddr_t blkno;
1871 }
1877 /*
1878 * We obtain and lock the backing buffer first in the process
1879 * here, as we have to ensure that any dirty inode that we
1880 * can't get the flush lock on is attached to the buffer.
1881 * If we scan the in-memory inodes first, then buffer IO can
1882 * complete before we get a lock on it, and hence we may fail
1883 * to mark all the active inodes on the buffer stale.
1884 */
1887 XBF_UNMAPPED);
1892 /*
1893 * This buffer may not have been correctly initialised as we
1894 * didn't read it from disk. That's not important because we are
1895 * only using to mark the buffer as stale in the log, and to
1896 * attach stale cached inodes on it. That means it will never be
1897 * dispatched for IO. If it is, we want to know about it, and we
1898 * want it to fail. We can acheive this by adding a write
1899 * verifier to the buffer.
1900 */
1903 /*
1904 * Walk the inodes already attached to the buffer and mark them
1905 * stale. These will all have the flush locks held, so an
1906 * in-memory inode walk can't lock them. By marking them all
1907 * stale first, we will not attempt to lock them in the loop
1908 * below as the XFS_ISTALE flag will be set.
1909 */
1920 }
1922 }
1925 /*
1926 * For each inode in memory attempt to add it to the inode
1927 * buffer and set it up for being staled on buffer IO
1928 * completion. This is safe as we've locked out tail pushing
1929 * and flushing by locking the buffer.
1930 *
1931 * We have already marked every inode that was part of a
1932 * transaction stale above, which means there is no point in
1933 * even trying to lock them.
1934 */
1936 retry:
1941 /* Inode not in memory, nothing to do */
1945 }
1947 /*
1948 * because this is an RCU protected lookup, we could
1949 * find a recently freed or even reallocated inode
1950 * during the lookup. We need to check under the
1951 * i_flags_lock for a valid inode here. Skip it if it
1952 * is not valid, the wrong inode or stale.
1953 */
1960 }
1963 /*
1964 * Don't try to lock/unlock the current inode, but we
1965 * _cannot_ skip the other inodes that we did not find
1966 * in the list attached to the buffer and are not
1967 * already marked stale. If we can't lock it, back off
1968 * and retry.
1969 */
1975 }
1981 /*
1982 * we don't need to attach clean inodes or those only
1983 * with unlogged changes (which we throw away, anyway).
1984 */
1991 }
2004 }
2008 }
2012 }
2014 /*
2015 * This is called to return an inode to the inode free list.
2016 * The inode should already be truncated to 0 length and have
2017 * no pages associated with it. This routine also assumes that
2018 * the inode is already a part of the transaction.
2019 *
2020 * The on-disk copy of the inode will have been added to the list
2021 * of unlinked inodes in the AGI. We need to remove the inode from
2022 * that list atomically with respect to freeing it here.
2023 */
2024 int
2029 {
2032 xfs_ino_t first_ino;
2043 /*
2044 * Pull the on-disk inode from the AGI unlinked list.
2045 */
2049 }
2054 }
2061 /*
2062 * Bump the generation count so no one will be confused
2063 * by reincarnations of this inode.
2064 */
2074 /*
2075 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
2076 * from picking up this inode when it is reclaimed (its incore state
2077 * initialzed but not flushed to disk yet). The in-core di_mode is
2078 * already cleared and a corresponding transaction logged.
2079 * The hack here just synchronizes the in-core to on-disk
2080 * di_mode value in advance before the actual inode sync to disk.
2081 * This is OK because the inode is already unlinked and would never
2082 * change its di_mode again for this inode generation.
2083 * This is a temporary hack that would require a proper fix
2084 * in the future.
2085 */
2090 }
2093 }
2095 /*
2096 * Reallocate the space for if_broot based on the number of records
2097 * being added or deleted as indicated in rec_diff. Move the records
2098 * and pointers in if_broot to fit the new size. When shrinking this
2099 * will eliminate holes between the records and pointers created by
2100 * the caller. When growing this will create holes to be filled in
2101 * by the caller.
2102 *
2103 * The caller must not request to add more records than would fit in
2104 * the on-disk inode root. If the if_broot is currently NULL, then
2105 * if we adding records one will be allocated. The caller must also
2106 * not request that the number of records go below zero, although
2107 * it can go to zero.
2108 *
2109 * ip -- the inode whose if_broot area is changing
2110 * ext_diff -- the change in the number of records, positive or negative,
2111 * requested for the if_broot array.
2112 */
2113 void
2118 {
2128 /*
2129 * Handle the degenerate case quietly.
2130 */
2133 }
2137 /*
2138 * If there wasn't any memory allocated before, just
2139 * allocate it now and get out.
2140 */
2146 }
2148 /*
2149 * If there is already an existing if_broot, then we need
2150 * to realloc() it and shift the pointers to their new
2151 * location. The records don't change location because
2152 * they are kept butted up against the btree block header.
2153 */
2169 }
2171 /*
2172 * rec_diff is less than 0. In this case, we are shrinking the
2173 * if_broot buffer. It must already exist. If we go to zero
2174 * records, just get rid of the root and clear the status bit.
2175 */
2182 else
2186 /*
2187 * First copy over the btree block header.
2188 */
2194 }
2196 /*
2197 * Only copy the records and pointers if there are any.
2198 */
2200 /*
2201 * First copy the records.
2202 */
2207 /*
2208 * Then copy the pointers.
2209 */
2215 }
2222 }
2225 /*
2226 * This is called when the amount of space needed for if_data
2227 * is increased or decreased. The change in size is indicated by
2228 * the number of bytes that need to be added or deleted in the
2229 * byte_diff parameter.
2230 *
2231 * If the amount of space needed has decreased below the size of the
2232 * inline buffer, then switch to using the inline buffer. Otherwise,
2233 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2234 * to what is needed.
2235 *
2236 * ip -- the inode whose if_data area is changing
2237 * byte_diff -- the change in the number of bytes, positive or negative,
2238 * requested for the if_data array.
2239 */
2240 void
2245 {
2252 }
2261 }
2265 /*
2266 * If the valid extents/data can fit in if_inline_ext/data,
2267 * copy them from the malloc'd vector and free it.
2268 */
2274 new_size);
2277 }
2280 /*
2281 * Stuck with malloc/realloc.
2282 * For inline data, the underlying buffer must be
2283 * a multiple of 4 bytes in size so that it can be
2284 * logged and stay on word boundaries. We enforce
2285 * that here.
2286 */
2293 /*
2294 * Only do the realloc if the underlying size
2295 * is really changing.
2296 */
2300 real_size,
2303 }
2310 }
2311 }
2315 }
2317 void
2321 {
2328 }
2330 /*
2331 * If the format is local, then we can't have an extents
2332 * array so just look for an inline data array. If we're
2333 * not local then we may or may not have an extents list,
2334 * so check and free it up if we do.
2335 */
2343 }
2350 }
2357 }
2358 }
2360 /*
2361 * This is called to unpin an inode. The caller must have the inode locked
2362 * in at least shared mode so that the buffer cannot be subsequently pinned
2363 * once someone is waiting for it to be unpinned.
2364 */
2365 static void
2368 {
2373 /* Give the log a push to start the unpinning I/O */
2376 }
2378 static void
2381 {
2393 }
2395 void
2398 {
2401 }
2403 /*
2404 * xfs_iextents_copy()
2405 *
2406 * This is called to copy the REAL extents (as opposed to the delayed
2407 * allocation extents) from the inode into the given buffer. It
2408 * returns the number of bytes copied into the buffer.
2409 *
2410 * If there are no delayed allocation extents, then we can just
2411 * memcpy() the extents into the buffer. Otherwise, we need to
2412 * examine each extent in turn and skip those which are delayed.
2413 */
2414 int
2419 {
2424 xfs_fsblock_t start_block;
2434 /*
2435 * There are some delayed allocation extents in the
2436 * inode, so copy the extents one at a time and skip
2437 * the delayed ones. There must be at least one
2438 * non-delayed extent.
2439 */
2445 /*
2446 * It's a delayed allocation extent, so skip it.
2447 */
2449 }
2451 /* Translate to on disk format */
2454 dp++;
2455 copied++;
2456 }
2461 }
2463 /*
2464 * Each of the following cases stores data into the same region
2465 * of the on-disk inode, so only one of them can be valid at
2466 * any given time. While it is possible to have conflicting formats
2467 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2468 * in EXTENTS format, this can only happen when the fork has
2469 * changed formats after being modified but before being flushed.
2470 * In these cases, the format always takes precedence, because the
2471 * format indicates the current state of the fork.
2472 */
2473 /*ARGSUSED*/
2474 STATIC void
2481 {
2495 /*
2496 * This can happen if we gave up in iformat in an error path,
2497 * for the attribute fork.
2498 */
2502 }
2512 }
2523 whichfork);
2524 }
2537 }
2544 }
2553 }
2559 }
2560 }
2562 STATIC int
2566 {
2590 /* really need a gang lookup range call here */
2601 /*
2602 * because this is an RCU protected lookup, we could find a
2603 * recently freed or even reallocated inode during the lookup.
2604 * We need to check under the i_flags_lock for a valid inode
2605 * here. Skip it if it is not valid or the wrong inode.
2606 */
2612 }
2615 /*
2616 * Do an un-protected check to see if the inode is dirty and
2617 * is a candidate for flushing. These checks will be repeated
2618 * later after the appropriate locks are acquired.
2619 */
2623 /*
2624 * Try to get locks. If any are unavailable or it is pinned,
2625 * then this inode cannot be flushed and is skipped.
2626 */
2633 }
2638 }
2640 /*
2641 * arriving here means that this inode can be flushed. First
2642 * re-check that it's dirty before flushing.
2643 */
2650 }
2651 clcount++;
2654 }
2656 }
2661 }
2663 out_free:
2666 out_put:
2671 cluster_corrupt_out:
2672 /*
2673 * Corruption detected in the clustering loop. Invalidate the
2674 * inode buffer and shut down the filesystem.
2675 */
2677 /*
2678 * Clean up the buffer. If it was delwri, just release it --
2679 * brelse can handle it with no problems. If not, shut down the
2680 * filesystem before releasing the buffer.
2681 */
2689 /*
2690 * Just like incore_relse: if we have b_iodone functions,
2691 * mark the buffer as an error and call them. Otherwise
2692 * mark it as stale and brelse.
2693 */
2702 }
2703 }
2705 /*
2706 * Unlocks the flush lock
2707 */
2712 }
2714 /*
2715 * Flush dirty inode metadata into the backing buffer.
2716 *
2717 * The caller must have the inode lock and the inode flush lock held. The
2718 * inode lock will still be held upon return to the caller, and the inode
2719 * flush lock will be released after the inode has reached the disk.
2720 *
2721 * The caller must write out the buffer returned in *bpp and release it.
2722 */
2723 int
2727 {
2744 /*
2745 * For stale inodes we cannot rely on the backing buffer remaining
2746 * stale in cache for the remaining life of the stale inode and so
2747 * xfs_imap_to_bp() below may give us a buffer that no longer contains
2748 * inodes below. We have to check this after ensuring the inode is
2749 * unpinned so that it is safe to reclaim the stale inode after the
2750 * flush call.
2751 */
2755 }
2757 /*
2758 * This may have been unpinned because the filesystem is shutting
2759 * down forcibly. If that's the case we must not write this inode
2760 * to disk, because the log record didn't make it to disk.
2761 *
2762 * We also have to remove the log item from the AIL in this case,
2763 * as we wait for an empty AIL as part of the unmount process.
2764 */
2768 }
2770 /*
2771 * Get the buffer containing the on-disk inode.
2772 */
2778 }
2780 /*
2781 * First flush out the inode that xfs_iflush was called with.
2782 */
2787 /*
2788 * If the buffer is pinned then push on the log now so we won't
2789 * get stuck waiting in the write for too long.
2790 */
2794 /*
2795 * inode clustering:
2796 * see if other inodes can be gathered into this write
2797 */
2805 corrupt_out:
2808 cluster_corrupt_out:
2810 abort_out:
2811 /*
2812 * Unlocks the flush lock
2813 */
2816 }
2819 STATIC int
2823 {
2834 /* set *dip = inode's place in the buffer */
2843 }
2850 }
2860 }
2871 }
2872 }
2875 XFS_RANDOM_IFLUSH_5)) {
2877 "%s: detected corrupt incore inode %Lu, "
2883 }
2890 }
2891 /*
2892 * bump the flush iteration count, used to detect flushes which
2893 * postdate a log record during recovery. This is redundant as we now
2894 * log every change and hence this can't happen. Still, it doesn't hurt.
2895 */
2898 /*
2899 * Copy the dirty parts of the inode into the on-disk
2900 * inode. We always copy out the core of the inode,
2901 * because if the inode is dirty at all the core must
2902 * be.
2903 */
2906 /* Wrap, we never let the log put out DI_MAX_FLUSH */
2910 /*
2911 * If this is really an old format inode and the superblock version
2912 * has not been updated to support only new format inodes, then
2913 * convert back to the old inode format. If the superblock version
2914 * has been updated, then make the conversion permanent.
2915 */
2919 /*
2920 * Convert it back.
2921 */
2925 /*
2926 * The superblock version has already been bumped,
2927 * so just make the conversion to the new inode
2928 * format permanent.
2929 */
2938 }
2939 }
2946 /*
2947 * We've recorded everything logged in the inode, so we'd like to clear
2948 * the ili_fields bits so we don't log and flush things unnecessarily.
2949 * However, we can't stop logging all this information until the data
2950 * we've copied into the disk buffer is written to disk. If we did we
2951 * might overwrite the copy of the inode in the log with all the data
2952 * after re-logging only part of it, and in the face of a crash we
2953 * wouldn't have all the data we need to recover.
2954 *
2955 * What we do is move the bits to the ili_last_fields field. When
2956 * logging the inode, these bits are moved back to the ili_fields field.
2957 * In the xfs_iflush_done() routine we clear ili_last_fields, since we
2958 * know that the information those bits represent is permanently on
2959 * disk. As long as the flush completes before the inode is logged
2960 * again, then both ili_fields and ili_last_fields will be cleared.
2961 *
2962 * We can play with the ili_fields bits here, because the inode lock
2963 * must be held exclusively in order to set bits there and the flush
2964 * lock protects the ili_last_fields bits. Set ili_logged so the flush
2965 * done routine can tell whether or not to look in the AIL. Also, store
2966 * the current LSN of the inode so that we can tell whether the item has
2967 * moved in the AIL from xfs_iflush_done(). In order to read the lsn we
2968 * need the AIL lock, because it is a 64 bit value that cannot be read
2969 * atomically.
2970 */
2978 /*
2979 * Attach the function xfs_iflush_done to the inode's
2980 * buffer. This will remove the inode from the AIL
2981 * and unlock the inode's flush lock when the inode is
2982 * completely written to disk.
2983 */
2986 /* update the lsn in the on disk inode if required */
2990 /* generate the checksum. */
2997 corrupt_out:
2999 }
3001 /*
3002 * Return a pointer to the extent record at file index idx.
3003 */
3004 xfs_bmbt_rec_host_t *
3008 {
3025 }
3026 }
3028 /*
3029 * Insert new item(s) into the extent records for incore inode
3030 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3031 */
3032 void
3039 {
3049 }
3051 /*
3052 * This is called when the amount of space required for incore file
3053 * extents needs to be increased. The ext_diff parameter stores the
3054 * number of new extents being added and the idx parameter contains
3055 * the extent index where the new extents will be added. If the new
3056 * extents are being appended, then we just need to (re)allocate and
3057 * initialize the space. Otherwise, if the new extents are being
3058 * inserted into the middle of the existing entries, a bit more work
3059 * is required to make room for the new extents to be inserted. The
3060 * caller is responsible for filling in the new extent entries upon
3061 * return.
3062 */
3063 void
3068 {
3077 /*
3078 * If the new number of extents (nextents + ext_diff)
3079 * fits inside the inode, then continue to use the inline
3080 * extent buffer.
3081 */
3088 }
3091 }
3092 /*
3093 * Otherwise use a linear (direct) extent list.
3094 * If the extents are currently inside the inode,
3095 * xfs_iext_realloc_direct will switch us from
3096 * inline to direct extent allocation mode.
3097 */
3105 }
3106 }
3107 /* Indirection array */
3120 }
3121 /* Extents fit in target extent page */
3129 }
3132 }
3133 /* Insert a new extent page */
3137 }
3138 /*
3139 * If extent(s) are being appended to the last page in
3140 * the indirection array and the new extent(s) don't fit
3141 * in the page, then erp is NULL and erp_idx is set to
3142 * the next index needed in the indirection array.
3143 */
3152 erp_idx++;
3153 }
3154 }
3155 }
3156 }
3158 }
3160 /*
3161 * This is called when incore extents are being added to the indirection
3162 * array and the new extents do not fit in the target extent list. The
3163 * erp_idx parameter contains the irec index for the target extent list
3164 * in the indirection array, and the idx parameter contains the extent
3165 * index within the list. The number of extents being added is stored
3166 * in the count parameter.
3167 *
3168 * |-------| |-------|
3169 * | | | | idx - number of extents before idx
3170 * | idx | | count |
3171 * | | | | count - number of extents being inserted at idx
3172 * |-------| |-------|
3173 * | count | | nex2 | nex2 - number of extents after idx + count
3174 * |-------| |-------|
3175 */
3176 void
3182 {
3196 /*
3197 * Save second part of target extent list
3198 * (all extents past */
3206 }
3208 /*
3209 * Add the new extents to the end of the target
3210 * list, then allocate new irec record(s) and
3211 * extent buffer(s) as needed to store the rest
3212 * of the new extents.
3213 */
3220 }
3222 erp_idx++;
3228 }
3230 /* Add nex2 extents back to indirection array */
3232 xfs_extnum_t ext_avail;
3238 /*
3239 * If nex2 extents fit in the current page, append
3240 * nex2_ep after the new extents.
3241 */
3244 }
3245 /*
3246 * Otherwise, check if space is available in the
3247 * next page.
3248 */
3252 erp_idx++;
3253 erp++;
3254 /* Create a hole for nex2 extents */
3257 }
3258 /*
3259 * Final choice, create a new extent page for
3260 * nex2 extents.
3261 */
3263 erp_idx++;
3265 }
3270 }
3271 }
3273 /*
3274 * This is called when the amount of space required for incore file
3275 * extents needs to be decreased. The ext_diff parameter stores the
3276 * number of extents to be removed and the idx parameter contains
3277 * the extent index where the extents will be removed from.
3278 *
3279 * If the amount of space needed has decreased below the linear
3280 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3281 * extent array. Otherwise, use kmem_realloc() to adjust the
3282 * size to what is needed.
3283 */
3284 void
3290 {
3309 }
3311 }
3313 /*
3314 * This removes ext_diff extents from the inline buffer, beginning
3315 * at extent index idx.
3316 */
3317 void
3322 {
3341 }
3342 }
3344 /*
3345 * This removes ext_diff extents from a linear (direct) extent list,
3346 * beginning at extent index idx. If the extents are being removed
3347 * from the end of the list (ie. truncate) then we just need to re-
3348 * allocate the list to remove the extra space. Otherwise, if the
3349 * extents are being removed from the middle of the existing extent
3350 * entries, then we first need to move the extent records beginning
3351 * at idx + ext_diff up in the list to overwrite the records being
3352 * removed, then remove the extra space via kmem_realloc.
3353 */
3354 void
3359 {
3371 }
3372 /* Move extents up in the list (if needed) */
3378 }
3381 /*
3382 * Reallocate the direct extent list. If the extents
3383 * will fit inside the inode then xfs_iext_realloc_direct
3384 * will switch from direct to inline extent allocation
3385 * mode for us.
3386 */
3389 }
3391 /*
3392 * This is called when incore extents are being removed from the
3393 * indirection array and the extents being removed span multiple extent
3394 * buffers. The idx parameter contains the file extent index where we
3395 * want to begin removing extents, and the count parameter contains
3396 * how many extents need to be removed.
3397 *
3398 * |-------| |-------|
3399 * | nex1 | | | nex1 - number of extents before idx
3400 * |-------| | count |
3401 * | | | | count - number of extents being removed at idx
3402 * | count | |-------|
3403 * | | | nex2 | nex2 - number of extents after idx + count
3404 * |-------| |-------|
3405 */
3406 void
3411 {
3428 /*
3429 * Check for deletion of entire list;
3430 * xfs_iext_irec_remove() updates extent offsets.
3431 */
3438 XFS_IEXT_BUFSZ);
3444 }
3445 }
3446 /* Move extents up (if needed) */
3451 }
3452 /* Zero out rest of page */
3455 /* Update remaining counters */
3460 erp_idx++;
3461 erp++;
3462 }
3465 }
3467 /*
3468 * Create, destroy, or resize a linear (direct) block of extents.
3469 */
3470 void
3474 {
3483 /* Free extent records */
3486 }
3487 /* Resize direct extent list and zero any new bytes */
3489 /* Check if extents will fit inside the inode */
3495 }
3498 }
3502 rnew_size,
3504 }
3509 }
3510 }
3511 /*
3512 * Switch from the inline extent buffer to a direct
3513 * extent list. Be sure to include the inline extent
3514 * bytes in new_size.
3515 */
3520 }
3522 }
3525 }
3527 /*
3528 * Switch from linear (direct) extent records to inline buffer.
3529 */
3530 void
3534 {
3537 /*
3538 * The inline buffer was zeroed when we switched
3539 * from inline to direct extent allocation mode,
3540 * so we don't need to clear it here.
3541 */
3547 }
3549 /*
3550 * Switch from inline buffer to linear (direct) extent records.
3551 * new_size should already be rounded up to the next power of 2
3552 * by the caller (when appropriate), so use new_size as it is.
3553 * However, since new_size may be rounded up, we can't update
3554 * if_bytes here. It is the caller's responsibility to update
3555 * if_bytes upon return.
3556 */
3557 void
3561 {
3569 }
3571 }
3573 /*
3574 * Resize an extent indirection array to new_size bytes.
3575 */
3576 STATIC void
3580 {
3595 }
3596 }
3598 /*
3599 * Switch from indirection array to linear (direct) extent allocations.
3600 */
3601 STATIC void
3604 {
3624 }
3625 }
3627 /*
3628 * Free incore file extents.
3629 */
3630 void
3633 {
3641 }
3648 }
3652 }
3654 /*
3655 * Return a pointer to the extent record for file system block bno.
3656 */
3662 {
3677 }
3680 /* Find target extent list */
3688 }
3689 /* Binary search extent records */
3700 /* Convert back to file-based extent index */
3703 }
3706 }
3707 }
3708 /* Convert back to file-based extent index */
3711 }
3717 }
3718 }
3721 }
3723 /*
3724 * Return a pointer to the indirection array entry containing the
3725 * extent record for filesystem block bno. Store the index of the
3726 * target irec in *erp_idxp.
3727 */
3733 {
3757 }
3758 }
3761 }
3763 /*
3764 * Return a pointer to the indirection array entry containing the
3765 * extent record at file extent index *idxp. Store the index of the
3766 * target irec in *erp_idxp and store the page index of the target
3767 * extent record in *idxp.
3768 */
3769 xfs_ext_irec_t *
3775 {
3794 /* Binary search extent irec's */
3810 erp_idx++;
3816 }
3817 }
3821 }
3823 /*
3824 * Allocate and initialize an indirection array once the space needed
3825 * for incore extents increases above XFS_IEXT_BUFSZ.
3826 */
3827 void
3830 {
3846 }
3857 }
3859 /*
3860 * Allocate and initialize a new entry in the indirection array.
3861 */
3862 xfs_ext_irec_t *
3866 {
3874 /* Resize indirection array */
3877 /*
3878 * Move records down in the array so the
3879 * new page can use erp_idx.
3880 */
3884 }
3887 /* Initialize new extent record */
3896 }
3898 /*
3899 * Remove a record from the indirection array.
3900 */
3901 void
3905 {
3917 }
3918 /* Compact extent records */
3922 }
3923 /*
3924 * Manually free the last extent record from the indirection
3925 * array. A call to xfs_iext_realloc_indirect() with a size
3926 * of zero would result in a call to xfs_iext_destroy() which
3927 * would in turn call this function again, creating a nasty
3928 * infinite loop.
3929 */
3935 }
3937 }
3939 /*
3940 * This is called to clean up large amounts of unused memory allocated
3941 * by the indirection array. Before compacting anything though, verify
3942 * that the indirection array is still needed and switch back to the
3943 * linear extent list (or even the inline buffer) if possible. The
3944 * compaction policy is as follows:
3945 *
3946 * Full Compaction: Extents fit into a single page (or inline buffer)
3947 * Partial Compaction: Extents occupy less than 50% of allocated space
3948 * No Compaction: Extents occupy at least 50% of allocated space
3949 */
3950 void
3953 {
3970 }
3971 }
3973 /*
3974 * Combine extents from neighboring extent pages.
3975 */
3976 void
3979 {
3995 /*
3996 * Free page before removing extent record
3997 * so er_extoffs don't get modified in
3998 * xfs_iext_irec_remove.
3999 */
4005 erp_idx++;
4006 }
4007 }
4008 }
4010 /*
4011 * This is called to update the er_extoff field in the indirection
4012 * array when extents have been added or removed from one of the
4013 * extent lists. erp_idx contains the irec index to begin updating
4014 * at and ext_diff contains the number of extents that were added
4015 * or removed.
4016 */
4017 void
4022 {
4030 }
4031 }
4033 /*
4034 * Test whether it is appropriate to check an inode for and free post EOF
4035 * blocks. The 'force' parameter determines whether we should also consider
4036 * regular files that are marked preallocated or append-only.
4037 */
4038 bool
4040 {
4041 /* prealloc/delalloc exists only on regular files */
4045 /*
4046 * Zero sized files with no cached pages and delalloc blocks will not
4047 * have speculative prealloc/delalloc blocks to remove.
4048 */
4054 /* If we haven't read in the extent list, then don't do it now. */
4058 /*
4059 * Do not free real preallocated or append-only files unless the file
4060 * has delalloc blocks and we are forced to remove them.
4061 */
4067 }