This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Hurd".
The branch, master has been updated
via 4133fc0b38fe2c50ce657dbd8c44e15f270f010b (commit)
via 23324e2911b30c3c93a992abc582f1be6f64ce7c (commit)
via 36c6358d65cb9499f23227553a4e166a1af8f372 (commit)
from 2336993cf542f430a424fbad426844594c80d213 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 4133fc0b38fe2c50ce657dbd8c44e15f270f010b
Author: Milos Nikic <[email protected]>
Date: Sun Oct 25 20:19:19 2026 -0700
ext2fs: Grow preallocation windows for sequential writers
Files written at the same time take blocks in turn, so each file's
fragments were at most the 8-block window long. Eight files appended
to in turn got 1949 fragments per 64 MB file, and four parallel dd of
256 MB got about 6400.
When a file has used up its window and keeps writing sequentially,
give it a window twice as big, up to 1024 blocks; any other miss starts
again from the base size. The window is no longer dropped whenever the
inode is written, which would undo the growth, but at the last close,
so that a closed file leaves no reservation behind.
The appended files now get 23 fragments each, and the dd files about
55 to 70. Kills of the translator during rm -rf and tar -xf, and
filling the disk with several writers, left e2fsck -f clean. With two
concurrent tar -xf of a Linux tree, half as many files are fragmented
(0.4% against 0.8%), but about 200 more holes of 4 to 64K stay in the
free space of a 4 GB disk, 1% of it. Most are the size of what a small
file leaves of its 8-block window, likely given back only after the
next file was placed, as the last close comes in with a no-senders
notification.
Message-ID: <[email protected]>
commit 23324e2911b30c3c93a992abc582f1be6f64ce7c
Author: Milos Nikic <[email protected]>
Date: Sun Oct 25 20:19:18 2026 -0700
ext2fs: Keep block preallocation in memory
Preallocated blocks were marked allocated in the block bitmap while
only the node's memory owned them, so a crash between the allocation
and the discard leaked them. With a journal, a normal boot replays the
log without a full check, and nothing frees them until e2fsck -f.
Killing the translator during tar -xf left such blocks repeatedly.
Reserve the preallocation window in memory instead, in a per-group map
next to the busy blocks. ext2_new_block skips other nodes' reserved
blocks, takes them only when nothing else is free, and sets a block in
the bitmap only when a file takes it. The window is dropped under
alloc_lock, which ext2_alloc_block holds while it uses it, and when the
node is freed. The layout does not change: 8 files appended to in turn
get 1949 fragments per 64 MB file, as before. Ten kills of the
translator at random times during rm -rf and tar -xf of a Linux kernel
tree all left e2fsck -f clean.
Message-ID: <[email protected]>
commit 36c6358d65cb9499f23227553a4e166a1af8f372
Author: Milos Nikic <[email protected]>
Date: Mon Oct 26 09:01:44 2026 -0700
ext2fs: Start a node with no preallocation window
A node can be dropped before its inode is read: a lookup that lost the
race to make it, or whose read of the inode failed, drops the node it
made. Dropping a node gives its preallocation window back, now that
the window is kept in memory, but the window's fields were only set
when the inode was read. Such a node gave back garbage.
Clear the window when the node is made.
-----------------------------------------------------------------------
Summary of changes:
ext2fs/balloc.c | 274 ++++++++++++++++++++++++++++++++++++++----------------
ext2fs/ext2_fs.h | 3 +
ext2fs/ext2fs.h | 6 +-
ext2fs/getblk.c | 70 ++++++++------
ext2fs/ialloc.c | 1 +
ext2fs/inode.c | 23 ++++-
ext2fs/truncate.c | 4 +-
7 files changed, 262 insertions(+), 119 deletions(-)
hooks/post-receive
--
Hurd
