| blob | a06bd62504fc7e1388abcf8aeac0000996c92a64 |
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 * Flags for xfs_free_eofblocks
588 */
589 #define XFS_FREE_EOF_TRYLOCK (1<<0)
591 /*
592 * This is called by xfs_inactive to free any blocks beyond eof
593 * when the link count isn't zero and by xfs_dm_punch_hole() when
594 * punching a hole to EOF.
595 */
596 STATIC int
601 {
604 xfs_fileoff_t end_fsb;
605 xfs_fileoff_t last_fsb;
606 xfs_filblks_t map_len;
608 xfs_bmbt_irec_t imap;
610 /*
611 * Figure out if there are any blocks beyond the end
612 * of the file. If not, then there is nothing to do.
613 */
629 /*
630 * Attach the dquots to the inode up front.
631 */
636 /*
637 * There are blocks after the end of file.
638 * Free them up now by truncating the file to
639 * its current size.
640 */
643 /*
644 * Do the xfs_itruncate_start() call before
645 * reserving any log space because
646 * itruncate_start will call into the buffer
647 * cache and we can't
648 * do that within a transaction.
649 */
654 }
657 }
664 }
669 XFS_ITRUNCATE_LOG_COUNT);
675 }
679 XFS_IOLOCK_EXCL |
680 XFS_ILOCK_EXCL);
685 XFS_DATA_FORK,
687 /*
688 * If we get an error at this point we
689 * simply don't bother truncating the file.
690 */
694 XFS_TRANS_ABORT));
697 XFS_TRANS_RELEASE_LOG_RES);
698 }
700 }
702 }
704 /*
705 * Free a symlink that has blocks associated with it.
706 */
707 STATIC int
711 {
716 xfs_fsblock_t first_block;
717 xfs_bmap_free_t free_list;
729 /*
730 * We're freeing a symlink that has some
731 * blocks allocated to it. Free the
732 * blocks here. We know that we've got
733 * either 1 or 2 extents and that we can
734 * free them all in one bunmapi call.
735 */
743 }
744 /*
745 * Lock the inode, fix the size, and join it to the transaction.
746 * Hold it so in the normal path, we still have it locked for
747 * the second transaction. In the error paths we need it
748 * held so the cancel won't rele it, see below.
749 */
756 /*
757 * Find the block(s) so we can inval and unmap them.
758 */
766 /*
767 * Invalidate the block(s).
768 */
774 }
775 /*
776 * Unmap the dead block(s) to the free_list.
777 */
782 /*
783 * Commit the first transaction. This logs the EFI and the inode.
784 */
787 /*
788 * The transaction must have been committed, since there were
789 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
790 * The new tp has the extent freeing and EFDs.
791 */
793 /*
794 * The first xact was committed, so add the inode to the new one.
795 * Mark it dirty so it will be logged and moved forward in the log as
796 * part of every commit.
797 */
801 /*
802 * Get a new, empty transaction to return to our caller.
803 */
805 /*
806 * Commit the transaction containing extent freeing and EFDs.
807 * If we get an error on the commit here or on the reserve below,
808 * we need to unlock the inode since the new transaction doesn't
809 * have the inode attached.
810 */
816 }
817 /*
818 * transaction commit worked ok so we can drop the extra ticket
819 * reference that we gained in xfs_trans_dup()
820 */
823 /*
824 * Remove the memory for extent descriptions (just bookkeeping).
825 */
829 /*
830 * Put an itruncate log reservation in the new transaction
831 * for our caller.
832 */
837 }
838 /*
839 * Return with the inode locked but not joined to the transaction.
840 */
844 error1:
846 error0:
847 /*
848 * Have to come here with the inode locked and either
849 * (held and in the transaction) or (not in the transaction).
850 * If the inode isn't held then cancel would iput it, but
851 * that's wrong since this is inactive and the vnode ref
852 * count is 0 already.
853 * Cancel won't do anything to the inode if held, but it still
854 * needs to be locked until the cancel is done, if it was
855 * joined to the transaction.
856 */
862 }
864 STATIC int
868 {
872 /*
873 * We're freeing a symlink which fit into
874 * the inode. Just free the memory used
875 * to hold the old symlink.
876 */
880 XFS_ITRUNCATE_LOG_COUNT);
886 }
889 /*
890 * Zero length symlinks _can_ exist.
891 */
895 XFS_DATA_FORK);
897 }
899 }
901 STATIC int
905 {
927 XFS_INACTIVE_LOG_COUNT);
941 error_cancel:
944 error_unlock:
948 }
950 int
953 {
960 /* If this is a read-only mount, don't do this (would generate I/O) */
967 /*
968 * If we are using filestreams, and we have an unlinked
969 * file that we are processing the last close on, then nothing
970 * will be able to reopen and write to this file. Purge this
971 * inode from the filestreams cache so that it doesn't delay
972 * teardown of the inode.
973 */
977 /*
978 * If we previously truncated this file and removed old data
979 * in the process, we want to initiate "early" writeout on
980 * the last close. This is an attempt to combat the notorious
981 * NULL files problem which is particularly noticable from a
982 * truncate down, buffered (re-)write (delalloc), followed by
983 * a crash. What we are effectively doing here is
984 * significantly reducing the time window where we'd otherwise
985 * be exposed to that problem.
986 */
990 }
1000 /*
1001 * If we can't get the iolock just skip truncating
1002 * the blocks past EOF because we could deadlock
1003 * with the mmap_sem otherwise. We'll get another
1004 * chance to drop them once the last reference to
1005 * the inode is dropped, so we'll never leak blocks
1006 * permanently.
1007 */
1009 XFS_FREE_EOF_TRYLOCK);
1012 }
1013 }
1016 }
1018 /*
1019 * xfs_inactive
1020 *
1021 * This is called when the vnode reference count for the vnode
1022 * goes to zero. If the file has been unlinked, then it must
1023 * now be truncated. Also, we clear all of the read-ahead state
1024 * kept for the inode here since the file is now closed.
1025 */
1026 int
1029 {
1030 xfs_bmap_free_t free_list;
1031 xfs_fsblock_t first_block;
1040 /*
1041 * If the inode is already free, then there can be nothing
1042 * to clean up here.
1043 */
1048 }
1050 /*
1051 * Only do a truncate if it's a regular file with
1052 * some actual space in it. It's OK to look at the
1053 * inode's fields without the lock because we're the
1054 * only one with a reference to the inode.
1055 */
1068 /* If this is a read-only mount, don't do this (would generate I/O) */
1083 }
1085 }
1095 /*
1096 * Do the xfs_itruncate_start() call before
1097 * reserving any log space because itruncate_start
1098 * will call into the buffer cache and we can't
1099 * do that within a transaction.
1100 */
1108 }
1113 XFS_ITRUNCATE_LOG_COUNT);
1115 /* Don't call itruncate_cleanup */
1120 }
1126 /*
1127 * normally, we have to run xfs_itruncate_finish sync.
1128 * But if filesystem is wsync and we're in the inactive
1129 * path, then we know that nlink == 0, and that the
1130 * xaction that made nlink == 0 is permanently committed
1131 * since xfs_remove runs as a synchronous transaction.
1132 */
1141 }
1144 /*
1145 * If we get an error while cleaning up a
1146 * symlink we bail out.
1147 */
1155 }
1163 XFS_INACTIVE_LOG_COUNT);
1168 }
1173 }
1175 /*
1176 * If there are attributes associated with the file
1177 * then blow them away now. The code calls a routine
1178 * that recursively deconstructs the attribute fork.
1179 * We need to just commit the current transaction
1180 * because we can't use it for xfs_attr_inactive().
1181 */
1184 /*
1185 * If we got an error, the transaction is already
1186 * cancelled, and the inode is unlocked. Just get out.
1187 */
1192 }
1194 /*
1195 * Free the inode.
1196 */
1200 /*
1201 * If we fail to free the inode, shut down. The cancel
1202 * might do that, we need to make sure. Otherwise the
1203 * inode might be lost for a long time or forever.
1204 */
1210 }
1213 /*
1214 * Credit the quota account(s). The inode is gone.
1215 */
1218 /*
1219 * Just ignore errors at this point. There is nothing we can
1220 * do except to try to keep going. Make sure it's not a silent
1221 * error.
1222 */
1231 }
1233 /*
1234 * Release the dquots held by inode, if any.
1235 */
1239 out:
1241 }
1243 /*
1244 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1245 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1246 * ci_name->name will point to a the actual name (caller must free) or
1247 * will be set to NULL if an exact match is found.
1248 */
1249 int
1255 {
1256 xfs_ino_t inum;
1258 uint lock_mode;
1278 out_free_name:
1281 out:
1284 }
1286 int
1290 mode_t mode,
1291 xfs_dev_t rdev,
1294 {
1300 xfs_bmap_free_t free_list;
1301 xfs_fsblock_t first_block;
1303 uint cancel_flags;
1305 xfs_prid_t prid;
1308 uint resblks;
1309 uint log_res;
1310 uint log_count;
1325 }
1329 else
1332 /*
1333 * Make sure that we have allocated dquot(s) on disk.
1334 */
1351 }
1355 /*
1356 * Initially assume that the file does not exist and
1357 * reserve the resources for that case. If that is not
1358 * the case we'll drop the one we have and get a more
1359 * appropriate transaction later.
1360 */
1364 /* flush outstanding delalloc blocks and retry */
1368 }
1370 /* No space at all so try a "no-allocation" reservation */
1374 }
1378 }
1383 /*
1384 * Check for directory link count overflow.
1385 */
1389 }
1393 /*
1394 * Reserve disk quota and the inode.
1395 */
1404 /*
1405 * A newly created regular or special file just has one directory
1406 * entry pointing to them, but a directory also the "." entry
1407 * pointing to itself.
1408 */
1415 }
1417 /*
1418 * At this point, we've gotten a newly allocated inode.
1419 * It is locked (and joined to the transaction).
1420 */
1423 /*
1424 * Now we join the directory inode to the transaction. We do not do it
1425 * earlier because xfs_dir_ialloc might commit the previous transaction
1426 * (and release all the locks). An error from here on will result in
1427 * the transaction cancel unlocking dp so don't do it explicitly in the
1428 * error path.
1429 */
1440 }
1452 }
1454 /*
1455 * If this is a synchronous mount, make sure that the
1456 * create transaction goes to disk before returning to
1457 * the user.
1458 */
1462 /*
1463 * Attach the dquot(s) to the inodes and modify them incore.
1464 * These ids of the inode couldn't have changed since the new
1465 * inode has been locked ever since it was created.
1466 */
1469 /*
1470 * xfs_trans_commit normally decrements the vnode ref count
1471 * when it unlocks the inode. Since we want to return the
1472 * vnode to the caller, we bump the vnode ref count now.
1473 */
1484 }
1491 /* Fallthrough to std_return with error = 0 */
1492 std_return:
1497 }
1501 out_bmap_cancel:
1503 out_trans_abort:
1505 out_trans_cancel:
1507 out_dqrele:
1516 out_abort_rele:
1517 /*
1518 * Wait until after the current transaction is aborted to
1519 * release the inode. This prevents recursive transactions
1520 * and deadlocks from xfs_inactive.
1521 */
1528 }
1530 #ifdef DEBUG
1536 #endif
1538 /*
1539 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1540 * a different value
1541 */
1544 {
1551 }
1553 /*
1554 * The following routine will lock n inodes in exclusive mode.
1555 * We assume the caller calls us with the inodes in i_ino order.
1556 *
1557 * We need to detect deadlock where an inode that we lock
1558 * is in the AIL and we start waiting for another inode that is locked
1559 * by a thread in a long running transaction (such as truncate). This can
1560 * result in deadlock since the long running trans might need to wait
1561 * for the inode we just locked in order to push the tail and free space
1562 * in the log.
1563 */
1564 void
1568 uint lock_mode)
1569 {
1578 again:
1585 /*
1586 * If try_lock is not set yet, make sure all locked inodes
1587 * are not in the AIL.
1588 * If any are, set try_lock to be used later.
1589 */
1595 try_lock++;
1596 }
1597 }
1598 }
1600 /*
1601 * If any of the previous locks we have locked is in the AIL,
1602 * we must TRY to get the second and subsequent locks. If
1603 * we can't get any, we must release all we have
1604 * and try again.
1605 */
1608 /* try_lock must be 0 if i is 0. */
1609 /*
1610 * try_lock means we have an inode locked
1611 * that is in the AIL.
1612 */
1615 attempts++;
1617 /*
1618 * Unlock all previous guys and try again.
1619 * xfs_iunlock will try to push the tail
1620 * if the inode is in the AIL.
1621 */
1625 /*
1626 * Check to see if we've already
1627 * unlocked this one.
1628 * Not the first one going back,
1629 * and the inode ptr is the same.
1630 */
1636 }
1640 #ifdef DEBUG
1641 xfs_lock_delays++;
1642 #endif
1643 }
1647 }
1650 }
1651 }
1653 #ifdef DEBUG
1659 xfs_locked_n++;
1660 }
1661 #endif
1662 }
1664 /*
1665 * xfs_lock_two_inodes() can only be used to lock one type of lock
1666 * at a time - the iolock or the ilock, but not both at once. If
1667 * we lock both at once, lockdep will report false positives saying
1668 * we have violated locking orders.
1669 */
1670 void
1674 uint lock_mode)
1675 {
1688 }
1690 again:
1693 /*
1694 * If the first lock we have locked is in the AIL, we must TRY to get
1695 * the second lock. If we can't get it, we must release the first one
1696 * and try again.
1697 */
1705 }
1708 }
1709 }
1711 int
1716 {
1721 xfs_bmap_free_t free_list;
1722 xfs_fsblock_t first_block;
1726 uint resblks;
1727 uint log_count;
1741 }
1757 }
1760 /*
1761 * We try to get the real space reservation first,
1762 * allowing for directory btree deletion(s) implying
1763 * possible bmap insert(s). If we can't get the space
1764 * reservation then we use 0 instead, and avoid the bmap
1765 * btree insert(s) in the directory code by, if the bmap
1766 * insert tries to happen, instead trimming the LAST
1767 * block from the directory.
1768 */
1776 }
1781 }
1785 /*
1786 * At this point, we've gotten both the directory and the entry
1787 * inodes locked.
1788 */
1795 /*
1796 * If we're removing a directory perform some additional validation.
1797 */
1803 }
1807 }
1808 }
1816 }
1820 /*
1821 * Drop the link from ip's "..".
1822 */
1827 /*
1828 * Drop the "." link from ip to self.
1829 */
1834 /*
1835 * When removing a non-directory we need to log the parent
1836 * inode here. For a directory this is done implicitly
1837 * by the xfs_droplink call for the ".." entry.
1838 */
1840 }
1842 /*
1843 * Drop the link from dp to ip.
1844 */
1849 /*
1850 * Determine if this is the last link while
1851 * we are in the transaction.
1852 */
1855 /*
1856 * If this is a synchronous mount, make sure that the
1857 * remove transaction goes to disk before returning to
1858 * the user.
1859 */
1871 /*
1872 * If we are using filestreams, kill the stream association.
1873 * If the file is still open it may get a new one but that
1874 * will get killed on last close in xfs_close() so we don't
1875 * have to worry about that.
1876 */
1880 std_return:
1885 }
1889 out_bmap_cancel:
1892 out_trans_cancel:
1895 }
1897 int
1902 {
1906 xfs_bmap_free_t free_list;
1907 xfs_fsblock_t first_block;
1927 }
1929 /* Return through std_return after this point. */
1948 }
1952 }
1956 /*
1957 * Increment vnode ref counts since xfs_trans_commit &
1958 * xfs_trans_cancel will both unlock the inodes and
1959 * decrement the associated ref counts.
1960 */
1966 /*
1967 * If the source has too many links, we can't make any more to it.
1968 */
1972 }
1974 /*
1975 * If we are using project inheritance, we only allow hard link
1976 * creation in our tree when the project IDs are the same; else
1977 * the tree quota mechanism could be circumvented.
1978 */
1983 }
2002 /*
2003 * If this is a synchronous mount, make sure that the
2004 * link transaction goes to disk before returning to
2005 * the user.
2006 */
2009 }
2015 }
2021 /* Fall through to std_return with error = 0. */
2022 std_return:
2028 }
2031 abort_return:
2033 /* FALLTHROUGH */
2035 error_return:
2038 }
2040 int
2045 mode_t mode,
2048 {
2054 xfs_bmap_free_t free_list;
2055 xfs_fsblock_t first_block;
2057 uint cancel_flags;
2059 xfs_fileoff_t first_fsb;
2060 xfs_filblks_t fs_blocks;
2063 xfs_daddr_t d;
2068 xfs_prid_t prid;
2070 uint resblks;
2082 /*
2083 * Check component lengths of the target path name.
2084 */
2096 }
2098 /* Return through std_return after this point. */
2103 else
2106 /*
2107 * Make sure that we have allocated dquot(s) on disk.
2108 */
2116 /*
2117 * The symlink will fit into the inode data fork?
2118 * There can't be any attributes so we get the whole variable part.
2119 */
2122 else
2131 }
2135 }
2140 /*
2141 * Check whether the directory allows new symlinks or not.
2142 */
2146 }
2148 /*
2149 * Reserve disk quota : blocks and inode.
2150 */
2155 /*
2156 * Check for ability to enter directory entry, if no space reserved.
2157 */
2161 /*
2162 * Initialize the bmap freelist prior to calling either
2163 * bmapi or the directory create code.
2164 */
2167 /*
2168 * Allocate an inode for the symlink.
2169 */
2176 }
2178 /*
2179 * An error after we've joined dp to the transaction will result in the
2180 * transaction cancel unlocking dp so don't do it explicitly in the
2181 * error path.
2182 */
2187 /*
2188 * Also attach the dquot(s) to it, if applicable.
2189 */
2194 /*
2195 * If the symlink will fit into the inode, write it inline.
2196 */
2202 /*
2203 * The inode was initially created in extent format.
2204 */
2221 }
2237 }
2244 }
2245 }
2247 /*
2248 * Create the directory entry for the symlink.
2249 */
2257 /*
2258 * If this is a synchronous mount, make sure that the
2259 * symlink transaction goes to disk before returning to
2260 * the user.
2261 */
2264 }
2266 /*
2267 * xfs_trans_commit normally decrements the vnode ref count
2268 * when it unlocks the inode. Since we want to return the
2269 * vnode to the caller, we bump the vnode ref count now.
2270 */
2276 }
2281 /* Fall through to std_return with error = 0 or errno from
2282 * xfs_trans_commit */
2283 std_return:
2291 }
2297 error2:
2299 error1:
2302 error_return:
2311 }
2313 int
2316 u_int evmask,
2317 u_int16_t state)
2318 {
2334 }
2346 }
2348 /*
2349 * xfs_alloc_file_space()
2350 * This routine allocates disk space for the given file.
2351 *
2352 * If alloc_type == 0, this request is for an ALLOCSP type
2353 * request which will change the file size. In this case, no
2354 * DMAPI event will be generated by the call. A TRUNCATE event
2355 * will be generated later by xfs_setattr.
2356 *
2357 * If alloc_type != 0, this request is for a RESVSP type
2358 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2359 * lower block boundary byte address is less than the file's
2360 * length.
2361 *
2362 * RETURNS:
2363 * 0 on success
2364 * errno on error
2365 *
2366 */
2367 STATIC int
2370 xfs_off_t offset,
2371 xfs_off_t len,
2374 {
2376 xfs_off_t count;
2377 xfs_filblks_t allocated_fsb;
2378 xfs_filblks_t allocatesize_fsb;
2380 xfs_fileoff_t startoffset_fsb;
2381 xfs_fsblock_t firstfsb;
2388 xfs_bmap_free_t free_list;
2415 /* Generate a DMAPI event if needed. */
2419 xfs_off_t end_dmi_offset;
2428 }
2430 /*
2431 * Allocate file space until done or until there is an error
2432 */
2433 retry:
2437 /*
2438 * Determine space reservations for data/realtime.
2439 */
2452 }
2464 }
2466 /*
2467 * Allocate and setup the transaction.
2468 */
2472 XFS_TRANS_PERM_LOG_RES,
2473 XFS_WRITE_LOG_COUNT);
2474 /*
2475 * Check for running out of space
2476 */
2478 /*
2479 * Free the transaction structure.
2480 */
2484 }
2494 /*
2495 * Issue the xfs_bmapi() call to allocate the blocks
2496 */
2504 }
2506 /*
2507 * Complete the transaction
2508 */
2512 }
2518 }
2525 }
2529 }
2530 dmapi_enospc_check:
2539 /* else fall through with error from XFS_SEND_DATA */
2540 }
2552 }
2554 /*
2555 * Zero file bytes between startoff and endoff inclusive.
2556 * The iolock is held exclusive and no blocks are buffered.
2557 *
2558 * This function is used by xfs_free_file_space() to zero
2559 * partial blocks when the range to free is not block aligned.
2560 * When unreserving space with boundaries that are not block
2561 * aligned we round up the start and round down the end
2562 * boundaries and then use this function to zero the parts of
2563 * the blocks that got dropped during the rounding.
2564 */
2565 STATIC int
2568 xfs_off_t startoff,
2569 xfs_off_t endoff)
2570 {
2571 xfs_bmbt_irec_t imap;
2572 xfs_fileoff_t offset_fsb;
2573 xfs_off_t lastoffset;
2574 xfs_off_t offset;
2580 /*
2581 * Avoid doing I/O beyond eof - it's not necessary
2582 * since nothing can read beyond eof. The space will
2583 * be zeroed when the file is extended anyway.
2584 */
2624 }
2637 }
2638 }
2641 }
2643 /*
2644 * xfs_free_file_space()
2645 * This routine frees disk space for the given file.
2646 *
2647 * This routine is only called by xfs_change_file_space
2648 * for an UNRESVSP type call.
2649 *
2650 * RETURNS:
2651 * 0 on success
2652 * errno on error
2653 *
2654 */
2655 STATIC int
2658 xfs_off_t offset,
2659 xfs_off_t len,
2661 {
2664 xfs_off_t end_dmi_offset;
2665 xfs_fileoff_t endoffset_fsb;
2667 xfs_fsblock_t firstfsb;
2668 xfs_bmap_free_t free_list;
2669 xfs_bmbt_irec_t imap;
2670 xfs_off_t ioffset;
2674 uint resblks;
2675 uint rounding;
2677 xfs_fileoff_t startoffset_fsb;
2706 }
2712 /* wait for the completion of any pending DIOs */
2714 }
2723 }
2725 /*
2726 * Need to zero the stuff we're not freeing, on disk.
2727 * If it's a realtime file & can't use unwritten extents then we
2728 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2729 * will take care of it for us.
2730 */
2739 xfs_daddr_t block;
2746 }
2755 mod++;
2758 }
2759 }
2761 /*
2762 * One contiguous piece to clear
2763 */
2766 /*
2767 * Some full blocks, possibly two pieces to clear
2768 */
2777 }
2779 /*
2780 * free file space until done or until there is an error
2781 */
2785 /*
2786 * allocate and setup the transaction. Allow this
2787 * transaction to dip into the reserve blocks to ensure
2788 * the freeing of the space succeeds at ENOSPC.
2789 */
2793 resblks,
2796 XFS_TRANS_PERM_LOG_RES,
2797 XFS_WRITE_LOG_COUNT);
2799 /*
2800 * check for running out of space
2801 */
2803 /*
2804 * Free the transaction structure.
2805 */
2809 }
2820 /*
2821 * issue the bunmapi() call to free the blocks
2822 */
2829 }
2831 /*
2832 * complete the transaction
2833 */
2837 }
2841 }
2843 out_unlock_iolock:
2848 error0:
2850 error1:
2853 XFS_ILOCK_EXCL);
2855 }
2857 /*
2858 * xfs_change_file_space()
2859 * This routine allocates or frees disk space for the given file.
2860 * The user specified parameters are checked for alignment and size
2861 * limitations.
2862 *
2863 * RETURNS:
2864 * 0 on success
2865 * errno on error
2866 *
2867 */
2868 int
2873 xfs_off_t offset,
2875 {
2879 xfs_fsize_t fsize;
2881 xfs_off_t startoffset;
2882 xfs_off_t llen;
2902 }
2917 /*
2918 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2919 * file space.
2920 * These calls do NOT zero the data space allocated to the file,
2921 * nor do they change the file size.
2922 *
2923 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2924 * space.
2925 * These calls cause the new file data to be zeroed and the file
2926 * size to be changed.
2927 */
2943 attr_flags)))
2956 }
2972 }
2974 /*
2975 * update the inode timestamp, mode, and prealloc flag bits
2976 */
2981 /* ASSERT(0); */
2984 }
2994 /*
2995 * Note that we don't have to worry about mandatory
2996 * file locking being disabled here because we only
2997 * clear the S_ISGID bit if the Group execute bit is
2998 * on, but if it was on then mandatory locking wouldn't
2999 * have been enabled.
3000 */
3005 }
3019 }