| blob | bdd30b18cc25554ad878d6dd3aeb3aee4d951aa6 |
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>
39 #include <sys/buf.h>
40 #include <sys/buf2.h>
47 #if 0
49 #endif
51 hammer_flush_group_t flg);
56 #ifdef DEBUG_TRUNCATE
58 #endif
60 /*
61 * RB-Tree support for inode structures
62 */
63 int
65 {
79 }
81 /*
82 * RB-Tree support for inode structures / special LOOKUP_INFO
83 */
84 static int
86 {
100 }
102 /*
103 * Used by hammer_scan_inode_snapshots() to locate all of an object's
104 * snapshots. Note that the asof field is not tested, which we can get
105 * away with because it is the lowest-priority field.
106 */
107 static int
109 {
121 }
123 /*
124 * Used by hammer_unload_pseudofs() to locate all inodes associated with
125 * a particular PFS.
126 */
127 static int
129 {
136 }
138 /*
139 * RB-Tree support for pseudofs structures
140 */
141 static int
143 {
149 }
158 /*
159 * The kernel is not actively referencing this vnode but is still holding
160 * it cached.
161 *
162 * This is called from the frontend.
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 */
194 }
196 }
198 /*
199 * Release the vnode association. This is typically (but not always)
200 * the last reference on the inode.
201 *
202 * Once the association is lost we are on our own with regards to
203 * flushing the inode.
204 */
205 int
207 {
209 hammer_mount_t hmp;
223 }
225 }
227 }
229 /*
230 * Return a locked vnode for the specified inode. The inode must be
231 * referenced but NOT LOCKED on entry and will remain referenced on
232 * return.
233 *
234 * Called from the frontend.
235 */
236 int
238 {
239 hammer_mount_t hmp;
242 u_int8_t obj_type;
258 }
280 }
282 /*
283 * Only mark as the root vnode if the ip is not
284 * historical, otherwise the VFS cache will get
285 * confused. The other half of the special handling
286 * is in hammer_vop_nlookupdotdot().
287 *
288 * Pseudo-filesystem roots can be accessed via
289 * non-root filesystem paths and setting VROOT may
290 * confuse the namecache. Set VPFSROOT instead.
291 */
296 else
298 }
301 /* vnode locked by getnewvnode() */
302 /* make related vnode dirty if inode dirty? */
307 }
309 /*
310 * loop if the vget fails (aka races), or if the vp
311 * no longer matches ip->vp.
312 */
317 }
318 }
321 }
323 /*
324 * Locate all copies of the inode for obj_id compatible with the specified
325 * asof, reference, and issue the related call-back. This routine is used
326 * for direct-io invalidation and does not create any new inodes.
327 */
328 void
332 {
334 hammer_inode_info_cmp_all_history,
336 }
338 /*
339 * Acquire a HAMMER inode. The returned inode is not locked. These functions
340 * do not attach or detach the related vnode (use hammer_get_vnode() for
341 * that).
342 *
343 * The flags argument is only applied for newly created inodes, and only
344 * certain flags are inherited.
345 *
346 * Called from the frontend.
347 */
352 {
360 /*
361 * Determine if we already have an inode cached. If we do then
362 * we are golden.
363 *
364 * If we find an inode with no vnode we have to mark the
365 * transaction such that hammer_inode_waitreclaims() is
366 * called later on to avoid building up an infinite number
367 * of inodes. Otherwise we can continue to * add new inodes
368 * faster then they can be disposed of, even with the tsleep
369 * delay.
370 *
371 * If we find a dummy inode we return a failure so dounlink
372 * (which does another lookup) doesn't try to mess with the
373 * link count. hammer_vop_nresolve() uses hammer_get_dummy_inode()
374 * to ref dummy inodes.
375 */
379 loop:
385 }
389 }
391 /*
392 * Allocate a new inode structure and deal with races later.
393 */
414 /*
415 * Locate the on-disk inode. If this is a PFS root we always
416 * access the current version of the root inode and (if it is not
417 * a master) always access information under it with a snapshot
418 * TID.
419 *
420 * We cache recent inode lookups in this directory in dip->cache[2].
421 * If we can't find it we assume the inode we are looking for is
422 * close to the directory inode.
423 */
424 retry:
429 else
431 }
443 HAMMER_CURSOR_ASOF;
449 }
451 /*
452 * On success the B-Tree lookup will hold the appropriate
453 * buffer cache buffers and provide a pointer to the requested
454 * information. Copy the information to the in-memory inode
455 * and cache the B-Tree node to improve future operations.
456 */
461 /*
462 * cache[0] tries to cache the location of the object inode.
463 * The assumption is that it is near the directory inode.
464 *
465 * cache[1] tries to cache the location of the object data.
466 * We might have something in the governing directory from
467 * scan optimizations (see the strategy code in
468 * hammer_vnops.c).
469 *
470 * We update dip->cache[2], if possible, with the location
471 * of the object inode for future directory shortcuts.
472 */
478 }
480 }
482 /*
483 * The file should not contain any data past the file size
484 * stored in the inode. Setting save_trunc_off to the
485 * file size instead of max reduces B-Tree lookup overheads
486 * on append by allowing the flusher to avoid checking for
487 * record overwrites.
488 */
491 /*
492 * Locate and assign the pseudofs management structure to
493 * the inode.
494 */
501 errorp);
503 }
504 }
506 /*
507 * The inode is placed on the red-black tree and will be synced to
508 * the media when flushed or by the filesystem sync. If this races
509 * another instantiation/lookup the insertion will fail.
510 */
516 }
522 }
526 }
530 }
532 /*
533 * Get a dummy inode to placemark a broken directory entry.
534 */
539 {
544 /*
545 * Determine if we already have an inode cached. If we do then
546 * we are golden.
547 *
548 * If we find an inode with no vnode we have to mark the
549 * transaction such that hammer_inode_waitreclaims() is
550 * called later on to avoid building up an infinite number
551 * of inodes. Otherwise we can continue to * add new inodes
552 * faster then they can be disposed of, even with the tsleep
553 * delay.
554 *
555 * If we find a non-fake inode we return an error. Only fake
556 * inodes can be returned by this routine.
557 */
561 loop:
568 }
571 }
573 /*
574 * Allocate a new inode structure and deal with races later.
575 */
594 /*
595 * Populate the dummy inode. Leave everything zero'd out.
596 *
597 * (ip->ino_leaf and ip->ino_data)
598 *
599 * Make the dummy inode a FIFO object which most copy programs
600 * will properly ignore.
601 */
605 /*
606 * Locate and assign the pseudofs management structure to
607 * the inode.
608 */
614 errorp);
616 }
618 /*
619 * The inode is placed on the red-black tree and will be synced to
620 * the media when flushed or by the filesystem sync. If this races
621 * another instantiation/lookup the insertion will fail.
622 *
623 * NOTE: Do not set HAMMER_INODE_ONDISK. The inode is a fake.
624 */
629 }
634 }
637 }
640 }
642 /*
643 * Return a referenced inode only if it is in our inode cache.
644 *
645 * Dummy inodes do not count.
646 */
650 {
663 else
665 }
667 }
669 /*
670 * Create a new filesystem object, returning the inode in *ipp. The
671 * returned inode will be referenced. The inode is created in-memory.
672 *
673 * If pfsm is non-NULL the caller wishes to create the root inode for
674 * a master PFS.
675 */
676 int
681 {
682 hammer_mount_t hmp;
683 hammer_inode_t ip;
684 uid_t xuid;
687 u_int32_t dummy;
705 }
719 /* ip->save_trunc_off = 0; (already zero) */
728 /*
729 * A nohistory designator on the parent directory is inherited by
730 * the child. We will do this even for pseudo-fs creation... the
731 * sysad can turn it off.
732 */
736 }
740 HAMMER_LOCALIZE_INODE;
753 /*
754 * If we are running version 2 or greater we use dirhash algorithm #1
755 * which is semi-sorted. Algorithm #0 was just a pure crc.
756 */
760 }
761 }
763 /*
764 * Setup the ".." pointer. This only needs to be done for directories
765 * but we do it for all objects as a recovery aid.
766 */
769 #if 0
770 /*
771 * The parent_obj_localization field only applies to pseudo-fs roots.
772 * XXX this is no longer applicable, PFSs are no longer directly
773 * tied into the parent's directory structure.
774 */
779 }
780 #endif
790 }
792 /*
793 * Calculate default uid/gid and overwrite with information from
794 * the vap.
795 */
802 }
809 else
834 }
842 /* not reached */
844 }
847 }
849 /*
850 * Final cleanup / freeing of an inode structure
851 */
852 static void
854 {
871 }
874 }
876 /*
877 * Retrieve pseudo-fs data. NULL will never be returned.
878 *
879 * If an error occurs *errorp will be set and a default template is returned,
880 * otherwise *errorp is set to 0. Typically when an error occurs it will
881 * be ENOENT.
882 */
883 hammer_pseudofs_inmem_t
886 {
888 hammer_inode_t ip;
889 hammer_pseudofs_inmem_t pfsm;
893 retry:
899 }
901 /*
902 * PFS records are stored in the root inode (not the PFS root inode,
903 * but the real root). Avoid an infinite recursion if loading
904 * the PFS for the real root.
905 */
908 HAMMER_MAX_TID,
912 }
921 HAMMER_LOCALIZE_MISC;
933 else
939 HAMMER_PFSD_DELETED) {
946 }
947 }
948 }
958 }
960 }
962 /*
963 * Store pseudo-fs data. The backend will automatically delete any prior
964 * on-disk pseudo-fs data but we have to delete in-memory versions.
965 */
966 int
968 {
970 hammer_record_t record;
971 hammer_inode_t ip;
976 retry:
980 HAMMER_LOCALIZE_MISC;
990 /*
991 * Replace any in-memory version of the record.
992 */
1004 }
1005 }
1007 /*
1008 * Allocate replacement general record. The backend flush will
1009 * delete any on-disk version of the record.
1010 */
1016 HAMMER_LOCALIZE_MISC;
1022 }
1028 }
1030 /*
1031 * Create a root directory for a PFS if one does not alredy exist.
1032 *
1033 * The PFS root stands alone so we must also bump the nlinks count
1034 * to prevent it from being destroyed on release.
1035 */
1036 int
1038 hammer_pseudofs_inmem_t pfsm)
1039 {
1040 hammer_inode_t ip;
1056 }
1057 }
1061 }
1063 /*
1064 * Unload any vnodes & inodes associated with a PFS, return ENOTEMPTY
1065 * if we are unable to disassociate all the inodes.
1066 */
1067 static
1068 int
1070 {
1078 else
1082 }
1084 int
1086 {
1092 hammer_inode_pfs_cmp,
1093 hammer_unload_pseudofs_callback,
1098 }
1102 }
1105 /*
1106 * Release a reference on a PFS
1107 */
1108 void
1110 {
1115 }
1116 }
1118 /*
1119 * Called by hammer_sync_inode().
1120 */
1121 static int
1123 {
1125 hammer_record_t record;
1129 retry:
1132 /*
1133 * If the inode has a presence on-disk then locate it and mark
1134 * it deleted, setting DELONDISK.
1135 *
1136 * The record may or may not be physically deleted, depending on
1137 * the retention policy.
1138 */
1140 HAMMER_INODE_ONDISK) {
1143 HAMMER_LOCALIZE_INODE;
1165 }
1168 }
1177 }
1178 }
1180 /*
1181 * Ok, write out the initial record or a new record (after deleting
1182 * the old one), unless the DELETED flag is set. This routine will
1183 * clear DELONDISK if it writes out a record.
1184 *
1185 * Update our inode statistics if this is the first application of
1186 * the inode on-disk.
1187 */
1189 /*
1190 * Generate a record and write it to the media. We clean-up
1191 * the state before releasing so we do not have to set-up
1192 * a flush_group.
1193 */
1204 /*
1205 * If this flag is set we cannot sync the new file size
1206 * because we haven't finished related truncations. The
1207 * inode will be flushed in another flush group to finish
1208 * the job.
1209 */
1216 }
1232 }
1234 /*
1235 * Note: The record was never on the inode's record tree
1236 * so just wave our hands importantly and destroy it.
1237 */
1244 /*
1245 * Finish up.
1246 */
1251 HAMMER_INODE_ATIME |
1252 HAMMER_INODE_MTIME);
1257 /*
1258 * Root volume count of inodes
1259 */
1264 vol0_stat_inodes);
1270 }
1272 }
1273 }
1275 /*
1276 * If the inode has been destroyed, clean out any left-over flags
1277 * that may have been set by the frontend.
1278 */
1281 HAMMER_INODE_ATIME |
1282 HAMMER_INODE_MTIME);
1283 }
1285 }
1287 /*
1288 * Update only the itimes fields.
1289 *
1290 * ATIME can be updated without generating any UNDO. MTIME is updated
1291 * with UNDO so it is guaranteed to be synchronized properly in case of
1292 * a crash.
1293 *
1294 * Neither field is included in the B-Tree leaf element's CRC, which is how
1295 * we can get away with updating ATIME the way we do.
1296 */
1297 static int
1299 {
1303 retry:
1305 HAMMER_INODE_ONDISK) {
1307 }
1311 HAMMER_LOCALIZE_INODE;
1329 /*
1330 * Updating MTIME requires an UNDO. Just cover
1331 * both atime and mtime.
1332 */
1336 HAMMER_ITIMES_BYTES);
1342 /*
1343 * Updating atime only can be done in-place with
1344 * no UNDO.
1345 */
1352 }
1354 }
1361 }
1363 }
1365 /*
1366 * Release a reference on an inode, flush as requested.
1367 *
1368 * On the last reference we queue the inode to the flusher for its final
1369 * disposition.
1370 */
1371 void
1373 {
1374 /*hammer_mount_t hmp = ip->hmp;*/
1376 /*
1377 * Handle disposition when dropping the last ref.
1378 */
1381 /*
1382 * Determine whether on-disk action is needed for
1383 * the inode's final disposition.
1384 */
1392 }
1397 /*
1398 * The inode still has multiple refs, try to drop
1399 * one ref.
1400 */
1405 }
1406 }
1407 }
1408 }
1410 /*
1411 * Unload and destroy the specified inode. Must be called with one remaining
1412 * reference. The reference is disposed of.
1413 *
1414 * The inode must be completely clean.
1415 */
1416 static int
1418 {
1436 }
1438 /*
1439 * Called during unmounting if a critical error occured. The in-memory
1440 * inode and all related structures are destroyed.
1441 *
1442 * If a critical error did not occur the unmount code calls the standard
1443 * release and asserts that the inode is gone.
1444 */
1445 int
1447 {
1448 hammer_record_t rec;
1450 /*
1451 * Get rid of the inodes in-memory records, regardless of their
1452 * state, and clear the mod-mask.
1453 */
1459 }
1463 else
1472 }
1477 /*
1478 * Remove the inode from any flush group, force it idle. FLUSH
1479 * and SETUP states have an inode ref.
1480 */
1486 /* fall through */
1490 /* fall through */
1493 }
1495 /*
1496 * There shouldn't be any associated vnode. The unload needs at
1497 * least one ref, if we do have a vp steal its ip ref.
1498 */
1506 }
1509 }
1511 /*
1512 * Called on mount -u when switching from RW to RO or vise-versa. Adjust
1513 * the read-only flag for cached inodes.
1514 *
1515 * This routine is called from a RB_SCAN().
1516 */
1517 int
1519 {
1524 else
1527 }
1529 /*
1530 * A transaction has modified an inode, requiring updates as specified by
1531 * the passed flags.
1532 *
1533 * HAMMER_INODE_DDIRTY: Inode data has been updated
1534 * HAMMER_INODE_XDIRTY: Dirty in-memory records
1535 * HAMMER_INODE_BUFS: Dirty buffer cache buffers
1536 * HAMMER_INODE_DELETED: Inode record/data must be deleted
1537 * HAMMER_INODE_ATIME/MTIME: mtime/atime has been updated
1538 */
1539 void
1541 {
1542 /*
1543 * ronly of 0 or 2 does not trigger assertion.
1544 * 2 is a special error state
1545 */
1553 }
1556 }
1558 /*
1559 * Request that an inode be flushed. This whole mess cannot block and may
1560 * recurse (if not synchronous). Once requested HAMMER will attempt to
1561 * actively flush the inode until the flush can be done.
1562 *
1563 * The inode may already be flushing, or may be in a setup state. We can
1564 * place the inode in a flushing state if it is currently idle and flag it
1565 * to reflush if it is currently flushing.
1566 *
1567 * Upon return if the inode could not be flushed due to a setup
1568 * dependancy, then it will be automatically flushed when the dependancy
1569 * is satisfied.
1570 */
1571 void
1573 {
1574 hammer_mount_t hmp;
1575 hammer_flush_group_t flg;
1578 /*
1579 * next_flush_group is the first flush group we can place the inode
1580 * in. It may be NULL. If it becomes full we append a new flush
1581 * group and make that the next_flush_group.
1582 */
1590 }
1596 }
1598 /*
1599 * Trivial 'nothing to flush' case. If the inode is in a SETUP
1600 * state we have to put it back into an IDLE state so we can
1601 * drop the extra ref.
1602 *
1603 * If we have a parent dependancy we must still fall through
1604 * so we can run it.
1605 */
1611 }
1614 }
1616 /*
1617 * Our flush action will depend on the current state.
1618 */
1621 /*
1622 * We have no dependancies and can flush immediately. Some
1623 * our children may not be flushable so we have to re-test
1624 * with that additional knowledge.
1625 */
1629 /*
1630 * Recurse upwards through dependancies via target_list
1631 * and start their flusher actions going if possible.
1632 *
1633 * 'good' is our connectivity. -1 means we have none and
1634 * can't flush, 0 means there weren't any dependancies, and
1635 * 1 means we have good connectivity.
1636 */
1640 /*
1641 * We can continue if good >= 0. Determine how
1642 * many records under our inode can be flushed (and
1643 * mark them).
1644 */
1647 /*
1648 * Parent has no connectivity, tell it to flush
1649 * us as soon as it does.
1650 *
1651 * The REFLUSH flag is also needed to trigger
1652 * dependancy wakeups.
1653 */
1655 HAMMER_INODE_REFLUSH;
1659 }
1660 }
1663 /*
1664 * We are already flushing, flag the inode to reflush
1665 * if needed after it completes its current flush.
1666 *
1667 * The REFLUSH flag is also needed to trigger
1668 * dependancy wakeups.
1669 */
1675 }
1677 }
1678 }
1680 /*
1681 * Scan ip->target_list, which is a list of records owned by PARENTS to our
1682 * ip which reference our ip.
1683 *
1684 * XXX This is a huge mess of recursive code, but not one bit of it blocks
1685 * so for now do not ref/deref the structures. Note that if we use the
1686 * ref/rel code later, the rel CAN block.
1687 */
1688 static int
1690 hammer_flush_group_t flg)
1691 {
1692 hammer_record_t depend;
1696 /*
1697 * If we hit our recursion limit and we have parent dependencies
1698 * We cannot continue. Returning < 0 will cause us to be flagged
1699 * for reflush. Returning -2 cuts off additional dependency checks
1700 * because they are likely to also hit the depth limit.
1701 *
1702 * We cannot return < 0 if there are no dependencies or there might
1703 * not be anything to wakeup (ip).
1704 */
1710 }
1712 /*
1713 * Scan dependencies
1714 */
1724 /*
1725 * If we failed due to the recursion depth limit then stop
1726 * now.
1727 */
1730 }
1732 }
1734 /*
1735 * This helper function takes a record representing the dependancy between
1736 * the parent inode and child inode.
1737 *
1738 * record->ip = parent inode
1739 * record->target_ip = child inode
1740 *
1741 * We are asked to recurse upwards and convert the record from SETUP
1742 * to FLUSH if possible.
1743 *
1744 * Return 1 if the record gives us connectivity
1745 *
1746 * Return 0 if the record is not relevant
1747 *
1748 * Return -1 if we can't resolve the dependancy and there is no connectivity.
1749 */
1750 static int
1752 hammer_flush_group_t flg)
1753 {
1754 hammer_mount_t hmp;
1755 hammer_inode_t pip;
1762 /*
1763 * If the record is already flushing, is it in our flush group?
1764 *
1765 * If it is in our flush group but it is a general record or a
1766 * delete-on-disk, it does not improve our connectivity (return 0),
1767 * and if the target inode is not trying to destroy itself we can't
1768 * allow the operation yet anyway (the second return -1).
1769 */
1771 /*
1772 * If not in our flush group ask the parent to reflush
1773 * us as soon as possible.
1774 */
1779 }
1781 /*
1782 * If in our flush group everything is already set up,
1783 * just return whether the record will improve our
1784 * visibility or not.
1785 */
1789 }
1791 /*
1792 * It must be a setup record. Try to resolve the setup dependancies
1793 * by recursing upwards so we can place ip on the flush list.
1794 *
1795 * Limit ourselves to 20 levels of recursion to avoid blowing out
1796 * the kernel stack. If we hit the recursion limit we can't flush
1797 * until the parent flushes. The parent will flush independantly
1798 * on its own and ultimately a deep recursion will be resolved.
1799 */
1804 /*
1805 * If good < 0 the parent has no connectivity and we cannot safely
1806 * flush the directory entry, which also means we can't flush our
1807 * ip. Flag us for downward recursion once the parent's
1808 * connectivity is resolved. Flag the parent for [re]flush or it
1809 * may not check for downward recursions.
1810 */
1815 }
1817 /*
1818 * We are go, place the parent inode in a flushing state so we can
1819 * place its record in a flushing state. Note that the parent
1820 * may already be flushing. The record must be in the same flush
1821 * group as the parent.
1822 */
1828 #if 0
1831 /*
1832 * Regardless of flushing state we cannot sync this path if the
1833 * record represents a delete-on-disk but the target inode
1834 * is not ready to sync its own deletion.
1835 *
1836 * XXX need to count effective nlinks to determine whether
1837 * the flush is ok, otherwise removing a hardlink will
1838 * just leave the DEL record to rot.
1839 */
1843 #endif
1845 /*
1846 * Because we have not calculated nlinks yet we can just
1847 * set records to the flush state if the parent is in
1848 * the same flush group as we are.
1849 */
1855 /*
1856 * A general directory-add contributes to our visibility.
1857 *
1858 * Otherwise it is probably a directory-delete or
1859 * delete-on-disk record and does not contribute to our
1860 * visbility (but we can still flush it).
1861 */
1866 /*
1867 * If the parent is not in our flush group we cannot
1868 * flush this record yet, there is no visibility.
1869 * We tell the parent to reflush and mark ourselves
1870 * so the parent knows it should flush us too.
1871 */
1875 }
1876 }
1878 /*
1879 * This is the core routine placing an inode into the FST_FLUSH state.
1880 */
1881 static void
1883 {
1886 /*
1887 * Set flush state and prevent the flusher from cycling into
1888 * the next flush group. Do not place the ip on the list yet.
1889 * Inodes not in the idle state get an extra reference.
1890 */
1901 /*
1902 * If the flush group reaches the autoflush limit we want to signal
1903 * the flusher. This is particularly important for remove()s.
1904 */
1908 /*
1909 * We need to be able to vfsync/truncate from the backend.
1910 */
1915 }
1917 /*
1918 * Figure out how many in-memory records we can actually flush
1919 * (not including inode meta-data, buffers, etc).
1920 */
1923 /*
1924 * If this is a upwards recursion we do not want to
1925 * recurse down again!
1926 */
1928 #if 0
1930 /*
1931 * No new records are added if we must complete a flush
1932 * from a previous cycle, but we do have to move the records
1933 * from the previous cycle to the current one.
1934 */
1935 #if 0
1938 #endif
1940 #endif
1942 /*
1943 * Normal flush, scan records and bring them into the flush.
1944 * Directory adds and deletes are usually skipped (they are
1945 * grouped with the related inode rather then with the
1946 * directory).
1947 *
1948 * go_count can be negative, which means the scan aborted
1949 * due to the flush group being over-full and we should
1950 * flush what we have.
1951 */
1954 }
1956 /*
1957 * This is a more involved test that includes go_count. If we
1958 * can't flush, flag the inode and return. If go_count is 0 we
1959 * were are unable to flush any records in our rec_tree and
1960 * must ignore the XDIRTY flag.
1961 */
1973 }
1975 /*
1976 * REFLUSH is needed to trigger dependancy wakeups
1977 * when an inode is in SETUP.
1978 */
1983 }
1987 }
1988 }
1990 /*
1991 * Snapshot the state of the inode for the backend flusher.
1992 *
1993 * We continue to retain save_trunc_off even when all truncations
1994 * have been resolved as an optimization to determine if we can
1995 * skip the B-Tree lookup for overwrite deletions.
1996 *
1997 * NOTE: The DELETING flag is a mod flag, but it is also sticky,
1998 * and stays in ip->flags. Once set, it stays set until the
1999 * inode is destroyed.
2000 */
2008 /*
2009 * The save_trunc_off used to cache whether the B-Tree
2010 * holds any records past that point is not used until
2011 * after the truncation has succeeded, so we can safely
2012 * set it now.
2013 */
2016 }
2022 #ifdef DEBUG_TRUNCATE
2025 #endif
2027 /*
2028 * The flusher list inherits our inode and reference.
2029 */
2037 }
2038 }
2040 /*
2041 * Callback for scan of ip->rec_tree. Try to include each record in our
2042 * flush. ip->flush_group has been set but the inode has not yet been
2043 * moved into a flushing state.
2044 *
2045 * If we get stuck on a record we have to set HAMMER_INODE_REFLUSH on
2046 * both inodes.
2047 *
2048 * We return 1 for any record placed or found in FST_FLUSH, which prevents
2049 * the caller from shortcutting the flush.
2050 */
2051 static int
2053 {
2054 hammer_flush_group_t flg;
2055 hammer_inode_t target_ip;
2056 hammer_inode_t ip;
2059 /*
2060 * Records deleted or committed by the backend are ignored.
2061 * Note that the flush detects deleted frontend records at
2062 * multiple points to deal with races. This is just the first
2063 * line of defense. The only time HAMMER_RECF_DELETED_FE cannot
2064 * be set is when HAMMER_RECF_INTERLOCK_BE is set, because it
2065 * messes up link-count calculations.
2066 *
2067 * NOTE: Don't get confused between record deletion and, say,
2068 * directory entry deletion. The deletion of a directory entry
2069 * which is on-media has nothing to do with the record deletion
2070 * flags.
2071 */
2073 HAMMER_RECF_COMMITTED)) {
2079 }
2081 }
2083 /*
2084 * If the record is in an idle state it has no dependancies and
2085 * can be flushed.
2086 */
2093 /*
2094 * The record has no setup dependancy, we can flush it.
2095 */
2104 /*
2105 * The record has a setup dependancy. These are typically
2106 * directory entry adds and deletes. Such entries will be
2107 * flushed when their inodes are flushed so we do not
2108 * usually have to add them to the flush here. However,
2109 * if the target_ip has set HAMMER_INODE_CONN_DOWN then
2110 * it is asking us to flush this record (and it).
2111 */
2116 /*
2117 * If the target IP is already flushing in our group
2118 * we could associate the record, but target_ip has
2119 * already synced ino_data to sync_ino_data and we
2120 * would also have to adjust nlinks. Plus there are
2121 * ordering issues for adds and deletes.
2122 *
2123 * Reflush downward if this is an ADD, and upward if
2124 * this is a DEL.
2125 */
2129 else
2132 }
2134 /*
2135 * Target IP is not yet flushing. This can get complex
2136 * because we have to be careful about the recursion.
2137 *
2138 * Directories create an issue for us in that if a flush
2139 * of a directory is requested the expectation is to flush
2140 * any pending directory entries, but this will cause the
2141 * related inodes to recursively flush as well. We can't
2142 * really defer the operation so just get as many as we
2143 * can and
2144 */
2145 #if 0
2148 /*
2149 * We aren't reclaiming and the target ip was not
2150 * previously prevented from flushing due to this
2151 * record dependancy. Do not flush this record.
2152 */
2153 /*r = 0;*/
2155 #endif
2158 /*
2159 * Our flush group is over-full and we risk blowing
2160 * out the UNDO FIFO. Stop the scan, flush what we
2161 * have, then reflush the directory.
2162 *
2163 * The directory may be forced through multiple
2164 * flush groups before it can be completely
2165 * flushed.
2166 */
2168 HAMMER_INODE_REFLUSH;
2171 /*
2172 * If the target IP is not flushing we can force
2173 * it to flush, even if it is unable to write out
2174 * any of its own records we have at least one in
2175 * hand that we CAN deal with.
2176 */
2182 HAMMER_FLUSH_RECURSION);
2185 /*
2186 * General or delete-on-disk record.
2187 *
2188 * XXX this needs help. If a delete-on-disk we could
2189 * disconnect the target. If the target has its own
2190 * dependancies they really need to be flushed.
2191 *
2192 * XXX
2193 */
2199 HAMMER_FLUSH_RECURSION);
2201 }
2204 /*
2205 * The flush_group should already match.
2206 */
2210 }
2212 }
2214 #if 0
2215 /*
2216 * This version just moves records already in a flush state to the new
2217 * flush group and that is it.
2218 */
2219 static int
2221 {
2230 }
2232 }
2233 #endif
2235 /*
2236 * Wait for a previously queued flush to complete.
2237 *
2238 * If a critical error occured we don't try to wait.
2239 */
2240 void
2242 {
2243 hammer_flush_group_t flg;
2254 }
2255 }
2256 }
2257 }
2259 /*
2260 * Called by the backend code when a flush has been completed.
2261 * The inode has already been removed from the flush list.
2262 *
2263 * A pipelined flush can occur, in which case we must re-enter the
2264 * inode on the list and re-copy its fields.
2265 */
2266 void
2268 {
2269 hammer_mount_t hmp;
2276 /*
2277 * Auto-reflush if the backend could not completely flush
2278 * the inode. This fixes a case where a deferred buffer flush
2279 * could cause fsync to return early.
2280 */
2284 /*
2285 * Merge left-over flags back into the frontend and fix the state.
2286 * Incomplete truncations are retained by the backend.
2287 */
2292 /*
2293 * The backend may have adjusted nlinks, so if the adjusted nlinks
2294 * does not match the fronttend set the frontend's RDIRTY flag again.
2295 */
2299 /*
2300 * Fix up the dirty buffer status.
2301 */
2304 }
2306 /*
2307 * Re-set the XDIRTY flag if some of the inode's in-memory records
2308 * could not be flushed.
2309 */
2315 /*
2316 * Do not lose track of inodes which no longer have vnode
2317 * assocations, otherwise they may never get flushed again.
2318 *
2319 * The reflush flag can be set superfluously, causing extra pain
2320 * for no reason. If the inode is no longer modified it no longer
2321 * needs to be flushed.
2322 */
2328 }
2330 /*
2331 * Adjust the flush state.
2332 */
2334 /*
2335 * We were unable to flush out all our records, leave the
2336 * inode in a flush state and in the current flush group.
2337 * The flush group will be re-run.
2338 *
2339 * This occurs if the UNDO block gets too full or there is
2340 * too much dirty meta-data and allows the flusher to
2341 * finalize the UNDO block and then re-flush.
2342 */
2346 /*
2347 * Remove from the flush_group
2348 */
2352 /*
2353 * Clean up the vnode ref and tracking counts.
2354 */
2358 }
2362 /*
2363 * And adjust the state.
2364 */
2371 }
2373 /*
2374 * If the frontend is waiting for a flush to complete,
2375 * wake it up.
2376 */
2380 }
2382 /*
2383 * If the frontend made more changes and requested another
2384 * flush, then try to get it running.
2385 *
2386 * Reflushes are aborted when the inode is errored out.
2387 */
2395 }
2396 }
2397 }
2399 /*
2400 * If we have no parent dependancies we can clear CONN_DOWN
2401 */
2405 /*
2406 * If the inode is now clean drop the space reservation.
2407 */
2412 }
2416 }
2418 /*
2419 * Called from hammer_sync_inode() to synchronize in-memory records
2420 * to the media.
2421 */
2422 static int
2424 {
2430 /*
2431 * Skip records that do not belong to the current flush.
2432 */
2437 #if 1
2439 kprintf("sync_record %p ip %p bad flush group %p %p\n", record, record->ip, record->flush_group ,record->ip->flush_group);
2442 }
2443 #endif
2446 /*
2447 * Interlock the record using the BE flag. Once BE is set the
2448 * frontend cannot change the state of FE.
2449 *
2450 * NOTE: If FE is set prior to us setting BE we still sync the
2451 * record out, but the flush completion code converts it to
2452 * a delete-on-disk record instead of destroying it.
2453 */
2457 /*
2458 * The backend has already disposed of the record.
2459 */
2463 }
2465 /*
2466 * If the whole inode is being deleting all on-disk records will
2467 * be deleted very soon, we can't sync any new records to disk
2468 * because they will be deleted in the same transaction they were
2469 * created in (delete_tid == create_tid), which will assert.
2470 *
2471 * XXX There may be a case with RECORD_ADD with DELETED_FE set
2472 * that we currently panic on.
2473 */
2477 /*
2478 * We don't have to do anything, if the record was
2479 * committed the space will have been accounted for
2480 * in the blockmap.
2481 */
2482 /* fall through */
2484 /*
2485 * Set deleted-by-backend flag. Do not set the
2486 * backend committed flag, because we are throwing
2487 * the record away.
2488 */
2502 /*
2503 * Follow through and issue the on-disk deletion
2504 */
2506 }
2507 }
2509 /*
2510 * If DELETED_FE is set special handling is needed for directory
2511 * entries. Dependant pieces related to the directory entry may
2512 * have already been synced to disk. If this occurs we have to
2513 * sync the directory entry and then change the in-memory record
2514 * from an ADD to a DELETE to cover the fact that it's been
2515 * deleted by the frontend.
2516 *
2517 * A directory delete covering record (MEM_RECORD_DEL) can never
2518 * be deleted by the frontend.
2519 *
2520 * Any other record type (aka DATA) can be deleted by the frontend.
2521 * XXX At the moment the flusher must skip it because there may
2522 * be another data record in the flush group for the same block,
2523 * meaning that some frontend data changes can leak into the backend's
2524 * synchronization point.
2525 */
2528 /*
2529 * Convert a front-end deleted directory-add to
2530 * a directory-delete entry later.
2531 */
2534 /*
2535 * Dispose of the record (race case). Mark as
2536 * deleted by backend (and not committed).
2537 */
2543 }
2544 }
2546 /*
2547 * Assign the create_tid for new records. Deletions already
2548 * have the record's entire key properly set up.
2549 */
2553 }
2563 }
2568 done:
2571 /*
2572 * Do partial finalization if we have built up too many dirty
2573 * buffers. Otherwise a buffer cache deadlock can occur when
2574 * doing things like creating tens of thousands of tiny files.
2575 *
2576 * We must release our cursor lock to avoid a 3-way deadlock
2577 * due to the exclusive sync lock the finalizer must get.
2578 */
2583 }
2586 }
2588 /*
2589 * Backend function called by the flusher to sync an inode to media.
2590 */
2591 int
2593 {
2595 hammer_node_t tmp_node;
2596 hammer_record_t depend;
2597 hammer_record_t next;
2599 u_int64_t nlinks;
2608 /*
2609 * Any directory records referencing this inode which are not in
2610 * our current flush group must adjust our nlink count for the
2611 * purposes of synchronization to disk.
2612 *
2613 * Records which are in our flush group can be unlinked from our
2614 * inode now, potentially allowing the inode to be physically
2615 * deleted.
2616 *
2617 * This cannot block.
2618 */
2625 /*
2626 * If this is an ADD that was deleted by the frontend
2627 * the frontend nlinks count will have already been
2628 * decremented, but the backend is going to sync its
2629 * directory entry and must account for it. The
2630 * record will be converted to a delete-on-disk when
2631 * it gets synced.
2632 *
2633 * If the ADD was not deleted by the frontend we
2634 * can remove the dependancy from our target_list.
2635 */
2640 target_entry);
2642 }
2644 /*
2645 * Not part of our flush group and not deleted by
2646 * the front-end, adjust the link count synced to
2647 * the media (undo what the frontend did when it
2648 * queued the record).
2649 */
2660 }
2661 }
2662 }
2664 /*
2665 * Set dirty if we had to modify the link count.
2666 */
2671 }
2673 /*
2674 * If there is a trunction queued destroy any data past the (aligned)
2675 * truncation point. Userland will have dealt with the buffer
2676 * containing the truncation point for us.
2677 *
2678 * We don't flush pending frontend data buffers until after we've
2679 * dealt with the truncation.
2680 */
2682 /*
2683 * Interlock trunc_off. The VOP front-end may continue to
2684 * make adjustments to it while we are blocked.
2685 */
2686 off_t trunc_off;
2687 off_t aligned_trunc_off;
2694 /*
2695 * Delete any whole blocks on-media. The front-end has
2696 * already cleaned out any partial block and made it
2697 * pending. The front-end may have updated trunc_off
2698 * while we were blocked so we only use sync_trunc_off.
2699 *
2700 * This operation can blow out the buffer cache, EWOULDBLOCK
2701 * means we were unable to complete the deletion. The
2702 * deletion will update sync_trunc_off in that case.
2703 */
2705 aligned_trunc_off,
2711 }
2716 /*
2717 * Clear the truncation flag on the backend after we have
2718 * complete the deletions. Backend data is now good again
2719 * (including new records we are about to sync, below).
2720 *
2721 * Leave sync_trunc_off intact. As we write additional
2722 * records the backend will update sync_trunc_off. This
2723 * tells the backend whether it can skip the overwrite
2724 * test. This should work properly even when the backend
2725 * writes full blocks where the truncation point straddles
2726 * the block because the comparison is against the base
2727 * offset of the record.
2728 */
2730 /* ip->sync_trunc_off = 0x7FFFFFFFFFFFFFFFLL; */
2733 }
2735 /*
2736 * Now sync related records. These will typically be directory
2737 * entries, records tracking direct-writes, or delete-on-disk records.
2738 */
2746 }
2749 /*
2750 * Re-seek for inode update, assuming our cache hasn't been ripped
2751 * out from under us.
2752 */
2762 }
2764 }
2766 /*
2767 * If we are deleting the inode the frontend had better not have
2768 * any active references on elements making up the inode.
2769 *
2770 * The call to hammer_ip_delete_clean() cleans up auxillary records
2771 * but not DB or DATA records. Those must have already been deleted
2772 * by the normal truncation mechanic.
2773 */
2787 /*
2788 * Set delete_tid in both the frontend and backend
2789 * copy of the inode record. The DELETED flag handles
2790 * this, do not set RDIRTY.
2791 */
2798 /*
2799 * Adjust the inode count in the volume header
2800 */
2805 vol0_stat_inodes);
2808 }
2810 }
2811 }
2817 defer_buffer_flush:
2818 /*
2819 * Now update the inode's on-disk inode-data and/or on-disk record.
2820 * DELETED and ONDISK are managed only in ip->flags.
2821 *
2822 * In the case of a defered buffer flush we still update the on-disk
2823 * inode to satisfy visibility requirements if there happen to be
2824 * directory dependancies.
2825 */
2828 /*
2829 * If deleted and on-disk, don't set any additional flags.
2830 * the delete flag takes care of things.
2831 *
2832 * Clear flags which may have been set by the frontend.
2833 */
2836 HAMMER_INODE_DELETING);
2839 /*
2840 * Take care of the case where a deleted inode was never
2841 * flushed to the disk in the first place.
2842 *
2843 * Clear flags which may have been set by the frontend.
2844 */
2847 HAMMER_INODE_DELETING);
2855 }
2858 /*
2859 * If already on-disk, do not set any additional flags.
2860 */
2863 /*
2864 * If not on-disk and not deleted, set DDIRTY to force
2865 * an initial record to be written.
2866 *
2867 * Also set the create_tid in both the frontend and backend
2868 * copy of the inode record.
2869 */
2876 }
2878 /*
2879 * If RDIRTY or DDIRTY is set, write out a new record. If the inode
2880 * is already on-disk the old record is marked as deleted.
2881 *
2882 * If DELETED is set hammer_update_inode() will delete the existing
2883 * record without writing out a new one.
2884 *
2885 * If *ONLY* the ITIMES flag is set we can update the record in-place.
2886 */
2896 }
2897 done:
2901 }
2904 }
2906 /*
2907 * This routine is called when the OS is no longer actively referencing
2908 * the inode (but might still be keeping it cached), or when releasing
2909 * the last reference to an inode.
2910 *
2911 * At this point if the inode's nlinks count is zero we want to destroy
2912 * it, which may mean destroying it on-media too.
2913 */
2914 void
2916 {
2919 /*
2920 * Set the DELETING flag when the link count drops to 0 and the
2921 * OS no longer has any opens on the inode.
2922 *
2923 * The backend will clear DELETING (a mod flag) and set DELETED
2924 * (a state flag) when it is actually able to perform the
2925 * operation.
2926 *
2927 * Don't reflag the deletion if the flusher is currently syncing
2928 * one that was already flagged. A previously set DELETING flag
2929 * may bounce around flags and sync_flags until the operation is
2930 * completely done.
2931 */
2941 }
2943 /*
2944 * Final cleanup
2945 */
2949 }
2952 }
2953 }
2954 }
2956 /*
2957 * After potentially resolving a dependancy the inode is tested
2958 * to determine whether it needs to be reflushed.
2959 */
2960 void
2962 {
2971 }
2973 }
2974 }
2976 /*
2977 * Clear the RECLAIM flag on an inode. This occurs when the inode is
2978 * reassociated with a vp or just before it gets freed.
2979 *
2980 * Pipeline wakeups to threads blocked due to an excessive number of
2981 * detached inodes. The reclaim count generates a bit of negative
2982 * feedback.
2983 */
2984 static void
2986 {
3002 }
3003 }
3004 }
3006 /*
3007 * Setup our reclaim pipeline. We only let so many detached (and dirty)
3008 * inodes build up before we start blocking.
3009 *
3010 * When we block we don't care *which* inode has finished reclaiming,
3011 * as lone as one does. This is somewhat heuristical... we also put a
3012 * cap on how long we are willing to wait.
3013 */
3014 void
3016 {
3030 }
3031 }
3033 /*
3034 * A larger then normal backlog of inodes is sitting in the flusher,
3035 * enforce a general slowdown to let it catch up. This routine is only
3036 * called on completion of a non-flusher-related transaction which
3037 * performed B-Tree node I/O.
3038 *
3039 * It is possible for the flusher to stall in a continuous load.
3040 * blogbench -i1000 -o seems to do a good job generating this sort of load.
3041 * If the flusher is unable to catch up the inode count can bloat until
3042 * we run out of kvm.
3043 *
3044 * This is a bit of a hack.
3045 */
3046 void
3048 {
3049 /*
3050 * Hysteresis.
3051 */
3057 }
3062 }
3064 }
3066 /*
3067 * Block for one flush cycle.
3068 */
3070 }