generic_permission() optimization

generic_permission() optimization

[Linus Torvalds]

[-- Attachment #1: Type: text/plain, Size: 2119 bytes --]

So call me crazy, but due to entirely unrelated changes (the x86
barrier_nospec optimization) I was doing some profiles to check that
everything looked fine.

And just looking at kernel profiles, I noticed that
"generic_permission()" wasn't entirely in the noise. It was right
there along with strncpy_from_user() etc. Which is a bit surprising,
because it should be really cheap to check basic Unix permissions?

It's all really just "acl_permission_check()" and that code is
actually fairly optimized, except that the whole

        vfsuid = i_uid_into_vfsuid(idmap, inode);

to check whether we're the owner is *not* cheap. It causes a call to
make_vfsuid(), and it's just messy.

Which made me wonder: we already have code that says "if the Group and
Other permission bits are the same wrt the mask we are checking, don't
bother doing the expensive group checks".

Why not extend that to "if any of the UGO choices are ok with the
permissions, why bother looking up ownership at all?"

Now, there is one reason to look up the owner: POSIX ACL's don't
matter to owners, but do matter to others.

But we could check for the cached case of "no POSIX ACLs" very
cheaply, and only do it for that case.

IOW, a patch something like the attached.

No, I didn't really check whether it makes any difference at all. But
my gut feel is that a *lot* of permission checks succeed for any user,
with things like system directories are commonly drwxr-xr-x, so if you
want to check read or execute permissions, it really doesn't matter
whether you are the User, the Group, or Other.

So thus the code does that

        unsigned int all;
        all = mode & (mode >> 3); // combine g into o
        all &= mode >> 6;         // ... and u into o

so now the low three bits of 'all' are the bits that *every* case has
set. And then

        if (!(mask & ~all & 7))
                return 0;

basically says "if what we are asking for is not zero in any of those
bits, we're good".

And it's entirely possible that I'm missing something silly and am
being just stupid. Somebody hit me with the clue bat if so.

               Linus

[-- Attachment #2: patch.diff --]
[-- Type: text/x-patch, Size: 1558 bytes --]

 fs/namei.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/fs/namei.c b/fs/namei.c
index 4a4a22a08ac2..6aeabde0ec9f 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -326,6 +326,25 @@ static int check_acl(struct mnt_idmap *idmap,
 	return -EAGAIN;
 }
 
+/*
+ * Very quick optimistic "we know we have no ACL's" check.
+ *
+ * Note that this is purely for ACL_TYPE_ACCESS, and purely
+ * for the "we have cached that there are no ACLs" case.
+ *
+ * If this returns true, we know there are no ACLs. But if
+ * it returns false, we might still not have ACLs (it could
+ * be the is_uncached_acl() case).
+ */
+static inline bool no_acl_inode(struct inode *inode)
+{
+#ifdef CONFIG_FS_POSIX_ACL
+	return likely(!READ_ONCE(inode->i_acl));
+#else
+	return true;
+#endif
+}
+
 /**
  * acl_permission_check - perform basic UNIX permission checking
  * @idmap:	idmap of the mount the inode was found from
@@ -348,6 +367,19 @@ static int acl_permission_check(struct mnt_idmap *idmap,
 	unsigned int mode = inode->i_mode;
 	vfsuid_t vfsuid;
 
+	/*
+	 * Common cheap case: everybody has the requested
+	 * rights, and there are no ACLs to check. No need
+	 * to do any owner/group checks.
+	 */
+	if (no_acl_inode(inode)) {
+		unsigned int all;
+		all = mode & (mode >> 3); // combine g into o
+		all &= mode >> 6;	  // ... and u into o
+		if (!(mask & ~all & 7))
+			return 0;
+	}
+
 	/* Are we the owner? If so, ACL's don't matter */
 	vfsuid = i_uid_into_vfsuid(idmap, inode);
 	if (likely(vfsuid_eq_kuid(vfsuid, current_fsuid()))) {

Re: generic_permission() optimization

[Al Viro]

On Wed, Oct 30, 2024 at 06:16:22PM -1000, Linus Torvalds wrote:

> +static inline bool no_acl_inode(struct inode *inode)
> +{
> +#ifdef CONFIG_FS_POSIX_ACL
> +	return likely(!READ_ONCE(inode->i_acl));
> +#else
> +	return true;
> +#endif
> +}

Hmm... Shouldn't there be || !IS_POSIXACL(inode) in there?

Re: generic_permission() optimization

[Linus Torvalds]

On Wed, 30 Oct 2024 at 20:05, Al Viro <viro@zeniv.linux.org.uk> wrote:
>
> On Wed, Oct 30, 2024 at 06:16:22PM -1000, Linus Torvalds wrote:
>
> > +static inline bool no_acl_inode(struct inode *inode)
> > +{
> > +#ifdef CONFIG_FS_POSIX_ACL
> > +     return likely(!READ_ONCE(inode->i_acl));
> > +#else
> > +     return true;
> > +#endif
> > +}
>
> Hmm... Shouldn't there be || !IS_POSIXACL(inode) in there?

I was going for "intentionally minimalistic". IOW, this was meant to
be an optimization for a presumed common case, but fall back to the
generic code quickly and simply.

Put another way: is the !IS_POSIXACL() actually a common situation
worth optimizing for?

Do real people actually use "noacl"? My gut feel is that it was one of
those mistakes that some random odd case is using, but not something
worth really optimizing for.

But maybe some common situation ends up using it even without "noacl"
- like /proc, perhaps?

I was kind of hoping that such cases would use 'cache_no_acl()' which
makes that inode->i_acl be NULL. Wouldn't that be the right model
anyway for !IS_POSIXACL()?

Anyway, this is all obviously a "matter of tuning the optimization".
And I don't actually know if it's even worth doing in the first place.

From just the profiles I looked at, that make_vfsuid() conversion
looked like a surprisingly big deal, but obviously this optimistic
fast case wouldn't remove all such cases anyway.

               Linus

Re: generic_permission() optimization

[Christian Brauner]

On Wed, Oct 30, 2024 at 06:16:22PM -1000, Linus Torvalds wrote:
> So call me crazy, but due to entirely unrelated changes (the x86
> barrier_nospec optimization) I was doing some profiles to check that
> everything looked fine.
> 
> And just looking at kernel profiles, I noticed that
> "generic_permission()" wasn't entirely in the noise. It was right
> there along with strncpy_from_user() etc. Which is a bit surprising,
> because it should be really cheap to check basic Unix permissions?
> 
> It's all really just "acl_permission_check()" and that code is
> actually fairly optimized, except that the whole
> 
>         vfsuid = i_uid_into_vfsuid(idmap, inode);
> 
> to check whether we're the owner is *not* cheap. It causes a call to
> make_vfsuid(), and it's just messy.

I assume you ran your benchmark on baremetal so no containers or
idmappings? I find this somewhat suprising. One thing to optimize here
independent of your proposal would be to try and __always_inline
make_vfsuid().

> 
> Which made me wonder: we already have code that says "if the Group and
> Other permission bits are the same wrt the mask we are checking, don't
> bother doing the expensive group checks".
> 
> Why not extend that to "if any of the UGO choices are ok with the
> permissions, why bother looking up ownership at all?"
> 
> Now, there is one reason to look up the owner: POSIX ACL's don't
> matter to owners, but do matter to others.
> 
> But we could check for the cached case of "no POSIX ACLs" very
> cheaply, and only do it for that case.
> 
> IOW, a patch something like the attached.

I think this should work (though I find the permission checking model in
general to be an unruly mess - that's ignoring the fun hardening bits of
it...).

Can you send give me a proper SoB patch? Liberal comments in the code
would be appreciated. I'd like to put this through LTP and some of the
permission tests I've written over the years.

> 
> No, I didn't really check whether it makes any difference at all. But
> my gut feel is that a *lot* of permission checks succeed for any user,
> with things like system directories are commonly drwxr-xr-x, so if you
> want to check read or execute permissions, it really doesn't matter
> whether you are the User, the Group, or Other.
> 
> So thus the code does that
> 
>         unsigned int all;
>         all = mode & (mode >> 3); // combine g into o
>         all &= mode >> 6;         // ... and u into o
> 
> so now the low three bits of 'all' are the bits that *every* case has
> set. And then
> 
>         if (!(mask & ~all & 7))
>                 return 0;
> 
> basically says "if what we are asking for is not zero in any of those
> bits, we're good".
> 
> And it's entirely possible that I'm missing something silly and am
> being just stupid. Somebody hit me with the clue bat if so.
> 
>                Linus

Re: generic_permission() optimization

[Linus Torvalds]

On Wed, 30 Oct 2024 at 20:42, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> I was kind of hoping that such cases would use 'cache_no_acl()' which
> makes that inode->i_acl be NULL. Wouldn't that be the right model
> anyway for !IS_POSIXACL()?

Alternatively, just initialize it to NULL in inode_init_always_gfp(), eg like

-       inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
+       inode->i_acl = inode->i_default_acl =
+               (sb->s_flags & SB_POSIXACL) ? ACL_NOT_CACHED : NULL;

or similar?

            Linus

Re: generic_permission() optimization

[Linus Torvalds]

On Thu, 31 Oct 2024 at 03:07, Christian Brauner <brauner@kernel.org> wrote:
>
> > It's all really just "acl_permission_check()" and that code is
> > actually fairly optimized, except that the whole
> >
> >         vfsuid = i_uid_into_vfsuid(idmap, inode);
> >
> > to check whether we're the owner is *not* cheap. It causes a call to
> > make_vfsuid(), and it's just messy.
>
> I assume you ran your benchmark on baremetal so no containers or
> idmappings? I find this somewhat suprising.

Yes, I did too, this is the "simple" case for the whole uid mapping
case, and I didn't expect it to be noticeable.

That said, that function is just called a *LOT*. It's not just for
each file opened, it's called for each path component as part of
filename lookup, for that may_lookup_inode_permission ->
do_inode_permission -> generic_permission -> acl_permission_check
path.

>          One thing to optimize here
> independent of your proposal would be to try and __always_inline
> make_vfsuid().

Maybe. Part of the cost seems to be the call, but a bigger part seems
to be the memory accesses around it with that whole
inode->i_sb->s_user_ns chain to load it, and then current->cred->fsuid
to compare against the result.

Anyway, I'll play around with this a bit more and try to get better profiles.

                Linus

Re: generic_permission() optimization

[Linus Torvalds]

On Thu, 31 Oct 2024 at 09:04, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> Maybe. Part of the cost seems to be the call, but a bigger part seems
> to be the memory accesses around it with that whole
> inode->i_sb->s_user_ns chain to load it, and then current->cred->fsuid
> to compare against the result.
>
> Anyway, I'll play around with this a bit more and try to get better profiles.

Ok, so I've done some more profiles, and yeah, the costs seem to be
almost entirely just cache misses.

make_vfsuid() shows up on the profile a bit too, but that seems to
really be literally just "it's called a lot, and takes some I$
misses".

When the profile looks like this:

 10.71 │      push %rbx
 15.44 │      mov  %edx,%eax
  7.88 │      mov  %rdi,%rbx
       │      cmp  $0xffffffff82532a00,%rdi
  9.65 │    ↓ je   3a
... nothing ...
 15.00 │ffffffff813493fa:   pop  %rbx
 41.33 │ffffffff813493fb: → jmp  ffffffff81bb5460 <__x86_return_thunk>

then it really looks like cache misses and some slow indirect branch
resolution for 'ret' (that __x86_return_thunk branch is misleading -
it is rewritten at runtime, but 'perf report' shows the original
object code).

So some of it is presumably due to IBRS on this CPU, and that's a big
part of make_vfsuid() in this bare-metal non-idmapped case. But the
profile does clearly say that in generic_permission(), the problem is
just the cache misses on the superblock accesses and all the extra
work with the credential check, even when the mapping is the identity
mapping.

I still get a fair number of calls to make_vfsuid() even with my patch
- I guess I'll have to look into why. This is my regular "full build
of an already built kernel", which I *expected* to be mainly just a
lot of fstat() calls by 'make' which I would have thought almost
always hit the fast case.

I might have messed something up.

               Linus

Re: generic_permission() optimization

[Al Viro]

On Thu, Oct 31, 2024 at 08:14:59AM -1000, Linus Torvalds wrote:
> On Wed, 30 Oct 2024 at 20:42, Linus Torvalds
> <torvalds@linux-foundation.org> wrote:
> >
> > I was kind of hoping that such cases would use 'cache_no_acl()' which
> > makes that inode->i_acl be NULL. Wouldn't that be the right model
> > anyway for !IS_POSIXACL()?
> 
> Alternatively, just initialize it to NULL in inode_init_always_gfp(), eg like
> 
> -       inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;
> +       inode->i_acl = inode->i_default_acl =
> +               (sb->s_flags & SB_POSIXACL) ? ACL_NOT_CACHED : NULL;

IIRC, the reason we do not do that was the possibility of mount -o remount,acl
Not that it makes much sense, but it's currently supported and POSIX ACLs
don't make much sense to start with...

Anyway, patch looks sane; I still think that adding || !IS_POSIXACL(inode)
wouldn't hurt (yes, it's a dereference of ->i_sb in case when ->i_acl
is ACL_NOT_CACHED, but we are going to dereference it shortly after
in case we don't take the fast path.  OTOH, that probably matters only
for fairly specific loads - massive accesses to procfs and sysfs, mostly.

Re: generic_permission() optimization

[Linus Torvalds]

On Thu, 31 Oct 2024 at 12:02, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> I still get a fair number of calls to make_vfsuid() even with my patch
> - I guess I'll have to look into why. This is my regular "full build
> of an already built kernel", which I *expected* to be mainly just a
> lot of fstat() calls by 'make' which I would have thought almost
> always hit the fast case.
>
> I might have messed something up.

Added some stats, and on my load (reading email in the web browser,
some xterms and running an allmodconfig kernel build), I get about a
45% hit-rate for the fast-case: out of 44M calls to
generic_permission(), about 20M hit the fast-case path.

So it's noticeable, but not *quite* as noticeable as I would have
hoped for. I suspect there are a fair number of owner calls for write,
and then because permissions are 0644, the code actually has to check
the owner.

              Linus

Re: generic_permission() optimization

[Linus Torvalds]

On Thu, 31 Oct 2024 at 12:28, Al Viro <viro@zeniv.linux.org.uk> wrote:
>
> Anyway, patch looks sane; I still think that adding || !IS_POSIXACL(inode)
> wouldn't hurt (yes, it's a dereference of ->i_sb in case when ->i_acl
> is ACL_NOT_CACHED, but we are going to dereference it shortly after
> in case we don't take the fast path.  OTOH, that probably matters only
> for fairly specific loads - massive accesses to procfs and sysfs, mostly.

Yeah, so the reason I'd like to avoid it is exactly that the i_sb
accesses are the ones that show up in profiles.

So I'd rather start with just the cheap inode-only "ACL is clearly not
there" check, and later if we find that the ACL_NOT_CACHED case is
problematic do we look at that.

           Linus

Re: generic_permission() optimization

[Linus Torvalds]

[-- Attachment #1: Type: text/plain, Size: 1271 bytes --]

On Thu, 31 Oct 2024 at 12:34, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> So I'd rather start with just the cheap inode-only "ACL is clearly not
> there" check, and later if we find that the ACL_NOT_CACHED case is
> problematic do we look at that.

Actually, if I switch the tests around so that I do the permission bit
check first, it becomes very natural to just check IS_POSIXACL() at
the end (where we're about to go to the slow case, which will be
touching i_sb anyway).

Plus I can actually improve code generation by not shifting the mode
bits down into the low bits, but instead spreading the requested
permission bits around.

The "spread bits around" becomes a simple constant multiplication with
just three bits set, and the compiler will actually generate much
better code (you can do it with two consecutive 'lea' instructions).

The expression for this ends up looking a bit like line noise, so a
comment explaining each step is a good idea.

IOW, here's a rewritten patch that does it that way around, and thus
deals with IS_POSIXACL() very naturally and seems to generate quite
good code for me.

Of course, while I actually tested the previous version after sending
it out, this new version is entirely untested. Again.

             Linus

[-- Attachment #2: patch.diff --]
[-- Type: text/x-patch, Size: 1965 bytes --]

 fs/namei.c | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/fs/namei.c b/fs/namei.c
index 4a4a22a08ac2..80f9a14ca9a5 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -326,6 +326,25 @@ static int check_acl(struct mnt_idmap *idmap,
 	return -EAGAIN;
 }
 
+/*
+ * Very quick optimistic "we know we have no ACL's" check.
+ *
+ * Note that this is purely for ACL_TYPE_ACCESS, and purely
+ * for the "we have cached that there are no ACLs" case.
+ *
+ * If this returns true, we know there are no ACLs. But if
+ * it returns false, we might still not have ACLs (it could
+ * be the is_uncached_acl() case).
+ */
+static inline bool no_acl_inode(struct inode *inode)
+{
+#ifdef CONFIG_FS_POSIX_ACL
+	return likely(!READ_ONCE(inode->i_acl));
+#else
+	return true;
+#endif
+}
+
 /**
  * acl_permission_check - perform basic UNIX permission checking
  * @idmap:	idmap of the mount the inode was found from
@@ -348,6 +367,28 @@ static int acl_permission_check(struct mnt_idmap *idmap,
 	unsigned int mode = inode->i_mode;
 	vfsuid_t vfsuid;
 
+	/*
+	 * Common cheap case: everybody has the requested
+	 * rights, and there are no ACLs to check. No need
+	 * to do any owner/group checks in that case.
+	 *
+	 *  - 'mask&7' is the requested permission bit set
+	 *  - multiplying by 0111 spreads them out to all of ugo
+	 *  - '& ~mode' looks for missing inode permission bits
+	 *  - the '!' is for "no missing permissions"
+	 *
+	 * After that, we just need to check that there are no
+	 * ACL's on the inode - do the 'IS_POSIXACL()' check last
+	 * because it will dereference the ->i_sb pointer and we
+	 * want to avoid that if at all possible.
+	 */
+	if (!((mask & 7)*0111 & ~mode)) {
+		if (no_acl_inode(inode))
+			return 0;
+		if (!IS_POSIXACL(inode))
+			return 0;
+	}
+
 	/* Are we the owner? If so, ACL's don't matter */
 	vfsuid = i_uid_into_vfsuid(idmap, inode);
 	if (likely(vfsuid_eq_kuid(vfsuid, current_fsuid()))) {

Re: generic_permission() optimization

[Al Viro]

On Thu, Oct 31, 2024 at 03:17:18PM -1000, Linus Torvalds wrote:
> On Thu, 31 Oct 2024 at 12:34, Linus Torvalds
> <torvalds@linux-foundation.org> wrote:
> >
> > So I'd rather start with just the cheap inode-only "ACL is clearly not
> > there" check, and later if we find that the ACL_NOT_CACHED case is
> > problematic do we look at that.
> 
> Actually, if I switch the tests around so that I do the permission bit
> check first, it becomes very natural to just check IS_POSIXACL() at
> the end (where we're about to go to the slow case, which will be
> touching i_sb anyway).
> 
> Plus I can actually improve code generation by not shifting the mode
> bits down into the low bits, but instead spreading the requested
> permission bits around.
> 
> The "spread bits around" becomes a simple constant multiplication with
> just three bits set, and the compiler will actually generate much
> better code (you can do it with two consecutive 'lea' instructions).
> 
> The expression for this ends up looking a bit like line noise, so a
> comment explaining each step is a good idea.
> 
> IOW, here's a rewritten patch that does it that way around, and thus
> deals with IS_POSIXACL() very naturally and seems to generate quite
> good code for me.

Acked-by: Al Viro <viro@zeniv.linux.org.uk>

Re: generic_permission() optimization

[Christian Brauner]

On Thu, Oct 31, 2024 at 03:17:18PM -1000, Linus Torvalds wrote:
> On Thu, 31 Oct 2024 at 12:34, Linus Torvalds
> <torvalds@linux-foundation.org> wrote:
> >
> > So I'd rather start with just the cheap inode-only "ACL is clearly not
> > there" check, and later if we find that the ACL_NOT_CACHED case is
> > problematic do we look at that.
> 
> Actually, if I switch the tests around so that I do the permission bit
> check first, it becomes very natural to just check IS_POSIXACL() at
> the end (where we're about to go to the slow case, which will be
> touching i_sb anyway).

Applied.

Re: generic_permission() optimization

[Linus Torvalds]

So I realize that Christian already applied my patch, but I'm coming
back to this because I figured out why it doesn't work as well as I
thought it would..

On Thu, 31 Oct 2024 at 12:31, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> Added some stats, and on my load (reading email in the web browser,
> some xterms and running an allmodconfig kernel build), I get about a
> 45% hit-rate for the fast-case: out of 44M calls to
> generic_permission(), about 20M hit the fast-case path.

So the 45% hit rate really bothered me, because on the load I was
testing I really thought it should be 100%.

And in fact, sometimes it *was* 100% when I did profiles, and I never
saw the slow case at all. So I saw that odd bimodal behavior where
sometimes about half the accesses went through the slow path, and
sometimes none of them did.

It took me way too long to realize why that was the case:  the quick
"do we have ACL's" test works wonderfully well when the ACL
information is cached, but the cached case isn't always filled in.

For some unfathomable reason I just mindlessly thought that "if the
ACL info isn't filled in, and we will go to the slow case, it now
*will* be filled in, so next time around we'll have it in the cache".

But that was just silly of me. We may never call "check_acl()" at all,
because if we do the lookup as the owner, we never even bother to look
up any ACL information:

        /* Are we the owner? If so, ACL's don't matter */

So next time around, the ACL info *still* won't be filled in, and so
we *still* won't take the fastpath.

End result: that patch is not nearly as effective as I would have
liked. Yes, it actually gets reasonable hit-rates, but the
ACL_NOT_CACHED state ends up being a lot stickier than my original
mental model incorrectly throught it would be.

So the "45% hit rate" was actually on all the successful quick cases
for system directory traversal where I was looking at files as a
non-owner, but all my *own* files wouldn't hit the fast case.

So that old optimization where we don't even bother looking up ACL's
if we are the owner is actually hindering the new optimization from
being effective.

Very annoying. The "don't bother with ACL's if we are the owner" is
definitely a good thing, so I don't want to disable one optimization
just to enable another one.

(Side note: the reason I sometimes saw 100% hit rates on my test was
that a "make install" as root on my kernel tree *would* populate the
ACL caches because now that tree was looked at by a non-owner).

I'll think about this some more. And maybe somebody smarter than me
sees a good solution before I do.

                  Linus

Re: generic_permission() optimization

[Mateusz Guzik]

On Thu, Nov 07, 2024 at 09:54:36AM -1000, Linus Torvalds wrote:
> On Thu, 31 Oct 2024 at 12:31, Linus Torvalds
> <torvalds@linux-foundation.org> wrote:
> >
> > Added some stats, and on my load (reading email in the web browser,
> > some xterms and running an allmodconfig kernel build), I get about a
> > 45% hit-rate for the fast-case: out of 44M calls to
> > generic_permission(), about 20M hit the fast-case path.
> 
> So the 45% hit rate really bothered me, because on the load I was
> testing I really thought it should be 100%.
> 
> And in fact, sometimes it *was* 100% when I did profiles, and I never
> saw the slow case at all. So I saw that odd bimodal behavior where
> sometimes about half the accesses went through the slow path, and
> sometimes none of them did.
> 
> It took me way too long to realize why that was the case:  the quick
> "do we have ACL's" test works wonderfully well when the ACL
> information is cached, but the cached case isn't always filled in.
> 
> For some unfathomable reason I just mindlessly thought that "if the
> ACL info isn't filled in, and we will go to the slow case, it now
> *will* be filled in, so next time around we'll have it in the cache".
> 
> But that was just silly of me. We may never call "check_acl()" at all,
> because if we do the lookup as the owner, we never even bother to look
> up any ACL information:
> 
>         /* Are we the owner? If so, ACL's don't matter */
> 
> So next time around, the ACL info *still* won't be filled in, and so
> we *still* won't take the fastpath.
> 
> End result: that patch is not nearly as effective as I would have
> liked. Yes, it actually gets reasonable hit-rates, but the
> ACL_NOT_CACHED state ends up being a lot stickier than my original
> mental model incorrectly throught it would be.
> 

How about filesystems maintaing a flag: IOP_EVERYONECANTRAREVERSE?
The name is a keybordfull and not the actual proposal.

Rationale:
To my reading generic_permission gets called for all path components,
where almost all of them just want to check if they can traverse.

So happens for vast majority of real path components the x is there for
*everyone*. Even in case of /home/$user/crap, while the middle dir has x
only for the owner and maybe the group, everything *below* tends to also
be all x.

I just did a kernel build while poking at the state with bpftrace:
bpftrace -e 'kprobe:generic_permission { @[(((struct inode *)arg1)->i_mode & 0x49) == 0x49] = count(); }'

result:
@[0]: 5623736
@[1]: 64867147

iow in 92% of calls everyone had x. Also note this collects calls for
non-traversal, so the real hit ratio is higher so to speak. I don't use
acls here so they were of no consequence anyway btw.

So if a filesystem cares to be faster, when instatianating an inode or
getting setattr called on it it can (re)compute if there is anything
blocking x for anyone. If nothing is in the way it can the flag and
allow link_path_walk to skip everything, otherwise *unset* the flag (as
needed).

This is completely transparent to filesystems which don't participate.

So that would be my proposal, no interest in coding it.

Re: generic_permission() optimization

[Linus Torvalds]

On Thu, 7 Nov 2024 at 12:22, Mateusz Guzik <mjguzik@gmail.com> wrote:
>
> How about filesystems maintaing a flag: IOP_EVERYONECANTRAREVERSE?

It's actually just easier if a filesystem just does

        cache_no_acl(inode);

in its read-inode function if it knows it has no ACL's.

Some filesystems already do that, eg btrfs has

        /*
         * try to precache a NULL acl entry for files that don't have
         * any xattrs or acls
         */
        ....
        if (!maybe_acls)
                cache_no_acl(inode);

in btrfs_read_locked_inode(). If that 'maybe' is just reliable enough,
that's all it takes.

I tried to do the same thing for ext4, and failed miserably, but
that's probably because my logic for "maybe_acls" was broken since I'm
not familiar enough with ext4 at that level, and I made it do just

        /* Initialize the "no ACL's" state for the simple cases */
        if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
                cache_no_acl(inode);

which doesn't seem to be a strong enough text.

              Linus

Re: generic_permission() optimization

[Mateusz Guzik]

On Thu, Nov 7, 2024 at 11:49 PM Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> On Thu, 7 Nov 2024 at 12:22, Mateusz Guzik <mjguzik@gmail.com> wrote:
> >
> > How about filesystems maintaing a flag: IOP_EVERYONECANTRAREVERSE?
>
> It's actually just easier if a filesystem just does
>
>         cache_no_acl(inode);
>
> in its read-inode function if it knows it has no ACL's.
>
> Some filesystems already do that, eg btrfs has
>
>         /*
>          * try to precache a NULL acl entry for files that don't have
>          * any xattrs or acls
>          */
>         ....
>         if (!maybe_acls)
>                 cache_no_acl(inode);
>
> in btrfs_read_locked_inode(). If that 'maybe' is just reliable enough,
> that's all it takes.
>
> I tried to do the same thing for ext4, and failed miserably, but
> that's probably because my logic for "maybe_acls" was broken since I'm
> not familiar enough with ext4 at that level, and I made it do just
>
>         /* Initialize the "no ACL's" state for the simple cases */
>         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
>                 cache_no_acl(inode);
>
> which doesn't seem to be a strong enough text.
>

[ roping in ext4 people ]

I plopped your snippet towards the end of __ext4_iget:

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 4008551bbb2d..34189d85e363 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -5071,7 +5071,12 @@ struct inode *__ext4_iget(struct super_block
*sb, unsigned long ino,
                goto bad_inode;
        }

+       /* Initialize the "no ACL's" state for the simple cases */
+       if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
+               cache_no_acl(inode);
+
        brelse(iloc.bh);

bpftrace over a kernel build shows almost everything is sorted out:
 bpftrace -e 'kprobe:security_inode_permission { @[((struct inode
*)arg0)->i_acl] = count(); }'

@[0xffffffffffffffff]: 23810
@[0x0]: 65984202

That's just shy of 66 mln calls where the acls were explicitly set to
empty, compared to less than 24k where it was the default "uncached"
state.

So indeed *something* is missed, but the patch does cover almost everything.

Perhaps the ext4 guys would chime in and see it through? :)

The context is speeding path lookup by avoiding some of the branches
during permission checking.

-- 
Mateusz Guzik <mjguzik gmail.com>

Re: generic_permission() optimization

[Linus Torvalds]

On Sat, 12 Apr 2025 at 09:26, Mateusz Guzik <mjguzik@gmail.com> wrote:
>
> I plopped your snippet towards the end of __ext4_iget:

That's literally where I did the same thing, except I put it right after the

          brelse(iloc.bh);

line, rather than before as you did.

And it made no difference for me, but I didn't try to figure out why.
Maybe some environment differences? Or maybe I just screwed up my
testing...

As mentioned earlier in the thread, I had this bi-modal distribution
of results, because if I had a load where the *non*-owner of the inode
looked up the pathnames, then the ACL information would get filled in
when the VFS layer would do the lookup, and then once the ACLs were
cached, everything worked beautifully.

But if the only lookups of a path were done by the owner of the inodes
(which is typical for at least my normal kernel build tree - nothing
but my build will look at the files, and they are obviously always
owned by me) then the ACL caches will never be filled because there
will never be any real ACL lookups.

And then rather than doing the nice efficient "no ACLs anywhere, no
need to even look", it ends up having to actually do the vfsuid
comparison for the UID equality check.

Which then does the extra accesses to look up the idmap etc, and is
visible in the profiles due to that whole dance:

        /* Are we the owner? If so, ACL's don't matter */
        vfsuid = i_uid_into_vfsuid(idmap, inode);
        if (likely(vfsuid_eq_kuid(vfsuid, current_fsuid()))) {

even when idmap is 'nop_mnt_idmap' and it is reasonably cheap. Just
because it ends up calling out to different functions and does extra
D$ accesses to the inode and the suberblock (ie i_user_ns() is this

        return inode->i_sb->s_user_ns;

so just to *see* that it's nop_mnt_idmap takes effort.

One improvement might be to cache that 'nop_mnt_idmap' thing in the
inode as a flag.

But it would be even better if the filesystem just initializes the
inode at inode read time to say "I have no ACL's for this inode" and
none of this code will even trigger.

                  Linus

Re: generic_permission() optimization

[Theodore Ts'o]

On Sat, Apr 12, 2025 at 06:26:09PM +0200, Mateusz Guzik wrote:
> > I tried to do the same thing for ext4, and failed miserably, but
> > that's probably because my logic for "maybe_acls" was broken since I'm
> > not familiar enough with ext4 at that level, and I made it do just

Linus, what problems did you run into?

> >         /* Initialize the "no ACL's" state for the simple cases */
> >         if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
> >                 cache_no_acl(inode);
> >
> > which doesn't seem to be a strong enough text.

Linus, were you running into false positives or false negatives?  You
said "failed miserably", which seems to imply that you ran into cases
where cache_no_acl() got called when the inode actually had an ACL ---
e.g., a false positive.

That's different from what Mateuz is reporting which is that most
inodes w/o ACL were getting cache_no_acl(), but some cases
cache_no_acl() was't getting called when it should.  That is, a flase
negative:

> bpftrace over a kernel build shows almost everything is sorted out:
>  bpftrace -e 'kprobe:security_inode_permission { @[((struct inode
> *)arg0)->i_acl] = count(); }'
> 
> @[0xffffffffffffffff]: 23810
> @[0x0]: 65984202
> 
> That's just shy of 66 mln calls where the acls were explicitly set to
> empty, compared to less than 24k where it was the default "uncached"
> state.
> 
> So indeed *something* is missed, but the patch does cover almost everything.

