| blob | 0c376bd9e173944a03a86fce2c614cbc4de62a3c |
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 */
1936 }
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 */
1961 /*
1962 * There is already another inode in the bucket we need
1963 * to add ourselves to. Add us at the front of the list.
1964 * Here we put the head pointer into our next pointer,
1965 * and then we fall through to point the head at us.
1966 */
1970 }
1972 /* both on-disk, don't endian flip twice */
1980 }
1982 /*
1983 * Point the bucket head pointer at the inode being inserted.
1984 */
1992 }
1994 /*
1995 * Pull the on-disk inode from the AGI unlinked list.
1996 */
1997 STATIC int
2001 {
2002 xfs_ino_t next_ino;
2008 xfs_agnumber_t agno;
2009 xfs_daddr_t agdaddr;
2010 xfs_agino_t agino;
2011 xfs_agino_t next_agino;
2019 /*
2020 * First pull the on-disk inode from the AGI unlinked list.
2021 */
2027 /*
2028 * Get the agi buffer first. It ensures lock ordering
2029 * on the list.
2030 */
2038 }
2039 /*
2040 * Validate the magic number of the agi block.
2041 */
2043 agi_ok =
2047 XFS_RANDOM_IUNLINK_REMOVE))) {
2055 }
2056 /*
2057 * Get the index into the agi hash table for the
2058 * list this inode will go on.
2059 */
2067 /*
2068 * We're at the head of the list. Get the inode's
2069 * on-disk buffer to see if there is anyone after us
2070 * on the list. Only modify our next pointer if it
2071 * is not already NULLAGINO. This saves us the overhead
2072 * of dealing with the buffer when there is no need to
2073 * change it.
2074 */
2081 }
2094 }
2095 /*
2096 * Point the bucket head pointer at the next inode.
2097 */
2106 /*
2107 * We need to search the list for the inode being freed.
2108 */
2112 /*
2113 * If the last inode wasn't the one pointing to
2114 * us, then release its buffer since we're not
2115 * going to do anything with it.
2116 */
2119 }
2128 }
2132 }
2133 /*
2134 * Now last_ibp points to the buffer previous to us on
2135 * the unlinked list. Pull us from the list.
2136 */
2143 }
2157 }
2158 /*
2159 * Point the previous inode on the list to the next inode.
2160 */
2168 }
2170 }
2173 {
2177 }
2179 STATIC void
2183 xfs_ino_t inum)
2184 {
2190 xfs_daddr_t blkno;
2207 }
2216 /*
2217 * Look for each inode in memory and attempt to lock it,
2218 * we can be racing with flush and tail pushing here.
2219 * any inode we get the locks on, add to an array of
2220 * inode items to process later.
2221 *
2222 * The get the buffer lock, we could beat a flush
2223 * or tail pushing thread to the lock here, in which
2224 * case they will go looking for the inode buffer
2225 * and fail, we need some other form of interlock
2226 * here.
2227 */
2234 /* Inode not in memory or we found it already,
2235 * nothing to do
2236 */
2240 }
2245 }
2247 /* If we can get the locks then add it to the
2248 * list, otherwise by the time we get the bp lock
2249 * below it will already be attached to the
2250 * inode buffer.
2251 */
2253 /* This inode will already be locked - by us, lets
2254 * keep it that way.
2255 */
2264 }
2265 }
2268 }
2279 }
2282 }
2283 }
2285 }
2289 XFS_BUF_LOCK);
2302 pre_flushed++;
2303 }
2305 }
2316 }
2330 }
2331 }
2336 }
2340 }
2342 /*
2343 * This is called to return an inode to the inode free list.
2344 * The inode should already be truncated to 0 length and have
2345 * no pages associated with it. This routine also assumes that
2346 * the inode is already a part of the transaction.
2347 *
2348 * The on-disk copy of the inode will have been added to the list
2349 * of unlinked inodes in the AGI. We need to remove the inode from
2350 * that list atomically with respect to freeing it here.
2351 */
2352 int
2357 {
2360 xfs_ino_t first_ino;
2371 /*
2372 * Pull the on-disk inode from the AGI unlinked list.
2373 */
2377 }
2382 }
2391 /*
2392 * Bump the generation count so no one will be confused
2393 * by reincarnations of this inode.
2394 */
2400 }
2403 }
2405 /*
2406 * Reallocate the space for if_broot based on the number of records
2407 * being added or deleted as indicated in rec_diff. Move the records
2408 * and pointers in if_broot to fit the new size. When shrinking this
2409 * will eliminate holes between the records and pointers created by
2410 * the caller. When growing this will create holes to be filled in
2411 * by the caller.
2412 *
2413 * The caller must not request to add more records than would fit in
2414 * the on-disk inode root. If the if_broot is currently NULL, then
2415 * if we adding records one will be allocated. The caller must also
2416 * not request that the number of records go below zero, although
2417 * it can go to zero.
2418 *
2419 * ip -- the inode whose if_broot area is changing
2420 * ext_diff -- the change in the number of records, positive or negative,
2421 * requested for the if_broot array.
2422 */
2423 void
2428 {
2437 /*
2438 * Handle the degenerate case quietly.
2439 */
2442 }
2446 /*
2447 * If there wasn't any memory allocated before, just
2448 * allocate it now and get out.
2449 */
2453 KM_SLEEP);
2456 }
2458 /*
2459 * If there is already an existing if_broot, then we need
2460 * to realloc() it and shift the pointers to their new
2461 * location. The records don't change location because
2462 * they are kept butted up against the btree block header.
2463 */
2469 new_size,
2471 KM_SLEEP);
2481 }
2483 /*
2484 * rec_diff is less than 0. In this case, we are shrinking the
2485 * if_broot buffer. It must already exist. If we go to zero
2486 * records, just get rid of the root and clear the status bit.
2487 */
2494 else
2498 /*
2499 * First copy over the btree block header.
2500 */
2505 }
2507 /*
2508 * Only copy the records and pointers if there are any.
2509 */
2511 /*
2512 * First copy the records.
2513 */
2520 /*
2521 * Then copy the pointers.
2522 */
2528 }
2535 }
2538 /*
2539 * This is called when the amount of space needed for if_data
2540 * is increased or decreased. The change in size is indicated by
2541 * the number of bytes that need to be added or deleted in the
2542 * byte_diff parameter.
2543 *
2544 * If the amount of space needed has decreased below the size of the
2545 * inline buffer, then switch to using the inline buffer. Otherwise,
2546 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2547 * to what is needed.
2548 *
2549 * ip -- the inode whose if_data area is changing
2550 * byte_diff -- the change in the number of bytes, positive or negative,
2551 * requested for the if_data array.
2552 */
2553 void
2558 {
2565 }
2574 }
2578 /*
2579 * If the valid extents/data can fit in if_inline_ext/data,
2580 * copy them from the malloc'd vector and free it.
2581 */
2587 new_size);
2590 }
2593 /*
2594 * Stuck with malloc/realloc.
2595 * For inline data, the underlying buffer must be
2596 * a multiple of 4 bytes in size so that it can be
2597 * logged and stay on word boundaries. We enforce
2598 * that here.
2599 */
2605 /*
2606 * Only do the realloc if the underlying size
2607 * is really changing.
2608 */
2612 real_size,
2614 KM_SLEEP);
2615 }
2621 }
2622 }
2626 }
2631 /*
2632 * Map inode to disk block and offset.
2633 *
2634 * mp -- the mount point structure for the current file system
2635 * tp -- the current transaction
2636 * ino -- the inode number of the inode to be located
2637 * imap -- this structure is filled in with the information necessary
2638 * to retrieve the given inode from disk
2639 * flags -- flags to pass to xfs_dilocate indicating whether or not
2640 * lookups in the inode btree were OK or not
2641 */
2642 int
2646 xfs_ino_t ino,
2648 uint flags)
2649 {
2650 xfs_fsblock_t fsbno;
2660 }
2667 }
2669 void
2673 {
2680 }
2682 /*
2683 * If the format is local, then we can't have an extents
2684 * array so just look for an inline data array. If we're
2685 * not local then we may or may not have an extents list,
2686 * so check and free it up if we do.
2687 */
2695 }
2702 }
2709 }
2710 }
2712 /*
2713 * This is called free all the memory associated with an inode.
2714 * It must free the inode itself and any buffers allocated for
2715 * if_extents/if_data and if_broot. It must also free the lock
2716 * associated with the inode.
2717 */
2718 void
2721 {
2729 }
2736 #ifdef XFS_VNODE_TRACE
2738 #endif
2739 #ifdef XFS_BMAP_TRACE
2741 #endif
2742 #ifdef XFS_BMBT_TRACE
2744 #endif
2745 #ifdef XFS_RW_TRACE
2747 #endif
2748 #ifdef XFS_ILOCK_TRACE
2750 #endif
2751 #ifdef XFS_DIR2_TRACE
2753 #endif
2755 /*
2756 * Only if we are shutting down the fs will we see an
2757 * inode still in the AIL. If it is there, we should remove
2758 * it to prevent a use-after-free from occurring.
2759 */
2770 else
2772 }
2774 }
2776 }
2779 /*
2780 * Increment the pin count of the given buffer.
2781 * This value is protected by ipinlock spinlock in the mount structure.
2782 */
2783 void
2786 {
2790 }
2792 /*
2793 * Decrement the pin count of the given inode, and wake up
2794 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2795 * inode must have been previously pinned with a call to xfs_ipin().
2796 */
2797 void
2800 {
2805 /*
2806 * If the inode is currently being reclaimed, the link between
2807 * the bhv_vnode and the xfs_inode will be broken after the
2808 * XFS_IRECLAIM* flag is set. Hence, if these flags are not
2809 * set, then we can move forward and mark the linux inode dirty
2810 * knowing that it is still valid as it won't freed until after
2811 * the bhv_vnode<->xfs_inode link is broken in xfs_reclaim. The
2812 * i_flags_lock is used to synchronise the setting of the
2813 * XFS_IRECLAIM* flags and the breaking of the link, and so we
2814 * can execute atomically w.r.t to reclaim by holding this lock
2815 * here.
2816 *
2817 * However, we still need to issue the unpin wakeup call as the
2818 * inode reclaim may be blocked waiting for the inode to become
2819 * unpinned.
2820 */
2830 /* make sync come back and flush this inode */
2833 }
2836 }
2837 }
2839 /*
2840 * This is called to wait for the given inode to be unpinned.
2841 * It will sleep until this happens. The caller must have the
2842 * inode locked in at least shared mode so that the buffer cannot
2843 * be subsequently pinned once someone is waiting for it to be
2844 * unpinned.
2845 */
2846 STATIC void
2849 {
2851 xfs_lsn_t lsn;
2857 }
2864 }
2866 /*
2867 * Give the log a push so we don't wait here too long.
2868 */
2872 }
2875 /*
2876 * xfs_iextents_copy()
2877 *
2878 * This is called to copy the REAL extents (as opposed to the delayed
2879 * allocation extents) from the inode into the given buffer. It
2880 * returns the number of bytes copied into the buffer.
2881 *
2882 * If there are no delayed allocation extents, then we can just
2883 * memcpy() the extents into the buffer. Otherwise, we need to
2884 * examine each extent in turn and skip those which are delayed.
2885 */
2886 int
2891 {
2896 xfs_fsblock_t start_block;
2906 /*
2907 * There are some delayed allocation extents in the
2908 * inode, so copy the extents one at a time and skip
2909 * the delayed ones. There must be at least one
2910 * non-delayed extent.
2911 */
2917 /*
2918 * It's a delayed allocation extent, so skip it.
2919 */
2921 }
2923 /* Translate to on disk format */
2926 dp++;
2927 copied++;
2928 }
2933 }
2935 /*
2936 * Each of the following cases stores data into the same region
2937 * of the on-disk inode, so only one of them can be valid at
2938 * any given time. While it is possible to have conflicting formats
2939 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2940 * in EXTENTS format, this can only happen when the fork has
2941 * changed formats after being modified but before being flushed.
2942 * In these cases, the format always takes precedence, because the
2943 * format indicates the current state of the fork.
2944 */
2945 /*ARGSUSED*/
2946 STATIC int
2953 {
2957 #ifdef XFS_TRANS_DEBUG
2959 #endif
2970 /*
2971 * This can happen if we gave up in iformat in an error path,
2972 * for the attribute fork.
2973 */
2977 }
2987 }
3001 whichfork);
3002 }
3011 XFS_BROOT_SIZE_ADJ));
3015 }
3022 }
3030 }
3036 }
3039 }
3041 /*
3042 * xfs_iflush() will write a modified inode's changes out to the
3043 * inode's on disk home. The caller must have the inode lock held
3044 * in at least shared mode and the inode flush semaphore must be
3045 * held as well. The inode lock will still be held upon return from
3046 * the call and the caller is free to unlock it.
3047 * The inode flush lock will be unlocked when the inode reaches the disk.
3048 * The flags indicate how the inode's buffer should be written out.
3049 */
3050 int
3053 uint flags)
3054 {
3060 /* REFERENCED */
3077 /*
3078 * If the inode isn't dirty, then just release the inode
3079 * flush lock and do nothing.
3080 */
3087 }
3089 /*
3090 * We can't flush the inode until it is unpinned, so
3091 * wait for it. We know noone new can pin it, because
3092 * we are holding the inode lock shared and you need
3093 * to hold it exclusively to pin the inode.
3094 */
3097 /*
3098 * This may have been unpinned because the filesystem is shutting
3099 * down forcibly. If that's the case we must not write this inode
3100 * to disk, because the log record didn't make it to disk!
3101 */
3108 }
3110 /*
3111 * Get the buffer containing the on-disk inode.
3112 */
3117 }
3119 /*
3120 * Decide how buffer will be flushed out. This is done before
3121 * the call to xfs_iflush_int because this field is zeroed by it.
3122 */
3124 /*
3125 * Flush out the inode buffer according to the directions
3126 * of the caller. In the cases where the caller has given
3127 * us a choice choose the non-delwri case. This is because
3128 * the inode is in the AIL and we need to get it out soon.
3129 */
3146 }
3164 }
3165 }
3167 /*
3168 * First flush out the inode that xfs_iflush was called with.
3169 */
3173 }
3175 /*
3176 * inode clustering:
3177 * see if other inodes can be gathered into this write
3178 */
3187 /*
3188 * Do an un-protected check to see if the inode is dirty and
3189 * is a candidate for flushing. These checks will be repeated
3190 * later after the appropriate locks are acquired.
3191 */
3198 }
3200 /*
3201 * Try to get locks. If any are unavailable,
3202 * then this inode cannot be flushed and is skipped.
3203 */
3205 /* get inode locks (just i_lock) */
3207 /* get inode flush lock */
3209 /* check if pinned */
3211 /* arriving here means that
3212 * this inode can be flushed.
3213 * first re-check that it's
3214 * dirty
3215 */
3220 clcount++;
3224 XFS_ILOCK_SHARED);
3226 }
3229 }
3232 }
3233 }
3235 }
3236 }
3242 }
3244 /*
3245 * If the buffer is pinned then push on the log so we won't
3246 * get stuck waiting in the write for too long.
3247 */
3250 }
3258 }
3261 corrupt_out:
3265 /*
3266 * Unlocks the flush lock
3267 */
3270 cluster_corrupt_out:
3271 /* Corruption detected in the clustering loop. Invalidate the
3272 * inode buffer and shut down the filesystem.
3273 */
3276 /*
3277 * Clean up the buffer. If it was B_DELWRI, just release it --
3278 * brelse can handle it with no problems. If not, shut down the
3279 * filesystem before releasing the buffer.
3280 */
3283 }
3288 /*
3289 * Just like incore_relse: if we have b_iodone functions,
3290 * mark the buffer as an error and call them. Otherwise
3291 * mark it as stale and brelse.
3292 */
3303 }
3304 }
3307 /*
3308 * Unlocks the flush lock
3309 */
3311 }
3314 STATIC int
3318 {
3322 #ifdef XFS_TRANS_DEBUG
3324 #endif
3336 /*
3337 * If the inode isn't dirty, then just release the inode
3338 * flush lock and do nothing.
3339 */
3344 }
3346 /* set *dip = inode's place in the buffer */
3349 /*
3350 * Clear i_update_core before copying out the data.
3351 * This is for coordination with our timestamp updates
3352 * that don't hold the inode lock. They will always
3353 * update the timestamps BEFORE setting i_update_core,
3354 * so if we clear i_update_core after they set it we
3355 * are guaranteed to see their updates to the timestamps.
3356 * I believe that this depends on strongly ordered memory
3357 * semantics, but we have that. We use the SYNCHRONIZE
3358 * macro to make sure that the compiler does not reorder
3359 * the i_update_core access below the data copy below.
3360 */
3364 /*
3365 * Make sure to get the latest atime from the Linux inode.
3366 */
3375 }
3382 }
3392 }
3403 }
3404 }
3407 XFS_RANDOM_IFLUSH_5)) {
3413 ip);
3415 }
3422 }
3423 /*
3424 * bump the flush iteration count, used to detect flushes which
3425 * postdate a log record during recovery.
3426 */
3430 /*
3431 * Copy the dirty parts of the inode into the on-disk
3432 * inode. We always copy out the core of the inode,
3433 * because if the inode is dirty at all the core must
3434 * be.
3435 */
3438 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3442 /*
3443 * If this is really an old format inode and the superblock version
3444 * has not been updated to support only new format inodes, then
3445 * convert back to the old inode format. If the superblock version
3446 * has been updated, then make the conversion permanent.
3447 */
3452 /*
3453 * Convert it back.
3454 */
3458 /*
3459 * The superblock version has already been bumped,
3460 * so just make the conversion to the new inode
3461 * format permanent.
3462 */
3471 }
3472 }
3476 }
3479 /*
3480 * The only error from xfs_iflush_fork is on the data fork.
3481 */
3483 }
3486 /*
3487 * We've recorded everything logged in the inode, so we'd
3488 * like to clear the ilf_fields bits so we don't log and
3489 * flush things unnecessarily. However, we can't stop
3490 * logging all this information until the data we've copied
3491 * into the disk buffer is written to disk. If we did we might
3492 * overwrite the copy of the inode in the log with all the
3493 * data after re-logging only part of it, and in the face of
3494 * a crash we wouldn't have all the data we need to recover.
3495 *
3496 * What we do is move the bits to the ili_last_fields field.
3497 * When logging the inode, these bits are moved back to the
3498 * ilf_fields field. In the xfs_iflush_done() routine we
3499 * clear ili_last_fields, since we know that the information
3500 * those bits represent is permanently on disk. As long as
3501 * the flush completes before the inode is logged again, then
3502 * both ilf_fields and ili_last_fields will be cleared.
3503 *
3504 * We can play with the ilf_fields bits here, because the inode
3505 * lock must be held exclusively in order to set bits there
3506 * and the flush lock protects the ili_last_fields bits.
3507 * Set ili_logged so the flush done
3508 * routine can tell whether or not to look in the AIL.
3509 * Also, store the current LSN of the inode so that we can tell
3510 * whether the item has moved in the AIL from xfs_iflush_done().
3511 * In order to read the lsn we need the AIL lock, because
3512 * it is a 64 bit value that cannot be read atomically.
3513 */
3524 /*
3525 * Attach the function xfs_iflush_done to the inode's
3526 * buffer. This will remove the inode from the AIL
3527 * and unlock the inode's flush lock when the inode is
3528 * completely written to disk.
3529 */
3536 /*
3537 * We're flushing an inode which is not in the AIL and has
3538 * not been logged but has i_update_core set. For this
3539 * case we can use a B_DELWRI flush and immediately drop
3540 * the inode flush lock because we can avoid the whole
3541 * AIL state thing. It's OK to drop the flush lock now,
3542 * because we've already locked the buffer and to do anything
3543 * you really need both.
3544 */
3549 }
3551 }
3555 corrupt_out:
3557 }
3560 /*
3561 * Flush all inactive inodes in mp.
3562 */
3563 void
3566 {
3570 again:
3577 /* Make sure we skip markers inserted by sync */
3581 }
3588 }
3594 out:
3596 }
3598 /*
3599 * xfs_iaccess: check accessibility of inode for mode.
3600 */
3601 int
3604 mode_t mode,
3606 {
3620 }
3622 /*
3623 * If there's an Access Control List it's used instead of
3624 * the mode bits.
3625 */
3633 }
3635 /*
3636 * If the DACs are ok we don't need any capability check.
3637 */
3640 /*
3641 * Read/write DACs are always overridable.
3642 * Executable DACs are overridable if at least one exec bit is set.
3643 */
3653 #ifdef NOISE
3657 }
3659 }
3661 /*
3662 * xfs_iroundup: round up argument to next power of two
3663 */
3664 uint
3666 uint v)
3667 {
3669 uint m;
3682 }
3685 }
3687 #ifdef XFS_ILOCK_TRACE
3690 void
3692 {
3701 }
3702 #endif
3704 /*
3705 * Return a pointer to the extent record at file index idx.
3706 */
3707 xfs_bmbt_rec_host_t *
3711 {
3726 }
3727 }
3729 /*
3730 * Insert new item(s) into the extent records for incore inode
3731 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3732 */
3733 void
3739 {
3746 }
3748 /*
3749 * This is called when the amount of space required for incore file
3750 * extents needs to be increased. The ext_diff parameter stores the
3751 * number of new extents being added and the idx parameter contains
3752 * the extent index where the new extents will be added. If the new
3753 * extents are being appended, then we just need to (re)allocate and
3754 * initialize the space. Otherwise, if the new extents are being
3755 * inserted into the middle of the existing entries, a bit more work
3756 * is required to make room for the new extents to be inserted. The
3757 * caller is responsible for filling in the new extent entries upon
3758 * return.
3759 */
3760 void
3765 {
3774 /*
3775 * If the new number of extents (nextents + ext_diff)
3776 * fits inside the inode, then continue to use the inline
3777 * extent buffer.
3778 */
3785 }
3789 }
3790 /*
3791 * Otherwise use a linear (direct) extent list.
3792 * If the extents are currently inside the inode,
3793 * xfs_iext_realloc_direct will switch us from
3794 * inline to direct extent allocation mode.
3795 */
3803 }
3804 }
3805 /* Indirection array */
3818 }
3819 /* Extents fit in target extent page */
3827 }
3830 }
3831 /* Insert a new extent page */
3835 }
3836 /*
3837 * If extent(s) are being appended to the last page in
3838 * the indirection array and the new extent(s) don't fit
3839 * in the page, then erp is NULL and erp_idx is set to
3840 * the next index needed in the indirection array.
3841 */
3850 erp_idx++;
3851 }
3852 }
3853 }
3854 }
3856 }
3858 /*
3859 * This is called when incore extents are being added to the indirection
3860 * array and the new extents do not fit in the target extent list. The
3861 * erp_idx parameter contains the irec index for the target extent list
3862 * in the indirection array, and the idx parameter contains the extent
3863 * index within the list. The number of extents being added is stored
3864 * in the count parameter.
3865 *
3866 * |-------| |-------|
3867 * | | | | idx - number of extents before idx
3868 * | idx | | count |
3869 * | | | | count - number of extents being inserted at idx
3870 * |-------| |-------|
3871 * | count | | nex2 | nex2 - number of extents after idx + count
3872 * |-------| |-------|
3873 */
3874 void
3880 {
3894 /*
3895 * Save second part of target extent list
3896 * (all extents past */
3904 }
3906 /*
3907 * Add the new extents to the end of the target
3908 * list, then allocate new irec record(s) and
3909 * extent buffer(s) as needed to store the rest
3910 * of the new extents.
3911 */
3918 }
3920 erp_idx++;
3926 }
3928 /* Add nex2 extents back to indirection array */
3930 xfs_extnum_t ext_avail;
3936 /*
3937 * If nex2 extents fit in the current page, append
3938 * nex2_ep after the new extents.
3939 */
3942 }
3943 /*
3944 * Otherwise, check if space is available in the
3945 * next page.
3946 */
3950 erp_idx++;
3951 erp++;
3952 /* Create a hole for nex2 extents */
3955 }
3956 /*
3957 * Final choice, create a new extent page for
3958 * nex2 extents.
3959 */
3961 erp_idx++;
3963 }
3968 }
3969 }
3971 /*
3972 * This is called when the amount of space required for incore file
3973 * extents needs to be decreased. The ext_diff parameter stores the
3974 * number of extents to be removed and the idx parameter contains
3975 * the extent index where the extents will be removed from.
3976 *
3977 * If the amount of space needed has decreased below the linear
3978 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3979 * extent array. Otherwise, use kmem_realloc() to adjust the
3980 * size to what is needed.
3981 */
3982 void
3987 {
4003 }
4005 }
4007 /*
4008 * This removes ext_diff extents from the inline buffer, beginning
4009 * at extent index idx.
4010 */
4011 void
4016 {
4035 }
4036 }
4038 /*
4039 * This removes ext_diff extents from a linear (direct) extent list,
4040 * beginning at extent index idx. If the extents are being removed
4041 * from the end of the list (ie. truncate) then we just need to re-
4042 * allocate the list to remove the extra space. Otherwise, if the
4043 * extents are being removed from the middle of the existing extent
4044 * entries, then we first need to move the extent records beginning
4045 * at idx + ext_diff up in the list to overwrite the records being
4046 * removed, then remove the extra space via kmem_realloc.
4047 */
4048 void
4053 {
4065 }
4066 /* Move extents up in the list (if needed) */
4072 }
4075 /*
4076 * Reallocate the direct extent list. If the extents
4077 * will fit inside the inode then xfs_iext_realloc_direct
4078 * will switch from direct to inline extent allocation
4079 * mode for us.
4080 */
4083 }
4085 /*
4086 * This is called when incore extents are being removed from the
4087 * indirection array and the extents being removed span multiple extent
4088 * buffers. The idx parameter contains the file extent index where we
4089 * want to begin removing extents, and the count parameter contains
4090 * how many extents need to be removed.
4091 *
4092 * |-------| |-------|
4093 * | nex1 | | | nex1 - number of extents before idx
4094 * |-------| | count |
4095 * | | | | count - number of extents being removed at idx
4096 * | count | |-------|
4097 * | | | nex2 | nex2 - number of extents after idx + count
4098 * |-------| |-------|
4099 */
4100 void
4105 {
4124 /*
4125 * Check for deletion of entire list;
4126 * xfs_iext_irec_remove() updates extent offsets.
4127 */
4134 XFS_IEXT_BUFSZ);
4140 }
4141 }
4142 /* Move extents up (if needed) */
4147 }
4148 /* Zero out rest of page */
4151 /* Update remaining counters */
4156 erp_idx++;
4157 erp++;
4158 }
4161 }
4163 /*
4164 * Create, destroy, or resize a linear (direct) block of extents.
4165 */
4166 void
4170 {
4179 /* Free extent records */
4182 }
4183 /* Resize direct extent list and zero any new bytes */
4185 /* Check if extents will fit inside the inode */
4191 }
4194 }
4198 rnew_size,
4200 KM_SLEEP);
4201 }
4206 }
4207 }
4208 /*
4209 * Switch from the inline extent buffer to a direct
4210 * extent list. Be sure to include the inline extent
4211 * bytes in new_size.
4212 */
4217 }
4219 }
4222 }
4224 /*
4225 * Switch from linear (direct) extent records to inline buffer.
4226 */
4227 void
4231 {
4234 /*
4235 * The inline buffer was zeroed when we switched
4236 * from inline to direct extent allocation mode,
4237 * so we don't need to clear it here.
4238 */
4244 }
4246 /*
4247 * Switch from inline buffer to linear (direct) extent records.
4248 * new_size should already be rounded up to the next power of 2
4249 * by the caller (when appropriate), so use new_size as it is.
4250 * However, since new_size may be rounded up, we can't update
4251 * if_bytes here. It is the caller's responsibility to update
4252 * if_bytes upon return.
4253 */
4254 void
4258 {
4266 }
4268 }
4270 /*
4271 * Resize an extent indirection array to new_size bytes.
4272 */
4273 void
4277 {
4292 }
4293 }
4295 /*
4296 * Switch from indirection array to linear (direct) extent allocations.
4297 */
4298 void
4301 {
4321 }
4322 }
4324 /*
4325 * Free incore file extents.
4326 */
4327 void
4330 {
4338 }
4345 }
4349 }
4351 /*
4352 * Return a pointer to the extent record for file system block bno.
4353 */
4359 {
4374 }
4377 /* Find target extent list */
4385 }
4386 /* Binary search extent records */
4397 /* Convert back to file-based extent index */
4400 }
4403 }
4404 }
4405 /* Convert back to file-based extent index */
4408 }
4414 }
4415 }
4418 }
4420 /*
4421 * Return a pointer to the indirection array entry containing the
4422 * extent record for filesystem block bno. Store the index of the
4423 * target irec in *erp_idxp.
4424 */
4430 {
4454 }
4455 }
4458 }
4460 /*
4461 * Return a pointer to the indirection array entry containing the
4462 * extent record at file extent index *idxp. Store the index of the
4463 * target irec in *erp_idxp and store the page index of the target
4464 * extent record in *idxp.
4465 */
4466 xfs_ext_irec_t *
4472 {
4489 /* Binary search extent irec's */
4505 erp_idx++;
4511 }
4512 }
4516 }
4518 /*
4519 * Allocate and initialize an indirection array once the space needed
4520 * for incore extents increases above XFS_IEXT_BUFSZ.
4521 */
4522 void
4525 {
4542 }
4553 }
4555 /*
4556 * Allocate and initialize a new entry in the indirection array.
4557 */
4558 xfs_ext_irec_t *
4562 {
4570 /* Resize indirection array */
4573 /*
4574 * Move records down in the array so the
4575 * new page can use erp_idx.
4576 */
4580 }
4583 /* Initialize new extent record */
4592 }
4594 /*
4595 * Remove a record from the indirection array.
4596 */
4597 void
4601 {
4613 }
4614 /* Compact extent records */
4618 }
4619 /*
4620 * Manually free the last extent record from the indirection
4621 * array. A call to xfs_iext_realloc_indirect() with a size
4622 * of zero would result in a call to xfs_iext_destroy() which
4623 * would in turn call this function again, creating a nasty
4624 * infinite loop.
4625 */
4632 }
4634 }
4636 /*
4637 * This is called to clean up large amounts of unused memory allocated
4638 * by the indirection array. Before compacting anything though, verify
4639 * that the indirection array is still needed and switch back to the
4640 * linear extent list (or even the inline buffer) if possible. The
4641 * compaction policy is as follows:
4642 *
4643 * Full Compaction: Extents fit into a single page (or inline buffer)
4644 * Full Compaction: Extents occupy less than 10% of allocated space
4645 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4646 * No Compaction: Extents occupy at least 50% of allocated space
4647 */
4648 void
4651 {
4670 }
4671 }
4673 /*
4674 * Combine extents from neighboring extent pages.
4675 */
4676 void
4679 {
4695 /*
4696 * Free page before removing extent record
4697 * so er_extoffs don't get modified in
4698 * xfs_iext_irec_remove.
4699 */
4705 erp_idx++;
4706 }
4707 }
4708 }
4710 /*
4711 * Fully compact the extent records managed by the indirection array.
4712 */
4713 void
4716 {
4736 /* Remove next page */
4738 /*
4739 * Free page before removing extent record
4740 * so er_extoffs don't get modified in
4741 * xfs_iext_irec_remove.
4742 */
4749 /* Update next page */
4751 /* Move rest of page up to become next new page */
4758 }
4760 erp_idx++;
4763 else
4765 }
4769 }
4770 }
4772 /*
4773 * This is called to update the er_extoff field in the indirection
4774 * array when extents have been added or removed from one of the
4775 * extent lists. erp_idx contains the irec index to begin updating
4776 * at and ext_diff contains the number of extents that were added
4777 * or removed.
4778 */
4779 void
4784 {
4792 }
4793 }