| blob | 1377c868f3f4929aec4106f187b01c03f480c433 |
1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22 *
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
25 *
26 * http://www.sgi.com
27 *
28 * For further information regarding this notice, see:
29 *
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31 */
74 /*
75 * The maximum pathlen is 1024 bytes. Since the minimum file system
76 * blocksize is 512 bytes, we can get a max of 2 extents back from
77 * bmapi.
78 */
79 #define SYMLINK_MAPS 2
81 /*
82 * For xfs, we check that the file isn't too big to be opened by this kernel.
83 * No other open action is required for regular files. Devices are handled
84 * through the specfs file system, pipes through fifofs. Device and
85 * fifo vnodes are "wrapped" by specfs and fifofs vnodes, respectively,
86 * when a new vnode is first looked up or created.
87 */
88 STATIC int
92 {
103 /*
104 * If it's a directory with any blocks, read-ahead block 0
105 * as we're almost certain to have the next operation be a read there.
106 */
112 }
114 }
117 /*
118 * xfs_getattr
119 */
120 STATIC int
126 {
150 #if XFS_BIG_INUMS
152 #endif
155 /*
156 * Quick exit for non-stat callers
157 */
163 /*
164 * Copy from in-core inode.
165 */
172 /*
173 * Check vnode type block/char vs. everything else.
174 * Do it with bitmask because that's faster than looking
175 * for multiple values individually.
176 */
182 #if 0
183 /* Large block sizes confuse various
184 * user space programs, so letting the
185 * stripe size through is not a good
186 * idea for now.
187 */
189 /*
190 * If the underlying volume is a stripe, then
191 * return the stripe width in bytes as the
192 * recommended I/O size.
193 */
195 /*
196 * Return the largest of the preferred buffer
197 * sizes since doing small I/Os into larger
198 * buffers causes buffers to be decommissioned.
199 * The value returned is in bytes.
200 */
204 #else
206 /*
207 * Return the largest of the preferred buffer
208 * sizes since doing small I/Os into larger
209 * buffers causes buffers to be decommissioned.
210 * The value returned is in bytes.
211 */
214 #endif
217 /*
218 * If the file blocks are being allocated from a
219 * realtime partition, then return the inode's
220 * realtime extent size or the realtime volume's
221 * extent size.
222 */
226 }
230 }
239 /*
240 * Exit for stat callers. See if any of the rest of the fields
241 * to be filled in are needed.
242 */
248 /*
249 * Convert di_flags to xflags.
250 */
253 /*
254 * Exit for inode revalidate. See if any of the rest of
255 * the fields to be filled in are needed.
256 */
272 else
276 all_done:
280 }
283 /*
284 * xfs_setattr
285 */
286 int
292 {
298 uint lock_flags;
316 /*
317 * Cannot set certain attributes.
318 */
322 }
330 /*
331 * Timestamps do not need to be logged and hence do not
332 * need to be done within a transaction.
333 */
341 }
346 /*
347 * If disk quotas is on, we make sure that the dquots do exist on disk,
348 * before we start any other transactions. Trying to do this later
349 * is messy. We don't care to take a readlock to look at the ids
350 * in inode here, because we can't hold it across the trans_reserve.
351 * If the IDs do change before we take the ilock, we're covered
352 * because the i_*dquot fields will get updated anyway.
353 */
363 }
369 }
375 }
376 /*
377 * We take a reference when we initialize udqp and gdqp,
378 * so it is important that we never blindly double trip on
379 * the same variable. See xfs_create() for an example.
380 */
387 }
389 /*
390 * For the other attributes, we acquire the inode lock and
391 * first do an error checking pass.
392 */
408 }
409 }
419 }
420 }
423 }
427 /* boolean: are we the file owner? */
430 /*
431 * Change various properties of a file.
432 * Only the owner or users with CAP_FOWNER
433 * capability may do these things.
434 */
438 /*
439 * CAP_FOWNER overrides the following restrictions:
440 *
441 * The user ID of the calling process must be equal
442 * to the file owner ID, except in cases where the
443 * CAP_FSETID capability is applicable.
444 */
448 }
450 /*
451 * CAP_FSETID overrides the following restrictions:
452 *
453 * The effective user ID of the calling process shall match
454 * the file owner when setting the set-user-ID and
455 * set-group-ID bits on that file.
456 *
457 * The effective group ID or one of the supplementary group
458 * IDs of the calling process shall match the group owner of
459 * the file when setting the set-group-ID bit on that file
460 */
469 #if 0
470 /* Linux allows this, Irix doesn't. */
473 #endif
476 }
477 }
479 /*
480 * Change file ownership. Must be the owner or privileged.
481 * If the system was configured with the "restricted_chown"
482 * option, the owner is not permitted to give away the file,
483 * and can change the group id only to a group of which he
484 * or she is a member.
485 */
487 /*
488 * These IDs could have changed since we last looked at them.
489 * But, we're assured that if the ownership did change
490 * while we didn't have the inode locked, inode's dquot(s)
491 * would have changed also.
492 */
499 iprojid;
501 /*
502 * CAP_CHOWN overrides the following restrictions:
503 *
504 * If _POSIX_CHOWN_RESTRICTED is defined, this capability
505 * shall override the restriction that a process cannot
506 * change the user ID of a file it owns and the restriction
507 * that the group ID supplied to the chown() function
508 * shall be equal to either the group ID or one of the
509 * supplementary group IDs of the calling process.
510 */
517 }
518 /*
519 * Do a quota reservation only if uid/projid/gid is actually
520 * going to change.
521 */
531 }
532 }
534 /*
535 * Truncate file. Must have write permission and not be a directory.
536 */
538 /* Short circuit the truncate case for zero length files */
547 }
555 }
556 /*
557 * Make sure that the dquots are attached to the inode.
558 */
561 }
563 /*
564 * Change file access or modified times.
565 */
572 }
573 }
574 }
576 /*
577 * Change extent size or realtime flag.
578 */
580 /*
581 * Can't change extent size if any extents are allocated.
582 */
589 }
591 /*
592 * Can't set extent size unless the file is marked, or
593 * about to be marked as a realtime file.
594 *
595 * This check will be removed when fixed size extents
596 * with buffered data writes is implemented.
597 *
598 */
607 }
609 /*
610 * Can't change realtime flag if any extents are allocated.
611 */
617 }
618 /*
619 * Extent size must be a multiple of the appropriate block
620 * size, if set at all.
621 */
623 xfs_extlen_t size;
632 }
636 }
637 }
638 /*
639 * If realtime flag is set then must have realtime data.
640 */
648 }
649 }
651 /*
652 * Can't modify an immutable/append-only file unless
653 * we have appropriate permission.
654 */
663 }
664 }
666 /*
667 * Now we can make the changes. Before we join the inode
668 * to the transaction, if XFS_AT_SIZE is set then take care of
669 * the part of the truncation that must be done without the
670 * inode lock. This needs to be done before joining the inode
671 * to the transaction, because the inode cannot be unlocked
672 * once it is a part of the transaction.
673 */
686 }
690 XFS_TRANS_PERM_LOG_RES,
691 XFS_ITRUNCATE_LOG_COUNT))) {
696 }
699 }
704 }
706 /* determine whether mandatory locking mode changes */
709 /*
710 * Truncate file. Must have write permission and not be a directory.
711 */
718 /*
719 * signal a sync transaction unless
720 * we're truncating an already unlinked
721 * file on a wsync filesystem
722 */
725 XFS_DATA_FORK,
731 }
732 }
733 /*
734 * Have to do this even if the file's size doesn't change.
735 */
737 }
739 /*
740 * Change file access modes.
741 */
748 }
750 /*
751 * Change file ownership. Must be the owner or privileged.
752 * If the system was configured with the "restricted_chown"
753 * option, the owner is not permitted to give away the file,
754 * and can change the group id only to a group of which he
755 * or she is a member.
756 */
758 /*
759 * CAP_FSETID overrides the following restrictions:
760 *
761 * The set-user-ID and set-group-ID bits of a file will be
762 * cleared upon successful return from chown()
763 */
767 }
769 /*
770 * Change the ownerships and register quota modifications
771 * in the transaction.
772 */
779 }
781 }
789 }
791 }
799 }
801 /*
802 * We may have to rev the inode as well as
803 * the superblock version number since projids didn't
804 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
805 */
808 }
812 }
815 /*
816 * Change file access or modified times.
817 */
824 }
830 }
833 }
835 /*
836 * Change XFS-added attributes.
837 */
840 /*
841 * Converting bytes to fs blocks.
842 */
845 }
847 uint di_flags;
849 /* can't set PREALLOC this way, just preserve it */
874 }
875 }
877 }
880 }
882 /*
883 * Change file inode change time only if XFS_AT_CTIME set
884 * AND we have been called by a DMI function.
885 */
892 }
894 /*
895 * Send out timestamp changes that need to be set to the
896 * current time. Not done when called by a DMI function.
897 */
903 /*
904 * If this is a synchronous mount, make sure that the
905 * transaction goes to disk before returning to the user.
906 * This is slightly sub-optimal in that truncates require
907 * two sync transactions instead of one for wsync filesytems.
908 * One for the truncate and one for the timestamps since we
909 * don't want to change the timestamps unless we're sure the
910 * truncate worked. Truncates are less than 1% of the laddis
911 * mix so this probably isn't worth the trouble to optimize.
912 */
919 }
921 /*
922 * If the (regular) file's mandatory locking mode changed, then
923 * notify the vnode. We do this under the inode lock to prevent
924 * racing calls to vop_vnode_change.
925 */
929 mandlock_after);
930 }
934 /*
935 * Release any dquot(s) the inode had kept before chown.
936 */
944 }
951 }
954 abort_return:
956 /* FALLTHROUGH */
957 error_return:
962 }
965 }
967 }
970 /*
971 * xfs_access
972 * Null conversion from vnode mode bits to inode mode bits, as in efs.
973 */
974 STATIC int
979 {
991 }
994 /*
995 * xfs_readlink
996 *
997 */
998 STATIC int
1004 {
1007 xfs_off_t offset;
1014 xfs_daddr_t d;
1038 }
1042 }
1046 }
1048 /*
1049 * See if the symlink is stored inline.
1050 */
1055 }
1057 /*
1058 * Symlink not inline. Call bmap to get it in.
1059 */
1067 }
1080 }
1087 }
1089 }
1092 error_return:
1097 }
1100 /*
1101 * xfs_fsync
1102 *
1103 * This is called to sync the inode and its data out to disk.
1104 * We need to hold the I/O lock while flushing the data, and
1105 * the inode lock while flushing the inode. The inode lock CANNOT
1106 * be held while flushing the data, so acquire after we're done
1107 * with that.
1108 */
1109 STATIC int
1114 xfs_off_t start,
1115 xfs_off_t stop)
1116 {
1131 /*
1132 * We always need to make sure that the required inode state
1133 * is safe on disk. The vnode might be clean but because
1134 * of committed transactions that haven't hit the disk yet.
1135 * Likewise, there could be unflushed non-transactional
1136 * changes to the inode core that have to go to disk.
1137 *
1138 * The following code depends on one assumption: that
1139 * any transaction that changes an inode logs the core
1140 * because it has to change some field in the inode core
1141 * (typically nextents or nblocks). That assumption
1142 * implies that any transactions against an inode will
1143 * catch any non-transactional updates. If inode-altering
1144 * transactions exist that violate this assumption, the
1145 * code breaks. Right now, it figures that if the involved
1146 * update_* field is clear and the inode is unpinned, the
1147 * inode is clean. Either it's been flushed or it's been
1148 * committed and the commit has hit the disk unpinning the inode.
1149 * (Note that xfs_inode_item_format() called at commit clears
1150 * the update_* fields.)
1151 */
1154 /* If we are flushing data then we care about update_size
1155 * being set, otherwise we care about update_core
1156 */
1160 /*
1161 * Timestamps/size haven't changed since last inode
1162 * flush or inode transaction commit. That means
1163 * either nothing got written or a transaction
1164 * committed which caught the updates. If the
1165 * latter happened and the transaction hasn't
1166 * hit the disk yet, the inode will be still
1167 * be pinned. If it is, force the log.
1168 */
1174 XFS_LOG_FORCE |
1177 }
1180 /*
1181 * Kick off a transaction to log the inode
1182 * core to get the updates. Make it
1183 * sync if FSYNC_WAIT is passed in (which
1184 * is done by everybody but specfs). The
1185 * sync transaction will also force the log.
1186 */
1194 }
1197 /*
1198 * Note - it's possible that we might have pushed
1199 * ourselves out of the way during trans_reserve
1200 * which would flush the inode. But there's no
1201 * guarantee that the inode buffer has actually
1202 * gone out yet (it's delwri). Plus the buffer
1203 * could be pinned anyway if it's part of an
1204 * inode in another recent transaction. So we
1205 * play it safe and fire off the transaction anyway.
1206 */
1215 }
1217 }
1219 /*
1220 * This is called by xfs_inactive to free any blocks beyond eof,
1221 * when the link count isn't zero.
1222 */
1223 STATIC int
1227 {
1230 xfs_fileoff_t end_fsb;
1231 xfs_fileoff_t last_fsb;
1232 xfs_filblks_t map_len;
1234 xfs_bmbt_irec_t imap;
1236 /*
1237 * Figure out if there are any blocks beyond the end
1238 * of the file. If not, then there is nothing to do.
1239 */
1254 /*
1255 * Attach the dquots to the inode up front.
1256 */
1260 /*
1261 * There are blocks after the end of file.
1262 * Free them up now by truncating the file to
1263 * its current size.
1264 */
1267 /*
1268 * Do the xfs_itruncate_start() call before
1269 * reserving any log space because
1270 * itruncate_start will call into the buffer
1271 * cache and we can't
1272 * do that within a transaction.
1273 */
1281 XFS_ITRUNCATE_LOG_COUNT);
1287 }
1291 XFS_IOLOCK_EXCL |
1292 XFS_ILOCK_EXCL);
1297 XFS_DATA_FORK,
1299 /*
1300 * If we get an error at this point we
1301 * simply don't bother truncating the file.
1302 */
1306 XFS_TRANS_ABORT));
1309 XFS_TRANS_RELEASE_LOG_RES,
1310 NULL);
1311 }
1313 }
1315 }
1317 /*
1318 * Free a symlink that has blocks associated with it.
1319 */
1320 STATIC int
1324 {
1329 xfs_fsblock_t first_block;
1330 xfs_bmap_free_t free_list;
1342 /*
1343 * We're freeing a symlink that has some
1344 * blocks allocated to it. Free the
1345 * blocks here. We know that we've got
1346 * either 1 or 2 extents and that we can
1347 * free them all in one bunmapi call.
1348 */
1356 }
1357 /*
1358 * Lock the inode, fix the size, and join it to the transaction.
1359 * Hold it so in the normal path, we still have it locked for
1360 * the second transaction. In the error paths we need it
1361 * held so the cancel won't rele it, see below.
1362 */
1369 /*
1370 * Find the block(s) so we can inval and unmap them.
1371 */
1379 /*
1380 * Invalidate the block(s).
1381 */
1387 }
1388 /*
1389 * Unmap the dead block(s) to the free_list.
1390 */
1395 /*
1396 * Commit the first transaction. This logs the EFI and the inode.
1397 */
1400 /*
1401 * The transaction must have been committed, since there were
1402 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
1403 * The new tp has the extent freeing and EFDs.
1404 */
1406 /*
1407 * The first xact was committed, so add the inode to the new one.
1408 * Mark it dirty so it will be logged and moved forward in the log as
1409 * part of every commit.
1410 */
1414 /*
1415 * Get a new, empty transaction to return to our caller.
1416 */
1418 /*
1419 * Commit the transaction containing extent freeing and EFD's.
1420 * If we get an error on the commit here or on the reserve below,
1421 * we need to unlock the inode since the new transaction doesn't
1422 * have the inode attached.
1423 */
1429 }
1430 /*
1431 * Remove the memory for extent descriptions (just bookkeeping).
1432 */
1436 /*
1437 * Put an itruncate log reservation in the new transaction
1438 * for our caller.
1439 */
1444 }
1445 /*
1446 * Return with the inode locked but not joined to the transaction.
1447 */
1451 error1:
1453 error0:
1454 /*
1455 * Have to come here with the inode locked and either
1456 * (held and in the transaction) or (not in the transaction).
1457 * If the inode isn't held then cancel would iput it, but
1458 * that's wrong since this is inactive and the vnode ref
1459 * count is 0 already.
1460 * Cancel won't do anything to the inode if held, but it still
1461 * needs to be locked until the cancel is done, if it was
1462 * joined to the transaction.
1463 */
1469 }
1471 STATIC int
1475 {
1479 /*
1480 * We're freeing a symlink which fit into
1481 * the inode. Just free the memory used
1482 * to hold the old symlink.
1483 */
1487 XFS_ITRUNCATE_LOG_COUNT);
1493 }
1496 /*
1497 * Zero length symlinks _can_ exist.
1498 */
1502 XFS_DATA_FORK);
1504 }
1506 }
1508 /*
1509 *
1510 */
1511 STATIC int
1515 {
1532 }
1538 XFS_INACTIVE_LOG_COUNT);
1545 }
1556 }
1558 STATIC int
1561 {
1572 }
1574 /* If this is a read-only mount, don't do this (would generate I/O) */
1578 #ifdef HAVE_REFCACHE
1579 /* If we are in the NFS reference cache then don't do this now */
1582 #endif
1593 /* Update linux inode block count after free above */
1596 }
1597 }
1600 }
1602 /*
1603 * xfs_inactive
1604 *
1605 * This is called when the vnode reference count for the vnode
1606 * goes to zero. If the file has been unlinked, then it must
1607 * now be truncated. Also, we clear all of the read-ahead state
1608 * kept for the inode here since the file is now closed.
1609 */
1610 STATIC int
1614 {
1617 xfs_bmap_free_t free_list;
1618 xfs_fsblock_t first_block;
1630 /*
1631 * If the inode is already free, then there can be nothing
1632 * to clean up here.
1633 */
1638 }
1640 /*
1641 * Only do a truncate if it's a regular file with
1642 * some actual space in it. It's OK to look at the
1643 * inode's fields without the lock because we're the
1644 * only one with a reference to the inode.
1645 */
1655 }
1659 /* If this is a read-only mount, don't do this (would generate I/O) */
1671 /* Update linux inode block count after free above */
1674 }
1676 }
1685 /*
1686 * Do the xfs_itruncate_start() call before
1687 * reserving any log space because itruncate_start
1688 * will call into the buffer cache and we can't
1689 * do that within a transaction.
1690 */
1698 XFS_ITRUNCATE_LOG_COUNT);
1700 /* Don't call itruncate_cleanup */
1705 }
1711 /*
1712 * normally, we have to run xfs_itruncate_finish sync.
1713 * But if filesystem is wsync and we're in the inactive
1714 * path, then we know that nlink == 0, and that the
1715 * xaction that made nlink == 0 is permanently committed
1716 * since xfs_remove runs as a synchronous transaction.
1717 */
1726 }
1729 /*
1730 * If we get an error while cleaning up a
1731 * symlink we bail out.
1732 */
1740 }
1748 XFS_INACTIVE_LOG_COUNT);
1753 }
1758 }
1760 /*
1761 * If there are attributes associated with the file
1762 * then blow them away now. The code calls a routine
1763 * that recursively deconstructs the attribute fork.
1764 * We need to just commit the current transaction
1765 * because we can't use it for xfs_attr_inactive().
1766 */
1769 /*
1770 * If we got an error, the transaction is already
1771 * cancelled, and the inode is unlocked. Just get out.
1772 */
1777 }
1779 /*
1780 * Free the inode.
1781 */
1785 /*
1786 * If we fail to free the inode, shut down. The cancel
1787 * might do that, we need to make sure. Otherwise the
1788 * inode might be lost for a long time or forever.
1789 */
1795 }
1798 /*
1799 * Credit the quota account(s). The inode is gone.
1800 */
1803 /*
1804 * Just ignore errors at this point. There is
1805 * nothing we can do except to try to keep going.
1806 */
1810 }
1811 /*
1812 * Release the dquots held by inode, if any.
1813 */
1818 out:
1820 }
1823 /*
1824 * xfs_lookup
1825 */
1826 STATIC int
1834 {
1836 xfs_ino_t e_inum;
1838 uint lock_mode;
1854 }
1857 }
1860 /*
1861 * xfs_create (create a new file).
1862 */
1863 STATIC int
1870 {
1877 xfs_dev_t rdev;
1879 xfs_bmap_free_t free_list;
1880 xfs_fsblock_t first_block;
1881 boolean_t dp_joined_to_trans;
1883 uint cancel_flags;
1885 xfs_prid_t prid;
1887 uint resblks;
1910 }
1915 /* Return through std_return after this point. */
1922 else
1925 /*
1926 * Make sure that we have allocated dquot(s) on disk.
1927 */
1940 /*
1941 * Initially assume that the file does not exist and
1942 * reserve the resources for that case. If that is not
1943 * the case we'll drop the one we have and get a more
1944 * appropriate transaction later.
1945 */
1952 }
1957 }
1965 /*
1966 * Reserve disk quota and the inode.
1967 */
1984 }
1987 /*
1988 * At this point, we've gotten a newly allocated inode.
1989 * It is locked (and joined to the transaction).
1990 */
1994 /*
1995 * Now we join the directory inode to the transaction.
1996 * We do not do it earlier because xfs_dir_ialloc
1997 * might commit the previous transaction (and release
1998 * all the locks).
1999 */
2011 }
2015 /*
2016 * If this is a synchronous mount, make sure that the
2017 * create transaction goes to disk before returning to
2018 * the user.
2019 */
2022 }
2026 /*
2027 * Attach the dquot(s) to the inodes and modify them incore.
2028 * These ids of the inode couldn't have changed since the new
2029 * inode has been locked ever since it was created.
2030 */
2033 /*
2034 * xfs_trans_commit normally decrements the vnode ref count
2035 * when it unlocks the inode. Since we want to return the
2036 * vnode to the caller, we bump the vnode ref count now.
2037 */
2045 }
2052 }
2057 /*
2058 * Propogate the fact that the vnode changed after the
2059 * xfs_inode locks have been released.
2060 */
2065 /* Fallthrough to std_return with error = 0 */
2067 std_return:
2070 DM_EVENT_POSTCREATE)) {
2076 }
2079 abort_return:
2081 /* FALLTHROUGH */
2082 error_return:
2094 abort_rele:
2095 /*
2096 * Wait until after the current transaction is aborted to
2097 * release the inode. This prevents recursive transactions
2098 * and deadlocks from xfs_inactive.
2099 */
2108 }
2110 #ifdef DEBUG
2111 /*
2112 * Some counters to see if (and how often) we are hitting some deadlock
2113 * prevention code paths.
2114 */
2119 #endif
2121 /*
2122 * The following routine will lock the inodes associated with the
2123 * directory and the named entry in the directory. The locks are
2124 * acquired in increasing inode number.
2125 *
2126 * If the entry is "..", then only the directory is locked. The
2127 * vnode ref count will still include that from the .. entry in
2128 * this case.
2129 *
2130 * There is a deadlock we need to worry about. If the locked directory is
2131 * in the AIL, it might be blocking up the log. The next inode we lock
2132 * could be already locked by another thread waiting for log space (e.g
2133 * a permanent log reservation with a long running transaction (see
2134 * xfs_itruncate_finish)). To solve this, we must check if the directory
2135 * is in the ail and use lock_nowait. If we can't lock, we need to
2136 * drop the inode lock on the directory and try again. xfs_iunlock will
2137 * potentially push the tail if we were holding up the log.
2138 */
2139 STATIC int
2144 {
2146 xfs_ino_t e_inum;
2150 #ifdef DEBUG
2151 xfs_rm_locks++;
2152 #endif
2155 again:
2162 /*
2163 * We want to lock in increasing inum. Since we've already
2164 * acquired the lock on the directory, we may need to release
2165 * if if the inum of the entry turns out to be less.
2166 */
2168 /*
2169 * We are already in the right order, so just
2170 * lock on the inode of the entry.
2171 * We need to use nowait if dp is in the AIL.
2172 */
2177 attempts++;
2178 #ifdef DEBUG
2179 xfs_rm_attempts++;
2180 #endif
2182 /*
2183 * Unlock dp and try again.
2184 * xfs_iunlock will try to push the tail
2185 * if the inode is in the AIL.
2186 */
2192 #ifdef DEBUG
2193 xfs_rm_lock_delays++;
2194 #endif
2195 }
2197 }
2200 }
2207 }
2208 /* else e_inum == dp->i_ino */
2209 /* This can happen if we're asked to lock /x/..
2210 * the entry is "..", which is also the parent directory.
2211 */
2214 }
2216 #ifdef DEBUG
2222 #endif
2224 /*
2225 * The following routine will lock n inodes in exclusive mode.
2226 * We assume the caller calls us with the inodes in i_ino order.
2227 *
2228 * We need to detect deadlock where an inode that we lock
2229 * is in the AIL and we start waiting for another inode that is locked
2230 * by a thread in a long running transaction (such as truncate). This can
2231 * result in deadlock since the long running trans might need to wait
2232 * for the inode we just locked in order to push the tail and free space
2233 * in the log.
2234 */
2235 void
2240 uint lock_mode)
2241 {
2253 }
2255 again:
2262 /*
2263 * If try_lock is not set yet, make sure all locked inodes
2264 * are not in the AIL.
2265 * If any are, set try_lock to be used later.
2266 */
2272 try_lock++;
2273 }
2274 }
2275 }
2277 /*
2278 * If any of the previous locks we have locked is in the AIL,
2279 * we must TRY to get the second and subsequent locks. If
2280 * we can't get any, we must release all we have
2281 * and try again.
2282 */
2285 /* try_lock must be 0 if i is 0. */
2286 /*
2287 * try_lock means we have an inode locked
2288 * that is in the AIL.
2289 */
2292 attempts++;
2294 /*
2295 * Unlock all previous guys and try again.
2296 * xfs_iunlock will try to push the tail
2297 * if the inode is in the AIL.
2298 */
2302 /*
2303 * Check to see if we've already
2304 * unlocked this one.
2305 * Not the first one going back,
2306 * and the inode ptr is the same.
2307 */
2313 }
2317 #ifdef DEBUG
2318 xfs_lock_delays++;
2319 #endif
2320 }
2324 }
2327 }
2328 }
2330 #ifdef DEBUG
2336 xfs_locked_n++;
2337 }
2338 #endif
2339 }
2341 #ifdef DEBUG
2342 #define REMOVE_DEBUG_TRACE(x) {remove_which_error_return = (x);}
2345 #define REMOVE_DEBUG_TRACE(x)
2349 /*
2350 * xfs_remove
2351 *
2352 */
2353 STATIC int
2358 {
2365 xfs_bmap_free_t free_list;
2366 xfs_fsblock_t first_block;
2371 uint resblks;
2391 }
2393 /* From this point on, return through std_return */
2396 /*
2397 * We need to get a reference to ip before we get our log
2398 * reservation. The reason for this is that we cannot call
2399 * xfs_iget for an inode for which we do not have a reference
2400 * once we've acquired a log reservation. This is because the
2401 * inode we are trying to get might be in xfs_inactive going
2402 * for a log reservation. Since we'll have to wait for the
2403 * inactive code to complete before returning from xfs_iget,
2404 * we need to make sure that we don't have log space reserved
2405 * when we call xfs_iget. Instead we get an unlocked referece
2406 * to the inode before getting our log reservation.
2407 */
2412 }
2427 }
2431 /*
2432 * We try to get the real space reservation first,
2433 * allowing for directory btree deletion(s) implying
2434 * possible bmap insert(s). If we can't get the space
2435 * reservation then we use 0 instead, and avoid the bmap
2436 * btree insert(s) in the directory code by, if the bmap
2437 * insert tries to happen, instead trimming the LAST
2438 * block from the directory.
2439 */
2447 }
2454 }
2462 }
2464 /*
2465 * At this point, we've gotten both the directory and the entry
2466 * inodes locked.
2467 */
2470 /*
2471 * Increment vnode ref count only in this case since
2472 * there's an extra vnode reference in the case where
2473 * dp == ip.
2474 */
2477 }
2479 /*
2480 * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2481 */
2489 }
2499 }
2501 /* Determine if this is the last link while
2502 * we are in the transaction.
2503 */
2506 /*
2507 * Take an extra ref on the inode so that it doesn't
2508 * go to xfs_inactive() from within the commit.
2509 */
2512 /*
2513 * If this is a synchronous mount, make sure that the
2514 * remove transaction goes to disk before returning to
2515 * the user.
2516 */
2519 }
2525 }
2531 }
2533 /*
2534 * Before we drop our extra reference to the inode, purge it
2535 * from the refcache if it is there. By waiting until afterwards
2536 * to do the IRELE, we ensure that we won't go inactive in the
2537 * xfs_refcache_purge_ip routine (although that would be OK).
2538 */
2543 /*
2544 * Let interposed file systems know about removed links.
2545 */
2550 /* Fall through to std_return with error = 0 */
2551 std_return:
2553 DM_EVENT_POSTREMOVE)) {
2558 }
2561 error1:
2567 error_rele:
2568 /*
2569 * In this case make sure to not release the inode until after
2570 * the current transaction is aborted. Releasing it beforehand
2571 * can cause us to go to xfs_inactive and start a recursive
2572 * transaction which can easily deadlock with the current one.
2573 */
2578 /*
2579 * Before we drop our extra reference to the inode, purge it
2580 * from the refcache if it is there. By waiting until afterwards
2581 * to do the IRELE, we ensure that we won't go inactive in the
2582 * xfs_refcache_purge_ip routine (although that would be OK).
2583 */
2589 }
2592 /*
2593 * xfs_link
2594 *
2595 */
2596 STATIC int
2602 {
2608 xfs_bmap_free_t free_list;
2609 xfs_fsblock_t first_block;
2640 }
2642 /* Return through std_return after this point. */
2659 }
2663 }
2671 }
2675 /*
2676 * Increment vnode ref counts since xfs_trans_commit &
2677 * xfs_trans_cancel will both unlock the inodes and
2678 * decrement the associated ref counts.
2679 */
2685 /*
2686 * If the source has too many links, we can't make any more to it.
2687 */
2691 }
2693 /*
2694 * If we are using project inheritance, we only allow hard link
2695 * creation in our tree when the project IDs are the same; else
2696 * the tree quota mechanism could be circumvented.
2697 */
2702 }
2706 target_namelen)))
2713 resblks);
2723 }
2725 /*
2726 * If this is a synchronous mount, make sure that the
2727 * link transaction goes to disk before returning to
2728 * the user.
2729 */
2732 }
2738 }
2743 }
2745 /* Fall through to std_return with error = 0. */
2746 std_return:
2748 DM_EVENT_POSTLINK)) {
2753 }
2756 abort_return:
2758 /* FALLTHROUGH */
2759 error_return:
2763 }
2764 /*
2765 * xfs_mkdir
2766 *
2767 */
2768 STATIC int
2775 {
2785 xfs_bmap_free_t free_list;
2786 xfs_fsblock_t first_block;
2788 boolean_t dp_joined_to_trans;
2791 xfs_prid_t prid;
2793 uint resblks;
2818 }
2820 /* Return through std_return after this point. */
2830 else
2833 /*
2834 * Make sure that we have allocated dquot(s) on disk.
2835 */
2850 XFS_TRANS_PERM_LOG_RES,
2851 XFS_MKDIR_LOG_COUNT);
2852 }
2857 }
2861 /*
2862 * Check for directory link count overflow.
2863 */
2867 }
2869 /*
2870 * Reserve disk quota and the inode.
2871 */
2879 /*
2880 * create the directory inode.
2881 */
2890 }
2893 /*
2894 * Now we add the directory inode to the transaction.
2895 * We waited until now since xfs_dir_ialloc might start
2896 * a new transaction. Had we joined the transaction
2897 * earlier, the locks might have gotten released.
2898 */
2911 }
2914 /*
2915 * Bump the in memory version number of the parent directory
2916 * so that other processes accessing it will recognize that
2917 * the directory has changed.
2918 */
2924 }
2930 }
2939 /*
2940 * Attach the dquots to the new inode and modify the icount incore.
2941 */
2944 /*
2945 * If this is a synchronous mount, make sure that the
2946 * mkdir transaction goes to disk before returning to
2947 * the user.
2948 */
2951 }
2957 }
2964 }
2966 /* Fall through to std_return with error = 0 or errno from
2967 * xfs_trans_commit. */
2969 std_return:
2972 DM_EVENT_POSTCREATE)) {
2976 DM_RIGHT_NULL,
2979 }
2982 error2:
2983 error1:
2985 abort_return:
2987 error_return:
2994 }
2997 }
3000 /*
3001 * xfs_rmdir
3002 *
3003 */
3004 STATIC int
3009 {
3016 xfs_bmap_free_t free_list;
3017 xfs_fsblock_t first_block;
3024 uint resblks;
3043 }
3045 /* Return through std_return after this point. */
3049 /*
3050 * We need to get a reference to cdp before we get our log
3051 * reservation. The reason for this is that we cannot call
3052 * xfs_iget for an inode for which we do not have a reference
3053 * once we've acquired a log reservation. This is because the
3054 * inode we are trying to get might be in xfs_inactive going
3055 * for a log reservation. Since we'll have to wait for the
3056 * inactive code to complete before returning from xfs_iget,
3057 * we need to make sure that we don't have log space reserved
3058 * when we call xfs_iget. Instead we get an unlocked referece
3059 * to the inode before getting our log reservation.
3060 */
3065 }
3069 /*
3070 * Get the dquots for the inodes.
3071 */
3079 }
3083 /*
3084 * We try to get the real space reservation first,
3085 * allowing for directory btree deletion(s) implying
3086 * possible bmap insert(s). If we can't get the space
3087 * reservation then we use 0 instead, and avoid the bmap
3088 * btree insert(s) in the directory code by, if the bmap
3089 * insert tries to happen, instead trimming the LAST
3090 * block from the directory.
3091 */
3099 }
3105 }
3108 /*
3109 * Now lock the child directory inode and the parent directory
3110 * inode in the proper order. This will take care of validating
3111 * that the directory entry for the child directory inode has
3112 * not changed while we were obtaining a log reservation.
3113 */
3119 }
3123 /*
3124 * Only increment the parent directory vnode count if
3125 * we didn't bump it in looking up cdp. The only time
3126 * we don't bump it is when we're looking up ".".
3127 */
3129 }
3138 }
3142 }
3148 }
3152 /*
3153 * Bump the in memory generation count on the parent
3154 * directory so that other can know that it has changed.
3155 */
3158 /*
3159 * Drop the link from cdp's "..".
3160 */
3164 }
3166 /*
3167 * Drop the link from dp to cdp.
3168 */
3172 }
3174 /*
3175 * Drop the "." link from cdp to self.
3176 */
3180 }
3182 /* Determine these before committing transaction */
3185 /*
3186 * Take an extra ref on the child vnode so that it
3187 * does not go to xfs_inactive() from within the commit.
3188 */
3191 /*
3192 * If this is a synchronous mount, make sure that the
3193 * rmdir transaction goes to disk before returning to
3194 * the user.
3195 */
3198 }
3204 XFS_TRANS_ABORT));
3207 }
3213 }
3216 /*
3217 * Let interposed file systems know about removed links.
3218 */
3223 /* Fall through to std_return with error = 0 or the errno
3224 * from xfs_trans_commit. */
3225 std_return:
3232 }
3235 error1:
3238 error_return:
3241 }
3244 /*
3245 * xfs_readdir
3246 *
3247 * Read dp's entries starting at uiop->uio_offset and translate them into
3248 * bufsize bytes worth of struct dirents starting at bufbase.
3249 */
3250 STATIC int
3256 {
3260 uint lock_mode;
3261 xfs_off_t start_offset;
3269 }
3276 }
3279 }
3282 /*
3283 * xfs_symlink
3284 *
3285 */
3286 STATIC int
3294 {
3301 xfs_bmap_free_t free_list;
3302 xfs_fsblock_t first_block;
3303 boolean_t dp_joined_to_trans;
3305 uint cancel_flags;
3307 xfs_fileoff_t first_fsb;
3308 xfs_filblks_t fs_blocks;
3311 xfs_daddr_t d;
3316 xfs_prid_t prid;
3318 uint resblks;
3339 /*
3340 * Check component lengths of the target path name.
3341 */
3350 /*
3351 * Skip any slashes.
3352 */
3354 total++;
3355 path++;
3356 }
3358 /*
3359 * Count up to the next slash or end of path.
3360 * Error out if the component is bigger than MAXNAMELEN.
3361 */
3366 }
3367 }
3368 }
3369 }
3377 }
3379 /* Return through std_return after this point. */
3386 else
3389 /*
3390 * Make sure that we have allocated dquot(s) on disk.
3391 */
3400 /*
3401 * The symlink will fit into the inode data fork?
3402 * There can't be any attributes so we get the whole variable part.
3403 */
3406 else
3415 }
3420 }
3424 /*
3425 * Check whether the directory allows new symlinks or not.
3426 */
3430 }
3432 /*
3433 * Reserve disk quota : blocks and inode.
3434 */
3439 /*
3440 * Check for ability to enter directory entry, if no space reserved.
3441 */
3445 /*
3446 * Initialize the bmap freelist prior to calling either
3447 * bmapi or the directory create code.
3448 */
3451 /*
3452 * Allocate an inode for the symlink.
3453 */
3460 }
3467 /*
3468 * Also attach the dquot(s) to it, if applicable.
3469 */
3474 /*
3475 * If the symlink will fit into the inode, write it inline.
3476 */
3482 /*
3483 * The inode was initially created in extent format.
3484 */
3501 }
3517 }
3524 }
3525 }
3527 /*
3528 * Create the directory entry for the symlink.
3529 */
3534 }
3538 /*
3539 * Bump the in memory version number of the parent directory
3540 * so that other processes accessing it will recognize that
3541 * the directory has changed.
3542 */
3545 /*
3546 * If this is a synchronous mount, make sure that the
3547 * symlink transaction goes to disk before returning to
3548 * the user.
3549 */
3552 }
3554 /*
3555 * xfs_trans_commit normally decrements the vnode ref count
3556 * when it unlocks the inode. Since we want to return the
3557 * vnode to the caller, we bump the vnode ref count now.
3558 */
3564 }
3569 /* Fall through to std_return with error = 0 or errno from
3570 * xfs_trans_commit */
3571 std_return:
3573 DM_EVENT_POSTSYMLINK)) {
3579 }
3587 }
3590 error2:
3592 error1:
3595 error_return:
3602 }
3605 }
3608 /*
3609 * xfs_fid2
3610 *
3611 * A fid routine that takes a pointer to a previously allocated
3612 * fid structure (like xfs_fast_fid) but uses a 64 bit inode number.
3613 */
3614 STATIC int
3618 {
3630 /*
3631 * use memcpy because the inode is a long long and there's no
3632 * assurance that xfid->fid_ino is properly aligned.
3633 */
3638 }
3641 /*
3642 * xfs_rwlock
3643 */
3644 int
3647 vrwlock_t locktype)
3648 {
3666 }
3669 }
3672 /*
3673 * xfs_rwunlock
3674 */
3675 void
3678 vrwlock_t locktype)
3679 {
3688 /*
3689 * In the write case, we may have added a new entry to
3690 * the reference cache. This might store a pointer to
3691 * an inode to be released in this inode. If it is there,
3692 * clear the pointer and release the inode after unlocking
3693 * this one.
3694 */
3700 }
3702 }
3704 STATIC int
3708 {
3721 /*
3722 * Bypass inodes which have already been cleaned by
3723 * the inode flush clustering code inside xfs_iflush
3724 */
3732 xfs_lsn_t sync_lsn;
3745 }
3746 }
3748 /*
3749 * We make this non-blocking if the inode is contended,
3750 * return EAGAIN to indicate to the caller that they
3751 * did not succeed. This prevents the flush path from
3752 * blocking on inodes inside another operation right
3753 * now, they get caught later by xfs_sync.
3754 */
3768 }
3771 }
3775 else
3780 }
3783 }
3786 int
3789 u_int evmask,
3790 u_int16_t state,
3792 {
3812 }
3824 }
3827 /*
3828 * xfs_reclaim
3829 */
3830 STATIC int
3833 {
3844 /* bad inode, get out here ASAP */
3848 }
3852 /*
3853 * Flush and invalidate any data left around that is
3854 * a part of this file.
3855 *
3856 * Get the inode's i/o lock so that buffers are pushed
3857 * out while holding the proper lock. We can't hold
3858 * the inode lock here since flushing out buffers may
3859 * cause us to try to get the lock in xfs_strategy().
3860 *
3861 * We don't have to call remapf() here, because there
3862 * cannot be any mapped file references to this vnode
3863 * since it is being reclaimed.
3864 */
3867 /*
3868 * If we hit an IO error, we need to make sure that the
3869 * buffer and page caches of file data for
3870 * the file are tossed away. We don't want to use
3871 * VOP_FLUSHINVAL_PAGES here because we don't want dirty
3872 * pages to stay attached to the vnode, but be
3873 * marked P_BAD. pdflush/vnode_pagebad
3874 * hates that.
3875 */
3880 }
3887 /*
3888 * di_size field may not be quite accurate if we're
3889 * shutting down.
3890 */
3893 }
3894 }
3896 /* If we have nothing to flush with this inode then complete the
3897 * teardown now, otherwise break the link between the xfs inode
3898 * and the linux inode and clean up the xfs inode later. This
3899 * avoids flushing the inode to disk during the delete operation
3900 * itself.
3901 */
3909 /* Protect sync from us */
3915 }
3917 }
3919 int
3924 {
3932 /* The hash lock here protects a thread in xfs_iget_core from
3933 * racing with us on linking the inode back with a vnode.
3934 * Once we have the XFS_IRECLAIM flag set it will not touch
3935 * us.
3936 */
3944 }
3946 }
3950 /*
3951 * If the inode is still dirty, then flush it out. If the inode
3952 * is not in the AIL, then it will be OK to flush it delwri as
3953 * long as xfs_iflush() does not keep any references to the inode.
3954 * We leave that decision up to xfs_iflush() since it has the
3955 * knowledge of whether it's OK to simply do a delwri flush of
3956 * the inode or whether we need to wait until the inode is
3957 * pulled from the AIL.
3958 * We get the flush lock regardless, though, just to make sure
3959 * we don't free it while it is being flushed.
3960 */
3965 }
3971 /*
3972 * If we hit an error, typically because of filesystem
3973 * shutdown, we don't need to let vn_reclaim to know
3974 * because we're gonna reclaim the inode anyway.
3975 */
3979 }
3981 }
3988 /*
3989 * We are not interested in doing an iflush if we're
3990 * in the process of shutting down the filesystem forcibly.
3991 * So, just reclaim the inode.
3992 */
3995 }
3997 reclaim:
4000 }
4002 int
4004 {
4020 }
4021 }
4024 XFS_IFLUSH_DELWRI_ELSE_ASYNC);
4027 }
4030 }
4034 }
4036 /*
4037 * xfs_alloc_file_space()
4038 * This routine allocates disk space for the given file.
4039 *
4040 * If alloc_type == 0, this request is for an ALLOCSP type
4041 * request which will change the file size. In this case, no
4042 * DMAPI event will be generated by the call. A TRUNCATE event
4043 * will be generated later by xfs_setattr.
4044 *
4045 * If alloc_type != 0, this request is for a RESVSP type
4046 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
4047 * lower block boundary byte address is less than the file's
4048 * length.
4049 *
4050 * RETURNS:
4051 * 0 on success
4052 * errno on error
4053 *
4054 */
4055 STATIC int
4058 xfs_off_t offset,
4059 xfs_off_t len,
4062 {
4063 xfs_filblks_t allocated_fsb;
4064 xfs_filblks_t allocatesize_fsb;
4066 xfs_off_t count;
4067 xfs_filblks_t datablocks;
4069 xfs_fsblock_t firstfsb;
4070 xfs_bmap_free_t free_list;
4076 uint resblks;
4079 xfs_fileoff_t startoffset_fsb;
4089 /*
4090 * determine if this is a realtime file
4091 */
4095 else
4114 /* Generate a DMAPI event if needed. */
4118 xfs_off_t end_dmi_offset;
4128 }
4130 /*
4131 * allocate file space until done or until there is an error
4132 */
4133 retry:
4135 /*
4136 * determine if reserving space on
4137 * the data or realtime partition.
4138 */
4146 rtextsize);
4152 }
4154 /*
4155 * allocate and setup the transaction
4156 */
4160 resblks,
4162 numrtextents,
4163 XFS_TRANS_PERM_LOG_RES,
4164 XFS_WRITE_LOG_COUNT);
4166 /*
4167 * check for running out of space
4168 */
4170 /*
4171 * Free the transaction structure.
4172 */
4176 }
4186 /*
4187 * issue the bmapi() call to allocate the blocks
4188 */
4196 }
4198 /*
4199 * complete the transaction
4200 */
4204 }
4210 }
4217 }
4221 }
4222 dmapi_enospc_check:
4232 /* else fall through with error from XFS_SEND_DATA */
4233 }
4237 error0:
4239 error1:
4243 }
4245 /*
4246 * Zero file bytes between startoff and endoff inclusive.
4247 * The iolock is held exclusive and no blocks are buffered.
4248 */
4249 STATIC int
4252 xfs_off_t startoff,
4253 xfs_off_t endoff)
4254 {
4255 xfs_bmbt_irec_t imap;
4256 xfs_fileoff_t offset_fsb;
4257 xfs_off_t lastoffset;
4258 xfs_off_t offset;
4294 }
4306 }
4307 }
4310 }
4312 /*
4313 * xfs_free_file_space()
4314 * This routine frees disk space for the given file.
4315 *
4316 * This routine is only called by xfs_change_file_space
4317 * for an UNRESVSP type call.
4318 *
4319 * RETURNS:
4320 * 0 on success
4321 * errno on error
4322 *
4323 */
4324 STATIC int
4327 xfs_off_t offset,
4328 xfs_off_t len,
4330 {
4334 xfs_off_t end_dmi_offset;
4335 xfs_fileoff_t endoffset_fsb;
4337 xfs_fsblock_t firstfsb;
4338 xfs_bmap_free_t free_list;
4339 xfs_off_t ilen;
4340 xfs_bmbt_irec_t imap;
4341 xfs_off_t ioffset;
4345 uint resblks;
4348 xfs_fileoff_t startoffset_fsb;
4378 }
4398 }
4400 /*
4401 * Need to zero the stuff we're not freeing, on disk.
4402 * If its a realtime file & can't use unwritten extents then we
4403 * actually need to zero the extent edges. Otherwise xfs_bunmapi
4404 * will take care of it for us.
4405 */
4414 xfs_daddr_t block;
4421 }
4430 mod++;
4433 }
4434 }
4436 /*
4437 * One contiguous piece to clear
4438 */
4441 /*
4442 * Some full blocks, possibly two pieces to clear
4443 */
4452 }
4454 /*
4455 * free file space until done or until there is an error
4456 */
4460 /*
4461 * allocate and setup the transaction
4462 */
4465 resblks,
4468 XFS_TRANS_PERM_LOG_RES,
4469 XFS_WRITE_LOG_COUNT);
4471 /*
4472 * check for running out of space
4473 */
4475 /*
4476 * Free the transaction structure.
4477 */
4481 }
4492 /*
4493 * issue the bunmapi() call to free the blocks
4494 */
4501 }
4503 /*
4504 * complete the transaction
4505 */
4509 }
4513 }
4515 out_unlock_iolock:
4520 error0:
4522 error1:
4525 XFS_ILOCK_EXCL);
4527 }
4529 /*
4530 * xfs_change_file_space()
4531 * This routine allocates or frees disk space for the given file.
4532 * The user specified parameters are checked for alignment and size
4533 * limitations.
4534 *
4535 * RETURNS:
4536 * 0 on success
4537 * errno on error
4538 *
4539 */
4540 int
4545 xfs_off_t offset,
4548 {
4551 xfs_fsize_t fsize;
4555 xfs_off_t startoffset;
4556 xfs_off_t llen;
4558 vattr_t va;
4567 /*
4568 * must be a regular file and have write permission
4569 */
4578 }
4593 }
4608 /*
4609 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
4610 * file space.
4611 * These calls do NOT zero the data space allocated to the file,
4612 * nor do they change the file size.
4613 *
4614 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
4615 * space.
4616 * These calls cause the new file data to be zeroed and the file
4617 * size to be changed.
4618 */
4634 attr_flags)))
4647 }
4663 }
4665 /*
4666 * update the inode timestamp, mode, and prealloc flag bits
4667 */
4672 /* ASSERT(0); */
4675 }
4685 /*
4686 * Note that we don't have to worry about mandatory
4687 * file locking being disabled here because we only
4688 * clear the S_ISGID bit if the Group execute bit is
4689 * on, but if it was on then mandatory locking wouldn't
4690 * have been enabled.
4691 */
4696 }
4710 }
4712 vnodeops_t xfs_vnodeops = {
4716 #ifdef HAVE_SENDFILE
4718 #endif
4752 };