So the test which we're talking about:

> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index 4008551bbb2d..34189d85e363 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -5071,7 +5071,12 @@ struct inode *__ext4_iget(struct super_block
> *sb, unsigned long ino,
>                 goto bad_inode;
>         }
> 
> +       /* Initialize the "no ACL's" state for the simple cases */
> +       if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
> +               cache_no_acl(inode);
> +
>         brelse(iloc.bh);
> 

tests if the inode does not have an extended attribute.  Posix ACL's
are stored as xattr's --- but if there are any extended attributes (or
in some cases, inline data), in order to authoratatively determine
whether there is an ACL or not will require iterating over all of the
extended attributes.  This can be rather heavyweight, so doing it
unconditionally any time we do an iget() is probably not warranted.

Still, if this works 99.99% of the time, given that most peple don't
enable inline_data, and most folks aren't setting extended attributes,
it should be fine.  Of course, given that SELinux's security ID's are
stored as extended attriutes, at that point this optimization won't
work.  But if you are using SELinux, you probably don't care about
performance anyway.  :-)

					- Ted

Re: generic_permission() optimization

[Linus Torvalds]

On Sat, 12 Apr 2025 at 14:53, Theodore Ts'o <tytso@mit.edu> wrote:
>
> Linus, what problems did you run into?

So this is a resurrected thread from November last year, and I have
long since paged out the exact details...

But when I did basically the exact patch that Mateusz posted, it
didn't actually change any behavior for me, and I still had roughly
half the lookups done the slow way (I also had a really hacky patch
that literally just counted "has cached ACL vs has not").

It is also entirely possible that I messed something up. My
*assumption* at the time was that I was hitting something like this:

> tests if the inode does not have an extended attribute.  Posix ACL's
> are stored as xattr's --- but if there are any extended attributes (or
> in some cases, inline data), in order to authoratatively determine
> whether there is an ACL or not will require iterating over all of the
> extended attributes.

Indeed. I sent a query to the ext4 list (and I think you) about
whether my test was even the right one.

