| blob | b572f7e840e0b82a372225581d87c85c104dfec6 |
1 /*
2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
57 int
62 {
68 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 */
146 }
147 }
157 }
158 }
161 }
165 /*
166 * Change file ownership. Must be the owner or privileged.
167 */
169 /*
170 * These IDs could have changed since we last looked at them.
171 * But, we're assured that if the ownership did change
172 * while we didn't have the inode locked, inode's dquot(s)
173 * would have changed also.
174 */
180 /*
181 * Do a quota reservation only if uid/gid is actually
182 * going to change.
183 */
193 }
194 }
196 /*
197 * Truncate file. Must have write permission and not be a directory.
198 */
200 /* Short circuit the truncate case for zero length files */
209 }
217 }
219 /*
220 * Make sure that the dquots are attached to the inode.
221 */
226 /*
227 * Now we can make the changes. Before we join the inode
228 * to the transaction, if ATTR_SIZE is set then take care of
229 * the part of the truncation that must be done without the
230 * inode lock. This needs to be done before joining the inode
231 * to the transaction, because the inode cannot be unlocked
232 * once it is a part of the transaction.
233 */
235 /*
236 * Do the first part of growing a file: zero any data
237 * in the last block that is beyond the old EOF. We
238 * need to do this before the inode is joined to the
239 * transaction to modify the i_size.
240 */
242 }
245 /*
246 * We are going to log the inode size change in this
247 * transaction so any previous writes that are beyond the on
248 * disk EOF and the new EOF that have not been written out need
249 * to be written here. If we do not write the data out, we
250 * expose ourselves to the null files problem.
251 *
252 * Only flush from the on disk size to the smaller of the in
253 * memory file size or the new size as that's the range we
254 * really care about here and prevents waiting for other data
255 * not within the range we care about here.
256 */
263 }
265 /* wait for all I/O to complete */
275 }
279 XFS_TRANS_PERM_LOG_RES,
280 XFS_ITRUNCATE_LOG_COUNT))) {
285 }
292 /*
293 * Only change the c/mtime if we are changing the size
294 * or we are explicitly asked to change it. This handles
295 * the semantic difference between truncate() and ftruncate()
296 * as implemented in the VFS.
297 */
309 /*
310 * signal a sync transaction unless
311 * we're truncating an already unlinked
312 * file on a wsync filesystem
313 */
315 XFS_DATA_FORK,
321 /*
322 * Truncated "down", so we're removing references
323 * to old data here - if we now delay flushing for
324 * a long time, we expose ourselves unduly to the
325 * notorious NULL files problem. So, we mark this
326 * vnode and flush it when the file is closed, and
327 * do not wait the usual (long) time for writeout.
328 */
330 }
334 }
336 /*
337 * Change file ownership. Must be the owner or privileged.
338 */
340 /*
341 * CAP_FSETID overrides the following restrictions:
342 *
343 * The set-user-ID and set-group-ID bits of a file will be
344 * cleared upon successful return from chown()
345 */
349 }
351 /*
352 * Change the ownerships and register quota modifications
353 * in the transaction.
354 */
361 }
364 }
372 }
375 }
379 }
381 /*
382 * Change file access modes.
383 */
398 }
400 /*
401 * Change file access or modified times.
402 */
409 }
416 }
419 }
421 /*
422 * Change file inode change time only if ATTR_CTIME set
423 * AND we have been called by a DMI function.
424 */
432 }
434 /*
435 * Send out timestamp changes that need to be set to the
436 * current time. Not done when called by a DMI function.
437 */
443 /*
444 * If this is a synchronous mount, make sure that the
445 * transaction goes to disk before returning to the user.
446 * This is slightly sub-optimal in that truncates require
447 * two sync transactions instead of one for wsync filesystems.
448 * One for the truncate and one for the timestamps since we
449 * don't want to change the timestamps unless we're sure the
450 * truncate worked. Truncates are less than 1% of the laddis
451 * mix so this probably isn't worth the trouble to optimize.
452 */
459 }
463 /*
464 * Release any dquot(s) the inode had kept before chown.
465 */
474 /*
475 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
476 * update. We could avoid this with linked transactions
477 * and passing down the transaction pointer all the way
478 * to attr_set. No previous user of the generic
479 * Posix ACL code seems to care about this issue either.
480 */
485 }
492 }
495 abort_return:
497 /* FALLTHROUGH */
498 error_return:
503 }
506 }
508 }
510 /*
511 * The maximum pathlen is 1024 bytes. Since the minimum file system
512 * blocksize is 512 bytes, we can get a max of 2 extents back from
513 * bmapi.
514 */
515 #define SYMLINK_MAPS 2
517 STATIC int
521 {
526 xfs_daddr_t d;
543 XBF_DONT_BLOCK);
550 }
557 }
562 out:
564 }
566 int
570 {
594 }
596 out:
599 }
601 /*
602 * xfs_fsync
603 *
604 * This is called to sync the inode and its data out to disk. We need to hold
605 * the I/O lock while flushing the data, and the inode lock while flushing the
606 * inode. The inode lock CANNOT be held while flushing the data, so acquire
607 * after we're done with that.
608 */
609 int
612 {
622 /*
623 * We always need to make sure that the required inode state is safe on
624 * disk. The inode might be clean but we still might need to force the
625 * log because of committed transactions that haven't hit the disk yet.
626 * Likewise, there could be unflushed non-transactional changes to the
627 * inode core that have to go to disk and this requires us to issue
628 * a synchronous transaction to capture these changes correctly.
629 *
630 * This code relies on the assumption that if the update_* fields
631 * of the inode are clear and the inode is unpinned then it is clean
632 * and no action is required.
633 */
637 /*
638 * Timestamps/size haven't changed since last inode flush or
639 * inode transaction commit. That means either nothing got
640 * written or a transaction committed which caught the updates.
641 * If the latter happened and the transaction hasn't hit the
642 * disk yet, the inode will be still be pinned. If it is,
643 * force the log.
644 */
653 /*
654 * If the inode is not pinned and nothing has changed
655 * we don't need to flush the cache.
656 */
658 }
660 /*
661 * Kick off a transaction to log the inode core to get the
662 * updates. The sync transaction will also force the log.
663 */
671 }
674 /*
675 * Note - it's possible that we might have pushed ourselves out
676 * of the way during trans_reserve which would flush the inode.
677 * But there's no guarantee that the inode buffer has actually
678 * gone out yet (it's delwri). Plus the buffer could be pinned
679 * anyway if it's part of an inode in another recent
680 * transaction. So we play it safe and fire off the
681 * transaction anyway.
682 */
690 }
693 /*
694 * If the log write didn't issue an ordered tag we need
695 * to flush the disk cache for the data device now.
696 */
700 /*
701 * If this inode is on the RT dev we need to flush that
702 * cache as well.
703 */
706 }
709 }
711 /*
712 * This is called by xfs_inactive to free any blocks beyond eof
713 * when the link count isn't zero and by xfs_dm_punch_hole() when
714 * punching a hole to EOF.
715 */
716 STATIC int
721 {
724 xfs_fileoff_t end_fsb;
725 xfs_fileoff_t last_fsb;
726 xfs_filblks_t map_len;
728 xfs_bmbt_irec_t imap;
731 /*
732 * Figure out if there are any blocks beyond the end
733 * of the file. If not, then there is nothing to do.
734 */
750 /*
751 * Attach the dquots to the inode up front.
752 */
757 /*
758 * There are blocks after the end of file.
759 * Free them up now by truncating the file to
760 * its current size.
761 */
764 /*
765 * Do the xfs_itruncate_start() call before
766 * reserving any log space because
767 * itruncate_start will call into the buffer
768 * cache and we can't
769 * do that within a transaction.
770 */
780 }
785 XFS_ITRUNCATE_LOG_COUNT);
791 }
795 XFS_IOLOCK_EXCL |
796 XFS_ILOCK_EXCL);
801 XFS_DATA_FORK,
803 /*
804 * If we get an error at this point we
805 * simply don't bother truncating the file.
806 */
810 XFS_TRANS_ABORT));
813 XFS_TRANS_RELEASE_LOG_RES);
814 }
817 }
819 }
821 /*
822 * Free a symlink that has blocks associated with it.
823 */
824 STATIC int
828 {
833 xfs_fsblock_t first_block;
834 xfs_bmap_free_t free_list;
846 /*
847 * We're freeing a symlink that has some
848 * blocks allocated to it. Free the
849 * blocks here. We know that we've got
850 * either 1 or 2 extents and that we can
851 * free them all in one bunmapi call.
852 */
860 }
861 /*
862 * Lock the inode, fix the size, and join it to the transaction.
863 * Hold it so in the normal path, we still have it locked for
864 * the second transaction. In the error paths we need it
865 * held so the cancel won't rele it, see below.
866 */
873 /*
874 * Find the block(s) so we can inval and unmap them.
875 */
883 /*
884 * Invalidate the block(s).
885 */
891 }
892 /*
893 * Unmap the dead block(s) to the free_list.
894 */
899 /*
900 * Commit the first transaction. This logs the EFI and the inode.
901 */
904 /*
905 * The transaction must have been committed, since there were
906 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
907 * The new tp has the extent freeing and EFDs.
908 */
910 /*
911 * The first xact was committed, so add the inode to the new one.
912 * Mark it dirty so it will be logged and moved forward in the log as
913 * part of every commit.
914 */
918 /*
919 * Get a new, empty transaction to return to our caller.
920 */
922 /*
923 * Commit the transaction containing extent freeing and EFDs.
924 * If we get an error on the commit here or on the reserve below,
925 * we need to unlock the inode since the new transaction doesn't
926 * have the inode attached.
927 */
933 }
934 /*
935 * transaction commit worked ok so we can drop the extra ticket
936 * reference that we gained in xfs_trans_dup()
937 */
940 /*
941 * Remove the memory for extent descriptions (just bookkeeping).
942 */
946 /*
947 * Put an itruncate log reservation in the new transaction
948 * for our caller.
949 */
954 }
955 /*
956 * Return with the inode locked but not joined to the transaction.
957 */
961 error1:
963 error0:
964 /*
965 * Have to come here with the inode locked and either
966 * (held and in the transaction) or (not in the transaction).
967 * If the inode isn't held then cancel would iput it, but
968 * that's wrong since this is inactive and the vnode ref
969 * count is 0 already.
970 * Cancel won't do anything to the inode if held, but it still
971 * needs to be locked until the cancel is done, if it was
972 * joined to the transaction.
973 */
979 }
981 STATIC int
985 {
989 /*
990 * We're freeing a symlink which fit into
991 * the inode. Just free the memory used
992 * to hold the old symlink.
993 */
997 XFS_ITRUNCATE_LOG_COUNT);
1003 }
1006 /*
1007 * Zero length symlinks _can_ exist.
1008 */
1012 XFS_DATA_FORK);
1014 }
1016 }
1018 STATIC int
1022 {
1044 XFS_INACTIVE_LOG_COUNT);
1058 error_cancel:
1061 error_unlock:
1065 }
1067 int
1070 {
1077 /* If this is a read-only mount, don't do this (would generate I/O) */
1084 /*
1085 * If we are using filestreams, and we have an unlinked
1086 * file that we are processing the last close on, then nothing
1087 * will be able to reopen and write to this file. Purge this
1088 * inode from the filestreams cache so that it doesn't delay
1089 * teardown of the inode.
1090 */
1094 /*
1095 * If we previously truncated this file and removed old data
1096 * in the process, we want to initiate "early" writeout on
1097 * the last close. This is an attempt to combat the notorious
1098 * NULL files problem which is particularly noticable from a
1099 * truncate down, buffered (re-)write (delalloc), followed by
1100 * a crash. What we are effectively doing here is
1101 * significantly reducing the time window where we'd otherwise
1102 * be exposed to that problem.
1103 */
1107 }
1119 }
1120 }
1123 }
1125 /*
1126 * xfs_inactive
1127 *
1128 * This is called when the vnode reference count for the vnode
1129 * goes to zero. If the file has been unlinked, then it must
1130 * now be truncated. Also, we clear all of the read-ahead state
1131 * kept for the inode here since the file is now closed.
1132 */
1133 int
1136 {
1137 xfs_bmap_free_t free_list;
1138 xfs_fsblock_t first_block;
1147 /*
1148 * If the inode is already free, then there can be nothing
1149 * to clean up here.
1150 */
1155 }
1157 /*
1158 * Only do a truncate if it's a regular file with
1159 * some actual space in it. It's OK to look at the
1160 * inode's fields without the lock because we're the
1161 * only one with a reference to the inode.
1162 */
1175 /* If this is a read-only mount, don't do this (would generate I/O) */
1190 }
1192 }
1202 /*
1203 * Do the xfs_itruncate_start() call before
1204 * reserving any log space because itruncate_start
1205 * will call into the buffer cache and we can't
1206 * do that within a transaction.
1207 */
1215 }
1220 XFS_ITRUNCATE_LOG_COUNT);
1222 /* Don't call itruncate_cleanup */
1227 }
1233 /*
1234 * normally, we have to run xfs_itruncate_finish sync.
1235 * But if filesystem is wsync and we're in the inactive
1236 * path, then we know that nlink == 0, and that the
1237 * xaction that made nlink == 0 is permanently committed
1238 * since xfs_remove runs as a synchronous transaction.
1239 */
1248 }
1251 /*
1252 * If we get an error while cleaning up a
1253 * symlink we bail out.
1254 */
1262 }
1270 XFS_INACTIVE_LOG_COUNT);
1275 }
1280 }
1282 /*
1283 * If there are attributes associated with the file
1284 * then blow them away now. The code calls a routine
1285 * that recursively deconstructs the attribute fork.
1286 * We need to just commit the current transaction
1287 * because we can't use it for xfs_attr_inactive().
1288 */
1291 /*
1292 * If we got an error, the transaction is already
1293 * cancelled, and the inode is unlocked. Just get out.
1294 */
1299 }
1301 /*
1302 * Free the inode.
1303 */
1307 /*
1308 * If we fail to free the inode, shut down. The cancel
1309 * might do that, we need to make sure. Otherwise the
1310 * inode might be lost for a long time or forever.
1311 */
1317 }
1320 /*
1321 * Credit the quota account(s). The inode is gone.
1322 */
1325 /*
1326 * Just ignore errors at this point. There is nothing we can
1327 * do except to try to keep going. Make sure it's not a silent
1328 * error.
1329 */
1338 }
1340 /*
1341 * Release the dquots held by inode, if any.
1342 */
1346 out:
1348 }
1350 /*
1351 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1352 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1353 * ci_name->name will point to a the actual name (caller must free) or
1354 * will be set to NULL if an exact match is found.
1355 */
1356 int
1362 {
1363 xfs_ino_t inum;
1365 uint lock_mode;
1386 out_free_name:
1389 out:
1392 }
1394 int
1398 mode_t mode,
1399 xfs_dev_t rdev,
1402 {
1408 xfs_bmap_free_t free_list;
1409 xfs_fsblock_t first_block;
1411 uint cancel_flags;
1413 xfs_prid_t prid;
1416 uint resblks;
1417 uint log_res;
1418 uint log_count;
1433 }
1437 else
1440 /*
1441 * Make sure that we have allocated dquot(s) on disk.
1442 */
1459 }
1463 /*
1464 * Initially assume that the file does not exist and
1465 * reserve the resources for that case. If that is not
1466 * the case we'll drop the one we have and get a more
1467 * appropriate transaction later.
1468 */
1472 /* flush outstanding delalloc blocks and retry */
1476 }
1478 /* No space at all so try a "no-allocation" reservation */
1482 }
1486 }
1491 /*
1492 * Check for directory link count overflow.
1493 */
1497 }
1501 /*
1502 * Reserve disk quota and the inode.
1503 */
1512 /*
1513 * A newly created regular or special file just has one directory
1514 * entry pointing to them, but a directory also the "." entry
1515 * pointing to itself.
1516 */
1523 }
1525 /*
1526 * At this point, we've gotten a newly allocated inode.
1527 * It is locked (and joined to the transaction).
1528 */
1532 /*
1533 * Now we join the directory inode to the transaction. We do not do it
1534 * earlier because xfs_dir_ialloc might commit the previous transaction
1535 * (and release all the locks). An error from here on will result in
1536 * the transaction cancel unlocking dp so don't do it explicitly in the
1537 * error path.
1538 */
1549 }
1561 }
1563 /*
1564 * If this is a synchronous mount, make sure that the
1565 * create transaction goes to disk before returning to
1566 * the user.
1567 */
1571 /*
1572 * Attach the dquot(s) to the inodes and modify them incore.
1573 * These ids of the inode couldn't have changed since the new
1574 * inode has been locked ever since it was created.
1575 */
1578 /*
1579 * xfs_trans_commit normally decrements the vnode ref count
1580 * when it unlocks the inode. Since we want to return the
1581 * vnode to the caller, we bump the vnode ref count now.
1582 */
1593 }
1600 /* Fallthrough to std_return with error = 0 */
1601 std_return:
1606 }
1610 out_bmap_cancel:
1612 out_trans_abort:
1614 out_trans_cancel:
1616 out_dqrele:
1625 out_abort_rele:
1626 /*
1627 * Wait until after the current transaction is aborted to
1628 * release the inode. This prevents recursive transactions
1629 * and deadlocks from xfs_inactive.
1630 */
1637 }
1639 #ifdef DEBUG
1645 #endif
1647 /*
1648 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1649 * a different value
1650 */
1653 {
1660 }
1662 /*
1663 * The following routine will lock n inodes in exclusive mode.
1664 * We assume the caller calls us with the inodes in i_ino order.
1665 *
1666 * We need to detect deadlock where an inode that we lock
1667 * is in the AIL and we start waiting for another inode that is locked
1668 * by a thread in a long running transaction (such as truncate). This can
1669 * result in deadlock since the long running trans might need to wait
1670 * for the inode we just locked in order to push the tail and free space
1671 * in the log.
1672 */
1673 void
1677 uint lock_mode)
1678 {
1687 again:
1694 /*
1695 * If try_lock is not set yet, make sure all locked inodes
1696 * are not in the AIL.
1697 * If any are, set try_lock to be used later.
1698 */
1704 try_lock++;
1705 }
1706 }
1707 }
1709 /*
1710 * If any of the previous locks we have locked is in the AIL,
1711 * we must TRY to get the second and subsequent locks. If
1712 * we can't get any, we must release all we have
1713 * and try again.
1714 */
1717 /* try_lock must be 0 if i is 0. */
1718 /*
1719 * try_lock means we have an inode locked
1720 * that is in the AIL.
1721 */
1724 attempts++;
1726 /*
1727 * Unlock all previous guys and try again.
1728 * xfs_iunlock will try to push the tail
1729 * if the inode is in the AIL.
1730 */
1734 /*
1735 * Check to see if we've already
1736 * unlocked this one.
1737 * Not the first one going back,
1738 * and the inode ptr is the same.
1739 */
1745 }
1749 #ifdef DEBUG
1750 xfs_lock_delays++;
1751 #endif
1752 }
1756 }
1759 }
1760 }
1762 #ifdef DEBUG
1768 xfs_locked_n++;
1769 }
1770 #endif
1771 }
1773 /*
1774 * xfs_lock_two_inodes() can only be used to lock one type of lock
1775 * at a time - the iolock or the ilock, but not both at once. If
1776 * we lock both at once, lockdep will report false positives saying
1777 * we have violated locking orders.
1778 */
1779 void
1783 uint lock_mode)
1784 {
1797 }
1799 again:
1802 /*
1803 * If the first lock we have locked is in the AIL, we must TRY to get
1804 * the second lock. If we can't get it, we must release the first one
1805 * and try again.
1806 */
1814 }
1817 }
1818 }
1820 int
1825 {
1830 xfs_bmap_free_t free_list;
1831 xfs_fsblock_t first_block;
1835 uint resblks;
1836 uint log_count;
1850 }
1866 }
1869 /*
1870 * We try to get the real space reservation first,
1871 * allowing for directory btree deletion(s) implying
1872 * possible bmap insert(s). If we can't get the space
1873 * reservation then we use 0 instead, and avoid the bmap
1874 * btree insert(s) in the directory code by, if the bmap
1875 * insert tries to happen, instead trimming the LAST
1876 * block from the directory.
1877 */
1885 }
1890 }
1894 /*
1895 * At this point, we've gotten both the directory and the entry
1896 * inodes locked.
1897 */
1904 /*
1905 * If we're removing a directory perform some additional validation.
1906 */
1912 }
1916 }
1917 }
1925 }
1929 /*
1930 * Drop the link from ip's "..".
1931 */
1936 /*
1937 * Drop the "." link from ip to self.
1938 */
1943 /*
1944 * When removing a non-directory we need to log the parent
1945 * inode here. For a directory this is done implicitly
1946 * by the xfs_droplink call for the ".." entry.
1947 */
1949 }
1951 /*
1952 * Drop the link from dp to ip.
1953 */
1958 /*
1959 * Determine if this is the last link while
1960 * we are in the transaction.
1961 */
1964 /*
1965 * If this is a synchronous mount, make sure that the
1966 * remove transaction goes to disk before returning to
1967 * the user.
1968 */
1980 /*
1981 * If we are using filestreams, kill the stream association.
1982 * If the file is still open it may get a new one but that
1983 * will get killed on last close in xfs_close() so we don't
1984 * have to worry about that.
1985 */
1992 std_return:
1997 }
2001 out_bmap_cancel:
2004 out_trans_cancel:
2007 }
2009 int
2014 {
2018 xfs_bmap_free_t free_list;
2019 xfs_fsblock_t first_block;
2039 }
2041 /* Return through std_return after this point. */
2060 }
2064 }
2068 /*
2069 * Increment vnode ref counts since xfs_trans_commit &
2070 * xfs_trans_cancel will both unlock the inodes and
2071 * decrement the associated ref counts.
2072 */
2078 /*
2079 * If the source has too many links, we can't make any more to it.
2080 */
2084 }
2086 /*
2087 * If we are using project inheritance, we only allow hard link
2088 * creation in our tree when the project IDs are the same; else
2089 * the tree quota mechanism could be circumvented.
2090 */
2095 }
2114 /*
2115 * If this is a synchronous mount, make sure that the
2116 * link transaction goes to disk before returning to
2117 * the user.
2118 */
2121 }
2127 }
2133 /* Fall through to std_return with error = 0. */
2134 std_return:
2140 }
2143 abort_return:
2145 /* FALLTHROUGH */
2147 error_return:
2150 }
2152 int
2157 mode_t mode,
2160 {
2166 xfs_bmap_free_t free_list;
2167 xfs_fsblock_t first_block;
2169 uint cancel_flags;
2171 xfs_fileoff_t first_fsb;
2172 xfs_filblks_t fs_blocks;
2175 xfs_daddr_t d;
2180 xfs_prid_t prid;
2182 uint resblks;
2194 /*
2195 * Check component lengths of the target path name.
2196 */
2207 }
2209 /* Return through std_return after this point. */
2214 else
2217 /*
2218 * Make sure that we have allocated dquot(s) on disk.
2219 */
2227 /*
2228 * The symlink will fit into the inode data fork?
2229 * There can't be any attributes so we get the whole variable part.
2230 */
2233 else
2242 }
2246 }
2251 /*
2252 * Check whether the directory allows new symlinks or not.
2253 */
2257 }
2259 /*
2260 * Reserve disk quota : blocks and inode.
2261 */
2266 /*
2267 * Check for ability to enter directory entry, if no space reserved.
2268 */
2272 /*
2273 * Initialize the bmap freelist prior to calling either
2274 * bmapi or the directory create code.
2275 */
2278 /*
2279 * Allocate an inode for the symlink.
2280 */
2287 }
2290 /*
2291 * An error after we've joined dp to the transaction will result in the
2292 * transaction cancel unlocking dp so don't do it explicitly in the
2293 * error path.
2294 */
2299 /*
2300 * Also attach the dquot(s) to it, if applicable.
2301 */
2306 /*
2307 * If the symlink will fit into the inode, write it inline.
2308 */
2314 /*
2315 * The inode was initially created in extent format.
2316 */
2333 }
2349 }
2356 }
2357 }
2359 /*
2360 * Create the directory entry for the symlink.
2361 */
2369 /*
2370 * If this is a synchronous mount, make sure that the
2371 * symlink transaction goes to disk before returning to
2372 * the user.
2373 */
2376 }
2378 /*
2379 * xfs_trans_commit normally decrements the vnode ref count
2380 * when it unlocks the inode. Since we want to return the
2381 * vnode to the caller, we bump the vnode ref count now.
2382 */
2388 }
2393 /* Fall through to std_return with error = 0 or errno from
2394 * xfs_trans_commit */
2395 std_return:
2402 }
2408 error2:
2410 error1:
2413 error_return:
2422 }
2424 int
2427 u_int evmask,
2428 u_int16_t state)
2429 {
2445 }
2457 }
2459 int
2462 {
2468 /* bad inode, get out here ASAP */
2472 }
2478 /*
2479 * If we have nothing to flush with this inode then complete the
2480 * teardown now, otherwise break the link between the xfs inode and the
2481 * linux inode and clean up the xfs inode later. This avoids flushing
2482 * the inode to disk during the delete operation itself.
2483 *
2484 * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
2485 * first to ensure that xfs_iunpin() will never see an xfs inode
2486 * that has a linux inode being reclaimed. Synchronisation is provided
2487 * by the i_flags_lock.
2488 */
2494 }
2497 }
2499 /*
2500 * xfs_alloc_file_space()
2501 * This routine allocates disk space for the given file.
2502 *
2503 * If alloc_type == 0, this request is for an ALLOCSP type
2504 * request which will change the file size. In this case, no
2505 * DMAPI event will be generated by the call. A TRUNCATE event
2506 * will be generated later by xfs_setattr.
2507 *
2508 * If alloc_type != 0, this request is for a RESVSP type
2509 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2510 * lower block boundary byte address is less than the file's
2511 * length.
2512 *
2513 * RETURNS:
2514 * 0 on success
2515 * errno on error
2516 *
2517 */
2518 STATIC int
2521 xfs_off_t offset,
2522 xfs_off_t len,
2525 {
2527 xfs_off_t count;
2528 xfs_filblks_t allocated_fsb;
2529 xfs_filblks_t allocatesize_fsb;
2531 xfs_fileoff_t startoffset_fsb;
2532 xfs_fsblock_t firstfsb;
2539 xfs_bmap_free_t free_list;
2566 /* Generate a DMAPI event if needed. */
2570 xfs_off_t end_dmi_offset;
2579 }
2581 /*
2582 * Allocate file space until done or until there is an error
2583 */
2584 retry:
2588 /*
2589 * Determine space reservations for data/realtime.
2590 */
2603 }
2615 }
2617 /*
2618 * Allocate and setup the transaction.
2619 */
2623 XFS_TRANS_PERM_LOG_RES,
2624 XFS_WRITE_LOG_COUNT);
2625 /*
2626 * Check for running out of space
2627 */
2629 /*
2630 * Free the transaction structure.
2631 */
2635 }
2645 /*
2646 * Issue the xfs_bmapi() call to allocate the blocks
2647 */
2655 }
2657 /*
2658 * Complete the transaction
2659 */
2663 }
2669 }
2676 }
2680 }
2681 dmapi_enospc_check:
2690 /* else fall through with error from XFS_SEND_DATA */
2691 }
2703 }
2705 /*
2706 * Zero file bytes between startoff and endoff inclusive.
2707 * The iolock is held exclusive and no blocks are buffered.
2708 *
2709 * This function is used by xfs_free_file_space() to zero
2710 * partial blocks when the range to free is not block aligned.
2711 * When unreserving space with boundaries that are not block
2712 * aligned we round up the start and round down the end
2713 * boundaries and then use this function to zero the parts of
2714 * the blocks that got dropped during the rounding.
2715 */
2716 STATIC int
2719 xfs_off_t startoff,
2720 xfs_off_t endoff)
2721 {
2722 xfs_bmbt_irec_t imap;
2723 xfs_fileoff_t offset_fsb;
2724 xfs_off_t lastoffset;
2725 xfs_off_t offset;
2731 /*
2732 * Avoid doing I/O beyond eof - it's not necessary
2733 * since nothing can read beyond eof. The space will
2734 * be zeroed when the file is extended anyway.
2735 */
2775 }
2788 }
2789 }
2792 }
2794 /*
2795 * xfs_free_file_space()
2796 * This routine frees disk space for the given file.
2797 *
2798 * This routine is only called by xfs_change_file_space
2799 * for an UNRESVSP type call.
2800 *
2801 * RETURNS:
2802 * 0 on success
2803 * errno on error
2804 *
2805 */
2806 STATIC int
2809 xfs_off_t offset,
2810 xfs_off_t len,
2812 {
2815 xfs_off_t end_dmi_offset;
2816 xfs_fileoff_t endoffset_fsb;
2818 xfs_fsblock_t firstfsb;
2819 xfs_bmap_free_t free_list;
2820 xfs_bmbt_irec_t imap;
2821 xfs_off_t ioffset;
2825 uint resblks;
2826 uint rounding;
2828 xfs_fileoff_t startoffset_fsb;
2857 }
2863 /* wait for the completion of any pending DIOs */
2865 }
2875 }
2877 /*
2878 * Need to zero the stuff we're not freeing, on disk.
2879 * If it's a realtime file & can't use unwritten extents then we
2880 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2881 * will take care of it for us.
2882 */
2891 xfs_daddr_t block;
2898 }
2907 mod++;
2910 }
2911 }
2913 /*
2914 * One contiguous piece to clear
2915 */
2918 /*
2919 * Some full blocks, possibly two pieces to clear
2920 */
2929 }
2931 /*
2932 * free file space until done or until there is an error
2933 */
2937 /*
2938 * allocate and setup the transaction. Allow this
2939 * transaction to dip into the reserve blocks to ensure
2940 * the freeing of the space succeeds at ENOSPC.
2941 */
2945 resblks,
2948 XFS_TRANS_PERM_LOG_RES,
2949 XFS_WRITE_LOG_COUNT);
2951 /*
2952 * check for running out of space
2953 */
2955 /*
2956 * Free the transaction structure.
2957 */
2961 }
2972 /*
2973 * issue the bunmapi() call to free the blocks
2974 */
2981 }
2983 /*
2984 * complete the transaction
2985 */
2989 }
2993 }
2995 out_unlock_iolock:
3000 error0:
3002 error1:
3005 XFS_ILOCK_EXCL);
3007 }
3009 /*
3010 * xfs_change_file_space()
3011 * This routine allocates or frees disk space for the given file.
3012 * The user specified parameters are checked for alignment and size
3013 * limitations.
3014 *
3015 * RETURNS:
3016 * 0 on success
3017 * errno on error
3018 *
3019 */
3020 int
3025 xfs_off_t offset,
3027 {
3031 xfs_fsize_t fsize;
3033 xfs_off_t startoffset;
3034 xfs_off_t llen;
3054 }
3069 /*
3070 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
3071 * file space.
3072 * These calls do NOT zero the data space allocated to the file,
3073 * nor do they change the file size.
3074 *
3075 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
3076 * space.
3077 * These calls cause the new file data to be zeroed and the file
3078 * size to be changed.
3079 */
3095 attr_flags)))
3108 }
3124 }
3126 /*
3127 * update the inode timestamp, mode, and prealloc flag bits
3128 */
3133 /* ASSERT(0); */
3136 }
3146 /*
3147 * Note that we don't have to worry about mandatory
3148 * file locking being disabled here because we only
3149 * clear the S_ISGID bit if the Group execute bit is
3150 * on, but if it was on then mandatory locking wouldn't
3151 * have been enabled.
3152 */
3157 }
3171 }