| blob | b7a5fe7c52c895776f125d53851d40c48795dce7 |
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 */
965 }
976 /*
977 * If we can't get the iolock just skip truncating the blocks
978 * past EOF because we could deadlock with the mmap_sem
979 * otherwise. We'll get another chance to drop them once the
980 * last reference to the inode is dropped, so we'll never leak
981 * blocks permanently.
982 *
983 * Further, check if the inode is being opened, written and
984 * closed frequently and we have delayed allocation blocks
985 * outstanding (e.g. streaming writes from the NFS server),
986 * truncating the blocks past EOF will cause fragmentation to
987 * occur.
988 *
989 * In this case don't do the truncation, either, but we have to
990 * be careful how we detect this case. Blocks beyond EOF show
991 * up as i_delayed_blks even when the inode is clean, so we
992 * need to truncate them away first before checking for a dirty
993 * release. Hence on the first dirty close we will still remove
994 * the speculative allocation, but after that we will leave it
995 * in place.
996 */
1001 XFS_FREE_EOF_TRYLOCK);
1005 /* delalloc blocks after truncation means it really is dirty */
1008 }
1010 }
1012 /*
1013 * xfs_inactive
1014 *
1015 * This is called when the vnode reference count for the vnode
1016 * goes to zero. If the file has been unlinked, then it must
1017 * now be truncated. Also, we clear all of the read-ahead state
1018 * kept for the inode here since the file is now closed.
1019 */
1020 int
1023 {
1024 xfs_bmap_free_t free_list;
1025 xfs_fsblock_t first_block;
1032 /*
1033 * If the inode is already free, then there can be nothing
1034 * to clean up here.
1035 */
1040 }
1042 /*
1043 * Only do a truncate if it's a regular file with
1044 * some actual space in it. It's OK to look at the
1045 * inode's fields without the lock because we're the
1046 * only one with a reference to the inode.
1047 */
1057 /* If this is a read-only mount, don't do this (would generate I/O) */
1072 }
1074 }
1084 /*
1085 * Do the xfs_itruncate_start() call before
1086 * reserving any log space because itruncate_start
1087 * will call into the buffer cache and we can't
1088 * do that within a transaction.
1089 */
1097 }
1102 XFS_ITRUNCATE_LOG_COUNT);
1104 /* Don't call itruncate_cleanup */
1109 }
1114 /*
1115 * normally, we have to run xfs_itruncate_finish sync.
1116 * But if filesystem is wsync and we're in the inactive
1117 * path, then we know that nlink == 0, and that the
1118 * xaction that made nlink == 0 is permanently committed
1119 * since xfs_remove runs as a synchronous transaction.
1120 */
1129 }
1132 /*
1133 * If we get an error while cleaning up a
1134 * symlink we bail out.
1135 */
1143 }
1150 XFS_INACTIVE_LOG_COUNT);
1155 }
1159 }
1161 /*
1162 * If there are attributes associated with the file
1163 * then blow them away now. The code calls a routine
1164 * that recursively deconstructs the attribute fork.
1165 * We need to just commit the current transaction
1166 * because we can't use it for xfs_attr_inactive().
1167 */
1170 /*
1171 * If we got an error, the transaction is already
1172 * cancelled, and the inode is unlocked. Just get out.
1173 */
1178 }
1180 /*
1181 * Free the inode.
1182 */
1186 /*
1187 * If we fail to free the inode, shut down. The cancel
1188 * might do that, we need to make sure. Otherwise the
1189 * inode might be lost for a long time or forever.
1190 */
1195 }
1198 /*
1199 * Credit the quota account(s). The inode is gone.
1200 */
1203 /*
1204 * Just ignore errors at this point. There is nothing we can
1205 * do except to try to keep going. Make sure it's not a silent
1206 * error.
1207 */
1216 }
1218 /*
1219 * Release the dquots held by inode, if any.
1220 */
1224 out:
1226 }
1228 /*
1229 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1230 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1231 * ci_name->name will point to a the actual name (caller must free) or
1232 * will be set to NULL if an exact match is found.
1233 */
1234 int
1240 {
1241 xfs_ino_t inum;
1243 uint lock_mode;
1263 out_free_name:
1266 out:
1269 }
1271 int
1275 mode_t mode,
1276 xfs_dev_t rdev,
1278 {
1284 xfs_bmap_free_t free_list;
1285 xfs_fsblock_t first_block;
1287 uint cancel_flags;
1289 prid_t prid;
1292 uint resblks;
1293 uint log_res;
1294 uint log_count;
1303 else
1306 /*
1307 * Make sure that we have allocated dquot(s) on disk.
1308 */
1325 }
1329 /*
1330 * Initially assume that the file does not exist and
1331 * reserve the resources for that case. If that is not
1332 * the case we'll drop the one we have and get a more
1333 * appropriate transaction later.
1334 */
1338 /* flush outstanding delalloc blocks and retry */
1342 }
1344 /* No space at all so try a "no-allocation" reservation */
1348 }
1352 }
1357 /*
1358 * Check for directory link count overflow.
1359 */
1363 }
1367 /*
1368 * Reserve disk quota and the inode.
1369 */
1378 /*
1379 * A newly created regular or special file just has one directory
1380 * entry pointing to them, but a directory also the "." entry
1381 * pointing to itself.
1382 */
1389 }
1391 /*
1392 * Now we join the directory inode to the transaction. We do not do it
1393 * earlier because xfs_dir_ialloc might commit the previous transaction
1394 * (and release all the locks). An error from here on will result in
1395 * the transaction cancel unlocking dp so don't do it explicitly in the
1396 * error path.
1397 */
1407 }
1419 }
1421 /*
1422 * If this is a synchronous mount, make sure that the
1423 * create transaction goes to disk before returning to
1424 * the user.
1425 */
1429 /*
1430 * Attach the dquot(s) to the inodes and modify them incore.
1431 * These ids of the inode couldn't have changed since the new
1432 * inode has been locked ever since it was created.
1433 */
1450 out_bmap_cancel:
1452 out_trans_abort:
1454 out_trans_cancel:
1456 out_release_inode:
1457 /*
1458 * Wait until after the current transaction is aborted to
1459 * release the inode. This prevents recursive transactions
1460 * and deadlocks from xfs_inactive.
1461 */
1471 }
1473 #ifdef DEBUG
1479 #endif
1481 /*
1482 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1483 * a different value
1484 */
1487 {
1494 }
1496 /*
1497 * The following routine will lock n inodes in exclusive mode.
1498 * We assume the caller calls us with the inodes in i_ino order.
1499 *
1500 * We need to detect deadlock where an inode that we lock
1501 * is in the AIL and we start waiting for another inode that is locked
1502 * by a thread in a long running transaction (such as truncate). This can
1503 * result in deadlock since the long running trans might need to wait
1504 * for the inode we just locked in order to push the tail and free space
1505 * in the log.
1506 */
1507 void
1511 uint lock_mode)
1512 {
1521 again:
1528 /*
1529 * If try_lock is not set yet, make sure all locked inodes
1530 * are not in the AIL.
1531 * If any are, set try_lock to be used later.
1532 */
1538 try_lock++;
1539 }
1540 }
1541 }
1543 /*
1544 * If any of the previous locks we have locked is in the AIL,
1545 * we must TRY to get the second and subsequent locks. If
1546 * we can't get any, we must release all we have
1547 * and try again.
1548 */
1551 /* try_lock must be 0 if i is 0. */
1552 /*
1553 * try_lock means we have an inode locked
1554 * that is in the AIL.
1555 */
1558 attempts++;
1560 /*
1561 * Unlock all previous guys and try again.
1562 * xfs_iunlock will try to push the tail
1563 * if the inode is in the AIL.
1564 */
1568 /*
1569 * Check to see if we've already
1570 * unlocked this one.
1571 * Not the first one going back,
1572 * and the inode ptr is the same.
1573 */
1579 }
1583 #ifdef DEBUG
1584 xfs_lock_delays++;
1585 #endif
1586 }
1590 }
1593 }
1594 }
1596 #ifdef DEBUG
1602 xfs_locked_n++;
1603 }
1604 #endif
1605 }
1607 /*
1608 * xfs_lock_two_inodes() can only be used to lock one type of lock
1609 * at a time - the iolock or the ilock, but not both at once. If
1610 * we lock both at once, lockdep will report false positives saying
1611 * we have violated locking orders.
1612 */
1613 void
1617 uint lock_mode)
1618 {
1631 }
1633 again:
1636 /*
1637 * If the first lock we have locked is in the AIL, we must TRY to get
1638 * the second lock. If we can't get it, we must release the first one
1639 * and try again.
1640 */
1648 }
1651 }
1652 }
1654 int
1659 {
1664 xfs_bmap_free_t free_list;
1665 xfs_fsblock_t first_block;
1669 uint resblks;
1670 uint log_count;
1691 }
1694 /*
1695 * We try to get the real space reservation first,
1696 * allowing for directory btree deletion(s) implying
1697 * possible bmap insert(s). If we can't get the space
1698 * reservation then we use 0 instead, and avoid the bmap
1699 * btree insert(s) in the directory code by, if the bmap
1700 * insert tries to happen, instead trimming the LAST
1701 * block from the directory.
1702 */
1710 }
1715 }
1722 /*
1723 * If we're removing a directory perform some additional validation.
1724 */
1730 }
1734 }
1735 }
1743 }
1747 /*
1748 * Drop the link from ip's "..".
1749 */
1754 /*
1755 * Drop the "." link from ip to self.
1756 */
1761 /*
1762 * When removing a non-directory we need to log the parent
1763 * inode here. For a directory this is done implicitly
1764 * by the xfs_droplink call for the ".." entry.
1765 */
1767 }
1769 /*
1770 * Drop the link from dp to ip.
1771 */
1776 /*
1777 * Determine if this is the last link while
1778 * we are in the transaction.
1779 */
1782 /*
1783 * If this is a synchronous mount, make sure that the
1784 * remove transaction goes to disk before returning to
1785 * the user.
1786 */
1798 /*
1799 * If we are using filestreams, kill the stream association.
1800 * If the file is still open it may get a new one but that
1801 * will get killed on last close in xfs_close() so we don't
1802 * have to worry about that.
1803 */
1809 out_bmap_cancel:
1812 out_trans_cancel:
1814 std_return:
1816 }
1818 int
1823 {
1827 xfs_bmap_free_t free_list;
1828 xfs_fsblock_t first_block;
1857 }
1861 }
1868 /*
1869 * If the source has too many links, we can't make any more to it.
1870 */
1874 }
1876 /*
1877 * If we are using project inheritance, we only allow hard link
1878 * creation in our tree when the project IDs are the same; else
1879 * the tree quota mechanism could be circumvented.
1880 */
1885 }
1904 /*
1905 * If this is a synchronous mount, make sure that the
1906 * link transaction goes to disk before returning to
1907 * the user.
1908 */
1911 }
1917 }
1921 abort_return:
1923 error_return:
1925 std_return:
1927 }
1929 int
1934 mode_t mode,
1936 {
1942 xfs_bmap_free_t free_list;
1943 xfs_fsblock_t first_block;
1945 uint cancel_flags;
1947 xfs_fileoff_t first_fsb;
1948 xfs_filblks_t fs_blocks;
1951 xfs_daddr_t d;
1956 prid_t prid;
1958 uint resblks;
1970 /*
1971 * Check component lengths of the target path name.
1972 */
1980 else
1983 /*
1984 * Make sure that we have allocated dquot(s) on disk.
1985 */
1993 /*
1994 * The symlink will fit into the inode data fork?
1995 * There can't be any attributes so we get the whole variable part.
1996 */
1999 else
2008 }
2012 }
2017 /*
2018 * Check whether the directory allows new symlinks or not.
2019 */
2023 }
2025 /*
2026 * Reserve disk quota : blocks and inode.
2027 */
2032 /*
2033 * Check for ability to enter directory entry, if no space reserved.
2034 */
2038 /*
2039 * Initialize the bmap freelist prior to calling either
2040 * bmapi or the directory create code.
2041 */
2044 /*
2045 * Allocate an inode for the symlink.
2046 */
2053 }
2055 /*
2056 * An error after we've joined dp to the transaction will result in the
2057 * transaction cancel unlocking dp so don't do it explicitly in the
2058 * error path.
2059 */
2063 /*
2064 * Also attach the dquot(s) to it, if applicable.
2065 */
2070 /*
2071 * If the symlink will fit into the inode, write it inline.
2072 */
2078 /*
2079 * The inode was initially created in extent format.
2080 */
2112 }
2119 }
2120 }
2122 /*
2123 * Create the directory entry for the symlink.
2124 */
2132 /*
2133 * If this is a synchronous mount, make sure that the
2134 * symlink transaction goes to disk before returning to
2135 * the user.
2136 */
2139 }
2144 }
2152 error2:
2154 error1:
2157 error_return:
2164 std_return:
2166 }
2168 int
2171 u_int evmask,
2172 u_int16_t state)
2173 {
2189 }
2200 }
2202 /*
2203 * xfs_alloc_file_space()
2204 * This routine allocates disk space for the given file.
2205 *
2206 * If alloc_type == 0, this request is for an ALLOCSP type
2207 * request which will change the file size. In this case, no
2208 * DMAPI event will be generated by the call. A TRUNCATE event
2209 * will be generated later by xfs_setattr.
2210 *
2211 * If alloc_type != 0, this request is for a RESVSP type
2212 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2213 * lower block boundary byte address is less than the file's
2214 * length.
2215 *
2216 * RETURNS:
2217 * 0 on success
2218 * errno on error
2219 *
2220 */
2221 STATIC int
2224 xfs_off_t offset,
2225 xfs_off_t len,
2228 {
2230 xfs_off_t count;
2231 xfs_filblks_t allocated_fsb;
2232 xfs_filblks_t allocatesize_fsb;
2234 xfs_fileoff_t startoffset_fsb;
2235 xfs_fsblock_t firstfsb;
2242 xfs_bmap_free_t free_list;
2269 /*
2270 * Allocate file space until done or until there is an error
2271 */
2275 /*
2276 * Determine space reservations for data/realtime.
2277 */
2290 }
2292 /*
2293 * The transaction reservation is limited to a 32-bit block
2294 * count, hence we need to limit the number of blocks we are
2295 * trying to reserve to avoid an overflow. We can't allocate
2296 * more than @nimaps extents, and an extent is limited on disk
2297 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
2298 */
2309 }
2311 /*
2312 * Allocate and setup the transaction.
2313 */
2317 XFS_TRANS_PERM_LOG_RES,
2318 XFS_WRITE_LOG_COUNT);
2319 /*
2320 * Check for running out of space
2321 */
2323 /*
2324 * Free the transaction structure.
2325 */
2329 }
2338 /*
2339 * Issue the xfs_bmapi() call to allocate the blocks
2340 */
2348 }
2350 /*
2351 * Complete the transaction
2352 */
2356 }
2362 }
2369 }
2373 }
2385 }
2387 /*
2388 * Zero file bytes between startoff and endoff inclusive.
2389 * The iolock is held exclusive and no blocks are buffered.
2390 *
2391 * This function is used by xfs_free_file_space() to zero
2392 * partial blocks when the range to free is not block aligned.
2393 * When unreserving space with boundaries that are not block
2394 * aligned we round up the start and round down the end
2395 * boundaries and then use this function to zero the parts of
2396 * the blocks that got dropped during the rounding.
2397 */
2398 STATIC int
2401 xfs_off_t startoff,
2402 xfs_off_t endoff)
2403 {
2404 xfs_bmbt_irec_t imap;
2405 xfs_fileoff_t offset_fsb;
2406 xfs_off_t lastoffset;
2407 xfs_off_t offset;
2413 /*
2414 * Avoid doing I/O beyond eof - it's not necessary
2415 * since nothing can read beyond eof. The space will
2416 * be zeroed when the file is extended anyway.
2417 */
2457 }
2470 }
2471 }
2474 }
2476 /*
2477 * xfs_free_file_space()
2478 * This routine frees disk space for the given file.
2479 *
2480 * This routine is only called by xfs_change_file_space
2481 * for an UNRESVSP type call.
2482 *
2483 * RETURNS:
2484 * 0 on success
2485 * errno on error
2486 *
2487 */
2488 STATIC int
2491 xfs_off_t offset,
2492 xfs_off_t len,
2494 {
2497 xfs_fileoff_t endoffset_fsb;
2499 xfs_fsblock_t firstfsb;
2500 xfs_bmap_free_t free_list;
2501 xfs_bmbt_irec_t imap;
2502 xfs_off_t ioffset;
2506 uint resblks;
2507 uint rounding;
2509 xfs_fileoff_t startoffset_fsb;
2532 /* wait for the completion of any pending DIOs */
2534 }
2543 }
2545 /*
2546 * Need to zero the stuff we're not freeing, on disk.
2547 * If it's a realtime file & can't use unwritten extents then we
2548 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2549 * will take care of it for us.
2550 */
2559 xfs_daddr_t block;
2566 }
2575 mod++;
2578 }
2579 }
2581 /*
2582 * One contiguous piece to clear
2583 */
2586 /*
2587 * Some full blocks, possibly two pieces to clear
2588 */
2597 }
2599 /*
2600 * free file space until done or until there is an error
2601 */
2605 /*
2606 * allocate and setup the transaction. Allow this
2607 * transaction to dip into the reserve blocks to ensure
2608 * the freeing of the space succeeds at ENOSPC.
2609 */
2613 resblks,
2616 XFS_TRANS_PERM_LOG_RES,
2617 XFS_WRITE_LOG_COUNT);
2619 /*
2620 * check for running out of space
2621 */
2623 /*
2624 * Free the transaction structure.
2625 */
2629 }
2639 /*
2640 * issue the bunmapi() call to free the blocks
2641 */
2648 }
2650 /*
2651 * complete the transaction
2652 */
2656 }
2660 }
2662 out_unlock_iolock:
2667 error0:
2669 error1:
2672 XFS_ILOCK_EXCL);
2674 }
2676 /*
2677 * xfs_change_file_space()
2678 * This routine allocates or frees disk space for the given file.
2679 * The user specified parameters are checked for alignment and size
2680 * limitations.
2681 *
2682 * RETURNS:
2683 * 0 on success
2684 * errno on error
2685 *
2686 */
2687 int
2692 xfs_off_t offset,
2694 {
2698 xfs_fsize_t fsize;
2700 xfs_off_t startoffset;
2701 xfs_off_t llen;
2720 }
2735 /*
2736 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2737 * file space.
2738 * These calls do NOT zero the data space allocated to the file,
2739 * nor do they change the file size.
2740 *
2741 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2742 * space.
2743 * These calls cause the new file data to be zeroed and the file
2744 * size to be changed.
2745 */
2753 /* FALLTHRU */
2766 attr_flags)))
2779 }
2795 }
2797 /*
2798 * update the inode timestamp, mode, and prealloc flag bits
2799 */
2804 /* ASSERT(0); */
2807 }
2816 /*
2817 * Note that we don't have to worry about mandatory
2818 * file locking being disabled here because we only
2819 * clear the S_ISGID bit if the Group execute bit is
2820 * on, but if it was on then mandatory locking wouldn't
2821 * have been enabled.
2822 */
2827 }
2842 }