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 bb0e216797ecfe9920dc8441b64a67bd28f67a4b (commit)
via 3c81dd124a423f3122121b1b2682eb4cdc276ffe (commit)
via bc4a23ecabc7a178a5d27a075cc13cd0ba6fd2c2 (commit)
via 426e44b30b77bef77da9fa329875db81098c2902 (commit)
from 4825a68653df7d07eb33c5be287903212811a96c (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 bb0e216797ecfe9920dc8441b64a67bd28f67a4b
Author: Milos Nikic <[email protected]>
Date: Wed Oct 7 22:57:14 2026 -0700
ext2fs: Keep the block map of orphan inodes on disk
diskfs_orphan_add cleared i_size, i_size_high, i_blocks and i_block[] of
the on-disk inode, and write_node left those fields alone for as long as
the node stayed on the orphan list. The orphan's blocks then appeared
nowhere on disk except in the bitmaps. At the next mount
ext2_recover_orphan_list read an inode with no size and no blocks, so
diskfs_drop_node freed the inode and left its blocks allocated; e2fsck
cleared the orphan the same way and freed the blocks only in pass 5.
Every file still open when the filesystem shut down leaked its blocks
until the next full check.
ext3 and ext4 keep the orphan's block map, size and block count on disk
and overload only i_dtime as the link to the next orphan. Do the same.
diskfs_orphan_add now only links the inode into the list and clears
i_links_count; write_node writes i_size, i_blocks and i_block[] for an
orphan as for any other inode and leaves only i_dtime to orphan.c. The
truncate at the last close rewrites the block map in the transaction
that frees the blocks, and recovery truncates whatever the orphan still
owns.
The fields were cleared so that a block freed and reused while its
inode was on the orphan list could not be reached through the orphan's
block map. Freed blocks now stay busy until their free commits, so the
block map of an orphan only ever names blocks it still owns, and the
workaround is no longer needed.
Message-ID: <[email protected]>
commit 3c81dd124a423f3122121b1b2682eb4cdc276ffe
Author: Milos Nikic <[email protected]>
Date: Wed Oct 7 22:57:13 2026 -0700
ext2fs: Keep freed blocks busy until their free commits
ext2_free_blocks clears the bitmap bit at once, so ext2_new_block could
hand the block to a new owner while the transaction that freed it was
still running or committing. The journal can hold copies of the
block's old contents in that window: in the freeing transaction, in the
committing one, and in older checkpoint transactions. A home write of
such a copy lands over the new owner's data. A crash before the free
commits also gives the block back to its old owner after the new owner
has overwritten it.
ext3 and ext4 close this window in the allocator: a block freed in a
transaction is allocated again only after that transaction commits. Do
the same. The bitmap and the free counts still change at free time, so
the transaction carries the free as before. The block is also marked
in a per-group busy bitmap kept in memory, and ext2_new_block searches
the block bitmap with the busy blocks marked in use. Group selection
counts only the free blocks that are not busy.
journal_record_freed_blocks now reports whether it recorded the range.
After the commit, journal_forget_freed_blocks marks the copies in the
freeing transaction and in older checkpoint transactions written, waits
for any write of them already in flight, and hands the blocks back with
ext2_release_busy_blocks. Since no freed block has a new owner before
that point, every copy it finds holds the old contents.
When a freed range cannot be tracked for lack of memory, it stays
allocated: a leaked block only costs space until e2fsck frees it, while
reusing it could put an old copy over its new owner.
Discarded preallocations never held data. They go through the new
ext2_free_unused_blocks, which leaves them allocatable at once.
When every free block is busy, ext2_new_block waits for the transaction
committing now to hand its blocks back, and retries. It cannot wait for
the running transaction, which the caller's handle holds open, so it
wakes kjournald to start that commit as soon as the handle drains. A
pager thread never waits. If a commit fails, its freed blocks stay busy
until the next mount.
Without a journal nothing is recorded, and freed blocks are reusable at
once as before.
A copy of a freed block in an older transaction that is still in the
log can be replayed over the block's new owner after a crash. Revoke
records are needed for that; the XXX comment in trunc_indirect now says
so.
Message-ID: <[email protected]>
commit bc4a23ecabc7a178a5d27a075cc13cd0ba6fd2c2
Author: Mikhail Karpov <[email protected]>
Date: Thu Oct 8 01:53:46 2026 +0200
storeio: Fix access mode of partition nodes
commit 426e44b30b77bef77da9fa329875db81098c2902
Author: Mikhail Karpov <[email protected]>
Date: Tue Oct 6 21:18:05 2026 +0700
Fix io_map for the zero store
It is expected to return a null port, so mmap maps an anonymous memory
object.
-----------------------------------------------------------------------
Summary of changes:
ext2fs/balloc.c | 206 +++++++++++++++++++++++++++++++++++++++++++++++-------
ext2fs/ext2fs.h | 8 +++
ext2fs/getblk.c | 3 +-
ext2fs/inode.c | 38 +++++-----
ext2fs/journal.c | 164 +++++++++++++++++++++++++++++++++----------
ext2fs/journal.h | 13 +++-
ext2fs/orphan.c | 19 ++---
ext2fs/truncate.c | 19 ++---
storeio/storeio.c | 77 ++++++++++++++++----
9 files changed, 425 insertions(+), 122 deletions(-)
hooks/post-receive
--
Hurd
