| blob | 0239a7c7c886a2c83a74352ee0504082cb328e26 |
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>
53 /*
54 * Used in xfs_itruncate_extents(). This is the maximum number of extents
55 * freed from a file in a single transaction.
56 */
57 #define XFS_ITRUNC_MAX_EXTENTS 2
64 #ifdef DEBUG
65 /*
66 * Make sure that the extents in the given memory buffer
67 * are valid.
68 */
69 STATIC void
73 xfs_exntfmt_t fmt)
74 {
75 xfs_bmbt_irec_t irec;
76 xfs_bmbt_rec_host_t rec;
86 }
87 }
89 #define xfs_validate_extents(ifp, nrecs, fmt)
92 /*
93 * Check that none of the inode's in the buffer have a next
94 * unlinked field of 0.
95 */
96 #if defined(DEBUG)
97 void
101 {
114 bp);
116 }
117 }
118 }
119 #endif
121 /*
122 * Find the buffer associated with the given inode map
123 * We do basic validation checks on the buffer once it has been
124 * retrieved from disk.
125 */
126 STATIC int
132 uint buf_flags,
133 uint iget_flags)
134 {
149 }
151 }
153 /*
154 * Validate the magic number and version of every inode in the buffer
155 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
156 */
157 #ifdef DEBUG
161 #endif
172 XFS_ERRTAG_ITOBP_INOTOBP,
173 XFS_RANDOM_ITOBP_INOTOBP))) {
177 }
180 #ifdef DEBUG
186 #endif
189 }
190 }
194 /*
195 * Mark the buffer as an inode buffer now that it looks good
196 */
201 }
203 /*
204 * This routine is called to map an inode number within a file
205 * system to the buffer containing the on-disk version of the
206 * inode. It returns a pointer to the buffer containing the
207 * on-disk inode in the bpp parameter, and in the dip parameter
208 * it returns a pointer to the on-disk inode within that buffer.
209 *
210 * If a non-zero error is returned, then the contents of bpp and
211 * dipp are undefined.
212 *
213 * Use xfs_imap() to determine the size and location of the
214 * buffer to read from disk.
215 */
216 int
220 xfs_ino_t ino,
224 uint imap_flags)
225 {
243 }
246 /*
247 * This routine is called to map an inode to the buffer containing
248 * the on-disk version of the inode. It returns a pointer to the
249 * buffer containing the on-disk inode in the bpp parameter, and in
250 * the dip parameter it returns a pointer to the on-disk inode within
251 * that buffer.
252 *
253 * If a non-zero error is returned, then the contents of bpp and
254 * dipp are undefined.
255 *
256 * The inode is expected to already been mapped to its buffer and read
257 * in once, thus we can use the mapping information stored in the inode
258 * rather than calling xfs_imap(). This allows us to avoid the overhead
259 * of looking at the inode btree for small block file systems
260 * (see xfs_imap()).
261 */
262 int
269 uint buf_flags)
270 {
285 }
290 }
292 /*
293 * Move inode type and inode format specific information from the
294 * on-disk inode to the in-core inode. For fifos, devs, and sockets
295 * this means set if_rdev to the proper value. For files, directories,
296 * and symlinks this means to bring in the in-line data or extent
297 * pointers. For a file in B-tree format, only the root is immediately
298 * brought in-core. The rest will be in-lined in if_extents when it
299 * is first referenced (see xfs_iread_extents()).
300 */
301 STATIC int
305 {
309 xfs_fsize_t di_size;
327 }
336 }
346 }
357 }
368 /*
369 * no local regular files yet
370 */
376 XFS_ERRLEVEL_LOW,
379 }
388 XFS_ERRLEVEL_LOW,
391 }
406 }
412 }
415 }
433 XFS_ERRLEVEL_LOW,
436 }
449 }
454 }
456 }
458 /*
459 * The file is in-lined in the on-disk inode.
460 * If it fits into if_inline_data, then copy
461 * it there, otherwise allocate a buffer for it
462 * and copy the data there. Either way, set
463 * if_data to point at the data.
464 * If we allocate a buffer for the data, make
465 * sure that its size is a multiple of 4 and
466 * record the real size in i_real_bytes.
467 */
468 STATIC int
474 {
478 /*
479 * If the size is unreasonable, then something
480 * is wrong and we just bail out rather than crash in
481 * kmem_alloc() or memcpy() below.
482 */
491 }
501 }
509 }
511 /*
512 * The file consists of a set of extents all
513 * of which fit into the on-disk inode.
514 * If there are few enough extents to fit into
515 * the if_inline_ext, then copy them there.
516 * Otherwise allocate a buffer for them and copy
517 * them into it. Either way, set if_extents
518 * to point at the extents.
519 */
520 STATIC int
525 {
536 /*
537 * If the number of extents is unreasonable, then something
538 * is wrong and we just bail out rather than crash in
539 * kmem_alloc() or memcpy() below.
540 */
547 }
554 else
565 }
572 XFS_ERRLEVEL_LOW,
575 }
576 }
579 }
581 /*
582 * The file has too many extents to fit into
583 * the inode, so they are in B-tree format.
584 * Allocate a buffer for the root of the B-tree
585 * and copy the root into it. The i_extents
586 * field will remain NULL until all of the
587 * extents are read in (when they are needed).
588 */
589 STATIC int
594 {
597 /* REFERENCED */
606 /*
607 * blow out if -- fork has less extents than can fit in
608 * fork (fork shouldn't be a btree format), root btree
609 * block has more records than can fit into the fork,
610 * or the number of extents is greater than the number of
611 * blocks.
612 */
622 }
627 /*
628 * Copy and convert from the on-disk structure
629 * to the in-memory structure.
630 */
638 }
640 STATIC void
644 {
674 }
676 void
680 {
710 }
712 STATIC uint
714 __uint16_t di_flags)
715 {
747 }
750 }
752 uint
755 {
760 }
762 uint
765 {
768 }
770 /*
771 * Read the disk inode attributes into the in-core inode structure.
772 */
773 int
778 uint iget_flags)
779 {
784 /*
785 * Fill in the location information in the in-core inode.
786 */
791 /*
792 * Get pointers to the on-disk inode and the buffer containing it.
793 */
800 /*
801 * If we got something that isn't an inode it means someone
802 * (nfs or dmi) has a stale handle.
803 */
805 #ifdef DEBUG
812 }
814 /*
815 * If the on-disk inode is already linked to a directory
816 * entry, copy all of the inode into the in-core inode.
817 * xfs_iformat() handles copying in the inode format
818 * specific information.
819 * Otherwise, just get the truly permanent information.
820 */
825 #ifdef DEBUG
830 }
836 /*
837 * Make sure to pull in the mode here as well in
838 * case the inode is released without being used.
839 * This ensures that xfs_inactive() will see that
840 * the inode is already free and not try to mess
841 * with the uninitialized part of it.
842 */
844 /*
845 * Initialize the per-fork minima and maxima for a new
846 * inode here. xfs_iformat will do it for old inodes.
847 */
850 }
852 /*
853 * The inode format changed when we moved the link count and
854 * made it 32 bits long. If this is an old format inode,
855 * convert it in memory to look like a new one. If it gets
856 * flushed to disk we will convert back before flushing or
857 * logging it. We zero out the new projid field and the old link
858 * count field. We'll handle clearing the pad field (the remains
859 * of the old uuid field) when we actually convert the inode to
860 * the new format. We don't change the version number so that we
861 * can distinguish this from a real new format inode.
862 */
867 }
872 /*
873 * Mark the buffer containing the inode as something to keep
874 * around for a while. This helps to keep recently accessed
875 * meta-data in-core longer.
876 */
879 /*
880 * Use xfs_trans_brelse() to release the buffer containing the
881 * on-disk inode, because it was acquired with xfs_trans_read_buf()
882 * in xfs_itobp() above. If tp is NULL, this is just a normal
883 * brelse(). If we're within a transaction, then xfs_trans_brelse()
884 * will only release the buffer if it is not dirty within the
885 * transaction. It will be OK to release the buffer in this case,
886 * because inodes on disk are never destroyed and we will be
887 * locking the new in-core inode before putting it in the hash
888 * table where other processes can find it. Thus we don't have
889 * to worry about the inode being changed just because we released
890 * the buffer.
891 */
892 out_brelse:
895 }
897 /*
898 * Read in extents from a btree-format inode.
899 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
900 */
901 int
906 {
909 xfs_extnum_t nextents;
915 }
919 /*
920 * We know that the size is valid (it's checked in iformat_btree)
921 */
930 }
933 }
935 /*
936 * Allocate an inode on disk and return a copy of its in-core version.
937 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
938 * appropriately within the inode. The uid and gid for the inode are
939 * set according to the contents of the given cred structure.
940 *
941 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
942 * has a free inode available, call xfs_iget()
943 * to obtain the in-core version of the allocated inode. Finally,
944 * fill in the inode and log its initial contents. In this case,
945 * ialloc_context would be set to NULL and call_again set to false.
946 *
947 * If xfs_dialloc() does not have an available inode,
948 * it will replenish its supply by doing an allocation. Since we can
949 * only do one allocation within a transaction without deadlocks, we
950 * must commit the current transaction before returning the inode itself.
951 * In this case, therefore, we will set call_again to true and return.
952 * The caller should then commit the current transaction, start a new
953 * transaction, and call xfs_ialloc() again to actually get the inode.
954 *
955 * To ensure that some other process does not grab the inode that
956 * was allocated during the first call to xfs_ialloc(), this routine
957 * also returns the [locked] bp pointing to the head of the freelist
958 * as ialloc_context. The caller should hold this buffer across
959 * the commit and pass it back into this routine on the second call.
960 *
961 * If we are allocating quota inodes, we do not have a parent inode
962 * to attach to or associate with (i.e. pip == NULL) because they
963 * are not linked into the directory structure - they are attached
964 * directly to the superblock - and so have no parent.
965 */
966 int
970 mode_t mode,
971 xfs_nlink_t nlink,
972 xfs_dev_t rdev,
973 prid_t prid,
978 {
979 xfs_ino_t ino;
981 uint flags;
983 timespec_t tv;
986 /*
987 * Call the space management code to pick
988 * the on-disk inode to be allocated.
989 */
997 }
1000 /*
1001 * Get the in-core inode with the lock held exclusively.
1002 * This is because we're setting fields here we need
1003 * to prevent others from looking at until we're done.
1004 */
1020 /*
1021 * If the superblock version is up to where we support new format
1022 * inodes and this is currently an old format inode, then change
1023 * the inode version number now. This way we only do the conversion
1024 * here rather than here and in the flush/logging code.
1025 */
1029 /*
1030 * We've already zeroed the old link count, the projid field,
1031 * and the pad field.
1032 */
1033 }
1035 /*
1036 * Project ids won't be stored on disk if we are using a version 1 inode.
1037 */
1045 }
1046 }
1048 /*
1049 * If the group ID of the new file does not match the effective group
1050 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1051 * (and only if the irix_sgid_inherit compatibility variable is set).
1052 */
1057 }
1070 /*
1071 * di_gen will have been taken care of in xfs_iread.
1072 */
1089 /*
1090 * we can't set up filestreams until after the VFS inode
1091 * is set up properly.
1092 */
1095 /* fall through */
1106 }
1113 }
1114 }
1116 xfs_inherit_noatime)
1119 xfs_inherit_nodump)
1122 xfs_inherit_sync)
1125 xfs_inherit_nosymlinks)
1130 xfs_inherit_nodefrag)
1135 }
1136 /* FALLTHROUGH */
1145 }
1146 /*
1147 * Attribute fork settings for new inode.
1148 */
1152 /*
1153 * Log the new values stuffed into the inode.
1154 */
1158 /* now that we have an i_mode we can setup inode ops and unlock */
1161 /* now we have set up the vfs inode we can associate the filestream */
1168 }
1172 }
1174 /*
1175 * Check to make sure that there are no blocks allocated to the
1176 * file beyond the size of the file. We don't check this for
1177 * files with fixed size extents or real time extents, but we
1178 * at least do it for regular files.
1179 */
1180 #ifdef DEBUG
1181 STATIC void
1184 xfs_fsize_t isize)
1185 {
1187 xfs_fileoff_t map_first;
1202 /*
1203 * The filesystem could be shutting down, so bmapi may return
1204 * an error.
1205 */
1209 map_first),
1211 NULL))
1215 }
1217 #define xfs_isize_check(ip, isize)
1220 /*
1221 * Free up the underlying blocks past new_size. The new size must be smaller
1222 * than the current size. This routine can be used both for the attribute and
1223 * data fork, and does not modify the inode size, which is left to the caller.
1224 *
1225 * The transaction passed to this routine must have made a permanent log
1226 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1227 * given transaction and start new ones, so make sure everything involved in
1228 * the transaction is tidy before calling here. Some transaction will be
1229 * returned to the caller to be committed. The incoming transaction must
1230 * already include the inode, and both inode locks must be held exclusively.
1231 * The inode must also be "held" within the transaction. On return the inode
1232 * will be "held" within the returned transaction. This routine does NOT
1233 * require any disk space to be reserved for it within the transaction.
1234 *
1235 * If we get an error, we must return with the inode locked and linked into the
1236 * current transaction. This keeps things simple for the higher level code,
1237 * because it always knows that the inode is locked and held in the transaction
1238 * that returns to it whether errors occur or not. We don't mark the inode
1239 * dirty on error so that transactions can be easily aborted if possible.
1240 */
1241 int
1246 xfs_fsize_t new_size)
1247 {
1251 xfs_bmap_free_t free_list;
1252 xfs_fsblock_t first_block;
1253 xfs_fileoff_t first_unmap_block;
1254 xfs_fileoff_t last_block;
1255 xfs_filblks_t unmap_len;
1267 /*
1268 * Since it is possible for space to become allocated beyond
1269 * the end of the file (in a crash where the space is allocated
1270 * but the inode size is not yet updated), simply remove any
1271 * blocks which show up between the new EOF and the maximum
1272 * possible file size. If the first block to be removed is
1273 * beyond the maximum file size (ie it is the same as last_block),
1274 * then there is nothing to do.
1275 */
1288 XFS_ITRUNC_MAX_EXTENTS,
1294 /*
1295 * Duplicate the transaction that has the permanent
1296 * reservation and commit the old transaction.
1297 */
1305 /*
1306 * Mark the inode dirty so it will be logged and
1307 * moved forward in the log as part of every commit.
1308 */
1310 }
1321 /*
1322 * Transaction commit worked ok so we can drop the extra ticket
1323 * reference that we gained in xfs_trans_dup()
1324 */
1328 XFS_TRANS_PERM_LOG_RES,
1329 XFS_ITRUNCATE_LOG_COUNT);
1332 }
1334 out:
1337 out_bmap_cancel:
1338 /*
1339 * If the bunmapi call encounters an error, return to the caller where
1340 * the transaction can be properly aborted. We just need to make sure
1341 * we're not holding any resources that we were not when we came in.
1342 */
1345 }
1347 int
1351 xfs_fsize_t new_size)
1352 {
1357 /*
1358 * The first thing we do is set the size to new_size permanently on
1359 * disk. This way we don't have to worry about anyone ever being able
1360 * to look at the data being freed even in the face of a crash.
1361 * What we're getting around here is the case where we free a block, it
1362 * is allocated to another file, it is written to, and then we crash.
1363 * If the new data gets written to the file but the log buffers
1364 * containing the free and reallocation don't, then we'd end up with
1365 * garbage in the blocks being freed. As long as we make the new_size
1366 * permanent before actually freeing any blocks it doesn't matter if
1367 * they get written to.
1368 */
1370 /*
1371 * If we are not changing the file size then do not update
1372 * the on-disk file size - we may be called from
1373 * xfs_inactive_free_eofblocks(). If we update the on-disk
1374 * file size and then the system crashes before the contents
1375 * of the file are flushed to disk then the files may be
1376 * full of holes (ie NULL files bug).
1377 */
1382 }
1383 }
1389 /*
1390 * If we are not changing the file size then do not update the on-disk
1391 * file size - we may be called from xfs_inactive_free_eofblocks().
1392 * If we update the on-disk file size and then the system crashes
1393 * before the contents of the file are flushed to disk then the files
1394 * may be full of holes (ie NULL files bug).
1395 */
1400 }
1405 /*
1406 * Always re-log the inode so that our permanent transaction can keep
1407 * on rolling it forward in the log.
1408 */
1413 }
1415 /*
1416 * This is called when the inode's link count goes to 0.
1417 * We place the on-disk inode on a list in the AGI. It
1418 * will be pulled from this list when the inode is freed.
1419 */
1420 int
1424 {
1430 xfs_agino_t agino;
1440 /*
1441 * Get the agi buffer first. It ensures lock ordering
1442 * on the list.
1443 */
1449 /*
1450 * Get the index into the agi hash table for the
1451 * list this inode will go on.
1452 */
1460 /*
1461 * There is already another inode in the bucket we need
1462 * to add ourselves to. Add us at the front of the list.
1463 * Here we put the head pointer into our next pointer,
1464 * and then we fall through to point the head at us.
1465 */
1478 }
1480 /*
1481 * Point the bucket head pointer at the inode being inserted.
1482 */
1490 }
1492 /*
1493 * Pull the on-disk inode from the AGI unlinked list.
1494 */
1495 STATIC int
1499 {
1500 xfs_ino_t next_ino;
1506 xfs_agnumber_t agno;
1507 xfs_agino_t agino;
1508 xfs_agino_t next_agino;
1518 /*
1519 * Get the agi buffer first. It ensures lock ordering
1520 * on the list.
1521 */
1528 /*
1529 * Get the index into the agi hash table for the
1530 * list this inode will go on.
1531 */
1539 /*
1540 * We're at the head of the list. Get the inode's
1541 * on-disk buffer to see if there is anyone after us
1542 * on the list. Only modify our next pointer if it
1543 * is not already NULLAGINO. This saves us the overhead
1544 * of dealing with the buffer when there is no need to
1545 * change it.
1546 */
1552 }
1565 }
1566 /*
1567 * Point the bucket head pointer at the next inode.
1568 */
1577 /*
1578 * We need to search the list for the inode being freed.
1579 */
1583 /*
1584 * If the last inode wasn't the one pointing to
1585 * us, then release its buffer since we're not
1586 * going to do anything with it.
1587 */
1590 }
1599 }
1603 }
1604 /*
1605 * Now last_ibp points to the buffer previous to us on
1606 * the unlinked list. Pull us from the list.
1607 */
1613 }
1627 }
1628 /*
1629 * Point the previous inode on the list to the next inode.
1630 */
1638 }
1640 }
1642 /*
1643 * A big issue when freeing the inode cluster is is that we _cannot_ skip any
1644 * inodes that are in memory - they all must be marked stale and attached to
1645 * the cluster buffer.
1646 */
1647 STATIC void
1651 xfs_ino_t inum)
1652 {
1658 xfs_daddr_t blkno;
1675 }
1681 /*
1682 * We obtain and lock the backing buffer first in the process
1683 * here, as we have to ensure that any dirty inode that we
1684 * can't get the flush lock on is attached to the buffer.
1685 * If we scan the in-memory inodes first, then buffer IO can
1686 * complete before we get a lock on it, and hence we may fail
1687 * to mark all the active inodes on the buffer stale.
1688 */
1691 XBF_LOCK);
1693 /*
1694 * Walk the inodes already attached to the buffer and mark them
1695 * stale. These will all have the flush locks held, so an
1696 * in-memory inode walk can't lock them. By marking them all
1697 * stale first, we will not attempt to lock them in the loop
1698 * below as the XFS_ISTALE flag will be set.
1699 */
1710 }
1712 }
1715 /*
1716 * For each inode in memory attempt to add it to the inode
1717 * buffer and set it up for being staled on buffer IO
1718 * completion. This is safe as we've locked out tail pushing
1719 * and flushing by locking the buffer.
1720 *
1721 * We have already marked every inode that was part of a
1722 * transaction stale above, which means there is no point in
1723 * even trying to lock them.
1724 */
1726 retry:
1731 /* Inode not in memory, nothing to do */
1735 }
1737 /*
1738 * because this is an RCU protected lookup, we could
1739 * find a recently freed or even reallocated inode
1740 * during the lookup. We need to check under the
1741 * i_flags_lock for a valid inode here. Skip it if it
1742 * is not valid, the wrong inode or stale.
1743 */
1750 }
1753 /*
1754 * Don't try to lock/unlock the current inode, but we
1755 * _cannot_ skip the other inodes that we did not find
1756 * in the list attached to the buffer and are not
1757 * already marked stale. If we can't lock it, back off
1758 * and retry.
1759 */
1765 }
1771 /*
1772 * we don't need to attach clean inodes or those only
1773 * with unlogged changes (which we throw away, anyway).
1774 */
1782 }
1795 }
1799 }
1802 }
1804 /*
1805 * This is called to return an inode to the inode free list.
1806 * The inode should already be truncated to 0 length and have
1807 * no pages associated with it. This routine also assumes that
1808 * the inode is already a part of the transaction.
1809 *
1810 * The on-disk copy of the inode will have been added to the list
1811 * of unlinked inodes in the AGI. We need to remove the inode from
1812 * that list atomically with respect to freeing it here.
1813 */
1814 int
1819 {
1822 xfs_ino_t first_ino;
1834 /*
1835 * Pull the on-disk inode from the AGI unlinked list.
1836 */
1840 }
1845 }
1854 /*
1855 * Bump the generation count so no one will be confused
1856 * by reincarnations of this inode.
1857 */
1866 /*
1867 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
1868 * from picking up this inode when it is reclaimed (its incore state
1869 * initialzed but not flushed to disk yet). The in-core di_mode is
1870 * already cleared and a corresponding transaction logged.
1871 * The hack here just synchronizes the in-core to on-disk
1872 * di_mode value in advance before the actual inode sync to disk.
1873 * This is OK because the inode is already unlinked and would never
1874 * change its di_mode again for this inode generation.
1875 * This is a temporary hack that would require a proper fix
1876 * in the future.
1877 */
1882 }
1885 }
1887 /*
1888 * Reallocate the space for if_broot based on the number of records
1889 * being added or deleted as indicated in rec_diff. Move the records
1890 * and pointers in if_broot to fit the new size. When shrinking this
1891 * will eliminate holes between the records and pointers created by
1892 * the caller. When growing this will create holes to be filled in
1893 * by the caller.
1894 *
1895 * The caller must not request to add more records than would fit in
1896 * the on-disk inode root. If the if_broot is currently NULL, then
1897 * if we adding records one will be allocated. The caller must also
1898 * not request that the number of records go below zero, although
1899 * it can go to zero.
1900 *
1901 * ip -- the inode whose if_broot area is changing
1902 * ext_diff -- the change in the number of records, positive or negative,
1903 * requested for the if_broot array.
1904 */
1905 void
1910 {
1920 /*
1921 * Handle the degenerate case quietly.
1922 */
1925 }
1929 /*
1930 * If there wasn't any memory allocated before, just
1931 * allocate it now and get out.
1932 */
1938 }
1940 /*
1941 * If there is already an existing if_broot, then we need
1942 * to realloc() it and shift the pointers to their new
1943 * location. The records don't change location because
1944 * they are kept butted up against the btree block header.
1945 */
1961 }
1963 /*
1964 * rec_diff is less than 0. In this case, we are shrinking the
1965 * if_broot buffer. It must already exist. If we go to zero
1966 * records, just get rid of the root and clear the status bit.
1967 */
1974 else
1978 /*
1979 * First copy over the btree block header.
1980 */
1985 }
1987 /*
1988 * Only copy the records and pointers if there are any.
1989 */
1991 /*
1992 * First copy the records.
1993 */
1998 /*
1999 * Then copy the pointers.
2000 */
2006 }
2013 }
2016 /*
2017 * This is called when the amount of space needed for if_data
2018 * is increased or decreased. The change in size is indicated by
2019 * the number of bytes that need to be added or deleted in the
2020 * byte_diff parameter.
2021 *
2022 * If the amount of space needed has decreased below the size of the
2023 * inline buffer, then switch to using the inline buffer. Otherwise,
2024 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2025 * to what is needed.
2026 *
2027 * ip -- the inode whose if_data area is changing
2028 * byte_diff -- the change in the number of bytes, positive or negative,
2029 * requested for the if_data array.
2030 */
2031 void
2036 {
2043 }
2052 }
2056 /*
2057 * If the valid extents/data can fit in if_inline_ext/data,
2058 * copy them from the malloc'd vector and free it.
2059 */
2065 new_size);
2068 }
2071 /*
2072 * Stuck with malloc/realloc.
2073 * For inline data, the underlying buffer must be
2074 * a multiple of 4 bytes in size so that it can be
2075 * logged and stay on word boundaries. We enforce
2076 * that here.
2077 */
2084 /*
2085 * Only do the realloc if the underlying size
2086 * is really changing.
2087 */
2091 real_size,
2094 }
2101 }
2102 }
2106 }
2108 void
2112 {
2119 }
2121 /*
2122 * If the format is local, then we can't have an extents
2123 * array so just look for an inline data array. If we're
2124 * not local then we may or may not have an extents list,
2125 * so check and free it up if we do.
2126 */
2134 }
2141 }
2148 }
2149 }
2151 /*
2152 * This is called to unpin an inode. The caller must have the inode locked
2153 * in at least shared mode so that the buffer cannot be subsequently pinned
2154 * once someone is waiting for it to be unpinned.
2155 */
2156 static void
2159 {
2164 /* Give the log a push to start the unpinning I/O */
2167 }
2169 void
2172 {
2176 }
2177 }
2179 /*
2180 * xfs_iextents_copy()
2181 *
2182 * This is called to copy the REAL extents (as opposed to the delayed
2183 * allocation extents) from the inode into the given buffer. It
2184 * returns the number of bytes copied into the buffer.
2185 *
2186 * If there are no delayed allocation extents, then we can just
2187 * memcpy() the extents into the buffer. Otherwise, we need to
2188 * examine each extent in turn and skip those which are delayed.
2189 */
2190 int
2195 {
2200 xfs_fsblock_t start_block;
2210 /*
2211 * There are some delayed allocation extents in the
2212 * inode, so copy the extents one at a time and skip
2213 * the delayed ones. There must be at least one
2214 * non-delayed extent.
2215 */
2221 /*
2222 * It's a delayed allocation extent, so skip it.
2223 */
2225 }
2227 /* Translate to on disk format */
2230 dp++;
2231 copied++;
2232 }
2237 }
2239 /*
2240 * Each of the following cases stores data into the same region
2241 * of the on-disk inode, so only one of them can be valid at
2242 * any given time. While it is possible to have conflicting formats
2243 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2244 * in EXTENTS format, this can only happen when the fork has
2245 * changed formats after being modified but before being flushed.
2246 * In these cases, the format always takes precedence, because the
2247 * format indicates the current state of the fork.
2248 */
2249 /*ARGSUSED*/
2250 STATIC void
2257 {
2261 #ifdef XFS_TRANS_DEBUG
2263 #endif
2274 /*
2275 * This can happen if we gave up in iformat in an error path,
2276 * for the attribute fork.
2277 */
2281 }
2291 }
2302 whichfork);
2303 }
2312 XFS_BROOT_SIZE_ADJ));
2316 }
2323 }
2332 }
2338 }
2339 }
2341 STATIC int
2345 {
2369 /* really need a gang lookup range call here */
2380 /*
2381 * because this is an RCU protected lookup, we could find a
2382 * recently freed or even reallocated inode during the lookup.
2383 * We need to check under the i_flags_lock for a valid inode
2384 * here. Skip it if it is not valid or the wrong inode.
2385 */
2391 }
2394 /*
2395 * Do an un-protected check to see if the inode is dirty and
2396 * is a candidate for flushing. These checks will be repeated
2397 * later after the appropriate locks are acquired.
2398 */
2402 /*
2403 * Try to get locks. If any are unavailable or it is pinned,
2404 * then this inode cannot be flushed and is skipped.
2405 */
2412 }
2417 }
2419 /*
2420 * arriving here means that this inode can be flushed. First
2421 * re-check that it's dirty before flushing.
2422 */
2429 }
2430 clcount++;
2433 }
2435 }
2440 }
2442 out_free:
2445 out_put:
2450 cluster_corrupt_out:
2451 /*
2452 * Corruption detected in the clustering loop. Invalidate the
2453 * inode buffer and shut down the filesystem.
2454 */
2456 /*
2457 * Clean up the buffer. If it was B_DELWRI, just release it --
2458 * brelse can handle it with no problems. If not, shut down the
2459 * filesystem before releasing the buffer.
2460 */
2468 /*
2469 * Just like incore_relse: if we have b_iodone functions,
2470 * mark the buffer as an error and call them. Otherwise
2471 * mark it as stale and brelse.
2472 */
2481 }
2482 }
2484 /*
2485 * Unlocks the flush lock
2486 */
2491 }
2493 /*
2494 * xfs_iflush() will write a modified inode's changes out to the
2495 * inode's on disk home. The caller must have the inode lock held
2496 * in at least shared mode and the inode flush completion must be
2497 * active as well. The inode lock will still be held upon return from
2498 * the call and the caller is free to unlock it.
2499 * The inode flush will be completed when the inode reaches the disk.
2500 * The flags indicate how the inode's buffer should be written out.
2501 */
2502 int
2505 uint flags)
2506 {
2523 /*
2524 * We can't flush the inode until it is unpinned, so wait for it if we
2525 * are allowed to block. We know no one new can pin it, because we are
2526 * holding the inode lock shared and you need to hold it exclusively to
2527 * pin the inode.
2528 *
2529 * If we are not allowed to block, force the log out asynchronously so
2530 * that when we come back the inode will be unpinned. If other inodes
2531 * in the same cluster are dirty, they will probably write the inode
2532 * out for us if they occur after the log force completes.
2533 */
2538 }
2541 /*
2542 * For stale inodes we cannot rely on the backing buffer remaining
2543 * stale in cache for the remaining life of the stale inode and so
2544 * xfs_itobp() below may give us a buffer that no longer contains
2545 * inodes below. We have to check this after ensuring the inode is
2546 * unpinned so that it is safe to reclaim the stale inode after the
2547 * flush call.
2548 */
2552 }
2554 /*
2555 * This may have been unpinned because the filesystem is shutting
2556 * down forcibly. If that's the case we must not write this inode
2557 * to disk, because the log record didn't make it to disk!
2558 */
2565 }
2567 /*
2568 * Get the buffer containing the on-disk inode.
2569 */
2575 }
2577 /*
2578 * First flush out the inode that xfs_iflush was called with.
2579 */
2584 /*
2585 * If the buffer is pinned then push on the log now so we won't
2586 * get stuck waiting in the write for too long.
2587 */
2591 /*
2592 * inode clustering:
2593 * see if other inodes can be gathered into this write
2594 */
2601 else
2605 corrupt_out:
2608 cluster_corrupt_out:
2609 /*
2610 * Unlocks the flush lock
2611 */
2614 }
2617 STATIC int
2621 {
2625 #ifdef XFS_TRANS_DEBUG
2627 #endif
2637 /* set *dip = inode's place in the buffer */
2640 /*
2641 * Clear i_update_core before copying out the data.
2642 * This is for coordination with our timestamp updates
2643 * that don't hold the inode lock. They will always
2644 * update the timestamps BEFORE setting i_update_core,
2645 * so if we clear i_update_core after they set it we
2646 * are guaranteed to see their updates to the timestamps.
2647 * I believe that this depends on strongly ordered memory
2648 * semantics, but we have that. We use the SYNCHRONIZE
2649 * macro to make sure that the compiler does not reorder
2650 * the i_update_core access below the data copy below.
2651 */
2655 /*
2656 * Make sure to get the latest timestamps from the Linux inode.
2657 */
2666 }
2673 }
2683 }
2694 }
2695 }
2698 XFS_RANDOM_IFLUSH_5)) {
2700 "%s: detected corrupt incore inode %Lu, "
2706 }
2713 }
2714 /*
2715 * bump the flush iteration count, used to detect flushes which
2716 * postdate a log record during recovery.
2717 */
2721 /*
2722 * Copy the dirty parts of the inode into the on-disk
2723 * inode. We always copy out the core of the inode,
2724 * because if the inode is dirty at all the core must
2725 * be.
2726 */
2729 /* Wrap, we never let the log put out DI_MAX_FLUSH */
2733 /*
2734 * If this is really an old format inode and the superblock version
2735 * has not been updated to support only new format inodes, then
2736 * convert back to the old inode format. If the superblock version
2737 * has been updated, then make the conversion permanent.
2738 */
2742 /*
2743 * Convert it back.
2744 */
2748 /*
2749 * The superblock version has already been bumped,
2750 * so just make the conversion to the new inode
2751 * format permanent.
2752 */
2761 }
2762 }
2769 /*
2770 * We've recorded everything logged in the inode, so we'd
2771 * like to clear the ilf_fields bits so we don't log and
2772 * flush things unnecessarily. However, we can't stop
2773 * logging all this information until the data we've copied
2774 * into the disk buffer is written to disk. If we did we might
2775 * overwrite the copy of the inode in the log with all the
2776 * data after re-logging only part of it, and in the face of
2777 * a crash we wouldn't have all the data we need to recover.
2778 *
2779 * What we do is move the bits to the ili_last_fields field.
2780 * When logging the inode, these bits are moved back to the
2781 * ilf_fields field. In the xfs_iflush_done() routine we
2782 * clear ili_last_fields, since we know that the information
2783 * those bits represent is permanently on disk. As long as
2784 * the flush completes before the inode is logged again, then
2785 * both ilf_fields and ili_last_fields will be cleared.
2786 *
2787 * We can play with the ilf_fields bits here, because the inode
2788 * lock must be held exclusively in order to set bits there
2789 * and the flush lock protects the ili_last_fields bits.
2790 * Set ili_logged so the flush done
2791 * routine can tell whether or not to look in the AIL.
2792 * Also, store the current LSN of the inode so that we can tell
2793 * whether the item has moved in the AIL from xfs_iflush_done().
2794 * In order to read the lsn we need the AIL lock, because
2795 * it is a 64 bit value that cannot be read atomically.
2796 */
2805 /*
2806 * Attach the function xfs_iflush_done to the inode's
2807 * buffer. This will remove the inode from the AIL
2808 * and unlock the inode's flush lock when the inode is
2809 * completely written to disk.
2810 */
2816 /*
2817 * We're flushing an inode which is not in the AIL and has
2818 * not been logged but has i_update_core set. For this
2819 * case we can use a B_DELWRI flush and immediately drop
2820 * the inode flush lock because we can avoid the whole
2821 * AIL state thing. It's OK to drop the flush lock now,
2822 * because we've already locked the buffer and to do anything
2823 * you really need both.
2824 */
2829 }
2831 }
2835 corrupt_out:
2837 }
2839 /*
2840 * Return a pointer to the extent record at file index idx.
2841 */
2842 xfs_bmbt_rec_host_t *
2846 {
2863 }
2864 }
2866 /*
2867 * Insert new item(s) into the extent records for incore inode
2868 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
2869 */
2870 void
2877 {
2887 }
2889 /*
2890 * This is called when the amount of space required for incore file
2891 * extents needs to be increased. The ext_diff parameter stores the
2892 * number of new extents being added and the idx parameter contains
2893 * the extent index where the new extents will be added. If the new
2894 * extents are being appended, then we just need to (re)allocate and
2895 * initialize the space. Otherwise, if the new extents are being
2896 * inserted into the middle of the existing entries, a bit more work
2897 * is required to make room for the new extents to be inserted. The
2898 * caller is responsible for filling in the new extent entries upon
2899 * return.
2900 */
2901 void
2906 {
2915 /*
2916 * If the new number of extents (nextents + ext_diff)
2917 * fits inside the inode, then continue to use the inline
2918 * extent buffer.
2919 */
2926 }
2929 }
2930 /*
2931 * Otherwise use a linear (direct) extent list.
2932 * If the extents are currently inside the inode,
2933 * xfs_iext_realloc_direct will switch us from
2934 * inline to direct extent allocation mode.
2935 */
2943 }
2944 }
2945 /* Indirection array */
2958 }
2959 /* Extents fit in target extent page */
2967 }
2970 }
2971 /* Insert a new extent page */
2975 }
2976 /*
2977 * If extent(s) are being appended to the last page in
2978 * the indirection array and the new extent(s) don't fit
2979 * in the page, then erp is NULL and erp_idx is set to
2980 * the next index needed in the indirection array.
2981 */
2990 erp_idx++;
2991 }
2992 }
2993 }
2994 }
2996 }
2998 /*
2999 * This is called when incore extents are being added to the indirection
3000 * array and the new extents do not fit in the target extent list. The
3001 * erp_idx parameter contains the irec index for the target extent list
3002 * in the indirection array, and the idx parameter contains the extent
3003 * index within the list. The number of extents being added is stored
3004 * in the count parameter.
3005 *
3006 * |-------| |-------|
3007 * | | | | idx - number of extents before idx
3008 * | idx | | count |
3009 * | | | | count - number of extents being inserted at idx
3010 * |-------| |-------|
3011 * | count | | nex2 | nex2 - number of extents after idx + count
3012 * |-------| |-------|
3013 */
3014 void
3020 {
3034 /*
3035 * Save second part of target extent list
3036 * (all extents past */
3044 }
3046 /*
3047 * Add the new extents to the end of the target
3048 * list, then allocate new irec record(s) and
3049 * extent buffer(s) as needed to store the rest
3050 * of the new extents.
3051 */
3058 }
3060 erp_idx++;
3066 }
3068 /* Add nex2 extents back to indirection array */
3070 xfs_extnum_t ext_avail;
3076 /*
3077 * If nex2 extents fit in the current page, append
3078 * nex2_ep after the new extents.
3079 */
3082 }
3083 /*
3084 * Otherwise, check if space is available in the
3085 * next page.
3086 */
3090 erp_idx++;
3091 erp++;
3092 /* Create a hole for nex2 extents */
3095 }
3096 /*
3097 * Final choice, create a new extent page for
3098 * nex2 extents.
3099 */
3101 erp_idx++;
3103 }
3108 }
3109 }
3111 /*
3112 * This is called when the amount of space required for incore file
3113 * extents needs to be decreased. The ext_diff parameter stores the
3114 * number of extents to be removed and the idx parameter contains
3115 * the extent index where the extents will be removed from.
3116 *
3117 * If the amount of space needed has decreased below the linear
3118 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3119 * extent array. Otherwise, use kmem_realloc() to adjust the
3120 * size to what is needed.
3121 */
3122 void
3128 {
3147 }
3149 }
3151 /*
3152 * This removes ext_diff extents from the inline buffer, beginning
3153 * at extent index idx.
3154 */
3155 void
3160 {
3179 }
3180 }
3182 /*
3183 * This removes ext_diff extents from a linear (direct) extent list,
3184 * beginning at extent index idx. If the extents are being removed
3185 * from the end of the list (ie. truncate) then we just need to re-
3186 * allocate the list to remove the extra space. Otherwise, if the
3187 * extents are being removed from the middle of the existing extent
3188 * entries, then we first need to move the extent records beginning
3189 * at idx + ext_diff up in the list to overwrite the records being
3190 * removed, then remove the extra space via kmem_realloc.
3191 */
3192 void
3197 {
3209 }
3210 /* Move extents up in the list (if needed) */
3216 }
3219 /*
3220 * Reallocate the direct extent list. If the extents
3221 * will fit inside the inode then xfs_iext_realloc_direct
3222 * will switch from direct to inline extent allocation
3223 * mode for us.
3224 */
3227 }
3229 /*
3230 * This is called when incore extents are being removed from the
3231 * indirection array and the extents being removed span multiple extent
3232 * buffers. The idx parameter contains the file extent index where we
3233 * want to begin removing extents, and the count parameter contains
3234 * how many extents need to be removed.
3235 *
3236 * |-------| |-------|
3237 * | nex1 | | | nex1 - number of extents before idx
3238 * |-------| | count |
3239 * | | | | count - number of extents being removed at idx
3240 * | count | |-------|
3241 * | | | nex2 | nex2 - number of extents after idx + count
3242 * |-------| |-------|
3243 */
3244 void
3249 {
3266 /*
3267 * Check for deletion of entire list;
3268 * xfs_iext_irec_remove() updates extent offsets.
3269 */
3276 XFS_IEXT_BUFSZ);
3282 }
3283 }
3284 /* Move extents up (if needed) */
3289 }
3290 /* Zero out rest of page */
3293 /* Update remaining counters */
3298 erp_idx++;
3299 erp++;
3300 }
3303 }
3305 /*
3306 * Create, destroy, or resize a linear (direct) block of extents.
3307 */
3308 void
3312 {
3321 /* Free extent records */
3324 }
3325 /* Resize direct extent list and zero any new bytes */
3327 /* Check if extents will fit inside the inode */
3333 }
3336 }
3340 rnew_size,
3342 }
3347 }
3348 }
3349 /*
3350 * Switch from the inline extent buffer to a direct
3351 * extent list. Be sure to include the inline extent
3352 * bytes in new_size.
3353 */
3358 }
3360 }
3363 }
3365 /*
3366 * Switch from linear (direct) extent records to inline buffer.
3367 */
3368 void
3372 {
3375 /*
3376 * The inline buffer was zeroed when we switched
3377 * from inline to direct extent allocation mode,
3378 * so we don't need to clear it here.
3379 */
3385 }
3387 /*
3388 * Switch from inline buffer to linear (direct) extent records.
3389 * new_size should already be rounded up to the next power of 2
3390 * by the caller (when appropriate), so use new_size as it is.
3391 * However, since new_size may be rounded up, we can't update
3392 * if_bytes here. It is the caller's responsibility to update
3393 * if_bytes upon return.
3394 */
3395 void
3399 {
3407 }
3409 }
3411 /*
3412 * Resize an extent indirection array to new_size bytes.
3413 */
3414 STATIC void
3418 {
3433 }
3434 }
3436 /*
3437 * Switch from indirection array to linear (direct) extent allocations.
3438 */
3439 STATIC void
3442 {
3462 }
3463 }
3465 /*
3466 * Free incore file extents.
3467 */
3468 void
3471 {
3479 }
3486 }
3490 }
3492 /*
3493 * Return a pointer to the extent record for file system block bno.
3494 */
3500 {
3515 }
3518 /* Find target extent list */
3526 }
3527 /* Binary search extent records */
3538 /* Convert back to file-based extent index */
3541 }
3544 }
3545 }
3546 /* Convert back to file-based extent index */
3549 }
3555 }
3556 }
3559 }
3561 /*
3562 * Return a pointer to the indirection array entry containing the
3563 * extent record for filesystem block bno. Store the index of the
3564 * target irec in *erp_idxp.
3565 */
3571 {
3595 }
3596 }
3599 }
3601 /*
3602 * Return a pointer to the indirection array entry containing the
3603 * extent record at file extent index *idxp. Store the index of the
3604 * target irec in *erp_idxp and store the page index of the target
3605 * extent record in *idxp.
3606 */
3607 xfs_ext_irec_t *
3613 {
3632 /* Binary search extent irec's */
3648 erp_idx++;
3654 }
3655 }
3659 }
3661 /*
3662 * Allocate and initialize an indirection array once the space needed
3663 * for incore extents increases above XFS_IEXT_BUFSZ.
3664 */
3665 void
3668 {
3684 }
3695 }
3697 /*
3698 * Allocate and initialize a new entry in the indirection array.
3699 */
3700 xfs_ext_irec_t *
3704 {
3712 /* Resize indirection array */
3715 /*
3716 * Move records down in the array so the
3717 * new page can use erp_idx.
3718 */
3722 }
3725 /* Initialize new extent record */
3734 }
3736 /*
3737 * Remove a record from the indirection array.
3738 */
3739 void
3743 {
3755 }
3756 /* Compact extent records */
3760 }
3761 /*
3762 * Manually free the last extent record from the indirection
3763 * array. A call to xfs_iext_realloc_indirect() with a size
3764 * of zero would result in a call to xfs_iext_destroy() which
3765 * would in turn call this function again, creating a nasty
3766 * infinite loop.
3767 */
3773 }
3775 }
3777 /*
3778 * This is called to clean up large amounts of unused memory allocated
3779 * by the indirection array. Before compacting anything though, verify
3780 * that the indirection array is still needed and switch back to the
3781 * linear extent list (or even the inline buffer) if possible. The
3782 * compaction policy is as follows:
3783 *
3784 * Full Compaction: Extents fit into a single page (or inline buffer)
3785 * Partial Compaction: Extents occupy less than 50% of allocated space
3786 * No Compaction: Extents occupy at least 50% of allocated space
3787 */
3788 void
3791 {
3808 }
3809 }
3811 /*
3812 * Combine extents from neighboring extent pages.
3813 */
3814 void
3817 {
3833 /*
3834 * Free page before removing extent record
3835 * so er_extoffs don't get modified in
3836 * xfs_iext_irec_remove.
3837 */
3843 erp_idx++;
3844 }
3845 }
3846 }
3848 /*
3849 * This is called to update the er_extoff field in the indirection
3850 * array when extents have been added or removed from one of the
3851 * extent lists. erp_idx contains the irec index to begin updating
3852 * at and ext_diff contains the number of extents that were added
3853 * or removed.
3854 */
3855 void
3860 {
3868 }
3869 }