| blob | 6f268756bf3632e376035e3b7402e29fb0319920 |
1 /*
2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
58 int
63 {
69 uint lock_flags;
91 /*
92 * If disk quotas is on, we make sure that the dquots do exist on disk,
93 * before we start any other transactions. Trying to do this later
94 * is messy. We don't care to take a readlock to look at the ids
95 * in inode here, because we can't hold it across the trans_reserve.
96 * If the IDs do change before we take the ilock, we're covered
97 * because the i_*dquot fields will get updated anyway.
98 */
107 }
113 }
115 /*
116 * We take a reference when we initialize udqp and gdqp,
117 * so it is important that we never blindly double trip on
118 * the same variable. See xfs_create() for an example.
119 */
126 }
128 /*
129 * For the other attributes, we acquire the inode lock and
130 * first do an error checking pass.
131 */
144 }
154 }
155 }
158 }
162 /*
163 * Change file ownership. Must be the owner or privileged.
164 */
166 /*
167 * These IDs could have changed since we last looked at them.
168 * But, we're assured that if the ownership did change
169 * while we didn't have the inode locked, inode's dquot(s)
170 * would have changed also.
171 */
177 /*
178 * Do a quota reservation only if uid/gid is actually
179 * going to change.
180 */
190 }
191 }
193 /*
194 * Truncate file. Must have write permission and not be a directory.
195 */
197 /* Short circuit the truncate case for zero length files */
206 }
214 }
216 /*
217 * Make sure that the dquots are attached to the inode.
218 */
223 /*
224 * Now we can make the changes. Before we join the inode
225 * to the transaction, if ATTR_SIZE is set then take care of
226 * the part of the truncation that must be done without the
227 * inode lock. This needs to be done before joining the inode
228 * to the transaction, because the inode cannot be unlocked
229 * once it is a part of the transaction.
230 */
232 /*
233 * Do the first part of growing a file: zero any data
234 * in the last block that is beyond the old EOF. We
235 * need to do this before the inode is joined to the
236 * transaction to modify the i_size.
237 */
239 }
242 /*
243 * We are going to log the inode size change in this
244 * transaction so any previous writes that are beyond the on
245 * disk EOF and the new EOF that have not been written out need
246 * to be written here. If we do not write the data out, we
247 * expose ourselves to the null files problem.
248 *
249 * Only flush from the on disk size to the smaller of the in
250 * memory file size or the new size as that's the range we
251 * really care about here and prevents waiting for other data
252 * not within the range we care about here.
253 */
260 }
262 /* wait for all I/O to complete */
272 }
276 XFS_TRANS_PERM_LOG_RES,
277 XFS_ITRUNCATE_LOG_COUNT))) {
282 }
289 /*
290 * Only change the c/mtime if we are changing the size
291 * or we are explicitly asked to change it. This handles
292 * the semantic difference between truncate() and ftruncate()
293 * as implemented in the VFS.
294 *
295 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME
296 * is a special case where we need to update the times despite
297 * not having these flags set. For all other operations the
298 * VFS set these flags explicitly if it wants a timestamp
299 * update.
300 */
306 }
314 /*
315 * signal a sync transaction unless
316 * we're truncating an already unlinked
317 * file on a wsync filesystem
318 */
320 XFS_DATA_FORK,
326 /*
327 * Truncated "down", so we're removing references
328 * to old data here - if we now delay flushing for
329 * a long time, we expose ourselves unduly to the
330 * notorious NULL files problem. So, we mark this
331 * vnode and flush it when the file is closed, and
332 * do not wait the usual (long) time for writeout.
333 */
335 }
339 }
341 /*
342 * Change file ownership. Must be the owner or privileged.
343 */
345 /*
346 * CAP_FSETID overrides the following restrictions:
347 *
348 * The set-user-ID and set-group-ID bits of a file will be
349 * cleared upon successful return from chown()
350 */
354 }
356 /*
357 * Change the ownerships and register quota modifications
358 * in the transaction.
359 */
366 }
369 }
377 }
380 }
381 }
383 /*
384 * Change file access modes.
385 */
397 }
399 /*
400 * Change file access or modified times.
401 */
407 }
413 }
419 }
421 /*
422 * And finally, log the inode core if any attribute in it
423 * has been changed.
424 */
431 /*
432 * If this is a synchronous mount, make sure that the
433 * transaction goes to disk before returning to the user.
434 * This is slightly sub-optimal in that truncates require
435 * two sync transactions instead of one for wsync filesystems.
436 * One for the truncate and one for the timestamps since we
437 * don't want to change the timestamps unless we're sure the
438 * truncate worked. Truncates are less than 1% of the laddis
439 * mix so this probably isn't worth the trouble to optimize.
440 */
449 /*
450 * Release any dquot(s) the inode had kept before chown.
451 */
460 /*
461 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
462 * update. We could avoid this with linked transactions
463 * and passing down the transaction pointer all the way
464 * to attr_set. No previous user of the generic
465 * Posix ACL code seems to care about this issue either.
466 */
471 }
478 }
481 abort_return:
483 /* FALLTHROUGH */
484 error_return:
489 }
492 }
494 }
496 /*
497 * The maximum pathlen is 1024 bytes. Since the minimum file system
498 * blocksize is 512 bytes, we can get a max of 2 extents back from
499 * bmapi.
500 */
501 #define SYMLINK_MAPS 2
503 STATIC int
507 {
512 xfs_daddr_t d;
535 }
542 }
547 out:
549 }
551 int
555 {
579 }
581 out:
584 }
586 /*
587 * xfs_fsync
588 *
589 * This is called to sync the inode and its data out to disk. We need to hold
590 * the I/O lock while flushing the data, and the inode lock while flushing the
591 * inode. The inode lock CANNOT be held while flushing the data, so acquire
592 * after we're done with that.
593 */
594 int
597 {
607 /*
608 * We always need to make sure that the required inode state is safe on
609 * disk. The inode might be clean but we still might need to force the
610 * log because of committed transactions that haven't hit the disk yet.
611 * Likewise, there could be unflushed non-transactional changes to the
612 * inode core that have to go to disk and this requires us to issue
613 * a synchronous transaction to capture these changes correctly.
614 *
615 * This code relies on the assumption that if the update_* fields
616 * of the inode are clear and the inode is unpinned then it is clean
617 * and no action is required.
618 */
622 /*
623 * Timestamps/size haven't changed since last inode flush or
624 * inode transaction commit. That means either nothing got
625 * written or a transaction committed which caught the updates.
626 * If the latter happened and the transaction hasn't hit the
627 * disk yet, the inode will be still be pinned. If it is,
628 * force the log.
629 */
638 /*
639 * If the inode is not pinned and nothing has changed
640 * we don't need to flush the cache.
641 */
643 }
645 /*
646 * Kick off a transaction to log the inode core to get the
647 * updates. The sync transaction will also force the log.
648 */
656 }
659 /*
660 * Note - it's possible that we might have pushed ourselves out
661 * of the way during trans_reserve which would flush the inode.
662 * But there's no guarantee that the inode buffer has actually
663 * gone out yet (it's delwri). Plus the buffer could be pinned
664 * anyway if it's part of an inode in another recent
665 * transaction. So we play it safe and fire off the
666 * transaction anyway.
667 */
675 }
678 /*
679 * If the log write didn't issue an ordered tag we need
680 * to flush the disk cache for the data device now.
681 */
685 /*
686 * If this inode is on the RT dev we need to flush that
687 * cache as well.
688 */
691 }
694 }
696 /*
697 * Flags for xfs_free_eofblocks
698 */
699 #define XFS_FREE_EOF_TRYLOCK (1<<0)
701 /*
702 * This is called by xfs_inactive to free any blocks beyond eof
703 * when the link count isn't zero and by xfs_dm_punch_hole() when
704 * punching a hole to EOF.
705 */
706 STATIC int
711 {
714 xfs_fileoff_t end_fsb;
715 xfs_fileoff_t last_fsb;
716 xfs_filblks_t map_len;
718 xfs_bmbt_irec_t imap;
720 /*
721 * Figure out if there are any blocks beyond the end
722 * of the file. If not, then there is nothing to do.
723 */
739 /*
740 * Attach the dquots to the inode up front.
741 */
746 /*
747 * There are blocks after the end of file.
748 * Free them up now by truncating the file to
749 * its current size.
750 */
753 /*
754 * Do the xfs_itruncate_start() call before
755 * reserving any log space because
756 * itruncate_start will call into the buffer
757 * cache and we can't
758 * do that within a transaction.
759 */
764 }
767 }
774 }
779 XFS_ITRUNCATE_LOG_COUNT);
785 }
789 XFS_IOLOCK_EXCL |
790 XFS_ILOCK_EXCL);
795 XFS_DATA_FORK,
797 /*
798 * If we get an error at this point we
799 * simply don't bother truncating the file.
800 */
804 XFS_TRANS_ABORT));
807 XFS_TRANS_RELEASE_LOG_RES);
808 }
810 }
812 }
814 /*
815 * Free a symlink that has blocks associated with it.
816 */
817 STATIC int
821 {
826 xfs_fsblock_t first_block;
827 xfs_bmap_free_t free_list;
839 /*
840 * We're freeing a symlink that has some
841 * blocks allocated to it. Free the
842 * blocks here. We know that we've got
843 * either 1 or 2 extents and that we can
844 * free them all in one bunmapi call.
845 */
853 }
854 /*
855 * Lock the inode, fix the size, and join it to the transaction.
856 * Hold it so in the normal path, we still have it locked for
857 * the second transaction. In the error paths we need it
858 * held so the cancel won't rele it, see below.
859 */
866 /*
867 * Find the block(s) so we can inval and unmap them.
868 */
876 /*
877 * Invalidate the block(s).
878 */
884 }
885 /*
886 * Unmap the dead block(s) to the free_list.
887 */
892 /*
893 * Commit the first transaction. This logs the EFI and the inode.
894 */
897 /*
898 * The transaction must have been committed, since there were
899 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
900 * The new tp has the extent freeing and EFDs.
901 */
903 /*
904 * The first xact was committed, so add the inode to the new one.
905 * Mark it dirty so it will be logged and moved forward in the log as
906 * part of every commit.
907 */
911 /*
912 * Get a new, empty transaction to return to our caller.
913 */
915 /*
916 * Commit the transaction containing extent freeing and EFDs.
917 * If we get an error on the commit here or on the reserve below,
918 * we need to unlock the inode since the new transaction doesn't
919 * have the inode attached.
920 */
926 }
927 /*
928 * transaction commit worked ok so we can drop the extra ticket
929 * reference that we gained in xfs_trans_dup()
930 */
933 /*
934 * Remove the memory for extent descriptions (just bookkeeping).
935 */
939 /*
940 * Put an itruncate log reservation in the new transaction
941 * for our caller.
942 */
947 }
948 /*
949 * Return with the inode locked but not joined to the transaction.
950 */
954 error1:
956 error0:
957 /*
958 * Have to come here with the inode locked and either
959 * (held and in the transaction) or (not in the transaction).
960 * If the inode isn't held then cancel would iput it, but
961 * that's wrong since this is inactive and the vnode ref
962 * count is 0 already.
963 * Cancel won't do anything to the inode if held, but it still
964 * needs to be locked until the cancel is done, if it was
965 * joined to the transaction.
966 */
972 }
974 STATIC int
978 {
982 /*
983 * We're freeing a symlink which fit into
984 * the inode. Just free the memory used
985 * to hold the old symlink.
986 */
990 XFS_ITRUNCATE_LOG_COUNT);
996 }
999 /*
1000 * Zero length symlinks _can_ exist.
1001 */
1005 XFS_DATA_FORK);
1007 }
1009 }
1011 STATIC int
1015 {
1037 XFS_INACTIVE_LOG_COUNT);
1051 error_cancel:
1054 error_unlock:
1058 }
1060 int
1063 {
1070 /* If this is a read-only mount, don't do this (would generate I/O) */
1077 /*
1078 * If we are using filestreams, and we have an unlinked
1079 * file that we are processing the last close on, then nothing
1080 * will be able to reopen and write to this file. Purge this
1081 * inode from the filestreams cache so that it doesn't delay
1082 * teardown of the inode.
1083 */
1087 /*
1088 * If we previously truncated this file and removed old data
1089 * in the process, we want to initiate "early" writeout on
1090 * the last close. This is an attempt to combat the notorious
1091 * NULL files problem which is particularly noticable from a
1092 * truncate down, buffered (re-)write (delalloc), followed by
1093 * a crash. What we are effectively doing here is
1094 * significantly reducing the time window where we'd otherwise
1095 * be exposed to that problem.
1096 */
1100 }
1110 /*
1111 * If we can't get the iolock just skip truncating
1112 * the blocks past EOF because we could deadlock
1113 * with the mmap_sem otherwise. We'll get another
1114 * chance to drop them once the last reference to
1115 * the inode is dropped, so we'll never leak blocks
1116 * permanently.
1117 */
1119 XFS_FREE_EOF_TRYLOCK);
1122 }
1123 }
1126 }
1128 /*
1129 * xfs_inactive
1130 *
1131 * This is called when the vnode reference count for the vnode
1132 * goes to zero. If the file has been unlinked, then it must
1133 * now be truncated. Also, we clear all of the read-ahead state
1134 * kept for the inode here since the file is now closed.
1135 */
1136 int
1139 {
1140 xfs_bmap_free_t free_list;
1141 xfs_fsblock_t first_block;
1150 /*
1151 * If the inode is already free, then there can be nothing
1152 * to clean up here.
1153 */
1158 }
1160 /*
1161 * Only do a truncate if it's a regular file with
1162 * some actual space in it. It's OK to look at the
1163 * inode's fields without the lock because we're the
1164 * only one with a reference to the inode.
1165 */
1178 /* If this is a read-only mount, don't do this (would generate I/O) */
1193 }
1195 }
1205 /*
1206 * Do the xfs_itruncate_start() call before
1207 * reserving any log space because itruncate_start
1208 * will call into the buffer cache and we can't
1209 * do that within a transaction.
1210 */
1218 }
1223 XFS_ITRUNCATE_LOG_COUNT);
1225 /* Don't call itruncate_cleanup */
1230 }
1236 /*
1237 * normally, we have to run xfs_itruncate_finish sync.
1238 * But if filesystem is wsync and we're in the inactive
1239 * path, then we know that nlink == 0, and that the
1240 * xaction that made nlink == 0 is permanently committed
1241 * since xfs_remove runs as a synchronous transaction.
1242 */
1251 }
1254 /*
1255 * If we get an error while cleaning up a
1256 * symlink we bail out.
1257 */
1265 }
1273 XFS_INACTIVE_LOG_COUNT);
1278 }
1283 }
1285 /*
1286 * If there are attributes associated with the file
1287 * then blow them away now. The code calls a routine
1288 * that recursively deconstructs the attribute fork.
1289 * We need to just commit the current transaction
1290 * because we can't use it for xfs_attr_inactive().
1291 */
1294 /*
1295 * If we got an error, the transaction is already
1296 * cancelled, and the inode is unlocked. Just get out.
1297 */
1302 }
1304 /*
1305 * Free the inode.
1306 */
1310 /*
1311 * If we fail to free the inode, shut down. The cancel
1312 * might do that, we need to make sure. Otherwise the
1313 * inode might be lost for a long time or forever.
1314 */
1320 }
1323 /*
1324 * Credit the quota account(s). The inode is gone.
1325 */
1328 /*
1329 * Just ignore errors at this point. There is nothing we can
1330 * do except to try to keep going. Make sure it's not a silent
1331 * error.
1332 */
1341 }
1343 /*
1344 * Release the dquots held by inode, if any.
1345 */
1349 out:
1351 }
1353 /*
1354 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1355 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1356 * ci_name->name will point to a the actual name (caller must free) or
1357 * will be set to NULL if an exact match is found.
1358 */
1359 int
1365 {
1366 xfs_ino_t inum;
1368 uint lock_mode;
1388 out_free_name:
1391 out:
1394 }
1396 int
1400 mode_t mode,
1401 xfs_dev_t rdev,
1404 {
1410 xfs_bmap_free_t free_list;
1411 xfs_fsblock_t first_block;
1413 uint cancel_flags;
1415 xfs_prid_t prid;
1418 uint resblks;
1419 uint log_res;
1420 uint log_count;
1435 }
1439 else
1442 /*
1443 * Make sure that we have allocated dquot(s) on disk.
1444 */
1461 }
1465 /*
1466 * Initially assume that the file does not exist and
1467 * reserve the resources for that case. If that is not
1468 * the case we'll drop the one we have and get a more
1469 * appropriate transaction later.
1470 */
1474 /* flush outstanding delalloc blocks and retry */
1478 }
1480 /* No space at all so try a "no-allocation" reservation */
1484 }
1488 }
1493 /*
1494 * Check for directory link count overflow.
1495 */
1499 }
1503 /*
1504 * Reserve disk quota and the inode.
1505 */
1514 /*
1515 * A newly created regular or special file just has one directory
1516 * entry pointing to them, but a directory also the "." entry
1517 * pointing to itself.
1518 */
1525 }
1527 /*
1528 * At this point, we've gotten a newly allocated inode.
1529 * It is locked (and joined to the transaction).
1530 */
1533 /*
1534 * Now we join the directory inode to the transaction. We do not do it
1535 * earlier because xfs_dir_ialloc might commit the previous transaction
1536 * (and release all the locks). An error from here on will result in
1537 * the transaction cancel unlocking dp so don't do it explicitly in the
1538 * error path.
1539 */
1550 }
1562 }
1564 /*
1565 * If this is a synchronous mount, make sure that the
1566 * create transaction goes to disk before returning to
1567 * the user.
1568 */
1572 /*
1573 * Attach the dquot(s) to the inodes and modify them incore.
1574 * These ids of the inode couldn't have changed since the new
1575 * inode has been locked ever since it was created.
1576 */
1579 /*
1580 * xfs_trans_commit normally decrements the vnode ref count
1581 * when it unlocks the inode. Since we want to return the
1582 * vnode to the caller, we bump the vnode ref count now.
1583 */
1594 }
1601 /* Fallthrough to std_return with error = 0 */
1602 std_return:
1607 }
1611 out_bmap_cancel:
1613 out_trans_abort:
1615 out_trans_cancel:
1617 out_dqrele:
1626 out_abort_rele:
1627 /*
1628 * Wait until after the current transaction is aborted to
1629 * release the inode. This prevents recursive transactions
1630 * and deadlocks from xfs_inactive.
1631 */
1638 }
1640 #ifdef DEBUG
1646 #endif
1648 /*
1649 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1650 * a different value
1651 */
1654 {
1661 }
1663 /*
1664 * The following routine will lock n inodes in exclusive mode.
1665 * We assume the caller calls us with the inodes in i_ino order.
1666 *
1667 * We need to detect deadlock where an inode that we lock
1668 * is in the AIL and we start waiting for another inode that is locked
1669 * by a thread in a long running transaction (such as truncate). This can
1670 * result in deadlock since the long running trans might need to wait
1671 * for the inode we just locked in order to push the tail and free space
1672 * in the log.
1673 */
1674 void
1678 uint lock_mode)
1679 {
1688 again:
1695 /*
1696 * If try_lock is not set yet, make sure all locked inodes
1697 * are not in the AIL.
1698 * If any are, set try_lock to be used later.
1699 */
1705 try_lock++;
1706 }
1707 }
1708 }
1710 /*
1711 * If any of the previous locks we have locked is in the AIL,
1712 * we must TRY to get the second and subsequent locks. If
1713 * we can't get any, we must release all we have
1714 * and try again.
1715 */
1718 /* try_lock must be 0 if i is 0. */
1719 /*
1720 * try_lock means we have an inode locked
1721 * that is in the AIL.
1722 */
1725 attempts++;
1727 /*
1728 * Unlock all previous guys and try again.
1729 * xfs_iunlock will try to push the tail
1730 * if the inode is in the AIL.
1731 */
1735 /*
1736 * Check to see if we've already
1737 * unlocked this one.
1738 * Not the first one going back,
1739 * and the inode ptr is the same.
1740 */
1746 }
1750 #ifdef DEBUG
1751 xfs_lock_delays++;
1752 #endif
1753 }
1757 }
1760 }
1761 }
1763 #ifdef DEBUG
1769 xfs_locked_n++;
1770 }
1771 #endif
1772 }
1774 /*
1775 * xfs_lock_two_inodes() can only be used to lock one type of lock
1776 * at a time - the iolock or the ilock, but not both at once. If
1777 * we lock both at once, lockdep will report false positives saying
1778 * we have violated locking orders.
1779 */
1780 void
1784 uint lock_mode)
1785 {
1798 }
1800 again:
1803 /*
1804 * If the first lock we have locked is in the AIL, we must TRY to get
1805 * the second lock. If we can't get it, we must release the first one
1806 * and try again.
1807 */
1815 }
1818 }
1819 }
1821 int
1826 {
1831 xfs_bmap_free_t free_list;
1832 xfs_fsblock_t first_block;
1836 uint resblks;
1837 uint log_count;
1851 }
1867 }
1870 /*
1871 * We try to get the real space reservation first,
1872 * allowing for directory btree deletion(s) implying
1873 * possible bmap insert(s). If we can't get the space
1874 * reservation then we use 0 instead, and avoid the bmap
1875 * btree insert(s) in the directory code by, if the bmap
1876 * insert tries to happen, instead trimming the LAST
1877 * block from the directory.
1878 */
1886 }
1891 }
1895 /*
1896 * At this point, we've gotten both the directory and the entry
1897 * inodes locked.
1898 */
1905 /*
1906 * If we're removing a directory perform some additional validation.
1907 */
1913 }
1917 }
1918 }
1926 }
1930 /*
1931 * Drop the link from ip's "..".
1932 */
1937 /*
1938 * Drop the "." link from ip to self.
1939 */
1944 /*
1945 * When removing a non-directory we need to log the parent
1946 * inode here. For a directory this is done implicitly
1947 * by the xfs_droplink call for the ".." entry.
1948 */
1950 }
1952 /*
1953 * Drop the link from dp to ip.
1954 */
1959 /*
1960 * Determine if this is the last link while
1961 * we are in the transaction.
1962 */
1965 /*
1966 * If this is a synchronous mount, make sure that the
1967 * remove transaction goes to disk before returning to
1968 * the user.
1969 */
1981 /*
1982 * If we are using filestreams, kill the stream association.
1983 * If the file is still open it may get a new one but that
1984 * will get killed on last close in xfs_close() so we don't
1985 * have to worry about that.
1986 */
1990 std_return:
1995 }
1999 out_bmap_cancel:
2002 out_trans_cancel:
2005 }
2007 int
2012 {
2016 xfs_bmap_free_t free_list;
2017 xfs_fsblock_t first_block;
2037 }
2039 /* Return through std_return after this point. */
2058 }
2062 }
2066 /*
2067 * Increment vnode ref counts since xfs_trans_commit &
2068 * xfs_trans_cancel will both unlock the inodes and
2069 * decrement the associated ref counts.
2070 */
2076 /*
2077 * If the source has too many links, we can't make any more to it.
2078 */
2082 }
2084 /*
2085 * If we are using project inheritance, we only allow hard link
2086 * creation in our tree when the project IDs are the same; else
2087 * the tree quota mechanism could be circumvented.
2088 */
2093 }
2112 /*
2113 * If this is a synchronous mount, make sure that the
2114 * link transaction goes to disk before returning to
2115 * the user.
2116 */
2119 }
2125 }
2131 /* Fall through to std_return with error = 0. */
2132 std_return:
2138 }
2141 abort_return:
2143 /* FALLTHROUGH */
2145 error_return:
2148 }
2150 int
2155 mode_t mode,
2158 {
2164 xfs_bmap_free_t free_list;
2165 xfs_fsblock_t first_block;
2167 uint cancel_flags;
2169 xfs_fileoff_t first_fsb;
2170 xfs_filblks_t fs_blocks;
2173 xfs_daddr_t d;
2178 xfs_prid_t prid;
2180 uint resblks;
2192 /*
2193 * Check component lengths of the target path name.
2194 */
2205 }
2207 /* Return through std_return after this point. */
2212 else
2215 /*
2216 * Make sure that we have allocated dquot(s) on disk.
2217 */
2225 /*
2226 * The symlink will fit into the inode data fork?
2227 * There can't be any attributes so we get the whole variable part.
2228 */
2231 else
2240 }
2244 }
2249 /*
2250 * Check whether the directory allows new symlinks or not.
2251 */
2255 }
2257 /*
2258 * Reserve disk quota : blocks and inode.
2259 */
2264 /*
2265 * Check for ability to enter directory entry, if no space reserved.
2266 */
2270 /*
2271 * Initialize the bmap freelist prior to calling either
2272 * bmapi or the directory create code.
2273 */
2276 /*
2277 * Allocate an inode for the symlink.
2278 */
2285 }
2287 /*
2288 * An error after we've joined dp to the transaction will result in the
2289 * transaction cancel unlocking dp so don't do it explicitly in the
2290 * error path.
2291 */
2296 /*
2297 * Also attach the dquot(s) to it, if applicable.
2298 */
2303 /*
2304 * If the symlink will fit into the inode, write it inline.
2305 */
2311 /*
2312 * The inode was initially created in extent format.
2313 */
2330 }
2346 }
2353 }
2354 }
2356 /*
2357 * Create the directory entry for the symlink.
2358 */
2366 /*
2367 * If this is a synchronous mount, make sure that the
2368 * symlink transaction goes to disk before returning to
2369 * the user.
2370 */
2373 }
2375 /*
2376 * xfs_trans_commit normally decrements the vnode ref count
2377 * when it unlocks the inode. Since we want to return the
2378 * vnode to the caller, we bump the vnode ref count now.
2379 */
2385 }
2390 /* Fall through to std_return with error = 0 or errno from
2391 * xfs_trans_commit */
2392 std_return:
2399 }
2405 error2:
2407 error1:
2410 error_return:
2419 }
2421 int
2424 u_int evmask,
2425 u_int16_t state)
2426 {
2442 }
2454 }
2456 /*
2457 * xfs_alloc_file_space()
2458 * This routine allocates disk space for the given file.
2459 *
2460 * If alloc_type == 0, this request is for an ALLOCSP type
2461 * request which will change the file size. In this case, no
2462 * DMAPI event will be generated by the call. A TRUNCATE event
2463 * will be generated later by xfs_setattr.
2464 *
2465 * If alloc_type != 0, this request is for a RESVSP type
2466 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2467 * lower block boundary byte address is less than the file's
2468 * length.
2469 *
2470 * RETURNS:
2471 * 0 on success
2472 * errno on error
2473 *
2474 */
2475 STATIC int
2478 xfs_off_t offset,
2479 xfs_off_t len,
2482 {
2484 xfs_off_t count;
2485 xfs_filblks_t allocated_fsb;
2486 xfs_filblks_t allocatesize_fsb;
2488 xfs_fileoff_t startoffset_fsb;
2489 xfs_fsblock_t firstfsb;
2496 xfs_bmap_free_t free_list;
2523 /* Generate a DMAPI event if needed. */
2527 xfs_off_t end_dmi_offset;
2536 }
2538 /*
2539 * Allocate file space until done or until there is an error
2540 */
2541 retry:
2545 /*
2546 * Determine space reservations for data/realtime.
2547 */
2560 }
2572 }
2574 /*
2575 * Allocate and setup the transaction.
2576 */
2580 XFS_TRANS_PERM_LOG_RES,
2581 XFS_WRITE_LOG_COUNT);
2582 /*
2583 * Check for running out of space
2584 */
2586 /*
2587 * Free the transaction structure.
2588 */
2592 }
2602 /*
2603 * Issue the xfs_bmapi() call to allocate the blocks
2604 */
2612 }
2614 /*
2615 * Complete the transaction
2616 */
2620 }
2626 }
2633 }
2637 }
2638 dmapi_enospc_check:
2647 /* else fall through with error from XFS_SEND_DATA */
2648 }
2660 }
2662 /*
2663 * Zero file bytes between startoff and endoff inclusive.
2664 * The iolock is held exclusive and no blocks are buffered.
2665 *
2666 * This function is used by xfs_free_file_space() to zero
2667 * partial blocks when the range to free is not block aligned.
2668 * When unreserving space with boundaries that are not block
2669 * aligned we round up the start and round down the end
2670 * boundaries and then use this function to zero the parts of
2671 * the blocks that got dropped during the rounding.
2672 */
2673 STATIC int
2676 xfs_off_t startoff,
2677 xfs_off_t endoff)
2678 {
2679 xfs_bmbt_irec_t imap;
2680 xfs_fileoff_t offset_fsb;
2681 xfs_off_t lastoffset;
2682 xfs_off_t offset;
2688 /*
2689 * Avoid doing I/O beyond eof - it's not necessary
2690 * since nothing can read beyond eof. The space will
2691 * be zeroed when the file is extended anyway.
2692 */
2732 }
2745 }
2746 }
2749 }
2751 /*
2752 * xfs_free_file_space()
2753 * This routine frees disk space for the given file.
2754 *
2755 * This routine is only called by xfs_change_file_space
2756 * for an UNRESVSP type call.
2757 *
2758 * RETURNS:
2759 * 0 on success
2760 * errno on error
2761 *
2762 */
2763 STATIC int
2766 xfs_off_t offset,
2767 xfs_off_t len,
2769 {
2772 xfs_off_t end_dmi_offset;
2773 xfs_fileoff_t endoffset_fsb;
2775 xfs_fsblock_t firstfsb;
2776 xfs_bmap_free_t free_list;
2777 xfs_bmbt_irec_t imap;
2778 xfs_off_t ioffset;
2782 uint resblks;
2783 uint rounding;
2785 xfs_fileoff_t startoffset_fsb;
2814 }
2820 /* wait for the completion of any pending DIOs */
2822 }
2831 }
2833 /*
2834 * Need to zero the stuff we're not freeing, on disk.
2835 * If it's a realtime file & can't use unwritten extents then we
2836 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2837 * will take care of it for us.
2838 */
2847 xfs_daddr_t block;
2854 }
2863 mod++;
2866 }
2867 }
2869 /*
2870 * One contiguous piece to clear
2871 */
2874 /*
2875 * Some full blocks, possibly two pieces to clear
2876 */
2885 }
2887 /*
2888 * free file space until done or until there is an error
2889 */
2893 /*
2894 * allocate and setup the transaction. Allow this
2895 * transaction to dip into the reserve blocks to ensure
2896 * the freeing of the space succeeds at ENOSPC.
2897 */
2901 resblks,
2904 XFS_TRANS_PERM_LOG_RES,
2905 XFS_WRITE_LOG_COUNT);
2907 /*
2908 * check for running out of space
2909 */
2911 /*
2912 * Free the transaction structure.
2913 */
2917 }
2928 /*
2929 * issue the bunmapi() call to free the blocks
2930 */
2937 }
2939 /*
2940 * complete the transaction
2941 */
2945 }
2949 }
2951 out_unlock_iolock:
2956 error0:
2958 error1:
2961 XFS_ILOCK_EXCL);
2963 }
2965 /*
2966 * xfs_change_file_space()
2967 * This routine allocates or frees disk space for the given file.
2968 * The user specified parameters are checked for alignment and size
2969 * limitations.
2970 *
2971 * RETURNS:
2972 * 0 on success
2973 * errno on error
2974 *
2975 */
2976 int
2981 xfs_off_t offset,
2983 {
2987 xfs_fsize_t fsize;
2989 xfs_off_t startoffset;
2990 xfs_off_t llen;
3010 }
3025 /*
3026 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
3027 * file space.
3028 * These calls do NOT zero the data space allocated to the file,
3029 * nor do they change the file size.
3030 *
3031 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
3032 * space.
3033 * These calls cause the new file data to be zeroed and the file
3034 * size to be changed.
3035 */
3051 attr_flags)))
3064 }
3080 }
3082 /*
3083 * update the inode timestamp, mode, and prealloc flag bits
3084 */
3089 /* ASSERT(0); */
3092 }
3102 /*
3103 * Note that we don't have to worry about mandatory
3104 * file locking being disabled here because we only
3105 * clear the S_ISGID bit if the Group execute bit is
3106 * on, but if it was on then mandatory locking wouldn't
3107 * have been enabled.
3108 */
3113 }
3127 }