Also, while I did a "getfattr -dR" to see if there are any *existing*
attributes (and couldn't find any), I also assume that if a file has
ever *had* any attributes, the filesystem may have the attribute block
allocated even if it's now empty.

And I have this memory that some gnome GUI tools used to use extended
attributes for things like file icon caching purposes. I didn't even
know how to sanely check for that.

I assume there's some trivial e2fstools thing to show things like
that, but it needs more ext4 specific knowledge than I have.

                 Linus

Re: generic_permission() optimization

[Linus Torvalds]

On Sat, 12 Apr 2025 at 15:36, Linus Torvalds
<torvalds@linux-foundation.org> wrote:
>
> Indeed. I sent a query to the ext4 list (and I think you) about
> whether my test was even the right one.

.. I went back to my email archives, and it turns out that I _only_
sent it to you, not to the ext4 lists at all.

Oh well. It was this patch:

  --- a/fs/ext4/inode.c
  +++ b/fs/ext4/inode.c
  @@ -5011,6 +5011,11 @@ struct inode *__ext4_iget(...
        }

        brelse(iloc.bh);
  +
  +     /* Initialize the "no ACL's" state for the simple cases */
  +     if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
  +             cache_no_acl(inode);
  +
        unlock_new_inode(inode);
        return inode;

and I think that's pretty much exactly the same patch as the one
Mateusz posted, just one line down (and the line numbers are different
because that patch was from five months ago and there's been some
unrelated changes since.

            Linus

Re: generic_permission() optimization

[Theodore Ts'o]

On Sat, Apr 12, 2025 at 03:36:00PM -0700, Linus Torvalds wrote:
> Indeed. I sent a query to the ext4 list (and I think you) about
> whether my test was even the right one.

Sorry, I must have not seen that message; at least, I don't have any
memory of it.

> Also, while I did a "getfattr -dR" to see if there are any *existing*
> attributes (and couldn't find any), I also assume that if a file has
> ever *had* any attributes, the filesystem may have the attribute block
> allocated even if it's now empty.

Well, getfattr will only show user xattrs.  It won't show security.*
xattr's that might have been set by SELinux, or a
system.posix_acl_access xattr.

> I assume there's some trivial e2fstools thing to show things like
> that, but it needs more ext4 specific knowledge than I have.

Yes, we can test for this using the debugfs command.  For exaple:

root@kvm-xfstests:~# debugfs /dev/vdc
debugfs 1.47.2-rc1 (28-Nov-2024)
debugfs:  stat <13>
Inode: 13   Type: regular    Mode:  0644   Flags: 0x80000
Generation: 1672288850    Version: 0x00000000:00000003
User:     0   Group:     0   Project:     0   Size: 286
File ACL: 0
Links: 1   Blockcount: 8
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67faf5d0:30d0b2e4 -- Sat Apr 12 19:22:56 2025
 atime: 0x67faf571:7064bd50 -- Sat Apr 12 19:21:21 2025
 mtime: 0x67faf571:71236aa8 -- Sat Apr 12 19:21:21 2025
crtime: 0x67faf571:7064bd50 -- Sat Apr 12 19:21:21 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 02 00 04 00 b7 7a 00 00 04 00 04 00 10 00 04 00 20 00 04 00 
Inode checksum: 0xc8f7f1a7
EXTENTS:
(0):33792

(If you know the pathname instead of the inode number, you can also
give that to debugfs's stat command, e.g., "stat /lost+found")

I tested it with a simple variant of your patch, and seems to do the right
thing.  Mateusz, if you want, try the following patch, and then mount
your test file system with "mount -o debug".  (The test_opt is to
avoid a huge amount of noise on your root file system; you can skip it
if it's more trouble than it's worth.)  The patch has a reversed
seense of the test, so it will print a message for every one where
cache_no_acl *wouldn't* be called.  You casn then use debugfs's "stat
<ino#>" to verify whether it has some kind of extended attribute.

	   	  	     	      - Ted

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index f386de8c12f6..3e0ba7c4723a 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
 		goto bad_inode;
 	brelse(iloc.bh);
 
+	if (test_opt(sb, DEBUG) &&
+	    (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
+	     ei->i_file_acl))
+		ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
+
 	unlock_new_inode(inode);
 	return inode;
 

Re: generic_permission() optimization

[Mateusz Guzik]

On Sun, Apr 13, 2025 at 1:55 AM Theodore Ts'o <tytso@mit.edu> wrote:
>
> On Sat, Apr 12, 2025 at 03:36:00PM -0700, Linus Torvalds wrote:
> > Indeed. I sent a query to the ext4 list (and I think you) about
> > whether my test was even the right one.
>
> Sorry, I must have not seen that message; at least, I don't have any
> memory of it.
>
> > Also, while I did a "getfattr -dR" to see if there are any *existing*
> > attributes (and couldn't find any), I also assume that if a file has
> > ever *had* any attributes, the filesystem may have the attribute block
> > allocated even if it's now empty.
>
> Well, getfattr will only show user xattrs.  It won't show security.*
> xattr's that might have been set by SELinux, or a
> system.posix_acl_access xattr.
>
> > I assume there's some trivial e2fstools thing to show things like
> > that, but it needs more ext4 specific knowledge than I have.
>
> Yes, we can test for this using the debugfs command.  For exaple:
>
> root@kvm-xfstests:~# debugfs /dev/vdc
> debugfs 1.47.2-rc1 (28-Nov-2024)
> debugfs:  stat <13>
> Inode: 13   Type: regular    Mode:  0644   Flags: 0x80000
> Generation: 1672288850    Version: 0x00000000:00000003
> User:     0   Group:     0   Project:     0   Size: 286
> File ACL: 0
> Links: 1   Blockcount: 8
> Fragment:  Address: 0    Number: 0    Size: 0
>  ctime: 0x67faf5d0:30d0b2e4 -- Sat Apr 12 19:22:56 2025
>  atime: 0x67faf571:7064bd50 -- Sat Apr 12 19:21:21 2025
>  mtime: 0x67faf571:71236aa8 -- Sat Apr 12 19:21:21 2025
> crtime: 0x67faf571:7064bd50 -- Sat Apr 12 19:21:21 2025
> Size of extra inode fields: 32
> Extended attributes:
>   system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 02 00 04 00 b7 7a 00 00 04 00 04 00 10 00 04 00 20 00 04 00
> Inode checksum: 0xc8f7f1a7
> EXTENTS:
> (0):33792
>
> (If you know the pathname instead of the inode number, you can also
> give that to debugfs's stat command, e.g., "stat /lost+found")
>
> I tested it with a simple variant of your patch, and seems to do the right
> thing.  Mateusz, if you want, try the following patch, and then mount
> your test file system with "mount -o debug".  (The test_opt is to
> avoid a huge amount of noise on your root file system; you can skip it
> if it's more trouble than it's worth.)  The patch has a reversed
> seense of the test, so it will print a message for every one where
> cache_no_acl *wouldn't* be called.  You casn then use debugfs's "stat
> <ino#>" to verify whether it has some kind of extended attribute.
>
>                                       - Ted
>
> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index f386de8c12f6..3e0ba7c4723a 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
>                 goto bad_inode;
>         brelse(iloc.bh);
>
> +       if (test_opt(sb, DEBUG) &&
> +           (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
> +            ei->i_file_acl))
> +               ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
> +
>         unlock_new_inode(inode);
>         return inode;
>

This is the rootfs of the thing, so I tried it out with merely
printing it. I got 70 entries at boot time. I don't think figuring out
what this is specifically is warranted (it is on debian though).

With a little bit of cumbersome bpf tracing I verified newly created
dirs (as in mkdir) also have i_acl == NULL, which is the bit important
here (apart from dirs instantiated from storage which now also have
it).

So... I think this is good enough to commit? I had no part in writing
the patch and I'm not an ext4 person, so I'm not submitting it myself.

Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?

The patch is valuable in its own right and is a soft blocker for my
own patch which adds IOP_FAST_MAY_EXEC to skip a bunch of crap work in
inode_permission() which for MAY_EXEC wont be needed [I have not
posted it yet].
-- 
Mateusz Guzik <mjguzik gmail.com>

Re: generic_permission() optimization

[Theodore Ts'o]

On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> This is the rootfs of the thing, so I tried it out with merely
> printing it. I got 70 entries at boot time. I don't think figuring out
> what this is specifically is warranted (it is on debian though).

Well, can you run:

debugfs -R "stat <INO>" /dev/ROOT_DEV

on say, two or three of the inodes (replace INO with a number, and
ROOT_DEV with the root file system device) and send me the result?
That would be really helpful in understanding what might be going on.

> So... I think this is good enough to commit? I had no part in writing
> the patch and I'm not an ext4 person, so I'm not submitting it myself.
> 
> Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?

Sure, I'll put together a more formal patch and do full QA run and
checking of the code paths, as a supposed a fairly superficial review
and hack.

					- Ted

Re: generic_permission() optimization

[Mateusz Guzik]

[-- Attachment #1: Type: text/plain, Size: 502 bytes --]

On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
>
> On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > This is the rootfs of the thing, so I tried it out with merely
> > printing it. I got 70 entries at boot time. I don't think figuring out
> > what this is specifically is warranted (it is on debian though).
>
> Well, can you run:
>
> debugfs -R "stat <INO>" /dev/ROOT_DEV
>

attached full list after boot

-- 
Mateusz Guzik <mjguzik gmail.com>

[-- Attachment #2: ino-dump --]
[-- Type: application/octet-stream, Size: 131481 bytes --]

Inode: 3015355   Type: directory    Mode:  02755   Flags: 0x80000
Generation: 2289563451    Version: 0x00000000:00000006
User:     0   Group:   999   Project:     0   Size: 4096
File ACL: 0
Links: 3   Blockcount: 8
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x64c24208:998aa400 -- Thu Jul 27 06:08:08 2023
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x64c24208:998aa400 -- Thu Jul 27 06:08:08 2023
crtime: 0x64c2412c:cd1b4360 -- Thu Jul 27 06:04:28 2023
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 05 00 20 00 05 00 
  system.posix_acl_default (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 05 00 20 00 05 00 
Inode checksum: 0x9eec79a6
EXTENTS:
(0):12066889

Inode: 3014799   Type: directory    Mode:  02755   Flags: 0x81000
Generation: 1258580606    Version: 0x00000000:00000405
User:     0   Group:   999   Project:     0   Size: 16384
File ACL: 0
Links: 2   Blockcount: 32
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67fb7f3c:53349abc -- Sun Apr 13 05:09:16 2025
 atime: 0x67fb7f3c:55d4a800 -- Sun Apr 13 05:09:16 2025
 mtime: 0x67fb7f3c:53349abc -- Sun Apr 13 05:09:16 2025
crtime: 0x64c24208:998aa400 -- Thu Jul 27 06:08:08 2023
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_default (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 05 00 20 00 05 00 
  system.posix_acl_access (28) = 01 00 00 00 01 00 07 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 05 00 20 00 05 00 
Inode checksum: 0x7779b8f0
EXTENTS:
(0-2):12067054-12067056, (3):12068928

Inode: 3014680   Type: regular    Mode:  0600   Flags: 0x80000
Generation: 1631317178    Version: 0x00000000:000006c4
User:     0   Group:     0   Project:     0   Size: 32
File ACL: 0
Links: 1   Blockcount: 8
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67fbb14a:e9e60b60 -- Sun Apr 13 08:42:50 2025
 atime: 0x67fbb14a:e7be2c00 -- Sun Apr 13 08:42:50 2025
 mtime: 0x67fbb14a:e95d682c -- Sun Apr 13 08:42:50 2025
crtime: 0x64c24208:8c30ac00 -- Thu Jul 27 06:08:08 2023
Size of extra inode fields: 32
Extended attributes:
  user.random-seed-creditable (1) = "1"
Inode checksum: 0x90e9f981
EXTENTS:
(0):12156928

Inode: 3015058   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2169160624    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67fbb237:78fcaf48 -- Sun Apr 13 08:46:47 2025
 atime: 0x67fbb14a:e95d682c -- Sun Apr 13 08:42:50 2025
 mtime: 0x67fbb237:78fcaf48 -- Sun Apr 13 08:46:47 2025
crtime: 0x67fb7f3c:53349abc -- Sun Apr 13 05:09:16 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 21 b1 36 4a a5 32 06 00 
Inode checksum: 0xbc9710a7
EXTENTS:
(ETB0):12092177, (0):12091559, (1-144):310902-311045, (145-285):516352-516492, (286-431):520704-520849, (432-577):521728-521873, (578-715):515072-515209, (716-843):514048-514175, (844-964):520320-520440, (965-1035):519280-519350, (1036[u]):519351, (1037-1068):519352-519383, (1069-1161):520864-520956, (1162-1217):519936-519991, (1218[u]):519992, (1219-1244):519993-520018, (1245-1281):560678-560714, (1282-1285[u]):560715-560718, (1286-1287):560719-560720, (1288-1291[u]):560721-560724, (1292-1294):560725-560727, (1295-1298[u]):560728-560731, (1299-1300):560732-560733, (1301-1304[u]):560734-560737, (1305-1326):560738-560759, (1327-1331[u]):562304-562308, (1332-1351):562309-562328, (1352[u]):562329, (1353-1367):562330-562344, (1368):564060, (1369[u]):564061, (1370-1374):564062-564066, (1375[u]):564067, (1376-1381):564068-564073, (1382[u]):564074, (1383-1387):564075-564079, (1388[u]):564080, (1389-1390):564081-564082, (1391[u]):564083, (1392-1404):564084-564096, (1405-1436[u]):559584-559615, (1437-1467[u]):559348-559378, (1468-1488[u]):561568-561588, (1489-1506[u]):568986-569003, (1507-1523[u]):558534-558550, (1524-1534[u]):564272-564282, (1535-1545[u]):564372-564382, (1546-1556[u]):586058-586068, (1557-1567[u]):586075-586085, (1568-1578[u]):586663-586673, (1579-1589[u]):586731-586741, (1590-1599[u]):564125-564134, (1600-1623[u]):587264-587287, (1624-1804[u]):587303-587483, (1805-1819[u]):587489-587503, (1820-2047[u]):587507-587734

Inode: 3016314   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3168712975    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 50331648
File ACL: 0
Links: 1   Blockcount: 98312
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67efe9b8:55183974 -- Fri Apr  4 10:16:24 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67efe9b8:44e1d910 -- Fri Apr  4 10:16:24 2025
crtime: 0x67eda506:0c65d400 -- Wed Apr  2 16:58:46 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 09 a9 4f eb d1 31 06 00 
Inode checksum: 0x5c1c968e
EXTENTS:
(ETB0):12091572, (0):12091571, (1-184):391168-391351, (185-324):376320-376459, (325-446):391504-391625, (447-540):391361-391454, (541-618):366513-366590, (619-682):361472-361535, (683-745):393400-393462, (746-804):395258-395316, (805-859):396167-396221, (860-911):406442-406493, (912-962):396422-396472, (963-1001):397568-397606, (1002-1039):395098-395135, (1040-1041):406682-406683, (1042[u]):406684, (1043-1077):406685-406719, (1078-1113):401670-401705, (1114-1149):401820-401855, (1150-1183):396507-396540, (1184-1217):402100-402133, (1218-1251):402321-402354, (1252-1284):406208-406240, (1285-1316):406848-406879, (1317-1348):406976-407007, (1349-1379):400538-400568, (1380-1385):401126-401131, (1386-1387[u]):401132-401133, (1388-1410):401134-401156, (1411-1441):402715-402745, (1442-1471):400685-400714, (1472-1482):393594-393604, (1483[u]):393605, (1484-1500):393606-393622, (1501-1529):399619-399647, (1530-1542):400778-400790, (1543[u]):400791, (1544):400792, (1545[u]):400793, (1546):400794, (1547[u]):400795, (1548):400796, (1549[u]):400797, (1550-1558):400798-400806, (1559-1562):402272-402275, (1563[u]):402276, (1564-1571):402277-402284, (1572[u]):402285, (1573-1587):402286-402300, (1588-1597):393906-393915, (1598[u]):393916, (1599-1609):393917-393927, (1610[u]):393928, (1611-1615):393929-393933, (1616-1635):398353-398372, (1636[u]):398373, (1637-1643):398374-398380, (1644-1670):393988-394014, (1671-1697):394707-394733, (1698-1724):402528-402554, (1725-1751):406347-406373, (1752-1777):396284-396309, (1778-1803):400936-400961, (1804-1828):400587-400611, (1829-1853):402043-402067, (1854-1876):394130-394152, (1877-1899):399358-399380, (1900-1922):400512-400534, (1923-1937):425696-425710, (1938-1950):403337-403349, (1951-1963):408646-408658, (1964-2005):425984-426025, (2006-2047):432447-432488, (2048-4095):7452672-7454719, (4096-6143):7456768-7458815, (6144-6687):7311360-7311903, (6688-6789[u]):7311904-7312005, (6790-6854):7312006-7312070, (6855-6956[u]):7312071-7312172, (6957-7021):7312173-7312237, (7022-7122[u]):7312238-7312338, (7123-7187):7312339-7312403, (7188-7289[u]):7312404-7312505, (7290-7516):7312506-7312732, (7517-7621[u]):7312733-7312837, (7622-7696):7312838-7312912, (7697-7800[u]):7312913-7313016, (7801-7862):7313017-7313078, (7863-7967[u]):7313079-7313183, (7968-8166):7313184-7313382, (8167-8191[u]):7313383-7313407, (8192-8273[u]):11057152-11057233, (8274-8378):11057234-11057338, (8379-8487[u]):11057339-11057447, (8488-8546):11057448-11057506, (8547-8654[u]):11057507-11057614, (8655-10239):11057615-11059199, (10240-11740):9154560-9156060, (11741-12287[u]):9156061-9156607

Inode: 3014865   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 937231974    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e76fb4:208d673c -- Fri Mar 28 23:57:40 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e76f16:356a05cc -- Fri Mar 28 23:55:02 2025
crtime: 0x67e58aa2:dd5e15e4 -- Thu Mar 27 13:28:02 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = bc a0 ac 46 56 31 06 00 
Inode checksum: 0xbe3243ad
EXTENTS:
(ETB0):12091581, (0):12091530, (1-126):201088-201213, (127-248):207488-207609, (249-366):197994-198111, (367-472):219407-219512, (473-568):200064-200159, (569-653):219936-220020, (654-730):205824-205900, (731-809):233649-233727, (810-919):252759-252868, (920-1013):252162-252255, (1014-1105):251652-251743, (1106-1191):246954-247039, (1192-1196):247854-247858, (1197[u]):247859, (1198):247860, (1199[u]):247861, (1200-1228):247862-247890, (1229[u]):247891, (1230-1271):247892-247933, (1272[u]):247934, (1273):247935, (1274-1278):252657-252661, (1279-1352[u]):252662-252735, (1353-1430[u]):251570-251647, (1431-1507[u]):236723-236799, (1508-1583[u]):252532-252607, (1584-1658[u]):338070-338144, (1659-1738[u]):357054-357133, (1739-1814[u]):350539-350614, (1815-1886[u]):351226-351297, (1887-1948[u]):340416-340477, (1949-2000[u]):340896-340947, (2001-2047[u]):362741-362787

Inode: 3016482   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4150179141    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67fa886b:14c0fd44 -- Sat Apr 12 11:36:11 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67fa8825:8d342200 -- Sat Apr 12 11:35:01 2025
crtime: 0x67f0c9bc:280de800 -- Sat Apr  5 02:12:12 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 3d 7b 3b e2 01 32 06 00 
Inode checksum: 0x377001c3
EXTENTS:
(ETB0):12092029, (0):12092028, (1-499):438960-439458, (500-1008):556544-557052, (1009-1249):548096-548336, (1250-1281):538593-538624, (1282[u]):538625, (1283-1296):538626-538639, (1297[u]):538640, (1298-1466):538641-538809, (1467[u]):538810, (1468-1484):538811-538827, (1485[u]):538828, (1486):538829, (1487):538187, (1488[u]):538188, (1489):538189, (1490[u]):538190, (1491-1608):538191-538308, (1609[u]):538309, (1610-1667):538310-538367, (1668-1732):550144-550208, (1733[u]):550209, (1734-1739):550210-550215, (1740-1742[u]):550216-550218, (1743-1746):550219-550222, (1747-1748[u]):550223-550224, (1749-1761):550225-550237, (1762-1763[u]):550238-550239, (1764-1794):550240-550270, (1795-1797[u]):550271-550273, (1798-1837):550274-550313, (1838-1902):543345-543409, (1903[u]):543410, (1904-1980):543411-543487, (1981-2000):12225451-12225470, (2001-2012[u]):12225471-12225482, (2013-2019):12225483-12225489, (2020-2030[u]):12225490-12225500, (2031-2037):12225501-12225507, (2038-2047[u]):12225508-12225517, (2048-2049[u]):197380-197381, (2050-2056):197382-197388, (2057-2067[u]):197389-197399, (2068-2087):197400-197419, (2088-2090[u]):197420-197422, (2091-2115):197423-197447, (2116[u]):205666, (2117-2129):205667-205679, (2130[u]):205680, (2131-2137):205681-205687, (2138-2149[u]):205688-205699, (2150-2181):201728-201759, (2182-2212):205569-205599, (2213-2232):203149-203168, (2233-2236[u]):203169-203172, (2237-2242):203173-203178, (2243-2254):205621-205632, (2255[u]):205633, (2256-2270):205634-205648, (2271[u]):205649, (2272-2290):196785-196803, (2291-2294[u]):196804-196807, (2295-2297):196808-196810, (2298-2351):221504-221557, (2352-2356[u]):221558-221562, (2357-2362):221563-221568, (2363-2374):202190-202201, (2375[u]):202202, (2376-2388):202203-202215, (2389-2390):218434-218435, (2391-2394[u]):218436-218439, (2395-2414):218440-218459, (2415):218578, (2416[u]):218579, (2417-2440):218580-218603, (2441-2465):218082-218106, (2466-2474):205738-205746, (2475-2478[u]):205747-205750, (2479-2480):205751-205752, (2481-2485[u]):205753-205757, (2486):205758, (2487-2489[u]):205759-205761, (2490-2491[u]):220814-220815, (2492):220816, (2493-2497[u]):220817-220821, (2498):220822, (2499-2503[u]):220823-220827, (2504-2505):220828-220829, (2506-2509[u]):220830-220833, (2510-2512):220834-220836, (2513-2529):197557-197573, (2530[u]):197574, (2531-2534):197575-197578, (2535-2556):201769-201790, (2557-2578):209158-209179, (2579-2600):218278-218299, (2601-2623):223920-223942, (2624-2631):223841-223848, (2632[u]):223849, (2633-2644):223850-223861, (2645[u]):223862, (2646-2647):202693-202694, (2648-2666[u]):202695-202713, (2667-2687[u]):202730-202750, (2688-2708[u]):209093-209113, (2709-2729[u]):218352-218372, (2730-2749[u]):197352-197371, (2750-2769[u]):199115-199134, (2770-2789[u]):205466-205485, (2790-2809[u]):218060-218079, (2810-2829[u]):223819-223838, (2830-2848[u]):196844-196862, (2849-2867[u]):196997-197015, (2868-2886[u]):198656-198674, (2887-2905[u]):198989-199007, (2906-2924[u]):202816-202834, (2925-2943[u]):209367-209385, (2944-2962[u]):220745-220763, (2963-2980[u]):201948-201965, (2981-2998[u]):202166-202183, (2999-3016[u]):202342-202359, (3017-3034[u]):205330-205347, (3035-3051[u]):218189-218205, (3052-3068[u]):220619-220635, (3069-3084[u]):198711-198726, (3085-3100[u]):202008-202023, (3101-3116[u]):203123-203138, (3117-3132[u]):205361-205376, (3133-3148[u]):205488-205503, (3149-3164[u]):217698-217713, (3165-3180[u]):218124-218139, (3181-3196[u]):218211-218226, (3197-3212[u]):218333-218348, (3213-3228[u]):220298-220313, (3229-3244[u]):220445-220460, (3245-3260[u]):221003-221018, (3261-3276[u]):223900-223915, (3277-3291[u]):196945-196959, (3292-3309[u]):228764-228781, (3310-3324[u]):197460-197474, (3325-3339[u]):198748-198762, (3340-3354[u]):202050-202064, (3355-3369[u]):205448-205462, (3370-3512[u]):273649-273791, (3513-3662[u]):281584-281733, (3663-3806[u]):291172-291315, (3807-4095[u]):3509248-3509536

Inode: 3015946   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1642631380    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e58aa2:dd5e15e4 -- Thu Mar 27 13:28:02 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e589ee:238f9580 -- Thu Mar 27 13:25:02 2025
crtime: 0x67e4d69b:70889800 -- Thu Mar 27 00:39:55 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = a3 e0 a5 8b 4b 31 06 00 
Inode checksum: 0x482dc948
EXTENTS:
(ETB0):12092086, (0):12275200, (1-277):84203-84479, (278-545):72692-72959, (546-616):67712-67782, (617-686):79290-79359, (687-752):71380-71445, (753-798):90379-90424, (799-843):86966-87010, (844-886):71226-71268, (887-924):92953-92990, (925-953):66210-66238, (954-982):70816-70844, (983-1011):92721-92749, (1012-1039):69552-69579, (1040-1067):91136-91163, (1068-1093):92521-92546, (1094-1118):90819-90843, (1119-1141):75145-75167, (1142-1163):78728-78749, (1164-1185):90112-90133, (1186-1205):92672-92691, (1206-1224):75883-75901, (1225-1243):90961-90979, (1244-1262):93004-93022, (1263-1279):78600-78616, (1280-1296):79388-79404, (1297-1313):86554-86570, (1314-1329):71182-71197, (1330-1345):79503-79518, (1346-1361):90482-90497, (1362-1377):91100-91115, (1378-1393):91944-91959, (1394-1409):92300-92315, (1410-1425):92923-92938, (1426-1440):78643-78657, (1441-1455):83730-83744, (1456-1470):83922-83936, (1471-1485):86025-86039, (1486-1500):86096-86110, (1501-1515):86588-86602, (1516-1554):117721-117759, (1555-2047):124097-124589, (2048-2573):144434-144959, (2574-2766):134290-134482, (2767-2814[u]):134483-134530, (2815-2817):134531-134533, (2818-2869[u]):134534-134585, (2870-2877):134586-134593, (2878-2910[u]):134594-134626, (2911-2925[u]):154068-154082, (2926-2932):154083-154089, (2933-2980[u]):154090-154137, (2981-2988):154138-154145, (2989-3036[u]):154146-154193, (3037-3067):154194-154224, (3068-3117[u]):154225-154274, (3118-3124):154275-154281, (3125-3175[u]):154282-154332, (3176-3180):154333-154337, (3181-3210[u]):154338-154367, (3211-3230[u]):133376-133395, (3231-3235):133396-133400, (3236-3288[u]):133401-133453, (3289-3290):133454-133455, (3291-3343[u]):133456-133508, (3344-3466):133509-133631, (3467-3547):132210-132290, (3548[u]):132291, (3549-3610):132292-132353, (3611-3722):133136-133247, (3723-3730):141979-141986, (3731-3733[u]):141987-141989, (3734-3742):141990-141998, (3743[u]):141999, (3744-3754):142000-142010, (3755[u]):142011, (3756-3768):142012-142024, (3769[u]):142025, (3770):142026, (3771-3786):159606-159621, (3787[u]):159622, (3788):159623, (3789[u]):159624, (3790):159625, (3791[u]):159626, (3792):159627, (3793[u]):159628, (3794-3805):159629-159640, (3806-3838):146813-146845, (3839-3864):132591-132616, (3865[u]):132617, (3866-3870):132618-132622, (3871-3873):139423-139425, (3874[u]):139426, (3875-3897):139427-139449, (3898-3902):139729-139733, (3903-3923[u]):139734-139754, (3924-3948[u]):139661-139685, (3949-4095[u]):11707984-11708130

Inode: 3016635   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1184159966    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c6445e:bb611dc0 -- Mon Mar  3 19:07:58 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c6436b:4cf43cb0 -- Mon Mar  3 19:03:55 2025
crtime: 0x67c63ab9:7a120000 -- Mon Mar  3 18:26:49 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 70 43 91 7d 78 2f 06 00 
Inode checksum: 0x0cff8fd6
EXTENTS:
(ETB0):12091618, (0):12091617, (1-192):78848-79039, (193-668):91172-91647, (669-1102):125545-125978, (1103-1203):153522-153622, (1204[u]):153623, (1205-1273):153624-153692, (1274-1275[u]):153693-153694, (1276-1279):153695-153698, (1280-1281[u]):153699-153700, (1282-1285):153701-153704, (1286-1287[u]):153705-153706, (1288-1291):153707-153710, (1292-1293[u]):153711-153712, (1294-1308):153713-153727, (1309-1312):177910-177913, (1313-1315[u]):177914-177916, (1316-1395):177917-177996, (1396[u]):177997, (1397-1429):177998-178030, (1430-1433[u]):178031-178034, (1434-1448):178035-178049, (1449-1452[u]):178050-178053, (1453-1454):178054-178055, (1455-1458[u]):178056-178059, (1459-1475):178060-178076, (1476[u]):178077, (1477-1491):178078-178092, (1492[u]):178093, (1493):178094, (1494[u]):178095, (1495):178096, (1496[u]):178097, (1497-1527):178098-178128, (1528[u]):178129, (1529-1559):178130-178160, (1560[u]):178161, (1561-1574):178162-178175, (1575-1596):207093-207114, (1597-1969[u]):207115-207487, (1970-2047[u]):14494-14571

Inode: 3016319   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 779963599    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c984c2:aab52c00 -- Thu Mar  6 06:19:30 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c9842e:15dceba4 -- Thu Mar  6 06:17:02 2025
crtime: 0x67c9827a:9c671000 -- Thu Mar  6 06:09:46 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 3a 27 34 8b aa 2f 06 00 
Inode checksum: 0xed21c8a6
EXTENTS:
(ETB0):12091826, (0):12091825, (1-197):201242-201438, (198-375):217092-217269, (376-579):316212-316415, (580-756):301960-302136, (757-930):306907-307080, (931-1034):312161-312264, (1035[u]):312265, (1036):312266, (1037[u]):312267, (1038):312268, (1039[u]):312269, (1040):312270, (1041[u]):312271, (1042):312272, (1043[u]):312273, (1044-1068):312274-312298, (1069[u]):312299, (1070-1075):312300-312305, (1076-1077[u]):312306-312307, (1078-1220[u]):311921-312063, (1221-1290[u]):356205-356274, (1291-1360[u]):356295-356364, (1361-1429[u]):333821-333889, (1430-1498[u]):356654-356722, (1499-1528[u]):346070-346099, (1529-1545[u]):360896-360912, (1546-1609[u]):368554-368617, (1610-1643[u]):363826-363859, (1644-1676[u]):366000-366032, (1677-1706[u]):362424-362453, (1707-1735[u]):378083-378111, (1736-1762[u]):365873-365899, (1763-1788[u]):375974-375999, (1789-1811[u]):377001-377023, (1812-1832[u]):362847-362867, (1833-1853[u]):363357-363377, (1854-1874[u]):363488-363508, (1875-1894[u]):369809-369828, (1895-1913[u]):362686-362704, (1914-1932[u]):371423-371441, (1933-1951[u]):371450-371468, (1952-1969[u]):394015-394032, (1970-1998[u]):431233-431261, (1999-2047[u]):12551103-12551151

Inode: 3015166   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4181066080    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e4155b:2cea1f30 -- Wed Mar 26 10:55:23 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e412ee:0e68ff54 -- Wed Mar 26 10:45:02 2025
crtime: 0x67dc5e48:2160ec00 -- Thu Mar 20 14:28:24 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = f5 58 a0 4d ca 30 06 00 
Inode checksum: 0xa5230ebe
EXTENTS:
(ETB0):12091534, (0):12091492, (1-1203):114689-115891, (1204-1369):144979-145144, (1370[u]):145145, (1371-1642):145146-145417, (1643[u]):145418, (1644-1764):145419-145539, (1765[u]):145540, (1766-1844):145541-145619, (1845[u]):145620, (1846-1877):145621-145652, (1878[u]):145653, (1879-1891):145654-145666, (1892-1893[u]):145667-145668, (1894-1908):145669-145683, (1909[u]):145684, (1910-1919):145685-145694, (1920-1946):133248-133274, (1947-1952[u]):133275-133280, (1953-1965):133281-133293, (1966-1970[u]):133294-133298, (1971-1983):133299-133311, (1984-1989[u]):133312-133317, (1990-2002):133318-133330, (2003-2007[u]):133331-133335, (2008-2047):133336-133375, (2048-2070):88822-88844, (2071-2076[u]):88845-88850, (2077-2168):88851-88942, (2169-2172[u]):88943-88946, (2173-2263):88947-89037, (2264[u]):89038, (2265-2318):89039-89092, (2319-2321[u]):89093-89095, (2322-2405):89096-89179, (2406-2407[u]):89180-89181, (2408-2482):89182-89256, (2483-2496[u]):89257-89270, (2497-2530):89271-89304, (2531-2544[u]):89305-89318, (2545-2548):89319-89322, (2549-2562[u]):89323-89336, (2563-2601):89337-89375, (2602-2702):111621-111721, (2703-2706[u]):111722-111725, (2707-2729):111726-111748, (2730-2733[u]):111749-111752, (2734-2821):111753-111840, (2822-2826[u]):111841-111845, (2827):111846, (2828-2832[u]):111847-111851, (2833):111852, (2834-2838[u]):111853-111857, (2839-2840):111858-111859, (2841-2844[u]):111860-111863, (2845-2846):111864-111865, (2847-2850[u]):111866-111869, (2851-2879):111870-111898, (2880[u]):111899, (2881-3003):111900-112022, (3004-3008[u]):112023-112027, (3009-3065):112028-112084, (3066-3070[u]):112085-112089, (3071-3113):112090-112132, (3114-3130):142337-142353, (3131-3135[u]):142354-142358, (3136-3179):142359-142402, (3180[u]):142403, (3181-3188):142404-142411, (3189-3193[u]):142412-142416, (3194-3206):142417-142429, (3207-3624[u]):142430-142847, (3625-4095[u]):134627-135097

Inode: 3015827   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 727091176    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c21092:17d78400 -- Fri Feb 28 14:37:54 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c20fe6:30cfa9d8 -- Fri Feb 28 14:35:02 2025
crtime: 0x67c11357:e30a75dc -- Thu Feb 27 20:37:27 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 7c dd 68 d9 29 2f 06 00 
Inode checksum: 0x12f9bc66
EXTENTS:
(ETB0):12091606, (0):12091605, (1-246):59114-59359, (247-487):76288-76528, (488-734):131784-132030, (735-958):145696-145919, (959-1039):176937-177017, (1040[u]):177018, (1041):177019, (1042[u]):177020, (1043):177021, (1044[u]):177022, (1045-1069):177023-177047, (1070[u]):177048, (1071-1173):177049-177151, (1174-1178):260725-260729, (1179-1440[u]):260730-260991, (1441-1682[u]):256876-257117, (1683-1806[u]):261458-261581, (1807-1910[u]):315032-315135, (1911-2010[u]):319296-319395, (2011-2047[u]):361088-361124

Inode: 3016154   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1864735567    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d338c9:06acfc00 -- Thu Mar 13 15:58:01 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d336f0:8d3ec5f0 -- Thu Mar 13 15:50:08 2025
crtime: 0x67d336e3:e27ceda4 -- Thu Mar 13 15:49:55 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = d5 c3 4f a0 3e 30 06 00 
Inode checksum: 0x999dc6b6
EXTENTS:
(ETB0):12091608, (0):12092007, (1-471):140627-141097, (472-996):169085-169609, (997-1036):253056-253095, (1037[u]):253096, (1038):253097, (1039[u]):253098, (1040):253099, (1041[u]):253100, (1042):253101, (1043[u]):253102, (1044-1066):253103-253125, (1067[u]):253126, (1068-1089):253127-253148, (1090[u]):253149, (1091):253150, (1092[u]):253151, (1093-1113):253152-253172, (1114-1585[u]):253173-253644, (1586-2047[u]):254336-254797

Inode: 3017814   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1043443558    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c98df7:9f437c00 -- Thu Mar  6 06:58:47 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c98d2a:cf11bbec -- Thu Mar  6 06:55:22 2025
crtime: 0x67c98d07:9c671000 -- Thu Mar  6 06:54:47 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 3c 20 32 2c ab 2f 06 00 
Inode checksum: 0xbeac512a
EXTENTS:
(ETB0):12091522, (0):12091521, (1-167):1522432-1522598, (168-386):1530149-1530367, (387-603):1542144-1542360, (604-864):1566971-1567231, (865-1033):1705598-1705766, (1034[u]):1705767, (1035):1705768, (1036[u]):1705769, (1037):1705770, (1038[u]):1705771, (1039):1705772, (1040[u]):1705773, (1041-1064):1705774-1705797, (1065[u]):1705798, (1066-1070):1705799-1705803, (1071-1122[u]):1705804-1705855, (1123-1393[u]):1775345-1775615, (1394-1651[u]):1837822-1838079, (1652-1909[u]):1843454-1843711, (1910-2047[u]):1838437-1838574

Inode: 3015615   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1698073953    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d7e646:b9034800 -- Mon Mar 17 05:07:18 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d780f5:76dca588 -- Sun Mar 16 21:55:01 2025
crtime: 0x67d7662a:6bc3e400 -- Sun Mar 16 20:00:42 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 80 4f ad 7a 7e 30 06 00 
Inode checksum: 0xfe16e191
EXTENTS:
(ETB0):12091624, (0):12091615, (1-339):200177-200515, (340-667):549374-549701, (668-984):555102-555418, (985-1128):549888-550031, (1129[u]):550032, (1130):550033, (1131[u]):550034, (1132-1201):550035-550104, (1202[u]):550105, (1203-1225):550106-550128, (1226-1240[u]):550129-550143, (1241-1496[u]):597248-597503, (1497-1700[u]):669939-670142, (1701-1893[u]):673022-673214, (1894-2047[u]):663552-663705

Inode: 3016338   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4173545633    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67dc5e48:2160ec00 -- Thu Mar 20 14:28:24 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67dc5dfd:505fb010 -- Thu Mar 20 14:27:09 2025
crtime: 0x67db3fe5:491ef568 -- Wed Mar 19 18:06:29 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = f2 c0 b8 3b b9 30 06 00 
Inode checksum: 0x4a59163c
EXTENTS:
(ETB0):12091535, (0):114688, (1-1115):116215-117329, (1116[u]):117330, (1117-1317):117331-117531, (1318[u]):117532, (1319-1323):117533-117537, (1324[u]):117538, (1325-1329):117539-117543, (1330[u]):117544, (1331-1336):117545-117550, (1337[u]):117551, (1338-1370):117552-117584, (1371[u]):117585, (1372-1441):117586-117655, (1442-1454):113664-113676, (1455[u]):113677, (1456):113678, (1457[u]):113679, (1458-1480):113680-113702, (1481[u]):113703, (1482-1504):113704-113726, (1505[u]):113727, (1506-1548):113728-113770, (1549-1552[u]):113771-113774, (1553-1564):113775-113786, (1565-1568[u]):113787-113790, (1569-1570):113791-113792, (1571-1574[u]):113793-113796, (1575-1607):113797-113829, (1608[u]):113830, (1609-1663):113831-113885, (1664[u]):113886, (1665-1698):113887-113920, (1699[u]):113921, (1700):113922, (1701[u]):113923, (1702-1722):113924-113944, (1723[u]):113945, (1724-1726):113946-113948, (1727[u]):113949, (1728-1733):113950-113955, (1734-2047[u]):113956-114269

Inode: 3017801   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3164817301    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c98c31:a3140c00 -- Thu Mar  6 06:51:13 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c98b38:19e5c39c -- Thu Mar  6 06:47:04 2025
crtime: 0x67c98b14:df6b46a4 -- Thu Mar  6 06:46:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = d6 40 78 0e ab 2f 06 00 
Inode checksum: 0xa3888db0
EXTENTS:
(ETB0):12091902, (0):12091901, (1-60):775136-775195, (61-118):754661-754718, (119-176):755904-755961, (177-234):756736-756793, (235-292):758400-758457, (293-362):804671-804740, (363-419):793920-793976, (420-476):796224-796280, (477-532):802016-802071, (533-587):804414-804468, (588-641):815360-815413, (642-694):1020960-1021012, (695-745):1018016-1018066, (746-789):1041463-1041506, (790-832):1041293-1041335, (833-873):1041935-1041975, (874-909):1016625-1016660, (910-945):1044084-1044119, (946-981):1044407-1044442, (982-1034):1227008-1227060, (1035[u]):1227061, (1036):1227062, (1037[u]):1227063, (1038):1227064, (1039[u]):1227065, (1040):1227066, (1041[u]):1227067, (1042):1227068, (1043[u]):1227069, (1044-1065):1227070-1227091, (1066[u]):1227092, (1067-1070):1227093-1227096, (1071-1098[u]):1227097-1227124, (1099-1219[u]):1365504-1365624, (1220-1335[u]):1359968-1360083, (1336-1420[u]):1373355-1373439, (1421-1492[u]):1368504-1368575, (1493-1559[u]):1359872-1359938, (1560-1609[u]):1345728-1345777, (1610-1658[u]):1372001-1372049, (1659-1694[u]):1380821-1380856, (1695-1730[u]):1386204-1386239, (1731-1764[u]):1389719-1389752, (1765-1795[u]):1398209-1398239, (1796-1826[u]):1402092-1402122, (1827-1856[u]):1380706-1380735, (1857-1886[u]):1420628-1420657, (1887-1917[u]):1443353-1443383, (1918-2047[u]):1466974-1467103

Inode: 3015033   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1961626995    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d7662a:6bc3e400 -- Sun Mar 16 20:00:42 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d7627d:a90da30c -- Sun Mar 16 19:45:01 2025
crtime: 0x67d755e5:660fb29c -- Sun Mar 16 18:51:17 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 5b 15 6c 82 7d 30 06 00 
Inode checksum: 0xf196f893
EXTENTS:
(ETB0):12091614, (0):12091613, (1-396):69620-70015, (397-763):80370-80736, (764-1040):75425-75701, (1041[u]):75702, (1042-1114):75703-75775, (1115-1274):74240-74399, (1275-1279[u]):74400-74404, (1280):74405, (1281-1285[u]):74406-74410, (1286-1287):74411-74412, (1288-1291[u]):74413-74416, (1292-1293):74417-74418, (1294-1297[u]):74419-74422, (1298-1314):74423-74439, (1315-1318[u]):74440-74443, (1319-1335):74444-74460, (1336[u]):74461, (1337-1347):74462-74472, (1348[u]):74473, (1349):74474, (1350[u]):74475, (1351-1358):74476-74483, (1359[u]):74484, (1360-1362):74485-74487, (1363[u]):74488, (1364-1368):74489-74493, (1369[u]):74494, (1370-1371):74495-74496, (1372):123846, (1373[u]):123847, (1374-1382):123848-123856, (1383-1622[u]):123857-124096, (1623-2047[u]):12255288-12255712

Inode: 3017583   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 905054076    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c986b6:c1988c00 -- Thu Mar  6 06:27:50 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c9860d:62f6054c -- Thu Mar  6 06:25:01 2025
crtime: 0x67c985c5:a6e49c00 -- Thu Mar  6 06:23:49 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 4d fe 73 bd aa 2f 06 00 
Inode checksum: 0x122c9bc2
EXTENTS:
(ETB0):12091870, (0):12091869, (1-76):859392-859467, (77-160):1021216-1021299, (161-300):1380976-1381115, (301-424):1381120-1381243, (425-577):1420658-1420810, (578-850):1438703-1438975, (851-1036):1421082-1421267, (1037[u]):1421268, (1038):1421269, (1039[u]):1421270, (1040):1421271, (1041[u]):1421272, (1042):1421273, (1043[u]):1421274, (1044-1064):1421275-1421295, (1065[u]):1421296, (1066-1071):1421297-1421302, (1072-1080[u]):1421303-1421311, (1081-1132[u]):1429044-1429095, (1133-1181[u]):1429453-1429501, (1182-1229[u]):1424848-1424895, (1230-1277[u]):1437230-1437277, (1278-1320[u]):1419111-1419153, (1321-1355[u]):1436918-1436952, (1356-1389[u]):1436404-1436437, (1390-1421[u]):1438434-1438465, (1422-1452[u]):1409929-1409959, (1453-1483[u]):1436444-1436474, (1484-1514[u]):1440735-1440765, (1515-1544[u]):1436347-1436376, (1545-1573[u]):1437142-1437170, (1574-1602[u]):1440573-1440601, (1603-1630[u]):1425115-1425142, (1631-1657[u]):1410277-1410303, (1658-1684[u]):1410998-1411024, (1685-1711[u]):1429135-1429161, (1712-1738[u]):1436746-1436772, (1739-1765[u]):1440011-1440037, (1766-1792[u]):1440328-1440354, (1793-1819[u]):1440603-1440629, (1820-1845[u]):1439551-1439576, (1846-1976[u]):1442685-1442815, (1977-2047[u]):1452925-1452995

Inode: 3016352   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3186014340    Version: 0x00000000:00000003
User:     0   Group:   999   Project:     0   Size: 41943040
File ACL: 0
Links: 1   Blockcount: 81928
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67f0c9bc:280de800 -- Sat Apr  5 02:12:12 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67efeb69:def4cea4 -- Fri Apr  4 10:23:37 2025
crtime: 0x67efead1:1a4e0038 -- Fri Apr  4 10:21:05 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 64 58 c5 98 f4 31 06 00 
Inode checksum: 0xffb018af
EXTENTS:
(ETB0):12091575, (0):15086080, (1-2047):8278016-8280062, (2048-4095):8280064-8282111, (4096-6288):3555328-3557520, (6289-6411[u]):3557521-3557643, (6412-6455):3557644-3557687, (6456-6578[u]):3557688-3557810, (6579-6621):3557811-3557853, (6622-6744[u]):3557854-3557976, (6745-6788):3557977-3558020, (6789-6911[u]):3558021-3558143, (6912-6955):3558144-3558187, (6956-7077[u]):3558188-3558309, (7078-7121):3558310-3558353, (7122-7244[u]):3558354-3558476, (7245-7289):3558477-3558521, (7290-7412[u]):3558522-3558644, (7413-7456):3558645-3558688, (7457-7578[u]):3558689-3558810, (7579-7622):3558811-3558854, (7623-7745[u]):3558855-3558977, (7746-7789):3558978-3559021, (7790-7912[u]):3559022-3559144, (7913-8191):3559145-3559423, (8192-10221):3610624-3612653, (10222-10239[u]):3612654-3612671

Inode: 3017840   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2774618042    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d060f4:08954400 -- Tue Mar 11 12:12:36 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d0536b:5bb38ca8 -- Tue Mar 11 11:14:51 2025
crtime: 0x67c98e5c:d6f80e64 -- Thu Mar  6 07:00:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = e7 1f 89 40 ab 2f 06 00 
Inode checksum: 0xec189d14
EXTENTS:
(ETB0):12091526, (0):12091525, (1-158):1835746-1835903, (159-670):2443264-2443775, (671-880):2544961-2545170, (881-1254):2569743-2570116, (1255[u]):2570117, (1256-1377):2570118-2570239, (1378-1525):2640816-2640963, (1526-1653):2641408-2641535, (1654-1678):2664768-2664792, (1679-1681[u]):2664793-2664795, (1682-1696):2664796-2664810, (1697-1700[u]):2664811-2664814, (1701-1702):2664815-2664816, (1703-1706[u]):2664817-2664820, (1707-1743):2664821-2664857, (1744[u]):2664858, (1745-1781):2664859-2664895, (1782-1799):2682484-2682501, (1800[u]):2682502, (1801-1841):2682503-2682543, (1842[u]):2682544, (1843-1856):2682545-2682558, (1857-1858[u]):2682559-2682560, (1859-1886):2682561-2682588, (1887[u]):2682589, (1888-1902):2682590-2682604, (1903-1904[u]):2682605-2682606, (1905-1907):2682607-2682609, (1908-1923):2680064-2680079, (1924[u]):2680080, (1925-1933):2680081-2680089, (1934-1936[u]):2680090-2680092, (1937-1957):2680093-2680113, (1958[u]):2680114, (1959-2023):2680115-2680179, (2024-2041):2734688-2734705, (2042-2047[u]):2734706-2734711, (2048-2055[u]):2596864-2596871, (2056-2059):2596872-2596875, (2060-2073[u]):2596876-2596889, (2074-2078):2596890-2596894, (2079-2092[u]):2596895-2596908, (2093-2096):2596909-2596912, (2097-2110[u]):2596913-2596926, (2111-2201):2596927-2597017, (2202-2206[u]):2597018-2597022, (2207-2245):2597023-2597061, (2246-2249[u]):2597062-2597065, (2250-2274):2597066-2597090, (2275-2289[u]):2597091-2597105, (2290-2346):2597106-2597162, (2347-2350[u]):2597163-2597166, (2351-2363):2597167-2597179, (2364-2368[u]):2597180-2597184, (2369-2422):2597185-2597238, (2423-2427[u]):2597239-2597243, (2428-2438):2597244-2597254, (2439[u]):2597255, (2440-2449):2597256-2597265, (2450-2454[u]):2597266-2597270, (2455):2597271, (2456[u]):2597272, (2457):2597273, (2458[u]):2597274, (2459-2539):2597275-2597355, (2540-4095[u]):2597356-2598911

Inode: 3017490   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2316130196    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c64659:c697c800 -- Mon Mar  3 19:16:25 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64538:02dc6c00 -- Mon Mar  3 19:11:36 2025
crtime: 0x67c6452f:9fe1caf8 -- Mon Mar  3 19:11:27 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 91 b9 32 1d 79 2f 06 00 
Inode checksum: 0x395dfc09
EXTENTS:
(ETB0):12091603, (0):12091602, (1-175):73553-73727, (176-475):224768-225067, (476-767):214254-214545, (768-1004):205025-205261, (1005-1054[u]):205262-205311, (1055-1296[u]):225389-225630, (1297-1486[u]):240450-240639, (1487-1649[u]):255779-255941, (1650-1810[u]):250079-250239, (1811-1969[u]):272541-272699, (1970-2047[u]):30718-30795

Inode: 3017775   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2560624844    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c98d07:9c671000 -- Thu Mar  6 06:54:47 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c98c53:ab6a3588 -- Thu Mar  6 06:51:47 2025
crtime: 0x67c98c31:a3140c00 -- Thu Mar  6 06:51:13 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 9e 30 71 1f ab 2f 06 00 
Inode checksum: 0x16a5e0ba
EXTENTS:
(ETB0):12091520, (0):12091903, (1-160):1518820-1518979, (161-407):1540425-1540671, (408-714):1568461-1568767, (715-1034):1652720-1653039, (1035[u]):1653040, (1036):1653041, (1037[u]):1653042, (1038):1653043, (1039[u]):1653044, (1040):1653045, (1041[u]):1653046, (1042):1653047, (1043[u]):1653048, (1044-1049):1653049-1653054, (1050-1064):1765421-1765435, (1065[u]):1765436, (1066-1069):1765437-1765440, (1070-1522[u]):1765441-1765893, (1523-1816[u]):1745911-1746204, (1817-2047[u]):1767677-1767907

Inode: 3017523   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 223211438    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c97cd0:06fed3a0 -- Thu Mar  6 05:45:36 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c97bb1:85ff84e4 -- Thu Mar  6 05:40:49 2025
crtime: 0x67c843d8:cd0a3c00 -- Wed Mar  5 07:30:16 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = e5 d7 43 8d 97 2f 06 00 
Inode checksum: 0x6f1a869f
EXTENTS:
(ETB0):12091794, (0):12091578, (1-233):54807-55039, (234-464):204289-204519, (465-676):248880-249091, (677-970):371474-371767, (971-1122):364264-364415, (1123-1202):361984-362063, (1203[u]):362064, (1204):362065, (1205[u]):362066, (1206-1211):362067-362072, (1212[u]):362073, (1213-1222):362074-362083, (1223[u]):362084, (1224-1233):362085-362094, (1234-1252[u]):362095-362113, (1253-1339[u]):368037-368123, (1340-1425[u]):364637-364722, (1426-1505[u]):370555-370634, (1506-1582[u]):361727-361803, (1583-1656[u]):369500-369573, (1657-1730[u]):374335-374408, (1731-1802[u]):364728-364799, (1803-1868[u]):372704-372769, (1869-1934[u]):372798-372863, (1935-1999[u]):372961-373025, (2000-2047[u]):12555448-12555495

Inode: 3017794   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 805679041    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c98b14:df6b46a4 -- Thu Mar  6 06:46:28 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c989e0:6ac36d44 -- Thu Mar  6 06:41:20 2025
crtime: 0x67c989d5:e7be2c00 -- Thu Mar  6 06:41:09 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 95 45 75 fb aa 2f 06 00 
Inode checksum: 0x59423f20
EXTENTS:
(ETB0):12091900, (0):12091875, (1-62):768631-768692, (63-122):757440-757499, (123-191):856960-857028, (192-257):868224-868289, (258-322):865792-865856, (323-386):872320-872383, (387-516):972032-972161, (517-628):971904-972015, (629-716):971776-971863, (717-803):963734-963820, (804-1006):991232-991434, (1007-1089[u]):991435-991517, (1090-1257[u]):1000984-1001151, (1258-1417[u]):1000672-1000831, (1418-1503[u]):999498-999583, (1504-1580[u]):994176-994252, (1581-1648[u]):991676-991743, (1649-1712[u]):1041344-1041407, (1713-1770[u]):1021056-1021113, (1771-1827[u]):1036672-1036728, (1828-1992[u]):1088224-1088388, (1993-2047[u]):12559049-12559103

Inode: 3015242   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 887252949    Version: 0x00000000:00000003
User:     0   Group:   999   Project:     0   Size: 58720256
File ACL: 0
Links: 1   Blockcount: 114696
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67efea70:2956a538 -- Fri Apr  4 10:19:28 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67efea70:2956a538 -- Fri Apr  4 10:19:28 2025
crtime: 0x67efe9b8:55183974 -- Fri Apr  4 10:16:24 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = f6 59 09 88 f4 31 06 00 
Inode checksum: 0x4d1e4ca5
EXTENTS:
(ETB0):12091573, (0):4706305, (1-2047):9176979-9179025, (2048-6332):9187328-9191612, (6333-6410[u]):9191613-9191690, (6411-6499):9191691-9191779, (6500-6577[u]):9191780-9191857, (6578-6665):9191858-9191945, (6666-6744[u]):9191946-9192024, (6745-6832):9192025-9192112, (6833-6910[u]):9192113-9192190, (6911-6999):9192191-9192279, (7000-7077[u]):9192280-9192357, (7078-7165):9192358-9192445, (7166-7244[u]):9192446-9192524, (7245-7332):9192525-9192612, (7333-7411[u]):9192613-9192691, (7412-7499):9192692-9192779, (7500-7577[u]):9192780-9192857, (7578-7666):9192858-9192946, (7667-7744[u]):9192947-9193024, (7745-7832):9193025-9193112, (7833-7910[u]):9193113-9193190, (7911-10239):9193191-9195519, (10240-12626):9203712-9206098, (12627-14335[u]):9206099-9207807

Inode: 3017441   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 143287301    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c6452f:9fe1caf8 -- Mon Mar  3 19:11:27 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64463:2dc6c000 -- Mon Mar  3 19:08:03 2025
crtime: 0x67c6445e:bb611dc0 -- Mon Mar  3 19:07:58 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 01 58 bf 10 79 2f 06 00 
Inode checksum: 0xb502532e
EXTENTS:
(ETB0):12091601, (0):12091600, (1-186):41158-41343, (187-372):52038-52223, (373-557):78151-78335, (558-757):131584-131783, (758-1003):200704-200949, (1004-1141[u]):200950-201087, (1142-1471[u]):217270-217599, (1472-1800[u]):209408-209736, (1801-2047[u]):201439-201685

Inode: 3015593   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 66604337    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d2f83d:38444c00 -- Thu Mar 13 11:22:37 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d2ef4a:48822938 -- Thu Mar 13 10:44:26 2025
crtime: 0x67d2be33:58b11400 -- Thu Mar 13 07:14:59 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 87 6e bb 6e 37 30 06 00 
Inode checksum: 0x5ea89d46
EXTENTS:
(ETB0):12091931, (0):4032512, (1-516):52988-53503, (517-1043):8941568-8942094, (1044[u]):8942095, (1045-1209):8942096-8942260, (1210[u]):8942261, (1211-1275):8942262-8942326, (1276-1279[u]):8942327-8942330, (1280-1281):8942331-8942332, (1282-1286[u]):8942333-8942337, (1287-1288):8942338-8942339, (1289-1292[u]):8942340-8942343, (1293-1294):8942344-8942345, (1295-1298[u]):8942346-8942349, (1299-1311):8942350-8942362, (1312-1316[u]):8942363-8942367, (1317-1338):8942368-8942389, (1339[u]):8942390, (1340-1343):8942391-8942394, (1344[u]):8942395, (1345):8942396, (1346[u]):8942397, (1347-1354):8942398-8942405, (1355[u]):8942406, (1356-1368):8942407-8942419, (1369[u]):8942420, (1370):8942421, (1371[u]):8942422, (1372-1373):8942423-8942424, (1374[u]):8942425, (1375-1382):8942426-8942433, (1383-2047[u]):8942434-8943098

Inode: 3017534   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 608786307    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c65469:d38f872c -- Mon Mar  3 20:16:25 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c653a3:60e05724 -- Mon Mar  3 20:13:07 2025
crtime: 0x67c65174:af79e000 -- Mon Mar  3 20:03:48 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 26 9a 6b d8 79 2f 06 00 
Inode checksum: 0x76632451
EXTENTS:
(ETB0):12091501, (0):12091500, (1-89):37504-37592, (90-168):35889-35967, (169-240):34488-34559, (241-308):39356-39423, (309-373):39807-39871, (374-437):34048-34111, (438-501):34240-34303, (502-565):34752-34815, (566-629):35328-35391, (630-691):58786-58847, (692-748):35264-35320, (749-872):74497-74620, (873-964):74659-74750, (965-1039):155566-155640, (1040[u]):155641, (1041-1046):155642-155647, (1047-1174):225664-225791, (1175-1198):228864-228887, (1199[u]):228888, (1200-1263):228889-228952, (1264-1267[u]):228953-228956, (1268-1269):228957-228958, (1270-1274[u]):228959-228963, (1275):228964, (1276-1280[u]):228965-228969, (1281-1282):228970-228971, (1283-1286[u]):228972-228975, (1287-1301):228976-228990, (1302-1305[u]):228991-228994, (1306-1310):228995-228999, (1311-1322):248466-248477, (1323[u]):248478, (1324-1343):248479-248498, (1344[u]):248499, (1345-1349):248500-248504, (1350[u]):248505, (1351-1352):248506-248507, (1353[u]):248508, (1354):248509, (1355[u]):248510, (1356-1364):248511-248519, (1365[u]):248520, (1366-1368):248521-248523, (1369-1420[u]):248524-248575, (1421-1527[u]):254017-254123, (1528-1624[u]):257951-258047, (1625-1704[u]):260372-260451, (1705-1776[u]):287357-287428, (1777-1840[u]):287071-287134, (1841-1894[u]):320828-320881, (1895-1947[u]):320658-320710, (1948-1998[u]):315789-315839, (1999-2047[u]):370635-370683

Inode: 3015257   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4019827117    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67fb7f3c:53349abc -- Sun Apr 13 05:09:16 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67fb7e3e:0748c440 -- Sun Apr 13 05:05:02 2025
crtime: 0x67fa886b:14c0fd44 -- Sat Apr 12 11:36:11 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 67 0d 14 94 96 32 06 00 
Inode checksum: 0x15283c86
EXTENTS:
(ETB0):12091604, (0):12091495, (1-61):146893-146953, (62-91):147405-147434, (92-358):153237-153503, (359-386):131352-131379, (387-414):152908-152935, (415-440):146854-146879, (441-464):141824-141847, (465-487):146649-146671, (488-508):133759-133779, (509-529):145999-146019, (530-548):131382-131400, (549-567):146087-146105, (568-610):159453-159495, (611-628):144217-144234, (629-646):146525-146542, (647-663):131542-131558, (664-680):146452-146468, (681-696):145980-145995, (697-712):146055-146070, (713-728):146374-146389, (729-744):146967-146982, (745-759):131444-131458, (760-781):159869-159890, (782-796):133738-133752, (797-811):133916-133930, (812-826):146509-146523, (827-841):146612-146626, (842-856):146989-147003, (857-871):152244-152258, (872-886):159267-159281, (887-900):132696-132709, (901-914):133792-133805, (915-928):133856-133869, (929-942):133871-133884, (943-956):143165-143178, (957-970):160070-160083, (971-983):133723-133735, (984-996):143307-143319, (997-1009):146209-146221, (1010-1022):152755-152767, (1023-1035):152860-152872, (1036-1044):153075-153083, (1045[u]):153084, (1046-1048):153085-153087, (1049-1061):159307-159319, (1062-1073):141858-141869, (1074-1085):144192-144203, (1086-1097):144241-144252, (1098-1109):152987-152998, (1110-1121):159928-159939, (1122-1132):131409-131419, (1133-1160):160437-160464, (1161-1171):133809-133819, (1172-1182):134087-134097, (1183-1193):139370-139380, (1194-1204):139536-139546, (1205[u]):139686, (1206-1215):139687-139696, (1216-1226):140078-140088, (1227-1237):141560-141570, (1238-1248):141875-141885, (1249-1259):141927-141937, (1260-1269):141939-141948, (1270[u]):141949, (1271-1273[u]):142321-142323, (1274-1275):142324-142325, (1276-1279[u]):142326-142329, (1280-1281):142330-142331, (1282-1285[u]):146476-146479, (1286-1288):146480-146482, (1289-1291[u]):146483-146485, (1292):146486, (1293-1303):147343-147353, (1304-1307):152333-152336, (1308-1311[u]):152337-152340, (1312-1314):152341-152343, (1315-1325):159983-159993, (1326-1336):160143-160153, (1337-1355):161004-161022, (1356-1358):161076-161078, (1359[u]):161079, (1360-1367):161080-161087, (1368-1378):160664-160674, (1379-1388):132808-132817, (1389-1398):132825-132834, (1399-1408):132922-132931, (1409-1418):133712-133721, (1419-1424):161305-161310, (1425[u]):161311, (1426-1432):161312-161318, (1433-1442):133966-133975, (1443-1445):139609-139611, (1446[u]):139612, (1447-1452):139613-139618, (1453-1462):139989-139998, (1463-1472):142296-142305, (1473-1477):143962-143966, (1478-1482[u]):143967-143971, (1483-1492[u]):144020-144029, (1493-1502[u]):144313-144322, (1503-1512[u]):146407-146416, (1513-1526[u]):161582-161595, (1527-1536[u]):146564-146573, (1537-1546[u]):147120-147129, (1547-1556[u]):147206-147215, (1557-1566[u]):152804-152813, (1567-1576[u]):159232-159241, (1577-1586[u]):159837-159846, (1587-1596[u]):159898-159907, (1597-1606[u]):160180-160189, (1607-1616[u]):160261-160270, (1617-1626[u]):161103-161112, (1627-1636[u]):161151-161160, (1637-1645[u]):133781-133789, (1646-1654[u]):133826-133834, (1655-1663[u]):133905-133913, (1664-1672[u]):139562-139570, (1673-1685[u]):162413-162425, (1686-1694[u]):139584-139592, (1695-1703[u]):141336-141344, (1704-1712[u]):141573-141581, (1713-1721[u]):141772-141780, (1722-1732[u]):162595-162605, (1733-1741[u]):143942-143950, (1742-1750[u]):143978-143986, (1751-1760[u]):162736-162745, (1761-1769[u]):144052-144060, (1770-1778[u]):152224-152232, (1779-1787[u]):152310-152318, (1788-1796[u]):159398-159406, (1797-1809[u]):162838-162850, (1810-1820[u]):162889-162899, (1821-1855[u]):162901-162935, (1856-1864[u]):160117-160125, (1865-1877[u]):162960-162972, (1878-1888[u]):162990-163000, (1889-1897[u]):160904-160912, (1898-1906[u]):162580-162588, (1907-1914[u]):131508-131515, (1915-1929[u]):163072-163086, (1930-2047[u]):12322816-12322933

Inode: 3015711   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 77819081    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c9827a:9c671000 -- Thu Mar  6 06:09:46 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c97f4a:4bc43558 -- Thu Mar  6 05:56:10 2025
crtime: 0x67c97cd0:06fed3a0 -- Thu Mar  6 05:45:36 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = a5 49 bd 34 aa 2f 06 00 
Inode checksum: 0x4cbbdc93
EXTENTS:
(ETB0):12091824, (0):12091793, (1-258):673534-673791, (259-534):686327-686602, (535-677):670577-670719, (678-813):664184-664319, (814-894):660911-660991, (895-959):663743-663807, (960-1024):670143-670207, (1025-1036):673215-673226, (1037[u]):673227, (1038-1089):673228-673279, (1090-1133):679945-679988, (1134-1196):754369-754431, (1197-1265):785105-785173, (1266-1269[u]):785174-785177, (1270-1271):785178-785179, (1272-1275[u]):785180-785183, (1276-1277):785184-785185, (1278-1282[u]):785186-785190, (1283):785191, (1284-1288[u]):785192-785196, (1289-1304):785197-785212, (1305-1309[u]):785213-785217, (1310-1349):785218-785257, (1350[u]):785258, (1351-1353):785259-785261, (1354[u]):785262, (1355-1357):785263-785265, (1358[u]):785266, (1359):785267, (1360[u]):785268, (1361-1366):785269-785274, (1367-1499[u]):785275-785407, (1500-1570[u]):815232-815302, (1571-1826[u]):852992-853247, (1827-1969[u]):856576-856718, (1970-2047[u]):854912-854989

Inode: 3015301   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1035420913    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d2be33:58b11400 -- Thu Mar 13 07:14:59 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d1ed9e:50ba989c -- Wed Mar 12 16:25:02 2025
crtime: 0x67d1b328:69db9c00 -- Wed Mar 12 12:15:36 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = d2 ee fb 83 27 30 06 00 
Inode checksum: 0x629a7e49
EXTENTS:
(ETB0):12091930, (0):12091929, (1-998):30868-31865, (999-1039):17454-17494, (1040[u]):17495, (1041):17496, (1042[u]):17497, (1043):17498, (1044[u]):17499, (1045):17500, (1046[u]):17501, (1047):17502, (1048[u]):17503, (1049-1067):17504-17522, (1068[u]):17523, (1069-1094):17524-17549, (1095-1872[u]):17550-18327, (1873-2047[u]):183224-183398

Inode: 3017503   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1228810752    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c7256f:d59f8000 -- Tue Mar  4 11:08:15 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c7252a:3ee29f38 -- Tue Mar  4 11:07:06 2025
crtime: 0x67c724ac:07645628 -- Tue Mar  4 11:05:00 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = d4 09 52 6f 86 2f 06 00 
Inode checksum: 0xb32381ec
EXTENTS:
(ETB0):12091703, (0):12091702, (1-15):394033-394047, (16-30):402162-402176, (31-225):412733-412927, (226-353):413184-413311, (354-380):413605-413631, (381-409):413667-413695, (410-433):413864-413887, (434-448):402929-402943, (449-467):414061-414079, (468-492):414183-414207, (493-507):404913-404927, (508-522):406494-406508, (523-548):414374-414399, (549-564):414448-414463, (565-582):414606-414623, (583-597):407763-407777, (598-625):414692-414719, (626-650):414823-414847, (651-681):414881-414911, (682-708):414949-414975, (709-723):408726-408740, (724-750):415077-415103, (751-773):415177-415199, (774-788):411633-411647, (789-805):415279-415295, (806-829):415336-415359, (830-844):411708-411722, (845-869):415559-415583, (870-884):411724-411738, (885-899):411757-411771, (900-926):415973-415999, (927-951):416071-416095, (952-966):411775-411789, (967-981):412684-412698, (982-1012):416289-416319, (1013-1031):416365-416383, (1032-1057):416422-416447, (1058-1072):414289-414303, (1073-1086):416586-416599, (1087[u]):416600, (1088-1094):416601-416607, (1095[u]):416713, (1096-1117):416714-416735, (1118-1121):396867-396870, (1122-1131[u]):396871-396880, (1132-1194[u]):416897-416959, (1195-1223[u]):416995-417023, (1224-1253[u]):417122-417151, (1254-1277[u]):417192-417215, (1278-1291[u]):398706-398719, (1292-1305[u]):399574-399587, (1306-1319[u]):399740-399753, (1320-1356[u]):417755-417791, (1357-1370[u]):400274-400287, (1371-1384[u]):400571-400584, (1385-1398[u]):402493-402506, (1399-1458[u]):418628-418687, (1459-1482[u]):418728-418751, (1483-1502[u]):418796-418815, (1503-1532[u]):419426-419455, (1533-1595[u]):419521-419583, (1596-1626[u]):419809-419839, (1627-1646[u]):420300-420319, (1647-1660[u]):403039-403052, (1661-1707[u]):420497-420543, (1708-1733[u]):420582-420607, (1734-1760[u]):420645-420671, (1761-1785[u]):420711-420735, (1786-1822[u]):420827-420863, (1823-1879[u]):421191-421247, (1880-1939[u]):421316-421375, (1940-1953[u]):404658-404671, (1954-1978[u]):422375-422399, (1979-2047[u]):11834-11902

Inode: 3016274   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 709967617    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67daf0c6:96267104 -- Wed Mar 19 12:28:54 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67daefde:455f48bc -- Wed Mar 19 12:25:02 2025
crtime: 0x67d86aca:53ec6000 -- Mon Mar 17 14:32:42 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 68 35 7e 03 8e 30 06 00 
Inode checksum: 0x3e10c5fd
EXTENTS:
(ETB0):12091629, (0):12091628, (1-69):1018812-1018880, (70-132):1016321-1016383, (133-473):1480875-1481215, (474-843):1495192-1495561, (844-1102):1477885-1478143, (1103-1268):1480704-1480869, (1269-1419):1542496-1542646, (1420-1470):1582457-1582507, (1471[u]):1582508, (1472-1867):1582509-1582904, (1868[u]):1582905, (1869-1873):1582906-1582910, (1874[u]):1582911, (1875-1894):1582912-1582931, (1895[u]):1582932, (1896-1905):1582933-1582942, (1906-1907[u]):1582943-1582944, (1908-1934):1582945-1582971, (1935-1936[u]):1582972-1582973, (1937-1961):1582974-1582998, (1962-1967[u]):1582999-1583004, (1968-1979):1583005-1583016, (1980-1986[u]):1583017-1583023, (1987-1998):1583024-1583035, (1999-2004[u]):1583036-1583041, (2005-2016):1583042-1583053, (2017-2023[u]):1583054-1583060, (2024-2047):1583061-1583084, (2048-2079):440015-440046, (2080-2081[u]):440047-440048, (2082-2093):440049-440060, (2094-2101[u]):440061-440068, (2102-2126):440069-440093, (2127[u]):440094, (2128-2220):440095-440187, (2221-2223[u]):440188-440190, (2224-2243):440191-440210, (2244[u]):440211, (2245-2277):440212-440244, (2278-2280[u]):440245-440247, (2281-2346):440248-440313, (2347-2349[u]):440314-440316, (2350-2382):440317-440349, (2383-2386[u]):440350-440353, (2387-2453):440354-440420, (2454-2457[u]):440421-440424, (2458-2459):440425-440426, (2460-2463[u]):440427-440430, (2464-2465):440431-440432, (2466-2469[u]):440433-440436, (2470-2471):440437-440438, (2472-2475[u]):440439-440442, (2476-2478):440443-440445, (2479-2481[u]):440446-440448, (2482-2484):440449-440451, (2485-2487[u]):440452-440454, (2488-2523):440455-440490, (2524[u]):440491, (2525-2529):440492-440496, (2530[u]):440497, (2531-2563):440498-440530, (2564-2577[u]):440531-440544, (2578-2608):440545-440575, (2609-2614):462332-462337, (2615-2629[u]):462338-462352, (2630-2633):462353-462356, (2634-2648[u]):462357-462371, (2649-2673):462372-462396, (2674[u]):462397, (2675-2683):462398-462406, (2684-2688[u]):462407-462411, (2689-2762):462412-462485, (2763[u]):462486, (2764-2820):462487-462543, (2821-2825[u]):462544-462548, (2826-2897):462549-462620, (2898[u]):462621, (2899):462622, (2900[u]):462623, (2901-2904):462624-462627, (2905[u]):462628, (2906-3069):462629-462792, (3070[u]):462793, (3071-3089):462794-462812, (3090[u]):462813, (3091-3092):462814-462815, (3093[u]):500200, (3094-3112):500201-500219, (3113-3532[u]):500220-500639, (3533-3815[u]):503269-503551, (3816-4081[u]):514550-514815, (4082-4095[u]):514226-514239

Inode: 3016232   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2049113136    Version: 0x00000000:00000005
User:     0   Group:   999   Project:     0   Size: 8388584
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67db3fe5:806f1d68 -- Wed Mar 19 18:06:29 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67db3fe5:806f1d68 -- Wed Mar 19 18:06:29 2025
crtime: 0x67daf0c6:96267104 -- Wed Mar 19 12:28:54 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = ad e5 72 84 b4 30 06 00 
Inode checksum: 0xefb9b543
EXTENTS:
(ETB0):12091630, (0):12091580, (1-256):197632-197887, (257-428):218624-218795, (429-749):253696-254016, (750-1016):277237-277503, (1017-1276):287998-288257, (1277-1462):263168-263353, (1463[u]):263354, (1464-1478):263355-263369, (1479-1480[u]):263370-263371, (1481-1484):263372-263375, (1485-1486[u]):263376-263377, (1487-1519):263378-263410, (1520[u]):263411, (1521-1532):263412-263423, (1533-1730):285952-286149, (1731[u]):286150, (1732-1788):286151-286207, (1789-1805):318131-318147, (1806[u]):318148, (1807-1819):318149-318161, (1820[u]):318162, (1821-1822):318163-318164, (1823[u]):318165, (1824-1863):318166-318205, (1864-1880[u]):318206-318222, (1881-1882):318223-318224, (1883-1898[u]):318225-318240, (1899-1900):318241-318242, (1901-1917[u]):318243-318259, (1918-1919):318260-318261, (1920-1935[u]):318262-318277, (1936-1974):318278-318316, (1975-1991[u]):318317-318333, (1992-2000):318334-318342, (2001-2005[u]):318343-318347, (2006-2024):318348-318366, (2025[u]):318367, (2026-2028):318368-318370, (2029-2034):366124-366129, (2035-2039[u]):366130-366134, (2040):366135, (2041-2045[u]):366136-366140, (2046-2047):366141-366142

Inode: 3016049   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1519005373    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d336e3:e27ceda4 -- Thu Mar 13 15:49:55 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d3344d:59439d34 -- Thu Mar 13 15:38:53 2025
crtime: 0x67d33440:3dfd2400 -- Thu Mar 13 15:38:40 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 0b a3 09 78 3e 30 06 00 
Inode checksum: 0x88c7472a
EXTENTS:
(ETB0):12091938, (0):12091937, (1-498):82958-83455, (499-983):125979-126463, (984-1067):171180-171263, (1068[u]):171264, (1069-1145):171265-171341, (1146-1549[u]):171342-171745, (1550-2047[u]):12281857-12282354

Inode: 3015837   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3701882836    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67eda506:0c65d400 -- Wed Apr  2 16:58:46 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67eda48d:5bebc524 -- Wed Apr  2 16:56:45 2025
crtime: 0x67eda46a:29020c00 -- Wed Apr  2 16:56:10 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 19 2a 05 e2 d1 31 06 00 
Inode checksum: 0x8c854355
EXTENTS:
(ETB0):12091570, (0):12092211, (1-306):363520-363825, (307-603):373463-373759, (604-899):367358-367653, (900-1041):364800-364941, (1042[u]):364942, (1043):364943, (1044[u]):364944, (1045):364945, (1046[u]):364946, (1047):364947, (1048[u]):364948, (1049):364949, (1050[u]):364950, (1051-1074):364951-364974, (1075[u]):364975, (1076):364976, (1077-1155[u]):364977-365055, (1156-1402[u]):377836-378082, (1403-1644[u]):384416-384657, (1645-1882[u]):383762-383999, (1883-2047[u]):374013-374177

Inode: 3014807   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3785920825    Version: 0x00000000:00000003
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16384
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d332cc:10366400 -- Thu Mar 13 15:32:28 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d32fb0:55d6cd4c -- Thu Mar 13 15:19:12 2025
crtime: 0x67d32fa0:112cad4c -- Thu Mar 13 15:18:56 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = a7 48 74 31 3e 30 06 00 
Inode checksum: 0x7cfb19f9
EXTENTS:
(0):12034048, (1-715):272902-273616, (716-965):14184448-14184697, (966-2047[u]):14184698-14185779

Inode: 3016451   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4118006318    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c985c5:a6e49c00 -- Thu Mar  6 06:23:49 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c984e6:0d9ba500 -- Thu Mar  6 06:20:06 2025
crtime: 0x67c984c2:aab52c00 -- Thu Mar  6 06:19:30 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 31 3b 04 ae aa 2f 06 00 
Inode checksum: 0x2961b484
EXTENTS:
(ETB0):12091868, (0):12091827, (1-92):884128-884219, (93-182):865146-865235, (183-269):1022976-1023062, (270-366):1378304-1378400, (367-810):1382485-1382928, (811-954):1399664-1399807, (955-1033):1419500-1419578, (1034[u]):1419579, (1035):1419580, (1036[u]):1419581, (1037):1419582, (1038[u]):1419583, (1039):1419584, (1040[u]):1419585, (1041):1419586, (1042[u]):1419587, (1043-1064):1419588-1419609, (1065[u]):1419610, (1066-1069):1419611-1419614, (1070-1233[u]):1419615-1419778, (1234-1745[u]):1437696-1438207, (1746-2047[u]):1420326-1420627

Inode: 3014894   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2260752342    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d0d98d:5cf5b5e4 -- Tue Mar 11 20:47:09 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d0cf22:db826cf4 -- Tue Mar 11 20:02:42 2025
crtime: 0x67d060f4:08954400 -- Tue Mar 11 12:12:36 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 3c be 63 5b 13 30 06 00 
Inode checksum: 0xb30a5e79
EXTENTS:
(ETB0):12091527, (0):12091392, (1-1014):87049-88062, (1015-1040):76903-76928, (1041[u]):76929, (1042-1178):76930-77066, (1179[u]):77067, (1180-1260):77068-77148, (1261-1265[u]):77149-77153, (1266):77154, (1267-1271[u]):77155-77159, (1272-1273):77160-77161, (1274-1277[u]):77162-77165, (1278-1279):77166-77167, (1280-1283[u]):77168-77171, (1284-1298):77172-77186, (1299-1303[u]):77187-77191, (1304-1334):77192-77222, (1335[u]):77223, (1336-1349):77224-77237, (1350[u]):77238, (1351):77239, (1352[u]):77240, (1353-1354):77241-77242, (1355-1871[u]):77243-77759, (1872-2047[u]):173128-173303

Inode: 3015437   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1801472646    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e801ad:e4e1c000 -- Sat Mar 29 10:20:29 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e80158:2ea7272c -- Sat Mar 29 10:19:04 2025
crtime: 0x67e7fc36:05b8d800 -- Sat Mar 29 09:57:10 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 33 5c 2f 90 7b 31 06 00 
Inode checksum: 0xaa38c780
EXTENTS:
(ETB0):12091706, (0):12091705, (1-96):75168-75263, (97-161):75997-76061, (162-215):75091-75144, (216-268):86652-86704, (269-308):90779-90818, (309-338):86311-86340, (339-367):86385-86413, (368-394):86620-86646, (395-418):79821-79844, (419-441):83658-83680, (442-463):78413-78434, (464-484):86187-86207, (485-504):76099-76118, (505-524):89580-89599, (525-542):75951-75968, (543-560):78471-78488, (561-578):83752-83769, (579-595):71662-71678, (596-612):78395-78411, (613-629):78706-78722, (630-646):79530-79546, (647-661):75902-75916, (662-676):76177-76191, (677-691):78622-78636, (692-706):78687-78701, (707-721):90339-90353, (722-736):90694-90708, (737-751):90735-90749, (752-766):91664-91678, (767-781):92027-92041, (782-795):76126-76139, (796-809):76156-76169, (810-823):86265-86278, (824-837):90568-90581, (838-851):90856-90869, (852-866):92755-92769, (867-880):91884-91897, (881-894):92281-92294, (895-907):79576-79588, (908-969):92861-92922, (970-982):79722-79734, (983-997):93059-93073, (998-1010):83456-83468, (1011-1031):93118-93138, (1032-1044):83686-83698, (1045-1057):83825-83837, (1058-1070):83844-83856, (1071-1083):83887-83899, (1084-1096):90228-90240, (1097-1109):90523-90535, (1110-1122):90884-90896, (1123-1135):91056-91068, (1136-1148):92794-92806, (1149-1160):75871-75882, (1161-1172):79630-79641, (1173-1184):87036-87047, (1185-1196):90711-90722, (1197-1208):92174-92185, (1209-1211):92432-92434, (1212[u]):92435, (1213-1220):92436-92443, (1221-1240):93362-93381, (1241-1252):92558-92569, (1253-1264):92592-92603, (1265-1271):92842-92848, (1272-1275[u]):92849-92852, (1276):92853, (1277-1278):79432-79433, (1279-1282[u]):79434-79437, (1283-1284):79438-79439, (1285-1287[u]):79440-79442, (1288[u]):79856, (1289-1290):79857-79858, (1291-1294[u]):79859-79862, (1295-1298):79863-79866, (1299-1312):93437-93450, (1313-1323):83809-83819, (1324-1325):83955-83956, (1326-1329[u]):83957-83960, (1330-1334):83961-83965, (1335-1345):87020-87030, (1346-1356):90604-90614, (1357-1365):93526-93534, (1366[u]):93535, (1367-1369):93536-93538, (1370[u]):93539, (1371):93540, (1372[u]):93541, (1373-1380):93542-93549, (1381[u]):93550, (1382):93551, (1383):90644, (1384[u]):90645, (1385-1393):90646-90654, (1394-1404[u]):90674-90684, (1405-1415[u]):91761-91771, (1416-1426[u]):91773-91783, (1427-1446[u]):93665-93684, (1447-1457[u]):92338-92348, (1458-1493[u]):99382-99417, (1494-1653[u]):113408-113567, (1654-1788[u]):122873-123007, (1789-1870[u]):124590-124671, (1871-1926[u]):112702-112757, (1927-2047[u]):12324445-12324565

Inode: 3016133   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1654370464    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d755e5:660fb29c -- Sun Mar 16 18:51:17 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d4ec05:8dcd0748 -- Fri Mar 14 22:55:01 2025
crtime: 0x67d33a07:dc85a60c -- Thu Mar 13 16:03:19 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 86 70 3b d0 3e 30 06 00 
Inode checksum: 0x58e1f10b
EXTENTS:
(ETB0):12091612, (0):12091611, (1-407):247113-247519, (408-687):248186-248465, (688-939):285700-285951, (940-1207):345460-345727, (1208-1297):345849-345938, (1298-1301[u]):345939-345942, (1302-1303):345943-345944, (1304-1307[u]):345945-345948, (1308-1309):345949-345950, (1310-1313[u]):345951-345954, (1314-1316):345955-345957, (1317-1319[u]):345958-345960, (1320-1338):345961-345979, (1339[u]):345980, (1340-1378):345981-346019, (1379-1382[u]):346020-346023, (1383-1428):346024-346069, (1429-1463):351679-351713, (1464[u]):351714, (1465-1466):351715-351716, (1467[u]):351717, (1468-1482):351718-351732, (1483-1623[u]):351733-351873, (1624-1816[u]):346303-346495, (1817-2047[u]):12260608-12260838

Inode: 3015348   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3323353459    Version: 0x00000000:00000005
User:     0   Group:   999   Project:     0   Size: 4364848
File ACL: 0
Links: 1   Blockcount: 8536
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d32fa0:7de4b54c -- Thu Mar 13 15:18:56 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d32fa0:7de4b54c -- Thu Mar 13 15:18:56 2025
crtime: 0x67d32f9b:60523400 -- Thu Mar 13 15:18:51 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 5f 1a 2d 31 3e 30 06 00 
Inode checksum: 0xae8c7e6a
EXTENTS:
(ETB0):12091935, (0):12091489, (1-510):85506-86015, (511-1020):143362-143871, (1021-1036):191491-191506, (1037[u]):191507, (1038):191508, (1039[u]):191509, (1040):191510, (1041[u]):191511, (1042):191512, (1043[u]):191513, (1044):191514, (1045[u]):191515, (1046-1065):191516-191535

Inode: 3017749   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2778677666    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c989d5:e7be2c00 -- Thu Mar  6 06:41:09 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c988b1:2da33820 -- Thu Mar  6 06:36:17 2025
crtime: 0x67c988ab:ca2dd000 -- Thu Mar  6 06:36:11 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = e8 44 b0 e9 aa 2f 06 00 
Inode checksum: 0x6520e447
EXTENTS:
(ETB0):12091874, (0):12091873, (1-76):1024273-1024348, (77-370):1509376-1509669, (371-888):1544200-1544717, (889-1004):1556481-1556596, (1005-1411[u]):1556597-1557003, (1412-1910[u]):1546155-1546653, (1911-2047[u]):1540288-1540424

Inode: 3014671   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4274289244    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67ecc694:4e338800 -- Wed Apr  2 01:09:40 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67ecc64b:3a4cdd9c -- Wed Apr  2 01:08:27 2025
crtime: 0x67ead0d2:04c4b400 -- Mon Mar 31 13:28:50 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = b8 bd d8 c0 a6 31 06 00 
Inode checksum: 0x9b3a0a03
EXTENTS:
(ETB0):12091927, (0):12091711, (1-42):201686-201727, (43-84):205397-205438, (85-126):219186-219227, (127-167):199010-199050, (168-207):203249-203288, (208-244):223976-224012, (245-277):221184-221216, (278-309):198881-198912, (310-341):217600-217631, (342-373):223943-223974, (374-523):237546-237695, (524-796):260452-260724, (797-1007):246538-246748, (1008-1185):244736-244913, (1186-1360):257280-257454, (1361-1477):259805-259921, (1478[u]):259922, (1479-1523):259923-259967, (1524-1635):238336-238447, (1636[u]):238448, (1637-1683):238449-238495, (1684-1746):264798-264860, (1747[u]):264861, (1748-1787):264862-264901, (1788-1789[u]):264902-264903, (1790-1794):264904-264908, (1795[u]):264909, (1796-1821):264910-264935, (1822[u]):264936, (1823-1841):264937-264955, (1842-1909):287845-287912, (1910-1911[u]):287913-287914, (1912-1924):287915-287927, (1925[u]):287928, (1926-1931):287929-287934, (1932[u]):287935, (1933-1941):287936-287944, (1942[u]):287945, (1943-1981):287946-287984, (1982-1989[u]):287985-287992, (1990-1994):287993-287997, (1995-1999):369445-369449, (2000-2007[u]):369450-369457, (2008-2018):369458-369468, (2019-2026[u]):369469-369476, (2027-2036):369477-369486, (2037-2044[u]):369487-369494, (2045-2047):369495-369497, (2048-2091):8327168-8327211, (2092-2100[u]):8327212-8327220, (2101-2143):8327221-8327263, (2144[u]):8327264, (2145-2159):8327265-8327279, (2160-2161[u]):8327280-8327281, (2162-2247):8327282-8327367, (2248[u]):8327368, (2249-2255):8327369-8327375, (2256-2258[u]):8327376-8327378, (2259-2261):8327379-8327381, (2262[u]):8327382, (2263-2277):8327383-8327397, (2278-2280[u]):8327398-8327400, (2281-2356):8327401-8327476, (2357-2360[u]):8327477-8327480, (2361-2401):8327481-8327521, (2402-2405[u]):8327522-8327525, (2406-2407):8327526-8327527, (2408-2411[u]):8327528-8327531, (2412-2414):8327532-8327534, (2415-2417[u]):8327535-8327537, (2418-2420):8327538-8327540, (2421-2423[u]):8327541-8327543, (2424-2426):8327544-8327546, (2427-2430[u]):8327547-8327550, (2431-2432):8327551-8327552, (2433-2436[u]):8327553-8327556, (2437-2525):8327557-8327645, (2526[u]):8327646, (2527-2557):8327647-8327677, (2558-2561[u]):8327678-8327681, (2562-2591):8327682-8327711, (2592-2606[u]):8327712-8327726, (2607-2649):8327727-8327769, (2650[u]):8327770, (2651-2683):8327771-8327803, (2684[u]):8327804, (2685-2708):8327805-8327828, (2709-2724[u]):8327829-8327844, (2725-2727):8327845-8327847, (2728-2743[u]):8327848-8327863, (2744-2796):8327864-8327916, (2797[u]):8327917, (2798-2872):8327918-8327992, (2873-2877[u]):8327993-8327997, (2878-2900):8327998-8328020, (2901[u]):8328021, (2902):8328022, (2903[u]):8328023, (2904-2922):8328024-8328042, (2923[u]):8328043, (2924-2941):8328044-8328061, (2942-4095[u]):8328062-8329215

Inode: 3016189   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1299172500    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d33a07:dc85a60c -- Thu Mar 13 16:03:19 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d338ea:b626dc00 -- Thu Mar 13 15:58:34 2025
crtime: 0x67d338c9:07a12000 -- Thu Mar 13 15:58:01 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = b4 8a 39 bd 3e 30 06 00 
Inode checksum: 0x01af6ad0
EXTENTS:
(ETB0):12091610, (0):12091609, (1-511):173569-174079, (512-1018):189440-189946, (1019-1030):222802-222813, (1031[u]):222814, (1032):222815, (1033[u]):222816, (1034-1039):222817-222822, (1040[u]):222823, (1041-1077):222824-222860, (1078-1448[u]):222861-223231, (1449-1876[u]):198228-198655, (1877-2047[u]):12259328-12259498

Inode: 3017527   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3383673892    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c64fc1:d4ab5c00 -- Mon Mar  3 19:56:33 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64ed9:e2407874 -- Mon Mar  3 19:52:41 2025
crtime: 0x67c64cab:bfb04400 -- Mon Mar  3 19:43:23 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 5a 94 68 8f 79 2f 06 00 
Inode checksum: 0xfc1aac11
EXTENTS:
(ETB0):12091497, (0):12091496, (1-128):58624-58751, (129-242):36430-36543, (243-390):69137-69284, (391-531):70259-70399, (532-659):67808-67935, (660-787):82816-82943, (788-985):120326-120523, (986-1115):130046-130175, (1116-1118):105216-105218, (1119[u]):105219, (1120-1124):105220-105224, (1125[u]):105225, (1126):105226, (1127[u]):105227, (1128-1175):105228-105275, (1176-1243[u]):105276-105343, (1244-1371[u]):109568-109695, (1372-1499[u]):124672-124799, (1500-1627[u]):134144-134271, (1628-1727[u]):208796-208895, (1728-1866[u]):220021-220159, (1867-2002[u]):213880-214015, (2003-2047[u]):12489901-12489945

Inode: 3017539   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 448423060    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c843d8:cd0a3c00 -- Wed Mar  5 07:30:16 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c8429e:20cf633c -- Wed Mar  5 07:25:02 2025
crtime: 0x67c73c0d:b1622800 -- Tue Mar  4 12:44:45 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 8e cd 18 d4 87 2f 06 00 
Inode checksum: 0x3a74f6cd
EXTENTS:
(ETB0):12091792, (0):12091821, (1-16):567719-567734, (17-32):568794-568809, (33-48):569382-569397, (49-63):558865-558879, (64-101):569469-569506, (102-132):569508-569538, (133-147):558993-559007, (148-201):569590-569643, (202-216):565600-565614, (217-231):566272-566286, (232-248):569769-569785, (249-263):566384-566398, (264-278):566457-566471, (279-293):566752-566766, (294-308):568774-568788, (309-323):569011-569025, (324-433):569924-570033, (434-470):570077-570113, (471-485):569072-569086, (486-502):570132-570148, (503-517):569364-569378, (518-531):558962-558975, (532-588):570235-570291, (589-615):570293-570319, (616-650):570330-570364, (651-664):559616-559629, (665-678):564436-564449, (679-692):565132-565145, (693-706):565206-565219, (707-720):565874-565887, (721-785):570494-570558, (786-820):570561-570595, (821-847):570613-570639, (848-873):570732-570757, (874-887):567538-567551, (888-935):570777-570824, (936-949):567864-567877, (950-967):570848-570865, (968-986):570872-570890, (987-1000):568523-568536, (1001-1014):569040-569053, (1015-1039):571108-571132, (1040[u]):571133, (1041-1103):571134-571196, (1104-1117):569449-569462, (1118-1131):570162-570175, (1132-1148):571229-571245, (1149-1161):559571-559583, (1162-1174):561875-561887, (1175-1205):571260-571290, (1206-1219):571315-571328, (1220-1232):564359-564371, (1233-1253):571883-571903, (1254-1296):571988-572030, (1297[u]):572031, (1298-1307):572032-572041, (1308-1311[u]):572042-572045, (1312-1314):572046-572048, (1315-1317[u]):572049-572051, (1318-1320):572052-572054, (1321-1323[u]):572055-572057, (1324-1326):572058-572060, (1327-1330[u]):572061-572064, (1331-1342):572065-572076, (1343-1345[u]):572077-572079, (1346[u]):564679, (1347-1358):564680-564691, (1359-1377):573869-573887, (1378-1385):565357-565364, (1386[u]):565365, (1387-1390):565366-565369, (1391-1403):565373-565385, (1404-1430):579685-579711, (1431-1437):579820-579826, (1438[u]):579827, (1439-1450):579828-579839, (1451-1462):580031-580042, (1463[u]):580043, (1464-1491):580044-580071, (1492[u]):580072, (1493):580073, (1494[u]):580074, (1495):580075, (1496[u]):580076, (1497):580077, (1498[u]):580078, (1499):580079, (1500[u]):580080, (1501):580081, (1502[u]):580082, (1503-1508):580083-580088, (1509-1515[u]):580089-580095, (1516-1528[u]):566194-566206, (1529-1543[u]):582385-582399, (1544-1556[u]):566324-566336, (1557-1618[u]):582569-582630, (1619-1631[u]):566519-566531, (1632-1692[u]):583846-583906, (1693-1705[u]):567468-567480, (1706-1738[u]):584000-584032, (1739-1823[u]):585702-585786, (1824-1836[u]):568543-568555, (1837-1849[u]):568589-568601, (1850-1876[u]):585805-585831, (1877-1981[u]):585836-585940, (1982-1994[u]):569094-569106, (1995-2047[u]):12553131-12553183

Inode: 3015543   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1709572147    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67ead0d2:04c4b400 -- Mon Mar 31 13:28:50 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67ead0c7:5a995c00 -- Mon Mar 31 13:28:39 2025
crtime: 0x67e8099a:4f27ac00 -- Sat Mar 29 10:54:18 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 5e 3d 87 5c 7c 31 06 00 
Inode checksum: 0xae059da3
EXTENTS:
(ETB0):12091710, (0):12091709, (1-62):296431-296492, (63-350):371135-371422, (351-630):362144-362423, (631-868):365266-365503, (869-1061):366143-366335, (1062-1217):369289-369444, (1218-1373):370369-370524, (1374-1382):365056-365064, (1383[u]):365065, (1384-1497):365066-365179, (1498-1619):361856-361977, (1620-1719):364416-364515, (1720-1726):378342-378348, (1727-1728[u]):378349-378350, (1729-1732):378351-378354, (1733-1734[u]):378355-378356, (1735-1737):378357-378359, (1738[u]):378360, (1739-1806):378361-378428, (1807-1815):378112-378120, (1816-1817[u]):378121-378122, (1818-1840):378123-378145, (1841[u]):378146, (1842-1867):378147-378172, (1868-1870[u]):378173-378175, (1871-1884):378176-378189, (1885-1950):370750-370815, (1951-1977):12321819-12321845, (1978-1987[u]):12321846-12321855, (1988-1995):12321856-12321863, (1996-2006[u]):12321864-12321874, (2007-2014):12321875-12321882, (2015-2024[u]):12321883-12321892, (2025-2033):12321893-12321901, (2034-2043[u]):12321902-12321911, (2044-2047):12321912-12321915, (2048-2052):200576-200580, (2053-2055[u]):200581-200583, (2056-2065):200584-200593, (2066[u]):200594, (2067-2096):200595-200624, (2097-2118):295946-295967, (2119-2130[u]):295968-295979, (2131-2139):295980-295988, (2140-2193):340480-340533, (2194[u]):340534, (2195-2198):340535-340538, (2199-2202[u]):340539-340542, (2203-2237):340543-340577, (2238[u]):340578, (2239-2258):340579-340598, (2259[u]):340599, (2260):340600, (2261[u]):340601, (2262-2288):340602-340628, (2289-2292[u]):340629-340632, (2293-2355):340633-340695, (2356-2359[u]):340696-340699, (2360-2365):340700-340705, (2366[u]):340706, (2367):340707, (2368[u]):340708, (2369-2391):340709-340731, (2392-2395[u]):340732-340735, (2396-2405):340736-340745, (2406[u]):340746, (2407-2475):340747-340815, (2476-2480[u]):340816-340820, (2481):340821, (2482-2486[u]):340822-340826, (2487-2488):340827-340828, (2489-2492[u]):340829-340832, (2493-2494):340833-340834, (2495-2498[u]):340835-340838, (2499-2500):340839-340840, (2501-2504[u]):340841-340844, (2505-2506):340845-340846, (2507-2511[u]):340847-340851, (2512-2521):340852-340861, (2522[u]):340862, (2523-2535):340863-340875, (2536[u]):340876, (2537-2555):340877-340895, (2556-2624):340948-341016, (2625[u]):341017, (2626-2653):341018-341045, (2654-2658[u]):341046-341050, (2659-2697):341051-341089, (2698-2714[u]):341090-341106, (2715-2741):341107-341133, (2742-2791[u]):341134-341183, (2792-2965[u]):339794-339967, (2966-3025[u]):340356-340415, (3026-3078[u]):351062-351114, (3079-3129[u]):350406-350456, (3130-3180[u]):351116-351166, (3181-3227[u]):347344-347390, (3228-3273[u]):358147-358192, (3274-3307[u]):350961-350994, (3308-3340[u]):358113-358145, (3341-3357[u]):350782-350798, (3358-3374[u]):350877-350893, (3375-3407[u]):358258-358290, (3408-3427[u]):358298-358317, (3428-3471[u]):358320-358363, (3472-3488[u]):358061-358077, (3489-3504[u]):331264-331279, (3505-3519[u]):329169-329183, (3520-3545[u]):358400-358425, (3546-3568[u]):358427-358449, (3569-3583[u]):339089-339103, (3584-3598[u]):339729-339743, (3599-3613[u]):340209-340223, (3614-3628[u]):342129-342143, (3629-3648[u]):358481-358500, (3649-3676[u]):358502-358529, (3677-3691[u]):350523-350537, (3692-3716[u]):358536-358560, (3717-3731[u]):356104-356118, (3732-3771[u]):358585-358624, (3772-3786[u]):356156-356170, (3787-3801[u]):357777-357791, (3802-3816[u]):358024-358038, (3817-3830[u]):332274-332287, (3831-3844[u]):337234-337247, (3845-3858[u]):341618-341631, (3859-3876[u]):358674-358691, (3877-3896[u]):358693-358712, (3897-3910[u]):356407-356420, (3911-3924[u]):356724-356737, (3925-3938[u]):357702-357715, (3939-3952[u]):357934-357947, (3953-3965[u]):332243-332255, (3966-3978[u]):334034-334046, (3979-3991[u]):337715-337727, (3992-4004[u]):338931-338943, (4005-4095[u]):373922-374012

Inode: 3015127   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2395591611    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d32f9b:60523400 -- Thu Mar 13 15:18:51 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d32f10:4dd2576c -- Thu Mar 13 15:16:32 2025
crtime: 0x67d2f83d:38444c00 -- Thu Mar 13 11:22:37 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 7a 70 54 e4 3a 30 06 00 
Inode checksum: 0xf65a5bf5
EXTENTS:
(ETB0):12091933, (0):12091932, (1-820):119372-120191, (821-1041):124940-125160, (1042[u]):125161, (1043):125162, (1044[u]):125163, (1045):125164, (1046[u]):125165, (1047):125166, (1048[u]):125167, (1049):125168, (1050[u]):125169, (1051-1069):125170-125188, (1070[u]):125189, (1071-1106):125190-125225, (1107-1424[u]):125226-125543, (1425-2047[u]):12280833-12281455

Inode: 3014921   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3513189876    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67eda46a:29020c00 -- Wed Apr  2 16:56:10 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67ed9e32:175172b4 -- Wed Apr  2 16:29:38 2025
crtime: 0x67ecc694:4e338800 -- Wed Apr  2 01:09:40 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 95 e1 14 a9 c4 31 06 00 
Inode checksum: 0x060313b7
EXTENTS:
(ETB0):12092027, (0):12091928, (1-518):391668-392185, (519-957):374409-374847, (958-1046):371840-371928, (1047[u]):371929, (1048):371930, (1049[u]):371931, (1050-1069):371932-371951, (1070[u]):371952, (1071-1176):371953-372058, (1177-1181[u]):372059-372063, (1182-1363[u]):372064-372245, (1364-1724[u]):388247-388607, (1725-2047[u]):368124-368446

Inode: 3016146   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1186996424    Version: 0x00000000:00000003
User:     0   Group:   999   Project:     0   Size: 41943040
File ACL: 0
Links: 1   Blockcount: 81928
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67efead1:1a4e0038 -- Fri Apr  4 10:21:05 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67efead1:0923a03c -- Fri Apr  4 10:21:05 2025
crtime: 0x67efea70:26e0793c -- Fri Apr  4 10:19:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 23 14 fe 92 f4 31 06 00 
Inode checksum: 0xf9a0ea9d
EXTENTS:
(ETB0):12091574, (0):8651776, (1-2047):9220096-9222142, (2048-4095):9222144-9224191, (4096-6254):8318976-8321134, (6255-6409[u]):8321135-8321289, (6410-6421):8321290-8321301, (6422-6575[u]):8321302-8321455, (6576-6587):8321456-8321467, (6588-6742[u]):8321468-8321622, (6743-6754):8321623-8321634, (6755-6908[u]):8321635-8321788, (6909-6921):8321789-8321801, (6922-7075[u]):8321802-8321955, (7076-7087):8321956-8321967, (7088-7242[u]):8321968-8322122, (7243-7254):8322123-8322134, (7255-7408[u]):8322135-8322288, (7409-7420):8322289-8322300, (7421-7575[u]):8322301-8322455, (7576-7587):8322456-8322467, (7588-7741[u]):8322468-8322621, (7742-7754):8322622-8322634, (7755-7908[u]):8322635-8322788, (7909-8191):8322789-8323071, (8192-8514):8275968-8276290, (8515-10239[u]):8276291-8278015

Inode: 3017532   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 809296807    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c65174:af79e000 -- Mon Mar  3 20:03:48 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64fc6:496ed400 -- Mon Mar  3 19:56:38 2025
crtime: 0x67c64fc1:d4ab5c00 -- Mon Mar  3 19:56:33 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 48 5a 80 be 79 2f 06 00 
Inode checksum: 0x1e4458ca
EXTENTS:
(ETB0):12091499, (0):12091498, (1-111):65265-65375, (112-217):57494-57599, (218-315):60542-60639, (316-412):43967-44063, (413-509):57343-57439, (510-605):35488-35583, (606-700):41377-41471, (701-823):275211-275333, (824-926):274873-274975, (927-1005):287744-287822, (1006-1027[u]):287823-287844, (1028-1123[u]):281307-281402, (1124-1212[u]):287639-287727, (1213-1290[u]):286679-286756, (1291-1365[u]):295989-296063, (1366-1440[u]):303349-303423, (1441-1504[u]):339648-339711, (1505-1563[u]):355961-356019, (1564-1621[u]):352060-352117, (1622-1678[u]):356596-356652, (1679-1732[u]):356049-356102, (1733-1785[u]):333172-333224, (1786-1837[u]):331318-331369, (1838-1887[u]):355280-355329, (1888-1932[u]):357330-357374, (1933-1975[u]):333081-333123, (1976-2047[u]):30796-30867

Inode: 3015589   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2567044870    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e8099a:4f27ac00 -- Sat Mar 29 10:54:18 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e8096a:84517ff0 -- Sat Mar 29 10:53:30 2025
crtime: 0x67e801ad:e4e1c000 -- Sat Mar 29 10:20:29 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 8d bd a0 e3 7b 31 06 00 
Inode checksum: 0x9fad6878
EXTENTS:
(ETB0):12091708, (0):12091707, (1-154):221636-221789, (155-291):218885-219021, (292-397):197888-197993, (398-496):198129-198227, (497-560):199808-199871, (561-624):218469-218532, (625-678):219270-219323, (679-731):217803-217855, (732-804):234231-234303, (805-1039):306431-306665, (1040[u]):306666, (1041-1042):306667-306668, (1043[u]):306669, (1044):306670, (1045[u]):306671, (1046):306672, (1047[u]):306673, (1048):306674, (1049[u]):306675, (1050-1069):306676-306695, (1070[u]):306696, (1071-1074):306697-306700, (1075-1146[u]):306701-306772, (1147-1355[u]):313332-313540, (1356-1516[u]):297566-297726, (1517-1672[u]):300742-300897, (1673-1827[u]):305758-305912, (1828-1971[u]):310277-310420, (1972-2047[u]):12404659-12404734

Inode: 3017537   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 426107682    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c724ac:07645628 -- Tue Mar  4 11:05:00 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c72424:288f73b8 -- Tue Mar  4 11:02:44 2025
crtime: 0x67c72033:06acfc00 -- Tue Mar  4 10:45:55 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 61 a6 12 2b 86 2f 06 00 
Inode checksum: 0x08465c25
EXTENTS:
(ETB0):12091714, (0):12091701, (1-122):407398-407519, (123-219):408063-408159, (220-255):406524-406559, (256-291):406777-406812, (292-323):407296-407327, (324-352):393565-393593, (353-380):407576-407603, (381-406):395072-395097, (407-432):399429-399454, (433-458):407618-407643, (459-483):397335-397359, (484-720):411379-411615, (721-743):402227-402249, (744-775):411653-411684, (776-798):402888-402910, (799-821):403885-403907, (822-843):393318-393339, (844-865):399527-399548, (866-886):396222-396242, (887-907):403496-403516, (908-928):406037-406057, (929-948):402004-402023, (949-1037):411870-411958, (1038[u]):411959, (1039-1082):411960-412003, (1083[u]):412004, (1084-1091):412005-412012, (1092-1111):403943-403962, (1112-1114):412059-412061, (1115-1257[u]):412062-412204, (1258-1277[u]):411687-411706, (1278-1296[u]):394496-394514, (1297-1364[u]):412245-412312, (1365-1383[u]):400646-400664, (1384-1402[u]):401859-401877, (1403-1421[u]):406189-406207, (1422-1440[u]):407733-407751, (1441-1458[u]):394734-394751, (1459-1476[u]):402179-402196, (1477-1494[u]):402650-402667, (1495-1519[u]):412400-412424, (1520-1541[u]):412431-412452, (1542-1559[u]):411800-411817, (1560-1577[u]):412318-412335, (1578-1594[u]):400667-400683, (1595-1611[u]):401596-401612, (1612-1658[u]):412501-412547, (1659-1675[u]):403724-403740, (1676-1692[u]):406295-406311, (1693-1710[u]):412580-412597, (1711-1727[u]):407715-407731, (1728-1743[u]):412214-412229, (1744-1765[u]):412620-412641, (1766-1791[u]):412646-412671, (1792-2047[u]):412928-413183

Inode: 3015309   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3694773008    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e7fc36:05b8d800 -- Sat Mar 29 09:57:10 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e7fb4b:a0bd626c -- Sat Mar 29 09:53:15 2025
crtime: 0x67e7fb2a:b71b0000 -- Sat Mar 29 09:52:42 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 43 65 41 80 7b 31 06 00 
Inode checksum: 0xa1fee811
EXTENTS:
(ETB0):12091704, (0):12092087, (1-384):14080-14463, (385-758):13568-13941, (759-982):27392-27615, (983-1034):11175-11226, (1035[u]):11227, (1036):11228, (1037[u]):11229, (1038):11230, (1039[u]):11231, (1040):11232, (1041[u]):11233, (1042):11234, (1043[u]):11235, (1044-1062):11236-11254, (1063-1181[u]):11255-11373, (1182-1338[u]):14592-14748, (1339-1479[u]):12147-12287, (1480-1615[u]):15270-15405, (1616-1743[u]):9344-9471, (1744-1846[u]):10944-11046, (1847-1949[u]):14942-15044, (1950-2047[u]):12328448-12328545

Inode: 3014668   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1302887663    Version: 0x00000000:00000005
User:     0   Group:   999   Project:     0   Size: 3773968
File ACL: 0
Links: 1   Blockcount: 7376
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67db3fe5:928dc968 -- Wed Mar 19 18:06:29 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67db3fe5:928dc968 -- Wed Mar 19 18:06:29 2025
crtime: 0x67d9d424:6a998d9c -- Tue Mar 18 16:14:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (36) = 01 00 00 00 01 00 06 00 02 00 04 00 e8 03 00 00 04 00 05 00 08 00 05 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 7d 38 49 8d a3 30 06 00 
Inode checksum: 0x10cd2e76
EXTENTS:
(0):17906944, (1-921):2314736-2315656

Inode: 3015260   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 4165214641    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c72033:05b8d800 -- Tue Mar  4 10:45:55 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c71dc0:5b8d8000 -- Tue Mar  4 10:35:28 2025
crtime: 0x67c65469:d38f872c -- Mon Mar  3 20:16:25 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 8f c2 8c 05 7a 2f 06 00 
Inode checksum: 0xe8eb1f64
EXTENTS:
(ETB0):12091503, (0):12091502, (1-48):50896-50943, (49-95):51793-51839, (96-139):36756-36799, (140-181):40918-40959, (182-221):34133-34172, (222-258):46363-46399, (259-295):51547-51583, (296-330):34578-34612, (331-362):51424-51455, (363-393):34688-34718, (394-424):45345-45375, (425-455):45537-45567, (456-486):46241-46271, (487-517):49505-49535, (518-548):49825-49855, (549-579):52641-52671, (580-610):56737-56767, (611-640):36226-36255, (641-670):45602-45631, (671-700):48226-48255, (701-729):35456-35484, (730-758):38211-38239, (759-787):44995-45023, (788-816):47523-47551, (817-845):47779-47807, (846-874):51139-51167, (875-929):160841-160895, (930-979):140352-140401, (980-1028):132354-132402, (1029-1057):331569-331597, (1058-1098):356767-356807, (1099-1138):356366-356405, (1139-1176):350663-350700, (1177-1198):357291-357312, (1199[u]):357313, (1200-1214):357314-357328, (1215-1251):348875-348911, (1252-1264):354474-354486, (1265-1266[u]):354487-354488, (1267-1270):354489-354492, (1271-1272[u]):354493-354494, (1273-1277):354495-354499, (1278[u]):354500, (1279-1283):354501-354505, (1284[u]):354506, (1285-1288):354507-354510, (1289-1302):350619-350632, (1303-1304[u]):350633-350634, (1305-1323):350635-350653, (1324-1342):351995-352013, (1343[u]):352014, (1344-1355):352015-352026, (1356-1384):357138-357166, (1385-1387):349898-349900, (1388[u]):349901, (1389-1412):349902-349925, (1413-1421):350208-350216, (1422-1424[u]):350217-350219, (1425-1439):350220-350234, (1440-1443[u]):350054-350057, (1444-1445):350058-350059, (1446-1449[u]):350060-350063, (1450-1464):350064-350078, (1465-1467):356739-356741, (1468[u]):356742, (1469-1476):356743-356750, (1477[u]):356751, (1478):356752, (1479[u]):356753, (1480):356754, (1481[u]):356755, (1482):356756, (1483[u]):356757, (1484):356758, (1485[u]):356759, (1486):356760, (1487[u]):356761, (1488-1489):356762-356763, (1490-1514):357492-357516, (1515-1524):350482-350491, (1525[u]):350492, (1526-1537):350493-350504, (1538-1559):356131-356152, (1560[u]):356153, (1561-1585):357676-357700, (1586-1608):357531-357553, (1609-1615):333009-333015, (1616[u]):333016, (1617-1630):333017-333030, (1631):337130, (1632-1652[u]):337131-337151, (1653-1674[u]):356021-356042, (1675-1694[u]):356440-356459, (1695-1713[u]):354959-354977, (1714-1731[u]):356276-356293, (1732-1748[u]):331618-331634, (1749-1775[u]):357812-357838, (1776-1792[u]):354874-354890, (1793-1809[u]):355164-355180, (1810-1826[u]):357658-357674, (1827-1843[u]):357793-357809, (1844-1859[u]):331396-331411, (1860-1875[u]):332656-332671, (1876-1891[u]):346580-346595, (1892-1907[u]):356423-356438, (1908-1923[u]):357717-357732, (1924-1938[u]):334013-334027, (1939-1953[u]):334193-334207, (1954-1968[u]):337489-337503, (1969-1983[u]):338705-338719, (1984-2047[u]):371776-371839

Inode: 3017540   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3412665845    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c73c0d:b1622800 -- Tue Mar  4 12:44:45 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c73515:d3423a94 -- Tue Mar  4 12:15:01 2025
crtime: 0x67c7256f:d59f8000 -- Tue Mar  4 11:08:15 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 8e b4 fe 7a 86 2f 06 00 
Inode checksum: 0xc99cfcef
EXTENTS:
(ETB0):12091823, (0):12091822, (1-121):422535-422655, (122-494):422731-423103, (495-508):406401-406414, (509-570):423234-423295, (571-609):423394-423432, (610-997):423434-423821, (998-1011):407672-407685, (1012-1025):408896-408909, (1026-1039):409921-409934, (1040):409995, (1041[u]):409996, (1042-1053):409997-410008, (1054-1067):410068-410081, (1068-1090):424227-424249, (1091-1105):424326-424340, (1106-1133):424369-424396, (1134-1147):410098-410111, (1148-1161):410828-410841, (1162-1175):412485-412498, (1176-1189):412599-412612, (1190-1203):415922-415935, (1204-1217):418162-418175, (1218-1219):393369-393370, (1220-1230[u]):393371-393381, (1231-1243[u]):393497-393509, (1244-1257[u]):424550-424563, (1258-1270[u]):393715-393727, (1271-1283[u]):399475-399487, (1284-1296[u]):401582-401594, (1297-1309[u]):401974-401986, (1310-1349[u]):424634-424673, (1350-1362[u]):402068-402080, (1363-1375[u]):403100-403112, (1376-1388[u]):403262-403274, (1389-1401[u]):405971-405983, (1402-1414[u]):406087-406099, (1415-1427[u]):406148-406160, (1428-1440[u]):406374-406386, (1441-1453[u]):406427-406439, (1454-1469[u]):424910-424925, (1470-1483[u]):424943-424956, (1484-1505[u]):426026-426047, (1506-1807[u]):542930-543231, (1808-2047[u]):539876-540115

Inode: 3016190   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 229362627    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d86aca:53ec6000 -- Mon Mar 17 14:32:42 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d84aaf:85329a28 -- Mon Mar 17 12:15:43 2025
crtime: 0x67d8487f:67f35400 -- Mon Mar 17 12:06:23 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 73 93 3a f8 8b 30 06 00 
Inode checksum: 0xa419f928
EXTENTS:
(ETB0):12091627, (0):12091625, (1-146):1019493-1019638, (147-354):1038128-1038335, (355-491):1043712-1043848, (492-622):1017784-1017914, (623-750):1016192-1016319, (751-866):1033600-1033715, (867-982):1043584-1043699, (983-1040):1037568-1037625, (1041[u]):1037626, (1042-1097):1037627-1037682, (1098-1179):1039616-1039697, (1180-1212[u]):1039698-1039730, (1213-1321[u]):1039461-1039569, (1322-1417[u]):1033376-1033471, (1418-1509[u]):1031936-1032027, (1510-1601[u]):1032064-1032155, (1602-1688[u]):1033216-1033302, (1689-1760[u]):1039744-1039815, (1761-1887[u]):1073025-1073151, (1888-2040[u]):1141504-1141656, (2041-2047[u]):1141728-1141734

Inode: 3015573   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1174815483    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c63ab9:7a120000 -- Mon Mar  3 18:26:49 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c6397b:7104c57c -- Mon Mar  3 18:21:31 2025
crtime: 0x67c5e0f8:c65d4000 -- Mon Mar  3 12:03:52 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 28 ee 0c 24 73 2f 06 00 
Inode checksum: 0x01616a0c
EXTENTS:
(ETB0):12091616, (0):12091579, (1-217):35004-35220, (218-423):56818-57023, (424-629):66802-67007, (630-835):140402-140607, (836-1039):191118-191321, (1040[u]):191322, (1041-1162):191323-191444, (1163[u]):191445, (1164-1205):191446-191487, (1206-1227):176128-176149, (1228-1232[u]):176150-176154, (1233-1234):176155-176156, (1235-1238[u]):176157-176160, (1239-1240):176161-176162, (1241-1245[u]):176163-176167, (1246):176168, (1247-1251[u]):176169-176173, (1252-1280):176174-176202, (1281[u]):176203, (1282-1289):176204-176211, (1290-1294[u]):176212-176216, (1295-1332):176217-176254, (1333-1498[u]):176255-176420, (1499-1778[u]):204520-204799, (1779-2047[u]):250865-251133

Inode: 3015214   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3367057683    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e4d69b:70889800 -- Thu Mar 27 00:39:55 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e4d665:999d9e90 -- Thu Mar 27 00:39:01 2025
crtime: 0x67e4155b:2cea1f30 -- Wed Mar 26 10:55:23 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = e9 bc de 06 40 31 06 00 
Inode checksum: 0x166e87ff
EXTENTS:
(ETB0):12092085, (0):12092084, (1-434):112206-112639, (435-852):114270-114687, (853-1037):117994-118178, (1038[u]):118179, (1039-1122):118180-118263, (1123[u]):118264, (1124-1270):118265-118411, (1271-1291):126464-126484, (1292[u]):126485, (1293-1300):126486-126493, (1301[u]):126494, (1302-1321):126495-126514, (1322-1326[u]):126515-126519, (1327):126520, (1328-1332[u]):126521-126525, (1333):126526, (1334-1338[u]):126527-126531, (1339-1340):126532-126533, (1341-1345[u]):126534-126538, (1346-1372):126539-126565, (1373-1654[u]):126566-126847, (1655-1962[u]):120524-120831, (1963-2047[u]):117824-117908

Inode: 3015258   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2861285810    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c5e0f8:c5f2e188 -- Mon Mar  3 12:03:52 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c5de72:31631dc8 -- Mon Mar  3 11:53:06 2025
crtime: 0x67c21092:17d78400 -- Fri Feb 28 14:37:54 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = c1 5d 59 f1 38 2f 06 00 
Inode checksum: 0x932a44a2
EXTENTS:
(ETB0):12091577, (0):12091576, (1-239):39537-39775, (240-477):57618-57855, (478-714):39955-40191, (715-948):83968-84201, (949-1039):141100-141190, (1040[u]):141191, (1041-1157):141192-141308, (1158[u]):141309, (1159-1160):141310-141311, (1161-1507):189024-189370, (1508[u]):189371, (1509-1518):189372-189381, (1519[u]):189382, (1520-1528):189383-189391, (1529[u]):189392, (1530-1556):189393-189419, (1557[u]):189420, (1558-1576):189421-189439, (1577-1591):169610-169624, (1592[u]):169625, (1593):169626, (1594[u]):169627, (1595-1621):169628-169654, (1622[u]):169655, (1623-1624):169656-169657, (1625[u]):169658, (1626-1627):169659-169660, (1628[u]):169661, (1629-1634):169662-169667, (1635-1639[u]):169668-169672, (1640-1673):169673-169706, (1674-1676[u]):169707-169709, (1677-1691):169710-169724, (1692-1694[u]):169725-169727, (1695-1697):169728-169730, (1698-1700[u]):169731-169733, (1701-1719):169734-169752, (1720[u]):169753, (1721):169754, (1722[u]):169755, (1723):169756, (1724[u]):169757, (1725):169758, (1726[u]):169759, (1727-1742):169760-169775, (1743[u]):169776, (1744-1757):169777-169790, (1758-1762[u]):169791-169795, (1763):169796, (1764-1768[u]):169797-169801, (1769-1793):169802-169826, (1794-1798[u]):169827-169831, (1799-1818):169832-169851, (1819[u]):169852, (1820-1873):169853-169906, (1874[u]):169907, (1875-1884):169908-169917, (1885-1889[u]):169918-169922, (1890-1894):169923-169927, (1895[u]):169928, (1896-1950):169929-169983, (1951-1991):12393434-12393474, (1992[u]):12393475, (1993-2000):12393476-12393483, (2001-2017[u]):12393484-12393500, (2018):12393501, (2019-2036[u]):12393502-12393519, (2037):12393520, (2038-2047[u]):12393521-12393530, (2048-2054[u]):4033040-4033046, (2055):4033047, (2056-2073[u]):4033048-4033065, (2074-2077):4033066-4033069, (2078[u]):4033070, (2079):4033071, (2080-2554[u]):4033072-4033546, (2555-2998[u]):4070967-4071410, (2999-3301[u]):4072099-4072401, (3302-3567[u]):4261366-4261631, (3568-4022[u]):4314777-4315231, (4023-4095[u]):4317366-4317438

Inode: 3017816   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3402060312    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c98e5c:d6f80e64 -- Thu Mar  6 07:00:28 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c98e06:0b5095f0 -- Thu Mar  6 06:59:02 2025
crtime: 0x67c98df7:9f437c00 -- Thu Mar  6 06:58:47 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = c1 65 80 3a ab 2f 06 00 
Inode checksum: 0xd575d2cb
EXTENTS:
(ETB0):12091524, (0):12091523, (1-138):1519485-1519622, (139-350):1529862-1530073, (351-525):1536351-1536525, (526-692):1538388-1538554, (693-852):1523559-1523718, (853-1004):1531232-1531383, (1005-1012[u]):1531384-1531391, (1013-1171[u]):1534297-1534455, (1172-1308[u]):1545191-1545327, (1309-1558[u]):1566720-1566969, (1559-1883[u]):1583857-1584181, (1884-2047[u]):1615872-1616035

Inode: 3017703   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1300108202    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c988ab:ca2dd000 -- Thu Mar  6 06:36:11 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c986c8:ea730428 -- Thu Mar  6 06:28:08 2025
crtime: 0x67c986b6:c1988c00 -- Thu Mar  6 06:27:50 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = cb 05 d3 cb aa 2f 06 00 
Inode checksum: 0x591d7517
EXTENTS:
(ETB0):12091872, (0):12091871, (1-73):868087-868159, (74-156):1021312-1021394, (157-242):1381886-1381971, (243-354):1390389-1390500, (355-455):1382383-1382483, (456-549):1395928-1396021, (550-640):1396077-1396167, (641-731):1405328-1405418, (732-820):1389312-1389400, (821-909):1389811-1389899, (910-992):1379169-1379251, (993-1004):1380544-1380555, (1005-1067[u]):1380556-1380618, (1068-1138[u]):1379776-1379846, (1139-1203[u]):1398784-1398848, (1204-1267[u]):1381248-1381311, (1268-1331[u]):1381806-1381869, (1332-1394[u]):1385301-1385363, (1395-1452[u]):1384959-1385016, (1453-1510[u]):1406775-1406832, (1511-1567[u]):1386333-1386389, (1568-1615[u]):1394688-1394735, (1616-1662[u]):1401875-1401921, (1663-1707[u]):1406111-1406155, (1708-1751[u]):1406727-1406770, (1752-1793[u]):1389650-1389691, (1794-1834[u]):1406069-1406109, (1835-1875[u]):1406917-1406957, (1876-1914[u]):1406488-1406526, (1915-1952[u]):1406633-1406670, (1953-1989[u]):1385947-1385983, (1990-2047[u]):1001152-1001209

Inode: 3014675   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 3826755184    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16384
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d1b328:69db9c00 -- Wed Mar 12 12:15:36 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d1b306:2bb911a8 -- Wed Mar 12 12:15:02 2025
crtime: 0x67d0d98d:5cf5b5e4 -- Tue Mar 11 20:47:09 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = f1 b6 95 8b 1a 30 06 00 
Inode checksum: 0xc91c5f47
EXTENTS:
(0):12091836, (1-1175):21270-22444, (1176-2047[u]):22445-23316

Inode: 3016152   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 651243428    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d8487f:66ff3000 -- Mon Mar 17 12:06:23 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d8482e:1e75b700 -- Mon Mar 17 12:05:02 2025
crtime: 0x67d7e646:b9034800 -- Mon Mar 17 05:07:18 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 0e 84 7d 1d 86 30 06 00 
Inode checksum: 0x1a8f74a4
EXTENTS:
(ETB0):12091626, (0):3702638, (1-419):1782365-1782783, (420-835):1787488-1787903, (836-1039):1781900-1782103, (1040[u]):1782104, (1041-1206):1782105-1782270, (1207[u]):1782271, (1208-1236):1782272-1782300, (1237-1270):1784964-1784997, (1271-1273[u]):1784998-1785000, (1274-1276):1785001-1785003, (1277-1279[u]):1785004-1785006, (1280-1282):1785007-1785009, (1283-1285[u]):1785010-1785012, (1286-1289):1785013-1785016, (1290-1291[u]):1785017-1785018, (1292-1308):1785019-1785035, (1309-1312[u]):1785036-1785039, (1313-1354):1785040-1785081, (1355[u]):1785082, (1356-1359):1785083-1785086, (1360[u]):1785087, (1361-1373):1785088-1785100, (1374[u]):1785101, (1375-1393):1785102-1785120, (1394[u]):1785121, (1395-1409):1785122-1785136, (1410[u]):1785137, (1411-1439):1785138-1785166, (1440-1444[u]):1785167-1785171, (1445-1456):1785172-1785183, (1457-1461[u]):1785184-1785188, (1462-1463):1785189-1785190, (1464-1468[u]):1785191-1785195, (1469-1483):1785196-1785210, (1484[u]):1785211, (1485):1785212, (1486[u]):1785213, (1487):1785214, (1488[u]):1785215, (1489):1785216, (1490[u]):1785217, (1491):1785218, (1492[u]):1785219, (1493):1785220, (1494[u]):1785221, (1495-1511):1785222-1785238, (1512[u]):1785239, (1513-1540):1785240-1785267, (1541[u]):1785268, (1542-1560):1785269-1785287, (1561-1616[u]):1785288-1785343, (1617-1986[u]):1783438-1783807, (1987-2047[u]):7310272-7310332

Inode: 3015182   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2461738065    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67e7fb2a:b71b0000 -- Sat Mar 29 09:52:42 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67e7f9f2:55e0c048 -- Sat Mar 29 09:47:30 2025
crtime: 0x67e76fb4:208d673c -- Fri Mar 28 23:57:40 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 8b 7a 36 30 73 31 06 00 
Inode checksum: 0x1bccdb42
EXTENTS:
(ETB0):12091607, (0):12091582, (1-69):139453-139521, (70-134):152140-152204, (135-192):141373-141430, (193-246):139263-139316, (247-288):139906-139947, (289-329):141607-141647, (330-366):139381-139417, (367-402):139623-139658, (403-431):141491-141519, (432-459):139850-139877, (460-487):141700-141727, (488-512):139792-139816, (513-536):131461-131484, (537-560):142106-142129, (561-584):146585-146608, (585-608):147131-147154, (609-631):133642-133664, (632-654):140143-140165, (655-677):141781-141803, (678-699):142042-142063, (700-720):141673-141693, (721-741):152502-152522, (742-761):139349-139368, (762-781):141582-141601, (782-801):141895-141914, (802-821):147228-147247, (822-841):152114-152133, (842-860):160492-160510, (861-878):139697-139714, (879-898):162523-162542, (899-916):139822-139839, (917-933):139325-139341, (934-950):141433-141449, (951-967):142250-142266, (968-984):160716-160732, (985-1000):139880-139895, (1001-1016):140093-140108, (1017-1040):162671-162694, (1041[u]):162695, (1042-1062):162697-162717, (1063-1078):140288-140303, (1079-1093):140115-140129, (1094-1119):162757-162782, (1120-1139):162790-162809, (1140-1154):141656-141670, (1155-1169):141806-141820, (1170-1184):142151-142165, (1185-1199):147183-147197, (1200-1214):152961-152975, (1215-1226):160294-160305, (1227[u]):160306, (1228-1229):160307-160308, (1230-1240):161792-161802, (1241-1244[u]):161803-161806, (1245-1259[u]):162816-162830, (1260-1274[u]):162973-162987, (1275-1291[u]):163024-163040, (1292-1307[u]):163055-163070, (1308-1321[u]):132728-132741, (1322-1335[u]):139955-139968, (1336-1349[u]):141739-141752, (1350-1363[u]):152084-152097, (1364-1378[u]):163156-163170, (1379-1392[u]):152406-152419, (1393-1406[u]):160529-160542, (1407-1420[u]):160592-160605, (1421-1433[u]):131431-131443, (1434-1446[u]):139549-139561, (1447-1459[u]):140190-140202, (1460-1472[u]):140260-140272, (1473-1485[u]):141458-141470, (1486-1498[u]):141476-141488, (1499-1511[u]):142306-142318, (1512-1526[u]):163480-163494, (1527-1539[u]):144300-144312, (1540-1552[u]):146311-146323, (1553-1565[u]):147392-147404, (1566-1587[u]):163568-163589, (1588-1600[u]):147435-147447, (1601-1613[u]):160321-160333, (1614-1626[u]):160738-160750, (1627-1639[u]):162560-162572, (1640-1658[u]):163732-163750, (1659-1670[u]):131114-131125, (1671-1682[u]):132982-132993, (1683-1694[u]):141537-141548, (1695-1706[u]):142132-142143, (1707-1718[u]):147299-147310, (1719-1746[u]):166627-166654, (1747-2047[u]):168065-168365

Inode: 3017508   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2170099929    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c64ad0:a8cce400 -- Mon Mar  3 19:35:28 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64a09:4d057398 -- Mon Mar  3 19:32:09 2025
crtime: 0x67c64659:c697c800 -- Mon Mar  3 19:16:25 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 52 49 f8 2e 79 2f 06 00 
Inode checksum: 0x4c63275e
EXTENTS:
(ETB0):12091621, (0):12091620, (1-173):73043-73215, (174-439):188406-188671, (440-698):177405-177663, (699-954):189952-190207, (955-1036):188748-188829, (1037[u]):188830, (1038-1192):188831-188985, (1193-1264):171746-171817, (1265-1266[u]):171818-171819, (1267-1270):171820-171823, (1271-1272[u]):171824-171825, (1273-1277):171826-171830, (1278[u]):171831, (1279-1283):171832-171836, (1284-1285[u]):171837-171838, (1286-1302):171839-171855, (1303-1304[u]):171856-171857, (1305-1343):171858-171896, (1344[u]):171897, (1345-1350):171898-171903, (1351-1385):210792-210826, (1386[u]):210827, (1387-1390):210828-210831, (1391[u]):210832, (1392-1417):210833-210858, (1418-1421[u]):210859-210862, (1422-1435):210863-210876, (1436-1439[u]):210877-210880, (1440-1441):210881-210882, (1442-1445[u]):210883-210886, (1446-1464):210887-210905, (1465[u]):210906, (1466-1473):210907-210914, (1474[u]):210915, (1475):210916, (1476[u]):210917, (1477):210918, (1478[u]):210919, (1479):210920, (1480[u]):210921, (1481):210922, (1482[u]):210923, (1483-1494):210924-210935, (1495[u]):210936, (1496-1502):210937-210943, (1503-1548):286758-286803, (1549[u]):286804, (1550-1584):286805-286839, (1585-1652[u]):286840-286907, (1653-1791[u]):286909-287047, (1792-2047[u]):361216-361471

Inode: 3017511   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 1994360079    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 8388608
File ACL: 0
Links: 1   Blockcount: 16392
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67c64cab:bfb04400 -- Mon Mar  3 19:43:23 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67c64be8:5e53fdf8 -- Mon Mar  3 19:40:08 2025
crtime: 0x67c64ad0:a8cce400 -- Mon Mar  3 19:35:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = fc 31 17 73 79 2f 06 00 
Inode checksum: 0x2b90f6e7
EXTENTS:
(ETB0):12091623, (0):12091622, (1-171):58869-59039, (172-327):70656-70811, (328-491):154368-154531, (492-646):159077-159231, (647-795):153088-153236, (796-938):199921-200063, (939-1079):199667-199807, (1080-1198):254195-254313, (1199[u]):254314, (1200-1220):254315-254335, (1221-1261):233791-233831, (1262-1266[u]):233832-233836, (1267):233837, (1268-1272[u]):233838-233842, (1273-1274):233843-233844, (1275-1278[u]):233845-233848, (1279-1280):233849-233850, (1281-1285[u]):233851-233855, (1286-1299):233856-233869, (1300-1304[u]):233870-233874, (1305-1320):233875-233890, (1321[u]):233891, (1322-1324):233892-233894, (1325-1349[u]):233895-233919, (1350-1475[u]):252930-253055, (1476-1601[u]):300404-300529, (1602-1726[u]):296832-296956, (1727-1822[u]):301440-301535, (1823-1914[u]):320164-320255, (1915-1996[u]):313250-313331, (1997-2047[u]):363431-363481

Inode: 3014698   Type: regular    Mode:  0640   Flags: 0x80000
Generation: 2350922755    Version: 0x00000000:00000004
User:     0   Group:   999   Project:     0   Size: 16777216
File ACL: 0
Links: 1   Blockcount: 32776
Fragment:  Address: 0    Number: 0    Size: 0
 ctime: 0x67d33440:3dfd2400 -- Thu Mar 13 15:38:40 2025
 atime: 0x67fb7fb0:616f1038 -- Sun Apr 13 05:11:12 2025
 mtime: 0x67d33365:d2af4094 -- Thu Mar 13 15:35:01 2025
crtime: 0x67d332cc:112a8800 -- Thu Mar 13 15:32:28 2025
Size of extra inode fields: 32
Extended attributes:
  system.posix_acl_access (28) = 01 00 00 00 01 00 06 00 04 00 05 00 08 00 04 00 04 00 00 00 10 00 04 00 20 00 00 00 
  user.crtime_usec (8) = 7a 6f da 61 3e 30 06 00 
Inode checksum: 0x72328df4
EXTENTS:
(ETB0):12091936, (0):12091531, (1-502):151562-152063, (503-1345):191536-192378, (1346-1451):235681-235786, (1452-1455[u]):235787-235790, (1456-1480):235791-235815, (1481[u]):235816, (1482-1494):235817-235829, (1495[u]):235830, (1496-1500):235831-235835, (1501[u]):235836, (1502-1581):235837-235916, (1582-1585[u]):235917-235920, (1586-1593):235921-235928, (1594-1597[u]):235929-235932, (1598-1599):235933-235934, (1600-1603[u]):235935-235938, (1604-1607):235939-235942, (1608-1612[u]):235943-235947, (1613-1633):235948-235968, (1634-1638[u]):235969-235973, (1639-1648):235974-235983, (1649-1650[u]):235984-235985, (1651-1652):235986-235987, (1653-1656[u]):235988-235991, (1657-1658):235992-235993, (1659-1663[u]):235994-235998, (1664):235999, (1665-1669[u]):236000-236004, (1670):236005, (1671-1675[u]):236006-236010, (1676-1677):236011-236012, (1678-1681[u]):236013-236016, (1682-1683):236017-236018, (1684-1687[u]):236019-236022, (1688-1689):236023-236024, (1690-1693[u]):236025-236028, (1694-1695):236029-236030, (1696-1700[u]):236031-236035, (1701):236036, (1702-1706[u]):236037-236041, (1707-1708):236042-236043, (1709-1713[u]):236044-236048, (1714-1715):236049-236050, (1716-1719[u]):236051-236054, (1720-1866):236055-236201, (1867-1881[u]):236202-236216, (1882-1885):236217-236220, (1886-1900[u]):236221-236235, (1901-1903):236236-236238, (1904-1919[u]):236239-236254, (1920-1922):236255-236257, (1923-1937[u]):236258-236272, (1938-1940):236273-236275, (1941-1956[u]):236276-236291, (1957-2043):236292-236378, (2044-2047):231292-231295, (2048-2151):2588672-2588775, (2152-4095[u]):2588776-2590719

Re: generic_permission() optimization

[Theodore Ts'o]

On Sun, Apr 13, 2025 at 02:52:32PM +0200, Mateusz Guzik wrote:
> On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
> >
> > On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > > This is the rootfs of the thing, so I tried it out with merely
> > > printing it. I got 70 entries at boot time. I don't think figuring out
> > > what this is specifically is warranted (it is on debian though).
> >
> > Well, can you run:
> >
> > debugfs -R "stat <INO>" /dev/ROOT_DEV
> >
> 
> attached full list after boot

So it looks like the test is working corretly.  Most of the inodes
either (a) have a Posix ACL defined, so we were definitely doing the
right thing, or (b) had a user.crtime_usec xattr.  My personal opinion
is that crtime is fairly pointless, and having microsecond accuracy on
the creation time is *completely* pointless, but we can't stop
programs from doing that.  (Therre was also a single xattr field that
contained the xattr user.random-seed-creditable.)

So it will ultimately come down to how much user think performance
compares to microsecond-level accuracy on crtime, which as far as I
know, no Linux programs other than samba / CIFS servers who want
Microsoft feature-for-feature compatibility care about.

(Or SELinux when it sets security ID's, but if you are using SELinux a
few extra branch instructions are the *least* of your performace
headaches....)

						- Ted

Re: generic_permission() optimization

[Christian Brauner]

On Sat, Apr 12, 2025 at 01:22:38PM -0700, Linus Torvalds wrote:
> On Sat, 12 Apr 2025 at 09:26, Mateusz Guzik <mjguzik@gmail.com> wrote:
> >
> > I plopped your snippet towards the end of __ext4_iget:
> 
> That's literally where I did the same thing, except I put it right after the
> 
>           brelse(iloc.bh);
> 
> line, rather than before as you did.
> 
> And it made no difference for me, but I didn't try to figure out why.
> Maybe some environment differences? Or maybe I just screwed up my
> testing...
> 
> As mentioned earlier in the thread, I had this bi-modal distribution
> of results, because if I had a load where the *non*-owner of the inode
> looked up the pathnames, then the ACL information would get filled in
> when the VFS layer would do the lookup, and then once the ACLs were
> cached, everything worked beautifully.
> 
> But if the only lookups of a path were done by the owner of the inodes
> (which is typical for at least my normal kernel build tree - nothing
> but my build will look at the files, and they are obviously always
> owned by me) then the ACL caches will never be filled because there
> will never be any real ACL lookups.
> 
> And then rather than doing the nice efficient "no ACLs anywhere, no
> need to even look", it ends up having to actually do the vfsuid
> comparison for the UID equality check.
> 
> Which then does the extra accesses to look up the idmap etc, and is
> visible in the profiles due to that whole dance:
> 
>         /* Are we the owner? If so, ACL's don't matter */
>         vfsuid = i_uid_into_vfsuid(idmap, inode);
>         if (likely(vfsuid_eq_kuid(vfsuid, current_fsuid()))) {
> 
> even when idmap is 'nop_mnt_idmap' and it is reasonably cheap. Just
> because it ends up calling out to different functions and does extra
> D$ accesses to the inode and the suberblock (ie i_user_ns() is this
> 
>         return inode->i_sb->s_user_ns;

I think we can improve this. Right now multiple mounts from different
superblocks can share the same struct mnt_idmap. But I can change the
code so that struct mnt_idmap can only be shared between mounts from the
same superblock. With that we could do:

diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
index a37991fdb194..a5ec15c8c754 100644
--- a/fs/mnt_idmapping.c
+++ b/fs/mnt_idmapping.c
@@ -20,6 +20,7 @@
 struct mnt_idmap {
        struct uid_gid_map uid_map;
        struct uid_gid_map gid_map;
+       struct user_namespace *s_user_ns;
        refcount_t count;
 };

And then stuff like:

static inline vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap,
                                         const struct inode *inode)
{
        return make_vfsuid(idmap, i_user_ns(inode), inode->i_uid);
}

just becomes:

static inline vfsuid_t i_uid_into_vfsuid(struct mnt_idmap *idmap,
                                         const struct inode *inode)
{
        return make_vfsuid(idmap, inode->i_uid);
}

which means:

vfsuid_t make_vfsuid(struct mnt_idmap *idmap,
                     kuid_t kuid)
{
        uid_t uid;

        if (idmap == &nop_mnt_idmap)
                return VFSUIDT_INIT(kuid);

<snip>
}

will only have to verify nop_mnt_idmap and we never have to access the
inode->i_sb->s_user_ns at all.

I'll wip up a patch for this.

> 
> so just to *see* that it's nop_mnt_idmap takes effort.
> 
> One improvement might be to cache that 'nop_mnt_idmap' thing in the
> inode as a flag.
> 
> But it would be even better if the filesystem just initializes the
> inode at inode read time to say "I have no ACL's for this inode" and
> none of this code will even trigger.

Yes, let's please do this.

[PATCH RFC 0/3] mnt_idmapping: avoid pointer chase & inline low-level helpers

[Christian Brauner]

We currently always chase a pointer inode->i_sb->s_user_ns whenever we
need to map a uid/gid. Linus reported in [1] that this is noticable
during path lookup.

In the majority of cases we don't need to bother with that pointer chase
because the inode won't be located on a filesystem that's mounted in a
user namespace. The user namespace of the superblock cannot ever change
once it's mounted. So introduce and raise IOP_USERNS on all inodes and
check for that flag in i_user_ns() when we retrieve the user namespace.

Additionally, we now inline all low-level idmapping helpers.

[1]: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com

Signed-off-by: Christian Brauner <brauner@kernel.org>
---
Christian Brauner (3):
      inode: add fastpath for filesystem user namespace retrieval
      mnt_idmapping: add struct mnt_idmap to header
      mnt_idmapping: inline all low-level helpers

 fs/inode.c                     |   6 ++
 fs/mnt_idmapping.c             | 165 ----------------------------------------
 include/linux/fs.h             |   5 +-
 include/linux/mnt_idmapping.h  | 168 +++++++++++++++++++++++++++++++++++++++--
 include/linux/uidgid.h         |  23 +++++-
 include/linux/user_namespace.h |  23 +-----
 kernel/user_namespace.c        |   2 +
 7 files changed, 195 insertions(+), 197 deletions(-)
---
base-commit: 0af2f6be1b4281385b618cb86ad946eded089ac8
change-id: 20250416-work-mnt_idmap-s_user_ns-eb57ee83e1d6

[PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Christian Brauner]

We currently always chase a pointer inode->i_sb->s_user_ns whenever we
need to map a uid/gid which is noticeable during path lookup as noticed
by Linus in [1]. In the majority of cases we don't need to bother with
that pointer chase because the inode won't be located on a filesystem
that's mounted in a user namespace. The user namespace of the superblock
cannot ever change once it's mounted. So introduce and raise IOP_USERNS
on all inodes and check for that flag in i_user_ns() when we retrieve
the user namespace.

Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
Signed-off-by: Christian Brauner <brauner@kernel.org>
---
 fs/inode.c                    |  6 ++++++
 fs/mnt_idmapping.c            | 14 --------------
 include/linux/fs.h            |  5 ++++-
 include/linux/mnt_idmapping.h | 14 ++++++++++++++
 4 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/fs/inode.c b/fs/inode.c
index 99318b157a9a..7335d05dd7d5 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -245,6 +245,8 @@ int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp
 		inode->i_opflags |= IOP_XATTR;
 	if (sb->s_type->fs_flags & FS_MGTIME)
 		inode->i_opflags |= IOP_MGTIME;
+	if (unlikely(!initial_idmapping(i_user_ns(inode))))
+		inode->i_opflags |= IOP_USERNS;
 	i_uid_write(inode, 0);
 	i_gid_write(inode, 0);
 	atomic_set(&inode->i_writecount, 0);
@@ -1864,6 +1866,10 @@ static void iput_final(struct inode *inode)
 
 	WARN_ON(inode->i_state & I_NEW);
 
+	/* This is security sensitive so catch missing IOP_USERNS. */
+	VFS_WARN_ON_ONCE(!initial_idmapping(i_user_ns(inode)) &&
+			 !(inode->i_opflags & IOP_USERNS));
+
 	if (op->drop_inode)
 		drop = op->drop_inode(inode);
 	else
diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
index a37991fdb194..8f7ae908ea16 100644
--- a/fs/mnt_idmapping.c
+++ b/fs/mnt_idmapping.c
@@ -42,20 +42,6 @@ struct mnt_idmap invalid_mnt_idmap = {
 };
 EXPORT_SYMBOL_GPL(invalid_mnt_idmap);
 
-/**
- * initial_idmapping - check whether this is the initial mapping
- * @ns: idmapping to check
- *
- * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
- * [...], 1000 to 1000 [...].
- *
- * Return: true if this is the initial mapping, false if not.
- */
-static inline bool initial_idmapping(const struct user_namespace *ns)
-{
-	return ns == &init_user_ns;
-}
-
 /**
  * make_vfsuid - map a filesystem kuid according to an idmapping
  * @idmap: the mount's idmapping
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 016b0fe1536e..d28384d5b752 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -663,6 +663,7 @@ is_uncached_acl(struct posix_acl *acl)
 #define IOP_DEFAULT_READLINK	0x0010
 #define IOP_MGTIME	0x0020
 #define IOP_CACHED_LINK	0x0040
+#define IOP_USERNS	0x0080
 
 /*
  * Keep mostly read-only and often accessed (especially for
@@ -1454,7 +1455,9 @@ struct super_block {
 
 static inline struct user_namespace *i_user_ns(const struct inode *inode)
 {
-	return inode->i_sb->s_user_ns;
+	if (unlikely(inode->i_opflags & IOP_USERNS))
+		return inode->i_sb->s_user_ns;
+	return &init_user_ns;
 }
 
 /* Helper functions so that in most cases filesystems will
diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
index e71a6070a8f8..85553b3a7904 100644
--- a/include/linux/mnt_idmapping.h
+++ b/include/linux/mnt_idmapping.h
@@ -25,6 +25,20 @@ static_assert(sizeof(vfsgid_t) == sizeof(kgid_t));
 static_assert(offsetof(vfsuid_t, val) == offsetof(kuid_t, val));
 static_assert(offsetof(vfsgid_t, val) == offsetof(kgid_t, val));
 
+/**
+ * initial_idmapping - check whether this is the initial mapping
+ * @ns: idmapping to check
+ *
+ * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
+ * [...], 1000 to 1000 [...].
+ *
+ * Return: true if this is the initial mapping, false if not.
+ */
+static inline bool initial_idmapping(const struct user_namespace *ns)
+{
+	return ns == &init_user_ns;
+}
+
 static inline bool is_valid_mnt_idmap(const struct mnt_idmap *idmap)
 {
 	return idmap != &nop_mnt_idmap && idmap != &invalid_mnt_idmap;

-- 
2.47.2

[PATCH RFC 2/3] mnt_idmapping: add struct mnt_idmap to header

[Christian Brauner]

The next patch will inline all current helpers for that we need access
to struct mnt_idmap internals from the header. Not my favorite but
whatever.

Signed-off-by: Christian Brauner <brauner@kernel.org>
---
 fs/mnt_idmapping.c             |  6 ------
 include/linux/mnt_idmapping.h  |  7 +++++++
 include/linux/uidgid.h         | 23 ++++++++++++++++++++++-
 include/linux/user_namespace.h | 23 +----------------------
 4 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
index 8f7ae908ea16..5c7e1db8fef8 100644
--- a/fs/mnt_idmapping.c
+++ b/fs/mnt_idmapping.c
@@ -17,12 +17,6 @@
 #define VFSUIDT_INIT_RAW(val) (vfsuid_t){ val }
 #define VFSGIDT_INIT_RAW(val) (vfsgid_t){ val }
 
-struct mnt_idmap {
-	struct uid_gid_map uid_map;
-	struct uid_gid_map gid_map;
-	refcount_t count;
-};
-
 /*
  * Carries the initial idmapping of 0:0:4294967295 which is an identity
  * mapping. This means that {g,u}id 0 is mapped to {g,u}id 0, {g,u}id 1 is
diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
index 85553b3a7904..4410672c2828 100644
--- a/include/linux/mnt_idmapping.h
+++ b/include/linux/mnt_idmapping.h
@@ -8,6 +8,13 @@
 struct mnt_idmap;
 struct user_namespace;
 
+/* Don't touch directly! All fields private. */
+struct mnt_idmap {
+	struct uid_gid_map uid_map;
+	struct uid_gid_map gid_map;
+	refcount_t count;
+};
+
 extern struct mnt_idmap nop_mnt_idmap;
 extern struct mnt_idmap invalid_mnt_idmap;
 extern struct user_namespace init_user_ns;
diff --git a/include/linux/uidgid.h b/include/linux/uidgid.h
index 2dc767e08f54..5696c870fd0b 100644
--- a/include/linux/uidgid.h
+++ b/include/linux/uidgid.h
@@ -17,7 +17,28 @@
 
 struct user_namespace;
 extern struct user_namespace init_user_ns;
-struct uid_gid_map;
+
+#define UID_GID_MAP_MAX_BASE_EXTENTS 5
+#define UID_GID_MAP_MAX_EXTENTS 340
+
+struct uid_gid_extent {
+	u32 first;
+	u32 lower_first;
+	u32 count;
+};
+
+struct uid_gid_map { /* 64 bytes -- 1 cache line */
+	union {
+		struct {
+			struct uid_gid_extent extent[UID_GID_MAP_MAX_BASE_EXTENTS];
+			u32 nr_extents;
+		};
+		struct {
+			struct uid_gid_extent *forward;
+			struct uid_gid_extent *reverse;
+		};
+	};
+};
 
 #define KUIDT_INIT(value) (kuid_t){ value }
 #define KGIDT_INIT(value) (kgid_t){ value }
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
index a0bb6d012137..6feae94c3661 100644
--- a/include/linux/user_namespace.h
+++ b/include/linux/user_namespace.h
@@ -12,28 +12,7 @@
 #include <linux/rwsem.h>
 #include <linux/sysctl.h>
 #include <linux/err.h>
-
-#define UID_GID_MAP_MAX_BASE_EXTENTS 5
-#define UID_GID_MAP_MAX_EXTENTS 340
-
-struct uid_gid_extent {
-	u32 first;
-	u32 lower_first;
-	u32 count;
-};
-
-struct uid_gid_map { /* 64 bytes -- 1 cache line */
-	union {
-		struct {
-			struct uid_gid_extent extent[UID_GID_MAP_MAX_BASE_EXTENTS];
-			u32 nr_extents;
-		};
-		struct {
-			struct uid_gid_extent *forward;
-			struct uid_gid_extent *reverse;
-		};
-	};
-};
+#include <linux/uidgid.h>
 
 #define USERNS_SETGROUPS_ALLOWED 1UL
 

-- 
2.47.2

[PATCH RFC 3/3] mnt_idmapping: inline all low-level helpers

[Christian Brauner]

Let's inline all low-level helpers and use likely()/unlikely() to help
the compiler along.

Signed-off-by: Christian Brauner <brauner@kernel.org>
---
 fs/mnt_idmapping.c            | 145 -----------------------------------------
 include/linux/mnt_idmapping.h | 147 +++++++++++++++++++++++++++++++++++++++---
 kernel/user_namespace.c       |   2 +
 3 files changed, 141 insertions(+), 153 deletions(-)

diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
index 5c7e1db8fef8..ba1f752b6fa7 100644
--- a/fs/mnt_idmapping.c
+++ b/fs/mnt_idmapping.c
@@ -10,13 +10,6 @@
 
 #include "internal.h"
 
-/*
- * Outside of this file vfs{g,u}id_t are always created from k{g,u}id_t,
- * never from raw values. These are just internal helpers.
- */
-#define VFSUIDT_INIT_RAW(val) (vfsuid_t){ val }
-#define VFSGIDT_INIT_RAW(val) (vfsgid_t){ val }
-
 /*
  * Carries the initial idmapping of 0:0:4294967295 which is an identity
  * mapping. This means that {g,u}id 0 is mapped to {g,u}id 0, {g,u}id 1 is
@@ -36,144 +29,6 @@ struct mnt_idmap invalid_mnt_idmap = {
 };
 EXPORT_SYMBOL_GPL(invalid_mnt_idmap);
 
-/**
- * make_vfsuid - map a filesystem kuid according to an idmapping
- * @idmap: the mount's idmapping
- * @fs_userns: the filesystem's idmapping
- * @kuid : kuid to be mapped
- *
- * Take a @kuid and remap it from @fs_userns into @idmap. Use this
- * function when preparing a @kuid to be reported to userspace.
- *
- * If initial_idmapping() determines that this is not an idmapped mount
- * we can simply return @kuid unchanged.
- * If initial_idmapping() tells us that the filesystem is not mounted with an
- * idmapping we know the value of @kuid won't change when calling
- * from_kuid() so we can simply retrieve the value via __kuid_val()
- * directly.
- *
- * Return: @kuid mapped according to @idmap.
- * If @kuid has no mapping in either @idmap or @fs_userns INVALID_UID is
- * returned.
- */
-
-vfsuid_t make_vfsuid(struct mnt_idmap *idmap,
-		     struct user_namespace *fs_userns,
-		     kuid_t kuid)
-{
-	uid_t uid;
-
-	if (idmap == &nop_mnt_idmap)
-		return VFSUIDT_INIT(kuid);
-	if (idmap == &invalid_mnt_idmap)
-		return INVALID_VFSUID;
-	if (initial_idmapping(fs_userns))
-		uid = __kuid_val(kuid);
-	else
-		uid = from_kuid(fs_userns, kuid);
-	if (uid == (uid_t)-1)
-		return INVALID_VFSUID;
-	return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));
-}
-EXPORT_SYMBOL_GPL(make_vfsuid);
-
-/**
- * make_vfsgid - map a filesystem kgid according to an idmapping
- * @idmap: the mount's idmapping
- * @fs_userns: the filesystem's idmapping
- * @kgid : kgid to be mapped
- *
- * Take a @kgid and remap it from @fs_userns into @idmap. Use this
- * function when preparing a @kgid to be reported to userspace.
- *
- * If initial_idmapping() determines that this is not an idmapped mount
- * we can simply return @kgid unchanged.
- * If initial_idmapping() tells us that the filesystem is not mounted with an
- * idmapping we know the value of @kgid won't change when calling
- * from_kgid() so we can simply retrieve the value via __kgid_val()
- * directly.
- *
- * Return: @kgid mapped according to @idmap.
- * If @kgid has no mapping in either @idmap or @fs_userns INVALID_GID is
- * returned.
- */
-vfsgid_t make_vfsgid(struct mnt_idmap *idmap,
-		     struct user_namespace *fs_userns, kgid_t kgid)
-{
-	gid_t gid;
-
-	if (idmap == &nop_mnt_idmap)
-		return VFSGIDT_INIT(kgid);
-	if (idmap == &invalid_mnt_idmap)
-		return INVALID_VFSGID;
-	if (initial_idmapping(fs_userns))
-		gid = __kgid_val(kgid);
-	else
-		gid = from_kgid(fs_userns, kgid);
-	if (gid == (gid_t)-1)
-		return INVALID_VFSGID;
-	return VFSGIDT_INIT_RAW(map_id_down(&idmap->gid_map, gid));
-}
-EXPORT_SYMBOL_GPL(make_vfsgid);
-
-/**
- * from_vfsuid - map a vfsuid into the filesystem idmapping
- * @idmap: the mount's idmapping
- * @fs_userns: the filesystem's idmapping
- * @vfsuid : vfsuid to be mapped
- *
- * Map @vfsuid into the filesystem idmapping. This function has to be used in
- * order to e.g. write @vfsuid to inode->i_uid.
- *
- * Return: @vfsuid mapped into the filesystem idmapping
- */
-kuid_t from_vfsuid(struct mnt_idmap *idmap,
-		   struct user_namespace *fs_userns, vfsuid_t vfsuid)
-{
-	uid_t uid;
-
-	if (idmap == &nop_mnt_idmap)
-		return AS_KUIDT(vfsuid);
-	if (idmap == &invalid_mnt_idmap)
-		return INVALID_UID;
-	uid = map_id_up(&idmap->uid_map, __vfsuid_val(vfsuid));
-	if (uid == (uid_t)-1)
-		return INVALID_UID;
-	if (initial_idmapping(fs_userns))
-		return KUIDT_INIT(uid);
-	return make_kuid(fs_userns, uid);
-}
-EXPORT_SYMBOL_GPL(from_vfsuid);
-
-/**
- * from_vfsgid - map a vfsgid into the filesystem idmapping
- * @idmap: the mount's idmapping
- * @fs_userns: the filesystem's idmapping
- * @vfsgid : vfsgid to be mapped
- *
- * Map @vfsgid into the filesystem idmapping. This function has to be used in
- * order to e.g. write @vfsgid to inode->i_gid.
- *
- * Return: @vfsgid mapped into the filesystem idmapping
- */
-kgid_t from_vfsgid(struct mnt_idmap *idmap,
-		   struct user_namespace *fs_userns, vfsgid_t vfsgid)
-{
-	gid_t gid;
-
-	if (idmap == &nop_mnt_idmap)
-		return AS_KGIDT(vfsgid);
-	if (idmap == &invalid_mnt_idmap)
-		return INVALID_GID;
-	gid = map_id_up(&idmap->gid_map, __vfsgid_val(vfsgid));
-	if (gid == (gid_t)-1)
-		return INVALID_GID;
-	if (initial_idmapping(fs_userns))
-		return KGIDT_INIT(gid);
-	return make_kgid(fs_userns, gid);
-}
-EXPORT_SYMBOL_GPL(from_vfsgid);
-
 #ifdef CONFIG_MULTIUSER
 /**
  * vfsgid_in_group_p() - check whether a vfsuid matches the caller's groups
diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
index 4410672c2828..e6fb905c39bd 100644
--- a/include/linux/mnt_idmapping.h
+++ b/include/linux/mnt_idmapping.h
@@ -140,22 +140,153 @@ static inline bool vfsgid_eq_kgid(vfsgid_t vfsgid, kgid_t kgid)
 #define AS_KUIDT(val) (kuid_t){ __vfsuid_val(val) }
 #define AS_KGIDT(val) (kgid_t){ __vfsgid_val(val) }
 
+/*
+ * Outside of this file vfs{g,u}id_t are always created from k{g,u}id_t,
+ * never from raw values. These are just internal helpers.
+ */
+#define VFSUIDT_INIT_RAW(val) (vfsuid_t){ val }
+#define VFSGIDT_INIT_RAW(val) (vfsgid_t){ val }
+
 int vfsgid_in_group_p(vfsgid_t vfsgid);
 
 struct mnt_idmap *mnt_idmap_get(struct mnt_idmap *idmap);
 void mnt_idmap_put(struct mnt_idmap *idmap);
 
-vfsuid_t make_vfsuid(struct mnt_idmap *idmap,
-		     struct user_namespace *fs_userns, kuid_t kuid);
+/**
+ * make_vfsuid - map a filesystem kuid according to an idmapping
+ * @idmap: the mount's idmapping
+ * @fs_userns: the filesystem's idmapping
+ * @kuid : kuid to be mapped
+ *
+ * Take a @kuid and remap it from @fs_userns into @idmap. Use this
+ * function when preparing a @kuid to be reported to userspace.
+ *
+ * If initial_idmapping() determines that this is not an idmapped mount
+ * we can simply return @kuid unchanged.
+ * If initial_idmapping() tells us that the filesystem is not mounted with an
+ * idmapping we know the value of @kuid won't change when calling
+ * from_kuid() so we can simply retrieve the value via __kuid_val()
+ * directly.
+ *
+ * Return: @kuid mapped according to @idmap.
+ * If @kuid has no mapping in either @idmap or @fs_userns INVALID_UID is
+ * returned.
+ */
+static inline vfsuid_t make_vfsuid(struct mnt_idmap *idmap,
+				   struct user_namespace *fs_userns,
+				   kuid_t kuid)
+{
+	uid_t uid;
+
+	if (likely(idmap == &nop_mnt_idmap))
+		return VFSUIDT_INIT(kuid);
+	if (unlikely(idmap == &invalid_mnt_idmap))
+		return INVALID_VFSUID;
+	if (likely(initial_idmapping(fs_userns)))
+		uid = __kuid_val(kuid);
+	else
+		uid = from_kuid(fs_userns, kuid);
+	if (unlikely(uid == (uid_t)-1))
+		return INVALID_VFSUID;
+	return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));
+}
 
-vfsgid_t make_vfsgid(struct mnt_idmap *idmap,
-		     struct user_namespace *fs_userns, kgid_t kgid);
+/**
+ * make_vfsgid - map a filesystem kgid according to an idmapping
+ * @idmap: the mount's idmapping
+ * @fs_userns: the filesystem's idmapping
+ * @kgid : kgid to be mapped
+ *
+ * Take a @kgid and remap it from @fs_userns into @idmap. Use this
+ * function when preparing a @kgid to be reported to userspace.
+ *
+ * If initial_idmapping() determines that this is not an idmapped mount
+ * we can simply return @kgid unchanged.
+ * If initial_idmapping() tells us that the filesystem is not mounted with an
+ * idmapping we know the value of @kgid won't change when calling
+ * from_kgid() so we can simply retrieve the value via __kgid_val()
+ * directly.
+ *
+ * Return: @kgid mapped according to @idmap.
+ * If @kgid has no mapping in either @idmap or @fs_userns INVALID_GID is
+ * returned.
+ */
+static inline vfsgid_t make_vfsgid(struct mnt_idmap *idmap,
+				   struct user_namespace *fs_userns,
+				   kgid_t kgid)
+{
+	gid_t gid;
+
+	if (likely(idmap == &nop_mnt_idmap))
+		return VFSGIDT_INIT(kgid);
+	if (unlikely(idmap == &invalid_mnt_idmap))
+		return INVALID_VFSGID;
+	if (likely(initial_idmapping(fs_userns)))
+		gid = __kgid_val(kgid);
+	else
+		gid = from_kgid(fs_userns, kgid);
+	if (unlikely(gid == (gid_t)-1))
+		return INVALID_VFSGID;
+	return VFSGIDT_INIT_RAW(map_id_down(&idmap->gid_map, gid));
+}
 
-kuid_t from_vfsuid(struct mnt_idmap *idmap,
-		   struct user_namespace *fs_userns, vfsuid_t vfsuid);
+/**
+ * from_vfsuid - map a vfsuid into the filesystem idmapping
+ * @idmap: the mount's idmapping
+ * @fs_userns: the filesystem's idmapping
+ * @vfsuid : vfsuid to be mapped
+ *
+ * Map @vfsuid into the filesystem idmapping. This function has to be used in
+ * order to e.g. write @vfsuid to inode->i_uid.
+ *
+ * Return: @vfsuid mapped into the filesystem idmapping
+ */
+static inline kuid_t from_vfsuid(struct mnt_idmap *idmap,
+				 struct user_namespace *fs_userns,
+				 vfsuid_t vfsuid)
+{
+	uid_t uid;
+
+	if (likely(idmap == &nop_mnt_idmap))
+		return AS_KUIDT(vfsuid);
+	if (unlikely(idmap == &invalid_mnt_idmap))
+		return INVALID_UID;
+	uid = map_id_up(&idmap->uid_map, __vfsuid_val(vfsuid));
+	if (unlikely(uid == (uid_t)-1))
+		return INVALID_UID;
+	if (likely(initial_idmapping(fs_userns)))
+		return KUIDT_INIT(uid);
+	return make_kuid(fs_userns, uid);
+}
 
-kgid_t from_vfsgid(struct mnt_idmap *idmap,
-		   struct user_namespace *fs_userns, vfsgid_t vfsgid);
+/**
+ * from_vfsgid - map a vfsgid into the filesystem idmapping
+ * @idmap: the mount's idmapping
+ * @fs_userns: the filesystem's idmapping
+ * @vfsgid : vfsgid to be mapped
+ *
+ * Map @vfsgid into the filesystem idmapping. This function has to be used in
+ * order to e.g. write @vfsgid to inode->i_gid.
+ *
+ * Return: @vfsgid mapped into the filesystem idmapping
+ */
+static inline kgid_t from_vfsgid(struct mnt_idmap *idmap,
+				 struct user_namespace *fs_userns,
+				 vfsgid_t vfsgid)
+{
+	gid_t gid;
+
+	if (likely(idmap == &nop_mnt_idmap))
+		return AS_KGIDT(vfsgid);
+	if (unlikely(idmap == &invalid_mnt_idmap))
+		return INVALID_GID;
+	gid = map_id_up(&idmap->gid_map, __vfsgid_val(vfsgid));
+	if (unlikely(gid == (gid_t)-1))
+		return INVALID_GID;
+	if (likely(initial_idmapping(fs_userns)))
+		return KGIDT_INIT(gid);
+	return make_kgid(fs_userns, gid);
+}
 
 /**
  * vfsuid_has_fsmapping - check whether a vfsuid maps into the filesystem
diff --git a/kernel/user_namespace.c b/kernel/user_namespace.c
index 682f40d5632d..693c62587571 100644
--- a/kernel/user_namespace.c
+++ b/kernel/user_namespace.c
@@ -336,6 +336,7 @@ u32 map_id_down(struct uid_gid_map *map, u32 id)
 {
 	return map_id_range_down(map, id, 1);
 }
+EXPORT_SYMBOL_GPL(map_id_down);
 
 /*
  * map_id_up_base - Find idmap via binary search in static extent array.
@@ -402,6 +403,7 @@ u32 map_id_up(struct uid_gid_map *map, u32 id)
 {
 	return map_id_range_up(map, id, 1);
 }
+EXPORT_SYMBOL_GPL(map_id_up);
 
 /**
  *	make_kuid - Map a user-namespace uid pair into a kuid.

-- 
2.47.2

Re: [PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Mateusz Guzik]

On Wed, Apr 16, 2025 at 3:17 PM Christian Brauner <brauner@kernel.org> wrote:
>
> We currently always chase a pointer inode->i_sb->s_user_ns whenever we
> need to map a uid/gid which is noticeable during path lookup as noticed
> by Linus in [1]. In the majority of cases we don't need to bother with
> that pointer chase because the inode won't be located on a filesystem
> that's mounted in a user namespace. The user namespace of the superblock
> cannot ever change once it's mounted. So introduce and raise IOP_USERNS
> on all inodes and check for that flag in i_user_ns() when we retrieve
> the user namespace.
>
> Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
> Signed-off-by: Christian Brauner <brauner@kernel.org>
> ---
>  fs/inode.c                    |  6 ++++++
>  fs/mnt_idmapping.c            | 14 --------------
>  include/linux/fs.h            |  5 ++++-
>  include/linux/mnt_idmapping.h | 14 ++++++++++++++
>  4 files changed, 24 insertions(+), 15 deletions(-)
>
> diff --git a/fs/inode.c b/fs/inode.c
> index 99318b157a9a..7335d05dd7d5 100644
> --- a/fs/inode.c
> +++ b/fs/inode.c
> @@ -245,6 +245,8 @@ int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp
>                 inode->i_opflags |= IOP_XATTR;
>         if (sb->s_type->fs_flags & FS_MGTIME)
>                 inode->i_opflags |= IOP_MGTIME;
> +       if (unlikely(!initial_idmapping(i_user_ns(inode))))
> +               inode->i_opflags |= IOP_USERNS;
>         i_uid_write(inode, 0);
>         i_gid_write(inode, 0);
>         atomic_set(&inode->i_writecount, 0);
> @@ -1864,6 +1866,10 @@ static void iput_final(struct inode *inode)
>
>         WARN_ON(inode->i_state & I_NEW);
>
> +       /* This is security sensitive so catch missing IOP_USERNS. */
> +       VFS_WARN_ON_ONCE(!initial_idmapping(i_user_ns(inode)) &&
> +                        !(inode->i_opflags & IOP_USERNS));
> +
>         if (op->drop_inode)
>                 drop = op->drop_inode(inode);
>         else
> diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
> index a37991fdb194..8f7ae908ea16 100644
> --- a/fs/mnt_idmapping.c
> +++ b/fs/mnt_idmapping.c
> @@ -42,20 +42,6 @@ struct mnt_idmap invalid_mnt_idmap = {
>  };
>  EXPORT_SYMBOL_GPL(invalid_mnt_idmap);
>
> -/**
> - * initial_idmapping - check whether this is the initial mapping
> - * @ns: idmapping to check
> - *
> - * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> - * [...], 1000 to 1000 [...].
> - *
> - * Return: true if this is the initial mapping, false if not.
> - */
> -static inline bool initial_idmapping(const struct user_namespace *ns)
> -{
> -       return ns == &init_user_ns;
> -}
> -
>  /**
>   * make_vfsuid - map a filesystem kuid according to an idmapping
>   * @idmap: the mount's idmapping
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index 016b0fe1536e..d28384d5b752 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -663,6 +663,7 @@ is_uncached_acl(struct posix_acl *acl)
>  #define IOP_DEFAULT_READLINK   0x0010
>  #define IOP_MGTIME     0x0020
>  #define IOP_CACHED_LINK        0x0040
> +#define IOP_USERNS     0x0080
>
>  /*
>   * Keep mostly read-only and often accessed (especially for
> @@ -1454,7 +1455,9 @@ struct super_block {
>
>  static inline struct user_namespace *i_user_ns(const struct inode *inode)
>  {
> -       return inode->i_sb->s_user_ns;
> +       if (unlikely(inode->i_opflags & IOP_USERNS))
> +               return inode->i_sb->s_user_ns;
> +       return &init_user_ns;
>  }
>
>  /* Helper functions so that in most cases filesystems will
> diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
> index e71a6070a8f8..85553b3a7904 100644
> --- a/include/linux/mnt_idmapping.h
> +++ b/include/linux/mnt_idmapping.h
> @@ -25,6 +25,20 @@ static_assert(sizeof(vfsgid_t) == sizeof(kgid_t));
>  static_assert(offsetof(vfsuid_t, val) == offsetof(kuid_t, val));
>  static_assert(offsetof(vfsgid_t, val) == offsetof(kgid_t, val));
>
> +/**
> + * initial_idmapping - check whether this is the initial mapping
> + * @ns: idmapping to check
> + *
> + * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> + * [...], 1000 to 1000 [...].
> + *
> + * Return: true if this is the initial mapping, false if not.
> + */
> +static inline bool initial_idmapping(const struct user_namespace *ns)
> +{
> +       return ns == &init_user_ns;
> +}
> +
>  static inline bool is_valid_mnt_idmap(const struct mnt_idmap *idmap)
>  {
>         return idmap != &nop_mnt_idmap && idmap != &invalid_mnt_idmap;
>
> --
> 2.47.2
>

I don't have an opinion.

But if going this way, i think you want the assert for correctly
applied flag when fetching the ns, not just iput_final.

-- 
Mateusz Guzik <mjguzik gmail.com>

Re: [PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Christian Brauner]

On Wed, Apr 16, 2025 at 03:49:43PM +0200, Mateusz Guzik wrote:
> On Wed, Apr 16, 2025 at 3:17 PM Christian Brauner <brauner@kernel.org> wrote:
> >
> > We currently always chase a pointer inode->i_sb->s_user_ns whenever we
> > need to map a uid/gid which is noticeable during path lookup as noticed
> > by Linus in [1]. In the majority of cases we don't need to bother with
> > that pointer chase because the inode won't be located on a filesystem
> > that's mounted in a user namespace. The user namespace of the superblock
> > cannot ever change once it's mounted. So introduce and raise IOP_USERNS
> > on all inodes and check for that flag in i_user_ns() when we retrieve
> > the user namespace.
> >
> > Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
> > Signed-off-by: Christian Brauner <brauner@kernel.org>
> > ---
> >  fs/inode.c                    |  6 ++++++
> >  fs/mnt_idmapping.c            | 14 --------------
> >  include/linux/fs.h            |  5 ++++-
> >  include/linux/mnt_idmapping.h | 14 ++++++++++++++
> >  4 files changed, 24 insertions(+), 15 deletions(-)
> >
> > diff --git a/fs/inode.c b/fs/inode.c
> > index 99318b157a9a..7335d05dd7d5 100644
> > --- a/fs/inode.c
> > +++ b/fs/inode.c
> > @@ -245,6 +245,8 @@ int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp
> >                 inode->i_opflags |= IOP_XATTR;
> >         if (sb->s_type->fs_flags & FS_MGTIME)
> >                 inode->i_opflags |= IOP_MGTIME;
> > +       if (unlikely(!initial_idmapping(i_user_ns(inode))))
> > +               inode->i_opflags |= IOP_USERNS;
> >         i_uid_write(inode, 0);
> >         i_gid_write(inode, 0);
> >         atomic_set(&inode->i_writecount, 0);
> > @@ -1864,6 +1866,10 @@ static void iput_final(struct inode *inode)
> >
> >         WARN_ON(inode->i_state & I_NEW);
> >
> > +       /* This is security sensitive so catch missing IOP_USERNS. */
> > +       VFS_WARN_ON_ONCE(!initial_idmapping(i_user_ns(inode)) &&
> > +                        !(inode->i_opflags & IOP_USERNS));
> > +
> >         if (op->drop_inode)
> >                 drop = op->drop_inode(inode);
> >         else
> > diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
> > index a37991fdb194..8f7ae908ea16 100644
> > --- a/fs/mnt_idmapping.c
> > +++ b/fs/mnt_idmapping.c
> > @@ -42,20 +42,6 @@ struct mnt_idmap invalid_mnt_idmap = {
> >  };
> >  EXPORT_SYMBOL_GPL(invalid_mnt_idmap);
> >
> > -/**
> > - * initial_idmapping - check whether this is the initial mapping
> > - * @ns: idmapping to check
> > - *
> > - * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> > - * [...], 1000 to 1000 [...].
> > - *
> > - * Return: true if this is the initial mapping, false if not.
> > - */
> > -static inline bool initial_idmapping(const struct user_namespace *ns)
> > -{
> > -       return ns == &init_user_ns;
> > -}
> > -
> >  /**
> >   * make_vfsuid - map a filesystem kuid according to an idmapping
> >   * @idmap: the mount's idmapping
> > diff --git a/include/linux/fs.h b/include/linux/fs.h
> > index 016b0fe1536e..d28384d5b752 100644
> > --- a/include/linux/fs.h
> > +++ b/include/linux/fs.h
> > @@ -663,6 +663,7 @@ is_uncached_acl(struct posix_acl *acl)
> >  #define IOP_DEFAULT_READLINK   0x0010
> >  #define IOP_MGTIME     0x0020
> >  #define IOP_CACHED_LINK        0x0040
> > +#define IOP_USERNS     0x0080
> >
> >  /*
> >   * Keep mostly read-only and often accessed (especially for
> > @@ -1454,7 +1455,9 @@ struct super_block {
> >
> >  static inline struct user_namespace *i_user_ns(const struct inode *inode)
> >  {
> > -       return inode->i_sb->s_user_ns;
> > +       if (unlikely(inode->i_opflags & IOP_USERNS))
> > +               return inode->i_sb->s_user_ns;
> > +       return &init_user_ns;
> >  }
> >
> >  /* Helper functions so that in most cases filesystems will
> > diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
> > index e71a6070a8f8..85553b3a7904 100644
> > --- a/include/linux/mnt_idmapping.h
> > +++ b/include/linux/mnt_idmapping.h
> > @@ -25,6 +25,20 @@ static_assert(sizeof(vfsgid_t) == sizeof(kgid_t));
> >  static_assert(offsetof(vfsuid_t, val) == offsetof(kuid_t, val));
> >  static_assert(offsetof(vfsgid_t, val) == offsetof(kgid_t, val));
> >
> > +/**
> > + * initial_idmapping - check whether this is the initial mapping
> > + * @ns: idmapping to check
> > + *
> > + * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> > + * [...], 1000 to 1000 [...].
> > + *
> > + * Return: true if this is the initial mapping, false if not.
> > + */
> > +static inline bool initial_idmapping(const struct user_namespace *ns)
> > +{
> > +       return ns == &init_user_ns;
> > +}
> > +
> >  static inline bool is_valid_mnt_idmap(const struct mnt_idmap *idmap)
> >  {
> >         return idmap != &nop_mnt_idmap && idmap != &invalid_mnt_idmap;
> >
> > --
> > 2.47.2
> >
> 
> I don't have an opinion.
> 
> But if going this way, i think you want the assert for correctly
> applied flag when fetching the ns, not just iput_final.

Sure.

Re: [PATCH RFC 3/3] mnt_idmapping: inline all low-level helpers

[Linus Torvalds]

On Wed, 16 Apr 2025 at 06:17, Christian Brauner <brauner@kernel.org> wrote:
>
> Let's inline all low-level helpers and use likely()/unlikely() to help
> the compiler along.

Hmm. This looks like it might be a mistake - code generation will
probably not be great, because you still end up calling a real
function for some of the cases (ie from_kuid() in the actual real
translation case), so all the register allocation etc issues with
having a function call largely do remain.

Yes, it inlines things into generic_permission(), and that will avoid
the function call overhead for the common case (good), but it also
does make for bigger code generation. And it doesn't actually *change*
the code - it ends up doing all the same accesses, just the
instruction flow is slightly different.

So I think you'd actually be better off with *just* the IOP_USERNS
patch, and only inlining *that* fast-path case, and keep the other
cases out-of-line.

IOW - instead of only checking IOP_USERNS only in i_user_ns() and
making it return 'init_user_ns' without doing the pointer following, I
think you should make just our *existing* inlined i_uid_into_vfsuid()
helper be the minimal inlined wrapper around just the IOP_USERNS
logic.

Because right now the problem with i_uid_into_vfsuid() is two-fold

 - it does that pointer chasing by calling i_user_ns(inode)

 - it then calls make_vfsuid() which does lots of pointless extra work
in the common case

and I think both should be fixed.

Btw, make_vfsuid() itself is kind of odd. It does:

        if (idmap == &nop_mnt_idmap)
                return VFSUIDT_INIT(kuid);
        if (idmap == &invalid_mnt_idmap)
                return INVALID_VFSUID;
        if (initial_idmapping(fs_userns))
                uid = __kuid_val(kuid);
        else
                uid = from_kuid(fs_userns, kuid);
        if (uid == (uid_t)-1)
                return INVALID_VFSUID;
        return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));

and honestly, that looks just horrendous for the actual simple cases.
I think it's a historical accident, but the

                return VFSUIDT_INIT(kuid);

and the

                uid = __kuid_val(kuid);
        ....
        return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));

things are actually the same exact "no mapping" code for the case we
care about most. We shouldn't even do that

        if (uid == (uid_t)-1)
                return INVALID_VFSUID;

case at all for that case, because the no-mapping situation is that
INVALID_VFSUID *is* (uid_t)-1, so all of this is entirely pointless.

So I think the inlined fast-case should be that

        if (idmap == &nop_mnt_idmap || initial_idmapping(fs_userns))
                return VFSUIDT_INIT(kuid);

code, and then the 'initial_idmapping()' thing should check the
IOP_USERNS bit explicitly, and never use the i_user_ns() helper at all
etc.

That case should then be "likely()", and the rest can remain out-of-line.

IOW: instead of inlining all the helpers, just make the *one* helper
that we already have (and is already a trivial inline function) be
much more targeted, and make that fast-case much more explicit.

Hmm?

                   Linus

Re: [PATCH RFC 3/3] mnt_idmapping: inline all low-level helpers

[Christian Brauner]

On Wed, Apr 16, 2025 at 08:04:26AM -0700, Linus Torvalds wrote:
> On Wed, 16 Apr 2025 at 06:17, Christian Brauner <brauner@kernel.org> wrote:
> >
> > Let's inline all low-level helpers and use likely()/unlikely() to help
> > the compiler along.

Sorry, I just had time to get back to this now.

> 
> Hmm. This looks like it might be a mistake - code generation will
> probably not be great, because you still end up calling a real
> function for some of the cases (ie from_kuid() in the actual real
> translation case), so all the register allocation etc issues with
> having a function call largely do remain.

Good point.

> 
> Yes, it inlines things into generic_permission(), and that will avoid
> the function call overhead for the common case (good), but it also
> does make for bigger code generation. And it doesn't actually *change*
> the code - it ends up doing all the same accesses, just the
> instruction flow is slightly different.
> 
> So I think you'd actually be better off with *just* the IOP_USERNS
> patch, and only inlining *that* fast-path case, and keep the other
> cases out-of-line.

Right.

> 
> IOW - instead of only checking IOP_USERNS only in i_user_ns() and
> making it return 'init_user_ns' without doing the pointer following, I
> think you should make just our *existing* inlined i_uid_into_vfsuid()
> helper be the minimal inlined wrapper around just the IOP_USERNS
> logic.
> 
> Because right now the problem with i_uid_into_vfsuid() is two-fold
> 
>  - it does that pointer chasing by calling i_user_ns(inode)
> 
>  - it then calls make_vfsuid() which does lots of pointless extra work
> in the common case
> 
> and I think both should be fixed.

Yes, agreed. I've mentioned that various times on other patch series. It
was just a matter of time and I had prioritized other stuff.

> 
> Btw, make_vfsuid() itself is kind of odd. It does:
> 
>         if (idmap == &nop_mnt_idmap)
>                 return VFSUIDT_INIT(kuid);
>         if (idmap == &invalid_mnt_idmap)
>                 return INVALID_VFSUID;
>         if (initial_idmapping(fs_userns))
>                 uid = __kuid_val(kuid);
>         else
>                 uid = from_kuid(fs_userns, kuid);
>         if (uid == (uid_t)-1)
>                 return INVALID_VFSUID;
>         return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));
> 
> and honestly, that looks just horrendous for the actual simple cases.
> I think it's a historical accident, but the
> 
>                 return VFSUIDT_INIT(kuid);
> 
> and the
> 
>                 uid = __kuid_val(kuid);
>         ....
>         return VFSUIDT_INIT_RAW(map_id_down(&idmap->uid_map, uid));
> 
> things are actually the same exact "no mapping" code for the case we
> care about most. We shouldn't even do that
> 
>         if (uid == (uid_t)-1)
>                 return INVALID_VFSUID;
> 
> case at all for that case, because the no-mapping situation is that
> INVALID_VFSUID *is* (uid_t)-1, so all of this is entirely pointless.
> 
> So I think the inlined fast-case should be that
> 
>         if (idmap == &nop_mnt_idmap || initial_idmapping(fs_userns))
>                 return VFSUIDT_INIT(kuid);
> 
> code, and then the 'initial_idmapping()' thing should check the
> IOP_USERNS bit explicitly, and never use the i_user_ns() helper at all
> etc.
> 
> That case should then be "likely()", and the rest can remain out-of-line.
> 
> IOW: instead of inlining all the helpers, just make the *one* helper
> that we already have (and is already a trivial inline function) be
> much more targeted, and make that fast-case much more explicit.
> 
> Hmm?

Yes, but I'd also like to add the shortcut to i_user_ns() because it's
called in quite a few places that it might actually matter. So both
initial_imdapping() and i_user_ns() should short-circuit ad
initial_idmapping() should take an inode as the argument just as
i_user_ns(). I'll send a new version out today hopefully.

Thanks for taking the time to review this!

Re: [PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Jan Kara]

On Wed 16-04-25 15:17:22, Christian Brauner wrote:
> We currently always chase a pointer inode->i_sb->s_user_ns whenever we
> need to map a uid/gid which is noticeable during path lookup as noticed
> by Linus in [1]. In the majority of cases we don't need to bother with
> that pointer chase because the inode won't be located on a filesystem
> that's mounted in a user namespace. The user namespace of the superblock
> cannot ever change once it's mounted. So introduce and raise IOP_USERNS
> on all inodes and check for that flag in i_user_ns() when we retrieve
> the user namespace.
> 
> Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
> Signed-off-by: Christian Brauner <brauner@kernel.org>

Some performance numbers would be in place here I guess - in particular
whether this change indeed improved the speed of path lookup or whether the
cost just moved elsewhere. Otherwise the patch looks good so feel free to
add:

Reviewed-by: Jan Kara <jack@suse.cz>

								Honza


> ---
>  fs/inode.c                    |  6 ++++++
>  fs/mnt_idmapping.c            | 14 --------------
>  include/linux/fs.h            |  5 ++++-
>  include/linux/mnt_idmapping.h | 14 ++++++++++++++
>  4 files changed, 24 insertions(+), 15 deletions(-)
> 
> diff --git a/fs/inode.c b/fs/inode.c
> index 99318b157a9a..7335d05dd7d5 100644
> --- a/fs/inode.c
> +++ b/fs/inode.c
> @@ -245,6 +245,8 @@ int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp
>  		inode->i_opflags |= IOP_XATTR;
>  	if (sb->s_type->fs_flags & FS_MGTIME)
>  		inode->i_opflags |= IOP_MGTIME;
> +	if (unlikely(!initial_idmapping(i_user_ns(inode))))
> +		inode->i_opflags |= IOP_USERNS;
>  	i_uid_write(inode, 0);
>  	i_gid_write(inode, 0);
>  	atomic_set(&inode->i_writecount, 0);
> @@ -1864,6 +1866,10 @@ static void iput_final(struct inode *inode)
>  
>  	WARN_ON(inode->i_state & I_NEW);
>  
> +	/* This is security sensitive so catch missing IOP_USERNS. */
> +	VFS_WARN_ON_ONCE(!initial_idmapping(i_user_ns(inode)) &&
> +			 !(inode->i_opflags & IOP_USERNS));
> +
>  	if (op->drop_inode)
>  		drop = op->drop_inode(inode);
>  	else
> diff --git a/fs/mnt_idmapping.c b/fs/mnt_idmapping.c
> index a37991fdb194..8f7ae908ea16 100644
> --- a/fs/mnt_idmapping.c
> +++ b/fs/mnt_idmapping.c
> @@ -42,20 +42,6 @@ struct mnt_idmap invalid_mnt_idmap = {
>  };
>  EXPORT_SYMBOL_GPL(invalid_mnt_idmap);
>  
> -/**
> - * initial_idmapping - check whether this is the initial mapping
> - * @ns: idmapping to check
> - *
> - * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> - * [...], 1000 to 1000 [...].
> - *
> - * Return: true if this is the initial mapping, false if not.
> - */
> -static inline bool initial_idmapping(const struct user_namespace *ns)
> -{
> -	return ns == &init_user_ns;
> -}
> -
>  /**
>   * make_vfsuid - map a filesystem kuid according to an idmapping
>   * @idmap: the mount's idmapping
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index 016b0fe1536e..d28384d5b752 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -663,6 +663,7 @@ is_uncached_acl(struct posix_acl *acl)
>  #define IOP_DEFAULT_READLINK	0x0010
>  #define IOP_MGTIME	0x0020
>  #define IOP_CACHED_LINK	0x0040
> +#define IOP_USERNS	0x0080
>  
>  /*
>   * Keep mostly read-only and often accessed (especially for
> @@ -1454,7 +1455,9 @@ struct super_block {
>  
>  static inline struct user_namespace *i_user_ns(const struct inode *inode)
>  {
> -	return inode->i_sb->s_user_ns;
> +	if (unlikely(inode->i_opflags & IOP_USERNS))
> +		return inode->i_sb->s_user_ns;
> +	return &init_user_ns;
>  }
>  
>  /* Helper functions so that in most cases filesystems will
> diff --git a/include/linux/mnt_idmapping.h b/include/linux/mnt_idmapping.h
> index e71a6070a8f8..85553b3a7904 100644
> --- a/include/linux/mnt_idmapping.h
> +++ b/include/linux/mnt_idmapping.h
> @@ -25,6 +25,20 @@ static_assert(sizeof(vfsgid_t) == sizeof(kgid_t));
>  static_assert(offsetof(vfsuid_t, val) == offsetof(kuid_t, val));
>  static_assert(offsetof(vfsgid_t, val) == offsetof(kgid_t, val));
>  
> +/**
> + * initial_idmapping - check whether this is the initial mapping
> + * @ns: idmapping to check
> + *
> + * Check whether this is the initial mapping, mapping 0 to 0, 1 to 1,
> + * [...], 1000 to 1000 [...].
> + *
> + * Return: true if this is the initial mapping, false if not.
> + */
> +static inline bool initial_idmapping(const struct user_namespace *ns)
> +{
> +	return ns == &init_user_ns;
> +}
> +
>  static inline bool is_valid_mnt_idmap(const struct mnt_idmap *idmap)
>  {
>  	return idmap != &nop_mnt_idmap && idmap != &invalid_mnt_idmap;
> 
> -- 
> 2.47.2
> 
-- 
Jan Kara <jack@suse.com>
SUSE Labs, CR

Re: [PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Mateusz Guzik]

On Tue, Apr 22, 2025 at 12:37 PM Jan Kara <jack@suse.cz> wrote:
>
> On Wed 16-04-25 15:17:22, Christian Brauner wrote:
> > We currently always chase a pointer inode->i_sb->s_user_ns whenever we
> > need to map a uid/gid which is noticeable during path lookup as noticed
> > by Linus in [1]. In the majority of cases we don't need to bother with
> > that pointer chase because the inode won't be located on a filesystem
> > that's mounted in a user namespace. The user namespace of the superblock
> > cannot ever change once it's mounted. So introduce and raise IOP_USERNS
> > on all inodes and check for that flag in i_user_ns() when we retrieve
> > the user namespace.
> >
> > Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
> > Signed-off-by: Christian Brauner <brauner@kernel.org>
>
> Some performance numbers would be in place here I guess - in particular
> whether this change indeed improved the speed of path lookup or whether the
> cost just moved elsewhere.

Note that right now path lookup is a raging branchfest, with some
avoidable memory references to boot.

I have a WIP patch to bypass inode permission checks with an
->i_opflag and get over 5% speed up when stating stuff in
/usr/include/linux/. This might be slightly more now.

Anyhow, this bit here probably does not help that much in isolation
and I would not worry about that fact given the overall state.
Demonstrating that this indeed avoids some work in the common case
would be sufficient for me.

To give you a taste: stat(2) specifically around 4.28 mln ops/s on my
box. Based on perf top I estimate sorting out the avoidable
single-threaded slowdowns will bring it above 5 mln.

The slowdowns notably include the dog slow memory allocation (likely
to be sorted out with sheaves), the smp_mb fence in legitimize_mnt and
more.

Part of the problem is LOOKUP_RCU checks all over the place. I presume
the intent was to keep this and refwalk closely tied to reduce code
duplication and make sure all parties get updated as needed. I know
the code would be faster (and I *suspect* cleaner) if this got
refactored into dedicated routines instead. Something to ponder after
the bigger fish is fried.
-- 
Mateusz Guzik <mjguzik gmail.com>

Re: [PATCH RFC 1/3] inode: add fastpath for filesystem user namespace retrieval

[Christian Brauner]

On Tue, Apr 22, 2025 at 03:33:03PM +0200, Mateusz Guzik wrote:
> On Tue, Apr 22, 2025 at 12:37 PM Jan Kara <jack@suse.cz> wrote:
> >
> > On Wed 16-04-25 15:17:22, Christian Brauner wrote:
> > > We currently always chase a pointer inode->i_sb->s_user_ns whenever we
> > > need to map a uid/gid which is noticeable during path lookup as noticed
> > > by Linus in [1]. In the majority of cases we don't need to bother with
> > > that pointer chase because the inode won't be located on a filesystem
> > > that's mounted in a user namespace. The user namespace of the superblock
> > > cannot ever change once it's mounted. So introduce and raise IOP_USERNS
> > > on all inodes and check for that flag in i_user_ns() when we retrieve
> > > the user namespace.
> > >
> > > Link: https://lore.kernel.org/CAHk-=whJgRDtxTudTQ9HV8BFw5-bBsu+c8Ouwd_PrPqPB6_KEQ@mail.gmail.com [1]
> > > Signed-off-by: Christian Brauner <brauner@kernel.org>
> >
> > Some performance numbers would be in place here I guess - in particular
> > whether this change indeed improved the speed of path lookup or whether the
> > cost just moved elsewhere.
> 
> Note that right now path lookup is a raging branchfest, with some
> avoidable memory references to boot.
> 
> I have a WIP patch to bypass inode permission checks with an
> ->i_opflag and get over 5% speed up when stating stuff in
> /usr/include/linux/. This might be slightly more now.
> 
> Anyhow, this bit here probably does not help that much in isolation
> and I would not worry about that fact given the overall state.
> Demonstrating that this indeed avoids some work in the common case
> would be sufficient for me.
> 
> To give you a taste: stat(2) specifically around 4.28 mln ops/s on my
> box. Based on perf top I estimate sorting out the avoidable
> single-threaded slowdowns will bring it above 5 mln.
> 
> The slowdowns notably include the dog slow memory allocation (likely
> to be sorted out with sheaves), the smp_mb fence in legitimize_mnt and
> more.
> 
> Part of the problem is LOOKUP_RCU checks all over the place. I presume
> the intent was to keep this and refwalk closely tied to reduce code
> duplication and make sure all parties get updated as needed. I know
> the code would be faster (and I *suspect* cleaner) if this got
> refactored into dedicated routines instead. Something to ponder after
> the bigger fish is fried.

I think the cleanup itself the right thing to do because it makes it
obvious that we're not doing any work when no idmapped mounts are
involved. v2 is a lot cleaner and simpler as well.

Re: generic_permission() optimization

[Mateusz Guzik]

On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
>
> On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > This is the rootfs of the thing, so I tried it out with merely
> > printing it. I got 70 entries at boot time. I don't think figuring out
> > what this is specifically is warranted (it is on debian though).
>
> Well, can you run:
>
> debugfs -R "stat <INO>" /dev/ROOT_DEV
>
> on say, two or three of the inodes (replace INO with a number, and
> ROOT_DEV with the root file system device) and send me the result?
> That would be really helpful in understanding what might be going on.
>
> > So... I think this is good enough to commit? I had no part in writing
> > the patch and I'm not an ext4 person, so I'm not submitting it myself.
> >
> > Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?
>
> Sure, I'll put together a more formal patch and do full QA run and
> checking of the code paths, as a supposed a fairly superficial review
> and hack.
>

It looks like this well through the cracks.

To recount, here is the patch (by Linus, not me):
> diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> index f386de8c12f6..3e0ba7c4723a 100644
> --- a/fs/ext4/inode.c
> +++ b/fs/ext4/inode.c
> @@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
>                 goto bad_inode;
>         brelse(iloc.bh);
>
> +       if (test_opt(sb, DEBUG) &&
> +           (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
> +            ei->i_file_acl))
> +               ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
> +
>         unlock_new_inode(inode);
>         return inode;

In my tests it covered most real-world lookups on my debian box.

Sorting this out acts as blocker for a lookup optimization I'm working
on which bypasses all perm checking if an inode has a flag indicating
everyone can traverse through it.

Re: generic_permission() optimization

[Mateusz Guzik]

On Wed, Nov 5, 2025 at 12:50 PM Mateusz Guzik <mjguzik@gmail.com> wrote:
>
> On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
> >
> > On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > > This is the rootfs of the thing, so I tried it out with merely
> > > printing it. I got 70 entries at boot time. I don't think figuring out
> > > what this is specifically is warranted (it is on debian though).
> >
> > Well, can you run:
> >
> > debugfs -R "stat <INO>" /dev/ROOT_DEV
> >
> > on say, two or three of the inodes (replace INO with a number, and
> > ROOT_DEV with the root file system device) and send me the result?
> > That would be really helpful in understanding what might be going on.
> >
> > > So... I think this is good enough to commit? I had no part in writing
> > > the patch and I'm not an ext4 person, so I'm not submitting it myself.
> > >
> > > Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?
> >
> > Sure, I'll put together a more formal patch and do full QA run and
> > checking of the code paths, as a supposed a fairly superficial review
> > and hack.
> >
>
> It looks like this well through the cracks.
>
> To recount, here is the patch (by Linus, not me):
> > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> > index f386de8c12f6..3e0ba7c4723a 100644
> > --- a/fs/ext4/inode.c
> > +++ b/fs/ext4/inode.c
> > @@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
> >                 goto bad_inode;
> >         brelse(iloc.bh);
> >
> > +       if (test_opt(sb, DEBUG) &&
> > +           (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
> > +            ei->i_file_acl))
> > +               ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
> > +
> >         unlock_new_inode(inode);
> >         return inode;
>

sigh, copy-pasto, the patch is:
  --- a/fs/ext4/inode.c
  +++ b/fs/ext4/inode.c
  @@ -5011,6 +5011,11 @@ struct inode *__ext4_iget(...
        }

        brelse(iloc.bh);
  +
  +     /* Initialize the "no ACL's" state for the simple cases */
  +     if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
  +             cache_no_acl(inode);
  +
        unlock_new_inode(inode);
        return inode;

> In my tests it covered most real-world lookups on my debian box.
>
> Sorting this out acts as blocker for a lookup optimization I'm working
> on which bypasses all perm checking if an inode has a flag indicating
> everyone can traverse through it.

Re: generic_permission() optimization

[Jan Kara]

On Wed 05-11-25 12:51:16, Mateusz Guzik wrote:
> On Wed, Nov 5, 2025 at 12:50 PM Mateusz Guzik <mjguzik@gmail.com> wrote:
> >
> > On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
> > >
> > > On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > > > This is the rootfs of the thing, so I tried it out with merely
> > > > printing it. I got 70 entries at boot time. I don't think figuring out
> > > > what this is specifically is warranted (it is on debian though).
> > >
> > > Well, can you run:
> > >
> > > debugfs -R "stat <INO>" /dev/ROOT_DEV
> > >
> > > on say, two or three of the inodes (replace INO with a number, and
> > > ROOT_DEV with the root file system device) and send me the result?
> > > That would be really helpful in understanding what might be going on.
> > >
> > > > So... I think this is good enough to commit? I had no part in writing
> > > > the patch and I'm not an ext4 person, so I'm not submitting it myself.
> > > >
> > > > Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?
> > >
> > > Sure, I'll put together a more formal patch and do full QA run and
> > > checking of the code paths, as a supposed a fairly superficial review
> > > and hack.
> > >
> >
> > It looks like this well through the cracks.
> >
> > To recount, here is the patch (by Linus, not me):
> > > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> > > index f386de8c12f6..3e0ba7c4723a 100644
> > > --- a/fs/ext4/inode.c
> > > +++ b/fs/ext4/inode.c
> > > @@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
> > >                 goto bad_inode;
> > >         brelse(iloc.bh);
> > >
> > > +       if (test_opt(sb, DEBUG) &&
> > > +           (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
> > > +            ei->i_file_acl))
> > > +               ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
> > > +
> > >         unlock_new_inode(inode);
> > >         return inode;
> >
> 
> sigh, copy-pasto, the patch is:
>   --- a/fs/ext4/inode.c
>   +++ b/fs/ext4/inode.c
>   @@ -5011,6 +5011,11 @@ struct inode *__ext4_iget(...
>         }
> 
>         brelse(iloc.bh);
>   +
>   +     /* Initialize the "no ACL's" state for the simple cases */
>   +     if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
>   +             cache_no_acl(inode);
>   +
>         unlock_new_inode(inode);
>         return inode;

This looks fine. Feel free to add:

Reviewed-by: Jan Kara <jack@suse.cz>

								Honza
-- 
Jan Kara <jack@suse.com>
SUSE Labs, CR

Re: generic_permission() optimization

[Mateusz Guzik]

On Wed, Nov 5, 2025 at 2:37 PM Jan Kara <jack@suse.cz> wrote:
>
> On Wed 05-11-25 12:51:16, Mateusz Guzik wrote:
> > On Wed, Nov 5, 2025 at 12:50 PM Mateusz Guzik <mjguzik@gmail.com> wrote:
> > >
> > > On Sun, Apr 13, 2025 at 2:40 PM Theodore Ts'o <tytso@mit.edu> wrote:
> > > >
> > > > On Sun, Apr 13, 2025 at 11:41:47AM +0200, Mateusz Guzik wrote:
> > > > > This is the rootfs of the thing, so I tried it out with merely
> > > > > printing it. I got 70 entries at boot time. I don't think figuring out
> > > > > what this is specifically is warranted (it is on debian though).
> > > >
> > > > Well, can you run:
> > > >
> > > > debugfs -R "stat <INO>" /dev/ROOT_DEV
> > > >
> > > > on say, two or three of the inodes (replace INO with a number, and
> > > > ROOT_DEV with the root file system device) and send me the result?
> > > > That would be really helpful in understanding what might be going on.
> > > >
> > > > > So... I think this is good enough to commit? I had no part in writing
> > > > > the patch and I'm not an ext4 person, so I'm not submitting it myself.
> > > > >
> > > > > Ted, you seem fine with the patch, so perhaps you could do the needful(tm)?
> > > >
> > > > Sure, I'll put together a more formal patch and do full QA run and
> > > > checking of the code paths, as a supposed a fairly superficial review
> > > > and hack.
> > > >
> > >
> > > It looks like this well through the cracks.
> > >
> > > To recount, here is the patch (by Linus, not me):
> > > > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
> > > > index f386de8c12f6..3e0ba7c4723a 100644
> > > > --- a/fs/ext4/inode.c
> > > > +++ b/fs/ext4/inode.c
> > > > @@ -5109,6 +5109,11 @@ struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
> > > >                 goto bad_inode;
> > > >         brelse(iloc.bh);
> > > >
> > > > +       if (test_opt(sb, DEBUG) &&
> > > > +           (ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
> > > > +            ei->i_file_acl))
> > > > +               ext4_msg(sb, KERN_DEBUG, "has xattr ino %lu", inode->i_ino);
> > > > +
> > > >         unlock_new_inode(inode);
> > > >         return inode;
> > >
> >
> > sigh, copy-pasto, the patch is:
> >   --- a/fs/ext4/inode.c
> >   +++ b/fs/ext4/inode.c
> >   @@ -5011,6 +5011,11 @@ struct inode *__ext4_iget(...
> >         }
> >
> >         brelse(iloc.bh);
> >   +
> >   +     /* Initialize the "no ACL's" state for the simple cases */
> >   +     if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) && !ei->i_file_acl)
> >   +             cache_no_acl(inode);
> >   +
> >         unlock_new_inode(inode);
> >         return inode;
>
> This looks fine. Feel free to add:
>
> Reviewed-by: Jan Kara <jack@suse.cz>
>

ping?

the window to get this in 6.19 is closing (if not too late already),
would be a bummer if it did not make it