| blob | bdbc00b56beacd2d9ca9d0c548855f3d7898ab9c |
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.75 2008/06/14 01:42:13 dillon Exp $
35 */
38 #include <vm/vm_extern.h>
39 #include <sys/buf.h>
40 #include <sys/buf2.h>
49 #ifdef DEBUG_TRUNCATE
51 #endif
53 /*
54 * The kernel is not actively referencing this vnode but is still holding
55 * it cached.
56 *
57 * This is called from the frontend.
58 */
59 int
61 {
64 /*
65 * Degenerate case
66 */
70 }
72 /*
73 * If the inode no longer has visibility in the filesystem and is
74 * fairly clean, try to recycle it immediately. This can deadlock
75 * in vfsync() if we aren't careful.
76 *
77 * Do not queue the inode to the flusher if we still have visibility,
78 * otherwise namespace calls such as chmod will unnecessarily generate
79 * multiple inode updates.
80 */
85 else
87 }
89 }
91 /*
92 * Release the vnode association. This is typically (but not always)
93 * the last reference on the inode.
94 *
95 * Once the association is lost we are on our own with regards to
96 * flushing the inode.
97 */
98 int
100 {
103 hammer_mount_t hmp;
114 /*
115 * Setup our reclaim pipeline. We only let so many detached
116 * (and dirty) inodes build up before we start blocking. Do
117 * not bother tracking the immediate increment/decrement if
118 * the inode is not actually dirty.
119 *
120 * When we block we don't care *which* inode has finished
121 * reclaiming, as lone as one does.
122 */
134 }
137 }
140 /*
141 * Reclaim pipeline. We can't let too many reclaimed inodes
142 * build-up in the flusher or the flusher loses its locality
143 * of reference, or worse blows out our memory. Once we have
144 * exceeded the reclaim pipe size start slowing down. Our
145 * imposed delay can be cut short if the flusher catches up
146 * to us.
147 */
151 HAMMER_RECLAIM_PIPESIZE;
157 }
160 entry);
161 }
162 }
163 }
165 }
167 /*
168 * Return a locked vnode for the specified inode. The inode must be
169 * referenced but NOT LOCKED on entry and will remain referenced on
170 * return.
171 *
172 * Called from the frontend.
173 */
174 int
176 {
177 hammer_mount_t hmp;
194 }
215 }
217 /*
218 * Only mark as the root vnode if the ip is not
219 * historical, otherwise the VFS cache will get
220 * confused. The other half of the special handling
221 * is in hammer_vop_nlookupdotdot().
222 */
226 }
229 /* vnode locked by getnewvnode() */
230 /* make related vnode dirty if inode dirty? */
235 }
237 /*
238 * loop if the vget fails (aka races), or if the vp
239 * no longer matches ip->vp.
240 */
245 }
246 }
249 }
251 /*
252 * Acquire a HAMMER inode. The returned inode is not locked. These functions
253 * do not attach or detach the related vnode (use hammer_get_vnode() for
254 * that).
255 *
256 * The flags argument is only applied for newly created inodes, and only
257 * certain flags are inherited.
258 *
259 * Called from the frontend.
260 */
264 {
270 /*
271 * Determine if we already have an inode cached. If we do then
272 * we are golden.
273 */
276 loop:
282 }
284 /*
285 * Allocate a new inode structure and deal with races later.
286 */
300 /*
301 * Locate the on-disk inode.
302 */
303 retry:
314 HAMMER_CURSOR_ASOF;
320 }
322 /*
323 * On success the B-Tree lookup will hold the appropriate
324 * buffer cache buffers and provide a pointer to the requested
325 * information. Copy the information to the in-memory inode
326 * and cache the B-Tree node to improve future operations.
327 */
334 }
336 /*
337 * On success load the inode's record and data and insert the
338 * inode into the B-Tree. It is possible to race another lookup
339 * insertion of the same inode so deal with that condition too.
340 *
341 * The cursor's locked node interlocks against others creating and
342 * destroying ip while we were blocked.
343 */
355 }
358 /*
359 * Do not panic on read-only accesses which fail, particularly
360 * historical accesses where the snapshot might not have
361 * complete connectivity.
362 */
367 }
371 }
379 }
382 }
384 /*
385 * Create a new filesystem object, returning the inode in *ipp. The
386 * returned inode will be referenced.
387 *
388 * The inode is created in-memory.
389 */
390 int
394 {
395 hammer_mount_t hmp;
396 hammer_inode_t ip;
397 uid_t xuid;
419 /*
420 * A nohistory designator on the parent directory is inherited by
421 * the child.
422 */
449 }
451 /*
452 * Calculate default uid/gid and overwrite with information from
453 * the vap.
454 */
464 else
471 else
478 }
481 }
483 /*
484 * Called by hammer_sync_inode().
485 */
486 static int
488 {
490 hammer_record_t record;
493 retry:
496 /*
497 * If the inode has a presence on-disk then locate it and mark
498 * it deleted, setting DELONDISK.
499 *
500 * The record may or may not be physically deleted, depending on
501 * the retention policy.
502 */
504 HAMMER_INODE_ONDISK) {
524 }
533 }
536 }
539 }
548 }
549 }
551 /*
552 * Ok, write out the initial record or a new record (after deleting
553 * the old one), unless the DELETED flag is set. This routine will
554 * clear DELONDISK if it writes out a record.
555 *
556 * Update our inode statistics if this is the first application of
557 * the inode on-disk.
558 */
560 /*
561 * Generate a record and write it to the media
562 */
585 }
589 }
591 /*
592 * The record isn't managed by the inode's record tree,
593 * destroy it whether we succeed or fail.
594 */
600 /*
601 * Finish up.
602 */
607 HAMMER_INODE_ITIMES);
610 /*
611 * Root volume count of inodes
612 */
616 vol0_stat_inodes);
622 }
623 }
624 }
626 /*
627 * If the inode has been destroyed, clean out any left-over flags
628 * that may have been set by the frontend.
629 */
632 HAMMER_INODE_ITIMES);
633 }
635 }
637 /*
638 * Update only the itimes fields. This is done no-historically. The
639 * record is updated in-place on the disk.
640 */
641 static int
643 {
648 retry:
651 HAMMER_INODE_ONDISK) {
669 }
671 /*
672 * Do not generate UNDO records for atime updates.
673 */
679 /*rec->ino_mtime = ip->sync_ino_rec.ino_mtime;*/
681 /* XXX recalculate crc */
683 }
690 }
691 }
693 }
695 /*
696 * Release a reference on an inode, flush as requested.
697 *
698 * On the last reference we queue the inode to the flusher for its final
699 * disposition.
700 */
701 void
703 {
706 /*
707 * Handle disposition when dropping the last ref.
708 */
711 /*
712 * Determine whether on-disk action is needed for
713 * the inode's final disposition.
714 */
720 HAMMER_FLUSH_SIGNAL);
723 }
727 }
732 /*
733 * The inode still has multiple refs, try to drop
734 * one ref.
735 */
740 }
741 }
742 }
743 }
745 /*
746 * Unload and destroy the specified inode. Must be called with one remaining
747 * reference. The reference is disposed of.
748 *
749 * This can only be called in the context of the flusher.
750 */
751 static int
753 {
780 }
782 /*
783 * Called on mount -u when switching from RW to RO or vise-versa. Adjust
784 * the read-only flag for cached inodes.
785 *
786 * This routine is called from a RB_SCAN().
787 */
788 int
790 {
795 else
798 }
800 /*
801 * A transaction has modified an inode, requiring updates as specified by
802 * the passed flags.
803 *
804 * HAMMER_INODE_DDIRTY: Inode data has been updated
805 * HAMMER_INODE_XDIRTY: Dirty in-memory records
806 * HAMMER_INODE_BUFS: Dirty buffer cache buffers
807 * HAMMER_INODE_DELETED: Inode record/data must be deleted
808 * HAMMER_INODE_ITIMES: mtime/atime has been updated
809 */
810 void
812 {
820 }
823 }
825 /*
826 * Request that an inode be flushed. This whole mess cannot block and may
827 * recurse (if not synchronous). Once requested HAMMER will attempt to
828 * actively flush the inode until the flush can be done.
829 *
830 * The inode may already be flushing, or may be in a setup state. We can
831 * place the inode in a flushing state if it is currently idle and flag it
832 * to reflush if it is currently flushing.
833 *
834 * If the HAMMER_FLUSH_SYNCHRONOUS flag is specified we will attempt to
835 * flush the indoe synchronously using the caller's context.
836 */
837 void
839 {
842 /*
843 * Trivial 'nothing to flush' case. If the inode is ina SETUP
844 * state we have to put it back into an IDLE state so we can
845 * drop the extra ref.
846 */
851 }
853 }
855 /*
856 * Our flush action will depend on the current state.
857 */
860 /*
861 * We have no dependancies and can flush immediately. Some
862 * our children may not be flushable so we have to re-test
863 * with that additional knowledge.
864 */
868 /*
869 * Recurse upwards through dependancies via target_list
870 * and start their flusher actions going if possible.
871 *
872 * 'good' is our connectivity. -1 means we have none and
873 * can't flush, 0 means there weren't any dependancies, and
874 * 1 means we have good connectivity.
875 */
878 /*
879 * We can continue if good >= 0. Determine how many records
880 * under our inode can be flushed (and mark them).
881 */
889 }
890 }
893 /*
894 * We are already flushing, flag the inode to reflush
895 * if needed after it completes its current flush.
896 */
902 }
904 }
905 }
907 /*
908 * Scan ip->target_list, which is a list of records owned by PARENTS to our
909 * ip which reference our ip.
910 *
911 * XXX This is a huge mess of recursive code, but not one bit of it blocks
912 * so for now do not ref/deref the structures. Note that if we use the
913 * ref/rel code later, the rel CAN block.
914 */
915 static int
917 {
918 hammer_record_t depend;
919 #if 0
920 hammer_record_t next;
921 hammer_inode_t pip;
922 #endif
934 }
937 #if 0
938 retry:
944 }
951 }
957 }
966 }
968 #endif
969 }
971 /*
972 * This helper function takes a record representing the dependancy between
973 * the parent inode and child inode.
974 *
975 * record->ip = parent inode
976 * record->target_ip = child inode
977 *
978 * We are asked to recurse upwards and convert the record from SETUP
979 * to FLUSH if possible.
980 *
981 * Return 1 if the record gives us connectivity
982 *
983 * Return 0 if the record is not relevant
984 *
985 * Return -1 if we can't resolve the dependancy and there is no connectivity.
986 */
987 static int
989 {
990 hammer_mount_t hmp;
991 hammer_inode_t pip;
998 /*
999 * If the record is already flushing, is it in our flush group?
1000 *
1001 * If it is in our flush group but it is a general record or a
1002 * delete-on-disk, it does not improve our connectivity (return 0),
1003 * and if the target inode is not trying to destroy itself we can't
1004 * allow the operation yet anyway (the second return -1).
1005 */
1010 }
1013 /* GENERAL or DEL */
1015 }
1017 /*
1018 * It must be a setup record. Try to resolve the setup dependancies
1019 * by recursing upwards so we can place ip on the flush list.
1020 */
1025 /*
1026 * We can't flush ip because it has no connectivity (XXX also check
1027 * nlinks for pre-existing connectivity!). Flag it so any resolution
1028 * recurses back down.
1029 */
1033 }
1035 /*
1036 * We are go, place the parent inode in a flushing state so we can
1037 * place its record in a flushing state. Note that the parent
1038 * may already be flushing. The record must be in the same flush
1039 * group as the parent.
1040 */
1046 #if 0
1049 /*
1050 * Regardless of flushing state we cannot sync this path if the
1051 * record represents a delete-on-disk but the target inode
1052 * is not ready to sync its own deletion.
1053 *
1054 * XXX need to count effective nlinks to determine whether
1055 * the flush is ok, otherwise removing a hardlink will
1056 * just leave the DEL record to rot.
1057 */
1061 #endif
1063 /*
1064 * This is the record we wanted to synchronize. If the
1065 * record went into a flush state while we blocked it
1066 * had better be in the correct flush group.
1067 */
1074 }
1078 /*
1079 * A general or delete-on-disk record does not contribute
1080 * to our visibility. We can still flush it, however.
1081 */
1084 /*
1085 * We couldn't resolve the dependancies, request that the
1086 * inode be flushed when the dependancies can be resolved.
1087 */
1090 }
1091 }
1093 /*
1094 * This is the core routine placing an inode into the FST_FLUSH state.
1095 */
1096 static void
1098 {
1101 /*
1102 * Set flush state and prevent the flusher from cycling into
1103 * the next flush group. Do not place the ip on the list yet.
1104 * Inodes not in the idle state get an extra reference.
1105 */
1115 /*
1116 * We need to be able to vfsync/truncate from the backend.
1117 */
1122 }
1124 /*
1125 * Figure out how many in-memory records we can actually flush
1126 * (not including inode meta-data, buffers, etc).
1127 */
1133 }
1135 /*
1136 * This is a more involved test that includes go_count. If we
1137 * can't flush, flag the inode and return. If go_count is 0 we
1138 * were are unable to flush any records in our rec_tree and
1139 * must ignore the XDIRTY flag.
1140 */
1152 }
1156 }
1160 }
1161 }
1163 /*
1164 * Snapshot the state of the inode for the backend flusher.
1165 *
1166 * The truncation must be retained in the frontend until after
1167 * we've actually performed the record deletion.
1168 *
1169 * NOTE: The DELETING flag is a mod flag, but it is also sticky,
1170 * and stays in ip->flags. Once set, it stays set until the
1171 * inode is destroyed.
1172 */
1179 #ifdef DEBUG_TRUNCATE
1182 #endif
1184 /*
1185 * The flusher list inherits our inode and reference.
1186 */
1193 }
1194 }
1196 /*
1197 * Callback for scan of ip->rec_tree. Try to include each record in our
1198 * flush. ip->flush_group has been set but the inode has not yet been
1199 * moved into a flushing state.
1200 *
1201 * If we get stuck on a record we have to set HAMMER_INODE_REFLUSH on
1202 * both inodes.
1203 *
1204 * We return 1 for any record placed or found in FST_FLUSH, which prevents
1205 * the caller from shortcutting the flush.
1206 */
1207 static int
1209 {
1210 hammer_inode_t target_ip;
1211 hammer_inode_t ip;
1214 /*
1215 * Deleted records are ignored. Note that the flush detects deleted
1216 * front-end records at multiple points to deal with races. This is
1217 * just the first line of defense. The only time DELETED_FE cannot
1218 * be set is when HAMMER_RECF_INTERLOCK_BE is set.
1219 *
1220 * Don't get confused between record deletion and, say, directory
1221 * entry deletion. The deletion of a directory entry that is on
1222 * the media has nothing to do with the record deletion flags.
1223 */
1227 /*
1228 * If the record is in an idle state it has no dependancies and
1229 * can be flushed.
1230 */
1236 /*
1237 * Record has no setup dependancy, we can flush it.
1238 */
1246 /*
1247 * Record has a setup dependancy. Try to include the
1248 * target ip in the flush.
1249 *
1250 * We have to be careful here, if we do not do the right
1251 * thing we can lose track of dirty inodes and the system
1252 * will lockup trying to allocate buffers.
1253 */
1258 /*
1259 * If the target IP is already flushing in our group
1260 * we are golden, otherwise make sure the target
1261 * reflushes.
1262 */
1270 }
1272 /*
1273 * If the target IP is not flushing we can force
1274 * it to flush, even if it is unable to write out
1275 * any of its own records we have at least one in
1276 * hand that we CAN deal with.
1277 */
1282 HAMMER_FLUSH_RECURSION);
1285 /*
1286 * General or delete-on-disk record.
1287 *
1288 * XXX this needs help. If a delete-on-disk we could
1289 * disconnect the target. If the target has its own
1290 * dependancies they really need to be flushed.
1291 *
1292 * XXX
1293 */
1298 HAMMER_FLUSH_RECURSION);
1300 }
1303 /*
1304 * Record already associated with a flush group. It had
1305 * better be ours.
1306 */
1310 }
1312 }
1314 /*
1315 * Wait for a previously queued flush to complete
1316 */
1317 void
1319 {
1326 }
1327 }
1328 }
1330 /*
1331 * Wait for records to drain
1332 */
1333 void
1335 {
1341 }
1342 }
1343 }
1345 /*
1346 * Called by the backend code when a flush has been completed.
1347 * The inode has already been removed from the flush list.
1348 *
1349 * A pipelined flush can occur, in which case we must re-enter the
1350 * inode on the list and re-copy its fields.
1351 */
1352 void
1354 {
1355 hammer_mount_t hmp;
1362 /*
1363 * Merge left-over flags back into the frontend and fix the state.
1364 */
1367 /*
1368 * The backend may have adjusted nlinks, so if the adjusted nlinks
1369 * does not match the fronttend set the frontend's RDIRTY flag again.
1370 */
1374 /*
1375 * Fix up the dirty buffer status. IO completions will also
1376 * try to clean up rsv_databufs.
1377 */
1383 }
1385 /*
1386 * Re-set the XDIRTY flag if some of the inode's in-memory records
1387 * could not be flushed.
1388 */
1394 /*
1395 * Do not lose track of inodes which no longer have vnode
1396 * assocations, otherwise they may never get flushed again.
1397 */
1401 /*
1402 * Adjust flush_state. The target state (idle or setup) shouldn't
1403 * be terribly important since we will reflush if we really need
1404 * to do anything. XXX
1405 */
1412 }
1417 /*
1418 * Clean up the vnode ref
1419 */
1423 }
1425 /*
1426 * If the frontend made more changes and requested another flush,
1427 * then try to get it running.
1428 */
1436 }
1437 }
1439 /*
1440 * If the inode is now clean drop the space reservation.
1441 */
1446 }
1448 /*
1449 * Finally, if the frontend is waiting for a flush to complete,
1450 * wake it up.
1451 */
1456 }
1457 }
1460 }
1462 /*
1463 * Called from hammer_sync_inode() to synchronize in-memory records
1464 * to the media.
1465 */
1466 static int
1468 {
1473 /*
1474 * Skip records that do not belong to the current flush.
1475 */
1480 #if 1
1482 kprintf("sync_record %p ip %p bad flush group %d %d\n", record, record->ip, record->flush_group ,record->ip->flush_group);
1485 }
1486 #endif
1489 /*
1490 * Interlock the record using the BE flag. Once BE is set the
1491 * frontend cannot change the state of FE.
1492 *
1493 * NOTE: If FE is set prior to us setting BE we still sync the
1494 * record out, but the flush completion code converts it to
1495 * a delete-on-disk record instead of destroying it.
1496 */
1500 /*
1501 * The backend may have already disposed of the record.
1502 */
1506 }
1508 /*
1509 * If the whole inode is being deleting all on-disk records will
1510 * be deleted very soon, we can't sync any new records to disk
1511 * because they will be deleted in the same transaction they were
1512 * created in (delete_tid == create_tid), which will assert.
1513 *
1514 * XXX There may be a case with RECORD_ADD with DELETED_FE set
1515 * that we currently panic on.
1516 */
1520 /*
1521 * We don't have to do anything, if the record was
1522 * committed the space will have been accounted for
1523 * in the blockmap.
1524 */
1525 /* fall through */
1540 /*
1541 * Follow through and issue the on-disk deletion
1542 */
1544 }
1545 }
1547 /*
1548 * If DELETED_FE is set special handling is needed for directory
1549 * entries. Dependant pieces related to the directory entry may
1550 * have already been synced to disk. If this occurs we have to
1551 * sync the directory entry and then change the in-memory record
1552 * from an ADD to a DELETE to cover the fact that it's been
1553 * deleted by the frontend.
1554 *
1555 * A directory delete covering record (MEM_RECORD_DEL) can never
1556 * be deleted by the frontend.
1557 *
1558 * Any other record type (aka DATA) can be deleted by the frontend.
1559 * XXX At the moment the flusher must skip it because there may
1560 * be another data record in the flush group for the same block,
1561 * meaning that some frontend data changes can leak into the backend's
1562 * synchronization point.
1563 */
1572 }
1573 }
1575 /*
1576 * Assign the create_tid for new records. Deletions already
1577 * have the record's entire key properly set up.
1578 */
1590 }
1599 }
1600 }
1601 done:
1604 }
1606 /*
1607 * XXX error handling
1608 */
1609 int
1611 {
1614 hammer_record_t depend;
1615 hammer_record_t next;
1617 u_int64_t nlinks;
1627 /*
1628 * Any directory records referencing this inode which are not in
1629 * our current flush group must adjust our nlink count for the
1630 * purposes of synchronization to disk.
1631 *
1632 * Records which are in our flush group can be unlinked from our
1633 * inode now, potentially allowing the inode to be physically
1634 * deleted.
1635 *
1636 * This cannot block.
1637 */
1644 /*
1645 * If this is an ADD that was deleted by the frontend
1646 * the frontend nlinks count will have already been
1647 * decremented, but the backend is going to sync its
1648 * directory entry and must account for it. The
1649 * record will be converted to a delete-on-disk when
1650 * it gets synced.
1651 *
1652 * If the ADD was not deleted by the frontend we
1653 * can remove the dependancy from our target_list.
1654 */
1659 target_entry);
1661 }
1663 /*
1664 * Not part of our flush group
1665 */
1676 }
1677 }
1678 }
1680 /*
1681 * Set dirty if we had to modify the link count.
1682 */
1687 }
1689 /*
1690 * If there is a trunction queued destroy any data past the (aligned)
1691 * truncation point. Userland will have dealt with the buffer
1692 * containing the truncation point for us.
1693 *
1694 * We don't flush pending frontend data buffers until after we've
1695 * dealth with the truncation.
1696 *
1697 * Don't bother if the inode is or has been deleted.
1698 */
1700 /*
1701 * Interlock trunc_off. The VOP front-end may continue to
1702 * make adjustments to it while we are blocked.
1703 */
1704 off_t trunc_off;
1705 off_t aligned_trunc_off;
1711 /*
1712 * Delete any whole blocks on-media. The front-end has
1713 * already cleaned out any partial block and made it
1714 * pending. The front-end may have updated trunc_off
1715 * while we were blocked so we only use sync_trunc_off.
1716 */
1718 aligned_trunc_off,
1723 /*
1724 * Clear the truncation flag on the backend after we have
1725 * complete the deletions. Backend data is now good again
1726 * (including new records we are about to sync, below).
1727 */
1732 }
1734 /*
1735 * Now sync related records. These will typically be directory
1736 * entries or delete-on-disk records.
1737 *
1738 * Not all records will be flushed, but clear XDIRTY anyway. We
1739 * will set it again in the frontend hammer_flush_inode_done()
1740 * if records remain.
1741 */
1749 }
1751 /*
1752 * If we are deleting the inode the frontend had better not have
1753 * any active references on elements making up the inode.
1754 */
1768 /*
1769 * Set delete_tid in both the frontend and backend
1770 * copy of the inode record. The DELETED flag handles
1771 * this, do not set RDIRTY.
1772 */
1776 /*
1777 * Adjust the inode count in the volume header
1778 */
1782 vol0_stat_inodes);
1785 }
1789 }
1790 }
1797 /*
1798 * Now update the inode's on-disk inode-data and/or on-disk record.
1799 * DELETED and ONDISK are managed only in ip->flags.
1800 */
1803 /*
1804 * If deleted and on-disk, don't set any additional flags.
1805 * the delete flag takes care of things.
1806 *
1807 * Clear flags which may have been set by the frontend.
1808 */
1811 HAMMER_INODE_DELETING);
1814 /*
1815 * Take care of the case where a deleted inode was never
1816 * flushed to the disk in the first place.
1817 *
1818 * Clear flags which may have been set by the frontend.
1819 */
1822 HAMMER_INODE_DELETING);
1830 }
1833 /*
1834 * If already on-disk, do not set any additional flags.
1835 */
1838 /*
1839 * If not on-disk and not deleted, set both dirty flags
1840 * to force an initial record to be written. Also set
1841 * the create_tid for the inode.
1842 *
1843 * Set create_tid in both the frontend and backend
1844 * copy of the inode record.
1845 */
1850 }
1852 /*
1853 * If RDIRTY or DDIRTY is set, write out a new record. If the inode
1854 * is already on-disk the old record is marked as deleted.
1855 *
1856 * If DELETED is set hammer_update_inode() will delete the existing
1857 * record without writing out a new one.
1858 *
1859 * If *ONLY* the ITIMES flag is set we can update the record in-place.
1860 */
1865 HAMMER_INODE_ITIMES) {
1870 }
1873 done:
1874 /*
1875 * Save the TID we used to sync the inode with to make sure we
1876 * do not improperly reuse it.
1877 */
1881 }
1883 /*
1884 * This routine is called when the OS is no longer actively referencing
1885 * the inode (but might still be keeping it cached), or when releasing
1886 * the last reference to an inode.
1887 *
1888 * At this point if the inode's nlinks count is zero we want to destroy
1889 * it, which may mean destroying it on-media too.
1890 */
1891 void
1893 {
1896 /*
1897 * Set the DELETING flag when the link count drops to 0 and the
1898 * OS no longer has any opens on the inode.
1899 *
1900 * The backend will clear DELETING (a mod flag) and set DELETED
1901 * (a state flag) when it is actually able to perform the
1902 * operation.
1903 */
1913 }
1915 /*
1916 * Final cleanup
1917 */
1921 }
1924 }
1925 }
1926 }
1928 /*
1929 * Re-test an inode when a dependancy had gone away to see if we
1930 * can chain flush it.
1931 */
1932 void
1934 {
1943 }
1945 }
1946 }
1948 /*
1949 * Clear the RECLAIM flag on an inode. This occurs when the inode is
1950 * reassociated with a vp or just before it gets freed.
1951 *
1952 * Wakeup one thread blocked waiting on reclaims to complete. Note that
1953 * the inode the thread is waiting on behalf of is a different inode then
1954 * the inode we are called with. This is to create a pipeline.
1955 */
1956 static void
1958 {
1973 }
1974 }