1 # $NetBSD: CHANGES,v 1.7 2025/01/07 17:39:45 andvar Exp $ 2 3 kernel: 4 5 - Instead of blindly continuing when it encounters an Inode that is 6 locked by another process, lfs_markv will process the rest of the 7 inodes passed to it and then return EAGAIN. The cleaner will 8 recognize this and not mark the segment clean. When the cleaner runs 9 again, the segment containing the (formerly) locked inode will sort high 10 for cleaning, since it is now almost entirely empty. 11 12 - A beginning has been made to test keeping atime information in the 13 Ifile, instead of on the inodes. This should make read-mostly 14 filesystems significantly faster, since the inodes will then remain 15 close to the data blocks on disk; but of course the ifile will be 16 somewhat larger. This code is not enabled, as it makes the format of 17 IFILEs change. 18 19 - The superblock has been broken into two components: an on-disk 20 superblock using fixed-size types, exactly 512 bytes regardless of 21 architecture (or could be enlarged in multiples of the media block 22 size up to LFS_SBPAD); and an in-memory superblock containing the 23 information only useful to a running LFS, including segment pointers, 24 etc. The superblock checksumming code has been modified to make 25 future changes to the superblock format easier. 26 27 - Because of the way that lfs_writeseg works, buffers are freed before 28 they are really written to disk: their contents are copied into large 29 buffers which are written async. Because the buffer cache does not 30 serve to throttle these writes, and malloced memory is used to hold them, 31 there is a danger of running out of kmem_map. To avoid this, a new 32 compile-time parameter, LFS_THROTTLE, is used as an upper bound for the 33 number of partial-segments allowed to be in progress writing at any 34 given time. 35 36 - If the system crashes between the point that a checkpoint is scheduled 37 for writing and the time that the write completes, the filesystem 38 could be left in an inconsistent state (no valid checkpoints on 39 disk). To avoid this, we toggle between the first two superblocks 40 when checkpointing, and (if it is indicated that no roll-forward agent 41 exists) do not allow one checkpoint to occur before the last one has 42 completed. When the filesystem is mounted, it uses the *older* of the 43 first two superblocks. 44 45 - DIROPs: 46 47 The design of the LFS includes segregating vnodes used in directory 48 operations, so that they can be written at the same time during a 49 checkpoint, avoiding filesystem inconsistency after a crash. Code for 50 this was partially written for BSD4.4, but was not complete or enabled. 51 52 In particular, vnodes marked VDIROP could be flushed by getnewvnode at 53 any time, negating the usefulness of marking a vnode VDIROP, since if 54 the filesystem then crashed it would be inconsistent. Now, when a 55 vnode is first marked VDIROP it is also referenced. To avoid running 56 out of vnodes, an attempt to mark more than LFS_MAXDIROP vnodes wth 57 VDIROP will sleep, and trigger a partial-segment write when no dirops 58 are active. 59 60 - LFS maintains a linked list of free inode numbers in the Ifile; 61 accesses to this list are now protected by a simple lock. 62 63 - lfs_vfree is not allowed to run while an inode has blocks scheduled 64 for writing, since that could trigger a miscounting in lfs_truncate. 65 66 - lfs_balloc now correctly extends fragments, if a block is written 67 beyond the current end-of-file. 68 69 - Blocks which have already been gathered into a partial-segment are not 70 allowed to be extended, since if they were, any blocks following them 71 would either be written in the wrong place, or overwrite other blocks. 72 73 - The LFS buffer-header accounting, which triggers a partial-segment 74 write if too many buffer-headers are in use by the LFS subsystem, has 75 been expanded to include *bytes* used in LFS buffers as well. 76 77 - Reads of the Ifile, which almost always come from the cleaner, can no 78 longer trigger a partial-segment write, since this could cause a 79 deadlock. 80 81 - Support has been added (but not tested, and currently disabled by 82 default) for true read-only filesystems. Currently, if a filesystem 83 is mounted read-only the cleaner can still operate on it, but this 84 obviously would not be true for read-only media. (I think the 85 original plan was for the roll-forward agent to operate using this 86 "feature"?) 87 88 - If a fake buffer is created by lfs_markv and another process draws the 89 same block in and changes it, the fake buffer is now discarded and 90 replaced by the "real" buffer containing the new data. 91 92 - An inode which has blocks gathered no longer has IN_MODIFIED set, but 93 still does in fact have dirty blocks attached. lfs_update will now 94 wait for such an inode's writes to complete before it runs, 95 suppressing a panic in vinvalbuf. 96 97 - Many filesystem operations now update the Ifile's mtime, allowing the 98 cleaner to detect when the filesystem is idle, and clean more 99 vigorously during such times (cf. Blackwell et al., 1995). 100 101 - When writing a partial-segment, make sure that the current segment is 102 still marked ACTIVE afterward (otherwise the cleaner might try to 103 clean it, since it might well be mostly empty). 104 105 - Don't trust the cleaner so much. Sort the blocks during gathering, 106 even if they came from the cleaner; verify the location of on-disk 107 inodes, even if the cleaner says it knows where they came from. 108 109 - The cleaning code (lfs_markv in particular) has been entirely 110 rewritten, and the partial-segment writing code changed to match. 111 Lfs_markv no longer uses its own implementation of lfs_segwrite, but 112 marks inodes with IN_CLEANING to differentiate them from the 113 non-cleaning inodes. This change fixes numerous problems with the old 114 cleaner, including a buffer overrun, and lost extensions in active 115 fragments. lfs_bmapv looks up and returns the addresses of inode 116 blocks, so the cleaner can do something intelligent with them. 117 118 If IN_CLEANING is set on an inode during partial-segment write, only fake 119 buffers will be written, and IN_MODIFIED will not be cleared, saving 120 us from a panic in vinvalbuf. The addition of IN_CLEANING also allows 121 dirops to be active while cleaning is in progress; since otherwise 122 buffers engaged in active dirops might be written ahead of schedule, 123 and cause an inconsistent checkpoint to be written to disk. 124 125 (XXX - even now, DIROP blocks can sometimes be written to disk, if we 126 are cleaning the same blocks as are active? Grr, I don't see a good 127 solution for this!) 128 129 - Added sysctl entries for LFS. In particular, `writeindir' controls 130 whether indirect blocks are written during non-checkpoint writes. 131 (Since there is no roll-forward agent as yet, there is no penalty in 132 not writing indirect blocks.) 133 134 - Wake up the cleaner at fs-unmount time, so it can die (if we unmount 135 and then remount, we could conceivably get more than one cleaner 136 operating at once). 137 138 newfs_lfs: 139 140 - The ifile inode is now created with the schg flag set, since nothing 141 ever modifies it. This could be a pain for the roll-forward agent, 142 but since that should really run *before* the filesystem is mounted, 143 I don't care. 144 145 - For large disks, it may be necessary to write one or more indirect 146 blocks when the ifile inode is created. Newlfs has been changed to 147 write the first indirect block, if necessary. It should instead just 148 build a set of inodes and blocks, and then use the partial-segment 149 writing routine mentioned above to write an ifile of whatever size is 150 desired. 151 152 lfs_cleanerd: 153 154 - Now writes information to the syslog. 155 156 - Can now deal properly with fragments. 157 158 - Sometimes, the cleaner can die. (Why?) If this happens and we don't 159 notice, we're screwed, since the fs will overfill. So, the invoked 160 cleaner now spawns itself repeatedly, a la init(8), to ensure that a 161 cleaner is always present to clean the fs. 162 163 - Added a flag to clean more actively, not on low load average but 164 filesystem inactivity; a la Blackwell et al., 1995. 165 166 fsck_lfs: 167 168 - Exists, although it currently cannot actually fix anything (it is a 169 diagnostic tool only at this point). 170
Indexes created Mon Sep 29 21:09:56 GMT 2025