| blob | 00cd207d79af4d456e40a11388f18f596b052eda |
1 /*
2 * Copyright (c) 2007-2008 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * $DragonFly: src/sys/vfs/hammer/hammer_inode.c,v 1.114 2008/09/24 00:53:51 dillon Exp $
35 */
38 #include <vm/vm_extern.h>
45 #if 0
47 #endif
49 hammer_flush_group_t flg);
54 #ifdef DEBUG_TRUNCATE
56 #endif
58 /*
59 * RB-Tree support for inode structures
60 */
61 int
63 {
77 }
79 /*
80 * RB-Tree support for inode structures / special LOOKUP_INFO
81 */
82 static int
84 {
98 }
100 /*
101 * Used by hammer_scan_inode_snapshots() to locate all of an object's
102 * snapshots. Note that the asof field is not tested, which we can get
103 * away with because it is the lowest-priority field.
104 */
105 static int
107 {
119 }
121 /*
122 * Used by hammer_unload_pseudofs() to locate all inodes associated with
123 * a particular PFS.
124 */
125 static int
127 {
134 }
136 /*
137 * RB-Tree support for pseudofs structures
138 */
139 static int
141 {
147 }
156 /*
157 * The kernel is not actively referencing this vnode but is still holding
158 * it cached.
159 *
160 * This is called from the frontend.
161 *
162 * MPALMOSTSAFE
163 */
164 int
166 {
169 /*
170 * Degenerate case
171 */
175 }
177 /*
178 * If the inode no longer has visibility in the filesystem try to
179 * recycle it immediately, even if the inode is dirty. Recycling
180 * it quickly allows the system to reclaim buffer cache and VM
181 * resources which can matter a lot in a heavily loaded system.
182 *
183 * This can deadlock in vfsync() if we aren't careful.
184 *
185 * Do not queue the inode to the flusher if we still have visibility,
186 * otherwise namespace calls such as chmod will unnecessarily generate
187 * multiple inode updates.
188 */
196 }
198 }
200 /*
201 * Release the vnode association. This is typically (but not always)
202 * the last reference on the inode.
203 *
204 * Once the association is lost we are on our own with regards to
205 * flushing the inode.
206 */
207 int
209 {
211 hammer_mount_t hmp;
225 }
227 }
229 }
231 /*
232 * Return a locked vnode for the specified inode. The inode must be
233 * referenced but NOT LOCKED on entry and will remain referenced on
234 * return.
235 *
236 * Called from the frontend.
237 */
238 int
240 {
241 hammer_mount_t hmp;
244 u_int8_t obj_type;
260 }
284 }
286 /*
287 * Only mark as the root vnode if the ip is not
288 * historical, otherwise the VFS cache will get
289 * confused. The other half of the special handling
290 * is in hammer_vop_nlookupdotdot().
291 *
292 * Pseudo-filesystem roots can be accessed via
293 * non-root filesystem paths and setting VROOT may
294 * confuse the namecache. Set VPFSROOT instead.
295 */
300 else
302 }
305 /* vnode locked by getnewvnode() */
306 /* make related vnode dirty if inode dirty? */
311 }
313 /*
314 * loop if the vget fails (aka races), or if the vp
315 * no longer matches ip->vp.
316 */
321 }
322 }
325 }
327 /*
328 * Locate all copies of the inode for obj_id compatible with the specified
329 * asof, reference, and issue the related call-back. This routine is used
330 * for direct-io invalidation and does not create any new inodes.
331 */
332 void
336 {
338 hammer_inode_info_cmp_all_history,
340 }
342 /*
343 * Acquire a HAMMER inode. The returned inode is not locked. These functions
344 * do not attach or detach the related vnode (use hammer_get_vnode() for
345 * that).
346 *
347 * The flags argument is only applied for newly created inodes, and only
348 * certain flags are inherited.
349 *
350 * Called from the frontend.
351 */
356 {
364 /*
365 * Determine if we already have an inode cached. If we do then
366 * we are golden.
367 *
368 * If we find an inode with no vnode we have to mark the
369 * transaction such that hammer_inode_waitreclaims() is
370 * called later on to avoid building up an infinite number
371 * of inodes. Otherwise we can continue to * add new inodes
372 * faster then they can be disposed of, even with the tsleep
373 * delay.
374 *
375 * If we find a dummy inode we return a failure so dounlink
376 * (which does another lookup) doesn't try to mess with the
377 * link count. hammer_vop_nresolve() uses hammer_get_dummy_inode()
378 * to ref dummy inodes.
379 */
383 loop:
389 }
393 }
395 /*
396 * Allocate a new inode structure and deal with races later.
397 */
418 /*
419 * Locate the on-disk inode. If this is a PFS root we always
420 * access the current version of the root inode and (if it is not
421 * a master) always access information under it with a snapshot
422 * TID.
423 *
424 * We cache recent inode lookups in this directory in dip->cache[2].
425 * If we can't find it we assume the inode we are looking for is
426 * close to the directory inode.
427 */
428 retry:
433 else
435 }
447 HAMMER_CURSOR_ASOF;
453 }
455 /*
456 * On success the B-Tree lookup will hold the appropriate
457 * buffer cache buffers and provide a pointer to the requested
458 * information. Copy the information to the in-memory inode
459 * and cache the B-Tree node to improve future operations.
460 */
465 /*
466 * cache[0] tries to cache the location of the object inode.
467 * The assumption is that it is near the directory inode.
468 *
469 * cache[1] tries to cache the location of the object data.
470 * We might have something in the governing directory from
471 * scan optimizations (see the strategy code in
472 * hammer_vnops.c).
473 *
474 * We update dip->cache[2], if possible, with the location
475 * of the object inode for future directory shortcuts.
476 */
482 }
484 }
486 /*
487 * The file should not contain any data past the file size
488 * stored in the inode. Setting save_trunc_off to the
489 * file size instead of max reduces B-Tree lookup overheads
490 * on append by allowing the flusher to avoid checking for
491 * record overwrites.
492 */
495 /*
496 * Locate and assign the pseudofs management structure to
497 * the inode.
498 */
505 errorp);
507 }
508 }
510 /*
511 * The inode is placed on the red-black tree and will be synced to
512 * the media when flushed or by the filesystem sync. If this races
513 * another instantiation/lookup the insertion will fail.
514 */
520 }
526 }
530 }
534 }
536 /*
537 * Get a dummy inode to placemark a broken directory entry.
538 */
543 {
548 /*
549 * Determine if we already have an inode cached. If we do then
550 * we are golden.
551 *
552 * If we find an inode with no vnode we have to mark the
553 * transaction such that hammer_inode_waitreclaims() is
554 * called later on to avoid building up an infinite number
555 * of inodes. Otherwise we can continue to * add new inodes
556 * faster then they can be disposed of, even with the tsleep
557 * delay.
558 *
559 * If we find a non-fake inode we return an error. Only fake
560 * inodes can be returned by this routine.
561 */
565 loop:
572 }
575 }
577 /*
578 * Allocate a new inode structure and deal with races later.
579 */
598 /*
599 * Populate the dummy inode. Leave everything zero'd out.
600 *
601 * (ip->ino_leaf and ip->ino_data)
602 *
603 * Make the dummy inode a FIFO object which most copy programs
604 * will properly ignore.
605 */
609 /*
610 * Locate and assign the pseudofs management structure to
611 * the inode.
612 */
618 errorp);
620 }
622 /*
623 * The inode is placed on the red-black tree and will be synced to
624 * the media when flushed or by the filesystem sync. If this races
625 * another instantiation/lookup the insertion will fail.
626 *
627 * NOTE: Do not set HAMMER_INODE_ONDISK. The inode is a fake.
628 */
633 }
638 }
641 }
644 }
646 /*
647 * Return a referenced inode only if it is in our inode cache.
648 *
649 * Dummy inodes do not count.
650 */
654 {
667 else
669 }
671 }
673 /*
674 * Create a new filesystem object, returning the inode in *ipp. The
675 * returned inode will be referenced. The inode is created in-memory.
676 *
677 * If pfsm is non-NULL the caller wishes to create the root inode for
678 * a master PFS.
679 */
680 int
685 {
686 hammer_mount_t hmp;
687 hammer_inode_t ip;
688 uid_t xuid;
691 u_int32_t dummy;
709 }
723 /* ip->save_trunc_off = 0; (already zero) */
732 /*
733 * A nohistory designator on the parent directory is inherited by
734 * the child. We will do this even for pseudo-fs creation... the
735 * sysad can turn it off.
736 */
740 }
744 HAMMER_LOCALIZE_INODE;
757 /*
758 * If we are running version 2 or greater directory entries are
759 * inode-localized instead of data-localized.
760 */
764 HAMMER_INODE_CAP_DIR_LOCAL_INO;
765 }
766 }
768 /*
769 * Setup the ".." pointer. This only needs to be done for directories
770 * but we do it for all objects as a recovery aid.
771 */
774 #if 0
775 /*
776 * The parent_obj_localization field only applies to pseudo-fs roots.
777 * XXX this is no longer applicable, PFSs are no longer directly
778 * tied into the parent's directory structure.
779 */
784 }
785 #endif
795 }
797 /*
798 * Calculate default uid/gid and overwrite with information from
799 * the vap.
800 */
807 }
814 else
839 }
847 /* not reached */
849 }
852 }
854 /*
855 * Final cleanup / freeing of an inode structure
856 */
857 static void
859 {
876 }
879 }
881 /*
882 * Retrieve pseudo-fs data. NULL will never be returned.
883 *
884 * If an error occurs *errorp will be set and a default template is returned,
885 * otherwise *errorp is set to 0. Typically when an error occurs it will
886 * be ENOENT.
887 */
888 hammer_pseudofs_inmem_t
891 {
893 hammer_inode_t ip;
894 hammer_pseudofs_inmem_t pfsm;
898 retry:
904 }
906 /*
907 * PFS records are stored in the root inode (not the PFS root inode,
908 * but the real root). Avoid an infinite recursion if loading
909 * the PFS for the real root.
910 */
913 HAMMER_MAX_TID,
917 }
926 HAMMER_LOCALIZE_MISC;
938 else
944 HAMMER_PFSD_DELETED) {
951 }
952 }
953 }
963 }
965 }
967 /*
968 * Store pseudo-fs data. The backend will automatically delete any prior
969 * on-disk pseudo-fs data but we have to delete in-memory versions.
970 */
971 int
973 {
975 hammer_record_t record;
976 hammer_inode_t ip;
981 retry:
985 HAMMER_LOCALIZE_MISC;
995 /*
996 * Replace any in-memory version of the record.
997 */
1009 }
1010 }
1012 /*
1013 * Allocate replacement general record. The backend flush will
1014 * delete any on-disk version of the record.
1015 */
1021 HAMMER_LOCALIZE_MISC;
1027 }
1033 }
1035 /*
1036 * Create a root directory for a PFS if one does not alredy exist.
1037 *
1038 * The PFS root stands alone so we must also bump the nlinks count
1039 * to prevent it from being destroyed on release.
1040 */
1041 int
1043 hammer_pseudofs_inmem_t pfsm)
1044 {
1045 hammer_inode_t ip;
1061 }
1062 }
1066 }
1068 /*
1069 * Unload any vnodes & inodes associated with a PFS, return ENOTEMPTY
1070 * if we are unable to disassociate all the inodes.
1071 */
1072 static
1073 int
1075 {
1083 else
1087 }
1089 int
1091 {
1097 hammer_inode_pfs_cmp,
1098 hammer_unload_pseudofs_callback,
1103 }
1107 }
1110 /*
1111 * Release a reference on a PFS
1112 */
1113 void
1115 {
1120 }
1121 }
1123 /*
1124 * Called by hammer_sync_inode().
1125 */
1126 static int
1128 {
1130 hammer_record_t record;
1134 retry:
1137 /*
1138 * If the inode has a presence on-disk then locate it and mark
1139 * it deleted, setting DELONDISK.
1140 *
1141 * The record may or may not be physically deleted, depending on
1142 * the retention policy.
1143 */
1145 HAMMER_INODE_ONDISK) {
1148 HAMMER_LOCALIZE_INODE;
1170 }
1173 }
1182 }
1183 }
1185 /*
1186 * Ok, write out the initial record or a new record (after deleting
1187 * the old one), unless the DELETED flag is set. This routine will
1188 * clear DELONDISK if it writes out a record.
1189 *
1190 * Update our inode statistics if this is the first application of
1191 * the inode on-disk.
1192 */
1194 /*
1195 * Generate a record and write it to the media. We clean-up
1196 * the state before releasing so we do not have to set-up
1197 * a flush_group.
1198 */
1209 /*
1210 * If this flag is set we cannot sync the new file size
1211 * because we haven't finished related truncations. The
1212 * inode will be flushed in another flush group to finish
1213 * the job.
1214 */
1221 }
1237 }
1239 /*
1240 * Note: The record was never on the inode's record tree
1241 * so just wave our hands importantly and destroy it.
1242 */
1249 /*
1250 * Finish up.
1251 */
1256 HAMMER_INODE_ATIME |
1257 HAMMER_INODE_MTIME);
1262 /*
1263 * Root volume count of inodes
1264 */
1269 vol0_stat_inodes);
1275 }
1277 }
1278 }
1280 /*
1281 * If the inode has been destroyed, clean out any left-over flags
1282 * that may have been set by the frontend.
1283 */
1286 HAMMER_INODE_ATIME |
1287 HAMMER_INODE_MTIME);
1288 }
1290 }
1292 /*
1293 * Update only the itimes fields.
1294 *
1295 * ATIME can be updated without generating any UNDO. MTIME is updated
1296 * with UNDO so it is guaranteed to be synchronized properly in case of
1297 * a crash.
1298 *
1299 * Neither field is included in the B-Tree leaf element's CRC, which is how
1300 * we can get away with updating ATIME the way we do.
1301 */
1302 static int
1304 {
1308 retry:
1310 HAMMER_INODE_ONDISK) {
1312 }
1316 HAMMER_LOCALIZE_INODE;
1334 /*
1335 * Updating MTIME requires an UNDO. Just cover
1336 * both atime and mtime.
1337 */
1341 HAMMER_ITIMES_BYTES);
1347 /*
1348 * Updating atime only can be done in-place with
1349 * no UNDO.
1350 */
1357 }
1359 }
1366 }
1368 }
1370 /*
1371 * Release a reference on an inode, flush as requested.
1372 *
1373 * On the last reference we queue the inode to the flusher for its final
1374 * disposition.
1375 */
1376 void
1378 {
1379 /*hammer_mount_t hmp = ip->hmp;*/
1381 /*
1382 * Handle disposition when dropping the last ref.
1383 */
1386 /*
1387 * Determine whether on-disk action is needed for
1388 * the inode's final disposition.
1389 */
1397 }
1402 /*
1403 * The inode still has multiple refs, try to drop
1404 * one ref.
1405 */
1410 }
1411 }
1412 }
1413 }
1415 /*
1416 * Unload and destroy the specified inode. Must be called with one remaining
1417 * reference. The reference is disposed of.
1418 *
1419 * The inode must be completely clean.
1420 */
1421 static int
1423 {
1441 }
1443 /*
1444 * Called during unmounting if a critical error occured. The in-memory
1445 * inode and all related structures are destroyed.
1446 *
1447 * If a critical error did not occur the unmount code calls the standard
1448 * release and asserts that the inode is gone.
1449 */
1450 int
1452 {
1453 hammer_record_t rec;
1455 /*
1456 * Get rid of the inodes in-memory records, regardless of their
1457 * state, and clear the mod-mask.
1458 */
1464 }
1468 else
1477 }
1482 /*
1483 * Remove the inode from any flush group, force it idle. FLUSH
1484 * and SETUP states have an inode ref.
1485 */
1491 /* fall through */
1495 /* fall through */
1498 }
1500 /*
1501 * There shouldn't be any associated vnode. The unload needs at
1502 * least one ref, if we do have a vp steal its ip ref.
1503 */
1511 }
1514 }
1516 /*
1517 * Called on mount -u when switching from RW to RO or vise-versa. Adjust
1518 * the read-only flag for cached inodes.
1519 *
1520 * This routine is called from a RB_SCAN().
1521 */
1522 int
1524 {
1529 else
1532 }
1534 /*
1535 * A transaction has modified an inode, requiring updates as specified by
1536 * the passed flags.
1537 *
1538 * HAMMER_INODE_DDIRTY: Inode data has been updated
1539 * HAMMER_INODE_XDIRTY: Dirty in-memory records
1540 * HAMMER_INODE_BUFS: Dirty buffer cache buffers
1541 * HAMMER_INODE_DELETED: Inode record/data must be deleted
1542 * HAMMER_INODE_ATIME/MTIME: mtime/atime has been updated
1543 */
1544 void
1546 {
1547 /*
1548 * ronly of 0 or 2 does not trigger assertion.
1549 * 2 is a special error state
1550 */
1558 }
1561 }
1563 /*
1564 * Request that an inode be flushed. This whole mess cannot block and may
1565 * recurse (if not synchronous). Once requested HAMMER will attempt to
1566 * actively flush the inode until the flush can be done.
1567 *
1568 * The inode may already be flushing, or may be in a setup state. We can
1569 * place the inode in a flushing state if it is currently idle and flag it
1570 * to reflush if it is currently flushing.
1571 *
1572 * Upon return if the inode could not be flushed due to a setup
1573 * dependancy, then it will be automatically flushed when the dependancy
1574 * is satisfied.
1575 */
1576 void
1578 {
1579 hammer_mount_t hmp;
1580 hammer_flush_group_t flg;
1583 /*
1584 * next_flush_group is the first flush group we can place the inode
1585 * in. It may be NULL. If it becomes full we append a new flush
1586 * group and make that the next_flush_group.
1587 */
1595 }
1601 }
1603 /*
1604 * Trivial 'nothing to flush' case. If the inode is in a SETUP
1605 * state we have to put it back into an IDLE state so we can
1606 * drop the extra ref.
1607 *
1608 * If we have a parent dependancy we must still fall through
1609 * so we can run it.
1610 */
1616 }
1619 }
1621 /*
1622 * Our flush action will depend on the current state.
1623 */
1626 /*
1627 * We have no dependancies and can flush immediately. Some
1628 * our children may not be flushable so we have to re-test
1629 * with that additional knowledge.
1630 */
1634 /*
1635 * Recurse upwards through dependancies via target_list
1636 * and start their flusher actions going if possible.
1637 *
1638 * 'good' is our connectivity. -1 means we have none and
1639 * can't flush, 0 means there weren't any dependancies, and
1640 * 1 means we have good connectivity.
1641 */
1645 /*
1646 * We can continue if good >= 0. Determine how
1647 * many records under our inode can be flushed (and
1648 * mark them).
1649 */
1652 /*
1653 * Parent has no connectivity, tell it to flush
1654 * us as soon as it does.
1655 *
1656 * The REFLUSH flag is also needed to trigger
1657 * dependancy wakeups.
1658 */
1660 HAMMER_INODE_REFLUSH;
1664 }
1665 }
1668 /*
1669 * We are already flushing, flag the inode to reflush
1670 * if needed after it completes its current flush.
1671 *
1672 * The REFLUSH flag is also needed to trigger
1673 * dependancy wakeups.
1674 */
1680 }
1682 }
1683 }
1685 /*
1686 * Scan ip->target_list, which is a list of records owned by PARENTS to our
1687 * ip which reference our ip.
1688 *
1689 * XXX This is a huge mess of recursive code, but not one bit of it blocks
1690 * so for now do not ref/deref the structures. Note that if we use the
1691 * ref/rel code later, the rel CAN block.
1692 */
1693 static int
1695 hammer_flush_group_t flg)
1696 {
1697 hammer_record_t depend;
1701 /*
1702 * If we hit our recursion limit and we have parent dependencies
1703 * We cannot continue. Returning < 0 will cause us to be flagged
1704 * for reflush. Returning -2 cuts off additional dependency checks
1705 * because they are likely to also hit the depth limit.
1706 *
1707 * We cannot return < 0 if there are no dependencies or there might
1708 * not be anything to wakeup (ip).
1709 */
1715 }
1717 /*
1718 * Scan dependencies
1719 */
1729 /*
1730 * If we failed due to the recursion depth limit then stop
1731 * now.
1732 */
1735 }
1737 }
1739 /*
1740 * This helper function takes a record representing the dependancy between
1741 * the parent inode and child inode.
1742 *
1743 * record->ip = parent inode
1744 * record->target_ip = child inode
1745 *
1746 * We are asked to recurse upwards and convert the record from SETUP
1747 * to FLUSH if possible.
1748 *
1749 * Return 1 if the record gives us connectivity
1750 *
1751 * Return 0 if the record is not relevant
1752 *
1753 * Return -1 if we can't resolve the dependancy and there is no connectivity.
1754 */
1755 static int
1757 hammer_flush_group_t flg)
1758 {
1759 hammer_mount_t hmp;
1760 hammer_inode_t pip;
1767 /*
1768 * If the record is already flushing, is it in our flush group?
1769 *
1770 * If it is in our flush group but it is a general record or a
1771 * delete-on-disk, it does not improve our connectivity (return 0),
1772 * and if the target inode is not trying to destroy itself we can't
1773 * allow the operation yet anyway (the second return -1).
1774 */
1776 /*
1777 * If not in our flush group ask the parent to reflush
1778 * us as soon as possible.
1779 */
1784 }
1786 /*
1787 * If in our flush group everything is already set up,
1788 * just return whether the record will improve our
1789 * visibility or not.
1790 */
1794 }
1796 /*
1797 * It must be a setup record. Try to resolve the setup dependancies
1798 * by recursing upwards so we can place ip on the flush list.
1799 *
1800 * Limit ourselves to 20 levels of recursion to avoid blowing out
1801 * the kernel stack. If we hit the recursion limit we can't flush
1802 * until the parent flushes. The parent will flush independantly
1803 * on its own and ultimately a deep recursion will be resolved.
1804 */
1809 /*
1810 * If good < 0 the parent has no connectivity and we cannot safely
1811 * flush the directory entry, which also means we can't flush our
1812 * ip. Flag us for downward recursion once the parent's
1813 * connectivity is resolved. Flag the parent for [re]flush or it
1814 * may not check for downward recursions.
1815 */
1820 }
1822 /*
1823 * We are go, place the parent inode in a flushing state so we can
1824 * place its record in a flushing state. Note that the parent
1825 * may already be flushing. The record must be in the same flush
1826 * group as the parent.
1827 */
1833 #if 0
1836 /*
1837 * Regardless of flushing state we cannot sync this path if the
1838 * record represents a delete-on-disk but the target inode
1839 * is not ready to sync its own deletion.
1840 *
1841 * XXX need to count effective nlinks to determine whether
1842 * the flush is ok, otherwise removing a hardlink will
1843 * just leave the DEL record to rot.
1844 */
1848 #endif
1850 /*
1851 * Because we have not calculated nlinks yet we can just
1852 * set records to the flush state if the parent is in
1853 * the same flush group as we are.
1854 */
1860 /*
1861 * A general directory-add contributes to our visibility.
1862 *
1863 * Otherwise it is probably a directory-delete or
1864 * delete-on-disk record and does not contribute to our
1865 * visbility (but we can still flush it).
1866 */
1871 /*
1872 * If the parent is not in our flush group we cannot
1873 * flush this record yet, there is no visibility.
1874 * We tell the parent to reflush and mark ourselves
1875 * so the parent knows it should flush us too.
1876 */
1880 }
1881 }
1883 /*
1884 * This is the core routine placing an inode into the FST_FLUSH state.
1885 */
1886 static void
1888 {
1891 /*
1892 * Set flush state and prevent the flusher from cycling into
1893 * the next flush group. Do not place the ip on the list yet.
1894 * Inodes not in the idle state get an extra reference.
1895 */
1906 /*
1907 * If the flush group reaches the autoflush limit we want to signal
1908 * the flusher. This is particularly important for remove()s.
1909 */
1913 /*
1914 * We need to be able to vfsync/truncate from the backend.
1915 */
1920 }
1922 /*
1923 * Figure out how many in-memory records we can actually flush
1924 * (not including inode meta-data, buffers, etc).
1925 */
1928 /*
1929 * If this is a upwards recursion we do not want to
1930 * recurse down again!
1931 */
1933 #if 0
1935 /*
1936 * No new records are added if we must complete a flush
1937 * from a previous cycle, but we do have to move the records
1938 * from the previous cycle to the current one.
1939 */
1940 #if 0
1943 #endif
1945 #endif
1947 /*
1948 * Normal flush, scan records and bring them into the flush.
1949 * Directory adds and deletes are usually skipped (they are
1950 * grouped with the related inode rather then with the
1951 * directory).
1952 *
1953 * go_count can be negative, which means the scan aborted
1954 * due to the flush group being over-full and we should
1955 * flush what we have.
1956 */
1959 }
1961 /*
1962 * This is a more involved test that includes go_count. If we
1963 * can't flush, flag the inode and return. If go_count is 0 we
1964 * were are unable to flush any records in our rec_tree and
1965 * must ignore the XDIRTY flag.
1966 */
1978 }
1980 /*
1981 * REFLUSH is needed to trigger dependancy wakeups
1982 * when an inode is in SETUP.
1983 */
1988 }
1992 }
1993 }
1995 /*
1996 * Snapshot the state of the inode for the backend flusher.
1997 *
1998 * We continue to retain save_trunc_off even when all truncations
1999 * have been resolved as an optimization to determine if we can
2000 * skip the B-Tree lookup for overwrite deletions.
2001 *
2002 * NOTE: The DELETING flag is a mod flag, but it is also sticky,
2003 * and stays in ip->flags. Once set, it stays set until the
2004 * inode is destroyed.
2005 */
2013 /*
2014 * The save_trunc_off used to cache whether the B-Tree
2015 * holds any records past that point is not used until
2016 * after the truncation has succeeded, so we can safely
2017 * set it now.
2018 */
2021 }
2027 #ifdef DEBUG_TRUNCATE
2030 #endif
2032 /*
2033 * The flusher list inherits our inode and reference.
2034 */
2042 }
2043 }
2045 /*
2046 * Callback for scan of ip->rec_tree. Try to include each record in our
2047 * flush. ip->flush_group has been set but the inode has not yet been
2048 * moved into a flushing state.
2049 *
2050 * If we get stuck on a record we have to set HAMMER_INODE_REFLUSH on
2051 * both inodes.
2052 *
2053 * We return 1 for any record placed or found in FST_FLUSH, which prevents
2054 * the caller from shortcutting the flush.
2055 */
2056 static int
2058 {
2059 hammer_flush_group_t flg;
2060 hammer_inode_t target_ip;
2061 hammer_inode_t ip;
2064 /*
2065 * Records deleted or committed by the backend are ignored.
2066 * Note that the flush detects deleted frontend records at
2067 * multiple points to deal with races. This is just the first
2068 * line of defense. The only time HAMMER_RECF_DELETED_FE cannot
2069 * be set is when HAMMER_RECF_INTERLOCK_BE is set, because it
2070 * messes up link-count calculations.
2071 *
2072 * NOTE: Don't get confused between record deletion and, say,
2073 * directory entry deletion. The deletion of a directory entry
2074 * which is on-media has nothing to do with the record deletion
2075 * flags.
2076 */
2078 HAMMER_RECF_COMMITTED)) {
2084 }
2086 }
2088 /*
2089 * If the record is in an idle state it has no dependancies and
2090 * can be flushed.
2091 */
2098 /*
2099 * The record has no setup dependancy, we can flush it.
2100 */
2109 /*
2110 * The record has a setup dependancy. These are typically
2111 * directory entry adds and deletes. Such entries will be
2112 * flushed when their inodes are flushed so we do not
2113 * usually have to add them to the flush here. However,
2114 * if the target_ip has set HAMMER_INODE_CONN_DOWN then
2115 * it is asking us to flush this record (and it).
2116 */
2121 /*
2122 * If the target IP is already flushing in our group
2123 * we could associate the record, but target_ip has
2124 * already synced ino_data to sync_ino_data and we
2125 * would also have to adjust nlinks. Plus there are
2126 * ordering issues for adds and deletes.
2127 *
2128 * Reflush downward if this is an ADD, and upward if
2129 * this is a DEL.
2130 */
2134 else
2137 }
2139 /*
2140 * Target IP is not yet flushing. This can get complex
2141 * because we have to be careful about the recursion.
2142 *
2143 * Directories create an issue for us in that if a flush
2144 * of a directory is requested the expectation is to flush
2145 * any pending directory entries, but this will cause the
2146 * related inodes to recursively flush as well. We can't
2147 * really defer the operation so just get as many as we
2148 * can and
2149 */
2150 #if 0
2153 /*
2154 * We aren't reclaiming and the target ip was not
2155 * previously prevented from flushing due to this
2156 * record dependancy. Do not flush this record.
2157 */
2158 /*r = 0;*/
2160 #endif
2163 /*
2164 * Our flush group is over-full and we risk blowing
2165 * out the UNDO FIFO. Stop the scan, flush what we
2166 * have, then reflush the directory.
2167 *
2168 * The directory may be forced through multiple
2169 * flush groups before it can be completely
2170 * flushed.
2171 */
2173 HAMMER_INODE_REFLUSH;
2176 /*
2177 * If the target IP is not flushing we can force
2178 * it to flush, even if it is unable to write out
2179 * any of its own records we have at least one in
2180 * hand that we CAN deal with.
2181 */
2187 HAMMER_FLUSH_RECURSION);
2190 /*
2191 * General or delete-on-disk record.
2192 *
2193 * XXX this needs help. If a delete-on-disk we could
2194 * disconnect the target. If the target has its own
2195 * dependancies they really need to be flushed.
2196 *
2197 * XXX
2198 */
2204 HAMMER_FLUSH_RECURSION);
2206 }
2209 /*
2210 * The flush_group should already match.
2211 */
2215 }
2217 }
2219 #if 0
2220 /*
2221 * This version just moves records already in a flush state to the new
2222 * flush group and that is it.
2223 */
2224 static int
2226 {
2235 }
2237 }
2238 #endif
2240 /*
2241 * Wait for a previously queued flush to complete.
2242 *
2243 * If a critical error occured we don't try to wait.
2244 */
2245 void
2247 {
2248 hammer_flush_group_t flg;
2259 }
2260 }
2261 }
2262 }
2264 /*
2265 * Called by the backend code when a flush has been completed.
2266 * The inode has already been removed from the flush list.
2267 *
2268 * A pipelined flush can occur, in which case we must re-enter the
2269 * inode on the list and re-copy its fields.
2270 */
2271 void
2273 {
2274 hammer_mount_t hmp;
2281 /*
2282 * Auto-reflush if the backend could not completely flush
2283 * the inode. This fixes a case where a deferred buffer flush
2284 * could cause fsync to return early.
2285 */
2289 /*
2290 * Merge left-over flags back into the frontend and fix the state.
2291 * Incomplete truncations are retained by the backend.
2292 */
2297 /*
2298 * The backend may have adjusted nlinks, so if the adjusted nlinks
2299 * does not match the fronttend set the frontend's RDIRTY flag again.
2300 */
2304 /*
2305 * Fix up the dirty buffer status.
2306 */
2309 }
2311 /*
2312 * Re-set the XDIRTY flag if some of the inode's in-memory records
2313 * could not be flushed.
2314 */
2320 /*
2321 * Do not lose track of inodes which no longer have vnode
2322 * assocations, otherwise they may never get flushed again.
2323 *
2324 * The reflush flag can be set superfluously, causing extra pain
2325 * for no reason. If the inode is no longer modified it no longer
2326 * needs to be flushed.
2327 */
2333 }
2335 /*
2336 * Adjust the flush state.
2337 */
2339 /*
2340 * We were unable to flush out all our records, leave the
2341 * inode in a flush state and in the current flush group.
2342 * The flush group will be re-run.
2343 *
2344 * This occurs if the UNDO block gets too full or there is
2345 * too much dirty meta-data and allows the flusher to
2346 * finalize the UNDO block and then re-flush.
2347 */
2351 /*
2352 * Remove from the flush_group
2353 */
2357 /*
2358 * Clean up the vnode ref and tracking counts.
2359 */
2363 }
2367 /*
2368 * And adjust the state.
2369 */
2376 }
2378 /*
2379 * If the frontend is waiting for a flush to complete,
2380 * wake it up.
2381 */
2385 }
2387 /*
2388 * If the frontend made more changes and requested another
2389 * flush, then try to get it running.
2390 *
2391 * Reflushes are aborted when the inode is errored out.
2392 */
2400 }
2401 }
2402 }
2404 /*
2405 * If we have no parent dependancies we can clear CONN_DOWN
2406 */
2410 /*
2411 * If the inode is now clean drop the space reservation.
2412 */
2417 }
2421 }
2423 /*
2424 * Called from hammer_sync_inode() to synchronize in-memory records
2425 * to the media.
2426 */
2427 static int
2429 {
2435 /*
2436 * Skip records that do not belong to the current flush.
2437 */
2442 #if 1
2444 kprintf("sync_record %p ip %p bad flush group %p %p\n", record, record->ip, record->flush_group ,record->ip->flush_group);
2448 }
2449 #endif
2452 /*
2453 * Interlock the record using the BE flag. Once BE is set the
2454 * frontend cannot change the state of FE.
2455 *
2456 * NOTE: If FE is set prior to us setting BE we still sync the
2457 * record out, but the flush completion code converts it to
2458 * a delete-on-disk record instead of destroying it.
2459 */
2463 /*
2464 * The backend has already disposed of the record.
2465 */
2469 }
2471 /*
2472 * If the whole inode is being deleting all on-disk records will
2473 * be deleted very soon, we can't sync any new records to disk
2474 * because they will be deleted in the same transaction they were
2475 * created in (delete_tid == create_tid), which will assert.
2476 *
2477 * XXX There may be a case with RECORD_ADD with DELETED_FE set
2478 * that we currently panic on.
2479 */
2483 /*
2484 * We don't have to do anything, if the record was
2485 * committed the space will have been accounted for
2486 * in the blockmap.
2487 */
2488 /* fall through */
2490 /*
2491 * Set deleted-by-backend flag. Do not set the
2492 * backend committed flag, because we are throwing
2493 * the record away.
2494 */
2508 /*
2509 * Follow through and issue the on-disk deletion
2510 */
2512 }
2513 }
2515 /*
2516 * If DELETED_FE is set special handling is needed for directory
2517 * entries. Dependant pieces related to the directory entry may
2518 * have already been synced to disk. If this occurs we have to
2519 * sync the directory entry and then change the in-memory record
2520 * from an ADD to a DELETE to cover the fact that it's been
2521 * deleted by the frontend.
2522 *
2523 * A directory delete covering record (MEM_RECORD_DEL) can never
2524 * be deleted by the frontend.
2525 *
2526 * Any other record type (aka DATA) can be deleted by the frontend.
2527 * XXX At the moment the flusher must skip it because there may
2528 * be another data record in the flush group for the same block,
2529 * meaning that some frontend data changes can leak into the backend's
2530 * synchronization point.
2531 */
2534 /*
2535 * Convert a front-end deleted directory-add to
2536 * a directory-delete entry later.
2537 */
2540 /*
2541 * Dispose of the record (race case). Mark as
2542 * deleted by backend (and not committed).
2543 */
2549 }
2550 }
2552 /*
2553 * Assign the create_tid for new records. Deletions already
2554 * have the record's entire key properly set up.
2555 */
2559 }
2569 }
2574 done:
2577 /*
2578 * Do partial finalization if we have built up too many dirty
2579 * buffers. Otherwise a buffer cache deadlock can occur when
2580 * doing things like creating tens of thousands of tiny files.
2581 *
2582 * We must release our cursor lock to avoid a 3-way deadlock
2583 * due to the exclusive sync lock the finalizer must get.
2584 *
2585 * WARNING: See warnings in hammer_unlock_cursor() function.
2586 */
2591 }
2594 }
2596 /*
2597 * Backend function called by the flusher to sync an inode to media.
2598 */
2599 int
2601 {
2603 hammer_node_t tmp_node;
2604 hammer_record_t depend;
2605 hammer_record_t next;
2607 u_int64_t nlinks;
2616 /*
2617 * Any directory records referencing this inode which are not in
2618 * our current flush group must adjust our nlink count for the
2619 * purposes of synchronization to disk.
2620 *
2621 * Records which are in our flush group can be unlinked from our
2622 * inode now, potentially allowing the inode to be physically
2623 * deleted.
2624 *
2625 * This cannot block.
2626 */
2633 /*
2634 * If this is an ADD that was deleted by the frontend
2635 * the frontend nlinks count will have already been
2636 * decremented, but the backend is going to sync its
2637 * directory entry and must account for it. The
2638 * record will be converted to a delete-on-disk when
2639 * it gets synced.
2640 *
2641 * If the ADD was not deleted by the frontend we
2642 * can remove the dependancy from our target_list.
2643 */
2648 target_entry);
2650 }
2652 /*
2653 * Not part of our flush group and not deleted by
2654 * the front-end, adjust the link count synced to
2655 * the media (undo what the frontend did when it
2656 * queued the record).
2657 */
2668 }
2669 }
2670 }
2672 /*
2673 * Set dirty if we had to modify the link count.
2674 */
2679 }
2681 /*
2682 * If there is a trunction queued destroy any data past the (aligned)
2683 * truncation point. Userland will have dealt with the buffer
2684 * containing the truncation point for us.
2685 *
2686 * We don't flush pending frontend data buffers until after we've
2687 * dealt with the truncation.
2688 */
2690 /*
2691 * Interlock trunc_off. The VOP front-end may continue to
2692 * make adjustments to it while we are blocked.
2693 */
2694 off_t trunc_off;
2695 off_t aligned_trunc_off;
2702 /*
2703 * Delete any whole blocks on-media. The front-end has
2704 * already cleaned out any partial block and made it
2705 * pending. The front-end may have updated trunc_off
2706 * while we were blocked so we only use sync_trunc_off.
2707 *
2708 * This operation can blow out the buffer cache, EWOULDBLOCK
2709 * means we were unable to complete the deletion. The
2710 * deletion will update sync_trunc_off in that case.
2711 */
2713 aligned_trunc_off,
2719 }
2724 /*
2725 * Clear the truncation flag on the backend after we have
2726 * complete the deletions. Backend data is now good again
2727 * (including new records we are about to sync, below).
2728 *
2729 * Leave sync_trunc_off intact. As we write additional
2730 * records the backend will update sync_trunc_off. This
2731 * tells the backend whether it can skip the overwrite
2732 * test. This should work properly even when the backend
2733 * writes full blocks where the truncation point straddles
2734 * the block because the comparison is against the base
2735 * offset of the record.
2736 */
2738 /* ip->sync_trunc_off = 0x7FFFFFFFFFFFFFFFLL; */
2741 }
2743 /*
2744 * Now sync related records. These will typically be directory
2745 * entries, records tracking direct-writes, or delete-on-disk records.
2746 */
2754 }
2757 /*
2758 * Re-seek for inode update, assuming our cache hasn't been ripped
2759 * out from under us.
2760 */
2770 }
2772 }
2774 /*
2775 * If we are deleting the inode the frontend had better not have
2776 * any active references on elements making up the inode.
2777 *
2778 * The call to hammer_ip_delete_clean() cleans up auxillary records
2779 * but not DB or DATA records. Those must have already been deleted
2780 * by the normal truncation mechanic.
2781 */
2795 /*
2796 * Set delete_tid in both the frontend and backend
2797 * copy of the inode record. The DELETED flag handles
2798 * this, do not set RDIRTY.
2799 */
2806 /*
2807 * Adjust the inode count in the volume header
2808 */
2813 vol0_stat_inodes);
2816 }
2818 }
2819 }
2825 defer_buffer_flush:
2826 /*
2827 * Now update the inode's on-disk inode-data and/or on-disk record.
2828 * DELETED and ONDISK are managed only in ip->flags.
2829 *
2830 * In the case of a defered buffer flush we still update the on-disk
2831 * inode to satisfy visibility requirements if there happen to be
2832 * directory dependancies.
2833 */
2836 /*
2837 * If deleted and on-disk, don't set any additional flags.
2838 * the delete flag takes care of things.
2839 *
2840 * Clear flags which may have been set by the frontend.
2841 */
2844 HAMMER_INODE_DELETING);
2847 /*
2848 * Take care of the case where a deleted inode was never
2849 * flushed to the disk in the first place.
2850 *
2851 * Clear flags which may have been set by the frontend.
2852 */
2855 HAMMER_INODE_DELETING);
2863 }
2866 /*
2867 * If already on-disk, do not set any additional flags.
2868 */
2871 /*
2872 * If not on-disk and not deleted, set DDIRTY to force
2873 * an initial record to be written.
2874 *
2875 * Also set the create_tid in both the frontend and backend
2876 * copy of the inode record.
2877 */
2884 }
2886 /*
2887 * If RDIRTY or DDIRTY is set, write out a new record. If the inode
2888 * is already on-disk the old record is marked as deleted.
2889 *
2890 * If DELETED is set hammer_update_inode() will delete the existing
2891 * record without writing out a new one.
2892 *
2893 * If *ONLY* the ITIMES flag is set we can update the record in-place.
2894 */
2904 }
2905 done:
2909 }
2912 }
2914 /*
2915 * This routine is called when the OS is no longer actively referencing
2916 * the inode (but might still be keeping it cached), or when releasing
2917 * the last reference to an inode.
2918 *
2919 * At this point if the inode's nlinks count is zero we want to destroy
2920 * it, which may mean destroying it on-media too.
2921 */
2922 void
2924 {
2927 /*
2928 * Set the DELETING flag when the link count drops to 0 and the
2929 * OS no longer has any opens on the inode.
2930 *
2931 * The backend will clear DELETING (a mod flag) and set DELETED
2932 * (a state flag) when it is actually able to perform the
2933 * operation.
2934 *
2935 * Don't reflag the deletion if the flusher is currently syncing
2936 * one that was already flagged. A previously set DELETING flag
2937 * may bounce around flags and sync_flags until the operation is
2938 * completely done.
2939 */
2949 }
2951 /*
2952 * Final cleanup
2953 */
2957 }
2960 }
2961 }
2962 }
2964 /*
2965 * After potentially resolving a dependancy the inode is tested
2966 * to determine whether it needs to be reflushed.
2967 */
2968 void
2970 {
2979 }
2981 }
2982 }
2984 /*
2985 * Clear the RECLAIM flag on an inode. This occurs when the inode is
2986 * reassociated with a vp or just before it gets freed.
2987 *
2988 * Pipeline wakeups to threads blocked due to an excessive number of
2989 * detached inodes. This typically occurs when atime updates accumulate
2990 * while scanning a directory tree.
2991 */
2992 static void
2994 {
3009 }
3012 }
3013 }
3015 /*
3016 * Setup our reclaim pipeline. We only let so many detached (and dirty)
3017 * inodes build up before we start blocking. This routine is called
3018 * if a new inode is created or an inode is loaded from media.
3019 *
3020 * When we block we don't care *which* inode has finished reclaiming,
3021 * as lone as one does.
3022 */
3023 void
3025 {
3035 }
3037 #if 0
3039 /*
3040 * XXX not used, doesn't work very well due to the large batching nature
3041 * of flushes.
3042 *
3043 * A larger then normal backlog of inodes is sitting in the flusher,
3044 * enforce a general slowdown to let it catch up. This routine is only
3045 * called on completion of a non-flusher-related transaction which
3046 * performed B-Tree node I/O.
3047 *
3048 * It is possible for the flusher to stall in a continuous load.
3049 * blogbench -i1000 -o seems to do a good job generating this sort of load.
3050 * If the flusher is unable to catch up the inode count can bloat until
3051 * we run out of kvm.
3052 *
3053 * This is a bit of a hack.
3054 */
3055 void
3057 {
3058 /*
3059 * Hysteresis.
3060 */
3066 }
3071 }
3073 }
3075 /*
3076 * Block for one flush cycle.
3077 */
3079 }
3081 #endif