| blob | 19e7a7b82703d6e3c3803c0a9cc3ac486562d8a4 |
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>
59 /*
60 * Used in xfs_itruncate(). This is the maximum number of extents
61 * freed from a file in a single transaction.
62 */
63 #define XFS_ITRUNC_MAX_EXTENTS 2
70 #ifdef DEBUG
71 /*
72 * Make sure that the extents in the given memory buffer
73 * are valid.
74 */
75 STATIC void
79 xfs_exntfmt_t fmt)
80 {
81 xfs_bmbt_irec_t irec;
82 xfs_bmbt_rec_host_t rec;
92 }
93 }
95 #define xfs_validate_extents(ifp, nrecs, fmt)
98 /*
99 * Check that none of the inode's in the buffer have a next
100 * unlinked field of 0.
101 */
102 #if defined(DEBUG)
103 void
107 {
119 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
120 bp);
122 }
123 }
124 }
125 #endif
127 /*
128 * Find the buffer associated with the given inode map
129 * We do basic validation checks on the buffer once it has been
130 * retrieved from disk.
131 */
132 STATIC int
138 uint buf_flags,
139 uint imap_flags)
140 {
151 "xfs_imap_to_bp: xfs_trans_read_buf()returned "
156 }
158 }
160 /*
161 * Validate the magic number and version of every inode in the buffer
162 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
163 */
164 #ifdef DEBUG
168 #endif
179 XFS_ERRTAG_ITOBP_INOTOBP,
180 XFS_RANDOM_ITOBP_INOTOBP))) {
184 }
187 #ifdef DEBUG
189 "Device %s - bad inode magic/vsn "
194 #endif
197 }
198 }
202 /*
203 * Mark the buffer as an inode buffer now that it looks good
204 */
209 }
211 /*
212 * This routine is called to map an inode number within a file
213 * system to the buffer containing the on-disk version of the
214 * inode. It returns a pointer to the buffer containing the
215 * on-disk inode in the bpp parameter, and in the dip parameter
216 * it returns a pointer to the on-disk inode within that buffer.
217 *
218 * If a non-zero error is returned, then the contents of bpp and
219 * dipp are undefined.
220 *
221 * Use xfs_imap() to determine the size and location of the
222 * buffer to read from disk.
223 */
224 STATIC int
228 xfs_ino_t ino,
232 {
233 xfs_imap_t imap;
250 }
253 /*
254 * This routine is called to map an inode to the buffer containing
255 * the on-disk version of the inode. It returns a pointer to the
256 * buffer containing the on-disk inode in the bpp parameter, and in
257 * the dip parameter it returns a pointer to the on-disk inode within
258 * that buffer.
259 *
260 * If a non-zero error is returned, then the contents of bpp and
261 * dipp are undefined.
262 *
263 * If the inode is new and has not yet been initialized, use xfs_imap()
264 * to determine the size and location of the buffer to read from disk.
265 * If the inode has already been mapped to its buffer and read in once,
266 * then use the mapping information stored in the inode rather than
267 * calling xfs_imap(). This allows us to avoid the overhead of looking
268 * at the inode btree for small block file systems (see xfs_dilocate()).
269 * We can tell whether the inode has been mapped in before by comparing
270 * its disk block address to 0. Only uninitialized inodes will have
271 * 0 for the disk block address.
272 */
273 int
280 xfs_daddr_t bno,
281 uint imap_flags,
282 uint buf_flags)
283 {
284 xfs_imap_t imap;
295 /*
296 * Fill in the fields in the inode that will be used to
297 * map the inode to its buffer from now on.
298 */
303 /*
304 * We've already mapped the inode once, so just use the
305 * mapping that we saved the first time.
306 */
310 }
322 }
327 }
329 /*
330 * Move inode type and inode format specific information from the
331 * on-disk inode to the in-core inode. For fifos, devs, and sockets
332 * this means set if_rdev to the proper value. For files, directories,
333 * and symlinks this means to bring in the in-line data or extent
334 * pointers. For a file in B-tree format, only the root is immediately
335 * brought in-core. The rest will be in-lined in if_extents when it
336 * is first referenced (see xfs_iread_extents()).
337 */
338 STATIC int
342 {
346 xfs_fsize_t di_size;
364 }
374 }
385 }
396 /*
397 * no local regular files yet
398 */
401 "corrupt inode %Lu "
405 XFS_ERRLEVEL_LOW,
408 }
413 "corrupt inode %Lu "
418 XFS_ERRLEVEL_LOW,
421 }
436 }
442 }
445 }
467 }
472 }
474 }
476 /*
477 * The file is in-lined in the on-disk inode.
478 * If it fits into if_inline_data, then copy
479 * it there, otherwise allocate a buffer for it
480 * and copy the data there. Either way, set
481 * if_data to point at the data.
482 * If we allocate a buffer for the data, make
483 * sure that its size is a multiple of 4 and
484 * record the real size in i_real_bytes.
485 */
486 STATIC int
492 {
496 /*
497 * If the size is unreasonable, then something
498 * is wrong and we just bail out rather than crash in
499 * kmem_alloc() or memcpy() below.
500 */
503 "corrupt inode %Lu "
510 }
520 }
528 }
530 /*
531 * The file consists of a set of extents all
532 * of which fit into the on-disk inode.
533 * If there are few enough extents to fit into
534 * the if_inline_ext, then copy them there.
535 * Otherwise allocate a buffer for them and copy
536 * them into it. Either way, set if_extents
537 * to point at the extents.
538 */
539 STATIC int
544 {
555 /*
556 * If the number of extents is unreasonable, then something
557 * is wrong and we just bail out rather than crash in
558 * kmem_alloc() or memcpy() below.
559 */
567 }
574 else
585 }
592 XFS_ERRLEVEL_LOW,
595 }
596 }
599 }
601 /*
602 * The file has too many extents to fit into
603 * the inode, so they are in B-tree format.
604 * Allocate a buffer for the root of the B-tree
605 * and copy the root into it. The i_extents
606 * field will remain NULL until all of the
607 * extents are read in (when they are needed).
608 */
609 STATIC int
614 {
617 /* REFERENCED */
626 /*
627 * blow out if -- fork has less extents than can fit in
628 * fork (fork shouldn't be a btree format), root btree
629 * block has more records than can fit into the fork,
630 * or the number of extents is greater than the number of
631 * blocks.
632 */
643 }
648 /*
649 * Copy and convert from the on-disk structure
650 * to the in-memory structure.
651 */
658 }
660 void
664 {
693 }
695 void
699 {
728 }
730 STATIC uint
732 __uint16_t di_flags)
733 {
765 }
768 }
770 uint
773 {
778 }
780 uint
783 {
788 }
790 /*
791 * Given a mount structure and an inode number, return a pointer
792 * to a newly allocated in-core inode corresponding to the given
793 * inode number.
794 *
795 * Initialize the inode's attributes and extent pointers if it
796 * already has them (it will not if the inode has no links).
797 */
798 int
802 xfs_ino_t ino,
804 xfs_daddr_t bno,
805 uint imap_flags)
806 {
820 /*
821 * Get pointer's to the on-disk inode and the buffer containing it.
822 * If the inode number refers to a block outside the file system
823 * then xfs_itobp() will return NULL. In this case we should
824 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
825 * know that this is a new incore inode.
826 */
831 }
833 /*
834 * Initialize inode's trace buffers.
835 * Do this before xfs_iformat in case it adds entries.
836 */
837 #ifdef XFS_INODE_TRACE
839 #endif
840 #ifdef XFS_BMAP_TRACE
842 #endif
843 #ifdef XFS_BMBT_TRACE
845 #endif
846 #ifdef XFS_RW_TRACE
848 #endif
849 #ifdef XFS_ILOCK_TRACE
851 #endif
852 #ifdef XFS_DIR2_TRACE
854 #endif
856 /*
857 * If we got something that isn't an inode it means someone
858 * (nfs or dmi) has a stale handle.
859 */
863 #ifdef DEBUG
865 "dip->di_core.di_magic (0x%x) != "
868 XFS_DINODE_MAGIC);
871 }
873 /*
874 * If the on-disk inode is already linked to a directory
875 * entry, copy all of the inode into the in-core inode.
876 * xfs_iformat() handles copying in the inode format
877 * specific information.
878 * Otherwise, just get the truly permanent information.
879 */
886 #ifdef DEBUG
889 error);
892 }
898 /*
899 * Make sure to pull in the mode here as well in
900 * case the inode is released without being used.
901 * This ensures that xfs_inactive() will see that
902 * the inode is already free and not try to mess
903 * with the uninitialized part of it.
904 */
906 /*
907 * Initialize the per-fork minima and maxima for a new
908 * inode here. xfs_iformat will do it for old inodes.
909 */
912 }
916 /*
917 * The inode format changed when we moved the link count and
918 * made it 32 bits long. If this is an old format inode,
919 * convert it in memory to look like a new one. If it gets
920 * flushed to disk we will convert back before flushing or
921 * logging it. We zero out the new projid field and the old link
922 * count field. We'll handle clearing the pad field (the remains
923 * of the old uuid field) when we actually convert the inode to
924 * the new format. We don't change the version number so that we
925 * can distinguish this from a real new format inode.
926 */
931 }
936 /*
937 * Mark the buffer containing the inode as something to keep
938 * around for a while. This helps to keep recently accessed
939 * meta-data in-core longer.
940 */
943 /*
944 * Use xfs_trans_brelse() to release the buffer containing the
945 * on-disk inode, because it was acquired with xfs_trans_read_buf()
946 * in xfs_itobp() above. If tp is NULL, this is just a normal
947 * brelse(). If we're within a transaction, then xfs_trans_brelse()
948 * will only release the buffer if it is not dirty within the
949 * transaction. It will be OK to release the buffer in this case,
950 * because inodes on disk are never destroyed and we will be
951 * locking the new in-core inode before putting it in the hash
952 * table where other processes can find it. Thus we don't have
953 * to worry about the inode being changed just because we released
954 * the buffer.
955 */
959 }
961 /*
962 * Read in extents from a btree-format inode.
963 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
964 */
965 int
970 {
973 xfs_extnum_t nextents;
980 }
985 /*
986 * We know that the size is valid (it's checked in iformat_btree)
987 */
997 }
1000 }
1002 /*
1003 * Allocate an inode on disk and return a copy of its in-core version.
1004 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1005 * appropriately within the inode. The uid and gid for the inode are
1006 * set according to the contents of the given cred structure.
1007 *
1008 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1009 * has a free inode available, call xfs_iget()
1010 * to obtain the in-core version of the allocated inode. Finally,
1011 * fill in the inode and log its initial contents. In this case,
1012 * ialloc_context would be set to NULL and call_again set to false.
1013 *
1014 * If xfs_dialloc() does not have an available inode,
1015 * it will replenish its supply by doing an allocation. Since we can
1016 * only do one allocation within a transaction without deadlocks, we
1017 * must commit the current transaction before returning the inode itself.
1018 * In this case, therefore, we will set call_again to true and return.
1019 * The caller should then commit the current transaction, start a new
1020 * transaction, and call xfs_ialloc() again to actually get the inode.
1021 *
1022 * To ensure that some other process does not grab the inode that
1023 * was allocated during the first call to xfs_ialloc(), this routine
1024 * also returns the [locked] bp pointing to the head of the freelist
1025 * as ialloc_context. The caller should hold this buffer across
1026 * the commit and pass it back into this routine on the second call.
1027 *
1028 * If we are allocating quota inodes, we do not have a parent inode
1029 * to attach to or associate with (i.e. pip == NULL) because they
1030 * are not linked into the directory structure - they are attached
1031 * directly to the superblock - and so have no parent.
1032 */
1033 int
1037 mode_t mode,
1038 xfs_nlink_t nlink,
1039 xfs_dev_t rdev,
1041 xfs_prid_t prid,
1046 {
1047 xfs_ino_t ino;
1050 uint flags;
1053 /*
1054 * Call the space management code to pick
1055 * the on-disk inode to be allocated.
1056 */
1061 }
1065 }
1068 /*
1069 * Get the in-core inode with the lock held exclusively.
1070 * This is because we're setting fields here we need
1071 * to prevent others from looking at until we're done.
1072 */
1077 }
1090 /*
1091 * If the superblock version is up to where we support new format
1092 * inodes and this is currently an old format inode, then change
1093 * the inode version number now. This way we only do the conversion
1094 * here rather than here and in the flush/logging code.
1095 */
1099 /*
1100 * We've already zeroed the old link count, the projid field,
1101 * and the pad field.
1102 */
1103 }
1105 /*
1106 * Project ids won't be stored on disk if we are using a version 1 inode.
1107 */
1115 }
1116 }
1118 /*
1119 * If the group ID of the new file does not match the effective group
1120 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1121 * (and only if the irix_sgid_inherit compatibility variable is set).
1122 */
1127 }
1134 /*
1135 * di_gen will have been taken care of in xfs_iread.
1136 */
1159 }
1160 /* fall through */
1171 }
1178 }
1179 }
1181 xfs_inherit_noatime)
1184 xfs_inherit_nodump)
1187 xfs_inherit_sync)
1190 xfs_inherit_nosymlinks)
1195 xfs_inherit_nodefrag)
1200 }
1201 /* FALLTHROUGH */
1210 }
1211 /*
1212 * Attribute fork settings for new inode.
1213 */
1217 /*
1218 * Log the new values stuffed into the inode.
1219 */
1222 /* now that we have an i_mode we can setup inode ops and unlock */
1227 }
1229 /*
1230 * Check to make sure that there are no blocks allocated to the
1231 * file beyond the size of the file. We don't check this for
1232 * files with fixed size extents or real time extents, but we
1233 * at least do it for regular files.
1234 */
1235 #ifdef DEBUG
1236 void
1240 xfs_fsize_t isize)
1241 {
1242 xfs_fileoff_t map_first;
1257 /*
1258 * The filesystem could be shutting down, so bmapi may return
1259 * an error.
1260 */
1264 map_first),
1270 }
1273 /*
1274 * Calculate the last possible buffered byte in a file. This must
1275 * include data that was buffered beyond the EOF by the write code.
1276 * This also needs to deal with overflowing the xfs_fsize_t type
1277 * which can happen for sizes near the limit.
1278 *
1279 * We also need to take into account any blocks beyond the EOF. It
1280 * may be the case that they were buffered by a write which failed.
1281 * In that case the pages will still be in memory, but the inode size
1282 * will never have been updated.
1283 */
1284 xfs_fsize_t
1287 {
1289 xfs_fsize_t last_byte;
1290 xfs_fileoff_t last_block;
1291 xfs_fileoff_t size_last_block;
1297 /*
1298 * Only check for blocks beyond the EOF if the extents have
1299 * been read in. This eliminates the need for the inode lock,
1300 * and it also saves us from looking when it really isn't
1301 * necessary.
1302 */
1305 XFS_DATA_FORK);
1308 }
1311 }
1318 }
1322 }
1324 }
1326 #if defined(XFS_RW_TRACE)
1327 STATIC void
1332 xfs_fsize_t new_size,
1333 xfs_off_t toss_start,
1334 xfs_off_t toss_finish)
1335 {
1338 }
1357 }
1358 #else
1359 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1360 #endif
1362 /*
1363 * Start the truncation of the file to new_size. The new size
1364 * must be smaller than the current size. This routine will
1365 * clear the buffer and page caches of file data in the removed
1366 * range, and xfs_itruncate_finish() will remove the underlying
1367 * disk blocks.
1368 *
1369 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1370 * must NOT have the inode lock held at all. This is because we're
1371 * calling into the buffer/page cache code and we can't hold the
1372 * inode lock when we do so.
1373 *
1374 * We need to wait for any direct I/Os in flight to complete before we
1375 * proceed with the truncate. This is needed to prevent the extents
1376 * being read or written by the direct I/Os from being removed while the
1377 * I/O is in flight as there is no other method of synchronising
1378 * direct I/O with the truncate operation. Also, because we hold
1379 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1380 * started until the truncate completes and drops the lock. Essentially,
1381 * the vn_iowait() call forms an I/O barrier that provides strict ordering
1382 * between direct I/Os and the truncate operation.
1383 *
1384 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1385 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1386 * in the case that the caller is locking things out of order and
1387 * may not be able to call xfs_itruncate_finish() with the inode lock
1388 * held without dropping the I/O lock. If the caller must drop the
1389 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1390 * must be called again with all the same restrictions as the initial
1391 * call.
1392 */
1393 int
1396 uint flags,
1397 xfs_fsize_t new_size)
1398 {
1399 xfs_fsize_t last_byte;
1400 xfs_off_t toss_start;
1411 /* wait for the completion of any pending DIOs */
1415 /*
1416 * Call toss_pages or flushinval_pages to get rid of pages
1417 * overlapping the region being removed. We have to use
1418 * the less efficient flushinval_pages in the case that the
1419 * caller may not be able to finish the truncate without
1420 * dropping the inode's I/O lock. Make sure
1421 * to catch any pages brought in by buffers overlapping
1422 * the EOF by searching out beyond the isize by our
1423 * block size. We round new_size up to a block boundary
1424 * so that we don't toss things on the same block as
1425 * new_size but before it.
1426 *
1427 * Before calling toss_page or flushinval_pages, make sure to
1428 * call remapf() over the same region if the file is mapped.
1429 * This frees up mapped file references to the pages in the
1430 * given range and for the flushinval_pages case it ensures
1431 * that we get the latest mapped changes flushed out.
1432 */
1436 /*
1437 * The place to start tossing is beyond our maximum
1438 * file size, so there is no way that the data extended
1439 * out there.
1440 */
1442 }
1445 last_byte);
1453 }
1454 }
1456 #ifdef DEBUG
1459 }
1460 #endif
1462 }
1464 /*
1465 * Shrink the file to the given new_size. The new size must be smaller than
1466 * the current size. This will free up the underlying blocks in the removed
1467 * range after a call to xfs_itruncate_start() or xfs_atruncate_start().
1468 *
1469 * The transaction passed to this routine must have made a permanent log
1470 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1471 * given transaction and start new ones, so make sure everything involved in
1472 * the transaction is tidy before calling here. Some transaction will be
1473 * returned to the caller to be committed. The incoming transaction must
1474 * already include the inode, and both inode locks must be held exclusively.
1475 * The inode must also be "held" within the transaction. On return the inode
1476 * will be "held" within the returned transaction. This routine does NOT
1477 * require any disk space to be reserved for it within the transaction.
1478 *
1479 * The fork parameter must be either xfs_attr_fork or xfs_data_fork, and it
1480 * indicates the fork which is to be truncated. For the attribute fork we only
1481 * support truncation to size 0.
1482 *
1483 * We use the sync parameter to indicate whether or not the first transaction
1484 * we perform might have to be synchronous. For the attr fork, it needs to be
1485 * so if the unlink of the inode is not yet known to be permanent in the log.
1486 * This keeps us from freeing and reusing the blocks of the attribute fork
1487 * before the unlink of the inode becomes permanent.
1488 *
1489 * For the data fork, we normally have to run synchronously if we're being
1490 * called out of the inactive path or we're being called out of the create path
1491 * where we're truncating an existing file. Either way, the truncate needs to
1492 * be sync so blocks don't reappear in the file with altered data in case of a
1493 * crash. wsync filesystems can run the first case async because anything that
1494 * shrinks the inode has to run sync so by the time we're called here from
1495 * inactive, the inode size is permanently set to 0.
1496 *
1497 * Calls from the truncate path always need to be sync unless we're in a wsync
1498 * filesystem and the file has already been unlinked.
1499 *
1500 * The caller is responsible for correctly setting the sync parameter. It gets
1501 * too hard for us to guess here which path we're being called out of just
1502 * based on inode state.
1503 *
1504 * If we get an error, we must return with the inode locked and linked into the
1505 * current transaction. This keeps things simple for the higher level code,
1506 * because it always knows that the inode is locked and held in the transaction
1507 * that returns to it whether errors occur or not. We don't mark the inode
1508 * dirty on error so that transactions can be easily aborted if possible.
1509 */
1510 int
1514 xfs_fsize_t new_size,
1517 {
1518 xfs_fsblock_t first_block;
1519 xfs_fileoff_t first_unmap_block;
1520 xfs_fileoff_t last_block;
1526 xfs_bmap_free_t free_list;
1542 /*
1543 * We only support truncating the entire attribute fork.
1544 */
1547 }
1550 /*
1551 * The first thing we do is set the size to new_size permanently
1552 * on disk. This way we don't have to worry about anyone ever
1553 * being able to look at the data being freed even in the face
1554 * of a crash. What we're getting around here is the case where
1555 * we free a block, it is allocated to another file, it is written
1556 * to, and then we crash. If the new data gets written to the
1557 * file but the log buffers containing the free and reallocation
1558 * don't, then we'd end up with garbage in the blocks being freed.
1559 * As long as we make the new_size permanent before actually
1560 * freeing any blocks it doesn't matter if they get writtten to.
1561 *
1562 * The callers must signal into us whether or not the size
1563 * setting here must be synchronous. There are a few cases
1564 * where it doesn't have to be synchronous. Those cases
1565 * occur if the file is unlinked and we know the unlink is
1566 * permanent or if the blocks being truncated are guaranteed
1567 * to be beyond the inode eof (regardless of the link count)
1568 * and the eof value is permanent. Both of these cases occur
1569 * only on wsync-mounted filesystems. In those cases, we're
1570 * guaranteed that no user will ever see the data in the blocks
1571 * that are being truncated so the truncate can run async.
1572 * In the free beyond eof case, the file may wind up with
1573 * more blocks allocated to it than it needs if we crash
1574 * and that won't get fixed until the next time the file
1575 * is re-opened and closed but that's ok as that shouldn't
1576 * be too many blocks.
1577 *
1578 * However, we can't just make all wsync xactions run async
1579 * because there's one call out of the create path that needs
1580 * to run sync where it's truncating an existing file to size
1581 * 0 whose size is > 0.
1582 *
1583 * It's probably possible to come up with a test in this
1584 * routine that would correctly distinguish all the above
1585 * cases from the values of the function parameters and the
1586 * inode state but for sanity's sake, I've decided to let the
1587 * layers above just tell us. It's simpler to correctly figure
1588 * out in the layer above exactly under what conditions we
1589 * can run async and I think it's easier for others read and
1590 * follow the logic in case something has to be changed.
1591 * cscope is your friend -- rcc.
1592 *
1593 * The attribute fork is much simpler.
1594 *
1595 * For the attribute fork we allow the caller to tell us whether
1596 * the unlink of the inode that led to this call is yet permanent
1597 * in the on disk log. If it is not and we will be freeing extents
1598 * in this inode then we make the first transaction synchronous
1599 * to make sure that the unlink is permanent by the time we free
1600 * the blocks.
1601 */
1604 /*
1605 * If we are not changing the file size then do
1606 * not update the on-disk file size - we may be
1607 * called from xfs_inactive_free_eofblocks(). If we
1608 * update the on-disk file size and then the system
1609 * crashes before the contents of the file are
1610 * flushed to disk then the files may be full of
1611 * holes (ie NULL files bug).
1612 */
1617 }
1618 }
1623 }
1629 /*
1630 * Since it is possible for space to become allocated beyond
1631 * the end of the file (in a crash where the space is allocated
1632 * but the inode size is not yet updated), simply remove any
1633 * blocks which show up between the new EOF and the maximum
1634 * possible file size. If the first block to be removed is
1635 * beyond the maximum file size (ie it is the same as last_block),
1636 * then there is nothing to do.
1637 */
1645 }
1647 /*
1648 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1649 * will tell us whether it freed the entire range or
1650 * not. If this is a synchronous mount (wsync),
1651 * then we can tell bunmapi to keep all the
1652 * transactions asynchronous since the unlink
1653 * transaction that made this inode inactive has
1654 * already hit the disk. There's no danger of
1655 * the freed blocks being reused, there being a
1656 * crash, and the reused blocks suddenly reappearing
1657 * in this file with garbage in them once recovery
1658 * runs.
1659 */
1665 XFS_ITRUNC_MAX_EXTENTS,
1669 /*
1670 * If the bunmapi call encounters an error,
1671 * return to the caller where the transaction
1672 * can be properly aborted. We just need to
1673 * make sure we're not holding any resources
1674 * that we were not when we came in.
1675 */
1678 }
1680 /*
1681 * Duplicate the transaction that has the permanent
1682 * reservation and commit the old transaction.
1683 */
1687 /* link the inode into the next xact in the chain */
1691 }
1694 /*
1695 * If the bmap finish call encounters an error, return
1696 * to the caller where the transaction can be properly
1697 * aborted. We just need to make sure we're not
1698 * holding any resources that we were not when we came
1699 * in.
1700 *
1701 * Aborting from this point might lose some blocks in
1702 * the file system, but oh well.
1703 */
1706 }
1709 /*
1710 * Mark the inode dirty so it will be logged and
1711 * moved forward in the log as part of every commit.
1712 */
1714 }
1720 /* link the inode into the next transaction in the chain */
1727 XFS_TRANS_PERM_LOG_RES,
1728 XFS_ITRUNCATE_LOG_COUNT);
1731 }
1732 /*
1733 * Only update the size in the case of the data fork, but
1734 * always re-log the inode so that our permanent transaction
1735 * can keep on rolling it forward in the log.
1736 */
1739 /*
1740 * If we are not changing the file size then do
1741 * not update the on-disk file size - we may be
1742 * called from xfs_inactive_free_eofblocks(). If we
1743 * update the on-disk file size and then the system
1744 * crashes before the contents of the file are
1745 * flushed to disk then the files may be full of
1746 * holes (ie NULL files bug).
1747 */
1751 }
1752 }
1762 }
1764 /*
1765 * This is called when the inode's link count goes to 0.
1766 * We place the on-disk inode on a list in the AGI. It
1767 * will be pulled from this list when the inode is freed.
1768 */
1769 int
1773 {
1779 xfs_agnumber_t agno;
1780 xfs_daddr_t agdaddr;
1781 xfs_agino_t agino;
1796 /*
1797 * Get the agi buffer first. It ensures lock ordering
1798 * on the list.
1799 */
1805 /*
1806 * Validate the magic number of the agi block.
1807 */
1809 agi_ok =
1813 XFS_RANDOM_IUNLINK))) {
1817 }
1818 /*
1819 * Get the index into the agi hash table for the
1820 * list this inode will go on.
1821 */
1829 /*
1830 * There is already another inode in the bucket we need
1831 * to add ourselves to. Add us at the front of the list.
1832 * Here we put the head pointer into our next pointer,
1833 * and then we fall through to point the head at us.
1834 */
1840 /* both on-disk, don't endian flip twice */
1848 }
1850 /*
1851 * Point the bucket head pointer at the inode being inserted.
1852 */
1860 }
1862 /*
1863 * Pull the on-disk inode from the AGI unlinked list.
1864 */
1865 STATIC int
1869 {
1870 xfs_ino_t next_ino;
1876 xfs_agnumber_t agno;
1877 xfs_daddr_t agdaddr;
1878 xfs_agino_t agino;
1879 xfs_agino_t next_agino;
1887 /*
1888 * First pull the on-disk inode from the AGI unlinked list.
1889 */
1895 /*
1896 * Get the agi buffer first. It ensures lock ordering
1897 * on the list.
1898 */
1906 }
1907 /*
1908 * Validate the magic number of the agi block.
1909 */
1911 agi_ok =
1915 XFS_RANDOM_IUNLINK_REMOVE))) {
1923 }
1924 /*
1925 * Get the index into the agi hash table for the
1926 * list this inode will go on.
1927 */
1935 /*
1936 * We're at the head of the list. Get the inode's
1937 * on-disk buffer to see if there is anyone after us
1938 * on the list. Only modify our next pointer if it
1939 * is not already NULLAGINO. This saves us the overhead
1940 * of dealing with the buffer when there is no need to
1941 * change it.
1942 */
1949 }
1962 }
1963 /*
1964 * Point the bucket head pointer at the next inode.
1965 */
1974 /*
1975 * We need to search the list for the inode being freed.
1976 */
1980 /*
1981 * If the last inode wasn't the one pointing to
1982 * us, then release its buffer since we're not
1983 * going to do anything with it.
1984 */
1987 }
1996 }
2000 }
2001 /*
2002 * Now last_ibp points to the buffer previous to us on
2003 * the unlinked list. Pull us from the list.
2004 */
2011 }
2025 }
2026 /*
2027 * Point the previous inode on the list to the next inode.
2028 */
2036 }
2038 }
2040 STATIC void
2044 xfs_ino_t inum)
2045 {
2051 xfs_daddr_t blkno;
2067 }
2076 /*
2077 * Look for each inode in memory and attempt to lock it,
2078 * we can be racing with flush and tail pushing here.
2079 * any inode we get the locks on, add to an array of
2080 * inode items to process later.
2081 *
2082 * The get the buffer lock, we could beat a flush
2083 * or tail pushing thread to the lock here, in which
2084 * case they will go looking for the inode buffer
2085 * and fail, we need some other form of interlock
2086 * here.
2087 */
2094 /* Inode not in memory or we found it already,
2095 * nothing to do
2096 */
2100 }
2105 }
2107 /* If we can get the locks then add it to the
2108 * list, otherwise by the time we get the bp lock
2109 * below it will already be attached to the
2110 * inode buffer.
2111 */
2113 /* This inode will already be locked - by us, lets
2114 * keep it that way.
2115 */
2124 }
2125 }
2128 }
2139 }
2142 }
2143 }
2145 }
2149 XFS_BUF_LOCK);
2162 pre_flushed++;
2163 }
2165 }
2176 }
2190 }
2191 }
2196 }
2200 }
2202 /*
2203 * This is called to return an inode to the inode free list.
2204 * The inode should already be truncated to 0 length and have
2205 * no pages associated with it. This routine also assumes that
2206 * the inode is already a part of the transaction.
2207 *
2208 * The on-disk copy of the inode will have been added to the list
2209 * of unlinked inodes in the AGI. We need to remove the inode from
2210 * that list atomically with respect to freeing it here.
2211 */
2212 int
2217 {
2220 xfs_ino_t first_ino;
2233 /*
2234 * Pull the on-disk inode from the AGI unlinked list.
2235 */
2239 }
2244 }
2253 /*
2254 * Bump the generation count so no one will be confused
2255 * by reincarnations of this inode.
2256 */
2265 /*
2266 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
2267 * from picking up this inode when it is reclaimed (its incore state
2268 * initialzed but not flushed to disk yet). The in-core di_mode is
2269 * already cleared and a corresponding transaction logged.
2270 * The hack here just synchronizes the in-core to on-disk
2271 * di_mode value in advance before the actual inode sync to disk.
2272 * This is OK because the inode is already unlinked and would never
2273 * change its di_mode again for this inode generation.
2274 * This is a temporary hack that would require a proper fix
2275 * in the future.
2276 */
2281 }
2284 }
2286 /*
2287 * Reallocate the space for if_broot based on the number of records
2288 * being added or deleted as indicated in rec_diff. Move the records
2289 * and pointers in if_broot to fit the new size. When shrinking this
2290 * will eliminate holes between the records and pointers created by
2291 * the caller. When growing this will create holes to be filled in
2292 * by the caller.
2293 *
2294 * The caller must not request to add more records than would fit in
2295 * the on-disk inode root. If the if_broot is currently NULL, then
2296 * if we adding records one will be allocated. The caller must also
2297 * not request that the number of records go below zero, although
2298 * it can go to zero.
2299 *
2300 * ip -- the inode whose if_broot area is changing
2301 * ext_diff -- the change in the number of records, positive or negative,
2302 * requested for the if_broot array.
2303 */
2304 void
2309 {
2318 /*
2319 * Handle the degenerate case quietly.
2320 */
2323 }
2327 /*
2328 * If there wasn't any memory allocated before, just
2329 * allocate it now and get out.
2330 */
2334 KM_SLEEP);
2337 }
2339 /*
2340 * If there is already an existing if_broot, then we need
2341 * to realloc() it and shift the pointers to their new
2342 * location. The records don't change location because
2343 * they are kept butted up against the btree block header.
2344 */
2350 new_size,
2352 KM_SLEEP);
2362 }
2364 /*
2365 * rec_diff is less than 0. In this case, we are shrinking the
2366 * if_broot buffer. It must already exist. If we go to zero
2367 * records, just get rid of the root and clear the status bit.
2368 */
2375 else
2379 /*
2380 * First copy over the btree block header.
2381 */
2386 }
2388 /*
2389 * Only copy the records and pointers if there are any.
2390 */
2392 /*
2393 * First copy the records.
2394 */
2401 /*
2402 * Then copy the pointers.
2403 */
2409 }
2416 }
2419 /*
2420 * This is called when the amount of space needed for if_data
2421 * is increased or decreased. The change in size is indicated by
2422 * the number of bytes that need to be added or deleted in the
2423 * byte_diff parameter.
2424 *
2425 * If the amount of space needed has decreased below the size of the
2426 * inline buffer, then switch to using the inline buffer. Otherwise,
2427 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2428 * to what is needed.
2429 *
2430 * ip -- the inode whose if_data area is changing
2431 * byte_diff -- the change in the number of bytes, positive or negative,
2432 * requested for the if_data array.
2433 */
2434 void
2439 {
2446 }
2455 }
2459 /*
2460 * If the valid extents/data can fit in if_inline_ext/data,
2461 * copy them from the malloc'd vector and free it.
2462 */
2468 new_size);
2471 }
2474 /*
2475 * Stuck with malloc/realloc.
2476 * For inline data, the underlying buffer must be
2477 * a multiple of 4 bytes in size so that it can be
2478 * logged and stay on word boundaries. We enforce
2479 * that here.
2480 */
2486 /*
2487 * Only do the realloc if the underlying size
2488 * is really changing.
2489 */
2493 real_size,
2495 KM_SLEEP);
2496 }
2502 }
2503 }
2507 }
2512 /*
2513 * Map inode to disk block and offset.
2514 *
2515 * mp -- the mount point structure for the current file system
2516 * tp -- the current transaction
2517 * ino -- the inode number of the inode to be located
2518 * imap -- this structure is filled in with the information necessary
2519 * to retrieve the given inode from disk
2520 * flags -- flags to pass to xfs_dilocate indicating whether or not
2521 * lookups in the inode btree were OK or not
2522 */
2523 int
2527 xfs_ino_t ino,
2529 uint flags)
2530 {
2531 xfs_fsblock_t fsbno;
2548 /*
2549 * If the inode number maps to a block outside the bounds
2550 * of the file system then return NULL rather than calling
2551 * read_buf and panicing when we get an error from the
2552 * driver.
2553 */
2557 "(imap->im_blkno (0x%llx) + imap->im_len (0x%llx)) > "
2563 }
2565 }
2567 void
2571 {
2578 }
2580 /*
2581 * If the format is local, then we can't have an extents
2582 * array so just look for an inline data array. If we're
2583 * not local then we may or may not have an extents list,
2584 * so check and free it up if we do.
2585 */
2593 }
2600 }
2607 }
2608 }
2610 /*
2611 * This is called free all the memory associated with an inode.
2612 * It must free the inode itself and any buffers allocated for
2613 * if_extents/if_data and if_broot. It must also free the lock
2614 * associated with the inode.
2615 */
2616 void
2619 {
2626 }
2633 #ifdef XFS_INODE_TRACE
2635 #endif
2636 #ifdef XFS_BMAP_TRACE
2638 #endif
2639 #ifdef XFS_BMBT_TRACE
2641 #endif
2642 #ifdef XFS_RW_TRACE
2644 #endif
2645 #ifdef XFS_ILOCK_TRACE
2647 #endif
2648 #ifdef XFS_DIR2_TRACE
2650 #endif
2652 /*
2653 * Only if we are shutting down the fs will we see an
2654 * inode still in the AIL. If it is there, we should remove
2655 * it to prevent a use-after-free from occurring.
2656 */
2666 else
2668 }
2670 }
2672 }
2675 /*
2676 * Increment the pin count of the given buffer.
2677 * This value is protected by ipinlock spinlock in the mount structure.
2678 */
2679 void
2682 {
2686 }
2688 /*
2689 * Decrement the pin count of the given inode, and wake up
2690 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2691 * inode must have been previously pinned with a call to xfs_ipin().
2692 */
2693 void
2696 {
2701 }
2703 /*
2704 * This is called to unpin an inode. It can be directed to wait or to return
2705 * immediately without waiting for the inode to be unpinned. The caller must
2706 * have the inode locked in at least shared mode so that the buffer cannot be
2707 * subsequently pinned once someone is waiting for it to be unpinned.
2708 */
2709 STATIC void
2713 {
2720 /* Give the log a push to start the unpinning I/O */
2725 }
2730 {
2732 }
2737 {
2739 }
2742 /*
2743 * xfs_iextents_copy()
2744 *
2745 * This is called to copy the REAL extents (as opposed to the delayed
2746 * allocation extents) from the inode into the given buffer. It
2747 * returns the number of bytes copied into the buffer.
2748 *
2749 * If there are no delayed allocation extents, then we can just
2750 * memcpy() the extents into the buffer. Otherwise, we need to
2751 * examine each extent in turn and skip those which are delayed.
2752 */
2753 int
2758 {
2763 xfs_fsblock_t start_block;
2773 /*
2774 * There are some delayed allocation extents in the
2775 * inode, so copy the extents one at a time and skip
2776 * the delayed ones. There must be at least one
2777 * non-delayed extent.
2778 */
2784 /*
2785 * It's a delayed allocation extent, so skip it.
2786 */
2788 }
2790 /* Translate to on disk format */
2793 dp++;
2794 copied++;
2795 }
2800 }
2802 /*
2803 * Each of the following cases stores data into the same region
2804 * of the on-disk inode, so only one of them can be valid at
2805 * any given time. While it is possible to have conflicting formats
2806 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2807 * in EXTENTS format, this can only happen when the fork has
2808 * changed formats after being modified but before being flushed.
2809 * In these cases, the format always takes precedence, because the
2810 * format indicates the current state of the fork.
2811 */
2812 /*ARGSUSED*/
2813 STATIC void
2820 {
2824 #ifdef XFS_TRANS_DEBUG
2826 #endif
2837 /*
2838 * This can happen if we gave up in iformat in an error path,
2839 * for the attribute fork.
2840 */
2844 }
2854 }
2868 whichfork);
2869 }
2878 XFS_BROOT_SIZE_ADJ));
2882 }
2889 }
2897 }
2903 }
2904 }
2906 STATIC int
2910 {
2935 /* really need a gang lookup range call here */
2945 /* if the inode lies outside this cluster, we're done. */
2948 /*
2949 * Do an un-protected check to see if the inode is dirty and
2950 * is a candidate for flushing. These checks will be repeated
2951 * later after the appropriate locks are acquired.
2952 */
2956 /*
2957 * Try to get locks. If any are unavailable or it is pinned,
2958 * then this inode cannot be flushed and is skipped.
2959 */
2966 }
2971 }
2973 /*
2974 * arriving here means that this inode can be flushed. First
2975 * re-check that it's dirty before flushing.
2976 */
2983 }
2984 clcount++;
2987 }
2989 }
2994 }
2996 out_free:
3002 cluster_corrupt_out:
3003 /*
3004 * Corruption detected in the clustering loop. Invalidate the
3005 * inode buffer and shut down the filesystem.
3006 */
3008 /*
3009 * Clean up the buffer. If it was B_DELWRI, just release it --
3010 * brelse can handle it with no problems. If not, shut down the
3011 * filesystem before releasing the buffer.
3012 */
3020 /*
3021 * Just like incore_relse: if we have b_iodone functions,
3022 * mark the buffer as an error and call them. Otherwise
3023 * mark it as stale and brelse.
3024 */
3035 }
3036 }
3038 /*
3039 * Unlocks the flush lock
3040 */
3044 }
3046 /*
3047 * xfs_iflush() will write a modified inode's changes out to the
3048 * inode's on disk home. The caller must have the inode lock held
3049 * in at least shared mode and the inode flush semaphore must be
3050 * held as well. The inode lock will still be held upon return from
3051 * the call and the caller is free to unlock it.
3052 * The inode flush lock will be unlocked when the inode reaches the disk.
3053 * The flags indicate how the inode's buffer should be written out.
3054 */
3055 int
3058 uint flags)
3059 {
3078 /*
3079 * If the inode isn't dirty, then just release the inode
3080 * flush lock and do nothing.
3081 */
3085 }
3087 /*
3088 * We can't flush the inode until it is unpinned, so wait for it if we
3089 * are allowed to block. We know noone new can pin it, because we are
3090 * holding the inode lock shared and you need to hold it exclusively to
3091 * pin the inode.
3092 *
3093 * If we are not allowed to block, force the log out asynchronously so
3094 * that when we come back the inode will be unpinned. If other inodes
3095 * in the same cluster are dirty, they will probably write the inode
3096 * out for us if they occur after the log force completes.
3097 */
3102 }
3105 /*
3106 * This may have been unpinned because the filesystem is shutting
3107 * down forcibly. If that's the case we must not write this inode
3108 * to disk, because the log record didn't make it to disk!
3109 */
3116 }
3118 /*
3119 * Decide how buffer will be flushed out. This is done before
3120 * the call to xfs_iflush_int because this field is zeroed by it.
3121 */
3123 /*
3124 * Flush out the inode buffer according to the directions
3125 * of the caller. In the cases where the caller has given
3126 * us a choice choose the non-delwri case. This is because
3127 * the inode is in the AIL and we need to get it out soon.
3128 */
3146 }
3165 }
3166 }
3168 /*
3169 * Get the buffer containing the on-disk inode.
3170 */
3176 }
3178 /*
3179 * First flush out the inode that xfs_iflush was called with.
3180 */
3185 /*
3186 * If the buffer is pinned then push on the log now so we won't
3187 * get stuck waiting in the write for too long.
3188 */
3192 /*
3193 * inode clustering:
3194 * see if other inodes can be gathered into this write
3195 */
3206 }
3209 corrupt_out:
3212 cluster_corrupt_out:
3213 /*
3214 * Unlocks the flush lock
3215 */
3218 }
3221 STATIC int
3225 {
3229 #ifdef XFS_TRANS_DEBUG
3231 #endif
3242 /*
3243 * If the inode isn't dirty, then just release the inode
3244 * flush lock and do nothing.
3245 */
3249 }
3251 /* set *dip = inode's place in the buffer */
3254 /*
3255 * Clear i_update_core before copying out the data.
3256 * This is for coordination with our timestamp updates
3257 * that don't hold the inode lock. They will always
3258 * update the timestamps BEFORE setting i_update_core,
3259 * so if we clear i_update_core after they set it we
3260 * are guaranteed to see their updates to the timestamps.
3261 * I believe that this depends on strongly ordered memory
3262 * semantics, but we have that. We use the SYNCHRONIZE
3263 * macro to make sure that the compiler does not reorder
3264 * the i_update_core access below the data copy below.
3265 */
3269 /*
3270 * Make sure to get the latest atime from the Linux inode.
3271 */
3280 }
3287 }
3297 }
3308 }
3309 }
3312 XFS_RANDOM_IFLUSH_5)) {
3318 ip);
3320 }
3327 }
3328 /*
3329 * bump the flush iteration count, used to detect flushes which
3330 * postdate a log record during recovery.
3331 */
3335 /*
3336 * Copy the dirty parts of the inode into the on-disk
3337 * inode. We always copy out the core of the inode,
3338 * because if the inode is dirty at all the core must
3339 * be.
3340 */
3343 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3347 /*
3348 * If this is really an old format inode and the superblock version
3349 * has not been updated to support only new format inodes, then
3350 * convert back to the old inode format. If the superblock version
3351 * has been updated, then make the conversion permanent.
3352 */
3357 /*
3358 * Convert it back.
3359 */
3363 /*
3364 * The superblock version has already been bumped,
3365 * so just make the conversion to the new inode
3366 * format permanent.
3367 */
3376 }
3377 }
3384 /*
3385 * We've recorded everything logged in the inode, so we'd
3386 * like to clear the ilf_fields bits so we don't log and
3387 * flush things unnecessarily. However, we can't stop
3388 * logging all this information until the data we've copied
3389 * into the disk buffer is written to disk. If we did we might
3390 * overwrite the copy of the inode in the log with all the
3391 * data after re-logging only part of it, and in the face of
3392 * a crash we wouldn't have all the data we need to recover.
3393 *
3394 * What we do is move the bits to the ili_last_fields field.
3395 * When logging the inode, these bits are moved back to the
3396 * ilf_fields field. In the xfs_iflush_done() routine we
3397 * clear ili_last_fields, since we know that the information
3398 * those bits represent is permanently on disk. As long as
3399 * the flush completes before the inode is logged again, then
3400 * both ilf_fields and ili_last_fields will be cleared.
3401 *
3402 * We can play with the ilf_fields bits here, because the inode
3403 * lock must be held exclusively in order to set bits there
3404 * and the flush lock protects the ili_last_fields bits.
3405 * Set ili_logged so the flush done
3406 * routine can tell whether or not to look in the AIL.
3407 * Also, store the current LSN of the inode so that we can tell
3408 * whether the item has moved in the AIL from xfs_iflush_done().
3409 * In order to read the lsn we need the AIL lock, because
3410 * it is a 64 bit value that cannot be read atomically.
3411 */
3422 /*
3423 * Attach the function xfs_iflush_done to the inode's
3424 * buffer. This will remove the inode from the AIL
3425 * and unlock the inode's flush lock when the inode is
3426 * completely written to disk.
3427 */
3434 /*
3435 * We're flushing an inode which is not in the AIL and has
3436 * not been logged but has i_update_core set. For this
3437 * case we can use a B_DELWRI flush and immediately drop
3438 * the inode flush lock because we can avoid the whole
3439 * AIL state thing. It's OK to drop the flush lock now,
3440 * because we've already locked the buffer and to do anything
3441 * you really need both.
3442 */
3447 }
3449 }
3453 corrupt_out:
3455 }
3458 /*
3459 * Flush all inactive inodes in mp.
3460 */
3461 void
3464 {
3467 again:
3474 /* Make sure we skip markers inserted by sync */
3478 }
3484 }
3490 out:
3492 }
3494 #ifdef XFS_ILOCK_TRACE
3497 void
3499 {
3508 }
3509 #endif
3511 /*
3512 * Return a pointer to the extent record at file index idx.
3513 */
3514 xfs_bmbt_rec_host_t *
3518 {
3533 }
3534 }
3536 /*
3537 * Insert new item(s) into the extent records for incore inode
3538 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3539 */
3540 void
3546 {
3553 }
3555 /*
3556 * This is called when the amount of space required for incore file
3557 * extents needs to be increased. The ext_diff parameter stores the
3558 * number of new extents being added and the idx parameter contains
3559 * the extent index where the new extents will be added. If the new
3560 * extents are being appended, then we just need to (re)allocate and
3561 * initialize the space. Otherwise, if the new extents are being
3562 * inserted into the middle of the existing entries, a bit more work
3563 * is required to make room for the new extents to be inserted. The
3564 * caller is responsible for filling in the new extent entries upon
3565 * return.
3566 */
3567 void
3572 {
3581 /*
3582 * If the new number of extents (nextents + ext_diff)
3583 * fits inside the inode, then continue to use the inline
3584 * extent buffer.
3585 */
3592 }
3596 }
3597 /*
3598 * Otherwise use a linear (direct) extent list.
3599 * If the extents are currently inside the inode,
3600 * xfs_iext_realloc_direct will switch us from
3601 * inline to direct extent allocation mode.
3602 */
3610 }
3611 }
3612 /* Indirection array */
3625 }
3626 /* Extents fit in target extent page */
3634 }
3637 }
3638 /* Insert a new extent page */
3642 }
3643 /*
3644 * If extent(s) are being appended to the last page in
3645 * the indirection array and the new extent(s) don't fit
3646 * in the page, then erp is NULL and erp_idx is set to
3647 * the next index needed in the indirection array.
3648 */
3657 erp_idx++;
3658 }
3659 }
3660 }
3661 }
3663 }
3665 /*
3666 * This is called when incore extents are being added to the indirection
3667 * array and the new extents do not fit in the target extent list. The
3668 * erp_idx parameter contains the irec index for the target extent list
3669 * in the indirection array, and the idx parameter contains the extent
3670 * index within the list. The number of extents being added is stored
3671 * in the count parameter.
3672 *
3673 * |-------| |-------|
3674 * | | | | idx - number of extents before idx
3675 * | idx | | count |
3676 * | | | | count - number of extents being inserted at idx
3677 * |-------| |-------|
3678 * | count | | nex2 | nex2 - number of extents after idx + count
3679 * |-------| |-------|
3680 */
3681 void
3687 {
3701 /*
3702 * Save second part of target extent list
3703 * (all extents past */
3711 }
3713 /*
3714 * Add the new extents to the end of the target
3715 * list, then allocate new irec record(s) and
3716 * extent buffer(s) as needed to store the rest
3717 * of the new extents.
3718 */
3725 }
3727 erp_idx++;
3733 }
3735 /* Add nex2 extents back to indirection array */
3737 xfs_extnum_t ext_avail;
3743 /*
3744 * If nex2 extents fit in the current page, append
3745 * nex2_ep after the new extents.
3746 */
3749 }
3750 /*
3751 * Otherwise, check if space is available in the
3752 * next page.
3753 */
3757 erp_idx++;
3758 erp++;
3759 /* Create a hole for nex2 extents */
3762 }
3763 /*
3764 * Final choice, create a new extent page for
3765 * nex2 extents.
3766 */
3768 erp_idx++;
3770 }
3775 }
3776 }
3778 /*
3779 * This is called when the amount of space required for incore file
3780 * extents needs to be decreased. The ext_diff parameter stores the
3781 * number of extents to be removed and the idx parameter contains
3782 * the extent index where the extents will be removed from.
3783 *
3784 * If the amount of space needed has decreased below the linear
3785 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3786 * extent array. Otherwise, use kmem_realloc() to adjust the
3787 * size to what is needed.
3788 */
3789 void
3794 {
3810 }
3812 }
3814 /*
3815 * This removes ext_diff extents from the inline buffer, beginning
3816 * at extent index idx.
3817 */
3818 void
3823 {
3842 }
3843 }
3845 /*
3846 * This removes ext_diff extents from a linear (direct) extent list,
3847 * beginning at extent index idx. If the extents are being removed
3848 * from the end of the list (ie. truncate) then we just need to re-
3849 * allocate the list to remove the extra space. Otherwise, if the
3850 * extents are being removed from the middle of the existing extent
3851 * entries, then we first need to move the extent records beginning
3852 * at idx + ext_diff up in the list to overwrite the records being
3853 * removed, then remove the extra space via kmem_realloc.
3854 */
3855 void
3860 {
3872 }
3873 /* Move extents up in the list (if needed) */
3879 }
3882 /*
3883 * Reallocate the direct extent list. If the extents
3884 * will fit inside the inode then xfs_iext_realloc_direct
3885 * will switch from direct to inline extent allocation
3886 * mode for us.
3887 */
3890 }
3892 /*
3893 * This is called when incore extents are being removed from the
3894 * indirection array and the extents being removed span multiple extent
3895 * buffers. The idx parameter contains the file extent index where we
3896 * want to begin removing extents, and the count parameter contains
3897 * how many extents need to be removed.
3898 *
3899 * |-------| |-------|
3900 * | nex1 | | | nex1 - number of extents before idx
3901 * |-------| | count |
3902 * | | | | count - number of extents being removed at idx
3903 * | count | |-------|
3904 * | | | nex2 | nex2 - number of extents after idx + count
3905 * |-------| |-------|
3906 */
3907 void
3912 {
3931 /*
3932 * Check for deletion of entire list;
3933 * xfs_iext_irec_remove() updates extent offsets.
3934 */
3941 XFS_IEXT_BUFSZ);
3947 }
3948 }
3949 /* Move extents up (if needed) */
3954 }
3955 /* Zero out rest of page */
3958 /* Update remaining counters */
3963 erp_idx++;
3964 erp++;
3965 }
3968 }
3970 /*
3971 * Create, destroy, or resize a linear (direct) block of extents.
3972 */
3973 void
3977 {
3986 /* Free extent records */
3989 }
3990 /* Resize direct extent list and zero any new bytes */
3992 /* Check if extents will fit inside the inode */
3998 }
4001 }
4005 rnew_size,
4007 }
4012 }
4013 }
4014 /*
4015 * Switch from the inline extent buffer to a direct
4016 * extent list. Be sure to include the inline extent
4017 * bytes in new_size.
4018 */
4023 }
4025 }
4028 }
4030 /*
4031 * Switch from linear (direct) extent records to inline buffer.
4032 */
4033 void
4037 {
4040 /*
4041 * The inline buffer was zeroed when we switched
4042 * from inline to direct extent allocation mode,
4043 * so we don't need to clear it here.
4044 */
4050 }
4052 /*
4053 * Switch from inline buffer to linear (direct) extent records.
4054 * new_size should already be rounded up to the next power of 2
4055 * by the caller (when appropriate), so use new_size as it is.
4056 * However, since new_size may be rounded up, we can't update
4057 * if_bytes here. It is the caller's responsibility to update
4058 * if_bytes upon return.
4059 */
4060 void
4064 {
4072 }
4074 }
4076 /*
4077 * Resize an extent indirection array to new_size bytes.
4078 */
4079 void
4083 {
4098 }
4099 }
4101 /*
4102 * Switch from indirection array to linear (direct) extent allocations.
4103 */
4104 void
4107 {
4127 }
4128 }
4130 /*
4131 * Free incore file extents.
4132 */
4133 void
4136 {
4144 }
4151 }
4155 }
4157 /*
4158 * Return a pointer to the extent record for file system block bno.
4159 */
4165 {
4180 }
4183 /* Find target extent list */
4191 }
4192 /* Binary search extent records */
4203 /* Convert back to file-based extent index */
4206 }
4209 }
4210 }
4211 /* Convert back to file-based extent index */
4214 }
4220 }
4221 }
4224 }
4226 /*
4227 * Return a pointer to the indirection array entry containing the
4228 * extent record for filesystem block bno. Store the index of the
4229 * target irec in *erp_idxp.
4230 */
4236 {
4260 }
4261 }
4264 }
4266 /*
4267 * Return a pointer to the indirection array entry containing the
4268 * extent record at file extent index *idxp. Store the index of the
4269 * target irec in *erp_idxp and store the page index of the target
4270 * extent record in *idxp.
4271 */
4272 xfs_ext_irec_t *
4278 {
4295 /* Binary search extent irec's */
4311 erp_idx++;
4317 }
4318 }
4322 }
4324 /*
4325 * Allocate and initialize an indirection array once the space needed
4326 * for incore extents increases above XFS_IEXT_BUFSZ.
4327 */
4328 void
4331 {
4347 }
4358 }
4360 /*
4361 * Allocate and initialize a new entry in the indirection array.
4362 */
4363 xfs_ext_irec_t *
4367 {
4375 /* Resize indirection array */
4378 /*
4379 * Move records down in the array so the
4380 * new page can use erp_idx.
4381 */
4385 }
4388 /* Initialize new extent record */
4397 }
4399 /*
4400 * Remove a record from the indirection array.
4401 */
4402 void
4406 {
4418 }
4419 /* Compact extent records */
4423 }
4424 /*
4425 * Manually free the last extent record from the indirection
4426 * array. A call to xfs_iext_realloc_indirect() with a size
4427 * of zero would result in a call to xfs_iext_destroy() which
4428 * would in turn call this function again, creating a nasty
4429 * infinite loop.
4430 */
4436 }
4438 }
4440 /*
4441 * This is called to clean up large amounts of unused memory allocated
4442 * by the indirection array. Before compacting anything though, verify
4443 * that the indirection array is still needed and switch back to the
4444 * linear extent list (or even the inline buffer) if possible. The
4445 * compaction policy is as follows:
4446 *
4447 * Full Compaction: Extents fit into a single page (or inline buffer)
4448 * Full Compaction: Extents occupy less than 10% of allocated space
4449 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4450 * No Compaction: Extents occupy at least 50% of allocated space
4451 */
4452 void
4455 {
4474 }
4475 }
4477 /*
4478 * Combine extents from neighboring extent pages.
4479 */
4480 void
4483 {
4499 /*
4500 * Free page before removing extent record
4501 * so er_extoffs don't get modified in
4502 * xfs_iext_irec_remove.
4503 */
4509 erp_idx++;
4510 }
4511 }
4512 }
4514 /*
4515 * Fully compact the extent records managed by the indirection array.
4516 */
4517 void
4520 {
4537 /*
4538 * Check how many extent records are available in this irec.
4539 * If there is none skip the whole exercise.
4540 */
4544 /*
4545 * Copy over as many as possible extent records into
4546 * the previous page.
4547 */
4553 /*
4554 * If the next irec is empty now we can simply
4555 * remove it.
4556 */
4558 /*
4559 * Free page before removing extent record
4560 * so er_extoffs don't get modified in
4561 * xfs_iext_irec_remove.
4562 */
4569 /*
4570 * If the next irec is not empty move up the content
4571 * that has not been copied to the previous page to
4572 * the beggining of this one.
4573 */
4583 }
4584 }
4587 erp_idx++;
4590 else
4592 }
4596 }
4597 }
4599 /*
4600 * This is called to update the er_extoff field in the indirection
4601 * array when extents have been added or removed from one of the
4602 * extent lists. erp_idx contains the irec index to begin updating
4603 * at and ext_diff contains the number of extents that were added
4604 * or removed.
4605 */
4606 void
4611 {
4619 }
4620 }