| blob | abf509a88915e95aae00dcebec502170b1280b38 |
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;
1464 /*
1465 * Call toss_pages or flushinval_pages to get rid of pages
1466 * overlapping the region being removed. We have to use
1467 * the less efficient flushinval_pages in the case that the
1468 * caller may not be able to finish the truncate without
1469 * dropping the inode's I/O lock. Make sure
1470 * to catch any pages brought in by buffers overlapping
1471 * the EOF by searching out beyond the isize by our
1472 * block size. We round new_size up to a block boundary
1473 * so that we don't toss things on the same block as
1474 * new_size but before it.
1475 *
1476 * Before calling toss_page or flushinval_pages, make sure to
1477 * call remapf() over the same region if the file is mapped.
1478 * This frees up mapped file references to the pages in the
1479 * given range and for the flushinval_pages case it ensures
1480 * that we get the latest mapped changes flushed out.
1481 */
1485 /*
1486 * The place to start tossing is beyond our maximum
1487 * file size, so there is no way that the data extended
1488 * out there.
1489 */
1491 }
1494 last_byte);
1502 }
1503 }
1505 #ifdef DEBUG
1508 }
1509 #endif
1511 }
1513 /*
1514 * Shrink the file to the given new_size. The new
1515 * size must be smaller than the current size.
1516 * This will free up the underlying blocks
1517 * in the removed range after a call to xfs_itruncate_start()
1518 * or xfs_atruncate_start().
1519 *
1520 * The transaction passed to this routine must have made
1521 * a permanent log reservation of at least XFS_ITRUNCATE_LOG_RES.
1522 * This routine may commit the given transaction and
1523 * start new ones, so make sure everything involved in
1524 * the transaction is tidy before calling here.
1525 * Some transaction will be returned to the caller to be
1526 * committed. The incoming transaction must already include
1527 * the inode, and both inode locks must be held exclusively.
1528 * The inode must also be "held" within the transaction. On
1529 * return the inode will be "held" within the returned transaction.
1530 * This routine does NOT require any disk space to be reserved
1531 * for it within the transaction.
1532 *
1533 * The fork parameter must be either xfs_attr_fork or xfs_data_fork,
1534 * and it indicates the fork which is to be truncated. For the
1535 * attribute fork we only support truncation to size 0.
1536 *
1537 * We use the sync parameter to indicate whether or not the first
1538 * transaction we perform might have to be synchronous. For the attr fork,
1539 * it needs to be so if the unlink of the inode is not yet known to be
1540 * permanent in the log. This keeps us from freeing and reusing the
1541 * blocks of the attribute fork before the unlink of the inode becomes
1542 * permanent.
1543 *
1544 * For the data fork, we normally have to run synchronously if we're
1545 * being called out of the inactive path or we're being called
1546 * out of the create path where we're truncating an existing file.
1547 * Either way, the truncate needs to be sync so blocks don't reappear
1548 * in the file with altered data in case of a crash. wsync filesystems
1549 * can run the first case async because anything that shrinks the inode
1550 * has to run sync so by the time we're called here from inactive, the
1551 * inode size is permanently set to 0.
1552 *
1553 * Calls from the truncate path always need to be sync unless we're
1554 * in a wsync filesystem and the file has already been unlinked.
1555 *
1556 * The caller is responsible for correctly setting the sync parameter.
1557 * It gets too hard for us to guess here which path we're being called
1558 * out of just based on inode state.
1559 */
1560 int
1564 xfs_fsize_t new_size,
1567 {
1568 xfs_fsblock_t first_block;
1569 xfs_fileoff_t first_unmap_block;
1570 xfs_fileoff_t last_block;
1576 xfs_bmap_free_t free_list;
1593 /*
1594 * We only support truncating the entire attribute fork.
1595 */
1598 }
1601 /*
1602 * The first thing we do is set the size to new_size permanently
1603 * on disk. This way we don't have to worry about anyone ever
1604 * being able to look at the data being freed even in the face
1605 * of a crash. What we're getting around here is the case where
1606 * we free a block, it is allocated to another file, it is written
1607 * to, and then we crash. If the new data gets written to the
1608 * file but the log buffers containing the free and reallocation
1609 * don't, then we'd end up with garbage in the blocks being freed.
1610 * As long as we make the new_size permanent before actually
1611 * freeing any blocks it doesn't matter if they get writtten to.
1612 *
1613 * The callers must signal into us whether or not the size
1614 * setting here must be synchronous. There are a few cases
1615 * where it doesn't have to be synchronous. Those cases
1616 * occur if the file is unlinked and we know the unlink is
1617 * permanent or if the blocks being truncated are guaranteed
1618 * to be beyond the inode eof (regardless of the link count)
1619 * and the eof value is permanent. Both of these cases occur
1620 * only on wsync-mounted filesystems. In those cases, we're
1621 * guaranteed that no user will ever see the data in the blocks
1622 * that are being truncated so the truncate can run async.
1623 * In the free beyond eof case, the file may wind up with
1624 * more blocks allocated to it than it needs if we crash
1625 * and that won't get fixed until the next time the file
1626 * is re-opened and closed but that's ok as that shouldn't
1627 * be too many blocks.
1628 *
1629 * However, we can't just make all wsync xactions run async
1630 * because there's one call out of the create path that needs
1631 * to run sync where it's truncating an existing file to size
1632 * 0 whose size is > 0.
1633 *
1634 * It's probably possible to come up with a test in this
1635 * routine that would correctly distinguish all the above
1636 * cases from the values of the function parameters and the
1637 * inode state but for sanity's sake, I've decided to let the
1638 * layers above just tell us. It's simpler to correctly figure
1639 * out in the layer above exactly under what conditions we
1640 * can run async and I think it's easier for others read and
1641 * follow the logic in case something has to be changed.
1642 * cscope is your friend -- rcc.
1643 *
1644 * The attribute fork is much simpler.
1645 *
1646 * For the attribute fork we allow the caller to tell us whether
1647 * the unlink of the inode that led to this call is yet permanent
1648 * in the on disk log. If it is not and we will be freeing extents
1649 * in this inode then we make the first transaction synchronous
1650 * to make sure that the unlink is permanent by the time we free
1651 * the blocks.
1652 */
1655 /*
1656 * If we are not changing the file size then do
1657 * not update the on-disk file size - we may be
1658 * called from xfs_inactive_free_eofblocks(). If we
1659 * update the on-disk file size and then the system
1660 * crashes before the contents of the file are
1661 * flushed to disk then the files may be full of
1662 * holes (ie NULL files bug).
1663 */
1668 }
1669 }
1674 }
1680 /*
1681 * Since it is possible for space to become allocated beyond
1682 * the end of the file (in a crash where the space is allocated
1683 * but the inode size is not yet updated), simply remove any
1684 * blocks which show up between the new EOF and the maximum
1685 * possible file size. If the first block to be removed is
1686 * beyond the maximum file size (ie it is the same as last_block),
1687 * then there is nothing to do.
1688 */
1696 }
1698 /*
1699 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1700 * will tell us whether it freed the entire range or
1701 * not. If this is a synchronous mount (wsync),
1702 * then we can tell bunmapi to keep all the
1703 * transactions asynchronous since the unlink
1704 * transaction that made this inode inactive has
1705 * already hit the disk. There's no danger of
1706 * the freed blocks being reused, there being a
1707 * crash, and the reused blocks suddenly reappearing
1708 * in this file with garbage in them once recovery
1709 * runs.
1710 */
1716 XFS_ITRUNC_MAX_EXTENTS,
1720 /*
1721 * If the bunmapi call encounters an error,
1722 * return to the caller where the transaction
1723 * can be properly aborted. We just need to
1724 * make sure we're not holding any resources
1725 * that we were not when we came in.
1726 */
1729 }
1731 /*
1732 * Duplicate the transaction that has the permanent
1733 * reservation and commit the old transaction.
1734 */
1738 /*
1739 * If the bmap finish call encounters an error,
1740 * return to the caller where the transaction
1741 * can be properly aborted. We just need to
1742 * make sure we're not holding any resources
1743 * that we were not when we came in.
1744 *
1745 * Aborting from this point might lose some
1746 * blocks in the file system, but oh well.
1747 */
1750 /*
1751 * If the passed in transaction committed
1752 * in xfs_bmap_finish(), then we want to
1753 * add the inode to this one before returning.
1754 * This keeps things simple for the higher
1755 * level code, because it always knows that
1756 * the inode is locked and held in the
1757 * transaction that returns to it whether
1758 * errors occur or not. We don't mark the
1759 * inode dirty so that this transaction can
1760 * be easily aborted if possible.
1761 */
1765 }
1767 }
1770 /*
1771 * The first xact was committed,
1772 * so add the inode to the new one.
1773 * Mark it dirty so it will be logged
1774 * and moved forward in the log as
1775 * part of every commit.
1776 */
1781 }
1786 XFS_TRANS_PERM_LOG_RES,
1787 XFS_ITRUNCATE_LOG_COUNT);
1788 /*
1789 * Add the inode being truncated to the next chained
1790 * transaction.
1791 */
1796 }
1797 /*
1798 * Only update the size in the case of the data fork, but
1799 * always re-log the inode so that our permanent transaction
1800 * can keep on rolling it forward in the log.
1801 */
1804 /*
1805 * If we are not changing the file size then do
1806 * not update the on-disk file size - we may be
1807 * called from xfs_inactive_free_eofblocks(). If we
1808 * update the on-disk file size and then the system
1809 * crashes before the contents of the file are
1810 * flushed to disk then the files may be full of
1811 * holes (ie NULL files bug).
1812 */
1816 }
1817 }
1827 }
1830 /*
1831 * xfs_igrow_start
1832 *
1833 * Do the first part of growing a file: zero any data in the last
1834 * block that is beyond the old EOF. We need to do this before
1835 * the inode is joined to the transaction to modify the i_size.
1836 * That way we can drop the inode lock and call into the buffer
1837 * cache to get the buffer mapping the EOF.
1838 */
1839 int
1842 xfs_fsize_t new_size,
1844 {
1851 /*
1852 * Zero any pages that may have been created by
1853 * xfs_write_file() beyond the end of the file
1854 * and any blocks between the old and new file sizes.
1855 */
1859 }
1861 /*
1862 * xfs_igrow_finish
1863 *
1864 * This routine is called to extend the size of a file.
1865 * The inode must have both the iolock and the ilock locked
1866 * for update and it must be a part of the current transaction.
1867 * The xfs_igrow_start() function must have been called previously.
1868 * If the change_flag is not zero, the inode change timestamp will
1869 * be updated.
1870 */
1871 void
1875 xfs_fsize_t new_size,
1877 {
1883 /*
1884 * Update the file size. Update the inode change timestamp
1885 * if change_flag set.
1886 */
1893 }
1896 /*
1897 * This is called when the inode's link count goes to 0.
1898 * We place the on-disk inode on a list in the AGI. It
1899 * will be pulled from this list when the inode is freed.
1900 */
1901 int
1905 {
1911 xfs_agnumber_t agno;
1912 xfs_daddr_t agdaddr;
1913 xfs_agino_t agino;
1928 /*
1929 * Get the agi buffer first. It ensures lock ordering
1930 * on the list.
1931 */
1937 /*
1938 * Validate the magic number of the agi block.
1939 */
1941 agi_ok =
1945 XFS_RANDOM_IUNLINK))) {
1949 }
1950 /*
1951 * Get the index into the agi hash table for the
1952 * list this inode will go on.
1953 */
1964 /*
1965 * Clear the on-disk di_nlink. This is to prevent xfs_bulkstat
1966 * from picking up this inode when it is reclaimed (its incore state
1967 * initialzed but not flushed to disk yet). The in-core di_nlink is
1968 * already cleared in xfs_droplink() and a corresponding transaction
1969 * logged. The hack here just synchronizes the in-core to on-disk
1970 * di_nlink value in advance before the actual inode sync to disk.
1971 * This is OK because the inode is already unlinked and would never
1972 * change its di_nlink again for this inode generation.
1973 * This is a temporary hack that would require a proper fix
1974 * in the future.
1975 */
1979 /*
1980 * There is already another inode in the bucket we need
1981 * to add ourselves to. Add us at the front of the list.
1982 * Here we put the head pointer into our next pointer,
1983 * and then we fall through to point the head at us.
1984 */
1986 /* both on-disk, don't endian flip twice */
1994 }
1996 /*
1997 * Point the bucket head pointer at the inode being inserted.
1998 */
2006 }
2008 /*
2009 * Pull the on-disk inode from the AGI unlinked list.
2010 */
2011 STATIC int
2015 {
2016 xfs_ino_t next_ino;
2022 xfs_agnumber_t agno;
2023 xfs_daddr_t agdaddr;
2024 xfs_agino_t agino;
2025 xfs_agino_t next_agino;
2033 /*
2034 * First pull the on-disk inode from the AGI unlinked list.
2035 */
2041 /*
2042 * Get the agi buffer first. It ensures lock ordering
2043 * on the list.
2044 */
2052 }
2053 /*
2054 * Validate the magic number of the agi block.
2055 */
2057 agi_ok =
2061 XFS_RANDOM_IUNLINK_REMOVE))) {
2069 }
2070 /*
2071 * Get the index into the agi hash table for the
2072 * list this inode will go on.
2073 */
2081 /*
2082 * We're at the head of the list. Get the inode's
2083 * on-disk buffer to see if there is anyone after us
2084 * on the list. Only modify our next pointer if it
2085 * is not already NULLAGINO. This saves us the overhead
2086 * of dealing with the buffer when there is no need to
2087 * change it.
2088 */
2095 }
2108 }
2109 /*
2110 * Point the bucket head pointer at the next inode.
2111 */
2120 /*
2121 * We need to search the list for the inode being freed.
2122 */
2126 /*
2127 * If the last inode wasn't the one pointing to
2128 * us, then release its buffer since we're not
2129 * going to do anything with it.
2130 */
2133 }
2142 }
2146 }
2147 /*
2148 * Now last_ibp points to the buffer previous to us on
2149 * the unlinked list. Pull us from the list.
2150 */
2157 }
2171 }
2172 /*
2173 * Point the previous inode on the list to the next inode.
2174 */
2182 }
2184 }
2187 {
2191 }
2193 STATIC void
2197 xfs_ino_t inum)
2198 {
2204 xfs_daddr_t blkno;
2221 }
2230 /*
2231 * Look for each inode in memory and attempt to lock it,
2232 * we can be racing with flush and tail pushing here.
2233 * any inode we get the locks on, add to an array of
2234 * inode items to process later.
2235 *
2236 * The get the buffer lock, we could beat a flush
2237 * or tail pushing thread to the lock here, in which
2238 * case they will go looking for the inode buffer
2239 * and fail, we need some other form of interlock
2240 * here.
2241 */
2248 /* Inode not in memory or we found it already,
2249 * nothing to do
2250 */
2254 }
2259 }
2261 /* If we can get the locks then add it to the
2262 * list, otherwise by the time we get the bp lock
2263 * below it will already be attached to the
2264 * inode buffer.
2265 */
2267 /* This inode will already be locked - by us, lets
2268 * keep it that way.
2269 */
2278 }
2279 }
2282 }
2293 }
2296 }
2297 }
2299 }
2303 XFS_BUF_LOCK);
2316 pre_flushed++;
2317 }
2319 }
2330 }
2344 }
2345 }
2350 }
2354 }
2356 /*
2357 * This is called to return an inode to the inode free list.
2358 * The inode should already be truncated to 0 length and have
2359 * no pages associated with it. This routine also assumes that
2360 * the inode is already a part of the transaction.
2361 *
2362 * The on-disk copy of the inode will have been added to the list
2363 * of unlinked inodes in the AGI. We need to remove the inode from
2364 * that list atomically with respect to freeing it here.
2365 */
2366 int
2371 {
2374 xfs_ino_t first_ino;
2385 /*
2386 * Pull the on-disk inode from the AGI unlinked list.
2387 */
2391 }
2396 }
2405 /*
2406 * Bump the generation count so no one will be confused
2407 * by reincarnations of this inode.
2408 */
2414 }
2417 }
2419 /*
2420 * Reallocate the space for if_broot based on the number of records
2421 * being added or deleted as indicated in rec_diff. Move the records
2422 * and pointers in if_broot to fit the new size. When shrinking this
2423 * will eliminate holes between the records and pointers created by
2424 * the caller. When growing this will create holes to be filled in
2425 * by the caller.
2426 *
2427 * The caller must not request to add more records than would fit in
2428 * the on-disk inode root. If the if_broot is currently NULL, then
2429 * if we adding records one will be allocated. The caller must also
2430 * not request that the number of records go below zero, although
2431 * it can go to zero.
2432 *
2433 * ip -- the inode whose if_broot area is changing
2434 * ext_diff -- the change in the number of records, positive or negative,
2435 * requested for the if_broot array.
2436 */
2437 void
2442 {
2451 /*
2452 * Handle the degenerate case quietly.
2453 */
2456 }
2460 /*
2461 * If there wasn't any memory allocated before, just
2462 * allocate it now and get out.
2463 */
2467 KM_SLEEP);
2470 }
2472 /*
2473 * If there is already an existing if_broot, then we need
2474 * to realloc() it and shift the pointers to their new
2475 * location. The records don't change location because
2476 * they are kept butted up against the btree block header.
2477 */
2483 new_size,
2485 KM_SLEEP);
2495 }
2497 /*
2498 * rec_diff is less than 0. In this case, we are shrinking the
2499 * if_broot buffer. It must already exist. If we go to zero
2500 * records, just get rid of the root and clear the status bit.
2501 */
2508 else
2512 /*
2513 * First copy over the btree block header.
2514 */
2519 }
2521 /*
2522 * Only copy the records and pointers if there are any.
2523 */
2525 /*
2526 * First copy the records.
2527 */
2534 /*
2535 * Then copy the pointers.
2536 */
2542 }
2549 }
2552 /*
2553 * This is called when the amount of space needed for if_data
2554 * is increased or decreased. The change in size is indicated by
2555 * the number of bytes that need to be added or deleted in the
2556 * byte_diff parameter.
2557 *
2558 * If the amount of space needed has decreased below the size of the
2559 * inline buffer, then switch to using the inline buffer. Otherwise,
2560 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2561 * to what is needed.
2562 *
2563 * ip -- the inode whose if_data area is changing
2564 * byte_diff -- the change in the number of bytes, positive or negative,
2565 * requested for the if_data array.
2566 */
2567 void
2572 {
2579 }
2588 }
2592 /*
2593 * If the valid extents/data can fit in if_inline_ext/data,
2594 * copy them from the malloc'd vector and free it.
2595 */
2601 new_size);
2604 }
2607 /*
2608 * Stuck with malloc/realloc.
2609 * For inline data, the underlying buffer must be
2610 * a multiple of 4 bytes in size so that it can be
2611 * logged and stay on word boundaries. We enforce
2612 * that here.
2613 */
2619 /*
2620 * Only do the realloc if the underlying size
2621 * is really changing.
2622 */
2626 real_size,
2628 KM_SLEEP);
2629 }
2635 }
2636 }
2640 }
2645 /*
2646 * Map inode to disk block and offset.
2647 *
2648 * mp -- the mount point structure for the current file system
2649 * tp -- the current transaction
2650 * ino -- the inode number of the inode to be located
2651 * imap -- this structure is filled in with the information necessary
2652 * to retrieve the given inode from disk
2653 * flags -- flags to pass to xfs_dilocate indicating whether or not
2654 * lookups in the inode btree were OK or not
2655 */
2656 int
2660 xfs_ino_t ino,
2662 uint flags)
2663 {
2664 xfs_fsblock_t fsbno;
2674 }
2681 }
2683 void
2687 {
2694 }
2696 /*
2697 * If the format is local, then we can't have an extents
2698 * array so just look for an inline data array. If we're
2699 * not local then we may or may not have an extents list,
2700 * so check and free it up if we do.
2701 */
2709 }
2716 }
2723 }
2724 }
2726 /*
2727 * This is called free all the memory associated with an inode.
2728 * It must free the inode itself and any buffers allocated for
2729 * if_extents/if_data and if_broot. It must also free the lock
2730 * associated with the inode.
2731 */
2732 void
2735 {
2743 }
2750 #ifdef XFS_VNODE_TRACE
2752 #endif
2753 #ifdef XFS_BMAP_TRACE
2755 #endif
2756 #ifdef XFS_BMBT_TRACE
2758 #endif
2759 #ifdef XFS_RW_TRACE
2761 #endif
2762 #ifdef XFS_ILOCK_TRACE
2764 #endif
2765 #ifdef XFS_DIR2_TRACE
2767 #endif
2769 /*
2770 * Only if we are shutting down the fs will we see an
2771 * inode still in the AIL. If it is there, we should remove
2772 * it to prevent a use-after-free from occurring.
2773 */
2784 else
2786 }
2788 }
2790 }
2793 /*
2794 * Increment the pin count of the given buffer.
2795 * This value is protected by ipinlock spinlock in the mount structure.
2796 */
2797 void
2800 {
2804 }
2806 /*
2807 * Decrement the pin count of the given inode, and wake up
2808 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2809 * inode must have been previously pinned with a call to xfs_ipin().
2810 */
2811 void
2814 {
2819 /*
2820 * If the inode is currently being reclaimed, the link between
2821 * the bhv_vnode and the xfs_inode will be broken after the
2822 * XFS_IRECLAIM* flag is set. Hence, if these flags are not
2823 * set, then we can move forward and mark the linux inode dirty
2824 * knowing that it is still valid as it won't freed until after
2825 * the bhv_vnode<->xfs_inode link is broken in xfs_reclaim. The
2826 * i_flags_lock is used to synchronise the setting of the
2827 * XFS_IRECLAIM* flags and the breaking of the link, and so we
2828 * can execute atomically w.r.t to reclaim by holding this lock
2829 * here.
2830 *
2831 * However, we still need to issue the unpin wakeup call as the
2832 * inode reclaim may be blocked waiting for the inode to become
2833 * unpinned.
2834 */
2844 /* make sync come back and flush this inode */
2847 }
2850 }
2851 }
2853 /*
2854 * This is called to wait for the given inode to be unpinned.
2855 * It will sleep until this happens. The caller must have the
2856 * inode locked in at least shared mode so that the buffer cannot
2857 * be subsequently pinned once someone is waiting for it to be
2858 * unpinned.
2859 */
2860 STATIC void
2863 {
2865 xfs_lsn_t lsn;
2871 }
2878 }
2880 /*
2881 * Give the log a push so we don't wait here too long.
2882 */
2886 }
2889 /*
2890 * xfs_iextents_copy()
2891 *
2892 * This is called to copy the REAL extents (as opposed to the delayed
2893 * allocation extents) from the inode into the given buffer. It
2894 * returns the number of bytes copied into the buffer.
2895 *
2896 * If there are no delayed allocation extents, then we can just
2897 * memcpy() the extents into the buffer. Otherwise, we need to
2898 * examine each extent in turn and skip those which are delayed.
2899 */
2900 int
2905 {
2910 xfs_fsblock_t start_block;
2920 /*
2921 * There are some delayed allocation extents in the
2922 * inode, so copy the extents one at a time and skip
2923 * the delayed ones. There must be at least one
2924 * non-delayed extent.
2925 */
2931 /*
2932 * It's a delayed allocation extent, so skip it.
2933 */
2935 }
2937 /* Translate to on disk format */
2940 dp++;
2941 copied++;
2942 }
2947 }
2949 /*
2950 * Each of the following cases stores data into the same region
2951 * of the on-disk inode, so only one of them can be valid at
2952 * any given time. While it is possible to have conflicting formats
2953 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2954 * in EXTENTS format, this can only happen when the fork has
2955 * changed formats after being modified but before being flushed.
2956 * In these cases, the format always takes precedence, because the
2957 * format indicates the current state of the fork.
2958 */
2959 /*ARGSUSED*/
2960 STATIC int
2967 {
2971 #ifdef XFS_TRANS_DEBUG
2973 #endif
2984 /*
2985 * This can happen if we gave up in iformat in an error path,
2986 * for the attribute fork.
2987 */
2991 }
3001 }
3015 whichfork);
3016 }
3025 XFS_BROOT_SIZE_ADJ));
3029 }
3036 }
3044 }
3050 }
3053 }
3055 /*
3056 * xfs_iflush() will write a modified inode's changes out to the
3057 * inode's on disk home. The caller must have the inode lock held
3058 * in at least shared mode and the inode flush semaphore must be
3059 * held as well. The inode lock will still be held upon return from
3060 * the call and the caller is free to unlock it.
3061 * The inode flush lock will be unlocked when the inode reaches the disk.
3062 * The flags indicate how the inode's buffer should be written out.
3063 */
3064 int
3067 uint flags)
3068 {
3074 /* REFERENCED */
3091 /*
3092 * If the inode isn't dirty, then just release the inode
3093 * flush lock and do nothing.
3094 */
3101 }
3103 /*
3104 * We can't flush the inode until it is unpinned, so
3105 * wait for it. We know noone new can pin it, because
3106 * we are holding the inode lock shared and you need
3107 * to hold it exclusively to pin the inode.
3108 */
3111 /*
3112 * This may have been unpinned because the filesystem is shutting
3113 * down forcibly. If that's the case we must not write this inode
3114 * to disk, because the log record didn't make it to disk!
3115 */
3122 }
3124 /*
3125 * Get the buffer containing the on-disk inode.
3126 */
3131 }
3133 /*
3134 * Decide how buffer will be flushed out. This is done before
3135 * the call to xfs_iflush_int because this field is zeroed by it.
3136 */
3138 /*
3139 * Flush out the inode buffer according to the directions
3140 * of the caller. In the cases where the caller has given
3141 * us a choice choose the non-delwri case. This is because
3142 * the inode is in the AIL and we need to get it out soon.
3143 */
3160 }
3178 }
3179 }
3181 /*
3182 * First flush out the inode that xfs_iflush was called with.
3183 */
3187 }
3189 /*
3190 * inode clustering:
3191 * see if other inodes can be gathered into this write
3192 */
3201 /*
3202 * Do an un-protected check to see if the inode is dirty and
3203 * is a candidate for flushing. These checks will be repeated
3204 * later after the appropriate locks are acquired.
3205 */
3212 }
3214 /*
3215 * Try to get locks. If any are unavailable,
3216 * then this inode cannot be flushed and is skipped.
3217 */
3219 /* get inode locks (just i_lock) */
3221 /* get inode flush lock */
3223 /* check if pinned */
3225 /* arriving here means that
3226 * this inode can be flushed.
3227 * first re-check that it's
3228 * dirty
3229 */
3234 clcount++;
3238 XFS_ILOCK_SHARED);
3240 }
3243 }
3246 }
3247 }
3249 }
3250 }
3256 }
3258 /*
3259 * If the buffer is pinned then push on the log so we won't
3260 * get stuck waiting in the write for too long.
3261 */
3264 }
3272 }
3275 corrupt_out:
3279 /*
3280 * Unlocks the flush lock
3281 */
3284 cluster_corrupt_out:
3285 /* Corruption detected in the clustering loop. Invalidate the
3286 * inode buffer and shut down the filesystem.
3287 */
3290 /*
3291 * Clean up the buffer. If it was B_DELWRI, just release it --
3292 * brelse can handle it with no problems. If not, shut down the
3293 * filesystem before releasing the buffer.
3294 */
3297 }
3302 /*
3303 * Just like incore_relse: if we have b_iodone functions,
3304 * mark the buffer as an error and call them. Otherwise
3305 * mark it as stale and brelse.
3306 */
3317 }
3318 }
3321 /*
3322 * Unlocks the flush lock
3323 */
3325 }
3328 STATIC int
3332 {
3336 #ifdef XFS_TRANS_DEBUG
3338 #endif
3350 /*
3351 * If the inode isn't dirty, then just release the inode
3352 * flush lock and do nothing.
3353 */
3358 }
3360 /* set *dip = inode's place in the buffer */
3363 /*
3364 * Clear i_update_core before copying out the data.
3365 * This is for coordination with our timestamp updates
3366 * that don't hold the inode lock. They will always
3367 * update the timestamps BEFORE setting i_update_core,
3368 * so if we clear i_update_core after they set it we
3369 * are guaranteed to see their updates to the timestamps.
3370 * I believe that this depends on strongly ordered memory
3371 * semantics, but we have that. We use the SYNCHRONIZE
3372 * macro to make sure that the compiler does not reorder
3373 * the i_update_core access below the data copy below.
3374 */
3378 /*
3379 * Make sure to get the latest atime from the Linux inode.
3380 */
3389 }
3396 }
3406 }
3417 }
3418 }
3421 XFS_RANDOM_IFLUSH_5)) {
3427 ip);
3429 }
3436 }
3437 /*
3438 * bump the flush iteration count, used to detect flushes which
3439 * postdate a log record during recovery.
3440 */
3444 /*
3445 * Copy the dirty parts of the inode into the on-disk
3446 * inode. We always copy out the core of the inode,
3447 * because if the inode is dirty at all the core must
3448 * be.
3449 */
3452 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3456 /*
3457 * If this is really an old format inode and the superblock version
3458 * has not been updated to support only new format inodes, then
3459 * convert back to the old inode format. If the superblock version
3460 * has been updated, then make the conversion permanent.
3461 */
3466 /*
3467 * Convert it back.
3468 */
3472 /*
3473 * The superblock version has already been bumped,
3474 * so just make the conversion to the new inode
3475 * format permanent.
3476 */
3485 }
3486 }
3490 }
3493 /*
3494 * The only error from xfs_iflush_fork is on the data fork.
3495 */
3497 }
3500 /*
3501 * We've recorded everything logged in the inode, so we'd
3502 * like to clear the ilf_fields bits so we don't log and
3503 * flush things unnecessarily. However, we can't stop
3504 * logging all this information until the data we've copied
3505 * into the disk buffer is written to disk. If we did we might
3506 * overwrite the copy of the inode in the log with all the
3507 * data after re-logging only part of it, and in the face of
3508 * a crash we wouldn't have all the data we need to recover.
3509 *
3510 * What we do is move the bits to the ili_last_fields field.
3511 * When logging the inode, these bits are moved back to the
3512 * ilf_fields field. In the xfs_iflush_done() routine we
3513 * clear ili_last_fields, since we know that the information
3514 * those bits represent is permanently on disk. As long as
3515 * the flush completes before the inode is logged again, then
3516 * both ilf_fields and ili_last_fields will be cleared.
3517 *
3518 * We can play with the ilf_fields bits here, because the inode
3519 * lock must be held exclusively in order to set bits there
3520 * and the flush lock protects the ili_last_fields bits.
3521 * Set ili_logged so the flush done
3522 * routine can tell whether or not to look in the AIL.
3523 * Also, store the current LSN of the inode so that we can tell
3524 * whether the item has moved in the AIL from xfs_iflush_done().
3525 * In order to read the lsn we need the AIL lock, because
3526 * it is a 64 bit value that cannot be read atomically.
3527 */
3538 /*
3539 * Attach the function xfs_iflush_done to the inode's
3540 * buffer. This will remove the inode from the AIL
3541 * and unlock the inode's flush lock when the inode is
3542 * completely written to disk.
3543 */
3550 /*
3551 * We're flushing an inode which is not in the AIL and has
3552 * not been logged but has i_update_core set. For this
3553 * case we can use a B_DELWRI flush and immediately drop
3554 * the inode flush lock because we can avoid the whole
3555 * AIL state thing. It's OK to drop the flush lock now,
3556 * because we've already locked the buffer and to do anything
3557 * you really need both.
3558 */
3563 }
3565 }
3569 corrupt_out:
3571 }
3574 /*
3575 * Flush all inactive inodes in mp.
3576 */
3577 void
3580 {
3584 again:
3591 /* Make sure we skip markers inserted by sync */
3595 }
3602 }
3608 out:
3610 }
3612 /*
3613 * xfs_iaccess: check accessibility of inode for mode.
3614 */
3615 int
3618 mode_t mode,
3620 {
3634 }
3636 /*
3637 * If there's an Access Control List it's used instead of
3638 * the mode bits.
3639 */
3647 }
3649 /*
3650 * If the DACs are ok we don't need any capability check.
3651 */
3654 /*
3655 * Read/write DACs are always overridable.
3656 * Executable DACs are overridable if at least one exec bit is set.
3657 */
3667 #ifdef NOISE
3671 }
3673 }
3675 /*
3676 * xfs_iroundup: round up argument to next power of two
3677 */
3678 uint
3680 uint v)
3681 {
3683 uint m;
3696 }
3699 }
3701 #ifdef XFS_ILOCK_TRACE
3704 void
3706 {
3715 }
3716 #endif
3718 /*
3719 * Return a pointer to the extent record at file index idx.
3720 */
3721 xfs_bmbt_rec_host_t *
3725 {
3740 }
3741 }
3743 /*
3744 * Insert new item(s) into the extent records for incore inode
3745 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3746 */
3747 void
3753 {
3760 }
3762 /*
3763 * This is called when the amount of space required for incore file
3764 * extents needs to be increased. The ext_diff parameter stores the
3765 * number of new extents being added and the idx parameter contains
3766 * the extent index where the new extents will be added. If the new
3767 * extents are being appended, then we just need to (re)allocate and
3768 * initialize the space. Otherwise, if the new extents are being
3769 * inserted into the middle of the existing entries, a bit more work
3770 * is required to make room for the new extents to be inserted. The
3771 * caller is responsible for filling in the new extent entries upon
3772 * return.
3773 */
3774 void
3779 {
3788 /*
3789 * If the new number of extents (nextents + ext_diff)
3790 * fits inside the inode, then continue to use the inline
3791 * extent buffer.
3792 */
3799 }
3803 }
3804 /*
3805 * Otherwise use a linear (direct) extent list.
3806 * If the extents are currently inside the inode,
3807 * xfs_iext_realloc_direct will switch us from
3808 * inline to direct extent allocation mode.
3809 */
3817 }
3818 }
3819 /* Indirection array */
3832 }
3833 /* Extents fit in target extent page */
3841 }
3844 }
3845 /* Insert a new extent page */
3849 }
3850 /*
3851 * If extent(s) are being appended to the last page in
3852 * the indirection array and the new extent(s) don't fit
3853 * in the page, then erp is NULL and erp_idx is set to
3854 * the next index needed in the indirection array.
3855 */
3864 erp_idx++;
3865 }
3866 }
3867 }
3868 }
3870 }
3872 /*
3873 * This is called when incore extents are being added to the indirection
3874 * array and the new extents do not fit in the target extent list. The
3875 * erp_idx parameter contains the irec index for the target extent list
3876 * in the indirection array, and the idx parameter contains the extent
3877 * index within the list. The number of extents being added is stored
3878 * in the count parameter.
3879 *
3880 * |-------| |-------|
3881 * | | | | idx - number of extents before idx
3882 * | idx | | count |
3883 * | | | | count - number of extents being inserted at idx
3884 * |-------| |-------|
3885 * | count | | nex2 | nex2 - number of extents after idx + count
3886 * |-------| |-------|
3887 */
3888 void
3894 {
3908 /*
3909 * Save second part of target extent list
3910 * (all extents past */
3918 }
3920 /*
3921 * Add the new extents to the end of the target
3922 * list, then allocate new irec record(s) and
3923 * extent buffer(s) as needed to store the rest
3924 * of the new extents.
3925 */
3932 }
3934 erp_idx++;
3940 }
3942 /* Add nex2 extents back to indirection array */
3944 xfs_extnum_t ext_avail;
3950 /*
3951 * If nex2 extents fit in the current page, append
3952 * nex2_ep after the new extents.
3953 */
3956 }
3957 /*
3958 * Otherwise, check if space is available in the
3959 * next page.
3960 */
3964 erp_idx++;
3965 erp++;
3966 /* Create a hole for nex2 extents */
3969 }
3970 /*
3971 * Final choice, create a new extent page for
3972 * nex2 extents.
3973 */
3975 erp_idx++;
3977 }
3982 }
3983 }
3985 /*
3986 * This is called when the amount of space required for incore file
3987 * extents needs to be decreased. The ext_diff parameter stores the
3988 * number of extents to be removed and the idx parameter contains
3989 * the extent index where the extents will be removed from.
3990 *
3991 * If the amount of space needed has decreased below the linear
3992 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3993 * extent array. Otherwise, use kmem_realloc() to adjust the
3994 * size to what is needed.
3995 */
3996 void
4001 {
4017 }
4019 }
4021 /*
4022 * This removes ext_diff extents from the inline buffer, beginning
4023 * at extent index idx.
4024 */
4025 void
4030 {
4049 }
4050 }
4052 /*
4053 * This removes ext_diff extents from a linear (direct) extent list,
4054 * beginning at extent index idx. If the extents are being removed
4055 * from the end of the list (ie. truncate) then we just need to re-
4056 * allocate the list to remove the extra space. Otherwise, if the
4057 * extents are being removed from the middle of the existing extent
4058 * entries, then we first need to move the extent records beginning
4059 * at idx + ext_diff up in the list to overwrite the records being
4060 * removed, then remove the extra space via kmem_realloc.
4061 */
4062 void
4067 {
4079 }
4080 /* Move extents up in the list (if needed) */
4086 }
4089 /*
4090 * Reallocate the direct extent list. If the extents
4091 * will fit inside the inode then xfs_iext_realloc_direct
4092 * will switch from direct to inline extent allocation
4093 * mode for us.
4094 */
4097 }
4099 /*
4100 * This is called when incore extents are being removed from the
4101 * indirection array and the extents being removed span multiple extent
4102 * buffers. The idx parameter contains the file extent index where we
4103 * want to begin removing extents, and the count parameter contains
4104 * how many extents need to be removed.
4105 *
4106 * |-------| |-------|
4107 * | nex1 | | | nex1 - number of extents before idx
4108 * |-------| | count |
4109 * | | | | count - number of extents being removed at idx
4110 * | count | |-------|
4111 * | | | nex2 | nex2 - number of extents after idx + count
4112 * |-------| |-------|
4113 */
4114 void
4119 {
4138 /*
4139 * Check for deletion of entire list;
4140 * xfs_iext_irec_remove() updates extent offsets.
4141 */
4148 XFS_IEXT_BUFSZ);
4154 }
4155 }
4156 /* Move extents up (if needed) */
4161 }
4162 /* Zero out rest of page */
4165 /* Update remaining counters */
4170 erp_idx++;
4171 erp++;
4172 }
4175 }
4177 /*
4178 * Create, destroy, or resize a linear (direct) block of extents.
4179 */
4180 void
4184 {
4193 /* Free extent records */
4196 }
4197 /* Resize direct extent list and zero any new bytes */
4199 /* Check if extents will fit inside the inode */
4205 }
4208 }
4212 rnew_size,
4214 KM_SLEEP);
4215 }
4220 }
4221 }
4222 /*
4223 * Switch from the inline extent buffer to a direct
4224 * extent list. Be sure to include the inline extent
4225 * bytes in new_size.
4226 */
4231 }
4233 }
4236 }
4238 /*
4239 * Switch from linear (direct) extent records to inline buffer.
4240 */
4241 void
4245 {
4248 /*
4249 * The inline buffer was zeroed when we switched
4250 * from inline to direct extent allocation mode,
4251 * so we don't need to clear it here.
4252 */
4258 }
4260 /*
4261 * Switch from inline buffer to linear (direct) extent records.
4262 * new_size should already be rounded up to the next power of 2
4263 * by the caller (when appropriate), so use new_size as it is.
4264 * However, since new_size may be rounded up, we can't update
4265 * if_bytes here. It is the caller's responsibility to update
4266 * if_bytes upon return.
4267 */
4268 void
4272 {
4280 }
4282 }
4284 /*
4285 * Resize an extent indirection array to new_size bytes.
4286 */
4287 void
4291 {
4306 }
4307 }
4309 /*
4310 * Switch from indirection array to linear (direct) extent allocations.
4311 */
4312 void
4315 {
4335 }
4336 }
4338 /*
4339 * Free incore file extents.
4340 */
4341 void
4344 {
4352 }
4359 }
4363 }
4365 /*
4366 * Return a pointer to the extent record for file system block bno.
4367 */
4373 {
4388 }
4391 /* Find target extent list */
4399 }
4400 /* Binary search extent records */
4411 /* Convert back to file-based extent index */
4414 }
4417 }
4418 }
4419 /* Convert back to file-based extent index */
4422 }
4428 }
4429 }
4432 }
4434 /*
4435 * Return a pointer to the indirection array entry containing the
4436 * extent record for filesystem block bno. Store the index of the
4437 * target irec in *erp_idxp.
4438 */
4444 {
4468 }
4469 }
4472 }
4474 /*
4475 * Return a pointer to the indirection array entry containing the
4476 * extent record at file extent index *idxp. Store the index of the
4477 * target irec in *erp_idxp and store the page index of the target
4478 * extent record in *idxp.
4479 */
4480 xfs_ext_irec_t *
4486 {
4503 /* Binary search extent irec's */
4519 erp_idx++;
4525 }
4526 }
4530 }
4532 /*
4533 * Allocate and initialize an indirection array once the space needed
4534 * for incore extents increases above XFS_IEXT_BUFSZ.
4535 */
4536 void
4539 {
4556 }
4567 }
4569 /*
4570 * Allocate and initialize a new entry in the indirection array.
4571 */
4572 xfs_ext_irec_t *
4576 {
4584 /* Resize indirection array */
4587 /*
4588 * Move records down in the array so the
4589 * new page can use erp_idx.
4590 */
4594 }
4597 /* Initialize new extent record */
4606 }
4608 /*
4609 * Remove a record from the indirection array.
4610 */
4611 void
4615 {
4627 }
4628 /* Compact extent records */
4632 }
4633 /*
4634 * Manually free the last extent record from the indirection
4635 * array. A call to xfs_iext_realloc_indirect() with a size
4636 * of zero would result in a call to xfs_iext_destroy() which
4637 * would in turn call this function again, creating a nasty
4638 * infinite loop.
4639 */
4646 }
4648 }
4650 /*
4651 * This is called to clean up large amounts of unused memory allocated
4652 * by the indirection array. Before compacting anything though, verify
4653 * that the indirection array is still needed and switch back to the
4654 * linear extent list (or even the inline buffer) if possible. The
4655 * compaction policy is as follows:
4656 *
4657 * Full Compaction: Extents fit into a single page (or inline buffer)
4658 * Full Compaction: Extents occupy less than 10% of allocated space
4659 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4660 * No Compaction: Extents occupy at least 50% of allocated space
4661 */
4662 void
4665 {
4684 }
4685 }
4687 /*
4688 * Combine extents from neighboring extent pages.
4689 */
4690 void
4693 {
4709 /*
4710 * Free page before removing extent record
4711 * so er_extoffs don't get modified in
4712 * xfs_iext_irec_remove.
4713 */
4719 erp_idx++;
4720 }
4721 }
4722 }
4724 /*
4725 * Fully compact the extent records managed by the indirection array.
4726 */
4727 void
4730 {
4750 /* Remove next page */
4752 /*
4753 * Free page before removing extent record
4754 * so er_extoffs don't get modified in
4755 * xfs_iext_irec_remove.
4756 */
4763 /* Update next page */
4765 /* Move rest of page up to become next new page */
4772 }
4774 erp_idx++;
4777 else
4779 }
4783 }
4784 }
4786 /*
4787 * This is called to update the er_extoff field in the indirection
4788 * array when extents have been added or removed from one of the
4789 * extent lists. erp_idx contains the irec index to begin updating
4790 * at and ext_diff contains the number of extents that were added
4791 * or removed.
4792 */
4793 void
4798 {
4806 }
4807 }