| blob | ea0969b7f79764989a0e694a966dbe5a93368115 |
1 /*
2 * Copyright 1998, 2000 Marshall Kirk McKusick. All Rights Reserved.
3 *
4 * The soft updates code is derived from the appendix of a University
5 * of Michigan technical report (Gregory R. Ganger and Yale N. Patt,
6 * "Soft Updates: A Solution to the Metadata Update Problem in File
7 * Systems", CSE-TR-254-95, August 1995).
8 *
9 * Further information about soft updates can be obtained from:
10 *
11 * Marshall Kirk McKusick http://www.mckusick.com/softdep/
12 * 1614 Oxford Street mckusick@mckusick.com
13 * Berkeley, CA 94709-1608 +1-510-843-9542
14 * USA
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 *
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY MARSHALL KIRK MCKUSICK ``AS IS'' AND ANY
27 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29 * DISCLAIMED. IN NO EVENT SHALL MARSHALL KIRK MCKUSICK BE LIABLE FOR
30 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 *
38 * from: @(#)ffs_softdep.c 9.59 (McKusick) 6/21/00
39 * $FreeBSD: src/sys/ufs/ffs/ffs_softdep.c,v 1.57.2.11 2002/02/05 18:46:53 dillon Exp $
40 * $DragonFly: src/sys/vfs/ufs/ffs_softdep.c,v 1.52 2007/08/13 17:31:56 dillon Exp $
41 */
43 /*
44 * For now we want the safety net that the DIAGNOSTIC and DEBUG flags provide.
45 */
46 #ifndef DIAGNOSTIC
47 #define DIAGNOSTIC
48 #endif
49 #ifndef DEBUG
50 #define DEBUG
51 #endif
53 #include <sys/param.h>
54 #include <sys/kernel.h>
55 #include <sys/systm.h>
56 #include <sys/buf.h>
57 #include <sys/malloc.h>
58 #include <sys/mount.h>
59 #include <sys/proc.h>
60 #include <sys/syslog.h>
61 #include <sys/vnode.h>
62 #include <sys/conf.h>
63 #include <sys/buf2.h>
64 #include <machine/inttypes.h>
74 #include <sys/thread2.h>
76 /*
77 * These definitions need to be adapted to the system to which
78 * this file is being ported.
79 */
80 /*
81 * malloc types defined for the softdep system.
82 */
97 #define M_SOFTDEP_FLAGS (M_WAITOK | M_USE_RESERVE)
99 #define D_PAGEDEP 0
100 #define D_INODEDEP 1
101 #define D_NEWBLK 2
102 #define D_BMSAFEMAP 3
103 #define D_ALLOCDIRECT 4
104 #define D_INDIRDEP 5
105 #define D_ALLOCINDIR 6
106 #define D_FREEFRAG 7
107 #define D_FREEBLKS 8
108 #define D_FREEFILE 9
109 #define D_DIRADD 10
110 #define D_MKDIR 11
111 #define D_DIRREM 12
112 #define D_LAST D_DIRREM
114 /*
115 * translate from workitem type to memory type
116 * MUST match the defines above, such that memtype[D_XXX] == M_XXX
117 */
119 M_PAGEDEP,
120 M_INODEDEP,
121 M_NEWBLK,
122 M_BMSAFEMAP,
123 M_ALLOCDIRECT,
124 M_INDIRDEP,
125 M_ALLOCINDIR,
126 M_FREEFRAG,
127 M_FREEBLKS,
128 M_FREEFILE,
129 M_DIRADD,
130 M_MKDIR,
131 M_DIRREM
132 };
134 #define DtoM(type) (memtype[type])
136 /*
137 * Names of malloc types.
138 */
139 #define TYPENAME(type) \
141 /*
142 * End system adaptaion definitions.
143 */
145 /*
146 * Internal function prototypes.
147 */
181 ufs_daddr_t);
197 /*
198 * Exported softdep operations.
199 */
216 };
218 /*
219 * Locking primitives.
220 *
221 * For a uniprocessor, all we need to do is protect against disk
222 * interrupts. For a multiprocessor, this lock would have to be
223 * a mutex. A single mutex is used throughout this file, though
224 * finer grain locking could be used if contention warranted it.
225 *
226 * For a multiprocessor, the sleep call would accept a lock and
227 * release it after the sleep processing was complete. In a uniprocessor
228 * implementation there is no such interlock, so we simple mark
229 * the places where it needs to be done with the `interlocked' form
230 * of the lock calls. Since the uniprocessor sleep already interlocks
231 * the spl, there is nothing that really needs to be done.
232 */
240 #define NOHOLDER ((struct thread *)-1)
241 #define SPECIAL_FLAG ((struct thread *)-2)
252 #define ACQUIRE_LOCK(lk) acquire_lock(lk)
253 #define FREE_LOCK(lk) free_lock(lk)
255 static void
257 {
258 thread_t holder;
265 else
267 }
270 lockcnt++;
271 }
273 static void
275 {
281 }
283 /*
284 * Function to release soft updates lock and panic.
285 */
286 void
288 {
293 }
299 /*
300 * When going to sleep, we must save our SPL so that it does
301 * not get lost if some other process uses the lock while we
302 * are sleeping. We restore it after we have slept. This routine
303 * wraps the interlocking with functions that sleep. The list
304 * below enumerates the available set of operations.
305 */
306 #define UNKNOWN 0
307 #define SLEEP 1
308 #define LOCKBUF 2
310 static int
313 {
314 thread_t holder;
318 # ifdef DEBUG
332 }
333 # ifdef DEBUG
339 else
341 }
343 lockcnt++;
347 }
349 /*
350 * Place holder for real semaphores.
351 */
354 thread_t holder;
358 };
363 static void
365 {
372 }
374 static int
376 {
386 }
388 }
393 }
395 static void
397 {
403 }
407 }
409 }
411 /*
412 * Worklist queue management.
413 * These routines require that the lock be held.
414 */
416 #define WORKLIST_INSERT(head, item) do { \
417 (item)->wk_state |= ONWORKLIST; \
418 LIST_INSERT_HEAD(head, item, wk_list); \
419 } while (0)
420 #define WORKLIST_REMOVE(item) do { \
421 (item)->wk_state &= ~ONWORKLIST; \
422 LIST_REMOVE(item, wk_list); \
423 } while (0)
424 #define WORKITEM_FREE(item, type) FREE(item, DtoM(type))
431 #define WORKLIST_INSERT(head, item) worklist_insert(head, item)
432 #define WORKLIST_REMOVE(item) worklist_remove(item)
433 #define WORKITEM_FREE(item, type) workitem_free((struct worklist *)item, type)
435 static void
437 {
444 }
447 }
449 static void
451 {
458 }
461 }
463 static void
465 {
471 }
476 }
478 }
481 /*
482 * Workitem queue management
483 */
495 #define FLUSH_INODES 1
497 #define FLUSH_REMOVE 2
498 /*
499 * runtime statistics
500 */
511 #ifdef DEBUG
512 #include <vm/vm.h>
513 #include <sys/sysctl.h>
528 /*
529 * Add an item to the end of the work queue.
530 * This routine requires that the lock be held.
531 * This is the only routine that adds items to the list.
532 * The following routine is the only one that removes items
533 * and does so in order from first to last.
534 */
535 static void
537 {
544 }
548 else
552 }
554 /*
555 * Process that runs once per second to handle items in the background queue.
556 *
557 * Note that we ensure that everything is done in the order in which they
558 * appear in the queue. The code below depends on this property to ensure
559 * that blocks of a file are freed before the inode itself is freed. This
560 * ordering ensures that no new <vfsid, inum, lbn> triples will be generated
561 * until all the old ones have been purged from the dependency lists.
562 */
563 static int
565 {
570 /*
571 * Record the process identifier of our caller so that we can give
572 * this process preferential treatment in request_cleanup below.
573 */
577 /*
578 * There is no danger of having multiple processes run this
579 * code, but we have to single-thread it when softdep_flushfiles()
580 * is in operation to get an accurate count of the number of items
581 * related to its mount point that are in the list.
582 */
587 }
589 /*
590 * If requested, try removing inode or removal dependencies.
591 */
596 }
601 }
607 /*
608 * If a umount operation wants to run the worklist
609 * accurately, abort.
610 */
614 }
616 /*
617 * If requested, try removing inode or removal dependencies.
618 */
623 }
628 }
629 /*
630 * We do not generally want to stop for buffer space, but if
631 * we are really being a buffer hog, we will stop and wait.
632 */
635 /*
636 * Never allow processing to run for more than one
637 * second. Otherwise the other syncer tasks may get
638 * excessively backlogged.
639 */
643 }
644 }
649 }
651 }
653 /*
654 * Process one item on the worklist.
655 */
656 static int
658 {
669 /*
670 * Normally we just process each item on the worklist in order.
671 * However, if we are in a situation where we cannot lock any
672 * inodes, we have to skip over any dirrem requests whose
673 * vnodes are resident and locked.
674 */
683 }
687 }
694 /* removal of a directory entry */
701 /* releasing blocks and/or fragments from a file */
708 /* releasing a fragment when replaced as a file grows */
715 /* releasing an inode when its link count drops to 0 */
724 /* NOTREACHED */
725 }
727 }
729 /*
730 * Move dependencies from one buffer to another.
731 */
732 static void
734 {
745 else
748 }
750 }
752 /*
753 * Purge the work list of all items associated with a particular mount point.
754 */
755 int
757 {
761 /*
762 * Await our turn to clear out the queue, then serialize access.
763 */
768 }
776 }
777 /*
778 * Alternately flush the block device associated with the mount
779 * point and process any dependencies that the flushing
780 * creates. In theory, this loop can happen at most twice,
781 * but we give it a few extra just to be sure.
782 */
786 loopcnt--;
787 /*
788 * Do another flush in case any vnodes were brought in
789 * as part of the cleanup operations.
790 */
793 /*
794 * If we still found nothing to do, we are really done.
795 */
798 }
804 }
809 /*
810 * If we are unmounting then it is an error to fail. If we
811 * are simply trying to downgrade to read-only, then filesystem
812 * activity can keep us busy forever, so we just fail with EBUSY.
813 */
818 }
820 }
822 /*
823 * Structure hashing.
824 *
825 * There are three types of structures that can be looked up:
826 * 1) pagedep structures identified by mount point, inode number,
827 * and logical block.
828 * 2) inodedep structures identified by mount point and inode number.
829 * 3) newblk structures identified by mount point and
830 * physical block number.
831 *
832 * The "pagedep" and "inodedep" dependency structures are hashed
833 * separately from the file blocks and inodes to which they correspond.
834 * This separation helps when the in-memory copy of an inode or
835 * file block must be replaced. It also obviates the need to access
836 * an inode or file page when simply updating (or de-allocating)
837 * dependency structures. Lookup of newblk structures is needed to
838 * find newly allocated blocks when trying to associate them with
839 * their allocdirect or allocindir structure.
840 *
841 * The lookup routines optionally create and hash a new instance when
842 * an existing entry is not found.
843 */
847 /*
848 * Structures and routines associated with pagedep caching.
849 */
852 #define PAGEDEP_HASH(mp, inum, lbn) \
853 (&pagedep_hashtbl[((((register_t)(mp)) >> 13) + (inum) + (lbn)) & \
854 pagedep_hash])
857 /*
858 * Helper routine for pagedep_lookup()
859 */
860 static __inline
864 {
872 }
873 }
875 }
877 /*
878 * Look up a pagedep. Return 1 if found, 0 if not found.
879 * If not found, allocate if DEPALLOC flag is passed.
880 * Found or allocated entry is returned in pagedeppp.
881 * This routine must be called with splbio interrupts blocked.
882 */
883 static int
886 {
892 #ifdef DEBUG
895 #endif
898 top:
907 }
917 }
932 }
934 /*
935 * Structures and routines associated with inodedep caching.
936 */
940 #define INODEDEP_HASH(fs, inum) \
941 (&inodedep_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & inodedep_hash])
944 /*
945 * Helper routine for inodedep_lookup()
946 */
947 static __inline
950 {
956 }
958 }
960 /*
961 * Look up a inodedep. Return 1 if found, 0 if not found.
962 * If not found, allocate if DEPALLOC flag is passed.
963 * Found or allocated entry is returned in inodedeppp.
964 * This routine must be called with splbio interrupts blocked.
965 */
966 static int
969 {
974 #ifdef DEBUG
977 #endif
980 top:
986 /*
987 * If we are over our limit, try to improve the situation.
988 */
994 }
998 }
1007 }
1027 }
1029 /*
1030 * Structures and routines associated with newblk caching.
1031 */
1034 #define NEWBLK_HASH(fs, inum) \
1035 (&newblk_hashtbl[((((register_t)(fs)) >> 13) + (inum)) & newblk_hash])
1038 /*
1039 * Helper routine for newblk_lookup()
1040 */
1041 static __inline
1044 ufs_daddr_t newblkno)
1045 {
1051 }
1053 }
1055 /*
1056 * Look up a newblk. Return 1 if found, 0 if not found.
1057 * If not found, allocate if DEPALLOC flag is passed.
1058 * Found or allocated entry is returned in newblkpp.
1059 */
1060 static int
1063 {
1068 top:
1084 }
1092 }
1094 /*
1095 * Executed during filesystem system initialization before
1096 * mounting any filesystems.
1097 */
1098 void
1100 {
1115 }
1117 /*
1118 * Called at mount time to notify the dependency code that a
1119 * filesystem wishes to use it.
1120 */
1121 int
1123 {
1131 /*
1132 * When doing soft updates, the counters in the
1133 * superblock may have gotten out of sync, so we have
1134 * to scan the cylinder groups and recalculate them.
1135 */
1144 }
1152 }
1153 #ifdef DEBUG
1156 #endif
1159 }
1161 /*
1162 * Protecting the freemaps (or bitmaps).
1163 *
1164 * To eliminate the need to execute fsck before mounting a filesystem
1165 * after a power failure, one must (conservatively) guarantee that the
1166 * on-disk copy of the bitmaps never indicate that a live inode or block is
1167 * free. So, when a block or inode is allocated, the bitmap should be
1168 * updated (on disk) before any new pointers. When a block or inode is
1169 * freed, the bitmap should not be updated until all pointers have been
1170 * reset. The latter dependency is handled by the delayed de-allocation
1171 * approach described below for block and inode de-allocation. The former
1172 * dependency is handled by calling the following procedure when a block or
1173 * inode is allocated. When an inode is allocated an "inodedep" is created
1174 * with its DEPCOMPLETE flag cleared until its bitmap is written to disk.
1175 * Each "inodedep" is also inserted into the hash indexing structure so
1176 * that any additional link additions can be made dependent on the inode
1177 * allocation.
1178 *
1179 * The ufs filesystem maintains a number of free block counts (e.g., per
1180 * cylinder group, per cylinder and per <cylinder, rotational position> pair)
1181 * in addition to the bitmaps. These counts are used to improve efficiency
1182 * during allocation and therefore must be consistent with the bitmaps.
1183 * There is no convenient way to guarantee post-crash consistency of these
1184 * counts with simple update ordering, for two main reasons: (1) The counts
1185 * and bitmaps for a single cylinder group block are not in the same disk
1186 * sector. If a disk write is interrupted (e.g., by power failure), one may
1187 * be written and the other not. (2) Some of the counts are located in the
1188 * superblock rather than the cylinder group block. So, we focus our soft
1189 * updates implementation on protecting the bitmaps. When mounting a
1190 * filesystem, we recompute the auxiliary counts from the bitmaps.
1191 */
1193 /*
1194 * Called just after updating the cylinder group block to allocate an inode.
1195 *
1196 * Parameters:
1197 * bp: buffer for cylgroup block with inode map
1198 * ip: inode related to allocation
1199 * newinum: new inode number being allocated
1200 */
1201 void
1203 {
1207 /*
1208 * Create a dependency for the newly allocated inode.
1209 * Panic if it already exists as something is seriously wrong.
1210 * Otherwise add it to the dependency list for the buffer holding
1211 * the cylinder group map from which it was allocated.
1212 */
1217 }
1223 }
1225 /*
1226 * Called just after updating the cylinder group block to
1227 * allocate block or fragment.
1228 *
1229 * Parameters:
1230 * bp: buffer for cylgroup block with block map
1231 * fs: filesystem doing allocation
1232 * newblkno: number of newly allocated block
1233 */
1234 void
1236 ufs_daddr_t newblkno)
1237 {
1241 /*
1242 * Create a dependency for the newly allocated block.
1243 * Add it to the dependency list for the buffer holding
1244 * the cylinder group map from which it was allocated.
1245 */
1252 }
1254 /*
1255 * Find the bmsafemap associated with a cylinder group buffer.
1256 * If none exists, create one. The buffer must be locked when
1257 * this routine is called and this routine must be called with
1258 * splbio interrupts blocked.
1259 */
1262 {
1266 #ifdef DEBUG
1269 #endif
1286 }
1288 /*
1289 * Direct block allocation dependencies.
1290 *
1291 * When a new block is allocated, the corresponding disk locations must be
1292 * initialized (with zeros or new data) before the on-disk inode points to
1293 * them. Also, the freemap from which the block was allocated must be
1294 * updated (on disk) before the inode's pointer. These two dependencies are
1295 * independent of each other and are needed for all file blocks and indirect
1296 * blocks that are pointed to directly by the inode. Just before the
1297 * "in-core" version of the inode is updated with a newly allocated block
1298 * number, a procedure (below) is called to setup allocation dependency
1299 * structures. These structures are removed when the corresponding
1300 * dependencies are satisfied or when the block allocation becomes obsolete
1301 * (i.e., the file is deleted, the block is de-allocated, or the block is a
1302 * fragment that gets upgraded). All of these cases are handled in
1303 * procedures described later.
1304 *
1305 * When a file extension causes a fragment to be upgraded, either to a larger
1306 * fragment or to a full block, the on-disk location may change (if the
1307 * previous fragment could not simply be extended). In this case, the old
1308 * fragment must be de-allocated, but not until after the inode's pointer has
1309 * been updated. In most cases, this is handled by later procedures, which
1310 * will construct a "freefrag" structure to be added to the workitem queue
1311 * when the inode update is complete (or obsolete). The main exception to
1312 * this is when an allocation occurs while a pending allocation dependency
1313 * (for the same block pointer) remains. This case is handled in the main
1314 * allocation dependency setup procedure by immediately freeing the
1315 * unreferenced fragments.
1316 *
1317 * Parameters:
1318 * ip: inode to which block is being added
1319 * lbn: block pointer within inode
1320 * newblkno: disk block number being added
1321 * oldblkno: previous block number, 0 unless frag
1322 * newsize: size of new block
1323 * oldsize: size of new block
1324 * bp: bp for allocated block
1325 */
1326 void
1330 {
1350 else
1368 }
1374 /* allocating an indirect block */
1378 }
1380 /*
1381 * Allocating a direct block.
1382 *
1383 * If we are allocating a directory block, then we must
1384 * allocate an associated pagedep to track additions and
1385 * deletions.
1386 */
1390 }
1391 /*
1392 * The list of allocdirects must be kept in sorted and ascending
1393 * order so that the rollback routines can quickly determine the
1394 * first uncommitted block (the size of the file stored on disk
1395 * ends at the end of the lowest committed fragment, or if there
1396 * are no fragments, at the end of the highest committed block).
1397 * Since files generally grow, the typical case is that the new
1398 * block is to be added at the end of the list. We speed this
1399 * special case by checking against the last allocdirect in the
1400 * list before laboriously traversing the list looking for the
1401 * insertion point.
1402 */
1406 /* insert at end of list */
1412 }
1416 }
1420 }
1421 /* insert in middle of list */
1426 }
1428 /*
1429 * Replace an old allocdirect dependency with a newer one.
1430 * This routine must be called with splbio interrupts blocked.
1431 *
1432 * Parameters:
1433 * adphead: head of list holding allocdirects
1434 * newadp: allocdirect being added
1435 * oldadp: existing allocdirect being checked
1436 */
1437 static void
1441 {
1444 #ifdef DEBUG
1447 #endif
1454 NDADDR);
1455 }
1458 /*
1459 * If the old dependency had a fragment to free or had never
1460 * previously had a block allocated, then the new dependency
1461 * can immediately post its freefrag and adopt the old freefrag.
1462 * This action is done by swapping the freefrag dependencies.
1463 * The new dependency gains the old one's freefrag, and the
1464 * old one gets the new one and then immediately puts it on
1465 * the worklist when it is freed by free_allocdirect. It is
1466 * not possible to do this swap when the old dependency had a
1467 * non-zero size but no previous fragment to free. This condition
1468 * arises when the new block is an extension of the old block.
1469 * Here, the first part of the fragment allocated to the new
1470 * dependency is part of the block currently claimed on disk by
1471 * the old dependency, so cannot legitimately be freed until the
1472 * conditions for the new dependency are fulfilled.
1473 */
1478 }
1480 }
1482 /*
1483 * Allocate a new freefrag structure if needed.
1484 */
1487 {
1506 }
1508 /*
1509 * This workitem de-allocates fragments that were replaced during
1510 * file block allocation.
1511 */
1512 static void
1514 {
1524 }
1526 /*
1527 * Indirect block allocation dependencies.
1528 *
1529 * The same dependencies that exist for a direct block also exist when
1530 * a new block is allocated and pointed to by an entry in a block of
1531 * indirect pointers. The undo/redo states described above are also
1532 * used here. Because an indirect block contains many pointers that
1533 * may have dependencies, a second copy of the entire in-memory indirect
1534 * block is kept. The buffer cache copy is always completely up-to-date.
1535 * The second copy, which is used only as a source for disk writes,
1536 * contains only the safe pointers (i.e., those that have no remaining
1537 * update dependencies). The second copy is freed when all pointers
1538 * are safe. The cache is not allowed to replace indirect blocks with
1539 * pending update dependencies. If a buffer containing an indirect
1540 * block with dependencies is written, these routines will mark it
1541 * dirty again. It can only be successfully written once all the
1542 * dependencies are removed. The ffs_fsync routine in conjunction with
1543 * softdep_sync_metadata work together to get all the dependencies
1544 * removed so that a file can be successfully written to disk. Three
1545 * procedures are used when setting up indirect block pointer
1546 * dependencies. The division is necessary because of the organization
1547 * of the "balloc" routine and because of the distinction between file
1548 * pages and file metadata blocks.
1549 */
1551 /*
1552 * Allocate a new allocindir structure.
1553 *
1554 * Parameters:
1555 * ip: inode for file being extended
1556 * ptrno: offset of pointer in indirect block
1557 * newblkno: disk block number being added
1558 * oldblkno: previous block number, 0 if none
1559 */
1562 ufs_daddr_t oldblkno)
1563 {
1576 }
1578 /*
1579 * Called just before setting an indirect block pointer
1580 * to a newly allocated file page.
1581 *
1582 * Parameters:
1583 * ip: inode for file being extended
1584 * lbn: allocated block number within file
1585 * bp: buffer with indirect blk referencing page
1586 * ptrno: offset of pointer in indirect block
1587 * newblkno: disk block number being added
1588 * oldblkno: previous block number, 0 if none
1589 * nbp: buffer holding allocated page
1590 */
1591 void
1596 {
1602 /*
1603 * If we are allocating a directory page, then we must
1604 * allocate an associated pagedep to track additions and
1605 * deletions.
1606 */
1613 }
1615 /*
1616 * Called just before setting an indirect block pointer to a
1617 * newly allocated indirect block.
1618 * Parameters:
1619 * nbp: newly allocated indirect block
1620 * ip: inode for file being extended
1621 * bp: indirect block referencing allocated block
1622 * ptrno: offset of pointer in indirect block
1623 * newblkno: disk block number being added
1624 */
1625 void
1628 ufs_daddr_t newblkno)
1629 {
1637 }
1639 /*
1640 * Called to finish the allocation of the "aip" allocated
1641 * by one of the two routines above.
1642 *
1643 * Parameters:
1644 * bp: in-memory copy of the indirect block
1645 * ip: inode for file being extended
1646 * aip: allocindir allocated by the above routines
1647 */
1648 static void
1651 {
1668 }
1673 }
1689 }
1693 /*
1694 * Check to see if there is an existing dependency
1695 * for this block. If there is, merge the old
1696 * dependency into the new one.
1697 */
1700 else
1709 }
1715 }
1720 }
1722 /*
1723 * Avoid any possibility of data corruption by
1724 * ensuring that our old version is thrown away.
1725 */
1729 }
1741 }
1748 }
1749 }
1751 /*
1752 * Block de-allocation dependencies.
1753 *
1754 * When blocks are de-allocated, the on-disk pointers must be nullified before
1755 * the blocks are made available for use by other files. (The true
1756 * requirement is that old pointers must be nullified before new on-disk
1757 * pointers are set. We chose this slightly more stringent requirement to
1758 * reduce complexity.) Our implementation handles this dependency by updating
1759 * the inode (or indirect block) appropriately but delaying the actual block
1760 * de-allocation (i.e., freemap and free space count manipulation) until
1761 * after the updated versions reach stable storage. After the disk is
1762 * updated, the blocks can be safely de-allocated whenever it is convenient.
1763 * This implementation handles only the common case of reducing a file's
1764 * length to zero. Other cases are handled by the conventional synchronous
1765 * write approach.
1766 *
1767 * The ffs implementation with which we worked double-checks
1768 * the state of the block pointers and file size as it reduces
1769 * a file's length. Some of this code is replicated here in our
1770 * soft updates implementation. The freeblks->fb_chkcnt field is
1771 * used to transfer a part of this information to the procedure
1772 * that eventually de-allocates the blocks.
1773 *
1774 * This routine should be called from the routine that shortens
1775 * a file's length, before the inode's size or block pointers
1776 * are modified. It will save the block pointer information for
1777 * later release and zero the inode so that the calling routine
1778 * can release it.
1779 */
1783 };
1787 /*
1788 * Parameters:
1789 * ip: The inode whose length is to be reduced
1790 * length: The new length for the file
1791 */
1792 void
1794 {
1823 }
1827 }
1830 /*
1831 * Push the zero'ed inode to to its disk buffer so that we are free
1832 * to delete its dependencies below. Once the dependencies are gone
1833 * the buffer can be safely released.
1834 */
1841 /*
1842 * Find and eliminate any inode dependencies.
1843 */
1849 }
1850 /*
1851 * Add the freeblks structure to the list of operations that
1852 * must await the zero'ed inode being written to disk. If we
1853 * still have a bitmap dependency (delay == 0), then the inode
1854 * has never been written to disk, so we can process the
1855 * freeblks below once we have deleted the dependencies.
1856 */
1860 /*
1861 * Because the file length has been truncated to zero, any
1862 * pending block allocation dependency structures associated
1863 * with this inode are obsolete and can simply be de-allocated.
1864 * We must first merge the two dependency lists to get rid of
1865 * any duplicate freefrag structures, then purge the merged list.
1866 */
1872 /*
1873 * We must wait for any I/O in progress to finish so that
1874 * all potential buffers on the dirty list will be visible.
1875 * Once they are all there, walk the list and get rid of
1876 * any dependencies.
1877 */
1893 /*
1894 * If the inode with zeroed block pointers is now on disk
1895 * we can start freeing blocks. Add freeblks to the worklist
1896 * instead of calling handle_workitem_freeblocks directly as
1897 * it is more likely that additional IO is needed to complete
1898 * the request here than in the !delay case.
1899 */
1902 }
1905 /*
1906 * If the inode has never been written to disk (delay == 0),
1907 * then we can process the freeblks now that we have deleted
1908 * the dependencies.
1909 */
1912 }
1914 static int
1916 {
1923 }
1928 }
1936 }
1938 /*
1939 * Reclaim any dependency structures from a buffer that is about to
1940 * be reallocated to a new vnode. The buffer must be locked, thus,
1941 * no I/O completion operations can occur while we are manipulating
1942 * its associated dependencies. The mutex is held so that other I/O's
1943 * associated with related dependencies do not occur.
1944 */
1945 static void
1947 {
1961 /*
1962 * None of the indirect pointers will ever be visible,
1963 * so they can simply be tossed. GOINGAWAY ensures
1964 * that allocated pointers will be saved in the buffer
1965 * cache until they are freed. Note that they will
1966 * only be able to be found by their physical address
1967 * since the inode mapping the logical address will
1968 * be gone. The save buffer used for the safe copy
1969 * was allocated in setup_allocindir_phase2 using
1970 * the physical address so it could be used for this
1971 * purpose. Hence we swap the safe copy with the real
1972 * copy, allowing the safe copy to be freed and holding
1973 * on to the real copy for later use in indir_trunc.
1974 *
1975 * NOTE: ir_savebp is relative to the block device
1976 * so b_bio1 contains the device block number.
1977 */
1981 }
1989 }
1998 /*
1999 * None of the directory additions will ever be
2000 * visible, so they can simply be tossed.
2001 */
2008 /*
2009 * Copy any directory remove dependencies to the list
2010 * to be processed after the zero'ed inode is written.
2011 * If the inode has already been written, then they
2012 * can be dumped directly onto the work list.
2013 */
2019 ALLCOMPLETE)
2021 else
2024 }
2039 /* NOTREACHED */
2045 /* NOTREACHED */
2046 }
2047 }
2048 }
2050 /*
2051 * Free an allocdirect. Generate a new freefrag work request if appropriate.
2052 * This routine must be called with splbio interrupts blocked.
2053 */
2054 static void
2057 {
2059 #ifdef DEBUG
2062 #endif
2072 else
2074 }
2076 }
2078 /*
2079 * Prepare an inode to be freed. The actual free operation is not
2080 * done until the zero'ed inode has been written to disk.
2081 */
2082 void
2084 {
2089 /*
2090 * This sets up the inode de-allocation dependency.
2091 */
2101 /*
2102 * If the inodedep does not exist, then the zero'ed inode has
2103 * been written to disk. If the allocated inode has never been
2104 * written to disk, then the on-disk inode is zero'ed. In either
2105 * case we can free the file immediately.
2106 */
2113 }
2116 }
2118 /*
2119 * Check to see if an inode has never been written to disk. If
2120 * so free the inodedep and return success, otherwise return failure.
2121 * This routine must be called with splbio interrupts blocked.
2122 *
2123 * If we still have a bitmap dependency, then the inode has never
2124 * been written to disk. Drop the dependency as it is no longer
2125 * necessary since the inode is being deallocated. We set the
2126 * ALLCOMPLETE flags since the bitmap now properly shows that the
2127 * inode is not allocated. Even if the inode is actively being
2128 * written, it has been rolled back to its zero'ed state, so we
2129 * are ensured that a zero inode is what is on the disk. For short
2130 * lived files, this change will usually result in removing all the
2131 * dependencies from the inode so that it can be freed immediately.
2132 */
2133 static int
2135 {
2146 /*
2147 * Another process might be in initiate_write_inodeblock
2148 * trying to allocate memory without holding "Softdep Lock".
2149 */
2162 }
2166 }
2168 }
2170 /*
2171 * Try to free an inodedep structure. Return 1 if it could be freed.
2172 */
2173 static int
2175 {
2190 }
2192 /*
2193 * This workitem routine performs the block de-allocation.
2194 * The workitem is added to the pending list after the updated
2195 * inode block has been written to disk. As mentioned above,
2196 * checks regarding the number of blocks de-allocated (compared
2197 * to the number of blocks allocated for the file) are also
2198 * performed in this function.
2199 */
2200 static void
2202 {
2204 ufs_daddr_t bn;
2223 }
2226 /*
2227 * Indirect blocks first.
2228 */
2237 }
2238 /*
2239 * All direct blocks or frags.
2240 */
2247 }
2249 #ifdef DIAGNOSTIC
2256 }
2258 /*
2259 * Release blocks associated with the inode ip and stored in the indirect
2260 * block at doffset. If level is greater than SINGLE, the block is an
2261 * indirect block and recursive calls to indirtrunc must be used to
2262 * cleanse other indirect blocks.
2263 */
2264 static int
2267 {
2270 ufs_daddr_t nb;
2281 /*
2282 * Get buffer of block pointers to be freed. This routine is not
2283 * called until the zero'ed inode has been written, so it is safe
2284 * to free blocks as they are encountered. Because the inode has
2285 * been zero'ed, calls to bmap on these blocks will fail. So, we
2286 * have to use the on-disk address and the block device for the
2287 * filesystem to look them up. If the file was deleted before its
2288 * indirect blocks were all written to disk, the routine that set
2289 * us up (deallocate_dependencies) will have arranged to leave
2290 * a complete copy of the indirect block in memory for our use.
2291 * Otherwise we have to read the blocks in from the disk.
2292 */
2296 /*
2297 * bp must be ir_savebp, which is held locked for our use.
2298 */
2304 }
2310 }
2317 }
2318 /*
2319 * Recursively free indirect blocks.
2320 */
2330 }
2333 }
2337 }
2339 /*
2340 * Free an allocindir.
2341 * This routine must be called with splbio interrupts blocked.
2342 */
2343 static void
2345 {
2348 #ifdef DEBUG
2351 #endif
2360 else
2363 }
2365 }
2367 /*
2368 * Directory entry addition dependencies.
2369 *
2370 * When adding a new directory entry, the inode (with its incremented link
2371 * count) must be written to disk before the directory entry's pointer to it.
2372 * Also, if the inode is newly allocated, the corresponding freemap must be
2373 * updated (on disk) before the directory entry's pointer. These requirements
2374 * are met via undo/redo on the directory entry's pointer, which consists
2375 * simply of the inode number.
2376 *
2377 * As directory entries are added and deleted, the free space within a
2378 * directory block can become fragmented. The ufs filesystem will compact
2379 * a fragmented directory block to make space for a new entry. When this
2380 * occurs, the offsets of previously added entries change. Any "diradd"
2381 * dependency structures corresponding to these entries must be updated with
2382 * the new offsets.
2383 */
2385 /*
2386 * This routine is called after the in-memory inode's link
2387 * count has been incremented, but before the directory entry's
2388 * pointer to the inode has been set.
2389 *
2390 * Parameters:
2391 * bp: buffer containing directory block
2392 * dp: inode for directory
2393 * diroffset: offset of new entry in directory
2394 * newinum: inode referenced by new directory entry
2395 * newdirbp: non-NULL => contents of new mkdir
2396 */
2397 void
2400 {
2409 /*
2410 * Whiteouts have no dependencies.
2411 */
2416 }
2422 M_SOFTDEP_FLAGS);
2434 M_SOFTDEP_FLAGS);
2439 M_SOFTDEP_FLAGS);
2443 /*
2444 * Dependency on "." and ".." being written to disk.
2445 */
2452 /*
2453 * Dependency on link count increase for parent directory
2454 */
2463 }
2464 }
2465 /*
2466 * Link into parent directory pagedep to await its being written.
2467 */
2472 da_pdlist);
2473 /*
2474 * Link into its inodedep. Put it on the id_bufwait list if the inode
2475 * is not yet written. If it is written, do the post-inode write
2476 * processing to put it on the id_pendinghd list.
2477 */
2481 else
2484 }
2486 /*
2487 * This procedure is called to change the offset of a directory
2488 * entry when compacting a directory block which must be owned
2489 * exclusively by the caller. Note that the actual entry movement
2490 * must be done in this procedure to ensure that no I/O completions
2491 * occur while the move is in progress.
2492 *
2493 * Parameters:
2494 * dp: inode for directory
2495 * base: address of dp->i_offset
2496 * oldloc: address of old directory location
2497 * newloc: address of new directory location
2498 * entrysize: size of directory entry
2499 */
2500 void
2504 {
2508 ufs_lbn_t lbn;
2528 }
2535 }
2536 }
2537 }
2538 done:
2541 }
2543 /*
2544 * Free a diradd dependency structure. This routine must be called
2545 * with splbio interrupts blocked.
2546 */
2547 static void
2549 {
2555 #ifdef DEBUG
2558 #endif
2568 }
2581 }
2585 }
2586 }
2588 }
2590 /*
2591 * Directory entry removal dependencies.
2592 *
2593 * When removing a directory entry, the entry's inode pointer must be
2594 * zero'ed on disk before the corresponding inode's link count is decremented
2595 * (possibly freeing the inode for re-use). This dependency is handled by
2596 * updating the directory entry but delaying the inode count reduction until
2597 * after the directory block has been written to disk. After this point, the
2598 * inode count can be decremented whenever it is convenient.
2599 */
2601 /*
2602 * This routine should be called immediately after removing
2603 * a directory entry. The inode's link count should not be
2604 * decremented by the calling procedure -- the soft updates
2605 * code will do this task when it is safe.
2606 *
2607 * Parameters:
2608 * bp: buffer containing directory block
2609 * dp: inode for the directory being modified
2610 * ip: inode for directory entry being removed
2611 * isrmdir: indicates if doing RMDIR
2612 */
2613 void
2616 {
2619 /*
2620 * Allocate a new dirrem if appropriate and ACQUIRE_LOCK.
2621 */
2624 /*
2625 * If the COMPLETE flag is clear, then there were no active
2626 * entries and we want to roll back to a zeroed entry until
2627 * the new inode is committed to disk. If the COMPLETE flag is
2628 * set then we have deleted an entry that never made it to
2629 * disk. If the entry we deleted resulted from a name change,
2630 * then the old name still resides on disk. We cannot delete
2631 * its inode (returned to us in prevdirrem) until the zeroed
2632 * directory entry gets to disk. The new inode has never been
2633 * referenced on the disk, so can be deleted immediately.
2634 */
2637 dm_next);
2646 }
2647 }
2649 /*
2650 * Allocate a new dirrem if appropriate and return it along with
2651 * its associated pagedep. Called without a lock, returns with lock.
2652 */
2655 /*
2656 * Parameters:
2657 * bp: buffer containing directory block
2658 * dp: inode for the directory being modified
2659 * ip: inode for directory entry being removed
2660 * isrmdir: indicates if doing RMDIR
2661 * prevdirremp: previously referenced inode, if any
2662 */
2666 {
2668 ufs_lbn_t lbn;
2673 /*
2674 * Whiteouts have no deletion dependencies.
2675 */
2678 /*
2679 * If we are over our limit, try to improve the situation.
2680 * Limiting the number of dirrem structures will also limit
2681 * the number of freefile and freeblks structures.
2682 */
2701 /*
2702 * Check for a diradd dependency for the same directory entry.
2703 * If present, then both dependencies become obsolete and can
2704 * be de-allocated. Check for an entry on both the pd_dirraddhd
2705 * list and the pd_pendinghd list.
2706 */
2718 }
2719 /*
2720 * Must be ATTACHED at this point.
2721 */
2725 }
2730 }
2731 /*
2732 * If we are deleting a changed name that never made it to disk,
2733 * then return the dirrem describing the previous inode (which
2734 * represents the inode currently referenced from this entry on disk).
2735 */
2740 }
2741 /*
2742 * We are deleting an entry that never made it to disk.
2743 * Mark it COMPLETE so we can delete its inode immediately.
2744 */
2748 }
2750 /*
2751 * Directory entry change dependencies.
2752 *
2753 * Changing an existing directory entry requires that an add operation
2754 * be completed first followed by a deletion. The semantics for the addition
2755 * are identical to the description of adding a new entry above except
2756 * that the rollback is to the old inode number rather than zero. Once
2757 * the addition dependency is completed, the removal is done as described
2758 * in the removal routine above.
2759 */
2761 /*
2762 * This routine should be called immediately after changing
2763 * a directory entry. The inode's link count should not be
2764 * decremented by the calling procedure -- the soft updates
2765 * code will perform this task when it is safe.
2766 *
2767 * Parameters:
2768 * bp: buffer containing directory block
2769 * dp: inode for the directory being modified
2770 * ip: inode for directory entry being removed
2771 * newinum: new inode number for changed entry
2772 * isrmdir: indicates if doing RMDIR
2773 */
2774 void
2778 {
2787 /*
2788 * Whiteouts do not need diradd dependencies.
2789 */
2798 }
2800 /*
2801 * Allocate a new dirrem and ACQUIRE_LOCK.
2802 */
2805 /*
2806 * The possible values for isrmdir:
2807 * 0 - non-directory file rename
2808 * 1 - directory rename within same directory
2809 * inum - directory rename to new directory of given inode number
2810 * When renaming to a new directory, we are both deleting and
2811 * creating a new directory entry, so the link count on the new
2812 * directory should not change. Thus we do not need the followup
2813 * dirrem which is usually done in handle_workitem_remove. We set
2814 * the DIRCHG flag to tell handle_workitem_remove to skip the
2815 * followup dirrem.
2816 */
2820 /*
2821 * Whiteouts have no additional dependencies,
2822 * so just put the dirrem on the correct list.
2823 */
2827 dm_next);
2831 }
2834 }
2836 /*
2837 * If the COMPLETE flag is clear, then there were no active
2838 * entries and we want to roll back to the previous inode until
2839 * the new inode is committed to disk. If the COMPLETE flag is
2840 * set, then we have deleted an entry that never made it to disk.
2841 * If the entry we deleted resulted from a name change, then the old
2842 * inode reference still resides on disk. Any rollback that we do
2843 * needs to be to that old inode (returned to us in prevdirrem). If
2844 * the entry we deleted resulted from a create, then there is
2845 * no entry on the disk, so we want to roll back to zero rather
2846 * than the uncommitted inode. In either of the COMPLETE cases we
2847 * want to immediately free the unwritten and unreferenced inode.
2848 */
2857 }
2860 }
2861 /*
2862 * Link into its inodedep. Put it on the id_bufwait list if the inode
2863 * is not yet written. If it is written, do the post-inode write
2864 * processing to put it on the id_pendinghd list.
2865 */
2875 }
2877 }
2879 /*
2880 * Called whenever the link count on an inode is changed.
2881 * It creates an inode dependency so that the new reference(s)
2882 * to the inode cannot be committed to disk until the updated
2883 * inode has been written.
2884 *
2885 * Parameters:
2886 * ip: the inode with the increased link count
2887 */
2888 void
2890 {
2898 }
2901 }
2903 /*
2904 * This workitem decrements the inode's link count.
2905 * If the link count reaches zero, the file is removed.
2906 */
2907 static void
2909 {
2913 ino_t oldinum;
2919 }
2925 }
2926 /*
2927 * Normal file deletion.
2928 */
2935 }
2942 }
2943 /*
2944 * Directory deletion. Decrement reference count for both the
2945 * just deleted parent directory entry and the reference for ".".
2946 * Next truncate the directory to length zero. When the
2947 * truncation completes, arrange to have the reference count on
2948 * the parent decremented to account for the loss of "..".
2949 */
2955 }
2960 /*
2961 * Rename a directory to a new parent. Since, we are both deleting
2962 * and creating a new directory entry, the link count on the new
2963 * directory should not change. Thus we skip the followup dirrem.
2964 */
2970 }
2971 /*
2972 * If the inodedep does not exist, then the zero'ed inode has
2973 * been written to disk. If the allocated inode has never been
2974 * written to disk, then the on-disk inode is zero'ed. In either
2975 * case we can remove the file immediately.
2976 */
2987 }
2993 }
2995 /*
2996 * Inode de-allocation dependencies.
2997 *
2998 * When an inode's link count is reduced to zero, it can be de-allocated. We
2999 * found it convenient to postpone de-allocation until after the inode is
3000 * written to disk with its new link count (zero). At this point, all of the
3001 * on-disk inode's block pointers are nullified and, with careful dependency
3002 * list ordering, all dependencies related to the inode will be satisfied and
3003 * the corresponding dependency structures de-allocated. So, if/when the
3004 * inode is reused, there will be no mixing of old dependencies with new
3005 * ones. This artificial dependency is set up by the block de-allocation
3006 * procedure above (softdep_setup_freeblocks) and completed by the
3007 * following procedure.
3008 */
3009 static void
3011 {
3017 #ifdef DEBUG
3023 #endif
3031 }
3033 /*
3034 * Helper function which unlinks marker element from work list and returns
3035 * the next element on the list.
3036 */
3039 {
3045 }
3047 /*
3048 * Disk writes.
3049 *
3050 * The dependency structures constructed above are most actively used when file
3051 * system blocks are written to disk. No constraints are placed on when a
3052 * block can be written, but unsatisfied update dependencies are made safe by
3053 * modifying (or replacing) the source memory for the duration of the disk
3054 * write. When the disk write completes, the memory block is again brought
3055 * up-to-date.
3056 *
3057 * In-core inode structure reclamation.
3058 *
3059 * Because there are a finite number of "in-core" inode structures, they are
3060 * reused regularly. By transferring all inode-related dependencies to the
3061 * in-memory inode block and indexing them separately (via "inodedep"s), we
3062 * can allow "in-core" inode structures to be reused at any time and avoid
3063 * any increase in contention.
3064 *
3065 * Called just before entering the device driver to initiate a new disk I/O.
3066 * The buffer must be locked, thus, no I/O completion operations can occur
3067 * while we are manipulating its associated dependencies.
3068 *
3069 * Parameters:
3070 * bp: structure describing disk write to occur
3071 */
3072 static void
3074 {
3079 /*
3080 * We only care about write operations. There should never
3081 * be dependencies for reads.
3082 */
3088 /*
3089 * Do any necessary pre-I/O processing.
3090 */
3108 /*
3109 * If there are no remaining dependencies, this
3110 * will be writing the real pointers, so the
3111 * dependency can be freed.
3112 */
3116 /* inline expand WORKLIST_REMOVE(wk); */
3121 }
3122 /*
3123 * Replace up-to-date version with safe version.
3124 */
3145 /* NOTREACHED */
3146 }
3147 }
3148 }
3150 /*
3151 * Called from within the procedure above to deal with unsatisfied
3152 * allocation dependencies in a directory. The buffer must be locked,
3153 * thus, no I/O completion operations can occur while we are
3154 * manipulating its associated dependencies.
3155 */
3156 static void
3158 {
3164 /*
3165 * This can only happen if there is a driver that does not
3166 * understand chaining. Here biodone will reissue the call
3167 * to strategy for the incomplete buffers.
3168 */
3171 }
3183 }
3186 else
3190 }
3191 }
3193 }
3195 /*
3196 * Called from within the procedure above to deal with unsatisfied
3197 * allocation dependencies in an inodeblock. The buffer must be
3198 * locked, thus, no I/O completion operations can occur while we
3199 * are manipulating its associated dependencies.
3200 *
3201 * Parameters:
3202 * bp: The inode block
3203 */
3204 static void
3206 {
3220 /*
3221 * If the bitmap is not yet written, then the allocated
3222 * inode cannot be written to disk.
3223 */
3234 }
3235 /*
3236 * If no dependencies, then there is nothing to roll back.
3237 */
3241 /*
3242 * Set the dependencies to busy.
3243 */
3247 #ifdef DIAGNOSTIC
3251 }
3259 }
3266 }
3272 }
3276 }
3277 /*
3278 * The on-disk inode cannot claim to be any larger than the last
3279 * fragment that has been written. Otherwise, the on-disk inode
3280 * might have fragments that were not the last block in the file
3281 * which would corrupt the filesystem.
3282 */
3288 /* keep going until hitting a rollback to a frag */
3293 #ifdef DIAGNOSTIC
3297 }
3300 }
3302 #ifdef DIAGNOSTIC
3307 }
3310 }
3313 }
3314 /*
3315 * If we have zero'ed out the last allocated block of the file,
3316 * roll back the size to the last currently allocated block.
3317 * We know that this last allocated block is a full-sized as
3318 * we already checked for fragments in the loop above.
3319 */
3326 }
3327 /*
3328 * The only dependencies are for indirect blocks.
3329 *
3330 * The file size for indirect block additions is not guaranteed.
3331 * Such a guarantee would be non-trivial to achieve. The conventional
3332 * synchronous write implementation also does not make this guarantee.
3333 * Fsck should catch and fix discrepancies. Arguably, the file size
3334 * can be over-estimated without destroying integrity when the file
3335 * moves into the indirect blocks (i.e., is large). If we want to
3336 * postpone fsck, we are stuck with this argument.
3337 */
3341 }
3343 /*
3344 * This routine is called during the completion interrupt
3345 * service routine for a disk write (from the procedure called
3346 * by the device driver to inform the filesystem caches of
3347 * a request completion). It should be called early in this
3348 * procedure, before the block is made available to other
3349 * processes or other routines are called.
3350 *
3351 * Parameters:
3352 * bp: describes the completed disk write
3353 */
3354 static void
3356 {
3366 #ifdef DEBUG
3370 #endif
3392 }
3399 }
3406 }
3412 }
3437 }
3448 }
3449 }
3452 stat_indir_blk_ptrs++;
3460 /* NOTREACHED */
3461 }
3462 }
3463 /*
3464 * Reattach any requests that must be redone.
3465 */
3469 }
3470 #ifdef DEBUG
3474 #endif
3475 }
3477 /*
3478 * Called from within softdep_disk_write_complete above. Note that
3479 * this routine is always called from interrupt level with further
3480 * splbio interrupts blocked.
3481 *
3482 * Parameters:
3483 * adp: the completed allocdirect
3484 */
3485 static void
3487 {
3497 }
3498 /*
3499 * The on-disk inode cannot claim to be any larger than the last
3500 * fragment that has been written. Otherwise, the on-disk inode
3501 * might have fragments that were not the last block in the file
3502 * which would corrupt the filesystem. Thus, we cannot free any
3503 * allocdirects after one whose ad_oldblkno claims a fragment as
3504 * these blocks must be rolled back to zero before writing the inode.
3505 * We check the currently active set of allocdirects in id_inoupdt.
3506 */
3510 /* found our block */
3513 /* continue if ad_oldlbn is not a fragment */
3517 /* hit a fragment */
3519 }
3520 /*
3521 * If we have reached the end of the current list without
3522 * finding the just finished dependency, then it must be
3523 * on the future dependency list. Future dependencies cannot
3524 * be freed until they are moved to the current list.
3525 */
3527 #ifdef DEBUG
3529 /* found our block */
3535 }
3538 }
3539 /*
3540 * If we have found the just finished dependency, then free
3541 * it along with anything that follows it that is complete.
3542 */
3548 }
3549 }
3551 /*
3552 * Called from within softdep_disk_write_complete above. Note that
3553 * this routine is always called from interrupt level with further
3554 * splbio interrupts blocked.
3555 *
3556 * Parameters:
3557 * aip: the completed allocindir
3558 */
3559 static void
3561 {
3569 }
3575 }
3582 }
3584 /*
3585 * Called from within softdep_disk_write_complete above to restore
3586 * in-memory inode block contents to their most up-to-date state. Note
3587 * that this routine is always called from interrupt level with further
3588 * splbio interrupts blocked.
3589 *
3590 * Parameters:
3591 * bp: buffer containing the inode block
3592 */
3593 static int
3595 {
3604 }
3608 /*
3609 * If we had to rollback the inode allocation because of
3610 * bitmaps being incomplete, then simply restore it.
3611 * Keep the block dirty so that it will not be reclaimed until
3612 * all associated dependencies have been cleared and the
3613 * corresponding updates written to disk.
3614 */
3620 stat_inode_bitmap++;
3623 }
3625 /*
3626 * Roll forward anything that had to be rolled back before
3627 * the inode could be updated.
3628 */
3635 }
3643 }
3652 }
3654 }
3658 }
3660 stat_direct_blk_ptrs++;
3661 /*
3662 * Reset the file size to its most up-to-date value.
3663 */
3667 }
3671 }
3673 /*
3674 * If there were any rollbacks in the inode block, then it must be
3675 * marked dirty so that its will eventually get written back in
3676 * its correct form.
3677 */
3680 /*
3681 * Process any allocdirects that completed during the update.
3682 */
3685 /*
3686 * Process deallocations that were held pending until the
3687 * inode had been written to disk. Freeing of the inode
3688 * is delayed until after all blocks have been freed to
3689 * avoid creation of new <vfsid, inum, lbn> triples
3690 * before the old ones have been deleted.
3691 */
3698 /*
3699 * We defer adding filefree to the worklist until
3700 * all other additions have been made to ensure
3701 * that it will be done after all the old blocks
3702 * have been freed.
3703 */
3707 }
3723 /* -- fall through -- */
3733 /* NOTREACHED */
3734 }
3735 }
3740 }
3743 }
3745 /*
3746 * If no outstanding dependencies, free it.
3747 */
3751 }
3753 /*
3754 * Process a diradd entry after its dependent inode has been written.
3755 * This routine must be called with splbio interrupts blocked.
3756 */
3757 static void
3759 {
3766 else
3770 }
3772 }
3774 /*
3775 * Handle the completion of a mkdir dependency.
3776 */
3777 static void
3779 {
3786 }
3794 else
3798 }
3801 }
3803 /*
3804 * Called from within softdep_disk_write_complete above.
3805 * A write operation was just completed. Removed inodes can
3806 * now be freed and associated block pointers may be committed.
3807 * Note that this routine is always called from interrupt level
3808 * with further splbio interrupts blocked.
3809 *
3810 * Parameters:
3811 * bp: buffer containing the written page
3812 */
3813 static int
3815 {
3824 }
3826 /*
3827 * Process any directory removals that have been committed.
3828 */
3833 }
3834 /*
3835 * Free any directory additions that have been committed.
3836 */
3839 /*
3840 * Uncommitted directory entries must be restored.
3841 */
3849 }
3856 /*
3857 * If the inode referenced by the directory has
3858 * been written out, then the dependency can be
3859 * moved to the pending list.
3860 */
3864 da_pdlist);
3865 }
3866 }
3867 }
3868 /*
3869 * If there were any rollbacks in the directory, then it must be
3870 * marked dirty so that its will eventually get written back in
3871 * its correct form.
3872 */
3875 stat_dir_entry++;
3877 }
3878 /*
3879 * If no dependencies remain, the pagedep will be freed.
3880 * Otherwise it will remain to update the page before it
3881 * is written back to disk.
3882 */
3891 }
3892 }
3894 }
3896 /*
3897 * Writing back in-core inode structures.
3898 *
3899 * The filesystem only accesses an inode's contents when it occupies an
3900 * "in-core" inode structure. These "in-core" structures are separate from
3901 * the page frames used to cache inode blocks. Only the latter are
3902 * transferred to/from the disk. So, when the updated contents of the
3903 * "in-core" inode structure are copied to the corresponding in-memory inode
3904 * block, the dependencies are also transferred. The following procedure is
3905 * called when copying a dirty "in-core" inode to a cached inode block.
3906 */
3908 /*
3909 * Called when an inode is loaded from disk. If the effective link count
3910 * differed from the actual link count when it was last flushed, then we
3911 * need to ensure that the correct effective link count is put back.
3912 *
3913 * Parameters:
3914 * ip: the "in_core" copy of the inode
3915 */
3916 void
3918 {
3921 /*
3922 * Check for alternate nlink count.
3923 */
3929 }
3932 }
3934 /*
3935 * This routine is called just before the "in-core" inode
3936 * information is to be copied to the in-memory inode block.
3937 * Recall that an inode block contains several inodes. If
3938 * the force flag is set, then the dependencies will be
3939 * cleared so that the update can always be made. Note that
3940 * the buffer is locked when this routine is called, so we
3941 * will never be in the middle of writing the inode block
3942 * to disk.
3943 *
3944 * Parameters:
3945 * ip: the "in_core" copy of the inode
3946 * bp: the buffer containing the inode block
3947 * waitfor: nonzero => update must be allowed
3948 */
3949 void
3952 {
3957 /*
3958 * If the effective link count is not equal to the actual link
3959 * count, then we must track the difference in an inodedep while
3960 * the inode is (potentially) tossed out of the cache. Otherwise,
3961 * if there is no existing inodedep, then there are no dependencies
3962 * to track.
3963 */
3970 }
3974 }
3975 /*
3976 * Changes have been initiated. Anything depending on these
3977 * changes cannot occur until this inode has been written.
3978 */
3982 /*
3983 * Any new dependencies associated with the incore inode must
3984 * now be moved to the list associated with the buffer holding
3985 * the in-memory copy of the inode. Once merged process any
3986 * allocdirects that are completed by the merger.
3987 */
3991 /*
3992 * Now that the inode has been pushed into the buffer, the
3993 * operations dependent on the inode being written to disk
3994 * can be moved to the id_bufwait so that they will be
3995 * processed when the buffer I/O completes.
3996 */
4000 }
4001 /*
4002 * Newly allocated inodes cannot be written until the bitmap
4003 * that allocates them have been written (indicated by
4004 * DEPCOMPLETE being set in id_state). If we are doing a
4005 * forced sync (e.g., an fsync on a file), we force the bitmap
4006 * to be written so that the update can be done.
4007 */
4011 }
4017 }
4019 /*
4020 * Merge the new inode dependency list (id_newinoupdt) into the old
4021 * inode dependency list (id_inoupdt). This routine must be called
4022 * with splbio interrupts blocked.
4023 */
4024 static void
4026 {
4034 }
4039 listadp);
4041 }
4043 }
4047 }
4048 }
4050 /*
4051 * If we are doing an fsync, then we must ensure that any directory
4052 * entries for the inode have been written after the inode gets to disk.
4053 *
4054 * Parameters:
4055 * vp: the "in_core" copy of the inode
4056 */
4057 static int
4059 {
4070 ino_t parentino;
4071 ufs_lbn_t lbn;
4079 }
4086 }
4094 }
4096 /*
4097 * Flush our parent if this directory entry
4098 * has a MKDIR_PARENT dependency.
4099 */
4102 else
4110 }
4112 /*
4113 * If we are being fsync'ed as part of vgone'ing this vnode,
4114 * then we will not be able to release and recover the
4115 * vnode below, so we just have to give up on writing its
4116 * directory entry out. It will eventually be written, just
4117 * not now, but then the user was not asking to have it
4118 * written, so we are not breaking any promises.
4119 */
4122 /*
4123 * We prevent deadlock by always fetching inodes from the
4124 * root, moving down the directory tree. Thus, when fetching
4125 * our parent directory, we must unlock ourselves before
4126 * requesting the lock on our parent. See the comment in
4127 * ufs_lookup for details on possible races.
4128 */
4139 }
4140 }
4141 /*
4142 * Flush directory page containing the inode's name.
4143 */
4153 }
4156 }
4158 /*
4159 * Flush all the dirty bitmaps associated with the block device
4160 * before flushing the rest of the dirty blocks so as to reduce
4161 * the number of dependencies that will have to be rolled back.
4162 */
4165 void
4167 {
4175 }
4177 static int
4179 {
4183 /*
4184 * If it is already scheduled, skip to the next buffer.
4185 */
4190 kprintf("softdep_fsync_mountdev_bp: warning, buffer %p ripped out from under vnode %p\n", bp, vp);
4192 }
4193 /*
4194 * We are only interested in bitmaps with outstanding
4195 * dependencies.
4196 */
4201 }
4207 }
4209 /*
4210 * This routine is called when we are trying to synchronously flush a
4211 * file. This routine must eliminate any filesystem metadata dependencies
4212 * so that the syncing routine can succeed by pushing the dirty blocks
4213 * associated with the file. If any I/O errors occur, they are returned.
4214 */
4218 };
4222 int
4224 {
4228 /*
4229 * Check whether this vnode is involved in a filesystem
4230 * that is doing soft dependency processing.
4231 */
4239 /*
4240 * Ensure that any direct block dependencies have been cleared.
4241 */
4246 }
4247 /*
4248 * For most files, the only metadata dependencies are the
4249 * cylinder group maps that allocate their inode or blocks.
4250 * The block allocation dependencies can be found by traversing
4251 * the dependency lists for any buffers that remain on their
4252 * dirty buffer list. The inode allocation dependency will
4253 * be resolved when the inode is updated with MNT_WAIT.
4254 * This work is done in two passes. The first pass grabs most
4255 * of the buffers and begins asynchronously writing them. The
4256 * only way to wait for these asynchronous writes is to sleep
4257 * on the filesystem vnode which may stay busy for a long time
4258 * if the filesystem is active. So, instead, we make a second
4259 * pass over the dependencies blocking on each write. In the
4260 * usual case we will be blocking against a write that we
4261 * initiated, so when it is done the dependency will have been
4262 * resolved. Thus the second pass is expected to end quickly.
4263 */
4265 top:
4266 /*
4267 * We must wait for any I/O in progress to finish so that
4268 * all potential buffers on the dirty list will be visible.
4269 */
4278 }
4280 /*
4281 * The brief unlock is to allow any pent up dependency
4282 * processing to be done. Then proceed with the second pass.
4283 */
4289 }
4291 /*
4292 * If we have managed to get rid of all the dirty buffers,
4293 * then we are done. For certain directories and block
4294 * devices, we may need to do further work.
4295 *
4296 * We must wait for any I/O in progress to finish so that
4297 * all potential buffers on the dirty list will be visible.
4298 */
4303 }
4306 /*
4307 * If we are trying to sync a block device, some of its buffers may
4308 * contain metadata that cannot be written until the contents of some
4309 * partially written files have been written to disk. The only easy
4310 * way to accomplish this is to sync the entire filesystem (luckily
4311 * this happens rarely).
4312 */
4319 }
4321 static int
4323 {
4336 }
4341 }
4343 /*
4344 * As we hold the buffer locked, none of its dependencies
4345 * will disappear.
4346 */
4364 }
4382 }
4387 restart:
4400 }
4403 }
4413 }
4417 /*
4418 * We are trying to sync a directory that may
4419 * have dependencies on both its own metadata
4420 * and/or dependencies on the inodes of any
4421 * recently allocated files. We walk its diradd
4422 * lists pushing out the associated inode.
4423 */
4436 }
4437 }
4441 /*
4442 * This case should never happen if the vnode has
4443 * been properly sync'ed. However, if this function
4444 * is used at a place where the vnode has not yet
4445 * been sync'ed, this dependency can show up. So,
4446 * rather than panic, just flush it.
4447 */
4458 }
4463 /*
4464 * This case should never happen if the vnode has
4465 * been properly sync'ed. However, if this function
4466 * is used at a place where the vnode has not yet
4467 * been sync'ed, this dependency can show up. So,
4468 * rather than panic, just flush it.
4469 *
4470 * nbp can wind up == bp if a device node for the
4471 * same filesystem is being fsynced at the same time,
4472 * leading to a panic if we don't catch the case.
4473 */
4486 }
4494 /* NOTREACHED */
4495 }
4496 }
4501 }
4503 /*
4504 * Flush the dependencies associated with an inodedep.
4505 * Called with splbio blocked.
4506 */
4507 static int
4509 {
4515 /*
4516 * This work is done in two passes. The first pass grabs most
4517 * of the buffers and begins asynchronously writing them. The
4518 * only way to wait for these asynchronous writes is to sleep
4519 * on the filesystem vnode which may stay busy for a long time
4520 * if the filesystem is active. So, instead, we make a second
4521 * pass over the dependencies blocking on each write. In the
4522 * usual case we will be blocking against a write that we
4523 * initiated, so when it is done the dependency will have been
4524 * resolved. Thus the second pass is expected to end quickly.
4525 * We give a brief window at the top of the loop to allow
4526 * any pending I/O to complete.
4527 */
4541 }
4548 }
4551 }
4562 }
4569 }
4572 }
4575 /*
4576 * If pass2, we are done, otherwise do pass 2.
4577 */
4581 }
4582 /*
4583 * Try freeing inodedep in case all dependencies have been removed.
4584 */
4588 }
4590 /*
4591 * Eliminate a pagedep dependency by flushing out all its diradd dependencies.
4592 * Called with splbio blocked.
4593 */
4594 static int
4597 {
4604 ino_t inum;
4608 /*
4609 * Flush ourselves if this directory entry
4610 * has a MKDIR_PARENT dependency.
4611 */
4617 /*
4618 * If that cleared dependencies, go on to next.
4619 */
4625 }
4626 }
4627 /*
4628 * A newly allocated directory must have its "." and
4629 * ".." entries written out before its name can be
4630 * committed in its parent. We do not want or need
4631 * the full semantics of a synchronous VOP_FSYNC as
4632 * that may end up here again, once for each directory
4633 * level in the filesystem. Instead, we push the blocks
4634 * and wait for them to clear. We have to fsync twice
4635 * because the first call may choose to defer blocks
4636 * that still have dependencies, but deferral will
4637 * happen at most once.
4638 */
4648 }
4652 /*
4653 * If that cleared dependencies, go on to next.
4654 */
4660 }
4661 }
4662 /*
4663 * Flush the inode on which the directory entry depends.
4664 * Having accounted for MKDIR_PARENT and MKDIR_BODY above,
4665 * the only remaining dependency is that the updated inode
4666 * count must get pushed to disk. The inode has already
4667 * been pushed into its inode buffer (via VOP_UPDATE) at
4668 * the time of the reference count change. So we need only
4669 * locate that buffer, ensure that there will be no rollback
4670 * caused by a bitmap dependency, then write the inode buffer.
4671 */
4675 }
4676 /*
4677 * If the inode still has bitmap dependencies,
4678 * push them to disk.
4679 */
4688 }
4689 /*
4690 * If the inode is still sitting in a buffer waiting
4691 * to be written, push it to disk.
4692 */
4701 /*
4702 * If we have failed to get rid of all the dependencies
4703 * then something is seriously wrong.
4704 */
4708 }
4709 }
4713 }
4715 /*
4716 * A large burst of file addition or deletion activity can drive the
4717 * memory load excessively high. First attempt to slow things down
4718 * using the techniques below. If that fails, this routine requests
4719 * the offending operations to fall back to running synchronously
4720 * until the memory load returns to a reasonable level.
4721 */
4722 int
4724 {
4733 }
4735 /*
4736 * If memory utilization has gotten too high, deliberately slow things
4737 * down and speed up the I/O processing.
4738 */
4739 static int
4741 {
4744 /*
4745 * We never hold up the filesystem syncer process.
4746 */
4749 /*
4750 * First check to see if the work list has gotten backlogged.
4751 * If it has, co-opt this process to help clean up two entries.
4752 * Because this process may hold inodes locked, we cannot
4753 * handle any remove requests that might block on a locked
4754 * inode as that could lead to deadlock.
4755 */
4765 }
4767 /*
4768 * If we are resource constrained on inode dependencies, try
4769 * flushing some dirty inodes. Otherwise, we are constrained
4770 * by file deletions, so try accelerating flushes of directories
4771 * with removal dependencies. We would like to do the cleanup
4772 * here, but we probably hold an inode locked at this point and
4773 * that might deadlock against one that we try to clean. So,
4774 * the best that we can do is request the syncer daemon to do
4775 * the cleanup for us.
4776 */
4795 }
4796 /*
4797 * Hopefully the syncer daemon will catch up and awaken us.
4798 * We wait at most tickdelay before proceeding in any case.
4799 */
4812 }
4814 /*
4815 * Awaken processes pausing in request_cleanup and clear proc_waiting
4816 * to indicate that there is no longer a timer running.
4817 */
4818 void
4820 {
4826 else
4828 }
4830 /*
4831 * Flush out a directory with at least one removal dependency in an effort to
4832 * reduce the number of dirrem, freefile, and freeblks dependency structures.
4833 */
4834 static void
4836 {
4843 ino_t ino;
4859 }
4865 }
4866 }
4868 }
4870 /*
4871 * Clear out a block of dirty inodes in an effort to reduce
4872 * the number of inodedep dependency structures.
4873 */
4877 };
4879 static int
4881 {
4887 }
4889 }
4891 static void
4893 {
4904 /*
4905 * Pick a random inode dependency to be cleared.
4906 * We will then gather up all the inodes in its block
4907 * that have dependencies and flush them out.
4908 */
4915 }
4919 }
4920 /*
4921 * Ugly code to find mount point given pointer to superblock.
4922 */
4928 /*
4929 * Find the last inode in the block with dependencies.
4930 */
4935 /*
4936 * Asynchronously push all but the last inode with dependencies.
4937 * Synchronously push the last inode with dependencies to ensure
4938 * that the inode block gets written to free up the inodedeps.
4939 */
4947 }
4955 }
4958 }
4960 }
4962 /*
4963 * Function to determine if the buffer has outstanding dependencies
4964 * that will cause a roll-back if the buffer is written. If wantcount
4965 * is set, return number of dependencies, otherwise just yes or no.
4966 */
4967 static int
4969 {
4986 /* bitmap allocation dependency */
4990 }
4992 /* direct block pointer dependency */
4996 }
5003 /* indirect block pointer dependency */
5007 }
5015 /* directory entry dependency */
5019 }
5020 }
5027 /* never a dependency on these blocks */
5034 /* NOTREACHED */
5035 }
5036 }
5037 out:
5040 }
5042 /*
5043 * Acquire exclusive access to a buffer.
5044 * Must be called with splbio blocked.
5045 * Return 1 if buffer was acquired.
5046 */
5047 static int
5049 {
5065 }
5066 }
5070 }
5073 }
5075 /*
5076 * Wait for pending output on a vnode to complete.
5077 * Must be called with vnode locked.
5078 */
5079 static void
5081 {
5089 }
5092 }
5094 /*
5095 * Called whenever a buffer that is being invalidated or reallocated
5096 * contains dependencies. This should only happen if an I/O error has
5097 * occurred. The routine is called with the buffer locked.
5098 */
5099 static void
5101 {
5107 }
5109 /*
5110 * Function to handle asynchronous write errors in the filesystem.
5111 */
5112 void
5114 {
5116 /* XXX should do something better! */
5118 }