| blob | 3da9829c19d5e80af53be627dc8b5b1a0b594ee0 |
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 */
57 /*
58 * Used in xfs_itruncate(). This is the maximum number of extents
59 * freed from a file in a single transaction.
60 */
61 #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
79 xfs_exntfmt_t fmt)
80 {
82 xfs_bmbt_irec_t irec;
83 xfs_bmbt_rec_t rec;
92 else
96 }
97 }
99 #define xfs_validate_extents(ifp, nrecs, disk, fmt)
102 /*
103 * Check that none of the inode's in the buffer have a next
104 * unlinked field of 0.
105 */
106 #if defined(DEBUG)
107 void
111 {
123 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
124 bp);
126 }
127 }
128 }
129 #endif
131 /*
132 * This routine is called to map an inode number within a file
133 * system to the buffer containing the on-disk version of the
134 * inode. It returns a pointer to the buffer containing the
135 * on-disk inode in the bpp parameter, and in the dip parameter
136 * it returns a pointer to the on-disk inode within that buffer.
137 *
138 * If a non-zero error is returned, then the contents of bpp and
139 * dipp are undefined.
140 *
141 * Use xfs_imap() to determine the size and location of the
142 * buffer to read from disk.
143 */
144 STATIC int
148 xfs_ino_t ino,
152 {
154 xfs_imap_t imap;
159 /*
160 * Call the space management code to find the location of the
161 * inode on disk.
162 */
167 "xfs_inotobp: xfs_imap() returned an "
170 }
172 /*
173 * If the inode number maps to a block outside the bounds of the
174 * file system then return NULL rather than calling read_buf
175 * and panicing when we get an error from the driver.
176 */
180 "xfs_inotobp: inode number (%llu + %d) maps to a block outside the bounds "
185 }
187 /*
188 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
189 * default to just a read_buf() call.
190 */
196 "xfs_inotobp: xfs_trans_read_buf() returned an "
199 }
201 di_ok =
205 XFS_RANDOM_ITOBP_INOTOBP))) {
209 "xfs_inotobp: XFS_TEST_ERROR() returned an "
212 }
216 /*
217 * Set *dipp to point to the on-disk inode in the buffer.
218 */
223 }
226 /*
227 * This routine is called to map an inode to the buffer containing
228 * the on-disk version of the inode. It returns a pointer to the
229 * buffer containing the on-disk inode in the bpp parameter, and in
230 * the dip parameter it returns a pointer to the on-disk inode within
231 * that buffer.
232 *
233 * If a non-zero error is returned, then the contents of bpp and
234 * dipp are undefined.
235 *
236 * If the inode is new and has not yet been initialized, use xfs_imap()
237 * to determine the size and location of the buffer to read from disk.
238 * If the inode has already been mapped to its buffer and read in once,
239 * then use the mapping information stored in the inode rather than
240 * calling xfs_imap(). This allows us to avoid the overhead of looking
241 * at the inode btree for small block file systems (see xfs_dilocate()).
242 * We can tell whether the inode has been mapped in before by comparing
243 * its disk block address to 0. Only uninitialized inodes will have
244 * 0 for the disk block address.
245 */
246 int
253 xfs_daddr_t bno,
254 uint imap_flags)
255 {
256 xfs_imap_t imap;
263 /*
264 * Call the space management code to find the location of the
265 * inode on disk.
266 */
272 /*
273 * If the inode number maps to a block outside the bounds
274 * of the file system then return NULL rather than calling
275 * read_buf and panicing when we get an error from the
276 * driver.
277 */
280 #ifdef DEBUG
282 "(imap.im_blkno (0x%llx) "
283 "+ imap.im_len (0x%llx)) > "
284 " XFS_FSB_TO_BB(mp, "
291 }
293 /*
294 * Fill in the fields in the inode that will be used to
295 * map the inode to its buffer from now on.
296 */
301 /*
302 * We've already mapped the inode once, so just use the
303 * mapping that we saved the first time.
304 */
308 }
311 /*
312 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
313 * default to just a read_buf() call.
314 */
318 #ifdef DEBUG
320 "xfs_trans_read_buf() returned error %d, "
326 }
328 /*
329 * Validate the magic number and version of every inode in the buffer
330 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
331 * No validation is done here in userspace (xfs_repair).
332 */
333 #if !defined(__KERNEL__)
335 #elif defined(DEBUG)
339 #endif
350 XFS_ERRTAG_ITOBP_INOTOBP,
351 XFS_RANDOM_ITOBP_INOTOBP))) {
355 }
356 #ifdef DEBUG
358 "Device %s - bad inode magic/vsn "
363 #endif
368 }
369 }
373 /*
374 * Mark the buffer as an inode buffer now that it looks good
375 */
378 /*
379 * Set *dipp to point to the on-disk inode in the buffer.
380 */
384 }
386 /*
387 * Move inode type and inode format specific information from the
388 * on-disk inode to the in-core inode. For fifos, devs, and sockets
389 * this means set if_rdev to the proper value. For files, directories,
390 * and symlinks this means to bring in the in-line data or extent
391 * pointers. For a file in B-tree format, only the root is immediately
392 * brought in-core. The rest will be in-lined in if_extents when it
393 * is first referenced (see xfs_iread_extents()).
394 */
395 STATIC int
399 {
403 xfs_fsize_t di_size;
422 }
424 if (unlikely(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT) > ip->i_mount->m_sb.sb_inodesize)) {
432 }
443 }
453 /*
454 * no local regular files yet
455 */
458 "corrupt inode %Lu "
462 XFS_ERRLEVEL_LOW,
465 }
470 "corrupt inode %Lu "
475 XFS_ERRLEVEL_LOW,
478 }
493 }
499 }
502 }
524 }
529 }
531 }
533 /*
534 * The file is in-lined in the on-disk inode.
535 * If it fits into if_inline_data, then copy
536 * it there, otherwise allocate a buffer for it
537 * and copy the data there. Either way, set
538 * if_data to point at the data.
539 * If we allocate a buffer for the data, make
540 * sure that its size is a multiple of 4 and
541 * record the real size in i_real_bytes.
542 */
543 STATIC int
549 {
553 /*
554 * If the size is unreasonable, then something
555 * is wrong and we just bail out rather than crash in
556 * kmem_alloc() or memcpy() below.
557 */
560 "corrupt inode %Lu "
567 }
577 }
585 }
587 /*
588 * The file consists of a set of extents all
589 * of which fit into the on-disk inode.
590 * If there are few enough extents to fit into
591 * the if_inline_ext, then copy them there.
592 * Otherwise allocate a buffer for them and copy
593 * them into it. Either way, set if_extents
594 * to point at the extents.
595 */
596 STATIC int
601 {
612 /*
613 * If the number of extents is unreasonable, then something
614 * is wrong and we just bail out rather than crash in
615 * kmem_alloc() or memcpy() below.
616 */
624 }
631 else
641 ARCH_CONVERT);
643 ARCH_CONVERT);
644 }
646 whichfork);
652 XFS_ERRLEVEL_LOW,
655 }
656 }
659 }
661 /*
662 * The file has too many extents to fit into
663 * the inode, so they are in B-tree format.
664 * Allocate a buffer for the root of the B-tree
665 * and copy the root into it. The i_extents
666 * field will remain NULL until all of the
667 * extents are read in (when they are needed).
668 */
669 STATIC int
674 {
677 /* REFERENCED */
686 /*
687 * blow out if -- fork has less extents than can fit in
688 * fork (fork shouldn't be a btree format), root btree
689 * block has more records than can fit into the fork,
690 * or the number of extents is greater than the number of
691 * blocks.
692 */
703 }
708 /*
709 * Copy and convert from the on-disk structure
710 * to the in-memory structure.
711 */
718 }
720 /*
721 * xfs_xlate_dinode_core - translate an xfs_inode_core_t between ondisk
722 * and native format
723 *
724 * buf = on-disk representation
725 * dip = native representation
726 * dir = direction - +ve -> disk to native
727 * -ve -> native to disk
728 */
729 void
731 xfs_caddr_t buf,
734 {
757 }
784 }
786 STATIC uint
788 __uint16_t di_flags)
789 {
819 }
822 }
824 uint
827 {
832 }
834 uint
837 {
840 }
842 /*
843 * Given a mount structure and an inode number, return a pointer
844 * to a newly allocated in-core inode corresponding to the given
845 * inode number.
846 *
847 * Initialize the inode's attributes and extent pointers if it
848 * already has them (it will not if the inode has no links).
849 */
850 int
854 xfs_ino_t ino,
856 xfs_daddr_t bno,
857 uint imap_flags)
858 {
871 /*
872 * Get pointer's to the on-disk inode and the buffer containing it.
873 * If the inode number refers to a block outside the file system
874 * then xfs_itobp() will return NULL. In this case we should
875 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
876 * know that this is a new incore inode.
877 */
882 }
884 /*
885 * Initialize inode's trace buffers.
886 * Do this before xfs_iformat in case it adds entries.
887 */
888 #ifdef XFS_BMAP_TRACE
890 #endif
891 #ifdef XFS_BMBT_TRACE
893 #endif
894 #ifdef XFS_RW_TRACE
896 #endif
897 #ifdef XFS_ILOCK_TRACE
899 #endif
900 #ifdef XFS_DIR2_TRACE
902 #endif
904 /*
905 * If we got something that isn't an inode it means someone
906 * (nfs or dmi) has a stale handle.
907 */
911 #ifdef DEBUG
913 "dip->di_core.di_magic (0x%x) != "
916 XFS_DINODE_MAGIC);
919 }
921 /*
922 * If the on-disk inode is already linked to a directory
923 * entry, copy all of the inode into the in-core inode.
924 * xfs_iformat() handles copying in the inode format
925 * specific information.
926 * Otherwise, just get the truly permanent information.
927 */
935 #ifdef DEBUG
938 error);
941 }
947 /*
948 * Make sure to pull in the mode here as well in
949 * case the inode is released without being used.
950 * This ensures that xfs_inactive() will see that
951 * the inode is already free and not try to mess
952 * with the uninitialized part of it.
953 */
955 /*
956 * Initialize the per-fork minima and maxima for a new
957 * inode here. xfs_iformat will do it for old inodes.
958 */
961 }
965 /*
966 * The inode format changed when we moved the link count and
967 * made it 32 bits long. If this is an old format inode,
968 * convert it in memory to look like a new one. If it gets
969 * flushed to disk we will convert back before flushing or
970 * logging it. We zero out the new projid field and the old link
971 * count field. We'll handle clearing the pad field (the remains
972 * of the old uuid field) when we actually convert the inode to
973 * the new format. We don't change the version number so that we
974 * can distinguish this from a real new format inode.
975 */
980 }
984 /*
985 * Mark the buffer containing the inode as something to keep
986 * around for a while. This helps to keep recently accessed
987 * meta-data in-core longer.
988 */
991 /*
992 * Use xfs_trans_brelse() to release the buffer containing the
993 * on-disk inode, because it was acquired with xfs_trans_read_buf()
994 * in xfs_itobp() above. If tp is NULL, this is just a normal
995 * brelse(). If we're within a transaction, then xfs_trans_brelse()
996 * will only release the buffer if it is not dirty within the
997 * transaction. It will be OK to release the buffer in this case,
998 * because inodes on disk are never destroyed and we will be
999 * locking the new in-core inode before putting it in the hash
1000 * table where other processes can find it. Thus we don't have
1001 * to worry about the inode being changed just because we released
1002 * the buffer.
1003 */
1007 }
1009 /*
1010 * Read in extents from a btree-format inode.
1011 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
1012 */
1013 int
1018 {
1021 xfs_extnum_t nextents;
1028 }
1033 /*
1034 * We know that the size is valid (it's checked in iformat_btree)
1035 */
1045 }
1048 }
1050 /*
1051 * Allocate an inode on disk and return a copy of its in-core version.
1052 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1053 * appropriately within the inode. The uid and gid for the inode are
1054 * set according to the contents of the given cred structure.
1055 *
1056 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1057 * has a free inode available, call xfs_iget()
1058 * to obtain the in-core version of the allocated inode. Finally,
1059 * fill in the inode and log its initial contents. In this case,
1060 * ialloc_context would be set to NULL and call_again set to false.
1061 *
1062 * If xfs_dialloc() does not have an available inode,
1063 * it will replenish its supply by doing an allocation. Since we can
1064 * only do one allocation within a transaction without deadlocks, we
1065 * must commit the current transaction before returning the inode itself.
1066 * In this case, therefore, we will set call_again to true and return.
1067 * The caller should then commit the current transaction, start a new
1068 * transaction, and call xfs_ialloc() again to actually get the inode.
1069 *
1070 * To ensure that some other process does not grab the inode that
1071 * was allocated during the first call to xfs_ialloc(), this routine
1072 * also returns the [locked] bp pointing to the head of the freelist
1073 * as ialloc_context. The caller should hold this buffer across
1074 * the commit and pass it back into this routine on the second call.
1075 */
1076 int
1080 mode_t mode,
1081 xfs_nlink_t nlink,
1082 xfs_dev_t rdev,
1084 xfs_prid_t prid,
1089 {
1090 xfs_ino_t ino;
1093 uint flags;
1096 /*
1097 * Call the space management code to pick
1098 * the on-disk inode to be allocated.
1099 */
1104 }
1108 }
1111 /*
1112 * Get the in-core inode with the lock held exclusively.
1113 * This is because we're setting fields here we need
1114 * to prevent others from looking at until we're done.
1115 */
1120 }
1133 /*
1134 * If the superblock version is up to where we support new format
1135 * inodes and this is currently an old format inode, then change
1136 * the inode version number now. This way we only do the conversion
1137 * here rather than here and in the flush/logging code.
1138 */
1142 /*
1143 * We've already zeroed the old link count, the projid field,
1144 * and the pad field.
1145 */
1146 }
1148 /*
1149 * Project ids won't be stored on disk if we are using a version 1 inode.
1150 */
1158 }
1159 }
1161 /*
1162 * If the group ID of the new file does not match the effective group
1163 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1164 * (and only if the irix_sgid_inherit compatibility variable is set).
1165 */
1170 }
1176 /*
1177 * di_gen will have been taken care of in xfs_iread.
1178 */
1205 }
1210 }
1214 }
1215 }
1217 xfs_inherit_noatime)
1220 xfs_inherit_nodump)
1223 xfs_inherit_sync)
1226 xfs_inherit_nosymlinks)
1231 xfs_inherit_nodefrag)
1234 }
1235 /* FALLTHROUGH */
1244 }
1245 /*
1246 * Attribute fork settings for new inode.
1247 */
1251 /*
1252 * Log the new values stuffed into the inode.
1253 */
1256 /* now that we have an i_mode we can setup inode ops and unlock */
1261 }
1263 /*
1264 * Check to make sure that there are no blocks allocated to the
1265 * file beyond the size of the file. We don't check this for
1266 * files with fixed size extents or real time extents, but we
1267 * at least do it for regular files.
1268 */
1269 #ifdef DEBUG
1270 void
1274 xfs_fsize_t isize)
1275 {
1276 xfs_fileoff_t map_first;
1288 /*
1289 * The filesystem could be shutting down, so bmapi may return
1290 * an error.
1291 */
1295 map_first),
1301 }
1304 /*
1305 * Calculate the last possible buffered byte in a file. This must
1306 * include data that was buffered beyond the EOF by the write code.
1307 * This also needs to deal with overflowing the xfs_fsize_t type
1308 * which can happen for sizes near the limit.
1309 *
1310 * We also need to take into account any blocks beyond the EOF. It
1311 * may be the case that they were buffered by a write which failed.
1312 * In that case the pages will still be in memory, but the inode size
1313 * will never have been updated.
1314 */
1315 xfs_fsize_t
1318 {
1320 xfs_fsize_t last_byte;
1321 xfs_fileoff_t last_block;
1322 xfs_fileoff_t size_last_block;
1328 /*
1329 * Only check for blocks beyond the EOF if the extents have
1330 * been read in. This eliminates the need for the inode lock,
1331 * and it also saves us from looking when it really isn't
1332 * necessary.
1333 */
1336 XFS_DATA_FORK);
1339 }
1342 }
1349 }
1353 }
1355 }
1357 #if defined(XFS_RW_TRACE)
1358 STATIC void
1363 xfs_fsize_t new_size,
1364 xfs_off_t toss_start,
1365 xfs_off_t toss_finish)
1366 {
1369 }
1388 }
1389 #else
1390 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1391 #endif
1393 /*
1394 * Start the truncation of the file to new_size. The new size
1395 * must be smaller than the current size. This routine will
1396 * clear the buffer and page caches of file data in the removed
1397 * range, and xfs_itruncate_finish() will remove the underlying
1398 * disk blocks.
1399 *
1400 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1401 * must NOT have the inode lock held at all. This is because we're
1402 * calling into the buffer/page cache code and we can't hold the
1403 * inode lock when we do so.
1404 *
1405 * We need to wait for any direct I/Os in flight to complete before we
1406 * proceed with the truncate. This is needed to prevent the extents
1407 * being read or written by the direct I/Os from being removed while the
1408 * I/O is in flight as there is no other method of synchronising
1409 * direct I/O with the truncate operation. Also, because we hold
1410 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1411 * started until the truncate completes and drops the lock. Essentially,
1412 * the vn_iowait() call forms an I/O barrier that provides strict ordering
1413 * between direct I/Os and the truncate operation.
1414 *
1415 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1416 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1417 * in the case that the caller is locking things out of order and
1418 * may not be able to call xfs_itruncate_finish() with the inode lock
1419 * held without dropping the I/O lock. If the caller must drop the
1420 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1421 * must be called again with all the same restrictions as the initial
1422 * call.
1423 */
1424 void
1427 uint flags,
1428 xfs_fsize_t new_size)
1429 {
1430 xfs_fsize_t last_byte;
1431 xfs_off_t toss_start;
1445 /*
1446 * Call toss_pages or flushinval_pages to get rid of pages
1447 * overlapping the region being removed. We have to use
1448 * the less efficient flushinval_pages in the case that the
1449 * caller may not be able to finish the truncate without
1450 * dropping the inode's I/O lock. Make sure
1451 * to catch any pages brought in by buffers overlapping
1452 * the EOF by searching out beyond the isize by our
1453 * block size. We round new_size up to a block boundary
1454 * so that we don't toss things on the same block as
1455 * new_size but before it.
1456 *
1457 * Before calling toss_page or flushinval_pages, make sure to
1458 * call remapf() over the same region if the file is mapped.
1459 * This frees up mapped file references to the pages in the
1460 * given range and for the flushinval_pages case it ensures
1461 * that we get the latest mapped changes flushed out.
1462 */
1466 /*
1467 * The place to start tossing is beyond our maximum
1468 * file size, so there is no way that the data extended
1469 * out there.
1470 */
1472 }
1475 last_byte);
1481 }
1482 }
1484 #ifdef DEBUG
1487 }
1488 #endif
1489 }
1491 /*
1492 * Shrink the file to the given new_size. The new
1493 * size must be smaller than the current size.
1494 * This will free up the underlying blocks
1495 * in the removed range after a call to xfs_itruncate_start()
1496 * or xfs_atruncate_start().
1497 *
1498 * The transaction passed to this routine must have made
1499 * a permanent log reservation of at least XFS_ITRUNCATE_LOG_RES.
1500 * This routine may commit the given transaction and
1501 * start new ones, so make sure everything involved in
1502 * the transaction is tidy before calling here.
1503 * Some transaction will be returned to the caller to be
1504 * committed. The incoming transaction must already include
1505 * the inode, and both inode locks must be held exclusively.
1506 * The inode must also be "held" within the transaction. On
1507 * return the inode will be "held" within the returned transaction.
1508 * This routine does NOT require any disk space to be reserved
1509 * for it within the transaction.
1510 *
1511 * The fork parameter must be either xfs_attr_fork or xfs_data_fork,
1512 * and it indicates the fork which is to be truncated. For the
1513 * attribute fork we only support truncation to size 0.
1514 *
1515 * We use the sync parameter to indicate whether or not the first
1516 * transaction we perform might have to be synchronous. For the attr fork,
1517 * it needs to be so if the unlink of the inode is not yet known to be
1518 * permanent in the log. This keeps us from freeing and reusing the
1519 * blocks of the attribute fork before the unlink of the inode becomes
1520 * permanent.
1521 *
1522 * For the data fork, we normally have to run synchronously if we're
1523 * being called out of the inactive path or we're being called
1524 * out of the create path where we're truncating an existing file.
1525 * Either way, the truncate needs to be sync so blocks don't reappear
1526 * in the file with altered data in case of a crash. wsync filesystems
1527 * can run the first case async because anything that shrinks the inode
1528 * has to run sync so by the time we're called here from inactive, the
1529 * inode size is permanently set to 0.
1530 *
1531 * Calls from the truncate path always need to be sync unless we're
1532 * in a wsync filesystem and the file has already been unlinked.
1533 *
1534 * The caller is responsible for correctly setting the sync parameter.
1535 * It gets too hard for us to guess here which path we're being called
1536 * out of just based on inode state.
1537 */
1538 int
1542 xfs_fsize_t new_size,
1545 {
1546 xfs_fsblock_t first_block;
1547 xfs_fileoff_t first_unmap_block;
1548 xfs_fileoff_t last_block;
1554 xfs_bmap_free_t free_list;
1571 /*
1572 * We only support truncating the entire attribute fork.
1573 */
1576 }
1579 /*
1580 * The first thing we do is set the size to new_size permanently
1581 * on disk. This way we don't have to worry about anyone ever
1582 * being able to look at the data being freed even in the face
1583 * of a crash. What we're getting around here is the case where
1584 * we free a block, it is allocated to another file, it is written
1585 * to, and then we crash. If the new data gets written to the
1586 * file but the log buffers containing the free and reallocation
1587 * don't, then we'd end up with garbage in the blocks being freed.
1588 * As long as we make the new_size permanent before actually
1589 * freeing any blocks it doesn't matter if they get writtten to.
1590 *
1591 * The callers must signal into us whether or not the size
1592 * setting here must be synchronous. There are a few cases
1593 * where it doesn't have to be synchronous. Those cases
1594 * occur if the file is unlinked and we know the unlink is
1595 * permanent or if the blocks being truncated are guaranteed
1596 * to be beyond the inode eof (regardless of the link count)
1597 * and the eof value is permanent. Both of these cases occur
1598 * only on wsync-mounted filesystems. In those cases, we're
1599 * guaranteed that no user will ever see the data in the blocks
1600 * that are being truncated so the truncate can run async.
1601 * In the free beyond eof case, the file may wind up with
1602 * more blocks allocated to it than it needs if we crash
1603 * and that won't get fixed until the next time the file
1604 * is re-opened and closed but that's ok as that shouldn't
1605 * be too many blocks.
1606 *
1607 * However, we can't just make all wsync xactions run async
1608 * because there's one call out of the create path that needs
1609 * to run sync where it's truncating an existing file to size
1610 * 0 whose size is > 0.
1611 *
1612 * It's probably possible to come up with a test in this
1613 * routine that would correctly distinguish all the above
1614 * cases from the values of the function parameters and the
1615 * inode state but for sanity's sake, I've decided to let the
1616 * layers above just tell us. It's simpler to correctly figure
1617 * out in the layer above exactly under what conditions we
1618 * can run async and I think it's easier for others read and
1619 * follow the logic in case something has to be changed.
1620 * cscope is your friend -- rcc.
1621 *
1622 * The attribute fork is much simpler.
1623 *
1624 * For the attribute fork we allow the caller to tell us whether
1625 * the unlink of the inode that led to this call is yet permanent
1626 * in the on disk log. If it is not and we will be freeing extents
1627 * in this inode then we make the first transaction synchronous
1628 * to make sure that the unlink is permanent by the time we free
1629 * the blocks.
1630 */
1635 }
1640 }
1646 /*
1647 * Since it is possible for space to become allocated beyond
1648 * the end of the file (in a crash where the space is allocated
1649 * but the inode size is not yet updated), simply remove any
1650 * blocks which show up between the new EOF and the maximum
1651 * possible file size. If the first block to be removed is
1652 * beyond the maximum file size (ie it is the same as last_block),
1653 * then there is nothing to do.
1654 */
1662 }
1664 /*
1665 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1666 * will tell us whether it freed the entire range or
1667 * not. If this is a synchronous mount (wsync),
1668 * then we can tell bunmapi to keep all the
1669 * transactions asynchronous since the unlink
1670 * transaction that made this inode inactive has
1671 * already hit the disk. There's no danger of
1672 * the freed blocks being reused, there being a
1673 * crash, and the reused blocks suddenly reappearing
1674 * in this file with garbage in them once recovery
1675 * runs.
1676 */
1682 XFS_ITRUNC_MAX_EXTENTS,
1686 /*
1687 * If the bunmapi call encounters an error,
1688 * return to the caller where the transaction
1689 * can be properly aborted. We just need to
1690 * make sure we're not holding any resources
1691 * that we were not when we came in.
1692 */
1695 }
1697 /*
1698 * Duplicate the transaction that has the permanent
1699 * reservation and commit the old transaction.
1700 */
1704 /*
1705 * If the bmap finish call encounters an error,
1706 * return to the caller where the transaction
1707 * can be properly aborted. We just need to
1708 * make sure we're not holding any resources
1709 * that we were not when we came in.
1710 *
1711 * Aborting from this point might lose some
1712 * blocks in the file system, but oh well.
1713 */
1716 /*
1717 * If the passed in transaction committed
1718 * in xfs_bmap_finish(), then we want to
1719 * add the inode to this one before returning.
1720 * This keeps things simple for the higher
1721 * level code, because it always knows that
1722 * the inode is locked and held in the
1723 * transaction that returns to it whether
1724 * errors occur or not. We don't mark the
1725 * inode dirty so that this transaction can
1726 * be easily aborted if possible.
1727 */
1731 }
1733 }
1736 /*
1737 * The first xact was committed,
1738 * so add the inode to the new one.
1739 * Mark it dirty so it will be logged
1740 * and moved forward in the log as
1741 * part of every commit.
1742 */
1747 }
1752 XFS_TRANS_PERM_LOG_RES,
1753 XFS_ITRUNCATE_LOG_COUNT);
1754 /*
1755 * Add the inode being truncated to the next chained
1756 * transaction.
1757 */
1762 }
1763 /*
1764 * Only update the size in the case of the data fork, but
1765 * always re-log the inode so that our permanent transaction
1766 * can keep on rolling it forward in the log.
1767 */
1771 }
1781 }
1784 /*
1785 * xfs_igrow_start
1786 *
1787 * Do the first part of growing a file: zero any data in the last
1788 * block that is beyond the old EOF. We need to do this before
1789 * the inode is joined to the transaction to modify the i_size.
1790 * That way we can drop the inode lock and call into the buffer
1791 * cache to get the buffer mapping the EOF.
1792 */
1793 int
1796 xfs_fsize_t new_size,
1798 {
1805 /*
1806 * Zero any pages that may have been created by
1807 * xfs_write_file() beyond the end of the file
1808 * and any blocks between the old and new file sizes.
1809 */
1813 }
1815 /*
1816 * xfs_igrow_finish
1817 *
1818 * This routine is called to extend the size of a file.
1819 * The inode must have both the iolock and the ilock locked
1820 * for update and it must be a part of the current transaction.
1821 * The xfs_igrow_start() function must have been called previously.
1822 * If the change_flag is not zero, the inode change timestamp will
1823 * be updated.
1824 */
1825 void
1829 xfs_fsize_t new_size,
1831 {
1837 /*
1838 * Update the file size. Update the inode change timestamp
1839 * if change_flag set.
1840 */
1846 }
1849 /*
1850 * This is called when the inode's link count goes to 0.
1851 * We place the on-disk inode on a list in the AGI. It
1852 * will be pulled from this list when the inode is freed.
1853 */
1854 int
1858 {
1864 xfs_agnumber_t agno;
1865 xfs_daddr_t agdaddr;
1866 xfs_agino_t agino;
1881 /*
1882 * Get the agi buffer first. It ensures lock ordering
1883 * on the list.
1884 */
1889 }
1890 /*
1891 * Validate the magic number of the agi block.
1892 */
1894 agi_ok =
1898 XFS_RANDOM_IUNLINK))) {
1902 }
1903 /*
1904 * Get the index into the agi hash table for the
1905 * list this inode will go on.
1906 */
1914 /*
1915 * There is already another inode in the bucket we need
1916 * to add ourselves to. Add us at the front of the list.
1917 * Here we put the head pointer into our next pointer,
1918 * and then we fall through to point the head at us.
1919 */
1923 }
1926 /* both on-disk, don't endian flip twice */
1934 }
1936 /*
1937 * Point the bucket head pointer at the inode being inserted.
1938 */
1946 }
1948 /*
1949 * Pull the on-disk inode from the AGI unlinked list.
1950 */
1951 STATIC int
1955 {
1956 xfs_ino_t next_ino;
1962 xfs_agnumber_t agno;
1963 xfs_daddr_t agdaddr;
1964 xfs_agino_t agino;
1965 xfs_agino_t next_agino;
1973 /*
1974 * First pull the on-disk inode from the AGI unlinked list.
1975 */
1981 /*
1982 * Get the agi buffer first. It ensures lock ordering
1983 * on the list.
1984 */
1992 }
1993 /*
1994 * Validate the magic number of the agi block.
1995 */
1997 agi_ok =
2001 XFS_RANDOM_IUNLINK_REMOVE))) {
2009 }
2010 /*
2011 * Get the index into the agi hash table for the
2012 * list this inode will go on.
2013 */
2021 /*
2022 * We're at the head of the list. Get the inode's
2023 * on-disk buffer to see if there is anyone after us
2024 * on the list. Only modify our next pointer if it
2025 * is not already NULLAGINO. This saves us the overhead
2026 * of dealing with the buffer when there is no need to
2027 * change it.
2028 */
2035 }
2048 }
2049 /*
2050 * Point the bucket head pointer at the next inode.
2051 */
2060 /*
2061 * We need to search the list for the inode being freed.
2062 */
2066 /*
2067 * If the last inode wasn't the one pointing to
2068 * us, then release its buffer since we're not
2069 * going to do anything with it.
2070 */
2073 }
2082 }
2086 }
2087 /*
2088 * Now last_ibp points to the buffer previous to us on
2089 * the unlinked list. Pull us from the list.
2090 */
2097 }
2111 }
2112 /*
2113 * Point the previous inode on the list to the next inode.
2114 */
2122 }
2124 }
2127 {
2131 }
2133 STATIC void
2137 xfs_ino_t inum)
2138 {
2144 xfs_daddr_t blkno;
2161 }
2170 /*
2171 * Look for each inode in memory and attempt to lock it,
2172 * we can be racing with flush and tail pushing here.
2173 * any inode we get the locks on, add to an array of
2174 * inode items to process later.
2175 *
2176 * The get the buffer lock, we could beat a flush
2177 * or tail pushing thread to the lock here, in which
2178 * case they will go looking for the inode buffer
2179 * and fail, we need some other form of interlock
2180 * here.
2181 */
2189 }
2191 /* Inode not in memory or we found it already,
2192 * nothing to do
2193 */
2197 }
2202 }
2204 /* If we can get the locks then add it to the
2205 * list, otherwise by the time we get the bp lock
2206 * below it will already be attached to the
2207 * inode buffer.
2208 */
2210 /* This inode will already be locked - by us, lets
2211 * keep it that way.
2212 */
2221 }
2222 }
2225 }
2236 }
2239 }
2240 }
2243 }
2247 XFS_BUF_LOCK);
2260 pre_flushed++;
2261 }
2263 }
2274 }
2288 }
2289 }
2294 }
2297 }
2299 /*
2300 * This is called to return an inode to the inode free list.
2301 * The inode should already be truncated to 0 length and have
2302 * no pages associated with it. This routine also assumes that
2303 * the inode is already a part of the transaction.
2304 *
2305 * The on-disk copy of the inode will have been added to the list
2306 * of unlinked inodes in the AGI. We need to remove the inode from
2307 * that list atomically with respect to freeing it here.
2308 */
2309 int
2314 {
2317 xfs_ino_t first_ino;
2328 /*
2329 * Pull the on-disk inode from the AGI unlinked list.
2330 */
2334 }
2339 }
2348 /*
2349 * Bump the generation count so no one will be confused
2350 * by reincarnations of this inode.
2351 */
2357 }
2360 }
2362 /*
2363 * Reallocate the space for if_broot based on the number of records
2364 * being added or deleted as indicated in rec_diff. Move the records
2365 * and pointers in if_broot to fit the new size. When shrinking this
2366 * will eliminate holes between the records and pointers created by
2367 * the caller. When growing this will create holes to be filled in
2368 * by the caller.
2369 *
2370 * The caller must not request to add more records than would fit in
2371 * the on-disk inode root. If the if_broot is currently NULL, then
2372 * if we adding records one will be allocated. The caller must also
2373 * not request that the number of records go below zero, although
2374 * it can go to zero.
2375 *
2376 * ip -- the inode whose if_broot area is changing
2377 * ext_diff -- the change in the number of records, positive or negative,
2378 * requested for the if_broot array.
2379 */
2380 void
2385 {
2394 /*
2395 * Handle the degenerate case quietly.
2396 */
2399 }
2403 /*
2404 * If there wasn't any memory allocated before, just
2405 * allocate it now and get out.
2406 */
2410 KM_SLEEP);
2413 }
2415 /*
2416 * If there is already an existing if_broot, then we need
2417 * to realloc() it and shift the pointers to their new
2418 * location. The records don't change location because
2419 * they are kept butted up against the btree block header.
2420 */
2426 new_size,
2428 KM_SLEEP);
2438 }
2440 /*
2441 * rec_diff is less than 0. In this case, we are shrinking the
2442 * if_broot buffer. It must already exist. If we go to zero
2443 * records, just get rid of the root and clear the status bit.
2444 */
2451 else
2455 /*
2456 * First copy over the btree block header.
2457 */
2462 }
2464 /*
2465 * Only copy the records and pointers if there are any.
2466 */
2468 /*
2469 * First copy the records.
2470 */
2477 /*
2478 * Then copy the pointers.
2479 */
2485 }
2492 }
2495 /*
2496 * This is called when the amount of space needed for if_data
2497 * is increased or decreased. The change in size is indicated by
2498 * the number of bytes that need to be added or deleted in the
2499 * byte_diff parameter.
2500 *
2501 * If the amount of space needed has decreased below the size of the
2502 * inline buffer, then switch to using the inline buffer. Otherwise,
2503 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2504 * to what is needed.
2505 *
2506 * ip -- the inode whose if_data area is changing
2507 * byte_diff -- the change in the number of bytes, positive or negative,
2508 * requested for the if_data array.
2509 */
2510 void
2515 {
2522 }
2531 }
2535 /*
2536 * If the valid extents/data can fit in if_inline_ext/data,
2537 * copy them from the malloc'd vector and free it.
2538 */
2544 new_size);
2547 }
2550 /*
2551 * Stuck with malloc/realloc.
2552 * For inline data, the underlying buffer must be
2553 * a multiple of 4 bytes in size so that it can be
2554 * logged and stay on word boundaries. We enforce
2555 * that here.
2556 */
2562 /*
2563 * Only do the realloc if the underlying size
2564 * is really changing.
2565 */
2569 real_size,
2571 KM_SLEEP);
2572 }
2578 }
2579 }
2583 }
2588 /*
2589 * Map inode to disk block and offset.
2590 *
2591 * mp -- the mount point structure for the current file system
2592 * tp -- the current transaction
2593 * ino -- the inode number of the inode to be located
2594 * imap -- this structure is filled in with the information necessary
2595 * to retrieve the given inode from disk
2596 * flags -- flags to pass to xfs_dilocate indicating whether or not
2597 * lookups in the inode btree were OK or not
2598 */
2599 int
2603 xfs_ino_t ino,
2605 uint flags)
2606 {
2607 xfs_fsblock_t fsbno;
2617 }
2624 }
2626 void
2630 {
2637 }
2639 /*
2640 * If the format is local, then we can't have an extents
2641 * array so just look for an inline data array. If we're
2642 * not local then we may or may not have an extents list,
2643 * so check and free it up if we do.
2644 */
2652 }
2659 }
2666 }
2667 }
2669 /*
2670 * This is called free all the memory associated with an inode.
2671 * It must free the inode itself and any buffers allocated for
2672 * if_extents/if_data and if_broot. It must also free the lock
2673 * associated with the inode.
2674 */
2675 void
2678 {
2686 }
2692 #ifdef XFS_BMAP_TRACE
2694 #endif
2695 #ifdef XFS_BMBT_TRACE
2697 #endif
2698 #ifdef XFS_RW_TRACE
2700 #endif
2701 #ifdef XFS_ILOCK_TRACE
2703 #endif
2704 #ifdef XFS_DIR2_TRACE
2706 #endif
2708 /*
2709 * Only if we are shutting down the fs will we see an
2710 * inode still in the AIL. If it is there, we should remove
2711 * it to prevent a use-after-free from occurring.
2712 */
2723 else
2725 }
2727 }
2729 }
2732 /*
2733 * Increment the pin count of the given buffer.
2734 * This value is protected by ipinlock spinlock in the mount structure.
2735 */
2736 void
2739 {
2743 }
2745 /*
2746 * Decrement the pin count of the given inode, and wake up
2747 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2748 * inode must have been previously pinned with a call to xfs_ipin().
2749 */
2750 void
2753 {
2758 /*
2759 * If the inode is currently being reclaimed, the link between
2760 * the bhv_vnode and the xfs_inode will be broken after the
2761 * XFS_IRECLAIM* flag is set. Hence, if these flags are not
2762 * set, then we can move forward and mark the linux inode dirty
2763 * knowing that it is still valid as it won't freed until after
2764 * the bhv_vnode<->xfs_inode link is broken in xfs_reclaim. The
2765 * i_flags_lock is used to synchronise the setting of the
2766 * XFS_IRECLAIM* flags and the breaking of the link, and so we
2767 * can execute atomically w.r.t to reclaim by holding this lock
2768 * here.
2769 *
2770 * However, we still need to issue the unpin wakeup call as the
2771 * inode reclaim may be blocked waiting for the inode to become
2772 * unpinned.
2773 */
2783 /* make sync come back and flush this inode */
2786 }
2789 }
2790 }
2792 /*
2793 * This is called to wait for the given inode to be unpinned.
2794 * It will sleep until this happens. The caller must have the
2795 * inode locked in at least shared mode so that the buffer cannot
2796 * be subsequently pinned once someone is waiting for it to be
2797 * unpinned.
2798 */
2799 STATIC void
2802 {
2804 xfs_lsn_t lsn;
2810 }
2817 }
2819 /*
2820 * Give the log a push so we don't wait here too long.
2821 */
2825 }
2828 /*
2829 * xfs_iextents_copy()
2830 *
2831 * This is called to copy the REAL extents (as opposed to the delayed
2832 * allocation extents) from the inode into the given buffer. It
2833 * returns the number of bytes copied into the buffer.
2834 *
2835 * If there are no delayed allocation extents, then we can just
2836 * memcpy() the extents into the buffer. Otherwise, we need to
2837 * examine each extent in turn and skip those which are delayed.
2838 */
2839 int
2844 {
2848 #ifdef XFS_BMAP_TRACE
2850 #endif
2854 xfs_fsblock_t start_block;
2864 /*
2865 * There are some delayed allocation extents in the
2866 * inode, so copy the extents one at a time and skip
2867 * the delayed ones. There must be at least one
2868 * non-delayed extent.
2869 */
2876 /*
2877 * It's a delayed allocation extent, so skip it.
2878 */
2880 }
2882 /* Translate to on disk format */
2887 dest_ep++;
2888 copied++;
2889 }
2894 }
2896 /*
2897 * Each of the following cases stores data into the same region
2898 * of the on-disk inode, so only one of them can be valid at
2899 * any given time. While it is possible to have conflicting formats
2900 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2901 * in EXTENTS format, this can only happen when the fork has
2902 * changed formats after being modified but before being flushed.
2903 * In these cases, the format always takes precedence, because the
2904 * format indicates the current state of the fork.
2905 */
2906 /*ARGSUSED*/
2907 STATIC int
2914 {
2918 #ifdef XFS_TRANS_DEBUG
2920 #endif
2931 /*
2932 * This can happen if we gave up in iformat in an error path,
2933 * for the attribute fork.
2934 */
2938 }
2948 }
2962 whichfork);
2963 }
2972 XFS_BROOT_SIZE_ADJ));
2976 }
2983 }
2991 }
2997 }
3000 }
3002 /*
3003 * xfs_iflush() will write a modified inode's changes out to the
3004 * inode's on disk home. The caller must have the inode lock held
3005 * in at least shared mode and the inode flush semaphore must be
3006 * held as well. The inode lock will still be held upon return from
3007 * the call and the caller is free to unlock it.
3008 * The inode flush lock will be unlocked when the inode reaches the disk.
3009 * The flags indicate how the inode's buffer should be written out.
3010 */
3011 int
3014 uint flags)
3015 {
3021 /* REFERENCED */
3039 /*
3040 * If the inode isn't dirty, then just release the inode
3041 * flush lock and do nothing.
3042 */
3049 }
3051 /*
3052 * We can't flush the inode until it is unpinned, so
3053 * wait for it. We know noone new can pin it, because
3054 * we are holding the inode lock shared and you need
3055 * to hold it exclusively to pin the inode.
3056 */
3059 /*
3060 * This may have been unpinned because the filesystem is shutting
3061 * down forcibly. If that's the case we must not write this inode
3062 * to disk, because the log record didn't make it to disk!
3063 */
3070 }
3072 /*
3073 * Get the buffer containing the on-disk inode.
3074 */
3079 }
3081 /*
3082 * Decide how buffer will be flushed out. This is done before
3083 * the call to xfs_iflush_int because this field is zeroed by it.
3084 */
3086 /*
3087 * Flush out the inode buffer according to the directions
3088 * of the caller. In the cases where the caller has given
3089 * us a choice choose the non-delwri case. This is because
3090 * the inode is in the AIL and we need to get it out soon.
3091 */
3108 }
3126 }
3127 }
3129 /*
3130 * First flush out the inode that xfs_iflush was called with.
3131 */
3135 }
3137 /*
3138 * inode clustering:
3139 * see if other inodes can be gathered into this write
3140 */
3149 /*
3150 * Do an un-protected check to see if the inode is dirty and
3151 * is a candidate for flushing. These checks will be repeated
3152 * later after the appropriate locks are acquired.
3153 */
3160 }
3162 /*
3163 * Try to get locks. If any are unavailable,
3164 * then this inode cannot be flushed and is skipped.
3165 */
3167 /* get inode locks (just i_lock) */
3169 /* get inode flush lock */
3171 /* check if pinned */
3173 /* arriving here means that
3174 * this inode can be flushed.
3175 * first re-check that it's
3176 * dirty
3177 */
3182 clcount++;
3186 XFS_ILOCK_SHARED);
3188 }
3191 }
3194 }
3195 }
3197 }
3198 }
3204 }
3206 /*
3207 * If the buffer is pinned then push on the log so we won't
3208 * get stuck waiting in the write for too long.
3209 */
3212 }
3220 }
3223 corrupt_out:
3227 /*
3228 * Unlocks the flush lock
3229 */
3232 cluster_corrupt_out:
3233 /* Corruption detected in the clustering loop. Invalidate the
3234 * inode buffer and shut down the filesystem.
3235 */
3238 /*
3239 * Clean up the buffer. If it was B_DELWRI, just release it --
3240 * brelse can handle it with no problems. If not, shut down the
3241 * filesystem before releasing the buffer.
3242 */
3245 }
3250 /*
3251 * Just like incore_relse: if we have b_iodone functions,
3252 * mark the buffer as an error and call them. Otherwise
3253 * mark it as stale and brelse.
3254 */
3265 }
3266 }
3269 /*
3270 * Unlocks the flush lock
3271 */
3273 }
3276 STATIC int
3280 {
3284 #ifdef XFS_TRANS_DEBUG
3286 #endif
3298 /*
3299 * If the inode isn't dirty, then just release the inode
3300 * flush lock and do nothing.
3301 */
3306 }
3308 /* set *dip = inode's place in the buffer */
3311 /*
3312 * Clear i_update_core before copying out the data.
3313 * This is for coordination with our timestamp updates
3314 * that don't hold the inode lock. They will always
3315 * update the timestamps BEFORE setting i_update_core,
3316 * so if we clear i_update_core after they set it we
3317 * are guaranteed to see their updates to the timestamps.
3318 * I believe that this depends on strongly ordered memory
3319 * semantics, but we have that. We use the SYNCHRONIZE
3320 * macro to make sure that the compiler does not reorder
3321 * the i_update_core access below the data copy below.
3322 */
3326 /*
3327 * Make sure to get the latest atime from the Linux inode.
3328 */
3337 }
3344 }
3354 }
3365 }
3366 }
3369 XFS_RANDOM_IFLUSH_5)) {
3375 ip);
3377 }
3384 }
3385 /*
3386 * bump the flush iteration count, used to detect flushes which
3387 * postdate a log record during recovery.
3388 */
3392 /*
3393 * Copy the dirty parts of the inode into the on-disk
3394 * inode. We always copy out the core of the inode,
3395 * because if the inode is dirty at all the core must
3396 * be.
3397 */
3400 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3404 /*
3405 * If this is really an old format inode and the superblock version
3406 * has not been updated to support only new format inodes, then
3407 * convert back to the old inode format. If the superblock version
3408 * has been updated, then make the conversion permanent.
3409 */
3414 /*
3415 * Convert it back.
3416 */
3420 /*
3421 * The superblock version has already been bumped,
3422 * so just make the conversion to the new inode
3423 * format permanent.
3424 */
3433 }
3434 }
3438 }
3441 /*
3442 * The only error from xfs_iflush_fork is on the data fork.
3443 */
3445 }
3448 /*
3449 * We've recorded everything logged in the inode, so we'd
3450 * like to clear the ilf_fields bits so we don't log and
3451 * flush things unnecessarily. However, we can't stop
3452 * logging all this information until the data we've copied
3453 * into the disk buffer is written to disk. If we did we might
3454 * overwrite the copy of the inode in the log with all the
3455 * data after re-logging only part of it, and in the face of
3456 * a crash we wouldn't have all the data we need to recover.
3457 *
3458 * What we do is move the bits to the ili_last_fields field.
3459 * When logging the inode, these bits are moved back to the
3460 * ilf_fields field. In the xfs_iflush_done() routine we
3461 * clear ili_last_fields, since we know that the information
3462 * those bits represent is permanently on disk. As long as
3463 * the flush completes before the inode is logged again, then
3464 * both ilf_fields and ili_last_fields will be cleared.
3465 *
3466 * We can play with the ilf_fields bits here, because the inode
3467 * lock must be held exclusively in order to set bits there
3468 * and the flush lock protects the ili_last_fields bits.
3469 * Set ili_logged so the flush done
3470 * routine can tell whether or not to look in the AIL.
3471 * Also, store the current LSN of the inode so that we can tell
3472 * whether the item has moved in the AIL from xfs_iflush_done().
3473 * In order to read the lsn we need the AIL lock, because
3474 * it is a 64 bit value that cannot be read atomically.
3475 */
3486 /*
3487 * Attach the function xfs_iflush_done to the inode's
3488 * buffer. This will remove the inode from the AIL
3489 * and unlock the inode's flush lock when the inode is
3490 * completely written to disk.
3491 */
3498 /*
3499 * We're flushing an inode which is not in the AIL and has
3500 * not been logged but has i_update_core set. For this
3501 * case we can use a B_DELWRI flush and immediately drop
3502 * the inode flush lock because we can avoid the whole
3503 * AIL state thing. It's OK to drop the flush lock now,
3504 * because we've already locked the buffer and to do anything
3505 * you really need both.
3506 */
3511 }
3513 }
3517 corrupt_out:
3519 }
3522 /*
3523 * Flush all inactive inodes in mp.
3524 */
3525 void
3528 {
3532 again:
3539 /* Make sure we skip markers inserted by sync */
3543 }
3550 }
3556 out:
3558 }
3560 /*
3561 * xfs_iaccess: check accessibility of inode for mode.
3562 */
3563 int
3566 mode_t mode,
3568 {
3582 }
3584 /*
3585 * If there's an Access Control List it's used instead of
3586 * the mode bits.
3587 */
3595 }
3597 /*
3598 * If the DACs are ok we don't need any capability check.
3599 */
3602 /*
3603 * Read/write DACs are always overridable.
3604 * Executable DACs are overridable if at least one exec bit is set.
3605 */
3615 #ifdef NOISE
3619 }
3621 }
3623 /*
3624 * xfs_iroundup: round up argument to next power of two
3625 */
3626 uint
3628 uint v)
3629 {
3631 uint m;
3644 }
3647 }
3649 #ifdef XFS_ILOCK_TRACE
3652 void
3654 {
3663 }
3664 #endif
3666 /*
3667 * Return a pointer to the extent record at file index idx.
3668 */
3669 xfs_bmbt_rec_t *
3673 {
3688 }
3689 }
3691 /*
3692 * Insert new item(s) into the extent records for incore inode
3693 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3694 */
3695 void
3701 {
3710 }
3711 }
3713 /*
3714 * This is called when the amount of space required for incore file
3715 * extents needs to be increased. The ext_diff parameter stores the
3716 * number of new extents being added and the idx parameter contains
3717 * the extent index where the new extents will be added. If the new
3718 * extents are being appended, then we just need to (re)allocate and
3719 * initialize the space. Otherwise, if the new extents are being
3720 * inserted into the middle of the existing entries, a bit more work
3721 * is required to make room for the new extents to be inserted. The
3722 * caller is responsible for filling in the new extent entries upon
3723 * return.
3724 */
3725 void
3730 {
3739 /*
3740 * If the new number of extents (nextents + ext_diff)
3741 * fits inside the inode, then continue to use the inline
3742 * extent buffer.
3743 */
3750 }
3754 }
3755 /*
3756 * Otherwise use a linear (direct) extent list.
3757 * If the extents are currently inside the inode,
3758 * xfs_iext_realloc_direct will switch us from
3759 * inline to direct extent allocation mode.
3760 */
3768 }
3769 }
3770 /* Indirection array */
3783 }
3784 /* Extents fit in target extent page */
3792 }
3795 }
3796 /* Insert a new extent page */
3800 }
3801 /*
3802 * If extent(s) are being appended to the last page in
3803 * the indirection array and the new extent(s) don't fit
3804 * in the page, then erp is NULL and erp_idx is set to
3805 * the next index needed in the indirection array.
3806 */
3815 erp_idx++;
3816 }
3817 }
3818 }
3819 }
3821 }
3823 /*
3824 * This is called when incore extents are being added to the indirection
3825 * array and the new extents do not fit in the target extent list. The
3826 * erp_idx parameter contains the irec index for the target extent list
3827 * in the indirection array, and the idx parameter contains the extent
3828 * index within the list. The number of extents being added is stored
3829 * in the count parameter.
3830 *
3831 * |-------| |-------|
3832 * | | | | idx - number of extents before idx
3833 * | idx | | count |
3834 * | | | | count - number of extents being inserted at idx
3835 * |-------| |-------|
3836 * | count | | nex2 | nex2 - number of extents after idx + count
3837 * |-------| |-------|
3838 */
3839 void
3845 {
3859 /*
3860 * Save second part of target extent list
3861 * (all extents past */
3869 }
3871 /*
3872 * Add the new extents to the end of the target
3873 * list, then allocate new irec record(s) and
3874 * extent buffer(s) as needed to store the rest
3875 * of the new extents.
3876 */
3883 }
3885 erp_idx++;
3891 }
3893 /* Add nex2 extents back to indirection array */
3895 xfs_extnum_t ext_avail;
3901 /*
3902 * If nex2 extents fit in the current page, append
3903 * nex2_ep after the new extents.
3904 */
3907 }
3908 /*
3909 * Otherwise, check if space is available in the
3910 * next page.
3911 */
3915 erp_idx++;
3916 erp++;
3917 /* Create a hole for nex2 extents */
3920 }
3921 /*
3922 * Final choice, create a new extent page for
3923 * nex2 extents.
3924 */
3926 erp_idx++;
3928 }
3933 }
3934 }
3936 /*
3937 * This is called when the amount of space required for incore file
3938 * extents needs to be decreased. The ext_diff parameter stores the
3939 * number of extents to be removed and the idx parameter contains
3940 * the extent index where the extents will be removed from.
3941 *
3942 * If the amount of space needed has decreased below the linear
3943 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3944 * extent array. Otherwise, use kmem_realloc() to adjust the
3945 * size to what is needed.
3946 */
3947 void
3952 {
3968 }
3970 }
3972 /*
3973 * This removes ext_diff extents from the inline buffer, beginning
3974 * at extent index idx.
3975 */
3976 void
3981 {
4000 }
4001 }
4003 /*
4004 * This removes ext_diff extents from a linear (direct) extent list,
4005 * beginning at extent index idx. If the extents are being removed
4006 * from the end of the list (ie. truncate) then we just need to re-
4007 * allocate the list to remove the extra space. Otherwise, if the
4008 * extents are being removed from the middle of the existing extent
4009 * entries, then we first need to move the extent records beginning
4010 * at idx + ext_diff up in the list to overwrite the records being
4011 * removed, then remove the extra space via kmem_realloc.
4012 */
4013 void
4018 {
4030 }
4031 /* Move extents up in the list (if needed) */
4037 }
4040 /*
4041 * Reallocate the direct extent list. If the extents
4042 * will fit inside the inode then xfs_iext_realloc_direct
4043 * will switch from direct to inline extent allocation
4044 * mode for us.
4045 */
4048 }
4050 /*
4051 * This is called when incore extents are being removed from the
4052 * indirection array and the extents being removed span multiple extent
4053 * buffers. The idx parameter contains the file extent index where we
4054 * want to begin removing extents, and the count parameter contains
4055 * how many extents need to be removed.
4056 *
4057 * |-------| |-------|
4058 * | nex1 | | | nex1 - number of extents before idx
4059 * |-------| | count |
4060 * | | | | count - number of extents being removed at idx
4061 * | count | |-------|
4062 * | | | nex2 | nex2 - number of extents after idx + count
4063 * |-------| |-------|
4064 */
4065 void
4070 {
4089 /*
4090 * Check for deletion of entire list;
4091 * xfs_iext_irec_remove() updates extent offsets.
4092 */
4099 XFS_IEXT_BUFSZ);
4105 }
4106 }
4107 /* Move extents up (if needed) */
4112 }
4113 /* Zero out rest of page */
4116 /* Update remaining counters */
4121 erp_idx++;
4122 erp++;
4123 }
4126 }
4128 /*
4129 * Create, destroy, or resize a linear (direct) block of extents.
4130 */
4131 void
4135 {
4144 /* Free extent records */
4147 }
4148 /* Resize direct extent list and zero any new bytes */
4150 /* Check if extents will fit inside the inode */
4156 }
4159 }
4163 rnew_size,
4165 KM_SLEEP);
4166 }
4171 }
4172 }
4173 /*
4174 * Switch from the inline extent buffer to a direct
4175 * extent list. Be sure to include the inline extent
4176 * bytes in new_size.
4177 */
4182 }
4184 }
4187 }
4189 /*
4190 * Switch from linear (direct) extent records to inline buffer.
4191 */
4192 void
4196 {
4199 /*
4200 * The inline buffer was zeroed when we switched
4201 * from inline to direct extent allocation mode,
4202 * so we don't need to clear it here.
4203 */
4209 }
4211 /*
4212 * Switch from inline buffer to linear (direct) extent records.
4213 * new_size should already be rounded up to the next power of 2
4214 * by the caller (when appropriate), so use new_size as it is.
4215 * However, since new_size may be rounded up, we can't update
4216 * if_bytes here. It is the caller's responsibility to update
4217 * if_bytes upon return.
4218 */
4219 void
4223 {
4232 }
4234 }
4236 /*
4237 * Resize an extent indirection array to new_size bytes.
4238 */
4239 void
4243 {
4258 }
4259 }
4261 /*
4262 * Switch from indirection array to linear (direct) extent allocations.
4263 */
4264 void
4267 {
4287 }
4288 }
4290 /*
4291 * Free incore file extents.
4292 */
4293 void
4296 {
4304 }
4311 }
4315 }
4317 /*
4318 * Return a pointer to the extent record for file system block bno.
4319 */
4325 {
4340 }
4343 /* Find target extent list */
4351 }
4352 /* Binary search extent records */
4363 /* Convert back to file-based extent index */
4366 }
4369 }
4370 }
4371 /* Convert back to file-based extent index */
4374 }
4380 }
4381 }
4384 }
4386 /*
4387 * Return a pointer to the indirection array entry containing the
4388 * extent record for filesystem block bno. Store the index of the
4389 * target irec in *erp_idxp.
4390 */
4396 {
4420 }
4421 }
4424 }
4426 /*
4427 * Return a pointer to the indirection array entry containing the
4428 * extent record at file extent index *idxp. Store the index of the
4429 * target irec in *erp_idxp and store the page index of the target
4430 * extent record in *idxp.
4431 */
4432 xfs_ext_irec_t *
4438 {
4455 /* Binary search extent irec's */
4471 erp_idx++;
4477 }
4478 }
4482 }
4484 /*
4485 * Allocate and initialize an indirection array once the space needed
4486 * for incore extents increases above XFS_IEXT_BUFSZ.
4487 */
4488 void
4491 {
4509 }
4520 }
4522 /*
4523 * Allocate and initialize a new entry in the indirection array.
4524 */
4525 xfs_ext_irec_t *
4529 {
4537 /* Resize indirection array */
4540 /*
4541 * Move records down in the array so the
4542 * new page can use erp_idx.
4543 */
4547 }
4550 /* Initialize new extent record */
4560 }
4562 /*
4563 * Remove a record from the indirection array.
4564 */
4565 void
4569 {
4581 }
4582 /* Compact extent records */
4586 }
4587 /*
4588 * Manually free the last extent record from the indirection
4589 * array. A call to xfs_iext_realloc_indirect() with a size
4590 * of zero would result in a call to xfs_iext_destroy() which
4591 * would in turn call this function again, creating a nasty
4592 * infinite loop.
4593 */
4600 }
4602 }
4604 /*
4605 * This is called to clean up large amounts of unused memory allocated
4606 * by the indirection array. Before compacting anything though, verify
4607 * that the indirection array is still needed and switch back to the
4608 * linear extent list (or even the inline buffer) if possible. The
4609 * compaction policy is as follows:
4610 *
4611 * Full Compaction: Extents fit into a single page (or inline buffer)
4612 * Full Compaction: Extents occupy less than 10% of allocated space
4613 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4614 * No Compaction: Extents occupy at least 50% of allocated space
4615 */
4616 void
4619 {
4638 }
4639 }
4641 /*
4642 * Combine extents from neighboring extent pages.
4643 */
4644 void
4647 {
4663 /*
4664 * Free page before removing extent record
4665 * so er_extoffs don't get modified in
4666 * xfs_iext_irec_remove.
4667 */
4673 erp_idx++;
4674 }
4675 }
4676 }
4678 /*
4679 * Fully compact the extent records managed by the indirection array.
4680 */
4681 void
4684 {
4704 /* Remove next page */
4706 /*
4707 * Free page before removing extent record
4708 * so er_extoffs don't get modified in
4709 * xfs_iext_irec_remove.
4710 */
4717 /* Update next page */
4719 /* Move rest of page up to become next new page */
4726 }
4728 erp_idx++;
4731 else
4733 }
4737 }
4738 }
4740 /*
4741 * This is called to update the er_extoff field in the indirection
4742 * array when extents have been added or removed from one of the
4743 * extent lists. erp_idx contains the irec index to begin updating
4744 * at and ext_diff contains the number of extents that were added
4745 * or removed.
4746 */
4747 void
4752 {
4760 }
4761 }