| blob | 344948082819d94b82c72c5967d14e83e140cc36 |
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 */
58 /*
59 * Used in xfs_itruncate(). This is the maximum number of extents
60 * freed from a file in a single transaction.
61 */
62 #define XFS_ITRUNC_MAX_EXTENTS 2
69 #ifdef DEBUG
70 /*
71 * Make sure that the extents in the given memory buffer
72 * are valid.
73 */
74 STATIC void
78 xfs_exntfmt_t fmt)
79 {
80 xfs_bmbt_irec_t irec;
81 xfs_bmbt_rec_host_t rec;
91 }
92 }
94 #define xfs_validate_extents(ifp, nrecs, fmt)
97 /*
98 * Check that none of the inode's in the buffer have a next
99 * unlinked field of 0.
100 */
101 #if defined(DEBUG)
102 void
106 {
118 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
119 bp);
121 }
122 }
123 }
124 #endif
126 /*
127 * This routine is called to map an inode number within a file
128 * system to the buffer containing the on-disk version of the
129 * inode. It returns a pointer to the buffer containing the
130 * on-disk inode in the bpp parameter, and in the dip parameter
131 * it returns a pointer to the on-disk inode within that buffer.
132 *
133 * If a non-zero error is returned, then the contents of bpp and
134 * dipp are undefined.
135 *
136 * Use xfs_imap() to determine the size and location of the
137 * buffer to read from disk.
138 */
139 STATIC int
143 xfs_ino_t ino,
147 {
149 xfs_imap_t imap;
154 /*
155 * Call the space management code to find the location of the
156 * inode on disk.
157 */
162 "xfs_inotobp: xfs_imap() returned an "
165 }
167 /*
168 * If the inode number maps to a block outside the bounds of the
169 * file system then return NULL rather than calling read_buf
170 * and panicing when we get an error from the driver.
171 */
175 "xfs_inotobp: inode number (%llu + %d) maps to a block outside the bounds "
180 }
182 /*
183 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
184 * default to just a read_buf() call.
185 */
191 "xfs_inotobp: xfs_trans_read_buf() returned an "
194 }
196 di_ok =
200 XFS_RANDOM_ITOBP_INOTOBP))) {
204 "xfs_inotobp: XFS_TEST_ERROR() returned an "
207 }
211 /*
212 * Set *dipp to point to the on-disk inode in the buffer.
213 */
218 }
221 /*
222 * This routine is called to map an inode to the buffer containing
223 * the on-disk version of the inode. It returns a pointer to the
224 * buffer containing the on-disk inode in the bpp parameter, and in
225 * the dip parameter it returns a pointer to the on-disk inode within
226 * that buffer.
227 *
228 * If a non-zero error is returned, then the contents of bpp and
229 * dipp are undefined.
230 *
231 * If the inode is new and has not yet been initialized, use xfs_imap()
232 * to determine the size and location of the buffer to read from disk.
233 * If the inode has already been mapped to its buffer and read in once,
234 * then use the mapping information stored in the inode rather than
235 * calling xfs_imap(). This allows us to avoid the overhead of looking
236 * at the inode btree for small block file systems (see xfs_dilocate()).
237 * We can tell whether the inode has been mapped in before by comparing
238 * its disk block address to 0. Only uninitialized inodes will have
239 * 0 for the disk block address.
240 */
241 int
248 xfs_daddr_t bno,
249 uint imap_flags)
250 {
251 xfs_imap_t imap;
258 /*
259 * Call the space management code to find the location of the
260 * inode on disk.
261 */
267 /*
268 * If the inode number maps to a block outside the bounds
269 * of the file system then return NULL rather than calling
270 * read_buf and panicing when we get an error from the
271 * driver.
272 */
275 #ifdef DEBUG
277 "(imap.im_blkno (0x%llx) "
278 "+ imap.im_len (0x%llx)) > "
279 " XFS_FSB_TO_BB(mp, "
286 }
288 /*
289 * Fill in the fields in the inode that will be used to
290 * map the inode to its buffer from now on.
291 */
296 /*
297 * We've already mapped the inode once, so just use the
298 * mapping that we saved the first time.
299 */
303 }
306 /*
307 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
308 * default to just a read_buf() call.
309 */
313 #ifdef DEBUG
315 "xfs_trans_read_buf() returned error %d, "
321 }
323 /*
324 * Validate the magic number and version of every inode in the buffer
325 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
326 * No validation is done here in userspace (xfs_repair).
327 */
328 #if !defined(__KERNEL__)
330 #elif defined(DEBUG)
334 #endif
345 XFS_ERRTAG_ITOBP_INOTOBP,
346 XFS_RANDOM_ITOBP_INOTOBP))) {
350 }
351 #ifdef DEBUG
353 "Device %s - bad inode magic/vsn "
358 #endif
363 }
364 }
368 /*
369 * Mark the buffer as an inode buffer now that it looks good
370 */
373 /*
374 * Set *dipp to point to the on-disk inode in the buffer.
375 */
379 }
381 /*
382 * Move inode type and inode format specific information from the
383 * on-disk inode to the in-core inode. For fifos, devs, and sockets
384 * this means set if_rdev to the proper value. For files, directories,
385 * and symlinks this means to bring in the in-line data or extent
386 * pointers. For a file in B-tree format, only the root is immediately
387 * brought in-core. The rest will be in-lined in if_extents when it
388 * is first referenced (see xfs_iread_extents()).
389 */
390 STATIC int
394 {
398 xfs_fsize_t di_size;
416 }
426 }
437 }
448 /*
449 * no local regular files yet
450 */
453 "corrupt inode %Lu "
457 XFS_ERRLEVEL_LOW,
460 }
465 "corrupt inode %Lu "
470 XFS_ERRLEVEL_LOW,
473 }
488 }
494 }
497 }
519 }
524 }
526 }
528 /*
529 * The file is in-lined in the on-disk inode.
530 * If it fits into if_inline_data, then copy
531 * it there, otherwise allocate a buffer for it
532 * and copy the data there. Either way, set
533 * if_data to point at the data.
534 * If we allocate a buffer for the data, make
535 * sure that its size is a multiple of 4 and
536 * record the real size in i_real_bytes.
537 */
538 STATIC int
544 {
548 /*
549 * If the size is unreasonable, then something
550 * is wrong and we just bail out rather than crash in
551 * kmem_alloc() or memcpy() below.
552 */
555 "corrupt inode %Lu "
562 }
572 }
580 }
582 /*
583 * The file consists of a set of extents all
584 * of which fit into the on-disk inode.
585 * If there are few enough extents to fit into
586 * the if_inline_ext, then copy them there.
587 * Otherwise allocate a buffer for them and copy
588 * them into it. Either way, set if_extents
589 * to point at the extents.
590 */
591 STATIC int
596 {
607 /*
608 * If the number of extents is unreasonable, then something
609 * is wrong and we just bail out rather than crash in
610 * kmem_alloc() or memcpy() below.
611 */
619 }
626 else
637 }
644 XFS_ERRLEVEL_LOW,
647 }
648 }
651 }
653 /*
654 * The file has too many extents to fit into
655 * the inode, so they are in B-tree format.
656 * Allocate a buffer for the root of the B-tree
657 * and copy the root into it. The i_extents
658 * field will remain NULL until all of the
659 * extents are read in (when they are needed).
660 */
661 STATIC int
666 {
669 /* REFERENCED */
678 /*
679 * blow out if -- fork has less extents than can fit in
680 * fork (fork shouldn't be a btree format), root btree
681 * block has more records than can fit into the fork,
682 * or the number of extents is greater than the number of
683 * blocks.
684 */
695 }
700 /*
701 * Copy and convert from the on-disk structure
702 * to the in-memory structure.
703 */
710 }
712 void
716 {
745 }
747 void
751 {
780 }
782 STATIC uint
784 __uint16_t di_flags)
785 {
817 }
820 }
822 uint
825 {
830 }
832 uint
835 {
838 }
840 /*
841 * Given a mount structure and an inode number, return a pointer
842 * to a newly allocated in-core inode corresponding to the given
843 * inode number.
844 *
845 * Initialize the inode's attributes and extent pointers if it
846 * already has them (it will not if the inode has no links).
847 */
848 int
852 xfs_ino_t ino,
854 xfs_daddr_t bno,
855 uint imap_flags)
856 {
870 /*
871 * Get pointer's to the on-disk inode and the buffer containing it.
872 * If the inode number refers to a block outside the file system
873 * then xfs_itobp() will return NULL. In this case we should
874 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
875 * know that this is a new incore inode.
876 */
881 }
883 /*
884 * Initialize inode's trace buffers.
885 * Do this before xfs_iformat in case it adds entries.
886 */
887 #ifdef XFS_VNODE_TRACE
889 #endif
890 #ifdef XFS_BMAP_TRACE
892 #endif
893 #ifdef XFS_BMBT_TRACE
895 #endif
896 #ifdef XFS_RW_TRACE
898 #endif
899 #ifdef XFS_ILOCK_TRACE
901 #endif
902 #ifdef XFS_DIR2_TRACE
904 #endif
906 /*
907 * If we got something that isn't an inode it means someone
908 * (nfs or dmi) has a stale handle.
909 */
913 #ifdef DEBUG
915 "dip->di_core.di_magic (0x%x) != "
918 XFS_DINODE_MAGIC);
921 }
923 /*
924 * If the on-disk inode is already linked to a directory
925 * entry, copy all of the inode into the in-core inode.
926 * xfs_iformat() handles copying in the inode format
927 * specific information.
928 * Otherwise, just get the truly permanent information.
929 */
936 #ifdef DEBUG
939 error);
942 }
948 /*
949 * Make sure to pull in the mode here as well in
950 * case the inode is released without being used.
951 * This ensures that xfs_inactive() will see that
952 * the inode is already free and not try to mess
953 * with the uninitialized part of it.
954 */
956 /*
957 * Initialize the per-fork minima and maxima for a new
958 * inode here. xfs_iformat will do it for old inodes.
959 */
962 }
966 /*
967 * The inode format changed when we moved the link count and
968 * made it 32 bits long. If this is an old format inode,
969 * convert it in memory to look like a new one. If it gets
970 * flushed to disk we will convert back before flushing or
971 * logging it. We zero out the new projid field and the old link
972 * count field. We'll handle clearing the pad field (the remains
973 * of the old uuid field) when we actually convert the inode to
974 * the new format. We don't change the version number so that we
975 * can distinguish this from a real new format inode.
976 */
981 }
986 /*
987 * Mark the buffer containing the inode as something to keep
988 * around for a while. This helps to keep recently accessed
989 * meta-data in-core longer.
990 */
993 /*
994 * Use xfs_trans_brelse() to release the buffer containing the
995 * on-disk inode, because it was acquired with xfs_trans_read_buf()
996 * in xfs_itobp() above. If tp is NULL, this is just a normal
997 * brelse(). If we're within a transaction, then xfs_trans_brelse()
998 * will only release the buffer if it is not dirty within the
999 * transaction. It will be OK to release the buffer in this case,
1000 * because inodes on disk are never destroyed and we will be
1001 * locking the new in-core inode before putting it in the hash
1002 * table where other processes can find it. Thus we don't have
1003 * to worry about the inode being changed just because we released
1004 * the buffer.
1005 */
1009 }
1011 /*
1012 * Read in extents from a btree-format inode.
1013 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
1014 */
1015 int
1020 {
1023 xfs_extnum_t nextents;
1030 }
1035 /*
1036 * We know that the size is valid (it's checked in iformat_btree)
1037 */
1047 }
1050 }
1052 /*
1053 * Allocate an inode on disk and return a copy of its in-core version.
1054 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1055 * appropriately within the inode. The uid and gid for the inode are
1056 * set according to the contents of the given cred structure.
1057 *
1058 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1059 * has a free inode available, call xfs_iget()
1060 * to obtain the in-core version of the allocated inode. Finally,
1061 * fill in the inode and log its initial contents. In this case,
1062 * ialloc_context would be set to NULL and call_again set to false.
1063 *
1064 * If xfs_dialloc() does not have an available inode,
1065 * it will replenish its supply by doing an allocation. Since we can
1066 * only do one allocation within a transaction without deadlocks, we
1067 * must commit the current transaction before returning the inode itself.
1068 * In this case, therefore, we will set call_again to true and return.
1069 * The caller should then commit the current transaction, start a new
1070 * transaction, and call xfs_ialloc() again to actually get the inode.
1071 *
1072 * To ensure that some other process does not grab the inode that
1073 * was allocated during the first call to xfs_ialloc(), this routine
1074 * also returns the [locked] bp pointing to the head of the freelist
1075 * as ialloc_context. The caller should hold this buffer across
1076 * the commit and pass it back into this routine on the second call.
1077 *
1078 * If we are allocating quota inodes, we do not have a parent inode
1079 * to attach to or associate with (i.e. pip == NULL) because they
1080 * are not linked into the directory structure - they are attached
1081 * directly to the superblock - and so have no parent.
1082 */
1083 int
1087 mode_t mode,
1088 xfs_nlink_t nlink,
1089 xfs_dev_t rdev,
1091 xfs_prid_t prid,
1096 {
1097 xfs_ino_t ino;
1100 uint flags;
1103 /*
1104 * Call the space management code to pick
1105 * the on-disk inode to be allocated.
1106 */
1111 }
1115 }
1118 /*
1119 * Get the in-core inode with the lock held exclusively.
1120 * This is because we're setting fields here we need
1121 * to prevent others from looking at until we're done.
1122 */
1127 }
1140 /*
1141 * If the superblock version is up to where we support new format
1142 * inodes and this is currently an old format inode, then change
1143 * the inode version number now. This way we only do the conversion
1144 * here rather than here and in the flush/logging code.
1145 */
1149 /*
1150 * We've already zeroed the old link count, the projid field,
1151 * and the pad field.
1152 */
1153 }
1155 /*
1156 * Project ids won't be stored on disk if we are using a version 1 inode.
1157 */
1165 }
1166 }
1168 /*
1169 * If the group ID of the new file does not match the effective group
1170 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1171 * (and only if the irix_sgid_inherit compatibility variable is set).
1172 */
1177 }
1184 /*
1185 * di_gen will have been taken care of in xfs_iread.
1186 */
1209 }
1210 /* fall through */
1221 }
1226 }
1230 }
1231 }
1233 xfs_inherit_noatime)
1236 xfs_inherit_nodump)
1239 xfs_inherit_sync)
1242 xfs_inherit_nosymlinks)
1247 xfs_inherit_nodefrag)
1252 }
1253 /* FALLTHROUGH */
1262 }
1263 /*
1264 * Attribute fork settings for new inode.
1265 */
1269 /*
1270 * Log the new values stuffed into the inode.
1271 */
1274 /* now that we have an i_mode we can setup inode ops and unlock */
1279 }
1281 /*
1282 * Check to make sure that there are no blocks allocated to the
1283 * file beyond the size of the file. We don't check this for
1284 * files with fixed size extents or real time extents, but we
1285 * at least do it for regular files.
1286 */
1287 #ifdef DEBUG
1288 void
1292 xfs_fsize_t isize)
1293 {
1294 xfs_fileoff_t map_first;
1306 /*
1307 * The filesystem could be shutting down, so bmapi may return
1308 * an error.
1309 */
1313 map_first),
1319 }
1322 /*
1323 * Calculate the last possible buffered byte in a file. This must
1324 * include data that was buffered beyond the EOF by the write code.
1325 * This also needs to deal with overflowing the xfs_fsize_t type
1326 * which can happen for sizes near the limit.
1327 *
1328 * We also need to take into account any blocks beyond the EOF. It
1329 * may be the case that they were buffered by a write which failed.
1330 * In that case the pages will still be in memory, but the inode size
1331 * will never have been updated.
1332 */
1333 xfs_fsize_t
1336 {
1338 xfs_fsize_t last_byte;
1339 xfs_fileoff_t last_block;
1340 xfs_fileoff_t size_last_block;
1346 /*
1347 * Only check for blocks beyond the EOF if the extents have
1348 * been read in. This eliminates the need for the inode lock,
1349 * and it also saves us from looking when it really isn't
1350 * necessary.
1351 */
1354 XFS_DATA_FORK);
1357 }
1360 }
1367 }
1371 }
1373 }
1375 #if defined(XFS_RW_TRACE)
1376 STATIC void
1381 xfs_fsize_t new_size,
1382 xfs_off_t toss_start,
1383 xfs_off_t toss_finish)
1384 {
1387 }
1406 }
1407 #else
1408 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1409 #endif
1411 /*
1412 * Start the truncation of the file to new_size. The new size
1413 * must be smaller than the current size. This routine will
1414 * clear the buffer and page caches of file data in the removed
1415 * range, and xfs_itruncate_finish() will remove the underlying
1416 * disk blocks.
1417 *
1418 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1419 * must NOT have the inode lock held at all. This is because we're
1420 * calling into the buffer/page cache code and we can't hold the
1421 * inode lock when we do so.
1422 *
1423 * We need to wait for any direct I/Os in flight to complete before we
1424 * proceed with the truncate. This is needed to prevent the extents
1425 * being read or written by the direct I/Os from being removed while the
1426 * I/O is in flight as there is no other method of synchronising
1427 * direct I/O with the truncate operation. Also, because we hold
1428 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1429 * started until the truncate completes and drops the lock. Essentially,
1430 * the vn_iowait() call forms an I/O barrier that provides strict ordering
1431 * between direct I/Os and the truncate operation.
1432 *
1433 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1434 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1435 * in the case that the caller is locking things out of order and
1436 * may not be able to call xfs_itruncate_finish() with the inode lock
1437 * held without dropping the I/O lock. If the caller must drop the
1438 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1439 * must be called again with all the same restrictions as the initial
1440 * call.
1441 */
1442 int
1445 uint flags,
1446 xfs_fsize_t new_size)
1447 {
1448 xfs_fsize_t last_byte;
1449 xfs_off_t toss_start;
1462 /* wait for the completion of any pending DIOs */
1466 /*
1467 * Call toss_pages or flushinval_pages to get rid of pages
1468 * overlapping the region being removed. We have to use
1469 * the less efficient flushinval_pages in the case that the
1470 * caller may not be able to finish the truncate without
1471 * dropping the inode's I/O lock. Make sure
1472 * to catch any pages brought in by buffers overlapping
1473 * the EOF by searching out beyond the isize by our
1474 * block size. We round new_size up to a block boundary
1475 * so that we don't toss things on the same block as
1476 * new_size but before it.
1477 *
1478 * Before calling toss_page or flushinval_pages, make sure to
1479 * call remapf() over the same region if the file is mapped.
1480 * This frees up mapped file references to the pages in the
1481 * given range and for the flushinval_pages case it ensures
1482 * that we get the latest mapped changes flushed out.
1483 */
1487 /*
1488 * The place to start tossing is beyond our maximum
1489 * file size, so there is no way that the data extended
1490 * out there.
1491 */
1493 }
1496 last_byte);
1504 }
1505 }
1507 #ifdef DEBUG
1510 }
1511 #endif
1513 }
1515 /*
1516 * Shrink the file to the given new_size. The new
1517 * size must be smaller than the current size.
1518 * This will free up the underlying blocks
1519 * in the removed range after a call to xfs_itruncate_start()
1520 * or xfs_atruncate_start().
1521 *
1522 * The transaction passed to this routine must have made
1523 * a permanent log reservation of at least XFS_ITRUNCATE_LOG_RES.
1524 * This routine may commit the given transaction and
1525 * start new ones, so make sure everything involved in
1526 * the transaction is tidy before calling here.
1527 * Some transaction will be returned to the caller to be
1528 * committed. The incoming transaction must already include
1529 * the inode, and both inode locks must be held exclusively.
1530 * The inode must also be "held" within the transaction. On
1531 * return the inode will be "held" within the returned transaction.
1532 * This routine does NOT require any disk space to be reserved
1533 * for it within the transaction.
1534 *
1535 * The fork parameter must be either xfs_attr_fork or xfs_data_fork,
1536 * and it indicates the fork which is to be truncated. For the
1537 * attribute fork we only support truncation to size 0.
1538 *
1539 * We use the sync parameter to indicate whether or not the first
1540 * transaction we perform might have to be synchronous. For the attr fork,
1541 * it needs to be so if the unlink of the inode is not yet known to be
1542 * permanent in the log. This keeps us from freeing and reusing the
1543 * blocks of the attribute fork before the unlink of the inode becomes
1544 * permanent.
1545 *
1546 * For the data fork, we normally have to run synchronously if we're
1547 * being called out of the inactive path or we're being called
1548 * out of the create path where we're truncating an existing file.
1549 * Either way, the truncate needs to be sync so blocks don't reappear
1550 * in the file with altered data in case of a crash. wsync filesystems
1551 * can run the first case async because anything that shrinks the inode
1552 * has to run sync so by the time we're called here from inactive, the
1553 * inode size is permanently set to 0.
1554 *
1555 * Calls from the truncate path always need to be sync unless we're
1556 * in a wsync filesystem and the file has already been unlinked.
1557 *
1558 * The caller is responsible for correctly setting the sync parameter.
1559 * It gets too hard for us to guess here which path we're being called
1560 * out of just based on inode state.
1561 */
1562 int
1566 xfs_fsize_t new_size,
1569 {
1570 xfs_fsblock_t first_block;
1571 xfs_fileoff_t first_unmap_block;
1572 xfs_fileoff_t last_block;
1578 xfs_bmap_free_t free_list;
1595 /*
1596 * We only support truncating the entire attribute fork.
1597 */
1600 }
1603 /*
1604 * The first thing we do is set the size to new_size permanently
1605 * on disk. This way we don't have to worry about anyone ever
1606 * being able to look at the data being freed even in the face
1607 * of a crash. What we're getting around here is the case where
1608 * we free a block, it is allocated to another file, it is written
1609 * to, and then we crash. If the new data gets written to the
1610 * file but the log buffers containing the free and reallocation
1611 * don't, then we'd end up with garbage in the blocks being freed.
1612 * As long as we make the new_size permanent before actually
1613 * freeing any blocks it doesn't matter if they get writtten to.
1614 *
1615 * The callers must signal into us whether or not the size
1616 * setting here must be synchronous. There are a few cases
1617 * where it doesn't have to be synchronous. Those cases
1618 * occur if the file is unlinked and we know the unlink is
1619 * permanent or if the blocks being truncated are guaranteed
1620 * to be beyond the inode eof (regardless of the link count)
1621 * and the eof value is permanent. Both of these cases occur
1622 * only on wsync-mounted filesystems. In those cases, we're
1623 * guaranteed that no user will ever see the data in the blocks
1624 * that are being truncated so the truncate can run async.
1625 * In the free beyond eof case, the file may wind up with
1626 * more blocks allocated to it than it needs if we crash
1627 * and that won't get fixed until the next time the file
1628 * is re-opened and closed but that's ok as that shouldn't
1629 * be too many blocks.
1630 *
1631 * However, we can't just make all wsync xactions run async
1632 * because there's one call out of the create path that needs
1633 * to run sync where it's truncating an existing file to size
1634 * 0 whose size is > 0.
1635 *
1636 * It's probably possible to come up with a test in this
1637 * routine that would correctly distinguish all the above
1638 * cases from the values of the function parameters and the
1639 * inode state but for sanity's sake, I've decided to let the
1640 * layers above just tell us. It's simpler to correctly figure
1641 * out in the layer above exactly under what conditions we
1642 * can run async and I think it's easier for others read and
1643 * follow the logic in case something has to be changed.
1644 * cscope is your friend -- rcc.
1645 *
1646 * The attribute fork is much simpler.
1647 *
1648 * For the attribute fork we allow the caller to tell us whether
1649 * the unlink of the inode that led to this call is yet permanent
1650 * in the on disk log. If it is not and we will be freeing extents
1651 * in this inode then we make the first transaction synchronous
1652 * to make sure that the unlink is permanent by the time we free
1653 * the blocks.
1654 */
1657 /*
1658 * If we are not changing the file size then do
1659 * not update the on-disk file size - we may be
1660 * called from xfs_inactive_free_eofblocks(). If we
1661 * update the on-disk file size and then the system
1662 * crashes before the contents of the file are
1663 * flushed to disk then the files may be full of
1664 * holes (ie NULL files bug).
1665 */
1670 }
1671 }
1676 }
1682 /*
1683 * Since it is possible for space to become allocated beyond
1684 * the end of the file (in a crash where the space is allocated
1685 * but the inode size is not yet updated), simply remove any
1686 * blocks which show up between the new EOF and the maximum
1687 * possible file size. If the first block to be removed is
1688 * beyond the maximum file size (ie it is the same as last_block),
1689 * then there is nothing to do.
1690 */
1698 }
1700 /*
1701 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1702 * will tell us whether it freed the entire range or
1703 * not. If this is a synchronous mount (wsync),
1704 * then we can tell bunmapi to keep all the
1705 * transactions asynchronous since the unlink
1706 * transaction that made this inode inactive has
1707 * already hit the disk. There's no danger of
1708 * the freed blocks being reused, there being a
1709 * crash, and the reused blocks suddenly reappearing
1710 * in this file with garbage in them once recovery
1711 * runs.
1712 */
1718 XFS_ITRUNC_MAX_EXTENTS,
1722 /*
1723 * If the bunmapi call encounters an error,
1724 * return to the caller where the transaction
1725 * can be properly aborted. We just need to
1726 * make sure we're not holding any resources
1727 * that we were not when we came in.
1728 */
1731 }
1733 /*
1734 * Duplicate the transaction that has the permanent
1735 * reservation and commit the old transaction.
1736 */
1740 /*
1741 * If the bmap finish call encounters an error,
1742 * return to the caller where the transaction
1743 * can be properly aborted. We just need to
1744 * make sure we're not holding any resources
1745 * that we were not when we came in.
1746 *
1747 * Aborting from this point might lose some
1748 * blocks in the file system, but oh well.
1749 */
1752 /*
1753 * If the passed in transaction committed
1754 * in xfs_bmap_finish(), then we want to
1755 * add the inode to this one before returning.
1756 * This keeps things simple for the higher
1757 * level code, because it always knows that
1758 * the inode is locked and held in the
1759 * transaction that returns to it whether
1760 * errors occur or not. We don't mark the
1761 * inode dirty so that this transaction can
1762 * be easily aborted if possible.
1763 */
1767 }
1769 }
1772 /*
1773 * The first xact was committed,
1774 * so add the inode to the new one.
1775 * Mark it dirty so it will be logged
1776 * and moved forward in the log as
1777 * part of every commit.
1778 */
1783 }
1788 XFS_TRANS_PERM_LOG_RES,
1789 XFS_ITRUNCATE_LOG_COUNT);
1790 /*
1791 * Add the inode being truncated to the next chained
1792 * transaction.
1793 */
1798 }
1799 /*
1800 * Only update the size in the case of the data fork, but
1801 * always re-log the inode so that our permanent transaction
1802 * can keep on rolling it forward in the log.
1803 */
1806 /*
1807 * If we are not changing the file size then do
1808 * not update the on-disk file size - we may be
1809 * called from xfs_inactive_free_eofblocks(). If we
1810 * update the on-disk file size and then the system
1811 * crashes before the contents of the file are
1812 * flushed to disk then the files may be full of
1813 * holes (ie NULL files bug).
1814 */
1818 }
1819 }
1829 }
1832 /*
1833 * xfs_igrow_start
1834 *
1835 * Do the first part of growing a file: zero any data in the last
1836 * block that is beyond the old EOF. We need to do this before
1837 * the inode is joined to the transaction to modify the i_size.
1838 * That way we can drop the inode lock and call into the buffer
1839 * cache to get the buffer mapping the EOF.
1840 */
1841 int
1844 xfs_fsize_t new_size,
1846 {
1853 /*
1854 * Zero any pages that may have been created by
1855 * xfs_write_file() beyond the end of the file
1856 * and any blocks between the old and new file sizes.
1857 */
1861 }
1863 /*
1864 * xfs_igrow_finish
1865 *
1866 * This routine is called to extend the size of a file.
1867 * The inode must have both the iolock and the ilock locked
1868 * for update and it must be a part of the current transaction.
1869 * The xfs_igrow_start() function must have been called previously.
1870 * If the change_flag is not zero, the inode change timestamp will
1871 * be updated.
1872 */
1873 void
1877 xfs_fsize_t new_size,
1879 {
1885 /*
1886 * Update the file size. Update the inode change timestamp
1887 * if change_flag set.
1888 */
1895 }
1898 /*
1899 * This is called when the inode's link count goes to 0.
1900 * We place the on-disk inode on a list in the AGI. It
1901 * will be pulled from this list when the inode is freed.
1902 */
1903 int
1907 {
1913 xfs_agnumber_t agno;
1914 xfs_daddr_t agdaddr;
1915 xfs_agino_t agino;
1930 /*
1931 * Get the agi buffer first. It ensures lock ordering
1932 * on the list.
1933 */
1939 /*
1940 * Validate the magic number of the agi block.
1941 */
1943 agi_ok =
1947 XFS_RANDOM_IUNLINK))) {
1951 }
1952 /*
1953 * Get the index into the agi hash table for the
1954 * list this inode will go on.
1955 */
1966 /*
1967 * Clear the on-disk di_nlink. This is to prevent xfs_bulkstat
1968 * from picking up this inode when it is reclaimed (its incore state
1969 * initialzed but not flushed to disk yet). The in-core di_nlink is
1970 * already cleared in xfs_droplink() and a corresponding transaction
1971 * logged. The hack here just synchronizes the in-core to on-disk
1972 * di_nlink value in advance before the actual inode sync to disk.
1973 * This is OK because the inode is already unlinked and would never
1974 * change its di_nlink again for this inode generation.
1975 * This is a temporary hack that would require a proper fix
1976 * in the future.
1977 */
1981 /*
1982 * There is already another inode in the bucket we need
1983 * to add ourselves to. Add us at the front of the list.
1984 * Here we put the head pointer into our next pointer,
1985 * and then we fall through to point the head at us.
1986 */
1988 /* both on-disk, don't endian flip twice */
1996 }
1998 /*
1999 * Point the bucket head pointer at the inode being inserted.
2000 */
2008 }
2010 /*
2011 * Pull the on-disk inode from the AGI unlinked list.
2012 */
2013 STATIC int
2017 {
2018 xfs_ino_t next_ino;
2024 xfs_agnumber_t agno;
2025 xfs_daddr_t agdaddr;
2026 xfs_agino_t agino;
2027 xfs_agino_t next_agino;
2035 /*
2036 * First pull the on-disk inode from the AGI unlinked list.
2037 */
2043 /*
2044 * Get the agi buffer first. It ensures lock ordering
2045 * on the list.
2046 */
2054 }
2055 /*
2056 * Validate the magic number of the agi block.
2057 */
2059 agi_ok =
2063 XFS_RANDOM_IUNLINK_REMOVE))) {
2071 }
2072 /*
2073 * Get the index into the agi hash table for the
2074 * list this inode will go on.
2075 */
2083 /*
2084 * We're at the head of the list. Get the inode's
2085 * on-disk buffer to see if there is anyone after us
2086 * on the list. Only modify our next pointer if it
2087 * is not already NULLAGINO. This saves us the overhead
2088 * of dealing with the buffer when there is no need to
2089 * change it.
2090 */
2097 }
2110 }
2111 /*
2112 * Point the bucket head pointer at the next inode.
2113 */
2122 /*
2123 * We need to search the list for the inode being freed.
2124 */
2128 /*
2129 * If the last inode wasn't the one pointing to
2130 * us, then release its buffer since we're not
2131 * going to do anything with it.
2132 */
2135 }
2144 }
2148 }
2149 /*
2150 * Now last_ibp points to the buffer previous to us on
2151 * the unlinked list. Pull us from the list.
2152 */
2159 }
2173 }
2174 /*
2175 * Point the previous inode on the list to the next inode.
2176 */
2184 }
2186 }
2189 {
2193 }
2195 STATIC void
2199 xfs_ino_t inum)
2200 {
2206 xfs_daddr_t blkno;
2223 }
2232 /*
2233 * Look for each inode in memory and attempt to lock it,
2234 * we can be racing with flush and tail pushing here.
2235 * any inode we get the locks on, add to an array of
2236 * inode items to process later.
2237 *
2238 * The get the buffer lock, we could beat a flush
2239 * or tail pushing thread to the lock here, in which
2240 * case they will go looking for the inode buffer
2241 * and fail, we need some other form of interlock
2242 * here.
2243 */
2250 /* Inode not in memory or we found it already,
2251 * nothing to do
2252 */
2256 }
2261 }
2263 /* If we can get the locks then add it to the
2264 * list, otherwise by the time we get the bp lock
2265 * below it will already be attached to the
2266 * inode buffer.
2267 */
2269 /* This inode will already be locked - by us, lets
2270 * keep it that way.
2271 */
2280 }
2281 }
2284 }
2295 }
2298 }
2299 }
2301 }
2305 XFS_BUF_LOCK);
2318 pre_flushed++;
2319 }
2321 }
2332 }
2346 }
2347 }
2352 }
2356 }
2358 /*
2359 * This is called to return an inode to the inode free list.
2360 * The inode should already be truncated to 0 length and have
2361 * no pages associated with it. This routine also assumes that
2362 * the inode is already a part of the transaction.
2363 *
2364 * The on-disk copy of the inode will have been added to the list
2365 * of unlinked inodes in the AGI. We need to remove the inode from
2366 * that list atomically with respect to freeing it here.
2367 */
2368 int
2373 {
2376 xfs_ino_t first_ino;
2387 /*
2388 * Pull the on-disk inode from the AGI unlinked list.
2389 */
2393 }
2398 }
2407 /*
2408 * Bump the generation count so no one will be confused
2409 * by reincarnations of this inode.
2410 */
2416 }
2419 }
2421 /*
2422 * Reallocate the space for if_broot based on the number of records
2423 * being added or deleted as indicated in rec_diff. Move the records
2424 * and pointers in if_broot to fit the new size. When shrinking this
2425 * will eliminate holes between the records and pointers created by
2426 * the caller. When growing this will create holes to be filled in
2427 * by the caller.
2428 *
2429 * The caller must not request to add more records than would fit in
2430 * the on-disk inode root. If the if_broot is currently NULL, then
2431 * if we adding records one will be allocated. The caller must also
2432 * not request that the number of records go below zero, although
2433 * it can go to zero.
2434 *
2435 * ip -- the inode whose if_broot area is changing
2436 * ext_diff -- the change in the number of records, positive or negative,
2437 * requested for the if_broot array.
2438 */
2439 void
2444 {
2453 /*
2454 * Handle the degenerate case quietly.
2455 */
2458 }
2462 /*
2463 * If there wasn't any memory allocated before, just
2464 * allocate it now and get out.
2465 */
2469 KM_SLEEP);
2472 }
2474 /*
2475 * If there is already an existing if_broot, then we need
2476 * to realloc() it and shift the pointers to their new
2477 * location. The records don't change location because
2478 * they are kept butted up against the btree block header.
2479 */
2485 new_size,
2487 KM_SLEEP);
2497 }
2499 /*
2500 * rec_diff is less than 0. In this case, we are shrinking the
2501 * if_broot buffer. It must already exist. If we go to zero
2502 * records, just get rid of the root and clear the status bit.
2503 */
2510 else
2514 /*
2515 * First copy over the btree block header.
2516 */
2521 }
2523 /*
2524 * Only copy the records and pointers if there are any.
2525 */
2527 /*
2528 * First copy the records.
2529 */
2536 /*
2537 * Then copy the pointers.
2538 */
2544 }
2551 }
2554 /*
2555 * This is called when the amount of space needed for if_data
2556 * is increased or decreased. The change in size is indicated by
2557 * the number of bytes that need to be added or deleted in the
2558 * byte_diff parameter.
2559 *
2560 * If the amount of space needed has decreased below the size of the
2561 * inline buffer, then switch to using the inline buffer. Otherwise,
2562 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2563 * to what is needed.
2564 *
2565 * ip -- the inode whose if_data area is changing
2566 * byte_diff -- the change in the number of bytes, positive or negative,
2567 * requested for the if_data array.
2568 */
2569 void
2574 {
2581 }
2590 }
2594 /*
2595 * If the valid extents/data can fit in if_inline_ext/data,
2596 * copy them from the malloc'd vector and free it.
2597 */
2603 new_size);
2606 }
2609 /*
2610 * Stuck with malloc/realloc.
2611 * For inline data, the underlying buffer must be
2612 * a multiple of 4 bytes in size so that it can be
2613 * logged and stay on word boundaries. We enforce
2614 * that here.
2615 */
2621 /*
2622 * Only do the realloc if the underlying size
2623 * is really changing.
2624 */
2628 real_size,
2630 KM_SLEEP);
2631 }
2637 }
2638 }
2642 }
2647 /*
2648 * Map inode to disk block and offset.
2649 *
2650 * mp -- the mount point structure for the current file system
2651 * tp -- the current transaction
2652 * ino -- the inode number of the inode to be located
2653 * imap -- this structure is filled in with the information necessary
2654 * to retrieve the given inode from disk
2655 * flags -- flags to pass to xfs_dilocate indicating whether or not
2656 * lookups in the inode btree were OK or not
2657 */
2658 int
2662 xfs_ino_t ino,
2664 uint flags)
2665 {
2666 xfs_fsblock_t fsbno;
2676 }
2683 }
2685 void
2689 {
2696 }
2698 /*
2699 * If the format is local, then we can't have an extents
2700 * array so just look for an inline data array. If we're
2701 * not local then we may or may not have an extents list,
2702 * so check and free it up if we do.
2703 */
2711 }
2718 }
2725 }
2726 }
2728 /*
2729 * This is called free all the memory associated with an inode.
2730 * It must free the inode itself and any buffers allocated for
2731 * if_extents/if_data and if_broot. It must also free the lock
2732 * associated with the inode.
2733 */
2734 void
2737 {
2745 }
2752 #ifdef XFS_VNODE_TRACE
2754 #endif
2755 #ifdef XFS_BMAP_TRACE
2757 #endif
2758 #ifdef XFS_BMBT_TRACE
2760 #endif
2761 #ifdef XFS_RW_TRACE
2763 #endif
2764 #ifdef XFS_ILOCK_TRACE
2766 #endif
2767 #ifdef XFS_DIR2_TRACE
2769 #endif
2771 /*
2772 * Only if we are shutting down the fs will we see an
2773 * inode still in the AIL. If it is there, we should remove
2774 * it to prevent a use-after-free from occurring.
2775 */
2786 else
2788 }
2790 }
2792 }
2795 /*
2796 * Increment the pin count of the given buffer.
2797 * This value is protected by ipinlock spinlock in the mount structure.
2798 */
2799 void
2802 {
2806 }
2808 /*
2809 * Decrement the pin count of the given inode, and wake up
2810 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2811 * inode must have been previously pinned with a call to xfs_ipin().
2812 */
2813 void
2816 {
2821 /*
2822 * If the inode is currently being reclaimed, the link between
2823 * the bhv_vnode and the xfs_inode will be broken after the
2824 * XFS_IRECLAIM* flag is set. Hence, if these flags are not
2825 * set, then we can move forward and mark the linux inode dirty
2826 * knowing that it is still valid as it won't freed until after
2827 * the bhv_vnode<->xfs_inode link is broken in xfs_reclaim. The
2828 * i_flags_lock is used to synchronise the setting of the
2829 * XFS_IRECLAIM* flags and the breaking of the link, and so we
2830 * can execute atomically w.r.t to reclaim by holding this lock
2831 * here.
2832 *
2833 * However, we still need to issue the unpin wakeup call as the
2834 * inode reclaim may be blocked waiting for the inode to become
2835 * unpinned.
2836 */
2846 /* make sync come back and flush this inode */
2849 }
2852 }
2853 }
2855 /*
2856 * This is called to wait for the given inode to be unpinned.
2857 * It will sleep until this happens. The caller must have the
2858 * inode locked in at least shared mode so that the buffer cannot
2859 * be subsequently pinned once someone is waiting for it to be
2860 * unpinned.
2861 */
2862 STATIC void
2865 {
2867 xfs_lsn_t lsn;
2873 }
2880 }
2882 /*
2883 * Give the log a push so we don't wait here too long.
2884 */
2888 }
2891 /*
2892 * xfs_iextents_copy()
2893 *
2894 * This is called to copy the REAL extents (as opposed to the delayed
2895 * allocation extents) from the inode into the given buffer. It
2896 * returns the number of bytes copied into the buffer.
2897 *
2898 * If there are no delayed allocation extents, then we can just
2899 * memcpy() the extents into the buffer. Otherwise, we need to
2900 * examine each extent in turn and skip those which are delayed.
2901 */
2902 int
2907 {
2912 xfs_fsblock_t start_block;
2922 /*
2923 * There are some delayed allocation extents in the
2924 * inode, so copy the extents one at a time and skip
2925 * the delayed ones. There must be at least one
2926 * non-delayed extent.
2927 */
2933 /*
2934 * It's a delayed allocation extent, so skip it.
2935 */
2937 }
2939 /* Translate to on disk format */
2942 dp++;
2943 copied++;
2944 }
2949 }
2951 /*
2952 * Each of the following cases stores data into the same region
2953 * of the on-disk inode, so only one of them can be valid at
2954 * any given time. While it is possible to have conflicting formats
2955 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2956 * in EXTENTS format, this can only happen when the fork has
2957 * changed formats after being modified but before being flushed.
2958 * In these cases, the format always takes precedence, because the
2959 * format indicates the current state of the fork.
2960 */
2961 /*ARGSUSED*/
2962 STATIC int
2969 {
2973 #ifdef XFS_TRANS_DEBUG
2975 #endif
2986 /*
2987 * This can happen if we gave up in iformat in an error path,
2988 * for the attribute fork.
2989 */
2993 }
3003 }
3017 whichfork);
3018 }
3027 XFS_BROOT_SIZE_ADJ));
3031 }
3038 }
3046 }
3052 }
3055 }
3057 /*
3058 * xfs_iflush() will write a modified inode's changes out to the
3059 * inode's on disk home. The caller must have the inode lock held
3060 * in at least shared mode and the inode flush semaphore must be
3061 * held as well. The inode lock will still be held upon return from
3062 * the call and the caller is free to unlock it.
3063 * The inode flush lock will be unlocked when the inode reaches the disk.
3064 * The flags indicate how the inode's buffer should be written out.
3065 */
3066 int
3069 uint flags)
3070 {
3076 /* REFERENCED */
3093 /*
3094 * If the inode isn't dirty, then just release the inode
3095 * flush lock and do nothing.
3096 */
3103 }
3105 /*
3106 * We can't flush the inode until it is unpinned, so
3107 * wait for it. We know noone new can pin it, because
3108 * we are holding the inode lock shared and you need
3109 * to hold it exclusively to pin the inode.
3110 */
3113 /*
3114 * This may have been unpinned because the filesystem is shutting
3115 * down forcibly. If that's the case we must not write this inode
3116 * to disk, because the log record didn't make it to disk!
3117 */
3124 }
3126 /*
3127 * Get the buffer containing the on-disk inode.
3128 */
3133 }
3135 /*
3136 * Decide how buffer will be flushed out. This is done before
3137 * the call to xfs_iflush_int because this field is zeroed by it.
3138 */
3140 /*
3141 * Flush out the inode buffer according to the directions
3142 * of the caller. In the cases where the caller has given
3143 * us a choice choose the non-delwri case. This is because
3144 * the inode is in the AIL and we need to get it out soon.
3145 */
3162 }
3180 }
3181 }
3183 /*
3184 * First flush out the inode that xfs_iflush was called with.
3185 */
3189 }
3191 /*
3192 * inode clustering:
3193 * see if other inodes can be gathered into this write
3194 */
3203 /*
3204 * Do an un-protected check to see if the inode is dirty and
3205 * is a candidate for flushing. These checks will be repeated
3206 * later after the appropriate locks are acquired.
3207 */
3214 }
3216 /*
3217 * Try to get locks. If any are unavailable,
3218 * then this inode cannot be flushed and is skipped.
3219 */
3221 /* get inode locks (just i_lock) */
3223 /* get inode flush lock */
3225 /* check if pinned */
3227 /* arriving here means that
3228 * this inode can be flushed.
3229 * first re-check that it's
3230 * dirty
3231 */
3236 clcount++;
3240 XFS_ILOCK_SHARED);
3242 }
3245 }
3248 }
3249 }
3251 }
3252 }
3258 }
3260 /*
3261 * If the buffer is pinned then push on the log so we won't
3262 * get stuck waiting in the write for too long.
3263 */
3266 }
3274 }
3277 corrupt_out:
3281 /*
3282 * Unlocks the flush lock
3283 */
3286 cluster_corrupt_out:
3287 /* Corruption detected in the clustering loop. Invalidate the
3288 * inode buffer and shut down the filesystem.
3289 */
3292 /*
3293 * Clean up the buffer. If it was B_DELWRI, just release it --
3294 * brelse can handle it with no problems. If not, shut down the
3295 * filesystem before releasing the buffer.
3296 */
3299 }
3304 /*
3305 * Just like incore_relse: if we have b_iodone functions,
3306 * mark the buffer as an error and call them. Otherwise
3307 * mark it as stale and brelse.
3308 */
3319 }
3320 }
3323 /*
3324 * Unlocks the flush lock
3325 */
3327 }
3330 STATIC int
3334 {
3338 #ifdef XFS_TRANS_DEBUG
3340 #endif
3352 /*
3353 * If the inode isn't dirty, then just release the inode
3354 * flush lock and do nothing.
3355 */
3360 }
3362 /* set *dip = inode's place in the buffer */
3365 /*
3366 * Clear i_update_core before copying out the data.
3367 * This is for coordination with our timestamp updates
3368 * that don't hold the inode lock. They will always
3369 * update the timestamps BEFORE setting i_update_core,
3370 * so if we clear i_update_core after they set it we
3371 * are guaranteed to see their updates to the timestamps.
3372 * I believe that this depends on strongly ordered memory
3373 * semantics, but we have that. We use the SYNCHRONIZE
3374 * macro to make sure that the compiler does not reorder
3375 * the i_update_core access below the data copy below.
3376 */
3380 /*
3381 * Make sure to get the latest atime from the Linux inode.
3382 */
3391 }
3398 }
3408 }
3419 }
3420 }
3423 XFS_RANDOM_IFLUSH_5)) {
3429 ip);
3431 }
3438 }
3439 /*
3440 * bump the flush iteration count, used to detect flushes which
3441 * postdate a log record during recovery.
3442 */
3446 /*
3447 * Copy the dirty parts of the inode into the on-disk
3448 * inode. We always copy out the core of the inode,
3449 * because if the inode is dirty at all the core must
3450 * be.
3451 */
3454 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3458 /*
3459 * If this is really an old format inode and the superblock version
3460 * has not been updated to support only new format inodes, then
3461 * convert back to the old inode format. If the superblock version
3462 * has been updated, then make the conversion permanent.
3463 */
3468 /*
3469 * Convert it back.
3470 */
3474 /*
3475 * The superblock version has already been bumped,
3476 * so just make the conversion to the new inode
3477 * format permanent.
3478 */
3487 }
3488 }
3492 }
3495 /*
3496 * The only error from xfs_iflush_fork is on the data fork.
3497 */
3499 }
3502 /*
3503 * We've recorded everything logged in the inode, so we'd
3504 * like to clear the ilf_fields bits so we don't log and
3505 * flush things unnecessarily. However, we can't stop
3506 * logging all this information until the data we've copied
3507 * into the disk buffer is written to disk. If we did we might
3508 * overwrite the copy of the inode in the log with all the
3509 * data after re-logging only part of it, and in the face of
3510 * a crash we wouldn't have all the data we need to recover.
3511 *
3512 * What we do is move the bits to the ili_last_fields field.
3513 * When logging the inode, these bits are moved back to the
3514 * ilf_fields field. In the xfs_iflush_done() routine we
3515 * clear ili_last_fields, since we know that the information
3516 * those bits represent is permanently on disk. As long as
3517 * the flush completes before the inode is logged again, then
3518 * both ilf_fields and ili_last_fields will be cleared.
3519 *
3520 * We can play with the ilf_fields bits here, because the inode
3521 * lock must be held exclusively in order to set bits there
3522 * and the flush lock protects the ili_last_fields bits.
3523 * Set ili_logged so the flush done
3524 * routine can tell whether or not to look in the AIL.
3525 * Also, store the current LSN of the inode so that we can tell
3526 * whether the item has moved in the AIL from xfs_iflush_done().
3527 * In order to read the lsn we need the AIL lock, because
3528 * it is a 64 bit value that cannot be read atomically.
3529 */
3540 /*
3541 * Attach the function xfs_iflush_done to the inode's
3542 * buffer. This will remove the inode from the AIL
3543 * and unlock the inode's flush lock when the inode is
3544 * completely written to disk.
3545 */
3552 /*
3553 * We're flushing an inode which is not in the AIL and has
3554 * not been logged but has i_update_core set. For this
3555 * case we can use a B_DELWRI flush and immediately drop
3556 * the inode flush lock because we can avoid the whole
3557 * AIL state thing. It's OK to drop the flush lock now,
3558 * because we've already locked the buffer and to do anything
3559 * you really need both.
3560 */
3565 }
3567 }
3571 corrupt_out:
3573 }
3576 /*
3577 * Flush all inactive inodes in mp.
3578 */
3579 void
3582 {
3586 again:
3593 /* Make sure we skip markers inserted by sync */
3597 }
3604 }
3610 out:
3612 }
3614 /*
3615 * xfs_iaccess: check accessibility of inode for mode.
3616 */
3617 int
3620 mode_t mode,
3622 {
3636 }
3638 /*
3639 * If there's an Access Control List it's used instead of
3640 * the mode bits.
3641 */
3649 }
3651 /*
3652 * If the DACs are ok we don't need any capability check.
3653 */
3656 /*
3657 * Read/write DACs are always overridable.
3658 * Executable DACs are overridable if at least one exec bit is set.
3659 */
3669 #ifdef NOISE
3673 }
3675 }
3677 /*
3678 * xfs_iroundup: round up argument to next power of two
3679 */
3680 uint
3682 uint v)
3683 {
3685 uint m;
3698 }
3701 }
3703 #ifdef XFS_ILOCK_TRACE
3706 void
3708 {
3717 }
3718 #endif
3720 /*
3721 * Return a pointer to the extent record at file index idx.
3722 */
3723 xfs_bmbt_rec_host_t *
3727 {
3742 }
3743 }
3745 /*
3746 * Insert new item(s) into the extent records for incore inode
3747 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3748 */
3749 void
3755 {
3762 }
3764 /*
3765 * This is called when the amount of space required for incore file
3766 * extents needs to be increased. The ext_diff parameter stores the
3767 * number of new extents being added and the idx parameter contains
3768 * the extent index where the new extents will be added. If the new
3769 * extents are being appended, then we just need to (re)allocate and
3770 * initialize the space. Otherwise, if the new extents are being
3771 * inserted into the middle of the existing entries, a bit more work
3772 * is required to make room for the new extents to be inserted. The
3773 * caller is responsible for filling in the new extent entries upon
3774 * return.
3775 */
3776 void
3781 {
3790 /*
3791 * If the new number of extents (nextents + ext_diff)
3792 * fits inside the inode, then continue to use the inline
3793 * extent buffer.
3794 */
3801 }
3805 }
3806 /*
3807 * Otherwise use a linear (direct) extent list.
3808 * If the extents are currently inside the inode,
3809 * xfs_iext_realloc_direct will switch us from
3810 * inline to direct extent allocation mode.
3811 */
3819 }
3820 }
3821 /* Indirection array */
3834 }
3835 /* Extents fit in target extent page */
3843 }
3846 }
3847 /* Insert a new extent page */
3851 }
3852 /*
3853 * If extent(s) are being appended to the last page in
3854 * the indirection array and the new extent(s) don't fit
3855 * in the page, then erp is NULL and erp_idx is set to
3856 * the next index needed in the indirection array.
3857 */
3866 erp_idx++;
3867 }
3868 }
3869 }
3870 }
3872 }
3874 /*
3875 * This is called when incore extents are being added to the indirection
3876 * array and the new extents do not fit in the target extent list. The
3877 * erp_idx parameter contains the irec index for the target extent list
3878 * in the indirection array, and the idx parameter contains the extent
3879 * index within the list. The number of extents being added is stored
3880 * in the count parameter.
3881 *
3882 * |-------| |-------|
3883 * | | | | idx - number of extents before idx
3884 * | idx | | count |
3885 * | | | | count - number of extents being inserted at idx
3886 * |-------| |-------|
3887 * | count | | nex2 | nex2 - number of extents after idx + count
3888 * |-------| |-------|
3889 */
3890 void
3896 {
3910 /*
3911 * Save second part of target extent list
3912 * (all extents past */
3920 }
3922 /*
3923 * Add the new extents to the end of the target
3924 * list, then allocate new irec record(s) and
3925 * extent buffer(s) as needed to store the rest
3926 * of the new extents.
3927 */
3934 }
3936 erp_idx++;
3942 }
3944 /* Add nex2 extents back to indirection array */
3946 xfs_extnum_t ext_avail;
3952 /*
3953 * If nex2 extents fit in the current page, append
3954 * nex2_ep after the new extents.
3955 */
3958 }
3959 /*
3960 * Otherwise, check if space is available in the
3961 * next page.
3962 */
3966 erp_idx++;
3967 erp++;
3968 /* Create a hole for nex2 extents */
3971 }
3972 /*
3973 * Final choice, create a new extent page for
3974 * nex2 extents.
3975 */
3977 erp_idx++;
3979 }
3984 }
3985 }
3987 /*
3988 * This is called when the amount of space required for incore file
3989 * extents needs to be decreased. The ext_diff parameter stores the
3990 * number of extents to be removed and the idx parameter contains
3991 * the extent index where the extents will be removed from.
3992 *
3993 * If the amount of space needed has decreased below the linear
3994 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3995 * extent array. Otherwise, use kmem_realloc() to adjust the
3996 * size to what is needed.
3997 */
3998 void
4003 {
4019 }
4021 }
4023 /*
4024 * This removes ext_diff extents from the inline buffer, beginning
4025 * at extent index idx.
4026 */
4027 void
4032 {
4051 }
4052 }
4054 /*
4055 * This removes ext_diff extents from a linear (direct) extent list,
4056 * beginning at extent index idx. If the extents are being removed
4057 * from the end of the list (ie. truncate) then we just need to re-
4058 * allocate the list to remove the extra space. Otherwise, if the
4059 * extents are being removed from the middle of the existing extent
4060 * entries, then we first need to move the extent records beginning
4061 * at idx + ext_diff up in the list to overwrite the records being
4062 * removed, then remove the extra space via kmem_realloc.
4063 */
4064 void
4069 {
4081 }
4082 /* Move extents up in the list (if needed) */
4088 }
4091 /*
4092 * Reallocate the direct extent list. If the extents
4093 * will fit inside the inode then xfs_iext_realloc_direct
4094 * will switch from direct to inline extent allocation
4095 * mode for us.
4096 */
4099 }
4101 /*
4102 * This is called when incore extents are being removed from the
4103 * indirection array and the extents being removed span multiple extent
4104 * buffers. The idx parameter contains the file extent index where we
4105 * want to begin removing extents, and the count parameter contains
4106 * how many extents need to be removed.
4107 *
4108 * |-------| |-------|
4109 * | nex1 | | | nex1 - number of extents before idx
4110 * |-------| | count |
4111 * | | | | count - number of extents being removed at idx
4112 * | count | |-------|
4113 * | | | nex2 | nex2 - number of extents after idx + count
4114 * |-------| |-------|
4115 */
4116 void
4121 {
4140 /*
4141 * Check for deletion of entire list;
4142 * xfs_iext_irec_remove() updates extent offsets.
4143 */
4150 XFS_IEXT_BUFSZ);
4156 }
4157 }
4158 /* Move extents up (if needed) */
4163 }
4164 /* Zero out rest of page */
4167 /* Update remaining counters */
4172 erp_idx++;
4173 erp++;
4174 }
4177 }
4179 /*
4180 * Create, destroy, or resize a linear (direct) block of extents.
4181 */
4182 void
4186 {
4195 /* Free extent records */
4198 }
4199 /* Resize direct extent list and zero any new bytes */
4201 /* Check if extents will fit inside the inode */
4207 }
4210 }
4214 rnew_size,
4216 KM_SLEEP);
4217 }
4222 }
4223 }
4224 /*
4225 * Switch from the inline extent buffer to a direct
4226 * extent list. Be sure to include the inline extent
4227 * bytes in new_size.
4228 */
4233 }
4235 }
4238 }
4240 /*
4241 * Switch from linear (direct) extent records to inline buffer.
4242 */
4243 void
4247 {
4250 /*
4251 * The inline buffer was zeroed when we switched
4252 * from inline to direct extent allocation mode,
4253 * so we don't need to clear it here.
4254 */
4260 }
4262 /*
4263 * Switch from inline buffer to linear (direct) extent records.
4264 * new_size should already be rounded up to the next power of 2
4265 * by the caller (when appropriate), so use new_size as it is.
4266 * However, since new_size may be rounded up, we can't update
4267 * if_bytes here. It is the caller's responsibility to update
4268 * if_bytes upon return.
4269 */
4270 void
4274 {
4282 }
4284 }
4286 /*
4287 * Resize an extent indirection array to new_size bytes.
4288 */
4289 void
4293 {
4308 }
4309 }
4311 /*
4312 * Switch from indirection array to linear (direct) extent allocations.
4313 */
4314 void
4317 {
4337 }
4338 }
4340 /*
4341 * Free incore file extents.
4342 */
4343 void
4346 {
4354 }
4361 }
4365 }
4367 /*
4368 * Return a pointer to the extent record for file system block bno.
4369 */
4375 {
4390 }
4393 /* Find target extent list */
4401 }
4402 /* Binary search extent records */
4413 /* Convert back to file-based extent index */
4416 }
4419 }
4420 }
4421 /* Convert back to file-based extent index */
4424 }
4430 }
4431 }
4434 }
4436 /*
4437 * Return a pointer to the indirection array entry containing the
4438 * extent record for filesystem block bno. Store the index of the
4439 * target irec in *erp_idxp.
4440 */
4446 {
4470 }
4471 }
4474 }
4476 /*
4477 * Return a pointer to the indirection array entry containing the
4478 * extent record at file extent index *idxp. Store the index of the
4479 * target irec in *erp_idxp and store the page index of the target
4480 * extent record in *idxp.
4481 */
4482 xfs_ext_irec_t *
4488 {
4505 /* Binary search extent irec's */
4521 erp_idx++;
4527 }
4528 }
4532 }
4534 /*
4535 * Allocate and initialize an indirection array once the space needed
4536 * for incore extents increases above XFS_IEXT_BUFSZ.
4537 */
4538 void
4541 {
4558 }
4569 }
4571 /*
4572 * Allocate and initialize a new entry in the indirection array.
4573 */
4574 xfs_ext_irec_t *
4578 {
4586 /* Resize indirection array */
4589 /*
4590 * Move records down in the array so the
4591 * new page can use erp_idx.
4592 */
4596 }
4599 /* Initialize new extent record */
4608 }
4610 /*
4611 * Remove a record from the indirection array.
4612 */
4613 void
4617 {
4629 }
4630 /* Compact extent records */
4634 }
4635 /*
4636 * Manually free the last extent record from the indirection
4637 * array. A call to xfs_iext_realloc_indirect() with a size
4638 * of zero would result in a call to xfs_iext_destroy() which
4639 * would in turn call this function again, creating a nasty
4640 * infinite loop.
4641 */
4648 }
4650 }
4652 /*
4653 * This is called to clean up large amounts of unused memory allocated
4654 * by the indirection array. Before compacting anything though, verify
4655 * that the indirection array is still needed and switch back to the
4656 * linear extent list (or even the inline buffer) if possible. The
4657 * compaction policy is as follows:
4658 *
4659 * Full Compaction: Extents fit into a single page (or inline buffer)
4660 * Full Compaction: Extents occupy less than 10% of allocated space
4661 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4662 * No Compaction: Extents occupy at least 50% of allocated space
4663 */
4664 void
4667 {
4686 }
4687 }
4689 /*
4690 * Combine extents from neighboring extent pages.
4691 */
4692 void
4695 {
4711 /*
4712 * Free page before removing extent record
4713 * so er_extoffs don't get modified in
4714 * xfs_iext_irec_remove.
4715 */
4721 erp_idx++;
4722 }
4723 }
4724 }
4726 /*
4727 * Fully compact the extent records managed by the indirection array.
4728 */
4729 void
4732 {
4752 /* Remove next page */
4754 /*
4755 * Free page before removing extent record
4756 * so er_extoffs don't get modified in
4757 * xfs_iext_irec_remove.
4758 */
4765 /* Update next page */
4767 /* Move rest of page up to become next new page */
4774 }
4776 erp_idx++;
4779 else
4781 }
4785 }
4786 }
4788 /*
4789 * This is called to update the er_extoff field in the indirection
4790 * array when extents have been added or removed from one of the
4791 * extent lists. erp_idx contains the irec index to begin updating
4792 * at and ext_diff contains the number of extents that were added
4793 * or removed.
4794 */
4795 void
4800 {
4808 }
4809 }