c66a49aaca44d296b67c6db5d70717bfacbdda92
| blob | c66a49aaca44d296b67c6db5d70717bfacbdda92 |
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.103.2.1 2008/07/16 18:39:31 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);
53 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;
224 /*
225 * Poke the flusher. If we don't do this programs
226 * will start to stall on the reclaiming count.
227 */
231 }
232 }
234 }
236 }
238 /*
239 * Return a locked vnode for the specified inode. The inode must be
240 * referenced but NOT LOCKED on entry and will remain referenced on
241 * return.
242 *
243 * Called from the frontend.
244 */
245 int
247 {
248 hammer_mount_t hmp;
251 u_int8_t obj_type;
266 }
288 }
290 /*
291 * Only mark as the root vnode if the ip is not
292 * historical, otherwise the VFS cache will get
293 * confused. The other half of the special handling
294 * is in hammer_vop_nlookupdotdot().
295 *
296 * Pseudo-filesystem roots also do not count.
297 */
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 {
363 /*
364 * Determine if we already have an inode cached. If we do then
365 * we are golden.
366 */
370 loop:
376 }
378 /*
379 * Allocate a new inode structure and deal with races later.
380 */
399 /*
400 * Locate the on-disk inode. If this is a PFS root we always
401 * access the current version of the root inode and (if it is not
402 * a master) always access information under it with a snapshot
403 * TID.
404 */
405 retry:
417 HAMMER_CURSOR_ASOF;
423 }
425 /*
426 * On success the B-Tree lookup will hold the appropriate
427 * buffer cache buffers and provide a pointer to the requested
428 * information. Copy the information to the in-memory inode
429 * and cache the B-Tree node to improve future operations.
430 */
435 /*
436 * cache[0] tries to cache the location of the object inode.
437 * The assumption is that it is near the directory inode.
438 *
439 * cache[1] tries to cache the location of the object data.
440 * The assumption is that it is near the directory data.
441 */
446 /*
447 * The file should not contain any data past the file size
448 * stored in the inode. Setting save_trunc_off to the
449 * file size instead of max reduces B-Tree lookup overheads
450 * on append by allowing the flusher to avoid checking for
451 * record overwrites.
452 */
455 /*
456 * Locate and assign the pseudofs management structure to
457 * the inode.
458 */
465 errorp);
467 }
468 }
470 /*
471 * The inode is placed on the red-black tree and will be synced to
472 * the media when flushed or by the filesystem sync. If this races
473 * another instantiation/lookup the insertion will fail.
474 */
480 }
486 }
490 }
493 }
495 /*
496 * Create a new filesystem object, returning the inode in *ipp. The
497 * returned inode will be referenced. The inode is created in-memory.
498 *
499 * If pfsm is non-NULL the caller wishes to create the root inode for
500 * a master PFS.
501 */
502 int
506 {
507 hammer_mount_t hmp;
508 hammer_inode_t ip;
509 uid_t xuid;
526 }
538 /* ip->save_trunc_off = 0; (already zero) */
547 /*
548 * A nohistory designator on the parent directory is inherited by
549 * the child. We will do this even for pseudo-fs creation... the
550 * sysad can turn it off.
551 */
555 }
559 HAMMER_LOCALIZE_INODE;
572 /*
573 * Setup the ".." pointer. This only needs to be done for directories
574 * but we do it for all objects as a recovery aid.
575 */
578 #if 0
579 /*
580 * The parent_obj_localization field only applies to pseudo-fs roots.
581 * XXX this is no longer applicable, PFSs are no longer directly
582 * tied into the parent's directory structure.
583 */
588 }
589 #endif
599 }
601 /*
602 * Calculate default uid/gid and overwrite with information from
603 * the vap.
604 */
611 }
618 else
643 }
650 /* not reached */
652 }
655 }
657 /*
658 * Final cleanup / freeing of an inode structure
659 */
660 static void
662 {
674 }
677 }
679 /*
680 * Retrieve pseudo-fs data. NULL will never be returned.
681 *
682 * If an error occurs *errorp will be set and a default template is returned,
683 * otherwise *errorp is set to 0. Typically when an error occurs it will
684 * be ENOENT.
685 */
686 hammer_pseudofs_inmem_t
689 {
691 hammer_inode_t ip;
692 hammer_pseudofs_inmem_t pfsm;
696 retry:
702 }
704 /*
705 * PFS records are stored in the root inode (not the PFS root inode,
706 * but the real root). Avoid an infinite recursion if loading
707 * the PFS for the real root.
708 */
711 HAMMER_MAX_TID,
715 }
724 HAMMER_LOCALIZE_MISC;
736 else
742 HAMMER_PFSD_DELETED) {
749 }
750 }
751 }
761 }
763 }
765 /*
766 * Store pseudo-fs data. The backend will automatically delete any prior
767 * on-disk pseudo-fs data but we have to delete in-memory versions.
768 */
769 int
771 {
773 hammer_record_t record;
774 hammer_inode_t ip;
779 retry:
783 HAMMER_LOCALIZE_MISC;
804 }
805 }
811 HAMMER_LOCALIZE_MISC;
817 }
823 }
825 /*
826 * Create a root directory for a PFS if one does not alredy exist.
827 *
828 * The PFS root stands alone so we must also bump the nlinks count
829 * to prevent it from being destroyed on release.
830 */
831 int
833 hammer_pseudofs_inmem_t pfsm)
834 {
835 hammer_inode_t ip;
849 }
850 }
854 }
856 /*
857 * Unload any vnodes & inodes associated with a PFS, return ENOTEMPTY
858 * if we are unable to disassociate all the inodes.
859 */
860 static
861 int
863 {
871 else
875 }
877 int
879 {
885 hammer_inode_pfs_cmp,
886 hammer_unload_pseudofs_callback,
891 }
895 }
898 /*
899 * Release a reference on a PFS
900 */
901 void
903 {
908 }
909 }
911 /*
912 * Called by hammer_sync_inode().
913 */
914 static int
916 {
918 hammer_record_t record;
922 retry:
925 /*
926 * If the inode has a presence on-disk then locate it and mark
927 * it deleted, setting DELONDISK.
928 *
929 * The record may or may not be physically deleted, depending on
930 * the retention policy.
931 */
933 HAMMER_INODE_ONDISK) {
936 HAMMER_LOCALIZE_INODE;
954 }
963 }
966 }
969 }
978 }
979 }
981 /*
982 * Ok, write out the initial record or a new record (after deleting
983 * the old one), unless the DELETED flag is set. This routine will
984 * clear DELONDISK if it writes out a record.
985 *
986 * Update our inode statistics if this is the first application of
987 * the inode on-disk.
988 */
990 /*
991 * Generate a record and write it to the media. We clean-up
992 * the state before releasing so we do not have to set-up
993 * a flush_group.
994 */
1005 /*
1006 * If this flag is set we cannot sync the new file size
1007 * because we haven't finished related truncations. The
1008 * inode will be flushed in another flush group to finish
1009 * the job.
1010 */
1017 }
1033 }
1037 }
1039 /*
1040 * The record isn't managed by the inode's record tree,
1041 * destroy it whether we succeed or fail.
1042 */
1048 /*
1049 * Finish up.
1050 */
1055 HAMMER_INODE_ATIME |
1056 HAMMER_INODE_MTIME);
1061 /*
1062 * Root volume count of inodes
1063 */
1068 vol0_stat_inodes);
1074 }
1076 }
1077 }
1079 /*
1080 * If the inode has been destroyed, clean out any left-over flags
1081 * that may have been set by the frontend.
1082 */
1085 HAMMER_INODE_ATIME |
1086 HAMMER_INODE_MTIME);
1087 }
1089 }
1091 /*
1092 * Update only the itimes fields.
1093 *
1094 * ATIME can be updated without generating any UNDO. MTIME is updated
1095 * with UNDO so it is guaranteed to be synchronized properly in case of
1096 * a crash.
1097 *
1098 * Neither field is included in the B-Tree leaf element's CRC, which is how
1099 * we can get away with updating ATIME the way we do.
1100 */
1101 static int
1103 {
1107 retry:
1109 HAMMER_INODE_ONDISK) {
1111 }
1115 HAMMER_LOCALIZE_INODE;
1133 }
1137 /*
1138 * Updating MTIME requires an UNDO. Just cover
1139 * both atime and mtime.
1140 */
1144 HAMMER_ITIMES_BYTES);
1150 /*
1151 * Updating atime only can be done in-place with
1152 * no UNDO.
1153 */
1160 }
1162 }
1169 }
1171 }
1173 /*
1174 * Release a reference on an inode, flush as requested.
1175 *
1176 * On the last reference we queue the inode to the flusher for its final
1177 * disposition.
1178 */
1179 void
1181 {
1184 /*
1185 * Handle disposition when dropping the last ref.
1186 */
1189 /*
1190 * Determine whether on-disk action is needed for
1191 * the inode's final disposition.
1192 */
1198 HAMMER_FLUSH_SIGNAL);
1201 }
1205 }
1210 /*
1211 * The inode still has multiple refs, try to drop
1212 * one ref.
1213 */
1218 }
1219 }
1220 }
1221 }
1223 /*
1224 * Unload and destroy the specified inode. Must be called with one remaining
1225 * reference. The reference is disposed of.
1226 *
1227 * This can only be called in the context of the flusher.
1228 */
1229 static int
1231 {
1249 }
1251 /*
1252 * Called on mount -u when switching from RW to RO or vise-versa. Adjust
1253 * the read-only flag for cached inodes.
1254 *
1255 * This routine is called from a RB_SCAN().
1256 */
1257 int
1259 {
1264 else
1267 }
1269 /*
1270 * A transaction has modified an inode, requiring updates as specified by
1271 * the passed flags.
1272 *
1273 * HAMMER_INODE_DDIRTY: Inode data has been updated
1274 * HAMMER_INODE_XDIRTY: Dirty in-memory records
1275 * HAMMER_INODE_BUFS: Dirty buffer cache buffers
1276 * HAMMER_INODE_DELETED: Inode record/data must be deleted
1277 * HAMMER_INODE_ATIME/MTIME: mtime/atime has been updated
1278 */
1279 void
1281 {
1289 }
1292 }
1294 /*
1295 * Request that an inode be flushed. This whole mess cannot block and may
1296 * recurse (if not synchronous). Once requested HAMMER will attempt to
1297 * actively flush the inode until the flush can be done.
1298 *
1299 * The inode may already be flushing, or may be in a setup state. We can
1300 * place the inode in a flushing state if it is currently idle and flag it
1301 * to reflush if it is currently flushing.
1302 *
1303 * If the HAMMER_FLUSH_SYNCHRONOUS flag is specified we will attempt to
1304 * flush the indoe synchronously using the caller's context.
1305 */
1306 void
1308 {
1309 hammer_mount_t hmp;
1310 hammer_flush_group_t flg;
1313 /*
1314 * next_flush_group is the first flush group we can place the inode
1315 * in. It may be NULL. If it becomes full we append a new flush
1316 * group and make that the next_flush_group.
1317 */
1325 }
1331 }
1333 /*
1334 * Trivial 'nothing to flush' case. If the inode is in a SETUP
1335 * state we have to put it back into an IDLE state so we can
1336 * drop the extra ref.
1337 *
1338 * If we have a parent dependancy we must still fall through
1339 * so we can run it.
1340 */
1346 }
1349 }
1351 /*
1352 * Our flush action will depend on the current state.
1353 */
1356 /*
1357 * We have no dependancies and can flush immediately. Some
1358 * our children may not be flushable so we have to re-test
1359 * with that additional knowledge.
1360 */
1364 /*
1365 * Recurse upwards through dependancies via target_list
1366 * and start their flusher actions going if possible.
1367 *
1368 * 'good' is our connectivity. -1 means we have none and
1369 * can't flush, 0 means there weren't any dependancies, and
1370 * 1 means we have good connectivity.
1371 */
1375 /*
1376 * We can continue if good >= 0. Determine how
1377 * many records under our inode can be flushed (and
1378 * mark them).
1379 */
1382 /*
1383 * parent has no connectivity, tell it to flush
1384 * us as soon as it does.
1385 */
1390 }
1391 }
1394 /*
1395 * We are already flushing, flag the inode to reflush
1396 * if needed after it completes its current flush.
1397 */
1403 }
1405 }
1406 }
1408 /*
1409 * Scan ip->target_list, which is a list of records owned by PARENTS to our
1410 * ip which reference our ip.
1411 *
1412 * XXX This is a huge mess of recursive code, but not one bit of it blocks
1413 * so for now do not ref/deref the structures. Note that if we use the
1414 * ref/rel code later, the rel CAN block.
1415 */
1416 static int
1418 {
1419 hammer_record_t depend;
1431 }
1433 }
1435 /*
1436 * This helper function takes a record representing the dependancy between
1437 * the parent inode and child inode.
1438 *
1439 * record->ip = parent inode
1440 * record->target_ip = child inode
1441 *
1442 * We are asked to recurse upwards and convert the record from SETUP
1443 * to FLUSH if possible.
1444 *
1445 * Return 1 if the record gives us connectivity
1446 *
1447 * Return 0 if the record is not relevant
1448 *
1449 * Return -1 if we can't resolve the dependancy and there is no connectivity.
1450 */
1451 static int
1453 hammer_flush_group_t flg)
1454 {
1455 hammer_mount_t hmp;
1456 hammer_inode_t pip;
1463 /*
1464 * If the record is already flushing, is it in our flush group?
1465 *
1466 * If it is in our flush group but it is a general record or a
1467 * delete-on-disk, it does not improve our connectivity (return 0),
1468 * and if the target inode is not trying to destroy itself we can't
1469 * allow the operation yet anyway (the second return -1).
1470 */
1472 /*
1473 * If not in our flush group ask the parent to reflush
1474 * us as soon as possible.
1475 */
1480 }
1482 /*
1483 * If in our flush group everything is already set up,
1484 * just return whether the record will improve our
1485 * visibility or not.
1486 */
1490 }
1492 /*
1493 * It must be a setup record. Try to resolve the setup dependancies
1494 * by recursing upwards so we can place ip on the flush list.
1495 */
1500 /*
1501 * If good < 0 the parent has no connectivity and we cannot safely
1502 * flush the directory entry, which also means we can't flush our
1503 * ip. Flag the parent and us for downward recursion once the
1504 * parent's connectivity is resolved.
1505 */
1507 /* pip->flags |= HAMMER_INODE_CONN_DOWN; set by recursion */
1510 }
1512 /*
1513 * We are go, place the parent inode in a flushing state so we can
1514 * place its record in a flushing state. Note that the parent
1515 * may already be flushing. The record must be in the same flush
1516 * group as the parent.
1517 */
1523 #if 0
1526 /*
1527 * Regardless of flushing state we cannot sync this path if the
1528 * record represents a delete-on-disk but the target inode
1529 * is not ready to sync its own deletion.
1530 *
1531 * XXX need to count effective nlinks to determine whether
1532 * the flush is ok, otherwise removing a hardlink will
1533 * just leave the DEL record to rot.
1534 */
1538 #endif
1540 /*
1541 * If the parent is in the same flush group as us we can
1542 * just set the record to a flushing state and we are
1543 * done.
1544 */
1550 /*
1551 * A general directory-add contributes to our visibility.
1552 *
1553 * Otherwise it is probably a directory-delete or
1554 * delete-on-disk record and does not contribute to our
1555 * visbility (but we can still flush it).
1556 */
1561 /*
1562 * If the parent is not in our flush group we cannot
1563 * flush this record yet, there is no visibility.
1564 * We tell the parent to reflush and mark ourselves
1565 * so the parent knows it should flush us too.
1566 */
1570 }
1571 }
1573 /*
1574 * This is the core routine placing an inode into the FST_FLUSH state.
1575 */
1576 static void
1578 {
1581 /*
1582 * Set flush state and prevent the flusher from cycling into
1583 * the next flush group. Do not place the ip on the list yet.
1584 * Inodes not in the idle state get an extra reference.
1585 */
1596 /*
1597 * We need to be able to vfsync/truncate from the backend.
1598 */
1603 }
1605 /*
1606 * Figure out how many in-memory records we can actually flush
1607 * (not including inode meta-data, buffers, etc).
1608 */
1610 /*
1611 * If this is a upwards recursion we do not want to
1612 * recurse down again!
1613 */
1616 /*
1617 * No new records are added if we must complete a flush
1618 * from a previous cycle, but we do have to move the records
1619 * from the previous cycle to the current one.
1620 */
1621 #if 0
1624 #endif
1627 /*
1628 * Normal flush, scan records and bring them into the flush.
1629 * Directory adds and deletes are usually skipped (they are
1630 * grouped with the related inode rather then with the
1631 * directory).
1632 *
1633 * go_count can be negative, which means the scan aborted
1634 * due to the flush group being over-full and we should
1635 * flush what we have.
1636 */
1639 }
1641 /*
1642 * This is a more involved test that includes go_count. If we
1643 * can't flush, flag the inode and return. If go_count is 0 we
1644 * were are unable to flush any records in our rec_tree and
1645 * must ignore the XDIRTY flag.
1646 */
1659 }
1663 }
1667 }
1668 }
1670 /*
1671 * Snapshot the state of the inode for the backend flusher.
1672 *
1673 * We continue to retain save_trunc_off even when all truncations
1674 * have been resolved as an optimization to determine if we can
1675 * skip the B-Tree lookup for overwrite deletions.
1676 *
1677 * NOTE: The DELETING flag is a mod flag, but it is also sticky,
1678 * and stays in ip->flags. Once set, it stays set until the
1679 * inode is destroyed.
1680 *
1681 * NOTE: If a truncation from a previous flush cycle had to be
1682 * continued into this one, the TRUNCATED flag will still be
1683 * set in sync_flags as will WOULDBLOCK. When this occurs
1684 * we CANNOT safely integrate a new truncation from the front-end
1685 * because there may be data records in-memory assigned a flush
1686 * state from the previous cycle that are supposed to be flushed
1687 * before the next frontend truncation.
1688 */
1690 HAMMER_INODE_TRUNCATED) {
1697 /*
1698 * The save_trunc_off used to cache whether the B-Tree
1699 * holds any records past that point is not used until
1700 * after the truncation has succeeded, so we can safely
1701 * set it now.
1702 */
1705 }
1711 #ifdef DEBUG_TRUNCATE
1714 #endif
1716 /*
1717 * The flusher list inherits our inode and reference.
1718 */
1726 }
1727 }
1729 /*
1730 * Callback for scan of ip->rec_tree. Try to include each record in our
1731 * flush. ip->flush_group has been set but the inode has not yet been
1732 * moved into a flushing state.
1733 *
1734 * If we get stuck on a record we have to set HAMMER_INODE_REFLUSH on
1735 * both inodes.
1736 *
1737 * We return 1 for any record placed or found in FST_FLUSH, which prevents
1738 * the caller from shortcutting the flush.
1739 */
1740 static int
1742 {
1743 hammer_flush_group_t flg;
1744 hammer_inode_t target_ip;
1745 hammer_inode_t ip;
1748 /*
1749 * Deleted records are ignored. Note that the flush detects deleted
1750 * front-end records at multiple points to deal with races. This is
1751 * just the first line of defense. The only time DELETED_FE cannot
1752 * be set is when HAMMER_RECF_INTERLOCK_BE is set.
1753 *
1754 * Don't get confused between record deletion and, say, directory
1755 * entry deletion. The deletion of a directory entry that is on
1756 * the media has nothing to do with the record deletion flags.
1757 */
1764 }
1766 }
1768 /*
1769 * If the record is in an idle state it has no dependancies and
1770 * can be flushed.
1771 */
1778 /*
1779 * The record has no setup dependancy, we can flush it.
1780 */
1789 /*
1790 * The record has a setup dependancy. These are typically
1791 * directory entry adds and deletes. Such entries will be
1792 * flushed when their inodes are flushed so we do not
1793 * usually have to add them to the flush here. However,
1794 * if the target_ip has set HAMMER_INODE_CONN_DOWN then
1795 * it is asking us to flush this record (and it).
1796 */
1801 /*
1802 * If the target IP is already flushing in our group
1803 * we are golden, otherwise make sure the target
1804 * reflushes.
1805 */
1815 }
1817 }
1819 /*
1820 * Target IP is not yet flushing. This can get complex
1821 * because we have to be careful about the recursion.
1822 *
1823 * Directories create an issue for us in that if a flush
1824 * of a directory is requested the expectation is to flush
1825 * any pending directory entries, but this will cause the
1826 * related inodes to recursively flush as well. We can't
1827 * really defer the operation so just get as many as we
1828 * can and
1829 */
1830 #if 0
1833 /*
1834 * We aren't reclaiming and the target ip was not
1835 * previously prevented from flushing due to this
1836 * record dependancy. Do not flush this record.
1837 */
1838 /*r = 0;*/
1840 #endif
1843 /*
1844 * Our flush group is over-full and we risk blowing
1845 * out the UNDO FIFO. Stop the scan, flush what we
1846 * have, then reflush the directory.
1847 *
1848 * The directory may be forced through multiple
1849 * flush groups before it can be completely
1850 * flushed.
1851 */
1856 /*
1857 * If the target IP is not flushing we can force
1858 * it to flush, even if it is unable to write out
1859 * any of its own records we have at least one in
1860 * hand that we CAN deal with.
1861 */
1867 HAMMER_FLUSH_RECURSION);
1870 /*
1871 * General or delete-on-disk record.
1872 *
1873 * XXX this needs help. If a delete-on-disk we could
1874 * disconnect the target. If the target has its own
1875 * dependancies they really need to be flushed.
1876 *
1877 * XXX
1878 */
1884 HAMMER_FLUSH_RECURSION);
1886 }
1889 /*
1890 * If the WOULDBLOCK flag is set records may have been left
1891 * over from a previous flush attempt. The flush group will
1892 * have been left intact - we are probably reflushing it
1893 * now.
1894 */
1898 }
1900 }
1902 #if 0
1903 /*
1904 * This version just moves records already in a flush state to the new
1905 * flush group and that is it.
1906 */
1907 static int
1909 {
1918 }
1920 }
1921 #endif
1923 /*
1924 * Wait for a previously queued flush to complete.
1925 */
1926 void
1928 {
1929 hammer_flush_group_t flg;
1934 }
1938 }
1939 }
1941 /*
1942 * Called by the backend code when a flush has been completed.
1943 * The inode has already been removed from the flush list.
1944 *
1945 * A pipelined flush can occur, in which case we must re-enter the
1946 * inode on the list and re-copy its fields.
1947 */
1948 void
1950 {
1951 hammer_mount_t hmp;
1958 /*
1959 * Merge left-over flags back into the frontend and fix the state.
1960 * Incomplete truncations are retained by the backend.
1961 */
1965 /*
1966 * The backend may have adjusted nlinks, so if the adjusted nlinks
1967 * does not match the fronttend set the frontend's RDIRTY flag again.
1968 */
1972 /*
1973 * Fix up the dirty buffer status.
1974 */
1977 }
1979 /*
1980 * Re-set the XDIRTY flag if some of the inode's in-memory records
1981 * could not be flushed.
1982 */
1988 /*
1989 * Do not lose track of inodes which no longer have vnode
1990 * assocations, otherwise they may never get flushed again.
1991 */
1995 /*
1996 * Adjust the flush state.
1997 */
1999 /*
2000 * We were unable to flush out all our records, leave the
2001 * inode in a flush state and in the current flush group.
2002 *
2003 * This occurs if the UNDO block gets too full
2004 * or there is too much dirty meta-data and allows the
2005 * flusher to finalize the UNDO block and then re-flush.
2006 */
2010 /*
2011 * Remove from the flush_group
2012 */
2016 /*
2017 * Clean up the vnode ref and tracking counts.
2018 */
2022 }
2026 /*
2027 * And adjust the state.
2028 */
2035 }
2037 /*
2038 * If the frontend is waiting for a flush to complete,
2039 * wake it up.
2040 */
2044 }
2045 }
2047 /*
2048 * If the frontend made more changes and requested another flush,
2049 * then try to get it running.
2050 */
2058 }
2059 }
2061 /*
2062 * If we have no parent dependancies we can clear CONN_DOWN
2063 */
2067 /*
2068 * If the inode is now clean drop the space reservation.
2069 */
2074 }
2078 }
2080 /*
2081 * Called from hammer_sync_inode() to synchronize in-memory records
2082 * to the media.
2083 */
2084 static int
2086 {
2092 /*
2093 * Skip records that do not belong to the current flush.
2094 */
2099 #if 1
2101 kprintf("sync_record %p ip %p bad flush group %p %p\n", record, record->ip, record->flush_group ,record->ip->flush_group);
2104 }
2105 #endif
2108 /*
2109 * Interlock the record using the BE flag. Once BE is set the
2110 * frontend cannot change the state of FE.
2111 *
2112 * NOTE: If FE is set prior to us setting BE we still sync the
2113 * record out, but the flush completion code converts it to
2114 * a delete-on-disk record instead of destroying it.
2115 */
2119 /*
2120 * The backend may have already disposed of the record.
2121 */
2125 }
2127 /*
2128 * If the whole inode is being deleting all on-disk records will
2129 * be deleted very soon, we can't sync any new records to disk
2130 * because they will be deleted in the same transaction they were
2131 * created in (delete_tid == create_tid), which will assert.
2132 *
2133 * XXX There may be a case with RECORD_ADD with DELETED_FE set
2134 * that we currently panic on.
2135 */
2139 /*
2140 * We don't have to do anything, if the record was
2141 * committed the space will have been accounted for
2142 * in the blockmap.
2143 */
2144 /* fall through */
2159 /*
2160 * Follow through and issue the on-disk deletion
2161 */
2163 }
2164 }
2166 /*
2167 * If DELETED_FE is set special handling is needed for directory
2168 * entries. Dependant pieces related to the directory entry may
2169 * have already been synced to disk. If this occurs we have to
2170 * sync the directory entry and then change the in-memory record
2171 * from an ADD to a DELETE to cover the fact that it's been
2172 * deleted by the frontend.
2173 *
2174 * A directory delete covering record (MEM_RECORD_DEL) can never
2175 * be deleted by the frontend.
2176 *
2177 * Any other record type (aka DATA) can be deleted by the frontend.
2178 * XXX At the moment the flusher must skip it because there may
2179 * be another data record in the flush group for the same block,
2180 * meaning that some frontend data changes can leak into the backend's
2181 * synchronization point.
2182 */
2191 }
2192 }
2194 /*
2195 * Assign the create_tid for new records. Deletions already
2196 * have the record's entire key properly set up.
2197 */
2210 }
2219 }
2220 }
2221 done:
2224 /*
2225 * Do partial finalization if we have built up too many dirty
2226 * buffers. Otherwise a buffer cache deadlock can occur when
2227 * doing things like creating tens of thousands of tiny files.
2228 *
2229 * We must release our cursor lock to avoid a 3-way deadlock
2230 * due to the exclusive sync lock the finalizer must get.
2231 */
2236 }
2239 }
2241 /*
2242 * XXX error handling
2243 */
2244 int
2246 {
2248 hammer_node_t tmp_node;
2249 hammer_record_t depend;
2250 hammer_record_t next;
2252 u_int64_t nlinks;
2261 /*
2262 * Any directory records referencing this inode which are not in
2263 * our current flush group must adjust our nlink count for the
2264 * purposes of synchronization to disk.
2265 *
2266 * Records which are in our flush group can be unlinked from our
2267 * inode now, potentially allowing the inode to be physically
2268 * deleted.
2269 *
2270 * This cannot block.
2271 */
2278 /*
2279 * If this is an ADD that was deleted by the frontend
2280 * the frontend nlinks count will have already been
2281 * decremented, but the backend is going to sync its
2282 * directory entry and must account for it. The
2283 * record will be converted to a delete-on-disk when
2284 * it gets synced.
2285 *
2286 * If the ADD was not deleted by the frontend we
2287 * can remove the dependancy from our target_list.
2288 */
2293 target_entry);
2295 }
2297 /*
2298 * Not part of our flush group
2299 */
2310 }
2311 }
2312 }
2314 /*
2315 * Set dirty if we had to modify the link count.
2316 */
2321 }
2323 /*
2324 * If there is a trunction queued destroy any data past the (aligned)
2325 * truncation point. Userland will have dealt with the buffer
2326 * containing the truncation point for us.
2327 *
2328 * We don't flush pending frontend data buffers until after we've
2329 * dealt with the truncation.
2330 */
2332 /*
2333 * Interlock trunc_off. The VOP front-end may continue to
2334 * make adjustments to it while we are blocked.
2335 */
2336 off_t trunc_off;
2337 off_t aligned_trunc_off;
2344 /*
2345 * Delete any whole blocks on-media. The front-end has
2346 * already cleaned out any partial block and made it
2347 * pending. The front-end may have updated trunc_off
2348 * while we were blocked so we only use sync_trunc_off.
2349 *
2350 * This operation can blow out the buffer cache, EWOULDBLOCK
2351 * means we were unable to complete the deletion. The
2352 * deletion will update sync_trunc_off in that case.
2353 */
2355 aligned_trunc_off,
2361 }
2366 /*
2367 * Clear the truncation flag on the backend after we have
2368 * complete the deletions. Backend data is now good again
2369 * (including new records we are about to sync, below).
2370 *
2371 * Leave sync_trunc_off intact. As we write additional
2372 * records the backend will update sync_trunc_off. This
2373 * tells the backend whether it can skip the overwrite
2374 * test. This should work properly even when the backend
2375 * writes full blocks where the truncation point straddles
2376 * the block because the comparison is against the base
2377 * offset of the record.
2378 */
2380 /* ip->sync_trunc_off = 0x7FFFFFFFFFFFFFFFLL; */
2383 }
2385 /*
2386 * Now sync related records. These will typically be directory
2387 * entries, records tracking direct-writes, or delete-on-disk records.
2388 */
2396 }
2399 /*
2400 * Re-seek for inode update, assuming our cache hasn't been ripped
2401 * out from under us.
2402 */
2412 }
2414 }
2416 /*
2417 * If we are deleting the inode the frontend had better not have
2418 * any active references on elements making up the inode.
2419 *
2420 * The call to hammer_ip_delete_clean() cleans up auxillary records
2421 * but not DB or DATA records. Those must have already been deleted
2422 * by the normal truncation mechanic.
2423 */
2437 /*
2438 * Set delete_tid in both the frontend and backend
2439 * copy of the inode record. The DELETED flag handles
2440 * this, do not set RDIRTY.
2441 */
2448 /*
2449 * Adjust the inode count in the volume header
2450 */
2455 vol0_stat_inodes);
2458 }
2462 }
2463 }
2470 defer_buffer_flush:
2471 /*
2472 * Now update the inode's on-disk inode-data and/or on-disk record.
2473 * DELETED and ONDISK are managed only in ip->flags.
2474 *
2475 * In the case of a defered buffer flush we still update the on-disk
2476 * inode to satisfy visibility requirements if there happen to be
2477 * directory dependancies.
2478 */
2481 /*
2482 * If deleted and on-disk, don't set any additional flags.
2483 * the delete flag takes care of things.
2484 *
2485 * Clear flags which may have been set by the frontend.
2486 */
2489 HAMMER_INODE_DELETING);
2492 /*
2493 * Take care of the case where a deleted inode was never
2494 * flushed to the disk in the first place.
2495 *
2496 * Clear flags which may have been set by the frontend.
2497 */
2500 HAMMER_INODE_DELETING);
2508 }
2511 /*
2512 * If already on-disk, do not set any additional flags.
2513 */
2516 /*
2517 * If not on-disk and not deleted, set DDIRTY to force
2518 * an initial record to be written.
2519 *
2520 * Also set the create_tid in both the frontend and backend
2521 * copy of the inode record.
2522 */
2529 }
2531 /*
2532 * If RDIRTY or DDIRTY is set, write out a new record. If the inode
2533 * is already on-disk the old record is marked as deleted.
2534 *
2535 * If DELETED is set hammer_update_inode() will delete the existing
2536 * record without writing out a new one.
2537 *
2538 * If *ONLY* the ITIMES flag is set we can update the record in-place.
2539 */
2549 }
2552 done:
2553 /*
2554 * Save the TID we used to sync the inode with to make sure we
2555 * do not improperly reuse it.
2556 */
2559 }
2561 /*
2562 * This routine is called when the OS is no longer actively referencing
2563 * the inode (but might still be keeping it cached), or when releasing
2564 * the last reference to an inode.
2565 *
2566 * At this point if the inode's nlinks count is zero we want to destroy
2567 * it, which may mean destroying it on-media too.
2568 */
2569 void
2571 {
2574 /*
2575 * Set the DELETING flag when the link count drops to 0 and the
2576 * OS no longer has any opens on the inode.
2577 *
2578 * The backend will clear DELETING (a mod flag) and set DELETED
2579 * (a state flag) when it is actually able to perform the
2580 * operation.
2581 */
2591 }
2593 /*
2594 * Final cleanup
2595 */
2599 }
2602 }
2603 }
2604 }
2606 /*
2607 * After potentially resolving a dependancy the inode is tested
2608 * to determine whether it needs to be reflushed.
2609 */
2610 void
2612 {
2621 }
2623 }
2624 }
2626 /*
2627 * Clear the RECLAIM flag on an inode. This occurs when the inode is
2628 * reassociated with a vp or just before it gets freed.
2629 *
2630 * Wakeup one thread blocked waiting on reclaims to complete. Note that
2631 * the inode the thread is waiting on behalf of is a different inode then
2632 * the inode we are called with. This is to create a pipeline.
2633 */
2634 static void
2636 {
2651 }
2652 }
2654 /*
2655 * Setup our reclaim pipeline. We only let so many detached (and dirty)
2656 * inodes build up before we start blocking.
2657 *
2658 * When we block we don't care *which* inode has finished reclaiming,
2659 * as lone as one does. This is somewhat heuristical... we also put a
2660 * cap on how long we are willing to wait.
2661 */
2662 void
2664 {
2674 }
2678 HAMMER_RECLAIM_WAIT;
2683 }
2684 }