[PATCH v3 0/11] vfs: add inode iteration methods

From: Huang Shijie

Date: Thu Nov 19 2026 - 22:13:59 EST


This series adds two superblock inode iteration helpers,
super_iter_inodes() and super_iter_inodes_locked(), and converts the
open-coded sb->s_inodes walks in the VFS to them. The design is based on
Dave Chinner's patch set:
"vfs: improving inode cache iteration scalability"
https://lore.kernel.org/all/20241002014017.3801899-1-david@xxxxxxxxxxxxx/

About the two helpers:

int super_iter_inodes(struct super_block *sb, ino_iter_fn iter_fn,
ino_iter_eligible_fn eligible, void *priv,
int flags);

static inline int super_iter_inodes_locked(struct super_block *sb,
ino_iter_fn iter_fn,
void *priv);

- super_iter_inodes() runs @iter_fn with a referenced inode and with
sb->s_inode_list_lock __dropped__, so the callback is free to block and
to do whatever it wants with the inode except drop the reference the
iterator holds. The iterator releases that one reference per inode
itself, so the callback cannot leave a dangling inode behind.
It is exported because GFS2 can be built as a module.

- super_iter_inodes_locked() keeps sb->s_inode_list_lock held for the
whole walk and takes no inode references at all. Its callback
therefore only has an existence guarantee: it must not block and
must do its own inode state checks and its own reference handling.
It is internal to the VFS, being declared in fs/internal.h.

- The callback is separate from the caller's data, so a caller keeps
its state in its own structure instead of filling in a shared
context:

typedef int (*ino_iter_fn)(struct inode *inode, void *priv);

- %INO_ITER_F_REFERENCED restricts the safe iterator to inodes that
still have a reference. It preserves the "only handle referenced
inodes" rule of landlock's sb-delete walk.

- %INO_ITER_F_NOREF does the opposite: only inodes whose reference
count has already reached zero are handed out. %INO_ITER_F_NOIGET
suppresses the reference. Neither keeps the inode alive, so the
caller must make it unclaimable itself.

Patch 1 adds super_iter_inodes().
Patch 2 adds super_iter_inodes_locked().
Patch 3-5 convert the callers which cannot use referenced inodes
(dquot removal, nr_blockdev_pages() and the
generic_shutdown_super() poisoning loop).
Patch 6-11 convert the remaining callers (inode eviction, sync_bdevs,
drop_pagecache_sb, add_dquot_ref, landlock's hook_sb_delete
and gfs2_evict_inodes()).


BTW:
This patch set depends a small patch:
"fs/drop_caches: skip filesystems without fs writeback"
https://lkml.org/lkml/2026/9/23/675

v2-->v3:
-the callers' state no longer goes through a shared struct, the
callback now takes the caller's own @priv.

-super_iter_inodes() takes @eligible directly, so a caller can reject
an inode before the reference is paid for.

-rename super_iter_inodes_unsafe() to super_iter_inodes_locked() and
drop the rcu_read_lock(), which the list lock already covers.

-drop @ctx->prev; the resume point is gone with the unsafe iterator.

-evict_inodes() no longer goes through the locked iterator.
it now uses the unlocked iterator with INO_ITER_F_NOREF | INO_ITER_F_NOIGET.

-each caller gets its own patch.

v2: https://lore.kernel.org/all/20261113115702.586594-1-huangsj@xxxxxxxx/
v1: https://lore.kernel.org/all/20261015093854.2082600-1-huangsj@xxxxxxxx/

Huang Shijie (11):
vfs: add super_iter_inodes()
vfs: add super_iter_inodes_locked()
fs/quota: convert remove_dquot_ref() to super_iter_inodes_locked()
block: convert nr_blockdev_pages() to super_iter_inodes_locked()
fs: convert generic_shutdown_super() poison loop
fs/inode: convert evict_inodes() to super_iter_inodes()
block: convert sync_bdevs() to super_iter_inodes()
fs/drop_caches: convert drop_pagecache_sb() to super_iter_inodes()
fs/quota: convert add_dquot_ref() to super_iter_inodes()
landlock: convert hook_sb_delete() to super_iter_inodes()
gfs2: convert gfs2_evict_inodes() to super_iter_inodes()

block/bdev.c | 101 ++++++++++--------------
fs/drop_caches.c | 45 ++++-------
fs/gfs2/ops_fstype.c | 29 ++-----
fs/inode.c | 61 ++++++---------
fs/internal.h | 31 ++++++++
fs/quota/dquot.c | 139 ++++++++++++++++-----------------
fs/super.c | 106 ++++++++++++++++++++++---
include/linux/fs/super_types.h | 29 +++++++
security/landlock/fs.c | 138 ++++++++++++--------------------
9 files changed, 370 insertions(+), 309 deletions(-)

--
2.53.0