| blob | 619720705bc6843e4624ce02c27829fa32256ba9 |
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 */
53 int
58 {
64 uint lock_flags;
86 /*
87 * If disk quotas is on, we make sure that the dquots do exist on disk,
88 * before we start any other transactions. Trying to do this later
89 * is messy. We don't care to take a readlock to look at the ids
90 * in inode here, because we can't hold it across the trans_reserve.
91 * If the IDs do change before we take the ilock, we're covered
92 * because the i_*dquot fields will get updated anyway.
93 */
102 }
108 }
110 /*
111 * We take a reference when we initialize udqp and gdqp,
112 * so it is important that we never blindly double trip on
113 * the same variable. See xfs_create() for an example.
114 */
121 }
123 /*
124 * For the other attributes, we acquire the inode lock and
125 * first do an error checking pass.
126 */
139 }
143 }
147 /*
148 * Change file ownership. Must be the owner or privileged.
149 */
151 /*
152 * These IDs could have changed since we last looked at them.
153 * But, we're assured that if the ownership did change
154 * while we didn't have the inode locked, inode's dquot(s)
155 * would have changed also.
156 */
162 /*
163 * Do a quota reservation only if uid/gid is actually
164 * going to change.
165 */
175 }
176 }
178 /*
179 * Truncate file. Must have write permission and not be a directory.
180 */
182 /* Short circuit the truncate case for zero length files */
191 }
194 }
202 }
204 /*
205 * Make sure that the dquots are attached to the inode.
206 */
211 /*
212 * Now we can make the changes. Before we join the inode
213 * to the transaction, if ATTR_SIZE is set then take care of
214 * the part of the truncation that must be done without the
215 * inode lock. This needs to be done before joining the inode
216 * to the transaction, because the inode cannot be unlocked
217 * once it is a part of the transaction.
218 */
220 /*
221 * Do the first part of growing a file: zero any data
222 * in the last block that is beyond the old EOF. We
223 * need to do this before the inode is joined to the
224 * transaction to modify the i_size.
225 */
229 }
233 /*
234 * We are going to log the inode size change in this
235 * transaction so any previous writes that are beyond the on
236 * disk EOF and the new EOF that have not been written out need
237 * to be written here. If we do not write the data out, we
238 * expose ourselves to the null files problem.
239 *
240 * Only flush from the on disk size to the smaller of the in
241 * memory file size or the new size as that's the range we
242 * really care about here and prevents waiting for other data
243 * not within the range we care about here.
244 */
252 }
254 /* wait for all I/O to complete */
258 xfs_get_blocks);
264 XFS_TRANS_PERM_LOG_RES,
265 XFS_ITRUNCATE_LOG_COUNT);
278 /*
279 * Only change the c/mtime if we are changing the size
280 * or we are explicitly asked to change it. This handles
281 * the semantic difference between truncate() and ftruncate()
282 * as implemented in the VFS.
283 *
284 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME
285 * is a special case where we need to update the times despite
286 * not having these flags set. For all other operations the
287 * VFS set these flags explicitly if it wants a timestamp
288 * update.
289 */
295 }
303 /*
304 * signal a sync transaction unless
305 * we're truncating an already unlinked
306 * file on a wsync filesystem
307 */
309 XFS_DATA_FORK,
315 /*
316 * Truncated "down", so we're removing references
317 * to old data here - if we now delay flushing for
318 * a long time, we expose ourselves unduly to the
319 * notorious NULL files problem. So, we mark this
320 * vnode and flush it when the file is closed, and
321 * do not wait the usual (long) time for writeout.
322 */
324 }
327 }
329 /*
330 * Change file ownership. Must be the owner or privileged.
331 */
333 /*
334 * CAP_FSETID overrides the following restrictions:
335 *
336 * The set-user-ID and set-group-ID bits of a file will be
337 * cleared upon successful return from chown()
338 */
342 }
344 /*
345 * Change the ownerships and register quota modifications
346 * in the transaction.
347 */
354 }
357 }
365 }
368 }
369 }
371 /*
372 * Change file access modes.
373 */
385 }
387 /*
388 * Change file access or modified times.
389 */
395 }
401 }
407 }
409 /*
410 * And finally, log the inode core if any attribute in it
411 * has been changed.
412 */
419 /*
420 * If this is a synchronous mount, make sure that the
421 * transaction goes to disk before returning to the user.
422 * This is slightly sub-optimal in that truncates require
423 * two sync transactions instead of one for wsync filesystems.
424 * One for the truncate and one for the timestamps since we
425 * don't want to change the timestamps unless we're sure the
426 * truncate worked. Truncates are less than 1% of the laddis
427 * mix so this probably isn't worth the trouble to optimize.
428 */
437 /*
438 * Release any dquot(s) the inode had kept before chown.
439 */
448 /*
449 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
450 * update. We could avoid this with linked transactions
451 * and passing down the transaction pointer all the way
452 * to attr_set. No previous user of the generic
453 * Posix ACL code seems to care about this issue either.
454 */
459 }
463 abort_return:
465 error_return:
470 }
473 }
475 }
477 /*
478 * The maximum pathlen is 1024 bytes. Since the minimum file system
479 * blocksize is 512 bytes, we can get a max of 2 extents back from
480 * bmapi.
481 */
482 #define SYMLINK_MAPS 2
484 STATIC int
488 {
493 xfs_daddr_t d;
516 }
523 }
528 out:
530 }
532 int
536 {
560 }
562 out:
565 }
567 /*
568 * Flags for xfs_free_eofblocks
569 */
570 #define XFS_FREE_EOF_TRYLOCK (1<<0)
572 /*
573 * This is called by xfs_inactive to free any blocks beyond eof
574 * when the link count isn't zero and by xfs_dm_punch_hole() when
575 * punching a hole to EOF.
576 */
577 STATIC int
582 {
585 xfs_fileoff_t end_fsb;
586 xfs_fileoff_t last_fsb;
587 xfs_filblks_t map_len;
589 xfs_bmbt_irec_t imap;
591 /*
592 * Figure out if there are any blocks beyond the end
593 * of the file. If not, then there is nothing to do.
594 */
610 /*
611 * Attach the dquots to the inode up front.
612 */
617 /*
618 * There are blocks after the end of file.
619 * Free them up now by truncating the file to
620 * its current size.
621 */
624 /*
625 * Do the xfs_itruncate_start() call before
626 * reserving any log space because
627 * itruncate_start will call into the buffer
628 * cache and we can't
629 * do that within a transaction.
630 */
635 }
638 }
645 }
650 XFS_ITRUNCATE_LOG_COUNT);
656 }
663 XFS_DATA_FORK,
665 /*
666 * If we get an error at this point we
667 * simply don't bother truncating the file.
668 */
672 XFS_TRANS_ABORT));
675 XFS_TRANS_RELEASE_LOG_RES);
676 }
678 }
680 }
682 /*
683 * Free a symlink that has blocks associated with it.
684 */
685 STATIC int
689 {
694 xfs_fsblock_t first_block;
695 xfs_bmap_free_t free_list;
707 /*
708 * We're freeing a symlink that has some
709 * blocks allocated to it. Free the
710 * blocks here. We know that we've got
711 * either 1 or 2 extents and that we can
712 * free them all in one bunmapi call.
713 */
721 }
722 /*
723 * Lock the inode, fix the size, and join it to the transaction.
724 * Hold it so in the normal path, we still have it locked for
725 * the second transaction. In the error paths we need it
726 * held so the cancel won't rele it, see below.
727 */
733 /*
734 * Find the block(s) so we can inval and unmap them.
735 */
743 /*
744 * Invalidate the block(s).
745 */
751 }
752 /*
753 * Unmap the dead block(s) to the free_list.
754 */
759 /*
760 * Commit the first transaction. This logs the EFI and the inode.
761 */
764 /*
765 * The transaction must have been committed, since there were
766 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
767 * The new tp has the extent freeing and EFDs.
768 */
770 /*
771 * The first xact was committed, so add the inode to the new one.
772 * Mark it dirty so it will be logged and moved forward in the log as
773 * part of every commit.
774 */
777 /*
778 * Get a new, empty transaction to return to our caller.
779 */
781 /*
782 * Commit the transaction containing extent freeing and EFDs.
783 * If we get an error on the commit here or on the reserve below,
784 * we need to unlock the inode since the new transaction doesn't
785 * have the inode attached.
786 */
792 }
793 /*
794 * transaction commit worked ok so we can drop the extra ticket
795 * reference that we gained in xfs_trans_dup()
796 */
799 /*
800 * Remove the memory for extent descriptions (just bookkeeping).
801 */
805 /*
806 * Put an itruncate log reservation in the new transaction
807 * for our caller.
808 */
813 }
814 /*
815 * Return with the inode locked but not joined to the transaction.
816 */
820 error1:
822 error0:
823 /*
824 * Have to come here with the inode locked and either
825 * (held and in the transaction) or (not in the transaction).
826 * If the inode isn't held then cancel would iput it, but
827 * that's wrong since this is inactive and the vnode ref
828 * count is 0 already.
829 * Cancel won't do anything to the inode if held, but it still
830 * needs to be locked until the cancel is done, if it was
831 * joined to the transaction.
832 */
838 }
840 STATIC int
844 {
848 /*
849 * We're freeing a symlink which fit into
850 * the inode. Just free the memory used
851 * to hold the old symlink.
852 */
856 XFS_ITRUNCATE_LOG_COUNT);
862 }
865 /*
866 * Zero length symlinks _can_ exist.
867 */
871 XFS_DATA_FORK);
873 }
875 }
877 STATIC int
881 {
903 XFS_INACTIVE_LOG_COUNT);
916 error_cancel:
919 error_unlock:
923 }
925 int
928 {
935 /* If this is a read-only mount, don't do this (would generate I/O) */
942 /*
943 * If we are using filestreams, and we have an unlinked
944 * file that we are processing the last close on, then nothing
945 * will be able to reopen and write to this file. Purge this
946 * inode from the filestreams cache so that it doesn't delay
947 * teardown of the inode.
948 */
952 /*
953 * If we previously truncated this file and removed old data
954 * in the process, we want to initiate "early" writeout on
955 * the last close. This is an attempt to combat the notorious
956 * NULL files problem which is particularly noticeable from a
957 * truncate down, buffered (re-)write (delalloc), followed by
958 * a crash. What we are effectively doing here is
959 * significantly reducing the time window where we'd otherwise
960 * be exposed to that problem.
961 */
967 }
968 }
979 /*
980 * If we can't get the iolock just skip truncating the blocks
981 * past EOF because we could deadlock with the mmap_sem
982 * otherwise. We'll get another chance to drop them once the
983 * last reference to the inode is dropped, so we'll never leak
984 * blocks permanently.
985 *
986 * Further, check if the inode is being opened, written and
987 * closed frequently and we have delayed allocation blocks
988 * outstanding (e.g. streaming writes from the NFS server),
989 * truncating the blocks past EOF will cause fragmentation to
990 * occur.
991 *
992 * In this case don't do the truncation, either, but we have to
993 * be careful how we detect this case. Blocks beyond EOF show
994 * up as i_delayed_blks even when the inode is clean, so we
995 * need to truncate them away first before checking for a dirty
996 * release. Hence on the first dirty close we will still remove
997 * the speculative allocation, but after that we will leave it
998 * in place.
999 */
1004 XFS_FREE_EOF_TRYLOCK);
1008 /* delalloc blocks after truncation means it really is dirty */
1011 }
1013 }
1015 /*
1016 * xfs_inactive
1017 *
1018 * This is called when the vnode reference count for the vnode
1019 * goes to zero. If the file has been unlinked, then it must
1020 * now be truncated. Also, we clear all of the read-ahead state
1021 * kept for the inode here since the file is now closed.
1022 */
1023 int
1026 {
1027 xfs_bmap_free_t free_list;
1028 xfs_fsblock_t first_block;
1035 /*
1036 * If the inode is already free, then there can be nothing
1037 * to clean up here.
1038 */
1043 }
1045 /*
1046 * Only do a truncate if it's a regular file with
1047 * some actual space in it. It's OK to look at the
1048 * inode's fields without the lock because we're the
1049 * only one with a reference to the inode.
1050 */
1060 /* If this is a read-only mount, don't do this (would generate I/O) */
1075 }
1077 }
1087 /*
1088 * Do the xfs_itruncate_start() call before
1089 * reserving any log space because itruncate_start
1090 * will call into the buffer cache and we can't
1091 * do that within a transaction.
1092 */
1100 }
1105 XFS_ITRUNCATE_LOG_COUNT);
1107 /* Don't call itruncate_cleanup */
1112 }
1117 /*
1118 * normally, we have to run xfs_itruncate_finish sync.
1119 * But if filesystem is wsync and we're in the inactive
1120 * path, then we know that nlink == 0, and that the
1121 * xaction that made nlink == 0 is permanently committed
1122 * since xfs_remove runs as a synchronous transaction.
1123 */
1132 }
1135 /*
1136 * If we get an error while cleaning up a
1137 * symlink we bail out.
1138 */
1146 }
1153 XFS_INACTIVE_LOG_COUNT);
1158 }
1162 }
1164 /*
1165 * If there are attributes associated with the file
1166 * then blow them away now. The code calls a routine
1167 * that recursively deconstructs the attribute fork.
1168 * We need to just commit the current transaction
1169 * because we can't use it for xfs_attr_inactive().
1170 */
1173 /*
1174 * If we got an error, the transaction is already
1175 * cancelled, and the inode is unlocked. Just get out.
1176 */
1181 }
1183 /*
1184 * Free the inode.
1185 */
1189 /*
1190 * If we fail to free the inode, shut down. The cancel
1191 * might do that, we need to make sure. Otherwise the
1192 * inode might be lost for a long time or forever.
1193 */
1198 }
1201 /*
1202 * Credit the quota account(s). The inode is gone.
1203 */
1206 /*
1207 * Just ignore errors at this point. There is nothing we can
1208 * do except to try to keep going. Make sure it's not a silent
1209 * error.
1210 */
1219 }
1221 /*
1222 * Release the dquots held by inode, if any.
1223 */
1227 out:
1229 }
1231 /*
1232 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1233 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1234 * ci_name->name will point to a the actual name (caller must free) or
1235 * will be set to NULL if an exact match is found.
1236 */
1237 int
1243 {
1244 xfs_ino_t inum;
1246 uint lock_mode;
1266 out_free_name:
1269 out:
1272 }
1274 int
1278 mode_t mode,
1279 xfs_dev_t rdev,
1281 {
1287 xfs_bmap_free_t free_list;
1288 xfs_fsblock_t first_block;
1290 uint cancel_flags;
1292 prid_t prid;
1295 uint resblks;
1296 uint log_res;
1297 uint log_count;
1306 else
1309 /*
1310 * Make sure that we have allocated dquot(s) on disk.
1311 */
1328 }
1332 /*
1333 * Initially assume that the file does not exist and
1334 * reserve the resources for that case. If that is not
1335 * the case we'll drop the one we have and get a more
1336 * appropriate transaction later.
1337 */
1341 /* flush outstanding delalloc blocks and retry */
1345 }
1347 /* No space at all so try a "no-allocation" reservation */
1351 }
1355 }
1360 /*
1361 * Check for directory link count overflow.
1362 */
1366 }
1370 /*
1371 * Reserve disk quota and the inode.
1372 */
1381 /*
1382 * A newly created regular or special file just has one directory
1383 * entry pointing to them, but a directory also the "." entry
1384 * pointing to itself.
1385 */
1392 }
1394 /*
1395 * Now we join the directory inode to the transaction. We do not do it
1396 * earlier because xfs_dir_ialloc might commit the previous transaction
1397 * (and release all the locks). An error from here on will result in
1398 * the transaction cancel unlocking dp so don't do it explicitly in the
1399 * error path.
1400 */
1410 }
1422 }
1424 /*
1425 * If this is a synchronous mount, make sure that the
1426 * create transaction goes to disk before returning to
1427 * the user.
1428 */
1432 /*
1433 * Attach the dquot(s) to the inodes and modify them incore.
1434 * These ids of the inode couldn't have changed since the new
1435 * inode has been locked ever since it was created.
1436 */
1453 out_bmap_cancel:
1455 out_trans_abort:
1457 out_trans_cancel:
1459 out_release_inode:
1460 /*
1461 * Wait until after the current transaction is aborted to
1462 * release the inode. This prevents recursive transactions
1463 * and deadlocks from xfs_inactive.
1464 */
1474 }
1476 #ifdef DEBUG
1482 #endif
1484 /*
1485 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1486 * a different value
1487 */
1490 {
1497 }
1499 /*
1500 * The following routine will lock n inodes in exclusive mode.
1501 * We assume the caller calls us with the inodes in i_ino order.
1502 *
1503 * We need to detect deadlock where an inode that we lock
1504 * is in the AIL and we start waiting for another inode that is locked
1505 * by a thread in a long running transaction (such as truncate). This can
1506 * result in deadlock since the long running trans might need to wait
1507 * for the inode we just locked in order to push the tail and free space
1508 * in the log.
1509 */
1510 void
1514 uint lock_mode)
1515 {
1524 again:
1531 /*
1532 * If try_lock is not set yet, make sure all locked inodes
1533 * are not in the AIL.
1534 * If any are, set try_lock to be used later.
1535 */
1541 try_lock++;
1542 }
1543 }
1544 }
1546 /*
1547 * If any of the previous locks we have locked is in the AIL,
1548 * we must TRY to get the second and subsequent locks. If
1549 * we can't get any, we must release all we have
1550 * and try again.
1551 */
1554 /* try_lock must be 0 if i is 0. */
1555 /*
1556 * try_lock means we have an inode locked
1557 * that is in the AIL.
1558 */
1561 attempts++;
1563 /*
1564 * Unlock all previous guys and try again.
1565 * xfs_iunlock will try to push the tail
1566 * if the inode is in the AIL.
1567 */
1571 /*
1572 * Check to see if we've already
1573 * unlocked this one.
1574 * Not the first one going back,
1575 * and the inode ptr is the same.
1576 */
1582 }
1586 #ifdef DEBUG
1587 xfs_lock_delays++;
1588 #endif
1589 }
1593 }
1596 }
1597 }
1599 #ifdef DEBUG
1605 xfs_locked_n++;
1606 }
1607 #endif
1608 }
1610 /*
1611 * xfs_lock_two_inodes() can only be used to lock one type of lock
1612 * at a time - the iolock or the ilock, but not both at once. If
1613 * we lock both at once, lockdep will report false positives saying
1614 * we have violated locking orders.
1615 */
1616 void
1620 uint lock_mode)
1621 {
1634 }
1636 again:
1639 /*
1640 * If the first lock we have locked is in the AIL, we must TRY to get
1641 * the second lock. If we can't get it, we must release the first one
1642 * and try again.
1643 */
1651 }
1654 }
1655 }
1657 int
1662 {
1667 xfs_bmap_free_t free_list;
1668 xfs_fsblock_t first_block;
1672 uint resblks;
1673 uint log_count;
1694 }
1697 /*
1698 * We try to get the real space reservation first,
1699 * allowing for directory btree deletion(s) implying
1700 * possible bmap insert(s). If we can't get the space
1701 * reservation then we use 0 instead, and avoid the bmap
1702 * btree insert(s) in the directory code by, if the bmap
1703 * insert tries to happen, instead trimming the LAST
1704 * block from the directory.
1705 */
1713 }
1718 }
1725 /*
1726 * If we're removing a directory perform some additional validation.
1727 */
1733 }
1737 }
1738 }
1746 }
1750 /*
1751 * Drop the link from ip's "..".
1752 */
1757 /*
1758 * Drop the "." link from ip to self.
1759 */
1764 /*
1765 * When removing a non-directory we need to log the parent
1766 * inode here. For a directory this is done implicitly
1767 * by the xfs_droplink call for the ".." entry.
1768 */
1770 }
1772 /*
1773 * Drop the link from dp to ip.
1774 */
1779 /*
1780 * Determine if this is the last link while
1781 * we are in the transaction.
1782 */
1785 /*
1786 * If this is a synchronous mount, make sure that the
1787 * remove transaction goes to disk before returning to
1788 * the user.
1789 */
1801 /*
1802 * If we are using filestreams, kill the stream association.
1803 * If the file is still open it may get a new one but that
1804 * will get killed on last close in xfs_close() so we don't
1805 * have to worry about that.
1806 */
1812 out_bmap_cancel:
1815 out_trans_cancel:
1817 std_return:
1819 }
1821 int
1826 {
1830 xfs_bmap_free_t free_list;
1831 xfs_fsblock_t first_block;
1860 }
1864 }
1871 /*
1872 * If the source has too many links, we can't make any more to it.
1873 */
1877 }
1879 /*
1880 * If we are using project inheritance, we only allow hard link
1881 * creation in our tree when the project IDs are the same; else
1882 * the tree quota mechanism could be circumvented.
1883 */
1888 }
1907 /*
1908 * If this is a synchronous mount, make sure that the
1909 * link transaction goes to disk before returning to
1910 * the user.
1911 */
1914 }
1920 }
1924 abort_return:
1926 error_return:
1928 std_return:
1930 }
1932 int
1937 mode_t mode,
1939 {
1945 xfs_bmap_free_t free_list;
1946 xfs_fsblock_t first_block;
1948 uint cancel_flags;
1950 xfs_fileoff_t first_fsb;
1951 xfs_filblks_t fs_blocks;
1954 xfs_daddr_t d;
1959 prid_t prid;
1961 uint resblks;
1973 /*
1974 * Check component lengths of the target path name.
1975 */
1983 else
1986 /*
1987 * Make sure that we have allocated dquot(s) on disk.
1988 */
1996 /*
1997 * The symlink will fit into the inode data fork?
1998 * There can't be any attributes so we get the whole variable part.
1999 */
2002 else
2011 }
2015 }
2020 /*
2021 * Check whether the directory allows new symlinks or not.
2022 */
2026 }
2028 /*
2029 * Reserve disk quota : blocks and inode.
2030 */
2035 /*
2036 * Check for ability to enter directory entry, if no space reserved.
2037 */
2041 /*
2042 * Initialize the bmap freelist prior to calling either
2043 * bmapi or the directory create code.
2044 */
2047 /*
2048 * Allocate an inode for the symlink.
2049 */
2056 }
2058 /*
2059 * An error after we've joined dp to the transaction will result in the
2060 * transaction cancel unlocking dp so don't do it explicitly in the
2061 * error path.
2062 */
2066 /*
2067 * Also attach the dquot(s) to it, if applicable.
2068 */
2073 /*
2074 * If the symlink will fit into the inode, write it inline.
2075 */
2081 /*
2082 * The inode was initially created in extent format.
2083 */
2115 }
2122 }
2123 }
2125 /*
2126 * Create the directory entry for the symlink.
2127 */
2135 /*
2136 * If this is a synchronous mount, make sure that the
2137 * symlink transaction goes to disk before returning to
2138 * the user.
2139 */
2142 }
2147 }
2155 error2:
2157 error1:
2160 error_return:
2167 std_return:
2169 }
2171 int
2174 u_int evmask,
2175 u_int16_t state)
2176 {
2192 }
2203 }
2205 /*
2206 * xfs_alloc_file_space()
2207 * This routine allocates disk space for the given file.
2208 *
2209 * If alloc_type == 0, this request is for an ALLOCSP type
2210 * request which will change the file size. In this case, no
2211 * DMAPI event will be generated by the call. A TRUNCATE event
2212 * will be generated later by xfs_setattr.
2213 *
2214 * If alloc_type != 0, this request is for a RESVSP type
2215 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2216 * lower block boundary byte address is less than the file's
2217 * length.
2218 *
2219 * RETURNS:
2220 * 0 on success
2221 * errno on error
2222 *
2223 */
2224 STATIC int
2227 xfs_off_t offset,
2228 xfs_off_t len,
2231 {
2233 xfs_off_t count;
2234 xfs_filblks_t allocated_fsb;
2235 xfs_filblks_t allocatesize_fsb;
2237 xfs_fileoff_t startoffset_fsb;
2238 xfs_fsblock_t firstfsb;
2245 xfs_bmap_free_t free_list;
2272 /*
2273 * Allocate file space until done or until there is an error
2274 */
2278 /*
2279 * Determine space reservations for data/realtime.
2280 */
2293 }
2295 /*
2296 * The transaction reservation is limited to a 32-bit block
2297 * count, hence we need to limit the number of blocks we are
2298 * trying to reserve to avoid an overflow. We can't allocate
2299 * more than @nimaps extents, and an extent is limited on disk
2300 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
2301 */
2312 }
2314 /*
2315 * Allocate and setup the transaction.
2316 */
2320 XFS_TRANS_PERM_LOG_RES,
2321 XFS_WRITE_LOG_COUNT);
2322 /*
2323 * Check for running out of space
2324 */
2326 /*
2327 * Free the transaction structure.
2328 */
2332 }
2341 /*
2342 * Issue the xfs_bmapi() call to allocate the blocks
2343 */
2351 }
2353 /*
2354 * Complete the transaction
2355 */
2359 }
2365 }
2372 }
2376 }
2388 }
2390 /*
2391 * Zero file bytes between startoff and endoff inclusive.
2392 * The iolock is held exclusive and no blocks are buffered.
2393 *
2394 * This function is used by xfs_free_file_space() to zero
2395 * partial blocks when the range to free is not block aligned.
2396 * When unreserving space with boundaries that are not block
2397 * aligned we round up the start and round down the end
2398 * boundaries and then use this function to zero the parts of
2399 * the blocks that got dropped during the rounding.
2400 */
2401 STATIC int
2404 xfs_off_t startoff,
2405 xfs_off_t endoff)
2406 {
2407 xfs_bmbt_irec_t imap;
2408 xfs_fileoff_t offset_fsb;
2409 xfs_off_t lastoffset;
2410 xfs_off_t offset;
2416 /*
2417 * Avoid doing I/O beyond eof - it's not necessary
2418 * since nothing can read beyond eof. The space will
2419 * be zeroed when the file is extended anyway.
2420 */
2460 }
2473 }
2474 }
2477 }
2479 /*
2480 * xfs_free_file_space()
2481 * This routine frees disk space for the given file.
2482 *
2483 * This routine is only called by xfs_change_file_space
2484 * for an UNRESVSP type call.
2485 *
2486 * RETURNS:
2487 * 0 on success
2488 * errno on error
2489 *
2490 */
2491 STATIC int
2494 xfs_off_t offset,
2495 xfs_off_t len,
2497 {
2500 xfs_fileoff_t endoffset_fsb;
2502 xfs_fsblock_t firstfsb;
2503 xfs_bmap_free_t free_list;
2504 xfs_bmbt_irec_t imap;
2505 xfs_off_t ioffset;
2509 uint resblks;
2510 uint rounding;
2512 xfs_fileoff_t startoffset_fsb;
2535 /* wait for the completion of any pending DIOs */
2537 }
2546 }
2548 /*
2549 * Need to zero the stuff we're not freeing, on disk.
2550 * If it's a realtime file & can't use unwritten extents then we
2551 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2552 * will take care of it for us.
2553 */
2562 xfs_daddr_t block;
2569 }
2578 mod++;
2581 }
2582 }
2584 /*
2585 * One contiguous piece to clear
2586 */
2589 /*
2590 * Some full blocks, possibly two pieces to clear
2591 */
2600 }
2602 /*
2603 * free file space until done or until there is an error
2604 */
2608 /*
2609 * allocate and setup the transaction. Allow this
2610 * transaction to dip into the reserve blocks to ensure
2611 * the freeing of the space succeeds at ENOSPC.
2612 */
2616 resblks,
2619 XFS_TRANS_PERM_LOG_RES,
2620 XFS_WRITE_LOG_COUNT);
2622 /*
2623 * check for running out of space
2624 */
2626 /*
2627 * Free the transaction structure.
2628 */
2632 }
2642 /*
2643 * issue the bunmapi() call to free the blocks
2644 */
2651 }
2653 /*
2654 * complete the transaction
2655 */
2659 }
2663 }
2665 out_unlock_iolock:
2670 error0:
2672 error1:
2675 XFS_ILOCK_EXCL);
2677 }
2679 /*
2680 * xfs_change_file_space()
2681 * This routine allocates or frees disk space for the given file.
2682 * The user specified parameters are checked for alignment and size
2683 * limitations.
2684 *
2685 * RETURNS:
2686 * 0 on success
2687 * errno on error
2688 *
2689 */
2690 int
2695 xfs_off_t offset,
2697 {
2701 xfs_fsize_t fsize;
2703 xfs_off_t startoffset;
2704 xfs_off_t llen;
2723 }
2738 /*
2739 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2740 * file space.
2741 * These calls do NOT zero the data space allocated to the file,
2742 * nor do they change the file size.
2743 *
2744 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2745 * space.
2746 * These calls cause the new file data to be zeroed and the file
2747 * size to be changed.
2748 */
2756 /* FALLTHRU */
2769 attr_flags)))
2782 }
2798 }
2800 /*
2801 * update the inode timestamp, mode, and prealloc flag bits
2802 */
2807 /* ASSERT(0); */
2810 }
2819 /*
2820 * Note that we don't have to worry about mandatory
2821 * file locking being disabled here because we only
2822 * clear the S_ISGID bit if the Group execute bit is
2823 * on, but if it was on then mandatory locking wouldn't
2824 * have been enabled.
2825 */
2830 }
2845 }