| blob | 1d7f5a7e063eb3d34266919d538c3b1d53df41d7 |
1 /*
2 * Copyright (c) 2000-2003,2005 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 */
60 /*
61 * Used in xfs_itruncate(). This is the maximum number of extents
62 * freed from a file in a single transaction.
63 */
64 #define XFS_ITRUNC_MAX_EXTENTS 2
72 #ifdef DEBUG
73 /*
74 * Make sure that the extents in the given memory buffer
75 * are valid.
76 */
77 STATIC void
82 xfs_exntfmt_t fmt)
83 {
84 xfs_bmbt_irec_t irec;
85 xfs_bmbt_rec_t rec;
93 else
97 ep++;
98 }
99 }
101 #define xfs_validate_extents(ep, nrecs, disk, fmt)
104 /*
105 * Check that none of the inode's in the buffer have a next
106 * unlinked field of 0.
107 */
108 #if defined(DEBUG)
109 void
113 {
125 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
126 bp);
128 }
129 }
130 }
131 #endif
133 /*
134 * This routine is called to map an inode number within a file
135 * system to the buffer containing the on-disk version of the
136 * inode. It returns a pointer to the buffer containing the
137 * on-disk inode in the bpp parameter, and in the dip parameter
138 * it returns a pointer to the on-disk inode within that buffer.
139 *
140 * If a non-zero error is returned, then the contents of bpp and
141 * dipp are undefined.
142 *
143 * Use xfs_imap() to determine the size and location of the
144 * buffer to read from disk.
145 */
146 STATIC int
150 xfs_ino_t ino,
154 {
156 xfs_imap_t imap;
161 /*
162 * Call the space managment code to find the location of the
163 * inode on disk.
164 */
169 "xfs_inotobp: xfs_imap() returned an "
172 }
174 /*
175 * If the inode number maps to a block outside the bounds of the
176 * file system then return NULL rather than calling read_buf
177 * and panicing when we get an error from the driver.
178 */
182 "xfs_inotobp: inode number (%llu + %d) maps to a block outside the bounds "
187 }
189 /*
190 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
191 * default to just a read_buf() call.
192 */
198 "xfs_inotobp: xfs_trans_read_buf() returned an "
201 }
203 di_ok =
207 XFS_RANDOM_ITOBP_INOTOBP))) {
211 "xfs_inotobp: XFS_TEST_ERROR() returned an "
214 }
218 /*
219 * Set *dipp to point to the on-disk inode in the buffer.
220 */
225 }
228 /*
229 * This routine is called to map an inode to the buffer containing
230 * the on-disk version of the inode. It returns a pointer to the
231 * buffer containing the on-disk inode in the bpp parameter, and in
232 * the dip parameter it returns a pointer to the on-disk inode within
233 * that buffer.
234 *
235 * If a non-zero error is returned, then the contents of bpp and
236 * dipp are undefined.
237 *
238 * If the inode is new and has not yet been initialized, use xfs_imap()
239 * to determine the size and location of the buffer to read from disk.
240 * If the inode has already been mapped to its buffer and read in once,
241 * then use the mapping information stored in the inode rather than
242 * calling xfs_imap(). This allows us to avoid the overhead of looking
243 * at the inode btree for small block file systems (see xfs_dilocate()).
244 * We can tell whether the inode has been mapped in before by comparing
245 * its disk block address to 0. Only uninitialized inodes will have
246 * 0 for the disk block address.
247 */
248 int
255 xfs_daddr_t bno)
256 {
259 xfs_imap_t imap;
260 #ifdef __KERNEL__
263 #endif
266 /*
267 * Call the space management code to find the location of the
268 * inode on disk.
269 */
274 }
276 /*
277 * If the inode number maps to a block outside the bounds
278 * of the file system then return NULL rather than calling
279 * read_buf and panicing when we get an error from the
280 * driver.
281 */
284 #ifdef DEBUG
286 "(imap.im_blkno (0x%llx) "
287 "+ imap.im_len (0x%llx)) > "
288 " XFS_FSB_TO_BB(mp, "
295 }
297 /*
298 * Fill in the fields in the inode that will be used to
299 * map the inode to its buffer from now on.
300 */
305 /*
306 * We've already mapped the inode once, so just use the
307 * mapping that we saved the first time.
308 */
312 }
315 /*
316 * Read in the buffer. If tp is NULL, xfs_trans_read_buf() will
317 * default to just a read_buf() call.
318 */
323 #ifdef DEBUG
325 "xfs_trans_read_buf() returned error %d, "
331 }
332 #ifdef __KERNEL__
333 /*
334 * Validate the magic number and version of every inode in the buffer
335 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
336 */
337 #ifdef DEBUG
339 #else
341 #endif
351 XFS_RANDOM_ITOBP_INOTOBP))) {
352 #ifdef DEBUG
357 #endif
362 }
363 }
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;
417 }
419 if (unlikely(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT) > ip->i_mount->m_sb.sb_inodesize)) {
427 }
438 }
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 {
608 /*
609 * If the number of extents is unreasonable, then something
610 * is wrong and we just bail out rather than crash in
611 * kmem_alloc() or memcpy() below.
612 */
620 }
631 }
640 ARCH_CONVERT);
642 ARCH_CONVERT);
643 }
645 whichfork);
651 XFS_ERRLEVEL_LOW,
654 }
655 }
658 }
660 /*
661 * The file has too many extents to fit into
662 * the inode, so they are in B-tree format.
663 * Allocate a buffer for the root of the B-tree
664 * and copy the root into it. The i_extents
665 * field will remain NULL until all of the
666 * extents are read in (when they are needed).
667 */
668 STATIC int
673 {
676 /* REFERENCED */
685 /*
686 * blow out if -- fork has less extents than can fit in
687 * fork (fork shouldn't be a btree format), root btree
688 * block has more records than can fit into the fork,
689 * or the number of extents is greater than the number of
690 * blocks.
691 */
702 }
707 /*
708 * Copy and convert from the on-disk structure
709 * to the in-memory structure.
710 */
717 }
719 /*
720 * xfs_xlate_dinode_core - translate an xfs_inode_core_t between ondisk
721 * and native format
722 *
723 * buf = on-disk representation
724 * dip = native representation
725 * dir = direction - +ve -> disk to native
726 * -ve -> native to disk
727 */
728 void
730 xfs_caddr_t buf,
733 {
756 }
783 }
785 STATIC uint
788 __uint16_t di_flags)
789 {
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 coresponding 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 {
867 /*
868 * Get pointer's to the on-disk inode and the buffer containing it.
869 * If the inode number refers to a block outside the file system
870 * then xfs_itobp() will return NULL. In this case we should
871 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
872 * know that this is a new incore inode.
873 */
879 }
881 /*
882 * Initialize inode's trace buffers.
883 * Do this before xfs_iformat in case it adds entries.
884 */
885 #ifdef XFS_BMAP_TRACE
887 #endif
888 #ifdef XFS_BMBT_TRACE
890 #endif
891 #ifdef XFS_RW_TRACE
893 #endif
894 #ifdef XFS_ILOCK_TRACE
896 #endif
897 #ifdef XFS_DIR2_TRACE
899 #endif
901 /*
902 * If we got something that isn't an inode it means someone
903 * (nfs or dmi) has a stale handle.
904 */
908 #ifdef DEBUG
910 "dip->di_core.di_magic (0x%x) != "
913 XFS_DINODE_MAGIC);
916 }
918 /*
919 * If the on-disk inode is already linked to a directory
920 * entry, copy all of the inode into the in-core inode.
921 * xfs_iformat() handles copying in the inode format
922 * specific information.
923 * Otherwise, just get the truly permanent information.
924 */
932 #ifdef DEBUG
935 error);
938 }
944 /*
945 * Make sure to pull in the mode here as well in
946 * case the inode is released without being used.
947 * This ensures that xfs_inactive() will see that
948 * the inode is already free and not try to mess
949 * with the uninitialized part of it.
950 */
952 /*
953 * Initialize the per-fork minima and maxima for a new
954 * inode here. xfs_iformat will do it for old inodes.
955 */
958 }
962 /*
963 * The inode format changed when we moved the link count and
964 * made it 32 bits long. If this is an old format inode,
965 * convert it in memory to look like a new one. If it gets
966 * flushed to disk we will convert back before flushing or
967 * logging it. We zero out the new projid field and the old link
968 * count field. We'll handle clearing the pad field (the remains
969 * of the old uuid field) when we actually convert the inode to
970 * the new format. We don't change the version number so that we
971 * can distinguish this from a real new format inode.
972 */
977 }
981 /*
982 * Mark the buffer containing the inode as something to keep
983 * around for a while. This helps to keep recently accessed
984 * meta-data in-core longer.
985 */
988 /*
989 * Use xfs_trans_brelse() to release the buffer containing the
990 * on-disk inode, because it was acquired with xfs_trans_read_buf()
991 * in xfs_itobp() above. If tp is NULL, this is just a normal
992 * brelse(). If we're within a transaction, then xfs_trans_brelse()
993 * will only release the buffer if it is not dirty within the
994 * transaction. It will be OK to release the buffer in this case,
995 * because inodes on disk are never destroyed and we will be
996 * locking the new in-core inode before putting it in the hash
997 * table where other processes can find it. Thus we don't have
998 * to worry about the inode being changed just because we released
999 * the buffer.
1000 */
1004 }
1006 /*
1007 * Read in extents from a btree-format inode.
1008 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
1009 */
1010 int
1015 {
1024 }
1027 /*
1028 * We know that the size is valid (it's checked in iformat_btree)
1029 */
1042 }
1046 }
1048 /*
1049 * Allocate an inode on disk and return a copy of its in-core version.
1050 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1051 * appropriately within the inode. The uid and gid for the inode are
1052 * set according to the contents of the given cred structure.
1053 *
1054 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1055 * has a free inode available, call xfs_iget()
1056 * to obtain the in-core version of the allocated inode. Finally,
1057 * fill in the inode and log its initial contents. In this case,
1058 * ialloc_context would be set to NULL and call_again set to false.
1059 *
1060 * If xfs_dialloc() does not have an available inode,
1061 * it will replenish its supply by doing an allocation. Since we can
1062 * only do one allocation within a transaction without deadlocks, we
1063 * must commit the current transaction before returning the inode itself.
1064 * In this case, therefore, we will set call_again to true and return.
1065 * The caller should then commit the current transaction, start a new
1066 * transaction, and call xfs_ialloc() again to actually get the inode.
1067 *
1068 * To ensure that some other process does not grab the inode that
1069 * was allocated during the first call to xfs_ialloc(), this routine
1070 * also returns the [locked] bp pointing to the head of the freelist
1071 * as ialloc_context. The caller should hold this buffer across
1072 * the commit and pass it back into this routine on the second call.
1073 */
1074 int
1078 mode_t mode,
1079 xfs_nlink_t nlink,
1080 xfs_dev_t rdev,
1082 xfs_prid_t prid,
1087 {
1088 xfs_ino_t ino;
1091 uint flags;
1094 /*
1095 * Call the space management code to pick
1096 * the on-disk inode to be allocated.
1097 */
1102 }
1106 }
1109 /*
1110 * Get the in-core inode with the lock held exclusively.
1111 * This is because we're setting fields here we need
1112 * to prevent others from looking at until we're done.
1113 */
1118 }
1131 /*
1132 * If the superblock version is up to where we support new format
1133 * inodes and this is currently an old format inode, then change
1134 * the inode version number now. This way we only do the conversion
1135 * here rather than here and in the flush/logging code.
1136 */
1140 /*
1141 * We've already zeroed the old link count, the projid field,
1142 * and the pad field.
1143 */
1144 }
1146 /*
1147 * Project ids won't be stored on disk if we are using a version 1 inode.
1148 */
1156 }
1157 }
1159 /*
1160 * If the group ID of the new file does not match the effective group
1161 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1162 * (and only if the irix_sgid_inherit compatibility variable is set).
1163 */
1168 }
1174 /*
1175 * di_gen will have been taken care of in xfs_iread.
1176 */
1203 }
1208 }
1212 }
1213 }
1215 xfs_inherit_noatime)
1218 xfs_inherit_nodump)
1221 xfs_inherit_sync)
1224 xfs_inherit_nosymlinks)
1229 }
1230 /* FALLTHROUGH */
1239 }
1240 /*
1241 * Attribute fork settings for new inode.
1242 */
1246 /*
1247 * Log the new values stuffed into the inode.
1248 */
1251 /* now that we have an i_mode we can set Linux inode ops (& unlock) */
1256 }
1258 /*
1259 * Check to make sure that there are no blocks allocated to the
1260 * file beyond the size of the file. We don't check this for
1261 * files with fixed size extents or real time extents, but we
1262 * at least do it for regular files.
1263 */
1264 #ifdef DEBUG
1265 void
1269 xfs_fsize_t isize)
1270 {
1271 xfs_fileoff_t map_first;
1283 /*
1284 * The filesystem could be shutting down, so bmapi may return
1285 * an error.
1286 */
1290 map_first),
1292 NULL))
1296 }
1299 /*
1300 * Calculate the last possible buffered byte in a file. This must
1301 * include data that was buffered beyond the EOF by the write code.
1302 * This also needs to deal with overflowing the xfs_fsize_t type
1303 * which can happen for sizes near the limit.
1304 *
1305 * We also need to take into account any blocks beyond the EOF. It
1306 * may be the case that they were buffered by a write which failed.
1307 * In that case the pages will still be in memory, but the inode size
1308 * will never have been updated.
1309 */
1310 xfs_fsize_t
1313 {
1315 xfs_fsize_t last_byte;
1316 xfs_fileoff_t last_block;
1317 xfs_fileoff_t size_last_block;
1323 /*
1324 * Only check for blocks beyond the EOF if the extents have
1325 * been read in. This eliminates the need for the inode lock,
1326 * and it also saves us from looking when it really isn't
1327 * necessary.
1328 */
1331 XFS_DATA_FORK);
1334 }
1337 }
1344 }
1348 }
1350 }
1352 #if defined(XFS_RW_TRACE)
1353 STATIC void
1358 xfs_fsize_t new_size,
1359 xfs_off_t toss_start,
1360 xfs_off_t toss_finish)
1361 {
1364 }
1383 }
1384 #else
1385 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1386 #endif
1388 /*
1389 * Start the truncation of the file to new_size. The new size
1390 * must be smaller than the current size. This routine will
1391 * clear the buffer and page caches of file data in the removed
1392 * range, and xfs_itruncate_finish() will remove the underlying
1393 * disk blocks.
1394 *
1395 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1396 * must NOT have the inode lock held at all. This is because we're
1397 * calling into the buffer/page cache code and we can't hold the
1398 * inode lock when we do so.
1399 *
1400 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1401 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1402 * in the case that the caller is locking things out of order and
1403 * may not be able to call xfs_itruncate_finish() with the inode lock
1404 * held without dropping the I/O lock. If the caller must drop the
1405 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1406 * must be called again with all the same restrictions as the initial
1407 * call.
1408 */
1409 void
1412 uint flags,
1413 xfs_fsize_t new_size)
1414 {
1415 xfs_fsize_t last_byte;
1416 xfs_off_t toss_start;
1427 /*
1428 * Call VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES() to get rid of pages and buffers
1429 * overlapping the region being removed. We have to use
1430 * the less efficient VOP_FLUSHINVAL_PAGES() in the case that the
1431 * caller may not be able to finish the truncate without
1432 * dropping the inode's I/O lock. Make sure
1433 * to catch any pages brought in by buffers overlapping
1434 * the EOF by searching out beyond the isize by our
1435 * block size. We round new_size up to a block boundary
1436 * so that we don't toss things on the same block as
1437 * new_size but before it.
1438 *
1439 * Before calling VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES(), make sure to
1440 * call remapf() over the same region if the file is mapped.
1441 * This frees up mapped file references to the pages in the
1442 * given range and for the VOP_FLUSHINVAL_PAGES() case it ensures
1443 * that we get the latest mapped changes flushed out.
1444 */
1448 /*
1449 * The place to start tossing is beyond our maximum
1450 * file size, so there is no way that the data extended
1451 * out there.
1452 */
1454 }
1457 last_byte);
1463 }
1464 }
1466 #ifdef DEBUG
1469 }
1470 #endif
1471 }
1473 /*
1474 * Shrink the file to the given new_size. The new
1475 * size must be smaller than the current size.
1476 * This will free up the underlying blocks
1477 * in the removed range after a call to xfs_itruncate_start()
1478 * or xfs_atruncate_start().
1479 *
1480 * The transaction passed to this routine must have made
1481 * a permanent log reservation of at least XFS_ITRUNCATE_LOG_RES.
1482 * This routine may commit the given transaction and
1483 * start new ones, so make sure everything involved in
1484 * the transaction is tidy before calling here.
1485 * Some transaction will be returned to the caller to be
1486 * committed. The incoming transaction must already include
1487 * the inode, and both inode locks must be held exclusively.
1488 * The inode must also be "held" within the transaction. On
1489 * return the inode will be "held" within the returned transaction.
1490 * This routine does NOT require any disk space to be reserved
1491 * for it within the transaction.
1492 *
1493 * The fork parameter must be either xfs_attr_fork or xfs_data_fork,
1494 * and it indicates the fork which is to be truncated. For the
1495 * attribute fork we only support truncation to size 0.
1496 *
1497 * We use the sync parameter to indicate whether or not the first
1498 * transaction we perform might have to be synchronous. For the attr fork,
1499 * it needs to be so if the unlink of the inode is not yet known to be
1500 * permanent in the log. This keeps us from freeing and reusing the
1501 * blocks of the attribute fork before the unlink of the inode becomes
1502 * permanent.
1503 *
1504 * For the data fork, we normally have to run synchronously if we're
1505 * being called out of the inactive path or we're being called
1506 * out of the create path where we're truncating an existing file.
1507 * Either way, the truncate needs to be sync so blocks don't reappear
1508 * in the file with altered data in case of a crash. wsync filesystems
1509 * can run the first case async because anything that shrinks the inode
1510 * has to run sync so by the time we're called here from inactive, the
1511 * inode size is permanently set to 0.
1512 *
1513 * Calls from the truncate path always need to be sync unless we're
1514 * in a wsync filesystem and the file has already been unlinked.
1515 *
1516 * The caller is responsible for correctly setting the sync parameter.
1517 * It gets too hard for us to guess here which path we're being called
1518 * out of just based on inode state.
1519 */
1520 int
1524 xfs_fsize_t new_size,
1527 {
1528 xfs_fsblock_t first_block;
1529 xfs_fileoff_t first_unmap_block;
1530 xfs_fileoff_t last_block;
1536 xfs_bmap_free_t free_list;
1553 /*
1554 * We only support truncating the entire attribute fork.
1555 */
1558 }
1561 /*
1562 * The first thing we do is set the size to new_size permanently
1563 * on disk. This way we don't have to worry about anyone ever
1564 * being able to look at the data being freed even in the face
1565 * of a crash. What we're getting around here is the case where
1566 * we free a block, it is allocated to another file, it is written
1567 * to, and then we crash. If the new data gets written to the
1568 * file but the log buffers containing the free and reallocation
1569 * don't, then we'd end up with garbage in the blocks being freed.
1570 * As long as we make the new_size permanent before actually
1571 * freeing any blocks it doesn't matter if they get writtten to.
1572 *
1573 * The callers must signal into us whether or not the size
1574 * setting here must be synchronous. There are a few cases
1575 * where it doesn't have to be synchronous. Those cases
1576 * occur if the file is unlinked and we know the unlink is
1577 * permanent or if the blocks being truncated are guaranteed
1578 * to be beyond the inode eof (regardless of the link count)
1579 * and the eof value is permanent. Both of these cases occur
1580 * only on wsync-mounted filesystems. In those cases, we're
1581 * guaranteed that no user will ever see the data in the blocks
1582 * that are being truncated so the truncate can run async.
1583 * In the free beyond eof case, the file may wind up with
1584 * more blocks allocated to it than it needs if we crash
1585 * and that won't get fixed until the next time the file
1586 * is re-opened and closed but that's ok as that shouldn't
1587 * be too many blocks.
1588 *
1589 * However, we can't just make all wsync xactions run async
1590 * because there's one call out of the create path that needs
1591 * to run sync where it's truncating an existing file to size
1592 * 0 whose size is > 0.
1593 *
1594 * It's probably possible to come up with a test in this
1595 * routine that would correctly distinguish all the above
1596 * cases from the values of the function parameters and the
1597 * inode state but for sanity's sake, I've decided to let the
1598 * layers above just tell us. It's simpler to correctly figure
1599 * out in the layer above exactly under what conditions we
1600 * can run async and I think it's easier for others read and
1601 * follow the logic in case something has to be changed.
1602 * cscope is your friend -- rcc.
1603 *
1604 * The attribute fork is much simpler.
1605 *
1606 * For the attribute fork we allow the caller to tell us whether
1607 * the unlink of the inode that led to this call is yet permanent
1608 * in the on disk log. If it is not and we will be freeing extents
1609 * in this inode then we make the first transaction synchronous
1610 * to make sure that the unlink is permanent by the time we free
1611 * the blocks.
1612 */
1617 }
1622 }
1628 /*
1629 * Since it is possible for space to become allocated beyond
1630 * the end of the file (in a crash where the space is allocated
1631 * but the inode size is not yet updated), simply remove any
1632 * blocks which show up between the new EOF and the maximum
1633 * possible file size. If the first block to be removed is
1634 * beyond the maximum file size (ie it is the same as last_block),
1635 * then there is nothing to do.
1636 */
1644 }
1646 /*
1647 * Free up up to XFS_ITRUNC_MAX_EXTENTS. xfs_bunmapi()
1648 * will tell us whether it freed the entire range or
1649 * not. If this is a synchronous mount (wsync),
1650 * then we can tell bunmapi to keep all the
1651 * transactions asynchronous since the unlink
1652 * transaction that made this inode inactive has
1653 * already hit the disk. There's no danger of
1654 * the freed blocks being reused, there being a
1655 * crash, and the reused blocks suddenly reappearing
1656 * in this file with garbage in them once recovery
1657 * runs.
1658 */
1661 unmap_len,
1664 XFS_ITRUNC_MAX_EXTENTS,
1667 /*
1668 * If the bunmapi call encounters an error,
1669 * return to the caller where the transaction
1670 * can be properly aborted. We just need to
1671 * make sure we're not holding any resources
1672 * that we were not when we came in.
1673 */
1676 }
1678 /*
1679 * Duplicate the transaction that has the permanent
1680 * reservation and commit the old transaction.
1681 */
1686 /*
1687 * If the bmap finish 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 *
1693 * Aborting from this point might lose some
1694 * blocks in the file system, but oh well.
1695 */
1698 /*
1699 * If the passed in transaction committed
1700 * in xfs_bmap_finish(), then we want to
1701 * add the inode to this one before returning.
1702 * This keeps things simple for the higher
1703 * level code, because it always knows that
1704 * the inode is locked and held in the
1705 * transaction that returns to it whether
1706 * errors occur or not. We don't mark the
1707 * inode dirty so that this transaction can
1708 * be easily aborted if possible.
1709 */
1713 }
1715 }
1718 /*
1719 * The first xact was committed,
1720 * so add the inode to the new one.
1721 * Mark it dirty so it will be logged
1722 * and moved forward in the log as
1723 * part of every commit.
1724 */
1729 }
1734 XFS_TRANS_PERM_LOG_RES,
1735 XFS_ITRUNCATE_LOG_COUNT);
1736 /*
1737 * Add the inode being truncated to the next chained
1738 * transaction.
1739 */
1744 }
1745 /*
1746 * Only update the size in the case of the data fork, but
1747 * always re-log the inode so that our permanent transaction
1748 * can keep on rolling it forward in the log.
1749 */
1753 }
1763 }
1766 /*
1767 * xfs_igrow_start
1768 *
1769 * Do the first part of growing a file: zero any data in the last
1770 * block that is beyond the old EOF. We need to do this before
1771 * the inode is joined to the transaction to modify the i_size.
1772 * That way we can drop the inode lock and call into the buffer
1773 * cache to get the buffer mapping the EOF.
1774 */
1775 int
1778 xfs_fsize_t new_size,
1780 {
1787 /*
1788 * Zero any pages that may have been created by
1789 * xfs_write_file() beyond the end of the file
1790 * and any blocks between the old and new file sizes.
1791 */
1795 }
1797 /*
1798 * xfs_igrow_finish
1799 *
1800 * This routine is called to extend the size of a file.
1801 * The inode must have both the iolock and the ilock locked
1802 * for update and it must be a part of the current transaction.
1803 * The xfs_igrow_start() function must have been called previously.
1804 * If the change_flag is not zero, the inode change timestamp will
1805 * be updated.
1806 */
1807 void
1811 xfs_fsize_t new_size,
1813 {
1819 /*
1820 * Update the file size. Update the inode change timestamp
1821 * if change_flag set.
1822 */
1828 }
1831 /*
1832 * This is called when the inode's link count goes to 0.
1833 * We place the on-disk inode on a list in the AGI. It
1834 * will be pulled from this list when the inode is freed.
1835 */
1836 int
1840 {
1846 xfs_agnumber_t agno;
1847 xfs_daddr_t agdaddr;
1848 xfs_agino_t agino;
1863 /*
1864 * Get the agi buffer first. It ensures lock ordering
1865 * on the list.
1866 */
1871 }
1872 /*
1873 * Validate the magic number of the agi block.
1874 */
1876 agi_ok =
1880 XFS_RANDOM_IUNLINK))) {
1884 }
1885 /*
1886 * Get the index into the agi hash table for the
1887 * list this inode will go on.
1888 */
1896 /*
1897 * There is already another inode in the bucket we need
1898 * to add ourselves to. Add us at the front of the list.
1899 * Here we put the head pointer into our next pointer,
1900 * and then we fall through to point the head at us.
1901 */
1905 }
1908 /* both on-disk, don't endian flip twice */
1916 }
1918 /*
1919 * Point the bucket head pointer at the inode being inserted.
1920 */
1928 }
1930 /*
1931 * Pull the on-disk inode from the AGI unlinked list.
1932 */
1933 STATIC int
1937 {
1938 xfs_ino_t next_ino;
1944 xfs_agnumber_t agno;
1945 xfs_daddr_t agdaddr;
1946 xfs_agino_t agino;
1947 xfs_agino_t next_agino;
1955 /*
1956 * First pull the on-disk inode from the AGI unlinked list.
1957 */
1963 /*
1964 * Get the agi buffer first. It ensures lock ordering
1965 * on the list.
1966 */
1974 }
1975 /*
1976 * Validate the magic number of the agi block.
1977 */
1979 agi_ok =
1983 XFS_RANDOM_IUNLINK_REMOVE))) {
1991 }
1992 /*
1993 * Get the index into the agi hash table for the
1994 * list this inode will go on.
1995 */
2003 /*
2004 * We're at the head of the list. Get the inode's
2005 * on-disk buffer to see if there is anyone after us
2006 * on the list. Only modify our next pointer if it
2007 * is not already NULLAGINO. This saves us the overhead
2008 * of dealing with the buffer when there is no need to
2009 * change it.
2010 */
2017 }
2030 }
2031 /*
2032 * Point the bucket head pointer at the next inode.
2033 */
2042 /*
2043 * We need to search the list for the inode being freed.
2044 */
2048 /*
2049 * If the last inode wasn't the one pointing to
2050 * us, then release its buffer since we're not
2051 * going to do anything with it.
2052 */
2055 }
2064 }
2068 }
2069 /*
2070 * Now last_ibp points to the buffer previous to us on
2071 * the unlinked list. Pull us from the list.
2072 */
2079 }
2093 }
2094 /*
2095 * Point the previous inode on the list to the next inode.
2096 */
2104 }
2106 }
2109 {
2113 }
2115 STATIC void
2119 xfs_ino_t inum)
2120 {
2126 xfs_daddr_t blkno;
2143 }
2152 /*
2153 * Look for each inode in memory and attempt to lock it,
2154 * we can be racing with flush and tail pushing here.
2155 * any inode we get the locks on, add to an array of
2156 * inode items to process later.
2157 *
2158 * The get the buffer lock, we could beat a flush
2159 * or tail pushing thread to the lock here, in which
2160 * case they will go looking for the inode buffer
2161 * and fail, we need some other form of interlock
2162 * here.
2163 */
2171 }
2173 /* Inode not in memory or we found it already,
2174 * nothing to do
2175 */
2179 }
2184 }
2186 /* If we can get the locks then add it to the
2187 * list, otherwise by the time we get the bp lock
2188 * below it will already be attached to the
2189 * inode buffer.
2190 */
2192 /* This inode will already be locked - by us, lets
2193 * keep it that way.
2194 */
2204 }
2205 }
2208 }
2219 }
2222 }
2223 }
2226 }
2230 XFS_BUF_LOCK);
2243 pre_flushed++;
2244 }
2246 }
2257 }
2271 }
2272 }
2277 }
2280 }
2282 /*
2283 * This is called to return an inode to the inode free list.
2284 * The inode should already be truncated to 0 length and have
2285 * no pages associated with it. This routine also assumes that
2286 * the inode is already a part of the transaction.
2287 *
2288 * The on-disk copy of the inode will have been added to the list
2289 * of unlinked inodes in the AGI. We need to remove the inode from
2290 * that list atomically with respect to freeing it here.
2291 */
2292 int
2297 {
2300 xfs_ino_t first_ino;
2311 /*
2312 * Pull the on-disk inode from the AGI unlinked list.
2313 */
2317 }
2322 }
2331 /*
2332 * Bump the generation count so no one will be confused
2333 * by reincarnations of this inode.
2334 */
2340 }
2343 }
2345 /*
2346 * Reallocate the space for if_broot based on the number of records
2347 * being added or deleted as indicated in rec_diff. Move the records
2348 * and pointers in if_broot to fit the new size. When shrinking this
2349 * will eliminate holes between the records and pointers created by
2350 * the caller. When growing this will create holes to be filled in
2351 * by the caller.
2352 *
2353 * The caller must not request to add more records than would fit in
2354 * the on-disk inode root. If the if_broot is currently NULL, then
2355 * if we adding records one will be allocated. The caller must also
2356 * not request that the number of records go below zero, although
2357 * it can go to zero.
2358 *
2359 * ip -- the inode whose if_broot area is changing
2360 * ext_diff -- the change in the number of records, positive or negative,
2361 * requested for the if_broot array.
2362 */
2363 void
2368 {
2377 /*
2378 * Handle the degenerate case quietly.
2379 */
2382 }
2386 /*
2387 * If there wasn't any memory allocated before, just
2388 * allocate it now and get out.
2389 */
2393 KM_SLEEP);
2396 }
2398 /*
2399 * If there is already an existing if_broot, then we need
2400 * to realloc() it and shift the pointers to their new
2401 * location. The records don't change location because
2402 * they are kept butted up against the btree block header.
2403 */
2409 new_size,
2411 KM_SLEEP);
2421 }
2423 /*
2424 * rec_diff is less than 0. In this case, we are shrinking the
2425 * if_broot buffer. It must already exist. If we go to zero
2426 * records, just get rid of the root and clear the status bit.
2427 */
2434 else
2438 /*
2439 * First copy over the btree block header.
2440 */
2445 }
2447 /*
2448 * Only copy the records and pointers if there are any.
2449 */
2451 /*
2452 * First copy the records.
2453 */
2460 /*
2461 * Then copy the pointers.
2462 */
2468 }
2475 }
2478 /*
2479 * This is called when the amount of space needed for if_extents
2480 * is increased or decreased. The change in size is indicated by
2481 * the number of extents that need to be added or deleted in the
2482 * ext_diff parameter.
2483 *
2484 * If the amount of space needed has decreased below the size of the
2485 * inline buffer, then switch to using the inline buffer. Otherwise,
2486 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2487 * to what is needed.
2488 *
2489 * ip -- the inode whose if_extents area is changing
2490 * ext_diff -- the change in the number of extents, positive or negative,
2491 * requested for the if_extents array.
2492 */
2493 void
2498 {
2502 uint rnew_size;
2506 }
2517 }
2521 /*
2522 * If the valid extents can fit in if_inline_ext,
2523 * copy them from the malloc'd vector and free it.
2524 */
2526 /*
2527 * For now, empty files are format EXTENTS,
2528 * so the if_extents pointer is null.
2529 */
2535 }
2537 }
2543 /*
2544 * Stuck with malloc/realloc.
2545 */
2554 rnew_size,
2556 KM_NOFS);
2557 }
2558 }
2561 }
2564 /*
2565 * This is called when the amount of space needed for if_data
2566 * is increased or decreased. The change in size is indicated by
2567 * the number of bytes that need to be added or deleted in the
2568 * byte_diff parameter.
2569 *
2570 * If the amount of space needed has decreased below the size of the
2571 * inline buffer, then switch to using the inline buffer. Otherwise,
2572 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2573 * to what is needed.
2574 *
2575 * ip -- the inode whose if_data area is changing
2576 * byte_diff -- the change in the number of bytes, positive or negative,
2577 * requested for the if_data array.
2578 */
2579 void
2584 {
2591 }
2600 }
2604 /*
2605 * If the valid extents/data can fit in if_inline_ext/data,
2606 * copy them from the malloc'd vector and free it.
2607 */
2613 new_size);
2616 }
2619 /*
2620 * Stuck with malloc/realloc.
2621 * For inline data, the underlying buffer must be
2622 * a multiple of 4 bytes in size so that it can be
2623 * logged and stay on word boundaries. We enforce
2624 * that here.
2625 */
2631 /*
2632 * Only do the realloc if the underlying size
2633 * is really changing.
2634 */
2638 real_size,
2640 KM_SLEEP);
2641 }
2647 }
2648 }
2652 }
2657 /*
2658 * Map inode to disk block and offset.
2659 *
2660 * mp -- the mount point structure for the current file system
2661 * tp -- the current transaction
2662 * ino -- the inode number of the inode to be located
2663 * imap -- this structure is filled in with the information necessary
2664 * to retrieve the given inode from disk
2665 * flags -- flags to pass to xfs_dilocate indicating whether or not
2666 * lookups in the inode btree were OK or not
2667 */
2668 int
2672 xfs_ino_t ino,
2674 uint flags)
2675 {
2676 xfs_fsblock_t fsbno;
2686 }
2693 }
2695 void
2699 {
2706 }
2708 /*
2709 * If the format is local, then we can't have an extents
2710 * array so just look for an inline data array. If we're
2711 * not local then we may or may not have an extents list,
2712 * so check and free it up if we do.
2713 */
2721 }
2729 }
2736 }
2737 }
2739 /*
2740 * This is called free all the memory associated with an inode.
2741 * It must free the inode itself and any buffers allocated for
2742 * if_extents/if_data and if_broot. It must also free the lock
2743 * associated with the inode.
2744 */
2745 void
2748 {
2756 }
2762 #ifdef XFS_BMAP_TRACE
2764 #endif
2765 #ifdef XFS_BMBT_TRACE
2767 #endif
2768 #ifdef XFS_RW_TRACE
2770 #endif
2771 #ifdef XFS_ILOCK_TRACE
2773 #endif
2774 #ifdef XFS_DIR2_TRACE
2776 #endif
2778 /* XXXdpd should be able to assert this but shutdown
2779 * is leaving the AIL behind. */
2783 }
2785 }
2788 /*
2789 * Increment the pin count of the given buffer.
2790 * This value is protected by ipinlock spinlock in the mount structure.
2791 */
2792 void
2795 {
2799 }
2801 /*
2802 * Decrement the pin count of the given inode, and wake up
2803 * anyone in xfs_iwait_unpin() if the count goes to 0. The
2804 * inode must have been previoulsy pinned with a call to xfs_ipin().
2805 */
2806 void
2809 {
2815 /* make sync come back and flush this inode */
2821 }
2824 }
2825 }
2827 /*
2828 * This is called to wait for the given inode to be unpinned.
2829 * It will sleep until this happens. The caller must have the
2830 * inode locked in at least shared mode so that the buffer cannot
2831 * be subsequently pinned once someone is waiting for it to be
2832 * unpinned.
2833 */
2834 STATIC void
2837 {
2839 xfs_lsn_t lsn;
2845 }
2852 }
2854 /*
2855 * Give the log a push so we don't wait here too long.
2856 */
2860 }
2863 /*
2864 * xfs_iextents_copy()
2865 *
2866 * This is called to copy the REAL extents (as opposed to the delayed
2867 * allocation extents) from the inode into the given buffer. It
2868 * returns the number of bytes copied into the buffer.
2869 *
2870 * If there are no delayed allocation extents, then we can just
2871 * memcpy() the extents into the buffer. Otherwise, we need to
2872 * examine each extent in turn and skip those which are delayed.
2873 */
2874 int
2879 {
2883 #ifdef XFS_BMAP_TRACE
2885 #endif
2889 xfs_fsblock_t start_block;
2899 /*
2900 * There are some delayed allocation extents in the
2901 * inode, so copy the extents one at a time and skip
2902 * the delayed ones. There must be at least one
2903 * non-delayed extent.
2904 */
2911 /*
2912 * It's a delayed allocation extent, so skip it.
2913 */
2914 ep++;
2916 }
2918 /* Translate to on disk format */
2923 dest_ep++;
2924 ep++;
2925 copied++;
2926 }
2931 }
2933 /*
2934 * Each of the following cases stores data into the same region
2935 * of the on-disk inode, so only one of them can be valid at
2936 * any given time. While it is possible to have conflicting formats
2937 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2938 * in EXTENTS format, this can only happen when the fork has
2939 * changed formats after being modified but before being flushed.
2940 * In these cases, the format always takes precedence, because the
2941 * format indicates the current state of the fork.
2942 */
2943 /*ARGSUSED*/
2944 STATIC int
2951 {
2955 #ifdef XFS_TRANS_DEBUG
2957 #endif
2968 /*
2969 * This can happen if we gave up in iformat in an error path,
2970 * for the attribute fork.
2971 */
2975 }
2985 }
2991 }
2992 }
3004 whichfork);
3005 }
3014 XFS_BROOT_SIZE_ADJ));
3018 }
3025 }
3033 }
3039 }
3042 }
3044 /*
3045 * xfs_iflush() will write a modified inode's changes out to the
3046 * inode's on disk home. The caller must have the inode lock held
3047 * in at least shared mode and the inode flush semaphore must be
3048 * held as well. The inode lock will still be held upon return from
3049 * the call and the caller is free to unlock it.
3050 * The inode flush lock will be unlocked when the inode reaches the disk.
3051 * The flags indicate how the inode's buffer should be written out.
3052 */
3053 int
3056 uint flags)
3057 {
3063 /* REFERENCED */
3081 /*
3082 * If the inode isn't dirty, then just release the inode
3083 * flush lock and do nothing.
3084 */
3091 }
3093 /*
3094 * We can't flush the inode until it is unpinned, so
3095 * wait for it. We know noone new can pin it, because
3096 * we are holding the inode lock shared and you need
3097 * to hold it exclusively to pin the inode.
3098 */
3101 /*
3102 * This may have been unpinned because the filesystem is shutting
3103 * down forcibly. If that's the case we must not write this inode
3104 * to disk, because the log record didn't make it to disk!
3105 */
3112 }
3114 /*
3115 * Get the buffer containing the on-disk inode.
3116 */
3121 }
3123 /*
3124 * Decide how buffer will be flushed out. This is done before
3125 * the call to xfs_iflush_int because this field is zeroed by it.
3126 */
3128 /*
3129 * Flush out the inode buffer according to the directions
3130 * of the caller. In the cases where the caller has given
3131 * us a choice choose the non-delwri case. This is because
3132 * the inode is in the AIL and we need to get it out soon.
3133 */
3150 }
3168 }
3169 }
3171 /*
3172 * First flush out the inode that xfs_iflush was called with.
3173 */
3177 }
3179 /*
3180 * inode clustering:
3181 * see if other inodes can be gathered into this write
3182 */
3191 /*
3192 * Do an un-protected check to see if the inode is dirty and
3193 * is a candidate for flushing. These checks will be repeated
3194 * later after the appropriate locks are acquired.
3195 */
3202 }
3204 /*
3205 * Try to get locks. If any are unavailable,
3206 * then this inode cannot be flushed and is skipped.
3207 */
3209 /* get inode locks (just i_lock) */
3211 /* get inode flush lock */
3213 /* check if pinned */
3215 /* arriving here means that
3216 * this inode can be flushed.
3217 * first re-check that it's
3218 * dirty
3219 */
3224 clcount++;
3228 XFS_ILOCK_SHARED);
3230 }
3233 }
3236 }
3237 }
3239 }
3240 }
3246 }
3248 /*
3249 * If the buffer is pinned then push on the log so we won't
3250 * get stuck waiting in the write for too long.
3251 */
3254 }
3262 }
3265 corrupt_out:
3269 /*
3270 * Unlocks the flush lock
3271 */
3274 cluster_corrupt_out:
3275 /* Corruption detected in the clustering loop. Invalidate the
3276 * inode buffer and shut down the filesystem.
3277 */
3280 /*
3281 * Clean up the buffer. If it was B_DELWRI, just release it --
3282 * brelse can handle it with no problems. If not, shut down the
3283 * filesystem before releasing the buffer.
3284 */
3287 }
3292 /*
3293 * Just like incore_relse: if we have b_iodone functions,
3294 * mark the buffer as an error and call them. Otherwise
3295 * mark it as stale and brelse.
3296 */
3307 }
3308 }
3311 /*
3312 * Unlocks the flush lock
3313 */
3315 }
3318 STATIC int
3322 {
3326 #ifdef XFS_TRANS_DEBUG
3328 #endif
3340 /*
3341 * If the inode isn't dirty, then just release the inode
3342 * flush lock and do nothing.
3343 */
3348 }
3350 /* set *dip = inode's place in the buffer */
3353 /*
3354 * Clear i_update_core before copying out the data.
3355 * This is for coordination with our timestamp updates
3356 * that don't hold the inode lock. They will always
3357 * update the timestamps BEFORE setting i_update_core,
3358 * so if we clear i_update_core after they set it we
3359 * are guaranteed to see their updates to the timestamps.
3360 * I believe that this depends on strongly ordered memory
3361 * semantics, but we have that. We use the SYNCHRONIZE
3362 * macro to make sure that the compiler does not reorder
3363 * the i_update_core access below the data copy below.
3364 */
3368 /*
3369 * Make sure to get the latest atime from the Linux inode.
3370 */
3379 }
3386 }
3396 }
3407 }
3408 }
3411 XFS_RANDOM_IFLUSH_5)) {
3417 ip);
3419 }
3426 }
3427 /*
3428 * bump the flush iteration count, used to detect flushes which
3429 * postdate a log record during recovery.
3430 */
3434 /*
3435 * Copy the dirty parts of the inode into the on-disk
3436 * inode. We always copy out the core of the inode,
3437 * because if the inode is dirty at all the core must
3438 * be.
3439 */
3442 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3446 /*
3447 * If this is really an old format inode and the superblock version
3448 * has not been updated to support only new format inodes, then
3449 * convert back to the old inode format. If the superblock version
3450 * has been updated, then make the conversion permanent.
3451 */
3456 /*
3457 * Convert it back.
3458 */
3462 /*
3463 * The superblock version has already been bumped,
3464 * so just make the conversion to the new inode
3465 * format permanent.
3466 */
3475 }
3476 }
3480 }
3483 /*
3484 * The only error from xfs_iflush_fork is on the data fork.
3485 */
3487 }
3490 /*
3491 * We've recorded everything logged in the inode, so we'd
3492 * like to clear the ilf_fields bits so we don't log and
3493 * flush things unnecessarily. However, we can't stop
3494 * logging all this information until the data we've copied
3495 * into the disk buffer is written to disk. If we did we might
3496 * overwrite the copy of the inode in the log with all the
3497 * data after re-logging only part of it, and in the face of
3498 * a crash we wouldn't have all the data we need to recover.
3499 *
3500 * What we do is move the bits to the ili_last_fields field.
3501 * When logging the inode, these bits are moved back to the
3502 * ilf_fields field. In the xfs_iflush_done() routine we
3503 * clear ili_last_fields, since we know that the information
3504 * those bits represent is permanently on disk. As long as
3505 * the flush completes before the inode is logged again, then
3506 * both ilf_fields and ili_last_fields will be cleared.
3507 *
3508 * We can play with the ilf_fields bits here, because the inode
3509 * lock must be held exclusively in order to set bits there
3510 * and the flush lock protects the ili_last_fields bits.
3511 * Set ili_logged so the flush done
3512 * routine can tell whether or not to look in the AIL.
3513 * Also, store the current LSN of the inode so that we can tell
3514 * whether the item has moved in the AIL from xfs_iflush_done().
3515 * In order to read the lsn we need the AIL lock, because
3516 * it is a 64 bit value that cannot be read atomically.
3517 */
3528 /*
3529 * Attach the function xfs_iflush_done to the inode's
3530 * buffer. This will remove the inode from the AIL
3531 * and unlock the inode's flush lock when the inode is
3532 * completely written to disk.
3533 */
3540 /*
3541 * We're flushing an inode which is not in the AIL and has
3542 * not been logged but has i_update_core set. For this
3543 * case we can use a B_DELWRI flush and immediately drop
3544 * the inode flush lock because we can avoid the whole
3545 * AIL state thing. It's OK to drop the flush lock now,
3546 * because we've already locked the buffer and to do anything
3547 * you really need both.
3548 */
3553 }
3555 }
3559 corrupt_out:
3561 }
3564 /*
3565 * Flush all inactive inodes in mp.
3566 */
3567 void
3570 {
3574 again:
3581 /* Make sure we skip markers inserted by sync */
3585 }
3592 }
3598 out:
3600 }
3602 /*
3603 * xfs_iaccess: check accessibility of inode for mode.
3604 */
3605 int
3608 mode_t mode,
3610 {
3624 }
3626 /*
3627 * If there's an Access Control List it's used instead of
3628 * the mode bits.
3629 */
3637 }
3639 /*
3640 * If the DACs are ok we don't need any capability check.
3641 */
3644 /*
3645 * Read/write DACs are always overridable.
3646 * Executable DACs are overridable if at least one exec bit is set.
3647 */
3657 #ifdef NOISE
3661 }
3663 }
3665 /*
3666 * xfs_iroundup: round up argument to next power of two
3667 */
3668 uint
3670 uint v)
3671 {
3673 uint m;
3686 }
3689 }
3691 #ifdef XFS_ILOCK_TRACE
3694 void
3696 {
3705 }
3706 #endif