| blob | e475e3717eb3cf114a61a6cbbe4f2339df5d4a7d |
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 */
56 int
59 {
65 /*
66 * If it's a directory with any blocks, read-ahead block 0
67 * as we're almost certain to have the next operation be a read there.
68 */
74 }
76 }
78 /*
79 * xfs_setattr
80 */
81 int
87 {
92 uint lock_flags;
107 /*
108 * Cannot set certain attributes.
109 */
113 }
118 /*
119 * Timestamps do not need to be logged and hence do not
120 * need to be done within a transaction.
121 */
129 }
134 /*
135 * If disk quotas is on, we make sure that the dquots do exist on disk,
136 * before we start any other transactions. Trying to do this later
137 * is messy. We don't care to take a readlock to look at the ids
138 * in inode here, because we can't hold it across the trans_reserve.
139 * If the IDs do change before we take the ilock, we're covered
140 * because the i_*dquot fields will get updated anyway.
141 */
151 }
157 }
163 }
164 /*
165 * We take a reference when we initialize udqp and gdqp,
166 * so it is important that we never blindly double trip on
167 * the same variable. See xfs_create() for an example.
168 */
175 }
177 /*
178 * For the other attributes, we acquire the inode lock and
179 * first do an error checking pass.
180 */
195 }
196 }
206 }
207 }
210 }
214 /* boolean: are we the file owner? */
217 /*
218 * Change various properties of a file.
219 * Only the owner or users with CAP_FOWNER
220 * capability may do these things.
221 */
225 /*
226 * CAP_FOWNER overrides the following restrictions:
227 *
228 * The user ID of the calling process must be equal
229 * to the file owner ID, except in cases where the
230 * CAP_FSETID capability is applicable.
231 */
235 }
237 /*
238 * CAP_FSETID overrides the following restrictions:
239 *
240 * The effective user ID of the calling process shall match
241 * the file owner when setting the set-user-ID and
242 * set-group-ID bits on that file.
243 *
244 * The effective group ID or one of the supplementary group
245 * IDs of the calling process shall match the group owner of
246 * the file when setting the set-group-ID bit on that file
247 */
256 #if 0
257 /* Linux allows this, Irix doesn't. */
260 #endif
263 }
264 }
266 /*
267 * Change file ownership. Must be the owner or privileged.
268 * If the system was configured with the "restricted_chown"
269 * option, the owner is not permitted to give away the file,
270 * and can change the group id only to a group of which he
271 * or she is a member.
272 */
274 /*
275 * These IDs could have changed since we last looked at them.
276 * But, we're assured that if the ownership did change
277 * while we didn't have the inode locked, inode's dquot(s)
278 * would have changed also.
279 */
286 iprojid;
288 /*
289 * CAP_CHOWN overrides the following restrictions:
290 *
291 * If _POSIX_CHOWN_RESTRICTED is defined, this capability
292 * shall override the restriction that a process cannot
293 * change the user ID of a file it owns and the restriction
294 * that the group ID supplied to the chown() function
295 * shall be equal to either the group ID or one of the
296 * supplementary group IDs of the calling process.
297 */
304 }
305 /*
306 * Do a quota reservation only if uid/projid/gid is actually
307 * going to change.
308 */
318 }
319 }
321 /*
322 * Truncate file. Must have write permission and not be a directory.
323 */
325 /* Short circuit the truncate case for zero length files */
334 }
342 }
343 /*
344 * Make sure that the dquots are attached to the inode.
345 */
348 }
350 /*
351 * Change file access or modified times.
352 */
359 }
360 }
361 }
363 /*
364 * Change extent size or realtime flag.
365 */
367 /*
368 * Can't change extent size if any extents are allocated.
369 */
375 }
377 /*
378 * Can't change realtime flag if any extents are allocated.
379 */
386 }
387 /*
388 * Extent size must be a multiple of the appropriate block
389 * size, if set at all.
390 */
392 xfs_extlen_t size;
401 }
405 }
406 }
407 /*
408 * If realtime flag is set then must have realtime data.
409 */
417 }
418 }
420 /*
421 * Can't modify an immutable/append-only file unless
422 * we have appropriate permission.
423 */
432 }
433 }
435 /*
436 * Now we can make the changes. Before we join the inode
437 * to the transaction, if XFS_AT_SIZE is set then take care of
438 * the part of the truncation that must be done without the
439 * inode lock. This needs to be done before joining the inode
440 * to the transaction, because the inode cannot be unlocked
441 * once it is a part of the transaction.
442 */
448 }
451 /*
452 * We are going to log the inode size change in this
453 * transaction so any previous writes that are beyond the on
454 * disk EOF and the new EOF that have not been written out need
455 * to be written here. If we do not write the data out, we
456 * expose ourselves to the null files problem.
457 *
458 * Only flush from the on disk size to the smaller of the in
459 * memory file size or the new size as that's the range we
460 * really care about here and prevents waiting for other data
461 * not within the range we care about here.
462 */
469 }
471 /* wait for all I/O to complete */
481 }
485 XFS_TRANS_PERM_LOG_RES,
486 XFS_ITRUNCATE_LOG_COUNT))) {
491 }
494 }
499 }
501 /*
502 * Truncate file. Must have write permission and not be a directory.
503 */
505 /*
506 * Only change the c/mtime if we are changing the size
507 * or we are explicitly asked to change it. This handles
508 * the semantic difference between truncate() and ftruncate()
509 * as implemented in the VFS.
510 */
519 /*
520 * signal a sync transaction unless
521 * we're truncating an already unlinked
522 * file on a wsync filesystem
523 */
526 XFS_DATA_FORK,
532 /*
533 * Truncated "down", so we're removing references
534 * to old data here - if we now delay flushing for
535 * a long time, we expose ourselves unduly to the
536 * notorious NULL files problem. So, we mark this
537 * vnode and flush it when the file is closed, and
538 * do not wait the usual (long) time for writeout.
539 */
541 }
542 }
544 /*
545 * Change file access modes.
546 */
553 }
555 /*
556 * Change file ownership. Must be the owner or privileged.
557 * If the system was configured with the "restricted_chown"
558 * option, the owner is not permitted to give away the file,
559 * and can change the group id only to a group of which he
560 * or she is a member.
561 */
563 /*
564 * CAP_FSETID overrides the following restrictions:
565 *
566 * The set-user-ID and set-group-ID bits of a file will be
567 * cleared upon successful return from chown()
568 */
572 }
574 /*
575 * Change the ownerships and register quota modifications
576 * in the transaction.
577 */
584 }
586 }
594 }
596 }
604 }
606 /*
607 * We may have to rev the inode as well as
608 * the superblock version number since projids didn't
609 * exist before DINODE_VERSION_2 and SB_VERSION_NLINK.
610 */
613 }
617 }
620 /*
621 * Change file access or modified times.
622 */
629 }
635 }
638 }
640 /*
641 * Change XFS-added attributes.
642 */
645 /*
646 * Converting bytes to fs blocks.
647 */
650 }
652 uint di_flags;
654 /* can't set PREALLOC this way, just preserve it */
684 }
686 }
689 }
691 /*
692 * Change file inode change time only if XFS_AT_CTIME set
693 * AND we have been called by a DMI function.
694 */
701 }
703 /*
704 * Send out timestamp changes that need to be set to the
705 * current time. Not done when called by a DMI function.
706 */
712 /*
713 * If this is a synchronous mount, make sure that the
714 * transaction goes to disk before returning to the user.
715 * This is slightly sub-optimal in that truncates require
716 * two sync transactions instead of one for wsync filesystems.
717 * One for the truncate and one for the timestamps since we
718 * don't want to change the timestamps unless we're sure the
719 * truncate worked. Truncates are less than 1% of the laddis
720 * mix so this probably isn't worth the trouble to optimize.
721 */
728 }
732 /*
733 * Release any dquot(s) the inode had kept before chown.
734 */
742 }
749 }
752 abort_return:
754 /* FALLTHROUGH */
755 error_return:
760 }
763 }
765 }
767 /*
768 * The maximum pathlen is 1024 bytes. Since the minimum file system
769 * blocksize is 512 bytes, we can get a max of 2 extents back from
770 * bmapi.
771 */
772 #define SYMLINK_MAPS 2
774 STATIC int
778 {
783 xfs_daddr_t d;
805 }
812 }
817 out:
819 }
821 int
825 {
849 }
851 out:
854 }
856 /*
857 * xfs_fsync
858 *
859 * This is called to sync the inode and its data out to disk. We need to hold
860 * the I/O lock while flushing the data, and the inode lock while flushing the
861 * inode. The inode lock CANNOT be held while flushing the data, so acquire
862 * after we're done with that.
863 */
864 int
867 {
877 /* capture size updates in I/O completion before writing the inode. */
882 /*
883 * We always need to make sure that the required inode state is safe on
884 * disk. The vnode might be clean but we still might need to force the
885 * log because of committed transactions that haven't hit the disk yet.
886 * Likewise, there could be unflushed non-transactional changes to the
887 * inode core that have to go to disk and this requires us to issue
888 * a synchronous transaction to capture these changes correctly.
889 *
890 * This code relies on the assumption that if the update_* fields
891 * of the inode are clear and the inode is unpinned then it is clean
892 * and no action is required.
893 */
897 /*
898 * Timestamps/size haven't changed since last inode flush or
899 * inode transaction commit. That means either nothing got
900 * written or a transaction committed which caught the updates.
901 * If the latter happened and the transaction hasn't hit the
902 * disk yet, the inode will be still be pinned. If it is,
903 * force the log.
904 */
913 /*
914 * If the inode is not pinned and nothing has changed
915 * we don't need to flush the cache.
916 */
918 }
920 /*
921 * Kick off a transaction to log the inode core to get the
922 * updates. The sync transaction will also force the log.
923 */
931 }
934 /*
935 * Note - it's possible that we might have pushed ourselves out
936 * of the way during trans_reserve which would flush the inode.
937 * But there's no guarantee that the inode buffer has actually
938 * gone out yet (it's delwri). Plus the buffer could be pinned
939 * anyway if it's part of an inode in another recent
940 * transaction. So we play it safe and fire off the
941 * transaction anyway.
942 */
950 }
953 /*
954 * If the log write didn't issue an ordered tag we need
955 * to flush the disk cache for the data device now.
956 */
960 /*
961 * If this inode is on the RT dev we need to flush that
962 * cache as well.
963 */
966 }
969 }
971 /*
972 * This is called by xfs_inactive to free any blocks beyond eof
973 * when the link count isn't zero and by xfs_dm_punch_hole() when
974 * punching a hole to EOF.
975 */
976 int
981 {
984 xfs_fileoff_t end_fsb;
985 xfs_fileoff_t last_fsb;
986 xfs_filblks_t map_len;
988 xfs_bmbt_irec_t imap;
991 /*
992 * Figure out if there are any blocks beyond the end
993 * of the file. If not, then there is nothing to do.
994 */
1010 /*
1011 * Attach the dquots to the inode up front.
1012 */
1016 /*
1017 * There are blocks after the end of file.
1018 * Free them up now by truncating the file to
1019 * its current size.
1020 */
1023 /*
1024 * Do the xfs_itruncate_start() call before
1025 * reserving any log space because
1026 * itruncate_start will call into the buffer
1027 * cache and we can't
1028 * do that within a transaction.
1029 */
1039 }
1044 XFS_ITRUNCATE_LOG_COUNT);
1050 }
1054 XFS_IOLOCK_EXCL |
1055 XFS_ILOCK_EXCL);
1060 XFS_DATA_FORK,
1062 /*
1063 * If we get an error at this point we
1064 * simply don't bother truncating the file.
1065 */
1069 XFS_TRANS_ABORT));
1072 XFS_TRANS_RELEASE_LOG_RES);
1073 }
1076 }
1078 }
1080 /*
1081 * Free a symlink that has blocks associated with it.
1082 */
1083 STATIC int
1087 {
1092 xfs_fsblock_t first_block;
1093 xfs_bmap_free_t free_list;
1105 /*
1106 * We're freeing a symlink that has some
1107 * blocks allocated to it. Free the
1108 * blocks here. We know that we've got
1109 * either 1 or 2 extents and that we can
1110 * free them all in one bunmapi call.
1111 */
1119 }
1120 /*
1121 * Lock the inode, fix the size, and join it to the transaction.
1122 * Hold it so in the normal path, we still have it locked for
1123 * the second transaction. In the error paths we need it
1124 * held so the cancel won't rele it, see below.
1125 */
1132 /*
1133 * Find the block(s) so we can inval and unmap them.
1134 */
1142 /*
1143 * Invalidate the block(s).
1144 */
1150 }
1151 /*
1152 * Unmap the dead block(s) to the free_list.
1153 */
1158 /*
1159 * Commit the first transaction. This logs the EFI and the inode.
1160 */
1163 /*
1164 * The transaction must have been committed, since there were
1165 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
1166 * The new tp has the extent freeing and EFDs.
1167 */
1169 /*
1170 * The first xact was committed, so add the inode to the new one.
1171 * Mark it dirty so it will be logged and moved forward in the log as
1172 * part of every commit.
1173 */
1177 /*
1178 * Get a new, empty transaction to return to our caller.
1179 */
1181 /*
1182 * Commit the transaction containing extent freeing and EFDs.
1183 * If we get an error on the commit here or on the reserve below,
1184 * we need to unlock the inode since the new transaction doesn't
1185 * have the inode attached.
1186 */
1192 }
1193 /*
1194 * Remove the memory for extent descriptions (just bookkeeping).
1195 */
1199 /*
1200 * Put an itruncate log reservation in the new transaction
1201 * for our caller.
1202 */
1207 }
1208 /*
1209 * Return with the inode locked but not joined to the transaction.
1210 */
1214 error1:
1216 error0:
1217 /*
1218 * Have to come here with the inode locked and either
1219 * (held and in the transaction) or (not in the transaction).
1220 * If the inode isn't held then cancel would iput it, but
1221 * that's wrong since this is inactive and the vnode ref
1222 * count is 0 already.
1223 * Cancel won't do anything to the inode if held, but it still
1224 * needs to be locked until the cancel is done, if it was
1225 * joined to the transaction.
1226 */
1232 }
1234 STATIC int
1238 {
1242 /*
1243 * We're freeing a symlink which fit into
1244 * the inode. Just free the memory used
1245 * to hold the old symlink.
1246 */
1250 XFS_ITRUNCATE_LOG_COUNT);
1256 }
1259 /*
1260 * Zero length symlinks _can_ exist.
1261 */
1265 XFS_DATA_FORK);
1267 }
1269 }
1271 STATIC int
1275 {
1297 XFS_INACTIVE_LOG_COUNT);
1311 error_cancel:
1314 error_unlock:
1318 }
1320 int
1323 {
1331 /* If this is a read-only mount, don't do this (would generate I/O) */
1338 /*
1339 * If we are using filestreams, and we have an unlinked
1340 * file that we are processing the last close on, then nothing
1341 * will be able to reopen and write to this file. Purge this
1342 * inode from the filestreams cache so that it doesn't delay
1343 * teardown of the inode.
1344 */
1348 /*
1349 * If we previously truncated this file and removed old data
1350 * in the process, we want to initiate "early" writeout on
1351 * the last close. This is an attempt to combat the notorious
1352 * NULL files problem which is particularly noticable from a
1353 * truncate down, buffered (re-)write (delalloc), followed by
1354 * a crash. What we are effectively doing here is
1355 * significantly reducing the time window where we'd otherwise
1356 * be exposed to that problem.
1357 */
1361 }
1373 }
1374 }
1377 }
1379 /*
1380 * xfs_inactive
1381 *
1382 * This is called when the vnode reference count for the vnode
1383 * goes to zero. If the file has been unlinked, then it must
1384 * now be truncated. Also, we clear all of the read-ahead state
1385 * kept for the inode here since the file is now closed.
1386 */
1387 int
1390 {
1392 xfs_bmap_free_t free_list;
1393 xfs_fsblock_t first_block;
1402 /*
1403 * If the inode is already free, then there can be nothing
1404 * to clean up here.
1405 */
1410 }
1412 /*
1413 * Only do a truncate if it's a regular file with
1414 * some actual space in it. It's OK to look at the
1415 * inode's fields without the lock because we're the
1416 * only one with a reference to the inode.
1417 */
1430 /* If this is a read-only mount, don't do this (would generate I/O) */
1445 }
1447 }
1456 /*
1457 * Do the xfs_itruncate_start() call before
1458 * reserving any log space because itruncate_start
1459 * will call into the buffer cache and we can't
1460 * do that within a transaction.
1461 */
1469 }
1474 XFS_ITRUNCATE_LOG_COUNT);
1476 /* Don't call itruncate_cleanup */
1481 }
1487 /*
1488 * normally, we have to run xfs_itruncate_finish sync.
1489 * But if filesystem is wsync and we're in the inactive
1490 * path, then we know that nlink == 0, and that the
1491 * xaction that made nlink == 0 is permanently committed
1492 * since xfs_remove runs as a synchronous transaction.
1493 */
1502 }
1505 /*
1506 * If we get an error while cleaning up a
1507 * symlink we bail out.
1508 */
1516 }
1524 XFS_INACTIVE_LOG_COUNT);
1529 }
1534 }
1536 /*
1537 * If there are attributes associated with the file
1538 * then blow them away now. The code calls a routine
1539 * that recursively deconstructs the attribute fork.
1540 * We need to just commit the current transaction
1541 * because we can't use it for xfs_attr_inactive().
1542 */
1545 /*
1546 * If we got an error, the transaction is already
1547 * cancelled, and the inode is unlocked. Just get out.
1548 */
1553 }
1555 /*
1556 * Free the inode.
1557 */
1561 /*
1562 * If we fail to free the inode, shut down. The cancel
1563 * might do that, we need to make sure. Otherwise the
1564 * inode might be lost for a long time or forever.
1565 */
1571 }
1574 /*
1575 * Credit the quota account(s). The inode is gone.
1576 */
1579 /*
1580 * Just ignore errors at this point. There is nothing we can
1581 * do except to try to keep going. Make sure it's not a silent
1582 * error.
1583 */
1592 }
1593 /*
1594 * Release the dquots held by inode, if any.
1595 */
1600 out:
1602 }
1605 int
1610 {
1611 xfs_ino_t inum;
1613 uint lock_mode;
1634 out:
1637 }
1639 int
1643 mode_t mode,
1644 xfs_dev_t rdev,
1647 {
1652 xfs_bmap_free_t free_list;
1653 xfs_fsblock_t first_block;
1656 uint cancel_flags;
1658 xfs_prid_t prid;
1660 uint resblks;
1674 }
1679 /* Return through std_return after this point. */
1684 else
1687 /*
1688 * Make sure that we have allocated dquot(s) on disk.
1689 */
1701 /*
1702 * Initially assume that the file does not exist and
1703 * reserve the resources for that case. If that is not
1704 * the case we'll drop the one we have and get a more
1705 * appropriate transaction later.
1706 */
1713 }
1717 }
1726 /*
1727 * Reserve disk quota and the inode.
1728 */
1743 }
1746 /*
1747 * At this point, we've gotten a newly allocated inode.
1748 * It is locked (and joined to the transaction).
1749 */
1753 /*
1754 * Now we join the directory inode to the transaction. We do not do it
1755 * earlier because xfs_dir_ialloc might commit the previous transaction
1756 * (and release all the locks). An error from here on will result in
1757 * the transaction cancel unlocking dp so don't do it explicitly in the
1758 * error path.
1759 */
1770 }
1774 /*
1775 * If this is a synchronous mount, make sure that the
1776 * create transaction goes to disk before returning to
1777 * the user.
1778 */
1781 }
1785 /*
1786 * Attach the dquot(s) to the inodes and modify them incore.
1787 * These ids of the inode couldn't have changed since the new
1788 * inode has been locked ever since it was created.
1789 */
1792 /*
1793 * xfs_trans_commit normally decrements the vnode ref count
1794 * when it unlocks the inode. Since we want to return the
1795 * vnode to the caller, we bump the vnode ref count now.
1796 */
1803 }
1810 }
1817 /* Fallthrough to std_return with error = 0 */
1819 std_return:
1827 }
1830 abort_return:
1832 /* FALLTHROUGH */
1834 error_return:
1846 abort_rele:
1847 /*
1848 * Wait until after the current transaction is aborted to
1849 * release the inode. This prevents recursive transactions
1850 * and deadlocks from xfs_inactive.
1851 */
1860 }
1862 #ifdef DEBUG
1863 /*
1864 * Some counters to see if (and how often) we are hitting some deadlock
1865 * prevention code paths.
1866 */
1871 #endif
1873 /*
1874 * The following routine will lock the inodes associated with the
1875 * directory and the named entry in the directory. The locks are
1876 * acquired in increasing inode number.
1877 *
1878 * If the entry is "..", then only the directory is locked. The
1879 * vnode ref count will still include that from the .. entry in
1880 * this case.
1881 *
1882 * There is a deadlock we need to worry about. If the locked directory is
1883 * in the AIL, it might be blocking up the log. The next inode we lock
1884 * could be already locked by another thread waiting for log space (e.g
1885 * a permanent log reservation with a long running transaction (see
1886 * xfs_itruncate_finish)). To solve this, we must check if the directory
1887 * is in the ail and use lock_nowait. If we can't lock, we need to
1888 * drop the inode lock on the directory and try again. xfs_iunlock will
1889 * potentially push the tail if we were holding up the log.
1890 */
1891 STATIC int
1895 {
1897 xfs_ino_t e_inum;
1901 #ifdef DEBUG
1902 xfs_rm_locks++;
1903 #endif
1906 again:
1913 /*
1914 * We want to lock in increasing inum. Since we've already
1915 * acquired the lock on the directory, we may need to release
1916 * if if the inum of the entry turns out to be less.
1917 */
1919 /*
1920 * We are already in the right order, so just
1921 * lock on the inode of the entry.
1922 * We need to use nowait if dp is in the AIL.
1923 */
1928 attempts++;
1929 #ifdef DEBUG
1930 xfs_rm_attempts++;
1931 #endif
1933 /*
1934 * Unlock dp and try again.
1935 * xfs_iunlock will try to push the tail
1936 * if the inode is in the AIL.
1937 */
1943 #ifdef DEBUG
1944 xfs_rm_lock_delays++;
1945 #endif
1946 }
1948 }
1951 }
1958 }
1959 /* else e_inum == dp->i_ino */
1960 /* This can happen if we're asked to lock /x/..
1961 * the entry is "..", which is also the parent directory.
1962 */
1965 }
1967 #ifdef DEBUG
1973 #endif
1975 /*
1976 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1977 * a different value
1978 */
1981 {
1988 }
1990 /*
1991 * The following routine will lock n inodes in exclusive mode.
1992 * We assume the caller calls us with the inodes in i_ino order.
1993 *
1994 * We need to detect deadlock where an inode that we lock
1995 * is in the AIL and we start waiting for another inode that is locked
1996 * by a thread in a long running transaction (such as truncate). This can
1997 * result in deadlock since the long running trans might need to wait
1998 * for the inode we just locked in order to push the tail and free space
1999 * in the log.
2000 */
2001 void
2005 uint lock_mode)
2006 {
2015 again:
2022 /*
2023 * If try_lock is not set yet, make sure all locked inodes
2024 * are not in the AIL.
2025 * If any are, set try_lock to be used later.
2026 */
2032 try_lock++;
2033 }
2034 }
2035 }
2037 /*
2038 * If any of the previous locks we have locked is in the AIL,
2039 * we must TRY to get the second and subsequent locks. If
2040 * we can't get any, we must release all we have
2041 * and try again.
2042 */
2045 /* try_lock must be 0 if i is 0. */
2046 /*
2047 * try_lock means we have an inode locked
2048 * that is in the AIL.
2049 */
2052 attempts++;
2054 /*
2055 * Unlock all previous guys and try again.
2056 * xfs_iunlock will try to push the tail
2057 * if the inode is in the AIL.
2058 */
2062 /*
2063 * Check to see if we've already
2064 * unlocked this one.
2065 * Not the first one going back,
2066 * and the inode ptr is the same.
2067 */
2073 }
2077 #ifdef DEBUG
2078 xfs_lock_delays++;
2079 #endif
2080 }
2084 }
2087 }
2088 }
2090 #ifdef DEBUG
2096 xfs_locked_n++;
2097 }
2098 #endif
2099 }
2101 #ifdef DEBUG
2102 #define REMOVE_DEBUG_TRACE(x) {remove_which_error_return = (x);}
2105 #define REMOVE_DEBUG_TRACE(x)
2108 int
2113 {
2117 xfs_bmap_free_t free_list;
2118 xfs_fsblock_t first_block;
2122 uint resblks;
2135 }
2146 }
2150 /*
2151 * We try to get the real space reservation first,
2152 * allowing for directory btree deletion(s) implying
2153 * possible bmap insert(s). If we can't get the space
2154 * reservation then we use 0 instead, and avoid the bmap
2155 * btree insert(s) in the directory code by, if the bmap
2156 * insert tries to happen, instead trimming the LAST
2157 * block from the directory.
2158 */
2166 }
2172 }
2179 }
2181 /*
2182 * At this point, we've gotten both the directory and the entry
2183 * inodes locked.
2184 */
2191 /*
2192 * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
2193 */
2201 }
2211 }
2213 /* Determine if this is the last link while
2214 * we are in the transaction.
2215 */
2218 /*
2219 * If this is a synchronous mount, make sure that the
2220 * remove transaction goes to disk before returning to
2221 * the user.
2222 */
2225 }
2231 }
2237 /*
2238 * If we are using filestreams, kill the stream association.
2239 * If the file is still open it may get a new one but that
2240 * will get killed on last close in xfs_close() so we don't
2241 * have to worry about that.
2242 */
2248 /* Fall through to std_return with error = 0 */
2249 std_return:
2255 }
2258 error1:
2264 error_rele:
2265 /*
2266 * In this case make sure to not release the inode until after
2267 * the current transaction is aborted. Releasing it beforehand
2268 * can cause us to go to xfs_inactive and start a recursive
2269 * transaction which can easily deadlock with the current one.
2270 */
2276 }
2278 int
2283 {
2288 xfs_bmap_free_t free_list;
2289 xfs_fsblock_t first_block;
2309 }
2311 /* Return through std_return after this point. */
2328 }
2332 }
2340 }
2344 /*
2345 * Increment vnode ref counts since xfs_trans_commit &
2346 * xfs_trans_cancel will both unlock the inodes and
2347 * decrement the associated ref counts.
2348 */
2354 /*
2355 * If the source has too many links, we can't make any more to it.
2356 */
2360 }
2362 /*
2363 * If we are using project inheritance, we only allow hard link
2364 * creation in our tree when the project IDs are the same; else
2365 * the tree quota mechanism could be circumvented.
2366 */
2371 }
2391 /*
2392 * If this is a synchronous mount, make sure that the
2393 * link transaction goes to disk before returning to
2394 * the user.
2395 */
2398 }
2404 }
2410 /* Fall through to std_return with error = 0. */
2411 std_return:
2417 }
2420 abort_return:
2422 /* FALLTHROUGH */
2424 error_return:
2427 }
2430 int
2434 mode_t mode,
2437 {
2444 xfs_bmap_free_t free_list;
2445 xfs_fsblock_t first_block;
2449 xfs_prid_t prid;
2451 uint resblks;
2466 }
2468 /* Return through std_return after this point. */
2476 else
2479 /*
2480 * Make sure that we have allocated dquot(s) on disk.
2481 */
2496 XFS_TRANS_PERM_LOG_RES,
2497 XFS_MKDIR_LOG_COUNT);
2498 }
2502 }
2507 /*
2508 * Check for directory link count overflow.
2509 */
2513 }
2515 /*
2516 * Reserve disk quota and the inode.
2517 */
2525 /*
2526 * create the directory inode.
2527 */
2535 }
2538 /*
2539 * Now we add the directory inode to the transaction.
2540 * We waited until now since xfs_dir_ialloc might start
2541 * a new transaction. Had we joined the transaction
2542 * earlier, the locks might have gotten released. An error
2543 * from here on will result in the transaction cancel
2544 * unlocking dp so don't do it explicitly in the error path.
2545 */
2558 }
2561 /*
2562 * Bump the in memory version number of the parent directory
2563 * so that other processes accessing it will recognize that
2564 * the directory has changed.
2565 */
2582 /*
2583 * Attach the dquots to the new inode and modify the icount incore.
2584 */
2587 /*
2588 * If this is a synchronous mount, make sure that the
2589 * mkdir transaction goes to disk before returning to
2590 * the user.
2591 */
2594 }
2600 }
2607 }
2609 /* Fall through to std_return with error = 0 or errno from
2610 * xfs_trans_commit. */
2612 std_return:
2618 DM_RIGHT_NULL,
2621 }
2624 error2:
2625 error1:
2627 abort_return:
2629 error_return:
2638 }
2640 int
2645 {
2649 xfs_bmap_free_t free_list;
2650 xfs_fsblock_t first_block;
2654 uint resblks;
2668 }
2670 /*
2671 * Get the dquots for the inodes.
2672 */
2679 }
2683 /*
2684 * We try to get the real space reservation first,
2685 * allowing for directory btree deletion(s) implying
2686 * possible bmap insert(s). If we can't get the space
2687 * reservation then we use 0 instead, and avoid the bmap
2688 * btree insert(s) in the directory code by, if the bmap
2689 * insert tries to happen, instead trimming the LAST
2690 * block from the directory.
2691 */
2699 }
2704 }
2707 /*
2708 * Now lock the child directory inode and the parent directory
2709 * inode in the proper order. This will take care of validating
2710 * that the directory entry for the child directory inode has
2711 * not changed while we were obtaining a log reservation.
2712 */
2717 }
2729 }
2733 }
2742 /*
2743 * Bump the in memory generation count on the parent
2744 * directory so that other can know that it has changed.
2745 */
2748 /*
2749 * Drop the link from cdp's "..".
2750 */
2754 }
2756 /*
2757 * Drop the link from dp to cdp.
2758 */
2762 }
2764 /*
2765 * Drop the "." link from cdp to self.
2766 */
2770 }
2772 /* Determine these before committing transaction */
2775 /*
2776 * If this is a synchronous mount, make sure that the
2777 * rmdir transaction goes to disk before returning to
2778 * the user.
2779 */
2782 }
2788 XFS_TRANS_ABORT));
2790 }
2795 }
2798 /* Fall through to std_return with error = 0 or the errno
2799 * from xfs_trans_commit. */
2800 std_return:
2807 }
2810 error1:
2813 /* FALLTHROUGH */
2815 error_return:
2818 }
2820 int
2825 mode_t mode,
2828 {
2834 xfs_bmap_free_t free_list;
2835 xfs_fsblock_t first_block;
2837 uint cancel_flags;
2839 xfs_fileoff_t first_fsb;
2840 xfs_filblks_t fs_blocks;
2843 xfs_daddr_t d;
2848 xfs_prid_t prid;
2850 uint resblks;
2862 /*
2863 * Check component lengths of the target path name.
2864 */
2875 }
2877 /* Return through std_return after this point. */
2882 else
2885 /*
2886 * Make sure that we have allocated dquot(s) on disk.
2887 */
2896 /*
2897 * The symlink will fit into the inode data fork?
2898 * There can't be any attributes so we get the whole variable part.
2899 */
2902 else
2911 }
2915 }
2920 /*
2921 * Check whether the directory allows new symlinks or not.
2922 */
2926 }
2928 /*
2929 * Reserve disk quota : blocks and inode.
2930 */
2935 /*
2936 * Check for ability to enter directory entry, if no space reserved.
2937 */
2941 /*
2942 * Initialize the bmap freelist prior to calling either
2943 * bmapi or the directory create code.
2944 */
2947 /*
2948 * Allocate an inode for the symlink.
2949 */
2956 }
2959 /*
2960 * An error after we've joined dp to the transaction will result in the
2961 * transaction cancel unlocking dp so don't do it explicitly in the
2962 * error path.
2963 */
2968 /*
2969 * Also attach the dquot(s) to it, if applicable.
2970 */
2975 /*
2976 * If the symlink will fit into the inode, write it inline.
2977 */
2983 /*
2984 * The inode was initially created in extent format.
2985 */
3002 }
3018 }
3025 }
3026 }
3028 /*
3029 * Create the directory entry for the symlink.
3030 */
3038 /*
3039 * Bump the in memory version number of the parent directory
3040 * so that other processes accessing it will recognize that
3041 * the directory has changed.
3042 */
3045 /*
3046 * If this is a synchronous mount, make sure that the
3047 * symlink transaction goes to disk before returning to
3048 * the user.
3049 */
3052 }
3054 /*
3055 * xfs_trans_commit normally decrements the vnode ref count
3056 * when it unlocks the inode. Since we want to return the
3057 * vnode to the caller, we bump the vnode ref count now.
3058 */
3064 }
3069 /* Fall through to std_return with error = 0 or errno from
3070 * xfs_trans_commit */
3071 std_return:
3078 }
3084 error2:
3086 error1:
3089 error_return:
3098 }
3100 int
3104 {
3111 /*
3112 * Bypass inodes which have already been cleaned by
3113 * the inode flush clustering code inside xfs_iflush
3114 */
3118 /*
3119 * We make this non-blocking if the inode is contended,
3120 * return EAGAIN to indicate to the caller that they
3121 * did not succeed. This prevents the flush path from
3122 * blocking on inodes inside another operation right
3123 * now, they get caught later by xfs_sync.
3124 */
3132 }
3135 }
3142 }
3145 int
3148 u_int evmask,
3149 u_int16_t state)
3150 {
3166 }
3178 }
3180 int
3183 {
3190 /* bad inode, get out here ASAP */
3194 }
3200 /*
3201 * Make sure the atime in the XFS inode is correct before freeing the
3202 * Linux inode.
3203 */
3206 /*
3207 * If we have nothing to flush with this inode then complete the
3208 * teardown now, otherwise break the link between the xfs inode and the
3209 * linux inode and clean up the xfs inode later. This avoids flushing
3210 * the inode to disk during the delete operation itself.
3211 *
3212 * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
3213 * first to ensure that xfs_iunpin() will never see an xfs inode
3214 * that has a linux inode being reclaimed. Synchronisation is provided
3215 * by the i_flags_lock.
3216 */
3224 /* Protect sync and unpin from us */
3233 }
3235 }
3237 int
3242 {
3250 /* The hash lock here protects a thread in xfs_iget_core from
3251 * racing with us on linking the inode back with a vnode.
3252 * Once we have the XFS_IRECLAIM flag set it will not touch
3253 * us.
3254 */
3264 }
3266 }
3272 /*
3273 * If the inode is still dirty, then flush it out. If the inode
3274 * is not in the AIL, then it will be OK to flush it delwri as
3275 * long as xfs_iflush() does not keep any references to the inode.
3276 * We leave that decision up to xfs_iflush() since it has the
3277 * knowledge of whether it's OK to simply do a delwri flush of
3278 * the inode or whether we need to wait until the inode is
3279 * pulled from the AIL.
3280 * We get the flush lock regardless, though, just to make sure
3281 * we don't free it while it is being flushed.
3282 */
3286 }
3293 /*
3294 * If we hit an error, typically because of filesystem
3295 * shutdown, we don't need to let vn_reclaim to know
3296 * because we're gonna reclaim the inode anyway.
3297 */
3301 }
3303 }
3308 }
3313 reclaim:
3316 }
3318 int
3320 {
3336 }
3337 }
3340 XFS_IFLUSH_DELWRI_ELSE_ASYNC))
3344 }
3347 }
3351 }
3353 /*
3354 * xfs_alloc_file_space()
3355 * This routine allocates disk space for the given file.
3356 *
3357 * If alloc_type == 0, this request is for an ALLOCSP type
3358 * request which will change the file size. In this case, no
3359 * DMAPI event will be generated by the call. A TRUNCATE event
3360 * will be generated later by xfs_setattr.
3361 *
3362 * If alloc_type != 0, this request is for a RESVSP type
3363 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
3364 * lower block boundary byte address is less than the file's
3365 * length.
3366 *
3367 * RETURNS:
3368 * 0 on success
3369 * errno on error
3370 *
3371 */
3372 STATIC int
3375 xfs_off_t offset,
3376 xfs_off_t len,
3379 {
3381 xfs_off_t count;
3382 xfs_filblks_t allocated_fsb;
3383 xfs_filblks_t allocatesize_fsb;
3385 xfs_fileoff_t startoffset_fsb;
3386 xfs_fsblock_t firstfsb;
3393 xfs_bmap_free_t free_list;
3419 /* Generate a DMAPI event if needed. */
3423 xfs_off_t end_dmi_offset;
3432 }
3434 /*
3435 * Allocate file space until done or until there is an error
3436 */
3437 retry:
3441 /*
3442 * Determine space reservations for data/realtime.
3443 */
3456 }
3468 }
3470 /*
3471 * Allocate and setup the transaction.
3472 */
3476 XFS_TRANS_PERM_LOG_RES,
3477 XFS_WRITE_LOG_COUNT);
3478 /*
3479 * Check for running out of space
3480 */
3482 /*
3483 * Free the transaction structure.
3484 */
3488 }
3498 /*
3499 * Issue the xfs_bmapi() call to allocate the blocks
3500 */
3508 }
3510 /*
3511 * Complete the transaction
3512 */
3516 }
3522 }
3529 }
3533 }
3534 dmapi_enospc_check:
3543 /* else fall through with error from XFS_SEND_DATA */
3544 }
3556 }
3558 /*
3559 * Zero file bytes between startoff and endoff inclusive.
3560 * The iolock is held exclusive and no blocks are buffered.
3561 */
3562 STATIC int
3565 xfs_off_t startoff,
3566 xfs_off_t endoff)
3567 {
3568 xfs_bmbt_irec_t imap;
3569 xfs_fileoff_t offset_fsb;
3570 xfs_off_t lastoffset;
3571 xfs_off_t offset;
3608 }
3621 }
3622 }
3625 }
3627 /*
3628 * xfs_free_file_space()
3629 * This routine frees disk space for the given file.
3630 *
3631 * This routine is only called by xfs_change_file_space
3632 * for an UNRESVSP type call.
3633 *
3634 * RETURNS:
3635 * 0 on success
3636 * errno on error
3637 *
3638 */
3639 STATIC int
3642 xfs_off_t offset,
3643 xfs_off_t len,
3645 {
3649 xfs_off_t end_dmi_offset;
3650 xfs_fileoff_t endoffset_fsb;
3652 xfs_fsblock_t firstfsb;
3653 xfs_bmap_free_t free_list;
3654 xfs_bmbt_irec_t imap;
3655 xfs_off_t ioffset;
3659 uint resblks;
3660 uint rounding;
3662 xfs_fileoff_t startoffset_fsb;
3691 }
3698 }
3708 }
3710 /*
3711 * Need to zero the stuff we're not freeing, on disk.
3712 * If its a realtime file & can't use unwritten extents then we
3713 * actually need to zero the extent edges. Otherwise xfs_bunmapi
3714 * will take care of it for us.
3715 */
3724 xfs_daddr_t block;
3731 }
3740 mod++;
3743 }
3744 }
3746 /*
3747 * One contiguous piece to clear
3748 */
3751 /*
3752 * Some full blocks, possibly two pieces to clear
3753 */
3762 }
3764 /*
3765 * free file space until done or until there is an error
3766 */
3770 /*
3771 * allocate and setup the transaction. Allow this
3772 * transaction to dip into the reserve blocks to ensure
3773 * the freeing of the space succeeds at ENOSPC.
3774 */
3778 resblks,
3781 XFS_TRANS_PERM_LOG_RES,
3782 XFS_WRITE_LOG_COUNT);
3784 /*
3785 * check for running out of space
3786 */
3788 /*
3789 * Free the transaction structure.
3790 */
3794 }
3798 XFS_QMOPT_RES_REGBLKS);
3805 /*
3806 * issue the bunmapi() call to free the blocks
3807 */
3814 }
3816 /*
3817 * complete the transaction
3818 */
3822 }
3826 }
3828 out_unlock_iolock:
3833 error0:
3835 error1:
3838 XFS_ILOCK_EXCL);
3840 }
3842 /*
3843 * xfs_change_file_space()
3844 * This routine allocates or frees disk space for the given file.
3845 * The user specified parameters are checked for alignment and size
3846 * limitations.
3847 *
3848 * RETURNS:
3849 * 0 on success
3850 * errno on error
3851 *
3852 */
3853 int
3858 xfs_off_t offset,
3861 {
3865 xfs_fsize_t fsize;
3867 xfs_off_t startoffset;
3868 xfs_off_t llen;
3870 bhv_vattr_t va;
3888 }
3903 /*
3904 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
3905 * file space.
3906 * These calls do NOT zero the data space allocated to the file,
3907 * nor do they change the file size.
3908 *
3909 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
3910 * space.
3911 * These calls cause the new file data to be zeroed and the file
3912 * size to be changed.
3913 */
3929 attr_flags)))
3942 }
3958 }
3960 /*
3961 * update the inode timestamp, mode, and prealloc flag bits
3962 */
3967 /* ASSERT(0); */
3970 }
3980 /*
3981 * Note that we don't have to worry about mandatory
3982 * file locking being disabled here because we only
3983 * clear the S_ISGID bit if the Group execute bit is
3984 * on, but if it was on then mandatory locking wouldn't
3985 * have been enabled.
3986 */
3991 }
4005 }