| blob | 1a5ad8cd97b00d3d8cd24c04961ea075cb5e1635 |
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 */
56 STATIC int
60 {
68 /*
69 * If it's a directory with any blocks, read-ahead block 0
70 * as we're almost certain to have the next operation be a read there.
71 */
77 }
79 }
81 /*
82 * xfs_getattr
83 */
84 STATIC int
90 {
114 #if XFS_BIG_INUMS
116 #endif
119 /*
120 * Quick exit for non-stat callers
121 */
127 /*
128 * Copy from in-core inode.
129 */
135 /*
136 * Check vnode type block/char vs. everything else.
137 */
151 /*
152 * If the file blocks are being allocated from a
153 * realtime partition, then return the inode's
154 * realtime extent size or the realtime volume's
155 * extent size.
156 */
159 }
161 }
169 /*
170 * Exit for stat callers. See if any of the rest of the fields
171 * to be filled in are needed.
172 */
178 /*
179 * Convert di_flags to xflags.
180 */
183 /*
184 * Exit for inode revalidate. See if any of the rest of
185 * the fields to be filled in are needed.
186 */
202 else
206 all_done:
210 }
213 /*
214 * xfs_setattr
215 */
216 int
222 {
228 uint lock_flags;
246 /*
247 * Cannot set certain attributes.
248 */
252 }
260 /*
261 * Timestamps do not need to be logged and hence do not
262 * need to be done within a transaction.
263 */
271 }
276 /*
277 * If disk quotas is on, we make sure that the dquots do exist on disk,
278 * before we start any other transactions. Trying to do this later
279 * is messy. We don't care to take a readlock to look at the ids
280 * in inode here, because we can't hold it across the trans_reserve.
281 * If the IDs do change before we take the ilock, we're covered
282 * because the i_*dquot fields will get updated anyway.
283 */
293 }
299 }
305 }
306 /*
307 * We take a reference when we initialize udqp and gdqp,
308 * so it is important that we never blindly double trip on
309 * the same variable. See xfs_create() for an example.
310 */
317 }
319 /*
320 * For the other attributes, we acquire the inode lock and
321 * first do an error checking pass.
322 */
337 }
338 }
348 }
349 }
352 }
356 /* boolean: are we the file owner? */
359 /*
360 * Change various properties of a file.
361 * Only the owner or users with CAP_FOWNER
362 * capability may do these things.
363 */
367 /*
368 * CAP_FOWNER overrides the following restrictions:
369 *
370 * The user ID of the calling process must be equal
371 * to the file owner ID, except in cases where the
372 * CAP_FSETID capability is applicable.
373 */
377 }
379 /*
380 * CAP_FSETID overrides the following restrictions:
381 *
382 * The effective user ID of the calling process shall match
383 * the file owner when setting the set-user-ID and
384 * set-group-ID bits on that file.
385 *
386 * The effective group ID or one of the supplementary group
387 * IDs of the calling process shall match the group owner of
388 * the file when setting the set-group-ID bit on that file
389 */
398 #if 0
399 /* Linux allows this, Irix doesn't. */
402 #endif
405 }
406 }
408 /*
409 * Change file ownership. Must be the owner or privileged.
410 * If the system was configured with the "restricted_chown"
411 * option, the owner is not permitted to give away the file,
412 * and can change the group id only to a group of which he
413 * or she is a member.
414 */
416 /*
417 * These IDs could have changed since we last looked at them.
418 * But, we're assured that if the ownership did change
419 * while we didn't have the inode locked, inode's dquot(s)
420 * would have changed also.
421 */
428 iprojid;
430 /*
431 * CAP_CHOWN overrides the following restrictions:
432 *
433 * If _POSIX_CHOWN_RESTRICTED is defined, this capability
434 * shall override the restriction that a process cannot
435 * change the user ID of a file it owns and the restriction
436 * that the group ID supplied to the chown() function
437 * shall be equal to either the group ID or one of the
438 * supplementary group IDs of the calling process.
439 */
446 }
447 /*
448 * Do a quota reservation only if uid/projid/gid is actually
449 * going to change.
450 */
460 }
461 }
463 /*
464 * Truncate file. Must have write permission and not be a directory.
465 */
467 /* Short circuit the truncate case for zero length files */
476 }
484 }
485 /*
486 * Make sure that the dquots are attached to the inode.
487 */
490 }
492 /*
493 * Change file access or modified times.
494 */
501 }
502 }
503 }
505 /*
506 * Change extent size or realtime flag.
507 */
509 /*
510 * Can't change extent size if any extents are allocated.
511 */
517 }
519 /*
520 * Can't change realtime flag if any extents are allocated.
521 */
528 }
529 /*
530 * Extent size must be a multiple of the appropriate block
531 * size, if set at all.
532 */
534 xfs_extlen_t size;
543 }
547 }
548 }
549 /*
550 * If realtime flag is set then must have realtime data.
551 */
559 }
560 }
562 /*
563 * Can't modify an immutable/append-only file unless
564 * we have appropriate permission.
565 */
574 }
575 }
577 /*
578 * Now we can make the changes. Before we join the inode
579 * to the transaction, if XFS_AT_SIZE is set then take care of
580 * the part of the truncation that must be done without the
581 * inode lock. This needs to be done before joining the inode
582 * to the transaction, because the inode cannot be unlocked
583 * once it is a part of the transaction.
584 */
590 }
593 /*
594 * We are going to log the inode size change in this
595 * transaction so any previous writes that are beyond the on
596 * disk EOF and the new EOF that have not been written out need
597 * to be written here. If we do not write the data out, we
598 * expose ourselves to the null files problem.
599 *
600 * Only flush from the on disk size to the smaller of the in
601 * memory file size or the new size as that's the range we
602 * really care about here and prevents waiting for other data
603 * not within the range we care about here.
604 */
611 }
613 /* wait for all I/O to complete */
623 }
627 XFS_TRANS_PERM_LOG_RES,
628 XFS_ITRUNCATE_LOG_COUNT))) {
633 }
636 }
641 }
643 /* determine whether mandatory locking mode changes */
646 /*
647 * Truncate file. Must have write permission and not be a directory.
648 */
655 /*
656 * signal a sync transaction unless
657 * we're truncating an already unlinked
658 * file on a wsync filesystem
659 */
662 XFS_DATA_FORK,
668 /*
669 * Truncated "down", so we're removing references
670 * to old data here - if we now delay flushing for
671 * a long time, we expose ourselves unduly to the
672 * notorious NULL files problem. So, we mark this
673 * vnode and flush it when the file is closed, and
674 * do not wait the usual (long) time for writeout.
675 */
677 }
678 /*
679 * Have to do this even if the file's size doesn't change.
680 */
682 }
684 /*
685 * Change file access modes.
686 */
693 }
695 /*
696 * Change file ownership. Must be the owner or privileged.
697 * If the system was configured with the "restricted_chown"
698 * option, the owner is not permitted to give away the file,
699 * and can change the group id only to a group of which he
700 * or she is a member.
701 */
703 /*
704 * CAP_FSETID overrides the following restrictions:
705 *
706 * The set-user-ID and set-group-ID bits of a file will be
707 * cleared upon successful return from chown()
708 */
712 }
714 /*
715 * Change the ownerships and register quota modifications
716 * in the transaction.
717 */
724 }
726 }
734 }
736 }
744 }
746 /*
747 * We may have to rev the inode as well as
748 * the superblock version number since projids didn't
749 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
750 */
753 }
757 }
760 /*
761 * Change file access or modified times.
762 */
769 }
775 }
778 }
780 /*
781 * Change XFS-added attributes.
782 */
785 /*
786 * Converting bytes to fs blocks.
787 */
790 }
792 uint di_flags;
794 /* can't set PREALLOC this way, just preserve it */
825 }
828 }
830 }
833 }
835 /*
836 * Change file inode change time only if XFS_AT_CTIME set
837 * AND we have been called by a DMI function.
838 */
845 }
847 /*
848 * Send out timestamp changes that need to be set to the
849 * current time. Not done when called by a DMI function.
850 */
856 /*
857 * If this is a synchronous mount, make sure that the
858 * transaction goes to disk before returning to the user.
859 * This is slightly sub-optimal in that truncates require
860 * two sync transactions instead of one for wsync filesystems.
861 * One for the truncate and one for the timestamps since we
862 * don't want to change the timestamps unless we're sure the
863 * truncate worked. Truncates are less than 1% of the laddis
864 * mix so this probably isn't worth the trouble to optimize.
865 */
872 }
874 /*
875 * If the (regular) file's mandatory locking mode changed, then
876 * notify the vnode. We do this under the inode lock to prevent
877 * racing calls to vop_vnode_change.
878 */
882 mandlock_after);
883 }
887 /*
888 * Release any dquot(s) the inode had kept before chown.
889 */
897 }
904 }
907 abort_return:
909 /* FALLTHROUGH */
910 error_return:
915 }
918 }
920 }
923 /*
924 * xfs_access
925 * Null conversion from vnode mode bits to inode mode bits, as in efs.
926 */
927 STATIC int
932 {
944 }
947 /*
948 * The maximum pathlen is 1024 bytes. Since the minimum file system
949 * blocksize is 512 bytes, we can get a max of 2 extents back from
950 * bmapi.
951 */
952 #define SYMLINK_MAPS 2
954 /*
955 * xfs_readlink
956 *
957 */
958 STATIC int
964 {
967 xfs_off_t offset;
974 xfs_daddr_t d;
998 }
1002 }
1004 /*
1005 * See if the symlink is stored inline.
1006 */
1011 }
1013 /*
1014 * Symlink not inline. Call bmap to get it in.
1015 */
1023 }
1036 }
1043 }
1045 }
1047 error_return:
1050 }
1053 /*
1054 * xfs_fsync
1055 *
1056 * This is called to sync the inode and its data out to disk.
1057 * We need to hold the I/O lock while flushing the data, and
1058 * the inode lock while flushing the inode. The inode lock CANNOT
1059 * be held while flushing the data, so acquire after we're done
1060 * with that.
1061 */
1062 STATIC int
1067 xfs_off_t start,
1068 xfs_off_t stop)
1069 {
1085 /*
1086 * We always need to make sure that the required inode state
1087 * is safe on disk. The vnode might be clean but because
1088 * of committed transactions that haven't hit the disk yet.
1089 * Likewise, there could be unflushed non-transactional
1090 * changes to the inode core that have to go to disk.
1091 *
1092 * The following code depends on one assumption: that
1093 * any transaction that changes an inode logs the core
1094 * because it has to change some field in the inode core
1095 * (typically nextents or nblocks). That assumption
1096 * implies that any transactions against an inode will
1097 * catch any non-transactional updates. If inode-altering
1098 * transactions exist that violate this assumption, the
1099 * code breaks. Right now, it figures that if the involved
1100 * update_* field is clear and the inode is unpinned, the
1101 * inode is clean. Either it's been flushed or it's been
1102 * committed and the commit has hit the disk unpinning the inode.
1103 * (Note that xfs_inode_item_format() called at commit clears
1104 * the update_* fields.)
1105 */
1108 /* If we are flushing data then we care about update_size
1109 * being set, otherwise we care about update_core
1110 */
1114 /*
1115 * Timestamps/size haven't changed since last inode
1116 * flush or inode transaction commit. That means
1117 * either nothing got written or a transaction
1118 * committed which caught the updates. If the
1119 * latter happened and the transaction hasn't
1120 * hit the disk yet, the inode will be still
1121 * be pinned. If it is, force the log.
1122 */
1128 XFS_LOG_FORCE |
1133 /*
1134 * If the inode is not pinned and nothing
1135 * has changed we don't need to flush the
1136 * cache.
1137 */
1139 }
1142 /*
1143 * Kick off a transaction to log the inode
1144 * core to get the updates. Make it
1145 * sync if FSYNC_WAIT is passed in (which
1146 * is done by everybody but specfs). The
1147 * sync transaction will also force the log.
1148 */
1156 }
1159 /*
1160 * Note - it's possible that we might have pushed
1161 * ourselves out of the way during trans_reserve
1162 * which would flush the inode. But there's no
1163 * guarantee that the inode buffer has actually
1164 * gone out yet (it's delwri). Plus the buffer
1165 * could be pinned anyway if it's part of an
1166 * inode in another recent transaction. So we
1167 * play it safe and fire off the transaction anyway.
1168 */
1177 }
1180 /*
1181 * If the log write didn't issue an ordered tag we need
1182 * to flush the disk cache for the data device now.
1183 */
1187 /*
1188 * If this inode is on the RT dev we need to flush that
1189 * cache as well.
1190 */
1193 }
1196 }
1198 /*
1199 * This is called by xfs_inactive to free any blocks beyond eof
1200 * when the link count isn't zero and by xfs_dm_punch_hole() when
1201 * punching a hole to EOF.
1202 */
1203 int
1208 {
1211 xfs_fileoff_t end_fsb;
1212 xfs_fileoff_t last_fsb;
1213 xfs_filblks_t map_len;
1215 xfs_bmbt_irec_t imap;
1218 /*
1219 * Figure out if there are any blocks beyond the end
1220 * of the file. If not, then there is nothing to do.
1221 */
1237 /*
1238 * Attach the dquots to the inode up front.
1239 */
1243 /*
1244 * There are blocks after the end of file.
1245 * Free them up now by truncating the file to
1246 * its current size.
1247 */
1250 /*
1251 * Do the xfs_itruncate_start() call before
1252 * reserving any log space because
1253 * itruncate_start will call into the buffer
1254 * cache and we can't
1255 * do that within a transaction.
1256 */
1266 }
1271 XFS_ITRUNCATE_LOG_COUNT);
1277 }
1281 XFS_IOLOCK_EXCL |
1282 XFS_ILOCK_EXCL);
1287 XFS_DATA_FORK,
1289 /*
1290 * If we get an error at this point we
1291 * simply don't bother truncating the file.
1292 */
1296 XFS_TRANS_ABORT));
1299 XFS_TRANS_RELEASE_LOG_RES);
1300 }
1303 }
1305 }
1307 /*
1308 * Free a symlink that has blocks associated with it.
1309 */
1310 STATIC int
1314 {
1319 xfs_fsblock_t first_block;
1320 xfs_bmap_free_t free_list;
1332 /*
1333 * We're freeing a symlink that has some
1334 * blocks allocated to it. Free the
1335 * blocks here. We know that we've got
1336 * either 1 or 2 extents and that we can
1337 * free them all in one bunmapi call.
1338 */
1346 }
1347 /*
1348 * Lock the inode, fix the size, and join it to the transaction.
1349 * Hold it so in the normal path, we still have it locked for
1350 * the second transaction. In the error paths we need it
1351 * held so the cancel won't rele it, see below.
1352 */
1359 /*
1360 * Find the block(s) so we can inval and unmap them.
1361 */
1369 /*
1370 * Invalidate the block(s).
1371 */
1377 }
1378 /*
1379 * Unmap the dead block(s) to the free_list.
1380 */
1385 /*
1386 * Commit the first transaction. This logs the EFI and the inode.
1387 */
1390 /*
1391 * The transaction must have been committed, since there were
1392 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
1393 * The new tp has the extent freeing and EFDs.
1394 */
1396 /*
1397 * The first xact was committed, so add the inode to the new one.
1398 * Mark it dirty so it will be logged and moved forward in the log as
1399 * part of every commit.
1400 */
1404 /*
1405 * Get a new, empty transaction to return to our caller.
1406 */
1408 /*
1409 * Commit the transaction containing extent freeing and EFDs.
1410 * If we get an error on the commit here or on the reserve below,
1411 * we need to unlock the inode since the new transaction doesn't
1412 * have the inode attached.
1413 */
1419 }
1420 /*
1421 * Remove the memory for extent descriptions (just bookkeeping).
1422 */
1426 /*
1427 * Put an itruncate log reservation in the new transaction
1428 * for our caller.
1429 */
1434 }
1435 /*
1436 * Return with the inode locked but not joined to the transaction.
1437 */
1441 error1:
1443 error0:
1444 /*
1445 * Have to come here with the inode locked and either
1446 * (held and in the transaction) or (not in the transaction).
1447 * If the inode isn't held then cancel would iput it, but
1448 * that's wrong since this is inactive and the vnode ref
1449 * count is 0 already.
1450 * Cancel won't do anything to the inode if held, but it still
1451 * needs to be locked until the cancel is done, if it was
1452 * joined to the transaction.
1453 */
1459 }
1461 STATIC int
1465 {
1469 /*
1470 * We're freeing a symlink which fit into
1471 * the inode. Just free the memory used
1472 * to hold the old symlink.
1473 */
1477 XFS_ITRUNCATE_LOG_COUNT);
1483 }
1486 /*
1487 * Zero length symlinks _can_ exist.
1488 */
1492 XFS_DATA_FORK);
1494 }
1496 }
1498 STATIC int
1502 {
1519 }
1525 XFS_INACTIVE_LOG_COUNT);
1532 }
1543 }
1545 STATIC int
1548 {
1561 /* If this is a read-only mount, don't do this (would generate I/O) */
1566 /*
1567 * If we are using filestreams, and we have an unlinked
1568 * file that we are processing the last close on, then nothing
1569 * will be able to reopen and write to this file. Purge this
1570 * inode from the filestreams cache so that it doesn't delay
1571 * teardown of the inode.
1572 */
1576 /*
1577 * If we previously truncated this file and removed old data
1578 * in the process, we want to initiate "early" writeout on
1579 * the last close. This is an attempt to combat the notorious
1580 * NULL files problem which is particularly noticable from a
1581 * truncate down, buffered (re-)write (delalloc), followed by
1582 * a crash. What we are effectively doing here is
1583 * significantly reducing the time window where we'd otherwise
1584 * be exposed to that problem.
1585 */
1588 }
1590 #ifdef HAVE_REFCACHE
1591 /* If we are in the NFS reference cache then don't do this now */
1594 #endif
1606 /* Update linux inode block count after free above */
1609 }
1610 }
1613 }
1615 /*
1616 * xfs_inactive
1617 *
1618 * This is called when the vnode reference count for the vnode
1619 * goes to zero. If the file has been unlinked, then it must
1620 * now be truncated. Also, we clear all of the read-ahead state
1621 * kept for the inode here since the file is now closed.
1622 */
1623 STATIC int
1627 {
1630 xfs_bmap_free_t free_list;
1631 xfs_fsblock_t first_block;
1643 /*
1644 * If the inode is already free, then there can be nothing
1645 * to clean up here.
1646 */
1651 }
1653 /*
1654 * Only do a truncate if it's a regular file with
1655 * some actual space in it. It's OK to look at the
1656 * inode's fields without the lock because we're the
1657 * only one with a reference to the inode.
1658 */
1669 }
1673 /* If this is a read-only mount, don't do this (would generate I/O) */
1688 /* Update linux inode block count after free above */
1691 }
1693 }
1702 /*
1703 * Do the xfs_itruncate_start() call before
1704 * reserving any log space because itruncate_start
1705 * will call into the buffer cache and we can't
1706 * do that within a transaction.
1707 */
1715 }
1720 XFS_ITRUNCATE_LOG_COUNT);
1722 /* Don't call itruncate_cleanup */
1727 }
1733 /*
1734 * normally, we have to run xfs_itruncate_finish sync.
1735 * But if filesystem is wsync and we're in the inactive
1736 * path, then we know that nlink == 0, and that the
1737 * xaction that made nlink == 0 is permanently committed
1738 * since xfs_remove runs as a synchronous transaction.
1739 */
1748 }
1751 /*
1752 * If we get an error while cleaning up a
1753 * symlink we bail out.
1754 */
1762 }
1770 XFS_INACTIVE_LOG_COUNT);
1775 }
1780 }
1782 /*
1783 * If there are attributes associated with the file
1784 * then blow them away now. The code calls a routine
1785 * that recursively deconstructs the attribute fork.
1786 * We need to just commit the current transaction
1787 * because we can't use it for xfs_attr_inactive().
1788 */
1791 /*
1792 * If we got an error, the transaction is already
1793 * cancelled, and the inode is unlocked. Just get out.
1794 */
1799 }
1801 /*
1802 * Free the inode.
1803 */
1807 /*
1808 * If we fail to free the inode, shut down. The cancel
1809 * might do that, we need to make sure. Otherwise the
1810 * inode might be lost for a long time or forever.
1811 */
1817 }
1820 /*
1821 * Credit the quota account(s). The inode is gone.
1822 */
1825 /*
1826 * Just ignore errors at this point. There is
1827 * nothing we can do except to try to keep going.
1828 */
1831 }
1832 /*
1833 * Release the dquots held by inode, if any.
1834 */
1839 out:
1841 }
1844 /*
1845 * xfs_lookup
1846 */
1847 STATIC int
1855 {
1857 xfs_ino_t e_inum;
1859 uint lock_mode;
1875 }
1878 }
1881 /*
1882 * xfs_create (create a new file).
1883 */
1884 STATIC int
1891 {
1898 xfs_dev_t rdev;
1900 xfs_bmap_free_t free_list;
1901 xfs_fsblock_t first_block;
1902 boolean_t dp_joined_to_trans;
1904 uint cancel_flags;
1906 xfs_prid_t prid;
1908 uint resblks;
1931 }
1936 /* Return through std_return after this point. */
1943 else
1946 /*
1947 * Make sure that we have allocated dquot(s) on disk.
1948 */
1961 /*
1962 * Initially assume that the file does not exist and
1963 * reserve the resources for that case. If that is not
1964 * the case we'll drop the one we have and get a more
1965 * appropriate transaction later.
1966 */
1973 }
1978 }
1986 /*
1987 * Reserve disk quota and the inode.
1988 */
2003 }
2006 /*
2007 * At this point, we've gotten a newly allocated inode.
2008 * It is locked (and joined to the transaction).
2009 */
2013 /*
2014 * Now we join the directory inode to the transaction.
2015 * We do not do it earlier because xfs_dir_ialloc
2016 * might commit the previous transaction (and release
2017 * all the locks).
2018 */
2030 }
2034 /*
2035 * If this is a synchronous mount, make sure that the
2036 * create transaction goes to disk before returning to
2037 * the user.
2038 */
2041 }
2045 /*
2046 * Attach the dquot(s) to the inodes and modify them incore.
2047 * These ids of the inode couldn't have changed since the new
2048 * inode has been locked ever since it was created.
2049 */
2052 /*
2053 * xfs_trans_commit normally decrements the vnode ref count
2054 * when it unlocks the inode. Since we want to return the
2055 * vnode to the caller, we bump the vnode ref count now.
2056 */
2064 }
2071 }
2076 /*
2077 * Propagate the fact that the vnode changed after the
2078 * xfs_inode locks have been released.
2079 */
2084 /* Fallthrough to std_return with error = 0 */
2086 std_return:
2089 DM_EVENT_POSTCREATE)) {
2095 }
2098 abort_return:
2100 /* FALLTHROUGH */
2102 error_return:
2113 abort_rele:
2114 /*
2115 * Wait until after the current transaction is aborted to
2116 * release the inode. This prevents recursive transactions
2117 * and deadlocks from xfs_inactive.
2118 */
2127 }
2129 #ifdef DEBUG
2130 /*
2131 * Some counters to see if (and how often) we are hitting some deadlock
2132 * prevention code paths.
2133 */
2138 #endif
2140 /*
2141 * The following routine will lock the inodes associated with the
2142 * directory and the named entry in the directory. The locks are
2143 * acquired in increasing inode number.
2144 *
2145 * If the entry is "..", then only the directory is locked. The
2146 * vnode ref count will still include that from the .. entry in
2147 * this case.
2148 *
2149 * There is a deadlock we need to worry about. If the locked directory is
2150 * in the AIL, it might be blocking up the log. The next inode we lock
2151 * could be already locked by another thread waiting for log space (e.g
2152 * a permanent log reservation with a long running transaction (see
2153 * xfs_itruncate_finish)). To solve this, we must check if the directory
2154 * is in the ail and use lock_nowait. If we can't lock, we need to
2155 * drop the inode lock on the directory and try again. xfs_iunlock will
2156 * potentially push the tail if we were holding up the log.
2157 */
2158 STATIC int
2162 {
2164 xfs_ino_t e_inum;
2168 #ifdef DEBUG
2169 xfs_rm_locks++;
2170 #endif
2173 again:
2180 /*
2181 * We want to lock in increasing inum. Since we've already
2182 * acquired the lock on the directory, we may need to release
2183 * if if the inum of the entry turns out to be less.
2184 */
2186 /*
2187 * We are already in the right order, so just
2188 * lock on the inode of the entry.
2189 * We need to use nowait if dp is in the AIL.
2190 */
2195 attempts++;
2196 #ifdef DEBUG
2197 xfs_rm_attempts++;
2198 #endif
2200 /*
2201 * Unlock dp and try again.
2202 * xfs_iunlock will try to push the tail
2203 * if the inode is in the AIL.
2204 */
2210 #ifdef DEBUG
2211 xfs_rm_lock_delays++;
2212 #endif
2213 }
2215 }
2218 }
2225 }
2226 /* else e_inum == dp->i_ino */
2227 /* This can happen if we're asked to lock /x/..
2228 * the entry is "..", which is also the parent directory.
2229 */
2232 }
2234 #ifdef DEBUG
2240 #endif
2242 /*
2243 * Bump the subclass so xfs_lock_inodes() acquires each lock with
2244 * a different value
2245 */
2248 {
2255 }
2257 /*
2258 * The following routine will lock n inodes in exclusive mode.
2259 * We assume the caller calls us with the inodes in i_ino order.
2260 *
2261 * We need to detect deadlock where an inode that we lock
2262 * is in the AIL and we start waiting for another inode that is locked
2263 * by a thread in a long running transaction (such as truncate). This can
2264 * result in deadlock since the long running trans might need to wait
2265 * for the inode we just locked in order to push the tail and free space
2266 * in the log.
2267 */
2268 void
2273 uint lock_mode)
2274 {
2286 }
2288 again:
2295 /*
2296 * If try_lock is not set yet, make sure all locked inodes
2297 * are not in the AIL.
2298 * If any are, set try_lock to be used later.
2299 */
2305 try_lock++;
2306 }
2307 }
2308 }
2310 /*
2311 * If any of the previous locks we have locked is in the AIL,
2312 * we must TRY to get the second and subsequent locks. If
2313 * we can't get any, we must release all we have
2314 * and try again.
2315 */
2318 /* try_lock must be 0 if i is 0. */
2319 /*
2320 * try_lock means we have an inode locked
2321 * that is in the AIL.
2322 */
2325 attempts++;
2327 /*
2328 * Unlock all previous guys and try again.
2329 * xfs_iunlock will try to push the tail
2330 * if the inode is in the AIL.
2331 */
2335 /*
2336 * Check to see if we've already
2337 * unlocked this one.
2338 * Not the first one going back,
2339 * and the inode ptr is the same.
2340 */
2346 }
2350 #ifdef DEBUG
2351 xfs_lock_delays++;
2352 #endif
2353 }
2357 }
2360 }
2361 }
2363 #ifdef DEBUG
2369 xfs_locked_n++;
2370 }
2371 #endif
2372 }
2374 #ifdef DEBUG
2375 #define REMOVE_DEBUG_TRACE(x) {remove_which_error_return = (x);}
2378 #define REMOVE_DEBUG_TRACE(x)
2382 /*
2383 * xfs_remove
2384 *
2385 */
2386 STATIC int
2391 {
2398 xfs_bmap_free_t free_list;
2399 xfs_fsblock_t first_block;
2404 uint resblks;
2421 }
2429 }
2431 /* From this point on, return through std_return */
2434 /*
2435 * We need to get a reference to ip before we get our log
2436 * reservation. The reason for this is that we cannot call
2437 * xfs_iget for an inode for which we do not have a reference
2438 * once we've acquired a log reservation. This is because the
2439 * inode we are trying to get might be in xfs_inactive going
2440 * for a log reservation. Since we'll have to wait for the
2441 * inactive code to complete before returning from xfs_iget,
2442 * we need to make sure that we don't have log space reserved
2443 * when we call xfs_iget. Instead we get an unlocked reference
2444 * to the inode before getting our log reservation.
2445 */
2450 }
2465 }
2469 /*
2470 * We try to get the real space reservation first,
2471 * allowing for directory btree deletion(s) implying
2472 * possible bmap insert(s). If we can't get the space
2473 * reservation then we use 0 instead, and avoid the bmap
2474 * btree insert(s) in the directory code by, if the bmap
2475 * insert tries to happen, instead trimming the LAST
2476 * block from the directory.
2477 */
2485 }
2492 }
2500 }
2502 /*
2503 * At this point, we've gotten both the directory and the entry
2504 * inodes locked.
2505 */
2508 /*
2509 * Increment vnode ref count only in this case since
2510 * there's an extra vnode reference in the case where
2511 * dp == ip.
2512 */
2515 }
2517 /*
2518 * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2519 */
2527 }
2537 }
2539 /* Determine if this is the last link while
2540 * we are in the transaction.
2541 */
2544 /*
2545 * Take an extra ref on the inode so that it doesn't
2546 * go to xfs_inactive() from within the commit.
2547 */
2550 /*
2551 * If this is a synchronous mount, make sure that the
2552 * remove transaction goes to disk before returning to
2553 * the user.
2554 */
2557 }
2563 }
2569 }
2571 /*
2572 * Before we drop our extra reference to the inode, purge it
2573 * from the refcache if it is there. By waiting until afterwards
2574 * to do the IRELE, we ensure that we won't go inactive in the
2575 * xfs_refcache_purge_ip routine (although that would be OK).
2576 */
2579 /*
2580 * If we are using filestreams, kill the stream association.
2581 * If the file is still open it may get a new one but that
2582 * will get killed on last close in xfs_close() so we don't
2583 * have to worry about that.
2584 */
2590 /*
2591 * Let interposed file systems know about removed links.
2592 */
2597 /* Fall through to std_return with error = 0 */
2598 std_return:
2600 DM_EVENT_POSTREMOVE)) {
2605 }
2608 error1:
2614 error_rele:
2615 /*
2616 * In this case make sure to not release the inode until after
2617 * the current transaction is aborted. Releasing it beforehand
2618 * can cause us to go to xfs_inactive and start a recursive
2619 * transaction which can easily deadlock with the current one.
2620 */
2625 /*
2626 * Before we drop our extra reference to the inode, purge it
2627 * from the refcache if it is there. By waiting until afterwards
2628 * to do the IRELE, we ensure that we won't go inactive in the
2629 * xfs_refcache_purge_ip routine (although that would be OK).
2630 */
2636 }
2639 /*
2640 * xfs_link
2641 *
2642 */
2643 STATIC int
2649 {
2655 xfs_bmap_free_t free_list;
2656 xfs_fsblock_t first_block;
2684 }
2686 /* Return through std_return after this point. */
2703 }
2707 }
2715 }
2719 /*
2720 * Increment vnode ref counts since xfs_trans_commit &
2721 * xfs_trans_cancel will both unlock the inodes and
2722 * decrement the associated ref counts.
2723 */
2729 /*
2730 * If the source has too many links, we can't make any more to it.
2731 */
2735 }
2737 /*
2738 * If we are using project inheritance, we only allow hard link
2739 * creation in our tree when the project IDs are the same; else
2740 * the tree quota mechanism could be circumvented.
2741 */
2746 }
2756 resblks);
2767 /*
2768 * If this is a synchronous mount, make sure that the
2769 * link transaction goes to disk before returning to
2770 * the user.
2771 */
2774 }
2780 }
2786 /* Fall through to std_return with error = 0. */
2787 std_return:
2789 DM_EVENT_POSTLINK)) {
2794 }
2797 abort_return:
2799 /* FALLTHROUGH */
2801 error_return:
2804 }
2807 /*
2808 * xfs_mkdir
2809 *
2810 */
2811 STATIC int
2818 {
2828 xfs_bmap_free_t free_list;
2829 xfs_fsblock_t first_block;
2831 boolean_t dp_joined_to_trans;
2834 xfs_prid_t prid;
2836 uint resblks;
2861 }
2863 /* Return through std_return after this point. */
2873 else
2876 /*
2877 * Make sure that we have allocated dquot(s) on disk.
2878 */
2893 XFS_TRANS_PERM_LOG_RES,
2894 XFS_MKDIR_LOG_COUNT);
2895 }
2900 }
2904 /*
2905 * Check for directory link count overflow.
2906 */
2910 }
2912 /*
2913 * Reserve disk quota and the inode.
2914 */
2922 /*
2923 * create the directory inode.
2924 */
2932 }
2935 /*
2936 * Now we add the directory inode to the transaction.
2937 * We waited until now since xfs_dir_ialloc might start
2938 * a new transaction. Had we joined the transaction
2939 * earlier, the locks might have gotten released.
2940 */
2953 }
2956 /*
2957 * Bump the in memory version number of the parent directory
2958 * so that other processes accessing it will recognize that
2959 * the directory has changed.
2960 */
2979 /*
2980 * Attach the dquots to the new inode and modify the icount incore.
2981 */
2984 /*
2985 * If this is a synchronous mount, make sure that the
2986 * mkdir transaction goes to disk before returning to
2987 * the user.
2988 */
2991 }
2997 }
3004 }
3006 /* Fall through to std_return with error = 0 or errno from
3007 * xfs_trans_commit. */
3009 std_return:
3012 DM_EVENT_POSTCREATE)) {
3016 DM_RIGHT_NULL,
3019 }
3022 error2:
3023 error1:
3025 abort_return:
3027 error_return:
3034 }
3037 }
3040 /*
3041 * xfs_rmdir
3042 *
3043 */
3044 STATIC int
3049 {
3056 xfs_bmap_free_t free_list;
3057 xfs_fsblock_t first_block;
3064 uint resblks;
3079 }
3088 }
3090 /* Return through std_return after this point. */
3094 /*
3095 * We need to get a reference to cdp before we get our log
3096 * reservation. The reason for this is that we cannot call
3097 * xfs_iget for an inode for which we do not have a reference
3098 * once we've acquired a log reservation. This is because the
3099 * inode we are trying to get might be in xfs_inactive going
3100 * for a log reservation. Since we'll have to wait for the
3101 * inactive code to complete before returning from xfs_iget,
3102 * we need to make sure that we don't have log space reserved
3103 * when we call xfs_iget. Instead we get an unlocked reference
3104 * to the inode before getting our log reservation.
3105 */
3110 }
3114 /*
3115 * Get the dquots for the inodes.
3116 */
3124 }
3128 /*
3129 * We try to get the real space reservation first,
3130 * allowing for directory btree deletion(s) implying
3131 * possible bmap insert(s). If we can't get the space
3132 * reservation then we use 0 instead, and avoid the bmap
3133 * btree insert(s) in the directory code by, if the bmap
3134 * insert tries to happen, instead trimming the LAST
3135 * block from the directory.
3136 */
3144 }
3150 }
3153 /*
3154 * Now lock the child directory inode and the parent directory
3155 * inode in the proper order. This will take care of validating
3156 * that the directory entry for the child directory inode has
3157 * not changed while we were obtaining a log reservation.
3158 */
3164 }
3168 /*
3169 * Only increment the parent directory vnode count if
3170 * we didn't bump it in looking up cdp. The only time
3171 * we don't bump it is when we're looking up ".".
3172 */
3174 }
3183 }
3187 }
3196 /*
3197 * Bump the in memory generation count on the parent
3198 * directory so that other can know that it has changed.
3199 */
3202 /*
3203 * Drop the link from cdp's "..".
3204 */
3208 }
3210 /*
3211 * Drop the link from dp to cdp.
3212 */
3216 }
3218 /*
3219 * Drop the "." link from cdp to self.
3220 */
3224 }
3226 /* Determine these before committing transaction */
3229 /*
3230 * Take an extra ref on the child vnode so that it
3231 * does not go to xfs_inactive() from within the commit.
3232 */
3235 /*
3236 * If this is a synchronous mount, make sure that the
3237 * rmdir transaction goes to disk before returning to
3238 * the user.
3239 */
3242 }
3248 XFS_TRANS_ABORT));
3251 }
3257 }
3260 /*
3261 * Let interposed file systems know about removed links.
3262 */
3267 /* Fall through to std_return with error = 0 or the errno
3268 * from xfs_trans_commit. */
3269 std_return:
3276 }
3279 error1:
3282 /* FALLTHROUGH */
3284 error_return:
3287 }
3290 /*
3291 * Read dp's entries starting at uiop->uio_offset and translate them into
3292 * bufsize bytes worth of struct dirents starting at bufbase.
3293 */
3294 STATIC int
3300 {
3304 uint lock_mode;
3317 }
3320 STATIC int
3328 {
3335 xfs_bmap_free_t free_list;
3336 xfs_fsblock_t first_block;
3337 boolean_t dp_joined_to_trans;
3339 uint cancel_flags;
3341 xfs_fileoff_t first_fsb;
3342 xfs_filblks_t fs_blocks;
3345 xfs_daddr_t d;
3350 xfs_prid_t prid;
3352 uint resblks;
3373 /*
3374 * Check component lengths of the target path name.
3375 */
3384 /*
3385 * Skip any slashes.
3386 */
3388 total++;
3389 path++;
3390 }
3392 /*
3393 * Count up to the next slash or end of path.
3394 * Error out if the component is bigger than MAXNAMELEN.
3395 */
3400 }
3401 }
3402 }
3403 }
3411 }
3413 /* Return through std_return after this point. */
3420 else
3423 /*
3424 * Make sure that we have allocated dquot(s) on disk.
3425 */
3434 /*
3435 * The symlink will fit into the inode data fork?
3436 * There can't be any attributes so we get the whole variable part.
3437 */
3440 else
3449 }
3454 }
3458 /*
3459 * Check whether the directory allows new symlinks or not.
3460 */
3464 }
3466 /*
3467 * Reserve disk quota : blocks and inode.
3468 */
3473 /*
3474 * Check for ability to enter directory entry, if no space reserved.
3475 */
3479 /*
3480 * Initialize the bmap freelist prior to calling either
3481 * bmapi or the directory create code.
3482 */
3485 /*
3486 * Allocate an inode for the symlink.
3487 */
3494 }
3501 /*
3502 * Also attach the dquot(s) to it, if applicable.
3503 */
3508 /*
3509 * If the symlink will fit into the inode, write it inline.
3510 */
3516 /*
3517 * The inode was initially created in extent format.
3518 */
3535 }
3551 }
3558 }
3559 }
3561 /*
3562 * Create the directory entry for the symlink.
3563 */
3571 /*
3572 * Bump the in memory version number of the parent directory
3573 * so that other processes accessing it will recognize that
3574 * the directory has changed.
3575 */
3578 /*
3579 * If this is a synchronous mount, make sure that the
3580 * symlink transaction goes to disk before returning to
3581 * the user.
3582 */
3585 }
3587 /*
3588 * xfs_trans_commit normally decrements the vnode ref count
3589 * when it unlocks the inode. Since we want to return the
3590 * vnode to the caller, we bump the vnode ref count now.
3591 */
3597 }
3602 /* Fall through to std_return with error = 0 or errno from
3603 * xfs_trans_commit */
3604 std_return:
3606 DM_EVENT_POSTSYMLINK)) {
3612 }
3620 }
3623 error2:
3625 error1:
3628 error_return:
3635 }
3638 }
3641 /*
3642 * xfs_fid2
3643 *
3644 * A fid routine that takes a pointer to a previously allocated
3645 * fid structure (like xfs_fast_fid) but uses a 64 bit inode number.
3646 */
3647 STATIC int
3651 {
3663 /*
3664 * use memcpy because the inode is a long long and there's no
3665 * assurance that xfid->fid_ino is properly aligned.
3666 */
3671 }
3674 /*
3675 * xfs_rwlock
3676 */
3677 int
3680 bhv_vrwlock_t locktype)
3681 {
3699 }
3702 }
3705 /*
3706 * xfs_rwunlock
3707 */
3708 void
3711 bhv_vrwlock_t locktype)
3712 {
3721 /*
3722 * In the write case, we may have added a new entry to
3723 * the reference cache. This might store a pointer to
3724 * an inode to be released in this inode. If it is there,
3725 * clear the pointer and release the inode after unlocking
3726 * this one.
3727 */
3733 }
3735 }
3737 STATIC int
3741 {
3754 /*
3755 * Bypass inodes which have already been cleaned by
3756 * the inode flush clustering code inside xfs_iflush
3757 */
3765 xfs_lsn_t sync_lsn;
3778 }
3779 }
3781 /*
3782 * We make this non-blocking if the inode is contended,
3783 * return EAGAIN to indicate to the caller that they
3784 * did not succeed. This prevents the flush path from
3785 * blocking on inodes inside another operation right
3786 * now, they get caught later by xfs_sync.
3787 */
3801 }
3804 }
3808 else
3813 }
3816 }
3818 int
3821 u_int evmask,
3822 u_int16_t state,
3824 {
3844 }
3856 }
3858 STATIC int
3861 {
3872 /* bad inode, get out here ASAP */
3876 }
3882 /*
3883 * Make sure the atime in the XFS inode is correct before freeing the
3884 * Linux inode.
3885 */
3888 /*
3889 * If we have nothing to flush with this inode then complete the
3890 * teardown now, otherwise break the link between the xfs inode and the
3891 * linux inode and clean up the xfs inode later. This avoids flushing
3892 * the inode to disk during the delete operation itself.
3893 *
3894 * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
3895 * first to ensure that xfs_iunpin() will never see an xfs inode
3896 * that has a linux inode being reclaimed. Synchronisation is provided
3897 * by the i_flags_lock.
3898 */
3906 /* Protect sync and unpin from us */
3914 }
3916 }
3918 int
3923 {
3931 /* The hash lock here protects a thread in xfs_iget_core from
3932 * racing with us on linking the inode back with a vnode.
3933 * Once we have the XFS_IRECLAIM flag set it will not touch
3934 * us.
3935 */
3945 }
3947 }
3952 /*
3953 * If the inode is still dirty, then flush it out. If the inode
3954 * is not in the AIL, then it will be OK to flush it delwri as
3955 * long as xfs_iflush() does not keep any references to the inode.
3956 * We leave that decision up to xfs_iflush() since it has the
3957 * knowledge of whether it's OK to simply do a delwri flush of
3958 * the inode or whether we need to wait until the inode is
3959 * pulled from the AIL.
3960 * We get the flush lock regardless, though, just to make sure
3961 * we don't free it while it is being flushed.
3962 */
3967 }
3973 /*
3974 * If we hit an error, typically because of filesystem
3975 * shutdown, we don't need to let vn_reclaim to know
3976 * because we're gonna reclaim the inode anyway.
3977 */
3981 }
3983 }
3990 /*
3991 * We are not interested in doing an iflush if we're
3992 * in the process of shutting down the filesystem forcibly.
3993 * So, just reclaim the inode.
3994 */
3997 }
3999 reclaim:
4002 }
4004 int
4006 {
4022 }
4023 }
4026 XFS_IFLUSH_DELWRI_ELSE_ASYNC))
4030 }
4033 }
4037 }
4039 /*
4040 * xfs_alloc_file_space()
4041 * This routine allocates disk space for the given file.
4042 *
4043 * If alloc_type == 0, this request is for an ALLOCSP type
4044 * request which will change the file size. In this case, no
4045 * DMAPI event will be generated by the call. A TRUNCATE event
4046 * will be generated later by xfs_setattr.
4047 *
4048 * If alloc_type != 0, this request is for a RESVSP type
4049 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
4050 * lower block boundary byte address is less than the file's
4051 * length.
4052 *
4053 * RETURNS:
4054 * 0 on success
4055 * errno on error
4056 *
4057 */
4058 STATIC int
4061 xfs_off_t offset,
4062 xfs_off_t len,
4065 {
4067 xfs_off_t count;
4068 xfs_filblks_t allocated_fsb;
4069 xfs_filblks_t allocatesize_fsb;
4071 xfs_fileoff_t startoffset_fsb;
4072 xfs_fsblock_t firstfsb;
4079 xfs_bmap_free_t free_list;
4105 /* Generate a DMAPI event if needed. */
4109 xfs_off_t end_dmi_offset;
4119 }
4121 /*
4122 * Allocate file space until done or until there is an error
4123 */
4124 retry:
4128 /*
4129 * Determine space reservations for data/realtime.
4130 */
4143 }
4155 }
4157 /*
4158 * Allocate and setup the transaction.
4159 */
4163 XFS_TRANS_PERM_LOG_RES,
4164 XFS_WRITE_LOG_COUNT);
4165 /*
4166 * Check for running out of space
4167 */
4169 /*
4170 * Free the transaction structure.
4171 */
4175 }
4185 /*
4186 * Issue the xfs_bmapi() call to allocate the blocks
4187 */
4195 }
4197 /*
4198 * Complete the transaction
4199 */
4203 }
4209 }
4216 }
4220 }
4221 dmapi_enospc_check:
4231 /* else fall through with error from XFS_SEND_DATA */
4232 }
4244 }
4246 /*
4247 * Zero file bytes between startoff and endoff inclusive.
4248 * The iolock is held exclusive and no blocks are buffered.
4249 */
4250 STATIC int
4253 xfs_off_t startoff,
4254 xfs_off_t endoff)
4255 {
4256 xfs_bmbt_irec_t imap;
4257 xfs_fileoff_t offset_fsb;
4258 xfs_off_t lastoffset;
4259 xfs_off_t offset;
4295 }
4307 }
4308 }
4311 }
4313 /*
4314 * xfs_free_file_space()
4315 * This routine frees disk space for the given file.
4316 *
4317 * This routine is only called by xfs_change_file_space
4318 * for an UNRESVSP type call.
4319 *
4320 * RETURNS:
4321 * 0 on success
4322 * errno on error
4323 *
4324 */
4325 STATIC int
4328 xfs_off_t offset,
4329 xfs_off_t len,
4331 {
4335 xfs_off_t end_dmi_offset;
4336 xfs_fileoff_t endoffset_fsb;
4338 xfs_fsblock_t firstfsb;
4339 xfs_bmap_free_t free_list;
4340 xfs_bmbt_irec_t imap;
4341 xfs_off_t ioffset;
4345 uint resblks;
4346 uint rounding;
4348 xfs_fileoff_t startoffset_fsb;
4378 }
4385 }
4397 }
4399 /*
4400 * Need to zero the stuff we're not freeing, on disk.
4401 * If its a realtime file & can't use unwritten extents then we
4402 * actually need to zero the extent edges. Otherwise xfs_bunmapi
4403 * will take care of it for us.
4404 */
4413 xfs_daddr_t block;
4420 }
4429 mod++;
4432 }
4433 }
4435 /*
4436 * One contiguous piece to clear
4437 */
4440 /*
4441 * Some full blocks, possibly two pieces to clear
4442 */
4451 }
4453 /*
4454 * free file space until done or until there is an error
4455 */
4459 /*
4460 * allocate and setup the transaction. Allow this
4461 * transaction to dip into the reserve blocks to ensure
4462 * the freeing of the space succeeds at ENOSPC.
4463 */
4467 resblks,
4470 XFS_TRANS_PERM_LOG_RES,
4471 XFS_WRITE_LOG_COUNT);
4473 /*
4474 * check for running out of space
4475 */
4477 /*
4478 * Free the transaction structure.
4479 */
4483 }
4487 XFS_QMOPT_RES_REGBLKS);
4494 /*
4495 * issue the bunmapi() call to free the blocks
4496 */
4503 }
4505 /*
4506 * complete the transaction
4507 */
4511 }
4515 }
4517 out_unlock_iolock:
4522 error0:
4524 error1:
4527 XFS_ILOCK_EXCL);
4529 }
4531 /*
4532 * xfs_change_file_space()
4533 * This routine allocates or frees disk space for the given file.
4534 * The user specified parameters are checked for alignment and size
4535 * limitations.
4536 *
4537 * RETURNS:
4538 * 0 on success
4539 * errno on error
4540 *
4541 */
4542 int
4547 xfs_off_t offset,
4550 {
4553 xfs_fsize_t fsize;
4557 xfs_off_t startoffset;
4558 xfs_off_t llen;
4560 bhv_vattr_t va;
4569 /*
4570 * must be a regular file and have write permission
4571 */
4580 }
4595 }
4610 /*
4611 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
4612 * file space.
4613 * These calls do NOT zero the data space allocated to the file,
4614 * nor do they change the file size.
4615 *
4616 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
4617 * space.
4618 * These calls cause the new file data to be zeroed and the file
4619 * size to be changed.
4620 */
4636 attr_flags)))
4649 }
4665 }
4667 /*
4668 * update the inode timestamp, mode, and prealloc flag bits
4669 */
4674 /* ASSERT(0); */
4677 }
4687 /*
4688 * Note that we don't have to worry about mandatory
4689 * file locking being disabled here because we only
4690 * clear the S_ISGID bit if the Group execute bit is
4691 * on, but if it was on then mandatory locking wouldn't
4692 * have been enabled.
4693 */
4698 }
4712 }
4714 bhv_vnodeops_t xfs_vnodeops = {
4718 #ifdef HAVE_SPLICE
4721 #endif
4755 };