* Re: [PATCH 07/14] fsinfo: Allow mount information to be queried [ver #18]
From: Miklos Szeredi @ 2020-03-10 9:04 UTC (permalink / raw)
To: David Howells
Cc: Linus Torvalds, Al Viro, Ian Kent, Miklos Szeredi,
Christian Brauner, Jann Horn, Darrick J. Wong, Karel Zak,
Jeff Layton, Linux API, linux-fsdevel, LSM, linux-kernel
In-Reply-To: <158376251286.344135.12815432977346939752.stgit@warthog.procyon.org.uk>
On Mon, Mar 9, 2020 at 3:02 PM David Howells <dhowells@redhat.com> wrote:
>
> Allow mount information, including information about the topology tree to
> be queried with the fsinfo() system call. Setting AT_FSINFO_QUERY_MOUNT
> allows overlapping mounts to be queried by indicating that the syscall
> should interpet the pathname as a number indicating the mount ID.
>
> To this end, a number of fsinfo() attributes are provided:
>
> (1) FSINFO_ATTR_MOUNT_INFO.
>
> This is a structure providing information about a mount, including:
>
> - Mounted superblock ID (mount ID uniquifier).
> - Mount ID (can be used with AT_FSINFO_QUERY_MOUNT).
> - Parent mount ID.
> - Mount attributes (eg. R/O, NOEXEC).
> - Mount change/notification counter.
>
> Note that the parent mount ID is overridden to the ID of the queried
> mount if the parent lies outside of the chroot or dfd tree.
>
> (2) FSINFO_ATTR_MOUNT_PATH.
>
> This a string providing information about a bind mount relative the
> the root that was bound off, though it may get overridden by the
> filesystem (NFS unconditionally sets it to "/", for example).
>
> (3) FSINFO_ATTR_MOUNT_POINT.
>
> This is a string indicating the name of the mountpoint within the
> parent mount, limited to the parent's mounted root and the chroot.
>
> (4) FSINFO_ATTR_MOUNT_POINT_FULL.
>
> This is a string indicating the full path of the mountpoint, limited to
> the chroot.
>
> (5) FSINFO_ATTR_MOUNT_CHILDREN.
>
> This produces an array of structures, one for each child and capped
> with one for the argument mount (checked after listing all the
> children). Each element contains the mount ID and the change counter
> of the respective mount object.
>
> Signed-off-by: David Howells <dhowells@redhat.com>
> ---
>
> fs/d_path.c | 2
> fs/fsinfo.c | 14 +++
> fs/internal.h | 10 ++
> fs/namespace.c | 177 +++++++++++++++++++++++++++++++++++++++++++
> include/uapi/linux/fsinfo.h | 36 +++++++++
> samples/vfs/test-fsinfo.c | 43 ++++++++++
> 6 files changed, 281 insertions(+), 1 deletion(-)
>
> diff --git a/fs/d_path.c b/fs/d_path.c
> index 0f1fc1743302..4c203f64e45e 100644
> --- a/fs/d_path.c
> +++ b/fs/d_path.c
> @@ -229,7 +229,7 @@ static int prepend_unreachable(char **buffer, int *buflen)
> return prepend(buffer, buflen, "(unreachable)", 13);
> }
>
> -static void get_fs_root_rcu(struct fs_struct *fs, struct path *root)
> +void get_fs_root_rcu(struct fs_struct *fs, struct path *root)
> {
> unsigned seq;
>
> diff --git a/fs/fsinfo.c b/fs/fsinfo.c
> index bafeb73feaf4..6d2bc03998e4 100644
> --- a/fs/fsinfo.c
> +++ b/fs/fsinfo.c
> @@ -236,6 +236,14 @@ static int fsinfo_generic_seq_read(struct path *path, struct fsinfo_context *ctx
> ret = sb->s_op->show_options(&m, path->mnt->mnt_root);
> break;
>
> + case FSINFO_ATTR_MOUNT_PATH:
> + if (sb->s_op->show_path) {
> + ret = sb->s_op->show_path(&m, path->mnt->mnt_root);
> + } else {
> + seq_dentry(&m, path->mnt->mnt_root, " \t\n\\");
> + }
> + break;
> +
> case FSINFO_ATTR_FS_STATISTICS:
> if (sb->s_op->show_stats)
> ret = sb->s_op->show_stats(&m, path->mnt->mnt_root);
> @@ -270,6 +278,12 @@ static const struct fsinfo_attribute fsinfo_common_attributes[] = {
>
> FSINFO_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, (void *)123UL),
> FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, (void *)123UL),
> +
> + FSINFO_VSTRUCT (FSINFO_ATTR_MOUNT_INFO, fsinfo_generic_mount_info),
> + FSINFO_STRING (FSINFO_ATTR_MOUNT_PATH, fsinfo_generic_seq_read),
> + FSINFO_STRING (FSINFO_ATTR_MOUNT_POINT, fsinfo_generic_mount_point),
> + FSINFO_STRING (FSINFO_ATTR_MOUNT_POINT_FULL, fsinfo_generic_mount_point_full),
> + FSINFO_LIST (FSINFO_ATTR_MOUNT_CHILDREN, fsinfo_generic_mount_children),
> {}
> };
>
> diff --git a/fs/internal.h b/fs/internal.h
> index abbd5299e7dc..1a318dc85f2f 100644
> --- a/fs/internal.h
> +++ b/fs/internal.h
> @@ -15,6 +15,7 @@ struct mount;
> struct shrink_control;
> struct fs_context;
> struct user_namespace;
> +struct fsinfo_context;
>
> /*
> * block_dev.c
> @@ -47,6 +48,11 @@ extern int __block_write_begin_int(struct page *page, loff_t pos, unsigned len,
> */
> extern void __init chrdev_init(void);
>
> +/*
> + * d_path.c
> + */
> +extern void get_fs_root_rcu(struct fs_struct *fs, struct path *root);
> +
> /*
> * fs_context.c
> */
> @@ -93,6 +99,10 @@ extern void __mnt_drop_write_file(struct file *);
> extern void dissolve_on_fput(struct vfsmount *);
> extern int lookup_mount_object(struct path *, int, struct path *);
> extern int fsinfo_generic_mount_source(struct path *, struct fsinfo_context *);
> +extern int fsinfo_generic_mount_info(struct path *, struct fsinfo_context *);
> +extern int fsinfo_generic_mount_point(struct path *, struct fsinfo_context *);
> +extern int fsinfo_generic_mount_point_full(struct path *, struct fsinfo_context *);
> +extern int fsinfo_generic_mount_children(struct path *, struct fsinfo_context *);
>
> /*
> * fs_struct.c
> diff --git a/fs/namespace.c b/fs/namespace.c
> index 54e8eb93fdd6..a6cb8c6b004f 100644
> --- a/fs/namespace.c
> +++ b/fs/namespace.c
> @@ -4149,4 +4149,181 @@ int lookup_mount_object(struct path *root, int mnt_id, struct path *_mntpt)
> goto out_unlock;
> }
>
> +/*
> + * Retrieve information about the nominated mount.
> + */
> +int fsinfo_generic_mount_info(struct path *path, struct fsinfo_context *ctx)
> +{
> + struct fsinfo_mount_info *p = ctx->buffer;
> + struct super_block *sb;
> + struct mount *m;
> + struct path root;
> + unsigned int flags;
> +
> + m = real_mount(path->mnt);
> + sb = m->mnt.mnt_sb;
> +
> + p->sb_unique_id = sb->s_unique_id;
> + p->mnt_unique_id = m->mnt_unique_id;
> + p->mnt_id = m->mnt_id;
> + p->parent_id = m->mnt_parent->mnt_id;
> +
> + get_fs_root(current->fs, &root);
> + if (path->mnt == root.mnt) {
> + p->parent_id = p->mnt_id;
> + } else {
> + rcu_read_lock();
> + if (!are_paths_connected(&root, path))
> + p->parent_id = p->mnt_id;
> + rcu_read_unlock();
> + }
> + if (IS_MNT_SHARED(m))
> + p->group_id = m->mnt_group_id;
> + if (IS_MNT_SLAVE(m)) {
> + int master = m->mnt_master->mnt_group_id;
> + int dom = get_dominating_id(m, &root);
This isn't safe without namespace_sem or mount_lock.
Thanks,
Miklos
^ permalink raw reply
* Re: [PATCH 08/14] fsinfo: Allow the mount topology propogation flags to be retrieved [ver #18]
From: Christian Brauner @ 2020-03-10 8:42 UTC (permalink / raw)
To: David Howells
Cc: torvalds, viro, raven, mszeredi, christian, jannh, darrick.wong,
kzak, jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376252176.344135.11226418366508725745.stgit@warthog.procyon.org.uk>
On Mon, Mar 09, 2020 at 02:02:01PM +0000, David Howells wrote:
> Allow the mount topology propogation flags to be retrieved as part of the
> FSINFO_ATTR_MOUNT_INFO attributes.
>
> Signed-off-by: David Howells <dhowells@redhat.com>
(Btw, I had a patchset for the old stat* family of syscalls a while back
https://lwn.net/ml/linux-fsdevel/20180418092722.20136-1-christian.brauner@ubuntu.com/)
Acked-by: Christian Brauner <christian.brauner@ubuntu.com>
^ permalink raw reply
* Re: [PATCH 01/14] VFS: Add additional RESOLVE_* flags [ver #18]
From: David Howells @ 2020-03-10 7:25 UTC (permalink / raw)
To: Linus Torvalds
Cc: dhowells, Aleksa Sarai, Al Viro, Stefan Metzmacher, Ian Kent,
Miklos Szeredi, Christian Brauner, Jann Horn, Darrick J. Wong,
Karel Zak, jlayton, Linux API, linux-fsdevel, LSM List,
Linux Kernel Mailing List
In-Reply-To: <CAHk-=wiEBNFJ0_riJnpuUXTO7+_HByVo-R3pGoB_84qv3LzHxA@mail.gmail.com>
Linus Torvalds <torvalds@linux-foundation.org> wrote:
> > > Also make openat2() handle RESOLVE_NO_TRAILING_SYMLINKS.
>
> No, please let's not do this.
>
> We have O_NOFOLLOW, and we can't get rid of it.
>
> So adding RESOLVE_NO_TRAILING_SYMLINKS isn't a cleanup. It's just
> extra complexity for absolutely zero gain.
Okay. So what's the equivalent of AT_SYMLINK_NOFOLLOW in RESOLVE_* flag
terms? RESOLVE_NO_SYMLINKS is not equivalent, though O_NOFOLLOW is. The
reason I ask is that RESOLVE_* flags can't be easily extended to non-open
syscalls that don't take O_* flags without it. Would you prefer that new
non-open syscalls continue to take AT_* and ignore RESOLVE_* flags? That
would be fine by me.
David
^ permalink raw reply
* Re: [PATCH v15 18/23] NET: Store LSM netlabel data in a lsmblob
From: Casey Schaufler @ 2020-03-10 1:21 UTC (permalink / raw)
To: Paul Moore
Cc: casey.schaufler, James Morris, linux-security-module, selinux,
keescook, john.johansen, penguin-kernel, Stephen Smalley,
Casey Schaufler
In-Reply-To: <CAHC9VhREcdFNtJkXkUrwtbu8GA_h2T5CJ9hAQCU0PSpd5yLGgg@mail.gmail.com>
On 3/6/2020 6:14 PM, Paul Moore wrote:
> On Fri, Feb 14, 2020 at 6:45 PM Casey Schaufler <casey@schaufler-ca.com> wrote:
>> Netlabel uses LSM interfaces requiring an lsmblob and
>> the internal storage is used to pass information between
>> these interfaces, so change the internal data from a secid
>> to a lsmblob. Update the netlabel interfaces and their
>> callers to accommodate the change. This requires that the
>> modules using netlabel use the lsm_id.slot to access the
>> correct secid when using netlabel.
>>
>> Reviewed-by: Kees Cook <keescook@chromium.org>
>> Reviewed-by: John Johansen <john.johansen@canonical.com>
>> Acked-by: Stephen Smalley <sds@tycho.nsa.gov>
>> Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
>> ---
>> include/net/netlabel.h | 8 ++--
>> net/ipv4/cipso_ipv4.c | 23 +++++++-----
>> net/netlabel/netlabel_kapi.c | 6 +--
>> net/netlabel/netlabel_unlabeled.c | 57 +++++++++++------------------
>> net/netlabel/netlabel_unlabeled.h | 2 +-
>> security/selinux/hooks.c | 2 +-
>> security/selinux/include/security.h | 1 +
>> security/selinux/netlabel.c | 2 +-
>> security/selinux/ss/services.c | 4 +-
>> security/smack/smack.h | 1 +
>> security/smack/smack_lsm.c | 5 ++-
>> security/smack/smackfs.c | 10 +++--
>> 12 files changed, 59 insertions(+), 62 deletions(-)
> ...
>
>
>> diff --git a/net/ipv4/cipso_ipv4.c b/net/ipv4/cipso_ipv4.c
>> index 376882215919..adb9dffc3952 100644
>> --- a/net/ipv4/cipso_ipv4.c
>> +++ b/net/ipv4/cipso_ipv4.c
>> @@ -106,15 +106,17 @@ int cipso_v4_rbm_strictvalid = 1;
>> /* Base length of the local tag (non-standard tag).
>> * Tag definition (may change between kernel versions)
>> *
>> - * 0 8 16 24 32
>> - * +----------+----------+----------+----------+
>> - * | 10000000 | 00000110 | 32-bit secid value |
>> - * +----------+----------+----------+----------+
>> - * | in (host byte order)|
>> - * +----------+----------+
>> - *
>> + * 0 8 16 16 + sizeof(struct lsmblob)
>> + * +----------+----------+---------------------+
>> + * | 10000000 | 00000110 | LSM blob data |
>> + * +----------+----------+---------------------+
>> + *
>> + * All secid and flag fields are in host byte order.
>> + * The lsmblob structure size varies depending on which
>> + * Linux security modules are built in the kernel.
>> + * The data is opaque.
>> */
>> -#define CIPSO_V4_TAG_LOC_BLEN 6
>> +#define CIPSO_V4_TAG_LOC_BLEN (2 + sizeof(struct lsmblob))
> This isn't as bad as the sk_buff.cb limitation so I'm not going to
> worry too much about it, but just to be safe I think we should put a
> compile-time check to ensure that the local tag is within the bounds
> of the IPv4 option limit. If we don't put a check I worry that there
> is a chance someone could get a very rude surprise at some point in
> the future (yes, this is highly unlikely, but still possible).
I hadn't thought about it, but that's a splendid idea.
>> /*
>> * Helper Functions
>> @@ -1467,7 +1469,8 @@ static int cipso_v4_gentag_loc(const struct cipso_v4_doi *doi_def,
>>
>> buffer[0] = CIPSO_V4_TAG_LOCAL;
>> buffer[1] = CIPSO_V4_TAG_LOC_BLEN;
>> - *(u32 *)&buffer[2] = secattr->attr.secid;
>> + memcpy(&buffer[2], &secattr->attr.lsmblob,
>> + sizeof(secattr->attr.lsmblob));
>>
>> return CIPSO_V4_TAG_LOC_BLEN;
>> }
^ permalink raw reply
* Re: [PATCH 01/14] VFS: Add additional RESOLVE_* flags [ver #18]
From: Linus Torvalds @ 2020-03-10 1:14 UTC (permalink / raw)
To: Aleksa Sarai
Cc: David Howells, Al Viro, Stefan Metzmacher, Ian Kent,
Miklos Szeredi, Christian Brauner, Jann Horn, Darrick J. Wong,
Karel Zak, jlayton, Linux API, linux-fsdevel, LSM List,
Linux Kernel Mailing List
In-Reply-To: <20200310005549.adrn3yf4mbljc5f6@yavin>
On Mon, Mar 9, 2020 at 5:56 PM Aleksa Sarai <cyphar@cyphar.com> wrote:
>
> On 2020-03-09, David Howells <dhowells@redhat.com> wrote:
> > This is necessary for fsinfo() to use RESOLVE_* flags instead of AT_* flags
> > if the latter are to be considered deprecated for new system calls.
> >
> > Also make openat2() handle RESOLVE_NO_TRAILING_SYMLINKS.
No, please let's not do this.
We have O_NOFOLLOW, and we can't get rid of it.
So adding RESOLVE_NO_TRAILING_SYMLINKS isn't a cleanup. It's just
extra complexity for absolutely zero gain.
> After thinking about what Christian said some more, I reckon we
> shouldn't support both O_NOFOLLOW and RESOLVE_NO_TRAILING_SYMLINKS. But
> that means we'll need to cherry-pick this patch and get it into mainline
> before v5.6.
No.
It simply means that we shouldn't have RESOLVE_NO_TRAILING_SYMLINKS at all.
Adding that flag is a mistake. It causes problems like this, where
subtlenly people say "what if both flags are set".
Just don't do it.
There's no way in hell we can ever get rid of O_NOFOLLOW anyway, since
people will continue to use plain open() and openat().
So adding RESOLVE_NO_TRAILING_SYMLINKS is entirely redundant.
Don't deprecate the old flags that are going to always stay around,
don't add stupid new flags that add no value.
It's that easy.
Linus
^ permalink raw reply
* Re: [PATCH v15 06/23] Use lsmblob in security_secctx_to_secid
From: Casey Schaufler @ 2020-03-10 1:13 UTC (permalink / raw)
To: Paul Moore
Cc: casey.schaufler, James Morris, linux-security-module, selinux,
keescook, john.johansen, penguin-kernel, Stephen Smalley
In-Reply-To: <CAHC9VhQyXEhU+2+Js+7B2AuebnD2ZQDT+5bHU-gO4FshvcFzGQ@mail.gmail.com>
On 3/6/2020 4:58 PM, Paul Moore wrote:
> On Fri, Feb 14, 2020 at 6:43 PM Casey Schaufler <casey@schaufler-ca.com> wrote:
>> Change security_secctx_to_secid() to fill in a lsmblob instead
>> of a u32 secid. Multiple LSMs may be able to interpret the
>> string, and this allows for setting whichever secid is
>> appropriate. In some cases there is scaffolding where other
>> interfaces have yet to be converted.
>>
>> Reviewed-by: Kees Cook <keescook@chromium.org>
>> Reviewed-by: John Johansen <john.johansen@canonical.com>
>> Acked-by: Stephen Smalley <sds@tycho.nsa.gov>
>> Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
>> ---
>> include/linux/security.h | 5 +++--
>> kernel/cred.c | 4 +---
>> net/netfilter/nft_meta.c | 12 +++++++-----
>> net/netfilter/xt_SECMARK.c | 5 ++++-
>> net/netlabel/netlabel_unlabeled.c | 14 ++++++++------
>> security/security.c | 18 +++++++++++++++---
>> 6 files changed, 38 insertions(+), 20 deletions(-)
> ...
>
>> diff --git a/net/netfilter/nft_meta.c b/net/netfilter/nft_meta.c
>> index 951b6e87ed5d..e12125b85035 100644
>> --- a/net/netfilter/nft_meta.c
>> +++ b/net/netfilter/nft_meta.c
>> @@ -811,21 +811,23 @@ static const struct nla_policy nft_secmark_policy[NFTA_SECMARK_MAX + 1] = {
>>
>> static int nft_secmark_compute_secid(struct nft_secmark *priv)
>> {
>> - u32 tmp_secid = 0;
>> + struct lsmblob blob;
>> int err;
>>
>> - err = security_secctx_to_secid(priv->ctx, strlen(priv->ctx), &tmp_secid);
>> + err = security_secctx_to_secid(priv->ctx, strlen(priv->ctx), &blob);
>> if (err)
>> return err;
>>
>> - if (!tmp_secid)
>> + if (!lsmblob_is_set(&blob))
>> return -ENOENT;
>>
>> - err = security_secmark_relabel_packet(tmp_secid);
>> + /* Using le[0] is scaffolding */
>> + err = security_secmark_relabel_packet(blob.secid[0]);
>> if (err)
>> return err;
> At the very least it looks like the comment above needs an update.
I can see that.
> However, I would really like to see an explanation in this patch,
> either in the comments or in the commit description, about how you
> plan to handle secmarks.
Yes. It should probably be spread between here, 0017 and the introduction.
> If your plan is to always have it be the
> first LSM, let's admit that and document it appropriately. If there
> is something much grander coming later in the patchset I guess
> "scaffolding" is an okay term, but it would be good to mention in the
> commit description that this will be replaced with something better
> later in the patchset.
You are correct.
> I'm worried about the case five years from know when we are changing
> this code, either due to bugs or new features, and we stumble across
> this commit. Was it always intended to be this way? Or was this
> temporary? Right now I don't know.
>
>> - priv->secid = tmp_secid;
>> + /* Using le[0] is scaffolding */
>> + priv->secid = blob.secid[0];
>> return 0;
>> }
> ...
>
>> diff --git a/net/netlabel/netlabel_unlabeled.c b/net/netlabel/netlabel_unlabeled.c
>> index d2e4ab8d1cb1..7a5a87f15736 100644
>> --- a/net/netlabel/netlabel_unlabeled.c
>> +++ b/net/netlabel/netlabel_unlabeled.c
>> @@ -881,7 +881,7 @@ static int netlbl_unlabel_staticadd(struct sk_buff *skb,
>> void *addr;
>> void *mask;
>> u32 addr_len;
>> - u32 secid;
>> + struct lsmblob blob;
>> struct netlbl_audit audit_info;
>>
>> /* Don't allow users to add both IPv4 and IPv6 addresses for a
>> @@ -905,12 +905,13 @@ static int netlbl_unlabel_staticadd(struct sk_buff *skb,
>> ret_val = security_secctx_to_secid(
>> nla_data(info->attrs[NLBL_UNLABEL_A_SECCTX]),
>> nla_len(info->attrs[NLBL_UNLABEL_A_SECCTX]),
>> - &secid);
>> + &blob);
>> if (ret_val != 0)
>> return ret_val;
>>
>> + /* scaffolding with the [0] */
>> return netlbl_unlhsh_add(&init_net,
>> - dev_name, addr, mask, addr_len, secid,
>> + dev_name, addr, mask, addr_len, blob.secid[0],
>> &audit_info);
>> }
> Same as above, although this time with the peer label.
>
^ permalink raw reply
* Re: [PATCH v15 05/23] net: Prepare UDS for security module stacking
From: Paul Moore @ 2020-03-10 1:02 UTC (permalink / raw)
To: Casey Schaufler
Cc: casey.schaufler, James Morris, linux-security-module, selinux,
keescook, john.johansen, penguin-kernel, Stephen Smalley
In-Reply-To: <50b463c1-1ff1-caad-3e4c-6e822e1c4a7a@schaufler-ca.com>
On Mon, Mar 9, 2020 at 8:13 PM Casey Schaufler <casey@schaufler-ca.com> wrote:
> On 3/6/2020 2:14 PM, Paul Moore wrote:
> > On Fri, Feb 14, 2020 at 6:42 PM Casey Schaufler <casey@schaufler-ca.com> wrote:
> >> Change the data used in UDS SO_PEERSEC processing from a
> >> secid to a more general struct lsmblob. Update the
> >> security_socket_getpeersec_dgram() interface to use the
> >> lsmblob. There is a small amount of scaffolding code
> >> that will come out when the security_secid_to_secctx()
> >> code is brought in line with the lsmblob.
> >>
> >> Reviewed-by: Kees Cook <keescook@chromium.org>
> >> Reviewed-by: John Johansen <john.johansen@canonical.com>
> >> Acked-by: Stephen Smalley <sds@tycho.nsa.gov>
> >> Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
> >> cc: netdev@vger.kernel.org
> >> ---
> >> include/linux/security.h | 7 +++++--
> >> include/net/af_unix.h | 2 +-
> >> include/net/scm.h | 8 +++++---
> >> net/ipv4/ip_sockglue.c | 8 +++++---
> >> net/unix/af_unix.c | 6 +++---
> >> security/security.c | 18 +++++++++++++++---
> >> 6 files changed, 34 insertions(+), 15 deletions(-)
> > ...
> >
> >> diff --git a/include/net/af_unix.h b/include/net/af_unix.h
> >> index 17e10fba2152..59af08ca802f 100644
> >> --- a/include/net/af_unix.h
> >> +++ b/include/net/af_unix.h
> >> @@ -36,7 +36,7 @@ struct unix_skb_parms {
> >> kgid_t gid;
> >> struct scm_fp_list *fp; /* Passed files */
> >> #ifdef CONFIG_SECURITY_NETWORK
> >> - u32 secid; /* Security ID */
> >> + struct lsmblob lsmblob; /* Security LSM data */
> >> #endif
> >> u32 consumed;
> >> } __randomize_layout;
> > This might be a problem. As it currently stands, the sk_buff.cb field
> > is 48 bytes; with CONFIG_SECURITY_NETWORK=n unix_skb_parms is 28 bytes
> > on a 64-bit system. That leaves 20 bytes (room for 5 LSMs) assuming a
> > tight packing *and* that netdev doesn't swoop in and drop another few
> > fields in unix_skb_parms.
> >
> > This may work now, and you might manage to sneak this by the netdev
> > crowd, but I predict problems in the future.
>
> Do you think that making this a struct lsmblob * instead would make
> the change more likely to be accepted? It would complicate the code
> but remove the issue.
I honestly have no idea anymore when it comes to the netdev crowd. I
can toss out a few examples, but you've been in this space long enough
to have seen the same things I have wrt to LSMs and the networking
folks.
Regardless of the implementation, I don't think you can embed the
lsmblob struct in the skb.cb; room for five LSMs is likely going to be
a limiting factor. Once you settle on that, no matter what you do for
a reference, pointer/index/etc., the problems are all roughly the
same. The trick is to find out what netdev will begrudgingly accept,
and for that I'm afraid you'll need to ask them directly.
--
paul moore
www.paul-moore.com
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: Andres Freund @ 2020-03-10 0:18 UTC (permalink / raw)
To: Jeff Layton
Cc: David Howells, torvalds, viro, Theodore Ts'o,
Stefan Metzmacher, Andreas Dilger, linux-ext4, Aleksa Sarai,
Trond Myklebust, Anna Schumaker, linux-nfs, linux-api, raven,
mszeredi, christian, jannh, darrick.wong, kzak, linux-fsdevel,
linux-security-module, linux-kernel
In-Reply-To: <32c384ac3adf0cf924d3071a13af7edffe53cc2b.camel@redhat.com>
Hi,
On 2020-03-09 18:49:31 -0400, Jeff Layton wrote:
> On Mon, 2020-03-09 at 12:22 -0700, Andres Freund wrote:
> > On 2020-03-09 13:50:59 -0400, Jeff Layton wrote:
> > > I sent a patch a few weeks ago to make syncfs() return errors when there
> > > have been writeback errors on the superblock. It's not merged yet, but
> > > once we have something like that in place, we could expose info from the
> > > errseq_t to userland using this interface.
> >
> > I'm still a bit worried about the details of errseq_t being exposed to
> > userland. Partially because it seems to restrict further evolution of
> > errseq_t, and partially because it will likely up with userland trying
> > to understand it (it's e.g. just too attractive to report a count of
> > errors etc).
>
> Trying to interpret the counter field won't really tell you anything.
> The counter is not incremented unless someone has queried the value
> since it was last checked. A single increment could represent a single
> writeback error or 10000 identical ones.
Oh, right. A zero errseq would still indicate something, but that's
probably fine.
> > Is there a reason to not instead report a 64bit counter instead of the
> > cookie? In contrast to the struct file case we'd only have the space
> > overhead once per superblock, rather than once per #files * #fd. And it
> > seems that the maintenance of that counter could be done without
> > widespread changes, e.g. instead/in addition to your change:
> What problem would moving to a 64-bit counter solve? I get the concern
> about people trying to get a counter out of the cookie field, but giving
> people an explicit 64-bit counter seems even more open to
> misinterpretation.
Well, you could get an actual error count out of it? I was thinking that
that value would get incremented every time mapping_set_error() is
called, which should make it a meaningful count?
Greetings,
Andres Freund
^ permalink raw reply
* Re: [PATCH v15 05/23] net: Prepare UDS for security module stacking
From: Casey Schaufler @ 2020-03-10 0:13 UTC (permalink / raw)
To: Paul Moore
Cc: casey.schaufler, James Morris, linux-security-module, selinux,
keescook, john.johansen, penguin-kernel, Stephen Smalley,
Casey Schaufler
In-Reply-To: <CAHC9VhQzSqbEh_RN3zqnhOqVMCjrKwGhyBXnYb8Du4LUq7=txQ@mail.gmail.com>
On 3/6/2020 2:14 PM, Paul Moore wrote:
> On Fri, Feb 14, 2020 at 6:42 PM Casey Schaufler <casey@schaufler-ca.com> wrote:
>> Change the data used in UDS SO_PEERSEC processing from a
>> secid to a more general struct lsmblob. Update the
>> security_socket_getpeersec_dgram() interface to use the
>> lsmblob. There is a small amount of scaffolding code
>> that will come out when the security_secid_to_secctx()
>> code is brought in line with the lsmblob.
>>
>> Reviewed-by: Kees Cook <keescook@chromium.org>
>> Reviewed-by: John Johansen <john.johansen@canonical.com>
>> Acked-by: Stephen Smalley <sds@tycho.nsa.gov>
>> Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
>> cc: netdev@vger.kernel.org
>> ---
>> include/linux/security.h | 7 +++++--
>> include/net/af_unix.h | 2 +-
>> include/net/scm.h | 8 +++++---
>> net/ipv4/ip_sockglue.c | 8 +++++---
>> net/unix/af_unix.c | 6 +++---
>> security/security.c | 18 +++++++++++++++---
>> 6 files changed, 34 insertions(+), 15 deletions(-)
> ...
>
>> diff --git a/include/net/af_unix.h b/include/net/af_unix.h
>> index 17e10fba2152..59af08ca802f 100644
>> --- a/include/net/af_unix.h
>> +++ b/include/net/af_unix.h
>> @@ -36,7 +36,7 @@ struct unix_skb_parms {
>> kgid_t gid;
>> struct scm_fp_list *fp; /* Passed files */
>> #ifdef CONFIG_SECURITY_NETWORK
>> - u32 secid; /* Security ID */
>> + struct lsmblob lsmblob; /* Security LSM data */
>> #endif
>> u32 consumed;
>> } __randomize_layout;
> This might be a problem. As it currently stands, the sk_buff.cb field
> is 48 bytes; with CONFIG_SECURITY_NETWORK=n unix_skb_parms is 28 bytes
> on a 64-bit system. That leaves 20 bytes (room for 5 LSMs) assuming a
> tight packing *and* that netdev doesn't swoop in and drop another few
> fields in unix_skb_parms.
>
> This may work now, and you might manage to sneak this by the netdev
> crowd, but I predict problems in the future.
Do you think that making this a struct lsmblob * instead would make
the change more likely to be accepted? It would complicate the code
but remove the issue.
^ permalink raw reply
* Re: [RFC PATCH v14 00/10] Landlock LSM
From: Jann Horn @ 2020-03-09 23:44 UTC (permalink / raw)
To: Mickaël Salaün
Cc: kernel list, Al Viro, Andy Lutomirski, Arnd Bergmann,
Casey Schaufler, Greg Kroah-Hartman, James Morris, Jann Horn,
Jonathan Corbet, Kees Cook, Michael Kerrisk,
Mickaël Salaün, Serge E . Hallyn, Shuah Khan,
Vincent Dagonneau, Kernel Hardening, Linux API, linux-arch,
linux-doc, linux-fsdevel, open list:KERNEL SELFTEST FRAMEWORK,
linux-security-module, the arch/x86 maintainers
In-Reply-To: <20200224160215.4136-1-mic@digikod.net>
On Mon, Feb 24, 2020 at 5:03 PM Mickaël Salaün <mic@digikod.net> wrote:
> This new version of Landlock is a major revamp of the previous series
> [1], hence the RFC tag. The three main changes are the replacement of
> eBPF with a dedicated safe management of access rules, the replacement
> of the use of seccomp(2) with a dedicated syscall, and the management of
> filesystem access-control (back from the v10).
>
> As discussed in [2], eBPF may be too powerful and dangerous to be put in
> the hand of unprivileged and potentially malicious processes, especially
> because of side-channel attacks against access-controls or other parts
> of the kernel.
>
> Thanks to this new implementation (1540 SLOC), designed from the ground
> to be used by unprivileged processes, this series enables a process to
> sandbox itself without requiring CAP_SYS_ADMIN, but only the
> no_new_privs constraint (like seccomp). Not relying on eBPF also
> enables to improve performances, especially for stacked security
> policies thanks to mergeable rulesets.
>
> The compiled documentation is available here:
> https://landlock.io/linux-doc/landlock-v14/security/landlock/index.html
>
> This series can be applied on top of v5.6-rc3. This can be tested with
> CONFIG_SECURITY_LANDLOCK and CONFIG_SAMPLE_LANDLOCK. This patch series
> can be found in a Git repository here:
> https://github.com/landlock-lsm/linux/commits/landlock-v14
> I would really appreciate constructive comments on the design and the code.
I've looked through the patchset, and I think that it would be
possible to simplify it quite a bit. I have tried to do that (and
compiled-tested it, but not actually tried running it); here's what I
came up with:
https://github.com/thejh/linux/commits/landlock-mod
The three modified patches (patches 1, 2 and 5) are marked with
"[MODIFIED]" in their title. Please take a look - what do you think?
Feel free to integrate my changes into your patches if you think they
make sense.
Apart from simplifying the code, I also found the following issues,
which I have fixed in the modified patches:
put_hierarchy() has to drop a reference on its parent. (However, this
must not recurse, so we have to do it with a loop.)
put_ruleset() is not in an RCU read-side critical section, so as soon
as it calls kfree_rcu(), "freeme" might disappear; but "orig" is in
"freeme", so when the loop tries to find the next element with
rb_next(orig), that can be a UAF.
rbtree_postorder_for_each_entry_safe() exists for dealing with such
issues.
AFAIK the calls to rb_erase() in clean_ruleset() is not safe if
someone is concurrently accessing the rbtree as an RCU reader, because
concurrent rotations can prevent a lookup from succeeding. The
simplest fix is probably to just make any rbtree that has been
installed on a process immutable, and give up on the cleaning -
arguably the memory wastage that can cause is pretty limited. (By the
way, as a future optimization, we might want to turn the rbtree into a
hashtable when installing it?)
The iput() in landlock_release_inode() looks unsafe - you need to
guarantee that even if the deletion of a ruleset races with
generic_shutdown_super(), every iput() for that superblock finishes
before landlock_release_inodes() returns, even if the iput() is
happening in the context of ruleset deletion. This is why
fsnotify_unmount_inodes() has that wait_var_event() at the end.
Aside from those things, there is also a major correctness issue where
I'm not sure how to solve it properly:
Let's say a process installs a filter on itself like this:
struct landlock_attr_ruleset ruleset = { .handled_access_fs =
ACCESS_FS_ROUGHLY_WRITE};
int ruleset_fd = landlock(LANDLOCK_CMD_CREATE_RULESET,
LANDLOCK_OPT_CREATE_RULESET, sizeof(ruleset), &ruleset);
struct landlock_attr_path_beneath path_beneath = {
.ruleset_fd = ruleset_fd,
.allowed_access = ACCESS_FS_ROUGHLY_WRITE,
.parent_fd = open("/tmp/foobar", O_PATH),
};
landlock(LANDLOCK_CMD_ADD_RULE, LANDLOCK_OPT_ADD_RULE_PATH_BENEATH,
sizeof(path_beneath), &path_beneath);
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
struct landlock_attr_enforce attr_enforce = { .ruleset_fd = ruleset_fd };
landlock(LANDLOCK_CMD_ENFORCE_RULESET, LANDLOCK_OPT_ENFORCE_RULESET,
sizeof(attr_enforce), &attr_enforce);
At this point, the process is not supposed to be able to write to
anything outside /tmp/foobar, right? But what happens if the process
does the following next?
struct landlock_attr_ruleset ruleset = { .handled_access_fs =
ACCESS_FS_ROUGHLY_WRITE};
int ruleset_fd = landlock(LANDLOCK_CMD_CREATE_RULESET,
LANDLOCK_OPT_CREATE_RULESET, sizeof(ruleset), &ruleset);
struct landlock_attr_path_beneath path_beneath = {
.ruleset_fd = ruleset_fd,
.allowed_access = ACCESS_FS_ROUGHLY_WRITE,
.parent_fd = open("/", O_PATH),
};
landlock(LANDLOCK_CMD_ADD_RULE, LANDLOCK_OPT_ADD_RULE_PATH_BENEATH,
sizeof(path_beneath), &path_beneath);
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
struct landlock_attr_enforce attr_enforce = { .ruleset_fd = ruleset_fd };
landlock(LANDLOCK_CMD_ENFORCE_RULESET, LANDLOCK_OPT_ENFORCE_RULESET,
sizeof(attr_enforce), &attr_enforce);
As far as I can tell from looking at the source, after this, you will
have write access to the entire filesystem again. I think the idea is
that LANDLOCK_CMD_ENFORCE_RULESET should only let you drop privileges,
not increase them, right?
I think the easy way to fix this would be to add a bitmask to each
rule that says from which ruleset it originally comes, and then let
check_access_path() collect these bitmasks from each rule with OR, and
check at the end whether the resulting bitmask is full - if not, at
least one of the rulesets did not permit the access, and it should be
denied.
But maybe it would make more sense to change how the API works
instead, and get rid of the concept of "merging" two rulesets
together? Instead, we could make the API work like this:
- LANDLOCK_CMD_CREATE_RULESET gives you a file descriptor whose
->private_data contains a pointer to the old ruleset of the process,
as well as a pointer to a new empty ruleset.
- LANDLOCK_CMD_ADD_RULE fails if the specified rule would not be
permitted by the old ruleset, then adds the rule to the new ruleset
- LANDLOCK_CMD_ENFORCE_RULESET fails if the old ruleset pointer in
->private_data doesn't match the current ruleset of the process, then
replaces the old ruleset with the new ruleset.
With this, the new ruleset is guaranteed to be a subset of the old
ruleset because each of the new ruleset's rules is permitted by the
old ruleset. (Unless the directory hierarchy rotates, but in that case
the inaccuracy isn't much worse than what would've been possible
through RCU path walk anyway AFAIK.)
What do you think?
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: David Howells @ 2020-03-09 22:52 UTC (permalink / raw)
To: Miklos Szeredi
Cc: dhowells, torvalds, viro, Theodore Ts'o, Stefan Metzmacher,
Andreas Dilger, linux-ext4, Aleksa Sarai, Trond Myklebust,
Anna Schumaker, linux-nfs, linux-api, raven, mszeredi, christian,
jannh, darrick.wong, kzak, jlayton, linux-fsdevel,
linux-security-module, linux-kernel
In-Reply-To: <20200309200238.GB28467@miu.piliscsaba.redhat.com>
Miklos Szeredi <miklos@szeredi.hu> wrote:
> > (1) It can be targetted. It makes it easy to query directly by path or
> > fd, but can also query by mount ID or fscontext fd. procfs and sysfs
> > cannot do three of these things easily.
>
> See above: with the addition of open(path, O_PATH) it can do all of these.
That's a horrible interface. To query a file by path, you have to do:
fd = open(path, O_PATH);
sprintf(procpath, "/proc/self/fdmount/%u/<attr>");
fd2 = open(procpath, O_RDONLY);
read(fd2, ...);
close(fd2);
close(fd);
See point (3) about efficiency also. You're having to open *two* files.
> > (2) Easier to provide LSM oversight. Is the accessing process allowed to
> > query information pertinent to a particular file?
>
> Not quite sure why this would be easier for a new ad-hoc interface than for
> the well established filesystem API.
You're right. That's why fsinfo() uses standard pathwalk where possible,
e.g.:
fsinfo(AT_FDCWD, "/path/to/file", ...);
or a fairly standard fd-querying interface:
fsinfo(fd, "", { resolve_flags = RESOLVE_EMPTY_PATH }, ...);
to query an open file descriptor. These are well-established filesystem APIs.
Where I vary from this is allowing direct specification of a mount ID also,
with a special flag to say that's what I'm doing:
fsinfo(AT_FDCWD, "23", { flags = FSINFO_QUERY_FLAGS_MOUNT }, ...);
> > (7) Don't have to create/delete a bunch of sysfs/procfs nodes each time a
> > mount happens or is removed - and since systemd makes much use of
> > mount namespaces and mount propagation, this will create a lot of
> > nodes.
>
> This patch creates a single struct mountfs_entry per mount, which is 48bytes.
fsinfo() doesn't create any. Furthermore, it seems that mounts get multiplied
8-10 times by systemd - though, as you say, it's not necessarily a great deal
of memory.
> Now onto the advantages of a filesystem based API:
>
> - immediately usable from all programming languages, including scripts
This is not true. You can't open O_PATH from shell scripts, so you can't
query things by path that you can't or shouldn't open (dev file paths, for
example; symlinks).
I imagine you're thinking of something like:
{
id=`cat /proc/self/fdmount/5/parent_mount`
} 5</my/path/to/my/file
but what if /my/path/to/my/file is actually /dev/foobar?
I've had a grep through the bash sources, but can't seem to find anywhere that
uses O_PATH.
> - same goes for future extensions: no need to update libc, utils, language
> bindings, strace, etc...
Applications and libraries using these attributes would have to change anyway
to make use of additional information.
But it's not a good argument since you now have to have text parsers that
change over time.
David
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: Jeff Layton @ 2020-03-09 22:49 UTC (permalink / raw)
To: Andres Freund
Cc: David Howells, torvalds, viro, Theodore Ts'o,
Stefan Metzmacher, Andreas Dilger, linux-ext4, Aleksa Sarai,
Trond Myklebust, Anna Schumaker, linux-nfs, linux-api, raven,
mszeredi, christian, jannh, darrick.wong, kzak, linux-fsdevel,
linux-security-module, linux-kernel
In-Reply-To: <20200309192240.nqf5bxylptw7mdm3@alap3.anarazel.de>
On Mon, 2020-03-09 at 12:22 -0700, Andres Freund wrote:
> Hi,
>
> On 2020-03-09 13:50:59 -0400, Jeff Layton wrote:
> > The PostgreSQL devs asked a while back for some way to tell whether
> > there have been any writeback errors on a superblock w/o having to do
> > any sort of flush -- just "have there been any so far".
>
> Indeed.
>
>
> > I sent a patch a few weeks ago to make syncfs() return errors when there
> > have been writeback errors on the superblock. It's not merged yet, but
> > once we have something like that in place, we could expose info from the
> > errseq_t to userland using this interface.
>
> I'm still a bit worried about the details of errseq_t being exposed to
> userland. Partially because it seems to restrict further evolution of
> errseq_t, and partially because it will likely up with userland trying
> to understand it (it's e.g. just too attractive to report a count of
> errors etc).
Trying to interpret the counter field won't really tell you anything.
The counter is not incremented unless someone has queried the value
since it was last checked. A single increment could represent a single
writeback error or 10000 identical ones.
There _is_ a flag that tells you whether someone has queried it, but
that gets masked off before copying the cookie to userland.
> Is there a reason to not instead report a 64bit counter instead of the
> cookie? In contrast to the struct file case we'd only have the space
> overhead once per superblock, rather than once per #files * #fd. And it
> seems that the maintenance of that counter could be done without
> widespread changes, e.g. instead/in addition to your change:
>
What problem would moving to a 64-bit counter solve? I get the concern
about people trying to get a counter out of the cookie field, but giving
people an explicit 64-bit counter seems even more open to
misinterpretation.
All that said, is an opaque cookie still something you'd find useful?
> > diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
> > index ccb14b6a16b5..897439475315 100644
> > --- a/include/linux/pagemap.h
> > +++ b/include/linux/pagemap.h
> > @@ -51,7 +51,10 @@ static inline void mapping_set_error(struct address_space *mapping, int error)
> > return;
> >
> > /* Record in wb_err for checkers using errseq_t based tracking */
> > - filemap_set_wb_err(mapping, error);
> > + __filemap_set_wb_err(mapping, error);
> > +
> > + /* Record it in superblock */
> > + errseq_set(&mapping->host->i_sb->s_wb_err, error);
> >
> > /* Record it in flags for now, for legacy callers */
> > if (error == -ENOSPC)
>
> Btw, seems like mapping_set_error() should have a non-inline cold path?
Good point. I'll do that in the next iteration.
--
Jeff Layton <jlayton@redhat.com>
^ permalink raw reply
* Re: [PATCH 01/14] VFS: Add additional RESOLVE_* flags [ver #18]
From: David Howells @ 2020-03-09 21:13 UTC (permalink / raw)
To: Stefan Metzmacher
Cc: dhowells, torvalds, viro, Aleksa Sarai, raven, mszeredi,
christian, jannh, darrick.wong, kzak, jlayton, linux-api,
linux-fsdevel, linux-security-module, linux-kernel
In-Reply-To: <a2012ba2-e322-39e2-fa80-c8d4aef501de@samba.org>
Stefan Metzmacher <metze@samba.org> wrote:
> > Automounting is currently forced by doing an open(), so adding support to
> > openat2() for RESOLVE_NO_TRAILING_AUTOMOUNTS is not trivial.
>
> lookup_flags &= ~LOOKUP_AUTOMOUNT won't work?
No. LOOKUP_OPEN overrides that.
David
^ permalink raw reply
* Re: [PATCH 01/14] VFS: Add additional RESOLVE_* flags [ver #18]
From: Stefan Metzmacher @ 2020-03-09 20:56 UTC (permalink / raw)
To: David Howells, torvalds, viro
Cc: Aleksa Sarai, raven, mszeredi, christian, jannh, darrick.wong,
kzak, jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376245699.344135.7522994074747336376.stgit@warthog.procyon.org.uk>
[-- Attachment #1.1: Type: text/plain, Size: 1032 bytes --]
Hi David,
> Add additional RESOLVE_* flags to correspond to AT_* flags that aren't
> currently implemented:
>
> RESOLVE_NO_TRAILING_SYMLINKS for AT_SYMLINK_NOFOLLOW
> RESOLVE_NO_TRAILING_AUTOMOUNTS for AT_NO_AUTOMOUNT
> RESOLVE_EMPTY_PATH for AT_EMPTY_PATH
Thanks for changing the names!
> This is necessary for fsinfo() to use RESOLVE_* flags instead of AT_* flags
> if the latter are to be considered deprecated for new system calls.
>
> Also make openat2() handle RESOLVE_NO_TRAILING_SYMLINKS.
>
> Automounting is currently forced by doing an open(), so adding support to
> openat2() for RESOLVE_NO_TRAILING_AUTOMOUNTS is not trivial.
lookup_flags &= ~LOOKUP_AUTOMOUNT won't work?
At least it should cause EINVAL (or something similar) instead of being
silently ignored. The same applies to RESOLVE_EMPTY_PATH, it should be
handled with some logic or also cause EINVAL.
vfs_statx()/vfs_stat_set_lookup_flags() seems to have a similar logic
using the AT_* flags.
metze
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 833 bytes --]
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: Miklos Szeredi @ 2020-03-09 20:02 UTC (permalink / raw)
To: David Howells
Cc: torvalds, viro, Theodore Ts'o, Stefan Metzmacher,
Andreas Dilger, linux-ext4, Aleksa Sarai, Trond Myklebust,
Anna Schumaker, linux-nfs, linux-api, raven, mszeredi, christian,
jannh, darrick.wong, kzak, jlayton, linux-fsdevel,
linux-security-module, linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
On Mon, Mar 09, 2020 at 02:00:46PM +0000, David Howells wrote:
> ============================
> WHY NOT USE PROCFS OR SYSFS?
> ============================
And here's the updated patch (hopefully addressed all of Al's concerns)
that uses procfs and a new mountfs.
Get mountinfo from open file:
cat /proc/$PID/fdmount/$FD/*
Get mountinfo by mount ID:
mount -t mountfs mountfs /mountfs
cat /mountfs/$MNT_ID/*
> Why is it better to go with a new system call rather than adding more magic
> stuff to /proc or /sysfs for each superblock object and each mount object?
>
> (1) It can be targetted. It makes it easy to query directly by path or
> fd, but can also query by mount ID or fscontext fd. procfs and sysfs
> cannot do three of these things easily.
See above: with the addition of open(path, O_PATH) it can do all of these.
>
> (2) Easier to provide LSM oversight. Is the accessing process allowed to
> query information pertinent to a particular file?
Not quite sure why this would be easier for a new ad-hoc interface than for
the well established filesystem API.
>
> (3) It's more efficient as we can return specific binary data rather than
> making huge text dumps. Granted, sysfs and procfs could present the
> same data, though as lots of little files which have to be
> individually opened, read, closed and parsed.
>
> (4) We wouldn't have the overhead of open and close (even adding a
> self-contained readfile() syscall has to do that internally).
>
> (5) Opening a file in procfs or sysfs has a pathwalk overhead for each
> file accessed. We can use an integer attribute ID instead (yes, this
> is similar to ioctl) - but could also use a string ID if that is
> preferred.
Is that super-high performance really warranted? What would be the
application of that?
>
> (6) Can query cross-namespace if, say, a container manager process is
> given an fs_context that hasn't yet been mounted into a namespace - or
> hasn't even been fully created yet.
This patch can do that too.
>
> (7) Don't have to create/delete a bunch of sysfs/procfs nodes each time a
> mount happens or is removed - and since systemd makes much use of
> mount namespaces and mount propagation, this will create a lot of
> nodes.
This patch creates a single struct mountfs_entry per mount, which is 48bytes.
Now onto the advantages of a filesystem based API:
- immediately usable from all programming languages, including scripts
- same goes for future extensions: no need to update libc, utils, language
bindings, strace, etc...
Thanks,
Miklos
---
fs/Makefile | 1
fs/mount.h | 8
fs/mountfs/Makefile | 1
fs/mountfs/super.c | 502 +++++++++++++++++++++++++++++++++++++++++++++++
fs/namespace.c | 31 ++
fs/proc/base.c | 2
fs/proc/fd.c | 82 +++++++
fs/proc/fd.h | 3
fs/proc_namespace.c | 22 --
fs/seq_file.c | 23 ++
include/linux/seq_file.h | 1
11 files changed, 654 insertions(+), 22 deletions(-)
--- a/fs/Makefile
+++ b/fs/Makefile
@@ -135,3 +135,4 @@ obj-$(CONFIG_EFIVAR_FS) += efivarfs/
obj-$(CONFIG_EROFS_FS) += erofs/
obj-$(CONFIG_VBOXSF_FS) += vboxsf/
obj-$(CONFIG_ZONEFS_FS) += zonefs/
+obj-y += mountfs/
--- a/fs/mount.h
+++ b/fs/mount.h
@@ -72,6 +72,7 @@ struct mount {
int mnt_expiry_mark; /* true if marked for expiry */
struct hlist_head mnt_pins;
struct hlist_head mnt_stuck_children;
+ struct mountfs_entry *mnt_mountfs_entry;
} __randomize_layout;
#define MNT_NS_INTERNAL ERR_PTR(-EINVAL) /* distinct from any mnt_namespace */
@@ -153,3 +154,10 @@ static inline bool is_anon_ns(struct mnt
{
return ns->seq == 0;
}
+
+void mnt_namespace_lock_read(void);
+void mnt_namespace_unlock_read(void);
+
+void mountfs_create(struct mount *mnt);
+extern void mountfs_remove(struct mount *mnt);
+int mountfs_lookup_internal(struct vfsmount *m, struct path *path);
--- /dev/null
+++ b/fs/mountfs/Makefile
@@ -0,0 +1 @@
+obj-y += super.o
--- /dev/null
+++ b/fs/mountfs/super.c
@@ -0,0 +1,502 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include "../pnode.h"
+#include <linux/fs.h>
+#include <linux/kref.h>
+#include <linux/nsproxy.h>
+#include <linux/fs_struct.h>
+#include <linux/fs_context.h>
+
+#define MOUNTFS_SUPER_MAGIC 0x4e756f4d
+
+static DEFINE_SPINLOCK(mountfs_lock);
+static struct rb_root mountfs_entries = RB_ROOT;
+static struct vfsmount *mountfs_mnt __read_mostly;
+
+struct mountfs_entry {
+ struct kref kref;
+ struct mount *mnt;
+ struct rb_node node;
+ int id;
+};
+
+static const char *mountfs_attrs[] = {
+ "root", "mountpoint", "id", "parent", "options", "children",
+ "group", "master", "propagate_from"
+};
+
+#define MOUNTFS_INO(id) (((unsigned long) id + 1) * \
+ (ARRAY_SIZE(mountfs_attrs) + 1))
+
+void mountfs_entry_release(struct kref *kref)
+{
+ kfree(container_of(kref, struct mountfs_entry, kref));
+}
+
+void mountfs_entry_put(struct mountfs_entry *entry)
+{
+ kref_put(&entry->kref, mountfs_entry_release);
+}
+
+static bool mountfs_entry_visible(struct mountfs_entry *entry)
+{
+ struct mount *mnt;
+ bool visible = false;
+
+ rcu_read_lock();
+ mnt = rcu_dereference(entry->mnt);
+ if (mnt && mnt->mnt_ns == current->nsproxy->mnt_ns)
+ visible = true;
+ rcu_read_unlock();
+
+ return visible;
+}
+static int mountfs_attr_show(struct seq_file *sf, void *v)
+{
+ const char *name = sf->file->f_path.dentry->d_name.name;
+ struct mountfs_entry *entry = sf->private;
+ struct mount *mnt;
+ struct vfsmount *m;
+ struct super_block *sb;
+ struct path root;
+ int tmp, err = -ENODEV;
+
+ mnt_namespace_lock_read();
+
+ mnt = entry->mnt;
+ if (!mnt || !mnt->mnt_ns)
+ goto out;
+
+ err = 0;
+ m = &mnt->mnt;
+ sb = m->mnt_sb;
+
+ if (strcmp(name, "root") == 0) {
+ if (sb->s_op->show_path) {
+ err = sb->s_op->show_path(sf, m->mnt_root);
+ } else {
+ seq_dentry(sf, m->mnt_root, " \t\n\\");
+ }
+ seq_putc(sf, '\n');
+ } else if (strcmp(name, "mountpoint") == 0) {
+ struct path mnt_path = { .dentry = m->mnt_root, .mnt = m };
+
+ get_fs_root(current->fs, &root);
+ err = seq_path_root(sf, &mnt_path, &root, " \t\n\\");
+ if (err == SEQ_SKIP) {
+ seq_puts(sf, "(unreachable)");
+ err = 0;
+ }
+ seq_putc(sf, '\n');
+ path_put(&root);
+ } else if (strcmp(name, "id") == 0) {
+ seq_printf(sf, "%i\n", mnt->mnt_id);
+ } else if (strcmp(name, "parent") == 0) {
+ tmp = rcu_dereference(mnt->mnt_parent)->mnt_id;
+ seq_printf(sf, "%i\n", tmp);
+ } else if (strcmp(name, "options") == 0) {
+ int mnt_flags = READ_ONCE(m->mnt_flags);
+
+ seq_puts(sf, mnt_flags & MNT_READONLY ? "ro" : "rw");
+ seq_mnt_opts(sf, mnt_flags);
+ seq_putc(sf, '\n');
+ } else if (strcmp(name, "children") == 0) {
+ struct mount *child;
+ bool first = true;
+
+ list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) {
+ if (!first)
+ seq_putc(sf, ',');
+ else
+ first = false;
+ seq_printf(sf, "%i", child->mnt_id);
+ }
+ if (!first)
+ seq_putc(sf, '\n');
+ } else if (strcmp(name, "group") == 0) {
+ if (IS_MNT_SHARED(mnt))
+ seq_printf(sf, "%i\n", mnt->mnt_group_id);
+ } else if (strcmp(name, "master") == 0) {
+ if (IS_MNT_SLAVE(mnt)) {
+ tmp = rcu_dereference(mnt->mnt_master)->mnt_group_id;
+ seq_printf(sf, "%i\n", tmp);
+ }
+ } else if (strcmp(name, "propagate_from") == 0) {
+ if (IS_MNT_SLAVE(mnt)) {
+ get_fs_root(current->fs, &root);
+ tmp = get_dominating_id(mnt, &root);
+ if (tmp)
+ seq_printf(sf, "%i\n", tmp);
+ }
+ } else {
+ WARN_ON(1);
+ err = -EIO;
+ }
+out:
+ mnt_namespace_unlock_read();
+
+ return err;
+}
+
+static int mountfs_attr_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, mountfs_attr_show, inode->i_private);
+}
+
+static const struct file_operations mountfs_attr_fops = {
+ .open = mountfs_attr_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+
+static struct mountfs_entry *mountfs_node_to_entry(struct rb_node *node)
+{
+ return rb_entry(node, struct mountfs_entry, node);
+}
+
+static struct rb_node **mountfs_find_node(int id, struct rb_node **parent)
+{
+ struct rb_node **link = &mountfs_entries.rb_node;
+
+ *parent = NULL;
+ while (*link) {
+ struct mountfs_entry *entry = mountfs_node_to_entry(*link);
+
+ *parent = *link;
+ if (id < entry->id)
+ link = &entry->node.rb_left;
+ else if (id > entry->id)
+ link = &entry->node.rb_right;
+ else
+ break;
+ }
+ return link;
+}
+
+void mountfs_create(struct mount *mnt)
+{
+ struct mountfs_entry *entry;
+ struct rb_node **link, *parent;
+
+ entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+ if (!entry) {
+ WARN(1, "failed to allocate mountfs entry");
+ return;
+ }
+ kref_init(&entry->kref);
+ entry->mnt = mnt;
+ entry->id = mnt->mnt_id;
+
+ spin_lock(&mountfs_lock);
+ link = mountfs_find_node(entry->id, &parent);
+ if (!WARN_ON(*link)) {
+ rb_link_node(&entry->node, parent, link);
+ rb_insert_color(&entry->node, &mountfs_entries);
+ mnt->mnt_mountfs_entry = entry;
+ } else {
+ kfree(entry);
+ }
+ spin_unlock(&mountfs_lock);
+}
+
+void mountfs_remove(struct mount *mnt)
+{
+ struct mountfs_entry *entry = mnt->mnt_mountfs_entry;
+
+ if (!entry)
+ return;
+ spin_lock(&mountfs_lock);
+ entry->mnt = NULL;
+ rb_erase(&entry->node, &mountfs_entries);
+ spin_unlock(&mountfs_lock);
+
+ mountfs_entry_put(entry);
+
+ mnt->mnt_mountfs_entry = NULL;
+}
+
+static struct mountfs_entry *mountfs_get_entry(const char *name)
+{
+ struct mountfs_entry *entry = NULL;
+ struct rb_node **link, *dummy;
+ unsigned long mnt_id;
+ char buf[32];
+ int ret;
+
+ ret = kstrtoul(name, 10, &mnt_id);
+ if (ret || mnt_id > INT_MAX)
+ return NULL;
+
+ snprintf(buf, sizeof(buf), "%lu", mnt_id);
+ if (strcmp(buf, name) != 0)
+ return NULL;
+
+ spin_lock(&mountfs_lock);
+ link = mountfs_find_node(mnt_id, &dummy);
+ if (*link) {
+ entry = mountfs_node_to_entry(*link);
+ if (!mountfs_entry_visible(entry))
+ entry = NULL;
+ else
+ kref_get(&entry->kref);
+ }
+ spin_unlock(&mountfs_lock);
+
+ return entry;
+}
+
+static void mountfs_init_inode(struct inode *inode, umode_t mode);
+
+static struct dentry *mountfs_lookup_entry(struct dentry *dentry,
+ struct mountfs_entry *entry,
+ int idx)
+{
+ struct inode *inode;
+
+ inode = new_inode(dentry->d_sb);
+ if (!inode) {
+ mountfs_entry_put(entry);
+ return ERR_PTR(-ENOMEM);
+ }
+ inode->i_private = entry;
+ inode->i_ino = MOUNTFS_INO(entry->id) + idx;
+ mountfs_init_inode(inode, idx ? S_IFREG | 0444 : S_IFDIR | 0555);
+ return d_splice_alias(inode, dentry);
+
+}
+
+static struct dentry *mountfs_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct mountfs_entry *entry = dir->i_private;
+ int i = 0;
+
+ if (entry) {
+ for (i = 0; i < ARRAY_SIZE(mountfs_attrs); i++)
+ if (strcmp(mountfs_attrs[i], dentry->d_name.name) == 0)
+ break;
+ if (i == ARRAY_SIZE(mountfs_attrs))
+ return ERR_PTR(-ENOMEM);
+ i++;
+ kref_get(&entry->kref);
+ } else {
+ entry = mountfs_get_entry(dentry->d_name.name);
+ if (!entry)
+ return ERR_PTR(-ENOENT);
+ }
+
+ return mountfs_lookup_entry(dentry, entry, i);
+}
+
+static int mountfs_d_revalidate(struct dentry *dentry, unsigned int flags)
+{
+ struct mountfs_entry *entry = dentry->d_inode->i_private;
+
+ /* root: valid */
+ if (!entry)
+ return 1;
+
+ /* removed: invalid */
+ if (!entry->mnt)
+ return 0;
+
+ /* attribute or visible in this namespace: valid */
+ if (!d_can_lookup(dentry) || mountfs_entry_visible(entry))
+ return 1;
+
+ /* invlisible in this namespace: valid but deny entry*/
+ return -ENOENT;
+}
+
+static int mountfs_readdir(struct file *file, struct dir_context *ctx)
+{
+ struct rb_node *node;
+ struct mountfs_entry *entry = file_inode(file)->i_private;
+ char name[32];
+ const char *s;
+ unsigned int len, pos, id;
+
+ if (ctx->pos - 2 > INT_MAX || !dir_emit_dots(file, ctx))
+ return 0;
+
+ if (entry) {
+ while (ctx->pos - 2 < ARRAY_SIZE(mountfs_attrs)) {
+ s = mountfs_attrs[ctx->pos - 2];
+ if (!dir_emit(ctx, s, strlen(s),
+ MOUNTFS_INO(entry->id) + ctx->pos,
+ DT_REG))
+ break;
+ ctx->pos++;
+ }
+ return 0;
+ }
+
+ pos = ctx->pos - 2;
+ do {
+ spin_lock(&mountfs_lock);
+ mountfs_find_node(pos, &node);
+ pos = 1U + INT_MAX;
+ do {
+ if (!node) {
+ spin_unlock(&mountfs_lock);
+ goto out;
+ }
+ entry = mountfs_node_to_entry(node);
+ node = rb_next(node);
+ } while (!mountfs_entry_visible(entry));
+ if (node)
+ pos = mountfs_node_to_entry(node)->id;
+ id = entry->id;
+ spin_unlock(&mountfs_lock);
+
+ len = snprintf(name, sizeof(name), "%i", id);
+ ctx->pos = id + 2;
+ if (!dir_emit(ctx, name, len, MOUNTFS_INO(id), DT_DIR))
+ return 0;
+ } while (pos <= INT_MAX);
+out:
+ ctx->pos = pos + 2;
+ return 0;
+}
+
+int mountfs_lookup_internal(struct vfsmount *m, struct path *path)
+{
+ char name[32];
+ struct qstr this = { .name = name };
+ struct mount *mnt = real_mount(m);
+ struct mountfs_entry *entry = mnt->mnt_mountfs_entry;
+ struct dentry *dentry, *old, *root = mountfs_mnt->mnt_root;
+
+ this.len = snprintf(name, sizeof(name), "%i", mnt->mnt_id);
+ dentry = d_hash_and_lookup(root, &this);
+ if (dentry && dentry->d_inode->i_private != entry) {
+ d_invalidate(dentry);
+ dput(dentry);
+ dentry = NULL;
+ }
+ if (!dentry) {
+ dentry = d_alloc(root, &this);
+ if (!dentry)
+ return -ENOMEM;
+
+ kref_get(&entry->kref);
+ old = mountfs_lookup_entry(dentry, entry, 0);
+ if (old) {
+ dput(dentry);
+ if (IS_ERR(old))
+ return PTR_ERR(old);
+ dentry = old;
+ }
+ }
+
+ *path = (struct path) { .mnt = mountfs_mnt, .dentry = dentry };
+ return 0;
+}
+
+static const struct dentry_operations mountfs_dops = {
+ .d_revalidate = mountfs_d_revalidate,
+};
+
+static const struct inode_operations mountfs_iops = {
+ .lookup = mountfs_lookup,
+};
+
+static const struct file_operations mountfs_fops = {
+ .iterate_shared = mountfs_readdir,
+ .read = generic_read_dir,
+ .llseek = generic_file_llseek,
+};
+
+static void mountfs_init_inode(struct inode *inode, umode_t mode)
+{
+ inode->i_mode = mode;
+ inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
+ if (S_ISREG(mode)) {
+ inode->i_size = PAGE_SIZE;
+ inode->i_fop = &mountfs_attr_fops;
+ } else {
+ inode->i_op = &mountfs_iops;
+ inode->i_fop = &mountfs_fops;
+ }
+}
+
+static void mountfs_evict_inode(struct inode *inode)
+{
+ struct mountfs_entry *entry = inode->i_private;
+
+ clear_inode(inode);
+ if (entry)
+ mountfs_entry_put(entry);
+}
+
+static const struct super_operations mountfs_sops = {
+ .statfs = simple_statfs,
+ .drop_inode = generic_delete_inode,
+ .evict_inode = mountfs_evict_inode,
+};
+
+static int mountfs_fill_super(struct super_block *sb, struct fs_context *fc)
+{
+ struct inode *root;
+
+ sb->s_iflags |= SB_I_NOEXEC | SB_I_NODEV;
+ sb->s_blocksize = PAGE_SIZE;
+ sb->s_blocksize_bits = PAGE_SHIFT;
+ sb->s_magic = MOUNTFS_SUPER_MAGIC;
+ sb->s_time_gran = 1;
+ sb->s_shrink.seeks = 0;
+ sb->s_op = &mountfs_sops;
+ sb->s_d_op = &mountfs_dops;
+
+ root = new_inode(sb);
+ if (!root)
+ return -ENOMEM;
+
+ root->i_ino = 1;
+ mountfs_init_inode(root, S_IFDIR | 0444);
+
+ sb->s_root = d_make_root(root);
+ if (!sb->s_root)
+ return -ENOMEM;
+
+ return 0;
+}
+
+static int mountfs_get_tree(struct fs_context *fc)
+{
+ return get_tree_single(fc, mountfs_fill_super);
+}
+
+static const struct fs_context_operations mountfs_context_ops = {
+ .get_tree = mountfs_get_tree,
+};
+
+static int mountfs_init_fs_context(struct fs_context *fc)
+{
+ fc->ops = &mountfs_context_ops;
+ fc->global = true;
+ return 0;
+}
+
+static struct file_system_type mountfs_fs_type = {
+ .name = "mountfs",
+ .init_fs_context = mountfs_init_fs_context,
+ .kill_sb = kill_anon_super,
+};
+
+static int __init mountfs_init(void)
+{
+ int err;
+
+ err = register_filesystem(&mountfs_fs_type);
+ if (!err) {
+ mountfs_mnt = kern_mount(&mountfs_fs_type);
+ if (IS_ERR(mountfs_mnt)) {
+ err = PTR_ERR(mountfs_mnt);
+ unregister_filesystem(&mountfs_fs_type);
+ }
+ }
+ return err;
+}
+fs_initcall(mountfs_init);
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -943,6 +943,8 @@ struct vfsmount *vfs_create_mount(struct
if (fc->sb_flags & SB_KERNMOUNT)
mnt->mnt.mnt_flags = MNT_INTERNAL;
+ else
+ mountfs_create(mnt);
atomic_inc(&fc->root->d_sb->s_active);
mnt->mnt.mnt_sb = fc->root->d_sb;
@@ -1013,7 +1015,7 @@ vfs_submount(const struct dentry *mountp
}
EXPORT_SYMBOL_GPL(vfs_submount);
-static struct mount *clone_mnt(struct mount *old, struct dentry *root,
+static struct mount *clone_mnt_common(struct mount *old, struct dentry *root,
int flag)
{
struct super_block *sb = old->mnt.mnt_sb;
@@ -1079,6 +1081,17 @@ static struct mount *clone_mnt(struct mo
return ERR_PTR(err);
}
+static struct mount *clone_mnt(struct mount *old, struct dentry *root,
+ int flag)
+{
+ struct mount *mnt = clone_mnt_common(old, root, flag);
+
+ if (!IS_ERR(mnt))
+ mountfs_create(mnt);
+
+ return mnt;
+}
+
static void cleanup_mnt(struct mount *mnt)
{
struct hlist_node *p;
@@ -1091,6 +1104,7 @@ static void cleanup_mnt(struct mount *mn
* so mnt_get_writers() below is safe.
*/
WARN_ON(mnt_get_writers(mnt));
+
if (unlikely(mnt->mnt_pins.first))
mnt_pin_kill(mnt);
hlist_for_each_entry_safe(m, p, &mnt->mnt_stuck_children, mnt_umount) {
@@ -1171,6 +1185,8 @@ static void mntput_no_expire(struct moun
unlock_mount_hash();
shrink_dentry_list(&list);
+ mountfs_remove(mnt);
+
if (likely(!(mnt->mnt.mnt_flags & MNT_INTERNAL))) {
struct task_struct *task = current;
if (likely(!(task->flags & PF_KTHREAD))) {
@@ -1237,13 +1253,14 @@ EXPORT_SYMBOL(path_is_mountpoint);
struct vfsmount *mnt_clone_internal(const struct path *path)
{
struct mount *p;
- p = clone_mnt(real_mount(path->mnt), path->dentry, CL_PRIVATE);
+ p = clone_mnt_common(real_mount(path->mnt), path->dentry, CL_PRIVATE);
if (IS_ERR(p))
return ERR_CAST(p);
p->mnt.mnt_flags |= MNT_INTERNAL;
return &p->mnt;
}
+
#ifdef CONFIG_PROC_FS
/* iterator; we want it to have access to namespace_sem, thus here... */
static void *m_start(struct seq_file *m, loff_t *pos)
@@ -1385,6 +1402,16 @@ static inline void namespace_lock(void)
down_write(&namespace_sem);
}
+void mnt_namespace_lock_read(void)
+{
+ down_read(&namespace_sem);
+}
+
+void mnt_namespace_unlock_read(void)
+{
+ up_read(&namespace_sem);
+}
+
enum umount_tree_flags {
UMOUNT_SYNC = 1,
UMOUNT_PROPAGATE = 2,
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -3092,6 +3092,7 @@ static const struct pid_entry tgid_base_
DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
DIR("map_files", S_IRUSR|S_IXUSR, proc_map_files_inode_operations, proc_map_files_operations),
DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
+ DIR("fdmount", S_IRUSR|S_IXUSR, proc_fdmount_inode_operations, proc_fdmount_operations),
DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
#ifdef CONFIG_NET
DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
@@ -3497,6 +3498,7 @@ static const struct inode_operations pro
static const struct pid_entry tid_base_stuff[] = {
DIR("fd", S_IRUSR|S_IXUSR, proc_fd_inode_operations, proc_fd_operations),
DIR("fdinfo", S_IRUSR|S_IXUSR, proc_fdinfo_inode_operations, proc_fdinfo_operations),
+ DIR("fdmount", S_IRUSR|S_IXUSR, proc_fdmount_inode_operations, proc_fdmount_operations),
DIR("ns", S_IRUSR|S_IXUGO, proc_ns_dir_inode_operations, proc_ns_dir_operations),
#ifdef CONFIG_NET
DIR("net", S_IRUGO|S_IXUGO, proc_net_inode_operations, proc_net_operations),
--- a/fs/proc/fd.c
+++ b/fs/proc/fd.c
@@ -361,3 +361,85 @@ const struct file_operations proc_fdinfo
.iterate_shared = proc_readfdinfo,
.llseek = generic_file_llseek,
};
+
+static int proc_fdmount_link(struct dentry *dentry, struct path *path)
+{
+ struct files_struct *files = NULL;
+ struct task_struct *task;
+ struct path fd_path;
+ int ret = -ENOENT;
+
+ task = get_proc_task(d_inode(dentry));
+ if (task) {
+ files = get_files_struct(task);
+ put_task_struct(task);
+ }
+
+ if (files) {
+ unsigned int fd = proc_fd(d_inode(dentry));
+ struct file *fd_file;
+
+ spin_lock(&files->file_lock);
+ fd_file = fcheck_files(files, fd);
+ if (fd_file) {
+ fd_path = fd_file->f_path;
+ path_get(&fd_path);
+ ret = 0;
+ }
+ spin_unlock(&files->file_lock);
+ put_files_struct(files);
+ }
+ if (!ret) {
+ ret = mountfs_lookup_internal(fd_path.mnt, path);
+ path_put(&fd_path);
+ }
+
+ return ret;
+}
+
+static struct dentry *proc_fdmount_instantiate(struct dentry *dentry,
+ struct task_struct *task, const void *ptr)
+{
+ const struct fd_data *data = ptr;
+ struct proc_inode *ei;
+ struct inode *inode;
+
+ inode = proc_pid_make_inode(dentry->d_sb, task, S_IFLNK | 0400);
+ if (!inode)
+ return ERR_PTR(-ENOENT);
+
+ ei = PROC_I(inode);
+ ei->fd = data->fd;
+
+ inode->i_op = &proc_pid_link_inode_operations;
+ inode->i_size = 64;
+
+ ei->op.proc_get_link = proc_fdmount_link;
+ tid_fd_update_inode(task, inode, 0);
+
+ d_set_d_op(dentry, &tid_fd_dentry_operations);
+ return d_splice_alias(inode, dentry);
+}
+
+static struct dentry *
+proc_lookupfdmount(struct inode *dir, struct dentry *dentry, unsigned int flags)
+{
+ return proc_lookupfd_common(dir, dentry, proc_fdmount_instantiate);
+}
+
+static int proc_readfdmount(struct file *file, struct dir_context *ctx)
+{
+ return proc_readfd_common(file, ctx,
+ proc_fdmount_instantiate);
+}
+
+const struct inode_operations proc_fdmount_inode_operations = {
+ .lookup = proc_lookupfdmount,
+ .setattr = proc_setattr,
+};
+
+const struct file_operations proc_fdmount_operations = {
+ .read = generic_read_dir,
+ .iterate_shared = proc_readfdmount,
+ .llseek = generic_file_llseek,
+};
--- a/fs/proc/fd.h
+++ b/fs/proc/fd.h
@@ -10,6 +10,9 @@ extern const struct inode_operations pro
extern const struct file_operations proc_fdinfo_operations;
extern const struct inode_operations proc_fdinfo_inode_operations;
+extern const struct file_operations proc_fdmount_operations;
+extern const struct inode_operations proc_fdmount_inode_operations;
+
extern int proc_fd_permission(struct inode *inode, int mask);
static inline unsigned int proc_fd(struct inode *inode)
--- a/fs/proc_namespace.c
+++ b/fs/proc_namespace.c
@@ -61,24 +61,6 @@ static int show_sb_opts(struct seq_file
return security_sb_show_options(m, sb);
}
-static void show_mnt_opts(struct seq_file *m, struct vfsmount *mnt)
-{
- static const struct proc_fs_info mnt_info[] = {
- { MNT_NOSUID, ",nosuid" },
- { MNT_NODEV, ",nodev" },
- { MNT_NOEXEC, ",noexec" },
- { MNT_NOATIME, ",noatime" },
- { MNT_NODIRATIME, ",nodiratime" },
- { MNT_RELATIME, ",relatime" },
- { 0, NULL }
- };
- const struct proc_fs_info *fs_infop;
-
- for (fs_infop = mnt_info; fs_infop->flag; fs_infop++) {
- if (mnt->mnt_flags & fs_infop->flag)
- seq_puts(m, fs_infop->str);
- }
-}
static inline void mangle(struct seq_file *m, const char *s)
{
@@ -120,7 +102,7 @@ static int show_vfsmnt(struct seq_file *
err = show_sb_opts(m, sb);
if (err)
goto out;
- show_mnt_opts(m, mnt);
+ seq_mnt_opts(m, mnt->mnt_flags);
if (sb->s_op->show_options)
err = sb->s_op->show_options(m, mnt_path.dentry);
seq_puts(m, " 0 0\n");
@@ -153,7 +135,7 @@ static int show_mountinfo(struct seq_fil
goto out;
seq_puts(m, mnt->mnt_flags & MNT_READONLY ? " ro" : " rw");
- show_mnt_opts(m, mnt);
+ seq_mnt_opts(m, mnt->mnt_flags);
/* Tagged fields ("foo:X" or "bar") */
if (IS_MNT_SHARED(r))
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -15,6 +15,7 @@
#include <linux/cred.h>
#include <linux/mm.h>
#include <linux/printk.h>
+#include <linux/mount.h>
#include <linux/string_helpers.h>
#include <linux/uaccess.h>
@@ -548,6 +549,28 @@ int seq_dentry(struct seq_file *m, struc
}
EXPORT_SYMBOL(seq_dentry);
+void seq_mnt_opts(struct seq_file *m, int mnt_flags)
+{
+ unsigned int i;
+ static const struct {
+ int flag;
+ const char *str;
+ } mnt_info[] = {
+ { MNT_NOSUID, ",nosuid" },
+ { MNT_NODEV, ",nodev" },
+ { MNT_NOEXEC, ",noexec" },
+ { MNT_NOATIME, ",noatime" },
+ { MNT_NODIRATIME, ",nodiratime" },
+ { MNT_RELATIME, ",relatime" },
+ { 0, NULL }
+ };
+
+ for (i = 0; mnt_info[i].flag; i++) {
+ if (mnt_flags & mnt_info[i].flag)
+ seq_puts(m, mnt_info[i].str);
+ }
+}
+
static void *single_start(struct seq_file *p, loff_t *pos)
{
return NULL + (*pos == 0);
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -138,6 +138,7 @@ int seq_file_path(struct seq_file *, str
int seq_dentry(struct seq_file *, struct dentry *, const char *);
int seq_path_root(struct seq_file *m, const struct path *path,
const struct path *root, const char *esc);
+void seq_mnt_opts(struct seq_file *m, int mnt_flags);
int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
int single_open_size(struct file *, int (*)(struct seq_file *, void *), void *, size_t);
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: Andres Freund @ 2020-03-09 19:22 UTC (permalink / raw)
To: Jeff Layton
Cc: David Howells, torvalds, viro, Theodore Ts'o,
Stefan Metzmacher, Andreas Dilger, linux-ext4, Aleksa Sarai,
Trond Myklebust, Anna Schumaker, linux-nfs, linux-api, raven,
mszeredi, christian, jannh, darrick.wong, kzak, linux-fsdevel,
linux-security-module, linux-kernel
In-Reply-To: <2d31e2658e5f6651dc7d9908c4c12b6ba461fc88.camel@redhat.com>
Hi,
On 2020-03-09 13:50:59 -0400, Jeff Layton wrote:
> The PostgreSQL devs asked a while back for some way to tell whether
> there have been any writeback errors on a superblock w/o having to do
> any sort of flush -- just "have there been any so far".
Indeed.
> I sent a patch a few weeks ago to make syncfs() return errors when there
> have been writeback errors on the superblock. It's not merged yet, but
> once we have something like that in place, we could expose info from the
> errseq_t to userland using this interface.
I'm still a bit worried about the details of errseq_t being exposed to
userland. Partially because it seems to restrict further evolution of
errseq_t, and partially because it will likely up with userland trying
to understand it (it's e.g. just too attractive to report a count of
errors etc).
Is there a reason to not instead report a 64bit counter instead of the
cookie? In contrast to the struct file case we'd only have the space
overhead once per superblock, rather than once per #files * #fd. And it
seems that the maintenance of that counter could be done without
widespread changes, e.g. instead/in addition to your change:
> diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
> index ccb14b6a16b5..897439475315 100644
> --- a/include/linux/pagemap.h
> +++ b/include/linux/pagemap.h
> @@ -51,7 +51,10 @@ static inline void mapping_set_error(struct address_space *mapping, int error)
> return;
>
> /* Record in wb_err for checkers using errseq_t based tracking */
> - filemap_set_wb_err(mapping, error);
> + __filemap_set_wb_err(mapping, error);
> +
> + /* Record it in superblock */
> + errseq_set(&mapping->host->i_sb->s_wb_err, error);
>
> /* Record it in flags for now, for legacy callers */
> if (error == -ENOSPC)
Btw, seems like mapping_set_error() should have a non-inline cold path?
Greetings,
Andres Freund
^ permalink raw reply
* Re: [PATCH 00/14] VFS: Filesystem information [ver #18]
From: Jeff Layton @ 2020-03-09 17:50 UTC (permalink / raw)
To: David Howells, torvalds, viro
Cc: Theodore Ts'o, Stefan Metzmacher, Andreas Dilger, linux-ext4,
Aleksa Sarai, Trond Myklebust, Anna Schumaker, linux-nfs,
linux-api, raven, mszeredi, christian, jannh, darrick.wong, kzak,
linux-fsdevel, linux-security-module, linux-kernel, Andres Freund
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
On Mon, 2020-03-09 at 14:00 +0000, David Howells wrote:
> Here's a set of patches that adds a system call, fsinfo(), that allows
> information about the VFS, mount topology, superblock and files to be
> retrieved.
>
> The patchset is based on top of the notifications patchset and allows event
> counters implemented in the latter to be retrieved to allow overruns to be
> efficiently managed.
>
> Included are a couple of sample programs plus limited example code for NFS
> and Ext4. The example code is not intended to go upstream as-is.
>
>
> =======
> THE WHY
> =======
>
> Why do we want this?
>
> Using /proc/mounts (or similar) has problems:
>
> (1) Reading from it holds a global lock (namespace_sem) that prevents
> mounting and unmounting. Lots of data is encoded and mangled into
> text whilst the lock is held, including superblock option strings and
> mount point paths. This causes performance problems when there are a
> lot of mount objects in a system.
>
> (2) Even though namespace_sem is held during a read, reading the whole
> file isn't necessarily atomic with respect to mount-type operations.
> If a read isn't satisfied in one go, then it may return to userspace
> briefly and then continue reading some way into the file. But changes
> can occur in the interval that may then go unseen.
>
> (3) Determining what has changed means parsing and comparing consecutive
> outputs of /proc/mounts.
>
> (4) Querying a specific mount or superblock means searching through
> /proc/mounts and searching by path or mount ID - but we might have an
> fd we want to query.
>
> (5) Mount topology is not explicit. One must derive it manually by
> comparing entries.
>
> (6) Whilst you can poll() it for events, it only tells you that something
> changed in the namespace, not what or whether you can even see the
> change.
>
> To fix the notification issues, the preceding notifications patchset added
> mount watch notifications whereby you can watch for notifications in a
> specific mount subtree. The notification messages include the ID(s) of the
> affected mounts.
>
> To support notifications, however, we need to be able to handle overruns in
> the notification queue. I added a number of event counters to struct
> super_block and struct mount to allow you to pin down the changes, but
> there needs to be a way to retrieve them. Exposing them through /proc
> would require adding yet another /proc/mounts-type file. We could add
> per-mount directories full of attributes in sysfs, but that has issues also
> (see below).
>
> Adding an extensible system call interface for retrieving filesystem
> information also allows other things to be exposed:
>
> (1) Jeff Layton's error handling changes need a way to allow error event
> information to be retrieved.
>
> (2) Bits in masks returned by things like statx() and FS_IOC_GETFLAGS are
> actually 3-state { Set, Unset, Not supported }. It could be useful to
> provide a way to expose information like this[*].
>
> (3) Limits of the numerical metadata values in a filesystem[*].
>
> (4) Filesystem capability information[*]. Filesystems don't all have the
> same capabilities, and even different instances may have different
> capabilities, particularly with network filesystems where the set of
> may be server-dependent. Capabilities might even vary at file
> granularity - though possibly such information should be conveyed
> through statx() instead.
>
> (5) ID mapping/shifting tables in use for a superblock.
>
> (6) Filesystem-specific information. I need something for AFS so that I
> can do pioctl()-emulation, thereby allowing me to implement certain of
> the AFS command line utilities that query state of a particular file.
> This could also have application for other filesystems, such as NFS,
> CIFS and ext4.
>
> [*] In a lot of cases these are probably fixed and can be memcpy'd from
> static data.
>
> There's a further consideration: I want to make it possible to have
> fsconfig(fd, FSCONFIG_CMD_CREATE) be intercepted by a container manager
> such that the manager can supervise a mount attempted inside the container.
> The manager would be given an fd pointing to the fs_context struct and
> would then need some way to query it (fsinfo()) and modify it (fsconfig()).
> This could also be used to arbitrate user-requested mounts when containers
> are not in play.
>
>
> ============================
> WHY NOT USE PROCFS OR SYSFS?
> ============================
>
> Why is it better to go with a new system call rather than adding more magic
> stuff to /proc or /sysfs for each superblock object and each mount object?
>
> (1) It can be targetted. It makes it easy to query directly by path or
> fd, but can also query by mount ID or fscontext fd. procfs and sysfs
> cannot do three of these things easily.
>
> (2) Easier to provide LSM oversight. Is the accessing process allowed to
> query information pertinent to a particular file?
>
> (3) It's more efficient as we can return specific binary data rather than
> making huge text dumps. Granted, sysfs and procfs could present the
> same data, though as lots of little files which have to be
> individually opened, read, closed and parsed.
>
> (4) We wouldn't have the overhead of open and close (even adding a
> self-contained readfile() syscall has to do that internally).
>
> (5) Opening a file in procfs or sysfs has a pathwalk overhead for each
> file accessed. We can use an integer attribute ID instead (yes, this
> is similar to ioctl) - but could also use a string ID if that is
> preferred.
>
> (6) Can query cross-namespace if, say, a container manager process is
> given an fs_context that hasn't yet been mounted into a namespace - or
> hasn't even been fully created yet.
>
> (7) Don't have to create/delete a bunch of sysfs/procfs nodes each time a
> mount happens or is removed - and since systemd makes much use of
> mount namespaces and mount propagation, this will create a lot of
> nodes.
>
>
> ================
> DESIGN DECISIONS
> ================
>
> (1) Information is partitioned into sets of attributes.
>
> (2) Attribute IDs are integers as they're fast to compare.
>
> (3) Attribute values are typed (struct, list of structs, string, opaque
> blob). They type is fixed for a particular attribute.
>
> (4) For structure types, the length is also a version. New fields can be
> tacked onto the end.
>
> (5) When copying a versioned struct to userspace, the core handles a
> version mismatch by truncating or zero-padding the data as necessary.
> None of this is seen by the filesystem.
>
> (6) The core handles all the buffering and buffer resizing.
>
> (7) The filesystem never gets any access to the userspace parameter buffer
> or result buffer.
>
> (8) "Meta" attributes can describe other attributes.
>
>
> ========
> OVERVIEW
> ========
>
> fsinfo() is a system call that allows information about the filesystem at a
> particular path point to be queried as a set of attributes.
>
> Attribute values are of four basic types:
>
> (1) Structure with version-dependent length (the length is the version).
>
> (2) Variable-length string.
>
> (3) List of structures (all the same length).
>
> (4) Opaque blob.
>
> Attributes can have multiple values either as a sequence of values or a
> sequence-of-sequences of values and all the values of a particular
> attribute must be of the same type. Values can be up to INT_MAX size,
> subject to memory availability.
>
> Note that the values of an attribute *are* allowed to vary between dentries
> within a single superblock, depending on the specific dentry that you're
> looking at, but the values still have to be of the type for that attribute.
>
> I've tried to make the interface as light as possible, so integer attribute
> ID rather than string and the core does all the buffer allocation and
> expansion and all the extensibility support work rather than leaving that
> to the filesystems. This means that userspace pointers are not exposed to
> the filesystem.
>
>
> fsinfo() allows a variety of information to be retrieved about a filesystem
> and the mount topology:
>
> (1) General superblock attributes:
>
> - Filesystem identifiers (UUID, volume label, device numbers, ...)
> - The limits on a filesystem's capabilities
> - Information on supported statx fields and attributes and IOC flags.
> - A variety single-bit flags indicating supported capabilities.
> - Timestamp resolution and range.
> - The amount of space/free space in a filesystem (as statfs()).
> - Superblock notification counter.
>
> (2) Filesystem-specific superblock attributes:
>
> - Superblock-level timestamps.
> - Cell name, workgroup or other netfs grouping concept.
> - Server names and addresses.
>
> (3) VFS information:
>
> - Mount topology information.
> - Mount attributes.
> - Mount notification counter.
> - Mount point path.
>
> (4) Information about what the fsinfo() syscall itself supports, including
> the type and struct size of attributes.
>
> The system is extensible:
>
> (1) New attributes can be added. There is no requirement that a
> filesystem implement every attribute. A helper function is provided
> to scan a list of attributes and a filesystem can have multiple such
> lists.
>
> (2) Version length-dependent structure attributes can be made larger and
> have additional information tacked on the end, provided it keeps the
> layout of the existing fields. If an older process asks for a shorter
> structure, it will only be given the bits it asks for. If a newer
> process asks for a longer structure on an older kernel, the extra
> space will be set to 0. In all cases, the size of the data actually
> available is returned.
>
> In essence, the size of a structure is that structure's version: a
> smaller size is an earlier version and a later version includes
> everything that the earlier version did.
>
> (3) New single-bit capability flags can be added. This is a structure-typed
> attribute and, as such, (2) applies. Any bits you wanted but the kernel
> doesn't support are automatically set to 0.
>
> fsinfo() may be called like the following, for example:
>
> struct fsinfo_params params = {
> .resolve_flags = RESOLVE_NO_TRAILING_SYMLINKS,
> .flags = FSINFO_FLAGS_QUERY_PATH,
> .request = FSINFO_ATTR_AFS_SERVER_ADDRESSES,
> .Nth = 2,
> };
> struct fsinfo_server_address address;
> len = fsinfo(AT_FDCWD, "/afs/grand.central.org/doc", ¶ms,
> &address, sizeof(address));
>
> The above example would query an AFS filesystem to retrieve the address
> list for the 3rd server, and:
>
> struct fsinfo_params params = {
> .resolve_flags = RESOLVE_NO_TRAILING_SYMLINKS,
> .flags = FSINFO_FLAGS_QUERY_PATH,
> .request = FSINFO_ATTR_NFS_SERVER_NAME;
> };
> char server_name[256];
> len = fsinfo(AT_FDCWD, "/home/dhowells/", ¶ms,
> &server_name, sizeof(server_name));
>
> would retrieve the name of the NFS server as a string.
>
> In future, I want to make fsinfo() capable of querying a context created by
> fsopen() or fspick(), e.g.:
>
> fd = fsopen("ext4", 0);
> struct fsinfo_params params = {
> .flags = FSINFO_FLAGS_QUERY_FSCONTEXT,
> .request = FSINFO_ATTR_CONFIGURATION;
> };
> char buffer[65536];
> fsinfo(fd, NULL, ¶ms, &buffer, sizeof(buffer));
>
> even if that context doesn't currently have a superblock attached.
>
> The patches can be found here also:
>
> https://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs.git
>
> on branch:
>
> fsinfo-core
>
>
> ===================
> SIGNIFICANT CHANGES
> ===================
>
> ver #18:
>
> (*) Moved the mount and superblock notification patches into a different
> branch.
>
> (*) Made superblock configuration (->show_opts), bindmount path
> (->show_path) and filesystem statistics (->show_stats) available as
> the CONFIGURATION, MOUNT_PATH and FS_STATISTICS attributes.
>
> (*) Made mountpoint device name available, filtered through the superblock
> (->show_devname), as the SOURCE attribute.
>
> (*) Made the mountpoint available as a full path as well as a relative
> one.
>
> (*) Added more event counters to MOUNT_INFO, including a subtree
> notification counter, to make it easier to clean up after a
> notification overrun.
>
> (*) Made the event counter value returned by MOUNT_CHILDREN the sum of the
> five event counters.
>
> (*) Added a mount uniquifier and added that to the MOUNT_CHILDREN entries
> also so that mount ID reuse can be detected.
>
> (*) Merged the SB_NOTIFICATION attribute into the MOUNT_INFO attribute to
> avoid duplicate information.
>
> (*) Switched to using the RESOLVE_* flags rather than AT_* flags for
> pathwalk control. Added more RESOLVE_* flags.
>
> (*) Used a lock instead of RCU to enumerate children for the
> MOUNT_CHILDREN attribute for safety. This is probably worth
> revisiting at a later date, however.
>
>
> ver #17:
>
> (*) Applied comments from Jann Horn, Darrick Wong and Christian Brauner.
>
> (*) Rearranged the order in which fsinfo() does things so that the
> superblock operations table can have a function pointer rather than a
> table pointer. The ->fsinfo() op is now called at least twice, once
> to determine the size of buffer needed and then to retrieve the data.
> If the retrieval step indicates yet more space is needed, the buffer
> will be expanded and that step repeated.
>
> (*) Merge the element size into the size in the fsinfo_attribute def and
> don't set size for strings or opaques. Let a helper work that out.
> This means that strings can actually get larger then 4K.
>
> (*) A helper is provided to scan a list of attributes and call the
> appropriate get function. This can be called from a filesystem's
> ->fsinfo() method multiple times. It also handles attribute
> enumeration and info querying.
>
> (*) Rearranged the patches to put all the notification patches first.
> This allowed some of the bits to be squashed together. At some point,
> I'll move the notification patches into a different branch.
>
> ver #16:
>
> (*) Split the features bits out of the fsinfo() core into their own patch
> and got rid of the name encoding attributes.
>
> (*) Renamed the 'array' type to 'list' and made AFS use it for returning
> server address lists.
>
> (*) Changed the ->fsinfo() method into an ->fsinfo_attributes[] table,
> where each attribute has a ->get() method to deal with it. These
> tables can then be returned with an fsinfo meta attribute.
>
> (*) Dropped the fscontext query and parameter/description retrieval
> attributes for now.
>
> (*) Picked the mount topology attributes into this branch.
>
> (*) Picked the mount notifications into this branch and rebased on top of
> notifications-pipe-core.
>
> (*) Picked the superblock notifications into this branch.
>
> (*) Add sample code for Ext4 and NFS.
>
> David
> ---
> David Howells (14):
> VFS: Add additional RESOLVE_* flags
> fsinfo: Add fsinfo() syscall to query filesystem information
> fsinfo: Provide a bitmap of supported features
> fsinfo: Allow retrieval of superblock devname, options and stats
> fsinfo: Allow fsinfo() to look up a mount object by ID
> fsinfo: Add a uniquifier ID to struct mount
> fsinfo: Allow mount information to be queried
> fsinfo: Allow the mount topology propogation flags to be retrieved
> fsinfo: Provide notification overrun handling support
> fsinfo: sample: Mount listing program
> fsinfo: Add API documentation
> fsinfo: Add support for AFS
> fsinfo: Example support for Ext4
> fsinfo: Example support for NFS
>
>
> Documentation/filesystems/fsinfo.rst | 564 +++++++++++++++++
> arch/alpha/kernel/syscalls/syscall.tbl | 1
> arch/arm/tools/syscall.tbl | 1
> arch/arm64/include/asm/unistd.h | 2
> arch/ia64/kernel/syscalls/syscall.tbl | 1
> arch/m68k/kernel/syscalls/syscall.tbl | 1
> arch/microblaze/kernel/syscalls/syscall.tbl | 1
> arch/mips/kernel/syscalls/syscall_n32.tbl | 1
> arch/mips/kernel/syscalls/syscall_n64.tbl | 1
> arch/mips/kernel/syscalls/syscall_o32.tbl | 1
> arch/parisc/kernel/syscalls/syscall.tbl | 1
> arch/powerpc/kernel/syscalls/syscall.tbl | 1
> arch/s390/kernel/syscalls/syscall.tbl | 1
> arch/sh/kernel/syscalls/syscall.tbl | 1
> arch/sparc/kernel/syscalls/syscall.tbl | 1
> arch/x86/entry/syscalls/syscall_32.tbl | 1
> arch/x86/entry/syscalls/syscall_64.tbl | 1
> arch/xtensa/kernel/syscalls/syscall.tbl | 1
> fs/Kconfig | 7
> fs/Makefile | 1
> fs/afs/internal.h | 1
> fs/afs/super.c | 218 +++++++
> fs/d_path.c | 2
> fs/ext4/Makefile | 1
> fs/ext4/ext4.h | 6
> fs/ext4/fsinfo.c | 45 +
> fs/ext4/super.c | 3
> fs/fsinfo.c | 720 ++++++++++++++++++++++
> fs/internal.h | 13
> fs/mount.h | 3
> fs/namespace.c | 362 +++++++++++
> fs/nfs/Makefile | 1
> fs/nfs/fsinfo.c | 230 +++++++
> fs/nfs/internal.h | 6
> fs/nfs/nfs4super.c | 3
> fs/nfs/super.c | 3
> fs/open.c | 8
> include/linux/fcntl.h | 3
> include/linux/fs.h | 4
> include/linux/fsinfo.h | 111 +++
> include/linux/syscalls.h | 4
> include/uapi/asm-generic/unistd.h | 4
> include/uapi/linux/fsinfo.h | 360 +++++++++++
> include/uapi/linux/mount.h | 10
> include/uapi/linux/openat2.h | 8
> include/uapi/linux/windows.h | 35 +
> kernel/sys_ni.c | 1
> samples/vfs/Makefile | 7
> samples/vfs/test-fsinfo.c | 880 +++++++++++++++++++++++++++
> samples/vfs/test-mntinfo.c | 277 ++++++++
> 50 files changed, 3905 insertions(+), 14 deletions(-)
> create mode 100644 Documentation/filesystems/fsinfo.rst
> create mode 100644 fs/ext4/fsinfo.c
> create mode 100644 fs/fsinfo.c
> create mode 100644 fs/nfs/fsinfo.c
> create mode 100644 include/linux/fsinfo.h
> create mode 100644 include/uapi/linux/fsinfo.h
> create mode 100644 include/uapi/linux/windows.h
> create mode 100644 samples/vfs/test-fsinfo.c
> create mode 100644 samples/vfs/test-mntinfo.c
>
>
The PostgreSQL devs asked a while back for some way to tell whether
there have been any writeback errors on a superblock w/o having to do
any sort of flush -- just "have there been any so far".
I sent a patch a few weeks ago to make syncfs() return errors when there
have been writeback errors on the superblock. It's not merged yet, but
once we have something like that in place, we could expose info from the
errseq_t to userland using this interface.
Something like this patch would do it (which depends on a few others in
my tree, nothing very large though):
---------------------------8<-----------------------
[PATCH] vfs: allow fsinfo to fetch the current state of s_wb_err
Add a new "error_state" struct to fsinfo, and teach the kernel to fill
that out from sb->s_wb_info. There are two fields:
wb_error_last: the most recently recorded errno for the filesystem
wb_error_cookie: this value will change vs. the previously fetched
value if a new error was recorded since it was last
checked. Callers should treat this as an opaque value
that can be compared to earlier fetched values.
Signed-off-by: Jeff Layton <jlayton@redhat.com>
---
fs/fsinfo.c | 11 +++++++++++
include/uapi/linux/fsinfo.h | 13 +++++++++++++
2 files changed, 24 insertions(+)
diff --git a/fs/fsinfo.c b/fs/fsinfo.c
index 6d2bc03998e4..3bbe6d7b1a79 100644
--- a/fs/fsinfo.c
+++ b/fs/fsinfo.c
@@ -275,6 +275,7 @@ static const struct fsinfo_attribute fsinfo_common_attributes[] = {
FSINFO_STRING (FSINFO_ATTR_SOURCE, fsinfo_generic_mount_source),
FSINFO_STRING (FSINFO_ATTR_CONFIGURATION, fsinfo_generic_seq_read),
FSINFO_STRING (FSINFO_ATTR_FS_STATISTICS, fsinfo_generic_seq_read),
+ FSINFO_VSTRUCT (FSINFO_ATTR_ERROR_STATE, fsinfo_generic_error_state),
FSINFO_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, (void *)123UL),
FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, (void *)123UL),
@@ -376,6 +377,16 @@ static int fsinfo_get_attribute_info(struct path *path,
return -EOPNOTSUPP; /* We want to go through all the lists */
}
+static int fsinfo_generic_error_state(struct path *path,
+ struct fsinfo_context *ctx)
+{
+ struct fsinfo_error_state *es = ctx->buffer;
+
+ es->wb_error_cookie = errseq_scrape(&path->dentry->d_sb->s_wb_err);
+ es->wb_error_last = es->wb_error_cookie & MAX_ERRNO;
+ return sizeof(*es);
+}
+
/**
* fsinfo_get_attribute - Look up and handle an attribute
* @path: The object to query
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index 346cf0cf42cb..3d33744c2320 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -27,6 +27,7 @@
#define FSINFO_ATTR_SOURCE 0x09 /* Superblock source/device name (string) */
#define FSINFO_ATTR_CONFIGURATION 0x0a /* Superblock configuration/options (string) */
#define FSINFO_ATTR_FS_STATISTICS 0x0b /* Superblock filesystem statistics (string) */
+#define FSINFO_ATTR_ERROR_STATE 0x0c /* errseq_t state */
#define FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO 0x100 /* Information about attr N (for path) */
#define FSINFO_ATTR_FSINFO_ATTRIBUTES 0x101 /* List of supported attrs (for path) */
@@ -357,4 +358,16 @@ struct fsinfo_nfs_server_address {
#define FSINFO_ATTR_NFS_SERVER_ADDRESSES__STRUCT struct fsinfo_nfs_server_address
+/*
+ * Information struct for fsinfo(FSINFO_ATTR_ERROR_STATE).
+ *
+ * Retrieve the error state for a filesystem.
+ */
+struct fsinfo_error_state {
+ __u32 wb_error_cookie; /* writeback error cookie */
+ __u32 wb_error_last; /* latest writeback error */
+};
+
+#define FSINFO_ATTR_ERROR_STATE__STRUCT struct fsinfo_error_state
+
#endif /* _UAPI_LINUX_FSINFO_H */
--
2.24.1
^ permalink raw reply related
* Re: [PATCH v2 2/2] KEYS: Avoid false positive ENOMEM error on key read
From: David Howells @ 2020-03-09 16:32 UTC (permalink / raw)
To: Waiman Long
Cc: dhowells, Jarkko Sakkinen, James Morris, Serge E. Hallyn,
Mimi Zohar, keyrings, linux-kernel, linux-security-module,
linux-integrity, Sumit Garg, Jerry Snitselaar, Roberto Sassu,
Eric Biggers, Chris von Recklinghausen
In-Reply-To: <20200308170410.14166-3-longman@redhat.com>
Waiman Long <longman@redhat.com> wrote:
> + tmpbuf = kmalloc(tbuflen, GFP_KERNEL);
This would probably be better off using kvmalloc() - otherwise big objects
have to be constructed from runs of contiguous pages. But since all we're
doing is buffering for userspace, we don't care about that.
If you agree, we can address it with an additional patch.
David
^ permalink raw reply
* [PATCH 14/14] fsinfo: Example support for NFS [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: Trond Myklebust, Anna Schumaker, linux-nfs, dhowells, raven,
mszeredi, christian, jannh, darrick.wong, kzak, jlayton,
linux-api, linux-fsdevel, linux-security-module, linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Add the ability to list NFS server addresses and hostname, timestamp
information and capabilities as an example.
Is this useful for export from NFS? Is there anything else that would be
useful?
Signed-off-by: David Howells <dhowells@redhat.com>
cc: Trond Myklebust <trond.myklebust@hammerspace.com>
cc: Anna Schumaker <anna.schumaker@netapp.com>
cc: linux-nfs@vger.kernel.org
---
fs/nfs/Makefile | 1
fs/nfs/fsinfo.c | 230 ++++++++++++++++++++++++++++++++++++++++++
fs/nfs/internal.h | 6 +
fs/nfs/nfs4super.c | 3 +
fs/nfs/super.c | 3 +
include/uapi/linux/fsinfo.h | 29 +++++
include/uapi/linux/windows.h | 35 ++++++
samples/vfs/test-fsinfo.c | 38 +++++++
8 files changed, 345 insertions(+)
create mode 100644 fs/nfs/fsinfo.c
create mode 100644 include/uapi/linux/windows.h
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index 2433c3e03cfa..20fbc9596833 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -13,6 +13,7 @@ nfs-y := client.o dir.o file.o getroot.o inode.o super.o \
nfs-$(CONFIG_ROOT_NFS) += nfsroot.o
nfs-$(CONFIG_SYSCTL) += sysctl.o
nfs-$(CONFIG_NFS_FSCACHE) += fscache.o fscache-index.o
+nfs-$(CONFIG_FSINFO) += fsinfo.o
obj-$(CONFIG_NFS_V2) += nfsv2.o
nfsv2-y := nfs2super.o proc.o nfs2xdr.o
diff --git a/fs/nfs/fsinfo.c b/fs/nfs/fsinfo.c
new file mode 100644
index 000000000000..a0299ec27efd
--- /dev/null
+++ b/fs/nfs/fsinfo.c
@@ -0,0 +1,230 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Filesystem information for NFS
+ *
+ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#include <linux/nfs_fs.h>
+#include <linux/windows.h>
+#include "internal.h"
+
+static const struct fsinfo_timestamp_info nfs_timestamp_info = {
+ .atime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .mtime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .ctime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .btime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+};
+
+static int nfs_fsinfo_get_timestamp_info(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ struct fsinfo_timestamp_info *r = ctx->buffer;
+ unsigned long long nsec;
+ unsigned int rem, mant;
+ int exp = -9;
+
+ *r = nfs_timestamp_info;
+
+ nsec = server->time_delta.tv_nsec;
+ nsec += server->time_delta.tv_sec * 1000000000ULL;
+ if (nsec == 0)
+ goto out;
+
+ do {
+ mant = nsec;
+ rem = do_div(nsec, 10);
+ if (rem)
+ break;
+ exp++;
+ } while (nsec);
+
+ r->atime.gran_mantissa = mant;
+ r->atime.gran_exponent = exp;
+ r->btime.gran_mantissa = mant;
+ r->btime.gran_exponent = exp;
+ r->ctime.gran_mantissa = mant;
+ r->ctime.gran_exponent = exp;
+ r->mtime.gran_mantissa = mant;
+ r->mtime.gran_exponent = exp;
+
+out:
+ return sizeof(*r);
+}
+
+static int nfs_fsinfo_get_info(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ const struct nfs_client *clp = server->nfs_client;
+ struct fsinfo_nfs_info *r = ctx->buffer;
+
+ r->version = clp->rpc_ops->version;
+ r->minor_version = clp->cl_minorversion;
+ r->transport_proto = clp->cl_proto;
+ return sizeof(*r);
+}
+
+static int nfs_fsinfo_get_server_name(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ const struct nfs_client *clp = server->nfs_client;
+
+ return fsinfo_string(clp->cl_hostname, ctx);
+}
+
+static int nfs_fsinfo_get_server_addresses(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ const struct nfs_client *clp = server->nfs_client;
+ struct fsinfo_nfs_server_address *addr = ctx->buffer;
+ int ret;
+
+ ret = 1 * sizeof(*addr);
+ if (ret <= ctx->buf_size)
+ memcpy(&addr[0].address, &clp->cl_addr, clp->cl_addrlen);
+ return ret;
+
+}
+
+static int nfs_fsinfo_get_gssapi_name(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ const struct nfs_client *clp = server->nfs_client;
+
+ return fsinfo_string(clp->cl_acceptor, ctx);
+}
+
+static int nfs_fsinfo_get_limits(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ struct fsinfo_limits *lim = ctx->buffer;
+
+ lim->max_file_size.hi = 0;
+ lim->max_file_size.lo = server->maxfilesize;
+ lim->max_ino.hi = 0;
+ lim->max_ino.lo = U64_MAX;
+ lim->max_hard_links = UINT_MAX;
+ lim->max_uid = UINT_MAX;
+ lim->max_gid = UINT_MAX;
+ lim->max_filename_len = NAME_MAX - 1;
+ lim->max_symlink_len = PATH_MAX - 1;
+ return sizeof(*lim);
+}
+
+static int nfs_fsinfo_get_supports(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ struct fsinfo_supports *sup = ctx->buffer;
+
+ /* Don't set STATX_INO as i_ino is fabricated and may not be unique. */
+
+ if (!(server->caps & NFS_CAP_MODE))
+ sup->stx_mask |= STATX_TYPE | STATX_MODE;
+ if (server->caps & NFS_CAP_OWNER)
+ sup->stx_mask |= STATX_UID;
+ if (server->caps & NFS_CAP_OWNER_GROUP)
+ sup->stx_mask |= STATX_GID;
+ if (server->caps & NFS_CAP_ATIME)
+ sup->stx_mask |= STATX_ATIME;
+ if (server->caps & NFS_CAP_CTIME)
+ sup->stx_mask |= STATX_CTIME;
+ if (server->caps & NFS_CAP_MTIME)
+ sup->stx_mask |= STATX_MTIME;
+ if (server->attr_bitmask[0] & FATTR4_WORD0_SIZE)
+ sup->stx_mask |= STATX_SIZE;
+ if (server->attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
+ sup->stx_mask |= STATX_NLINK;
+
+ if (server->attr_bitmask[0] & FATTR4_WORD0_ARCHIVE)
+ sup->win_file_attrs |= ATTR_ARCHIVE;
+ if (server->attr_bitmask[0] & FATTR4_WORD0_HIDDEN)
+ sup->win_file_attrs |= ATTR_HIDDEN;
+ if (server->attr_bitmask[1] & FATTR4_WORD1_SYSTEM)
+ sup->win_file_attrs |= ATTR_SYSTEM;
+
+ sup->stx_attributes = STATX_ATTR_AUTOMOUNT;
+ return sizeof(*sup);
+}
+
+static int nfs_fsinfo_get_features(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct nfs_server *server = NFS_SB(path->dentry->d_sb);
+ struct fsinfo_features *ft = ctx->buffer;
+
+ fsinfo_set_feature(ft, FSINFO_FEAT_IS_NETWORK_FS);
+ fsinfo_set_feature(ft, FSINFO_FEAT_AUTOMOUNTS);
+ fsinfo_set_feature(ft, FSINFO_FEAT_O_SYNC);
+ fsinfo_set_feature(ft, FSINFO_FEAT_O_DIRECT);
+ fsinfo_set_feature(ft, FSINFO_FEAT_ADV_LOCKS);
+ fsinfo_set_feature(ft, FSINFO_FEAT_DEVICE_FILES);
+ fsinfo_set_feature(ft, FSINFO_FEAT_UNIX_SPECIALS);
+ if (server->nfs_client->rpc_ops->version == 4) {
+ fsinfo_set_feature(ft, FSINFO_FEAT_LEASES);
+ fsinfo_set_feature(ft, FSINFO_FEAT_IVER_ALL_CHANGE);
+ }
+
+ if (server->caps & NFS_CAP_OWNER)
+ fsinfo_set_feature(ft, FSINFO_FEAT_UIDS);
+ if (server->caps & NFS_CAP_OWNER_GROUP)
+ fsinfo_set_feature(ft, FSINFO_FEAT_GIDS);
+ if (!(server->caps & NFS_CAP_MODE))
+ fsinfo_set_feature(ft, FSINFO_FEAT_NO_UNIX_MODE);
+ if (server->caps & NFS_CAP_ACLS)
+ fsinfo_set_feature(ft, FSINFO_FEAT_HAS_ACL);
+ if (server->caps & NFS_CAP_SYMLINKS)
+ fsinfo_set_feature(ft, FSINFO_FEAT_SYMLINKS);
+ if (server->caps & NFS_CAP_HARDLINKS)
+ fsinfo_set_feature(ft, FSINFO_FEAT_HARD_LINKS);
+ if (server->caps & NFS_CAP_ATIME)
+ fsinfo_set_feature(ft, FSINFO_FEAT_HAS_ATIME);
+ if (server->caps & NFS_CAP_CTIME)
+ fsinfo_set_feature(ft, FSINFO_FEAT_HAS_CTIME);
+ if (server->caps & NFS_CAP_MTIME)
+ fsinfo_set_feature(ft, FSINFO_FEAT_HAS_MTIME);
+
+ if (server->attr_bitmask[0] & FATTR4_WORD0_CASE_INSENSITIVE)
+ fsinfo_set_feature(ft, FSINFO_FEAT_NAME_CASE_INDEP);
+ if ((server->attr_bitmask[0] & FATTR4_WORD0_ARCHIVE) ||
+ (server->attr_bitmask[0] & FATTR4_WORD0_HIDDEN) ||
+ (server->attr_bitmask[1] & FATTR4_WORD1_SYSTEM))
+ fsinfo_set_feature(ft, FSINFO_FEAT_WINDOWS_ATTRS);
+
+ return sizeof(*ft);
+}
+
+static const struct fsinfo_attribute nfs_fsinfo_attributes[] = {
+ FSINFO_VSTRUCT (FSINFO_ATTR_TIMESTAMP_INFO, nfs_fsinfo_get_timestamp_info),
+ FSINFO_VSTRUCT (FSINFO_ATTR_LIMITS, nfs_fsinfo_get_limits),
+ FSINFO_VSTRUCT (FSINFO_ATTR_SUPPORTS, nfs_fsinfo_get_supports),
+ FSINFO_VSTRUCT (FSINFO_ATTR_FEATURES, nfs_fsinfo_get_features),
+ FSINFO_VSTRUCT (FSINFO_ATTR_NFS_INFO, nfs_fsinfo_get_info),
+ FSINFO_STRING (FSINFO_ATTR_NFS_SERVER_NAME, nfs_fsinfo_get_server_name),
+ FSINFO_LIST (FSINFO_ATTR_NFS_SERVER_ADDRESSES, nfs_fsinfo_get_server_addresses),
+ FSINFO_STRING (FSINFO_ATTR_NFS_GSSAPI_NAME, nfs_fsinfo_get_gssapi_name),
+ {}
+};
+
+int nfs_fsinfo(struct path *path, struct fsinfo_context *ctx)
+{
+ return fsinfo_get_attribute(path, ctx, nfs_fsinfo_attributes);
+}
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index f80c47d5ff27..59e407066b45 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -10,6 +10,7 @@
#include <linux/sunrpc/addr.h>
#include <linux/nfs_page.h>
#include <linux/wait_bit.h>
+#include <linux/fsinfo.h>
#define NFS_SB_MASK (SB_RDONLY|SB_NOSUID|SB_NODEV|SB_NOEXEC|SB_SYNCHRONOUS)
@@ -247,6 +248,11 @@ extern const struct svc_version nfs4_callback_version4;
/* fs_context.c */
extern struct file_system_type nfs_fs_type;
+/* fsinfo.c */
+#ifdef CONFIG_FSINFO
+extern int nfs_fsinfo(struct path *path, struct fsinfo_context *ctx);
+#endif
+
/* pagelist.c */
extern int __init nfs_init_nfspagecache(void);
extern void nfs_destroy_nfspagecache(void);
diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c
index 1475f932d7da..cd38da87cbd3 100644
--- a/fs/nfs/nfs4super.c
+++ b/fs/nfs/nfs4super.c
@@ -26,6 +26,9 @@ static const struct super_operations nfs4_sops = {
.write_inode = nfs4_write_inode,
.drop_inode = nfs_drop_inode,
.statfs = nfs_statfs,
+#ifdef CONFIG_FSINFO
+ .fsinfo = nfs_fsinfo,
+#endif
.evict_inode = nfs4_evict_inode,
.umount_begin = nfs_umount_begin,
.show_options = nfs_show_options,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index dada09b391c6..27ac751d3789 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -76,6 +76,9 @@ const struct super_operations nfs_sops = {
.write_inode = nfs_write_inode,
.drop_inode = nfs_drop_inode,
.statfs = nfs_statfs,
+#ifdef CONFIG_FSINFO
+ .fsinfo = nfs_fsinfo,
+#endif
.evict_inode = nfs_evict_inode,
.umount_begin = nfs_umount_begin,
.show_options = nfs_show_options,
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index d8d05f0f1473..346cf0cf42cb 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -43,6 +43,11 @@
#define FSINFO_ATTR_EXT4_TIMESTAMPS 0x400 /* Ext4 superblock timestamps */
+#define FSINFO_ATTR_NFS_INFO 0x500 /* Information about an NFS mount */
+#define FSINFO_ATTR_NFS_SERVER_NAME 0x501 /* Name of the server (string) */
+#define FSINFO_ATTR_NFS_SERVER_ADDRESSES 0x502 /* List of addresses of the server */
+#define FSINFO_ATTR_NFS_GSSAPI_NAME 0x503 /* GSSAPI acceptor name */
+
/*
* Optional fsinfo() parameter structure.
*
@@ -328,4 +333,28 @@ struct fsinfo_ext4_timestamps {
#define FSINFO_ATTR_EXT4_TIMESTAMPS__STRUCT struct fsinfo_ext4_timestamps
+/*
+ * Information struct for fsinfo(FSINFO_ATTR_NFS_INFO).
+ *
+ * Get information about an NFS mount.
+ */
+struct fsinfo_nfs_info {
+ __u32 version;
+ __u32 minor_version;
+ __u32 transport_proto;
+};
+
+#define FSINFO_ATTR_NFS_INFO__STRUCT struct fsinfo_nfs_info
+
+/*
+ * Information struct for fsinfo(FSINFO_ATTR_NFS_SERVER_ADDRESSES).
+ *
+ * Get the addresses of the server for an NFS mount.
+ */
+struct fsinfo_nfs_server_address {
+ struct __kernel_sockaddr_storage address;
+};
+
+#define FSINFO_ATTR_NFS_SERVER_ADDRESSES__STRUCT struct fsinfo_nfs_server_address
+
#endif /* _UAPI_LINUX_FSINFO_H */
diff --git a/include/uapi/linux/windows.h b/include/uapi/linux/windows.h
new file mode 100644
index 000000000000..17efb9a40529
--- /dev/null
+++ b/include/uapi/linux/windows.h
@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Common windows attributes
+ */
+#ifndef _UAPI_LINUX_WINDOWS_H
+#define _UAPI_LINUX_WINDOWS_H
+
+/*
+ * File Attribute flags
+ */
+#define ATTR_READONLY 0x0001
+#define ATTR_HIDDEN 0x0002
+#define ATTR_SYSTEM 0x0004
+#define ATTR_VOLUME 0x0008
+#define ATTR_DIRECTORY 0x0010
+#define ATTR_ARCHIVE 0x0020
+#define ATTR_DEVICE 0x0040
+#define ATTR_NORMAL 0x0080
+#define ATTR_TEMPORARY 0x0100
+#define ATTR_SPARSE 0x0200
+#define ATTR_REPARSE 0x0400
+#define ATTR_COMPRESSED 0x0800
+#define ATTR_OFFLINE 0x1000 /* ie file not immediately available -
+ on offline storage */
+#define ATTR_NOT_CONTENT_INDEXED 0x2000
+#define ATTR_ENCRYPTED 0x4000
+#define ATTR_POSIX_SEMANTICS 0x01000000
+#define ATTR_BACKUP_SEMANTICS 0x02000000
+#define ATTR_DELETE_ON_CLOSE 0x04000000
+#define ATTR_SEQUENTIAL_SCAN 0x08000000
+#define ATTR_RANDOM_ACCESS 0x10000000
+#define ATTR_NO_BUFFERING 0x20000000
+#define ATTR_WRITE_THROUGH 0x80000000
+
+#endif /* _UAPI_LINUX_WINDOWS_H */
diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
index 829297e9d1b6..b03869faef01 100644
--- a/samples/vfs/test-fsinfo.c
+++ b/samples/vfs/test-fsinfo.c
@@ -408,6 +408,40 @@ static void dump_ext4_fsinfo_timestamps(void *reply, unsigned int size)
printf("\tlast-err: %s\n", dump_ext4_time(buffer, r->last_error_time));
}
+static void dump_nfs_fsinfo_info(void *reply, unsigned int size)
+{
+ struct fsinfo_nfs_info *r = reply;
+
+ printf("ver=%u.%u proto=%u\n", r->version, r->minor_version, r->transport_proto);
+}
+
+static void dump_nfs_fsinfo_server_addresses(void *reply, unsigned int size)
+{
+ struct fsinfo_nfs_server_address *r = reply;
+ struct sockaddr_storage *ss = (struct sockaddr_storage *)&r->address;
+ struct sockaddr_in6 *sin6;
+ struct sockaddr_in *sin;
+ char buf[1024];
+
+ switch (ss->ss_family) {
+ case AF_INET:
+ sin = (struct sockaddr_in *)ss;
+ if (!inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)))
+ break;
+ printf("%5u %s\n", ntohs(sin->sin_port), buf);
+ return;
+ case AF_INET6:
+ sin6 = (struct sockaddr_in6 *)ss;
+ if (!inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf)))
+ break;
+ printf("%5u %s\n", ntohs(sin6->sin6_port), buf);
+ return;
+ default:
+ printf("family=%u\n", ss->ss_family);
+ return;
+ }
+}
+
static void dump_string(void *reply, unsigned int size)
{
char *s = reply, *p;
@@ -495,6 +529,10 @@ static const struct fsinfo_attribute fsinfo_attributes[] = {
FSINFO_STRING (FSINFO_ATTR_AFS_SERVER_NAME, string),
FSINFO_LIST_N (FSINFO_ATTR_AFS_SERVER_ADDRESSES, afs_fsinfo_server_address),
FSINFO_VSTRUCT (FSINFO_ATTR_EXT4_TIMESTAMPS, ext4_fsinfo_timestamps),
+ FSINFO_VSTRUCT (FSINFO_ATTR_NFS_INFO, nfs_fsinfo_info),
+ FSINFO_STRING (FSINFO_ATTR_NFS_SERVER_NAME, string),
+ FSINFO_LIST (FSINFO_ATTR_NFS_SERVER_ADDRESSES, nfs_fsinfo_server_addresses),
+ FSINFO_STRING (FSINFO_ATTR_NFS_GSSAPI_NAME, string),
{}
};
^ permalink raw reply related
* [PATCH 13/14] fsinfo: Example support for Ext4 [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: Theodore Ts'o, Andreas Dilger, linux-ext4, dhowells, raven,
mszeredi, christian, jannh, darrick.wong, kzak, jlayton,
linux-api, linux-fsdevel, linux-security-module, linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Add the ability to list some Ext4 volume timestamps as an example.
Is this useful for ext4? Is there anything else that could be useful?
Signed-off-by: David Howells <dhowells@redhat.com>
cc: "Theodore Ts'o" <tytso@mit.edu>
cc: Andreas Dilger <adilger.kernel@dilger.ca>
cc: linux-ext4@vger.kernel.org
---
fs/ext4/Makefile | 1 +
fs/ext4/ext4.h | 6 ++++++
fs/ext4/fsinfo.c | 45 +++++++++++++++++++++++++++++++++++++++++++
fs/ext4/super.c | 3 +++
include/uapi/linux/fsinfo.h | 16 +++++++++++++++
samples/vfs/test-fsinfo.c | 35 +++++++++++++++++++++++++++++++++
6 files changed, 106 insertions(+)
create mode 100644 fs/ext4/fsinfo.c
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
index 4ccb3c9189d8..71d5b460c7c7 100644
--- a/fs/ext4/Makefile
+++ b/fs/ext4/Makefile
@@ -16,3 +16,4 @@ ext4-$(CONFIG_EXT4_FS_SECURITY) += xattr_security.o
ext4-inode-test-objs += inode-test.o
obj-$(CONFIG_EXT4_KUNIT_TESTS) += ext4-inode-test.o
ext4-$(CONFIG_FS_VERITY) += verity.o
+ext4-$(CONFIG_FSINFO) += fsinfo.o
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 9a2ee2428ecc..461968a87cd6 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -42,6 +42,7 @@
#include <linux/fscrypt.h>
#include <linux/fsverity.h>
+#include <linux/fsinfo.h>
#include <linux/compiler.h>
@@ -3166,6 +3167,11 @@ extern const struct inode_operations ext4_file_inode_operations;
extern const struct file_operations ext4_file_operations;
extern loff_t ext4_llseek(struct file *file, loff_t offset, int origin);
+/* fsinfo.c */
+#ifdef CONFIG_FSINFO
+extern int ext4_fsinfo(struct path *path, struct fsinfo_context *ctx);
+#endif
+
/* inline.c */
extern int ext4_get_max_inline_size(struct inode *inode);
extern int ext4_find_inline_data_nolock(struct inode *inode);
diff --git a/fs/ext4/fsinfo.c b/fs/ext4/fsinfo.c
new file mode 100644
index 000000000000..785f82a74dc9
--- /dev/null
+++ b/fs/ext4/fsinfo.c
@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Filesystem information for ext4
+ *
+ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#include <linux/mount.h>
+#include "ext4.h"
+
+static int ext4_fsinfo_get_volume_name(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct ext4_sb_info *sbi = EXT4_SB(path->mnt->mnt_sb);
+ const struct ext4_super_block *es = sbi->s_es;
+
+ memcpy(ctx->buffer, es->s_volume_name, sizeof(es->s_volume_name));
+ return strlen(ctx->buffer);
+}
+
+static int ext4_fsinfo_get_timestamps(struct path *path, struct fsinfo_context *ctx)
+{
+ const struct ext4_sb_info *sbi = EXT4_SB(path->mnt->mnt_sb);
+ const struct ext4_super_block *es = sbi->s_es;
+ struct fsinfo_ext4_timestamps *ts = ctx->buffer;
+
+#define Z(R,S) R = S | (((u64)S##_hi) << 32)
+ Z(ts->mkfs_time, es->s_mkfs_time);
+ Z(ts->mount_time, es->s_mtime);
+ Z(ts->write_time, es->s_wtime);
+ Z(ts->last_check_time, es->s_lastcheck);
+ Z(ts->first_error_time, es->s_first_error_time);
+ Z(ts->last_error_time, es->s_last_error_time);
+ return sizeof(*ts);
+}
+
+static const struct fsinfo_attribute ext4_fsinfo_attributes[] = {
+ FSINFO_STRING (FSINFO_ATTR_VOLUME_NAME, ext4_fsinfo_get_volume_name),
+ FSINFO_VSTRUCT (FSINFO_ATTR_EXT4_TIMESTAMPS, ext4_fsinfo_get_timestamps),
+ {}
+};
+
+int ext4_fsinfo(struct path *path, struct fsinfo_context *ctx)
+{
+ return fsinfo_get_attribute(path, ctx, ext4_fsinfo_attributes);
+}
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 8434217549b3..02b4df073c4b 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -1477,6 +1477,9 @@ static const struct super_operations ext4_sops = {
.freeze_fs = ext4_freeze,
.unfreeze_fs = ext4_unfreeze,
.statfs = ext4_statfs,
+#ifdef CONFIG_FSINFO
+ .fsinfo = ext4_fsinfo,
+#endif
.remount_fs = ext4_remount,
.show_options = ext4_show_options,
#ifdef CONFIG_QUOTA
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index 154c13a55819..d8d05f0f1473 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -41,6 +41,8 @@
#define FSINFO_ATTR_AFS_SERVER_NAME 0x301 /* Name of the Nth server (string) */
#define FSINFO_ATTR_AFS_SERVER_ADDRESSES 0x302 /* List of addresses of the Nth server */
+#define FSINFO_ATTR_EXT4_TIMESTAMPS 0x400 /* Ext4 superblock timestamps */
+
/*
* Optional fsinfo() parameter structure.
*
@@ -312,4 +314,18 @@ struct fsinfo_afs_server_address {
#define FSINFO_ATTR_AFS_SERVER_ADDRESSES__STRUCT struct fsinfo_afs_server_address
+/*
+ * Information struct for fsinfo(FSINFO_ATTR_EXT4_TIMESTAMPS).
+ */
+struct fsinfo_ext4_timestamps {
+ __u64 mkfs_time;
+ __u64 mount_time;
+ __u64 write_time;
+ __u64 last_check_time;
+ __u64 first_error_time;
+ __u64 last_error_time;
+};
+
+#define FSINFO_ATTR_EXT4_TIMESTAMPS__STRUCT struct fsinfo_ext4_timestamps
+
#endif /* _UAPI_LINUX_FSINFO_H */
diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
index 82944f09e0c9..829297e9d1b6 100644
--- a/samples/vfs/test-fsinfo.c
+++ b/samples/vfs/test-fsinfo.c
@@ -374,6 +374,40 @@ static void dump_afs_fsinfo_server_address(void *reply, unsigned int size)
printf("family=%u\n", ss->ss_family);
}
+static char *dump_ext4_time(char *buffer, time_t tim)
+{
+ struct tm tm;
+ int len;
+
+ if (tim == 0)
+ return "-";
+
+ if (!localtime_r(&tim, &tm)) {
+ perror("localtime_r");
+ exit(1);
+ }
+ len = strftime(buffer, 100, "%F %T", &tm);
+ if (len == 0) {
+ perror("strftime");
+ exit(1);
+ }
+ return buffer;
+}
+
+static void dump_ext4_fsinfo_timestamps(void *reply, unsigned int size)
+{
+ struct fsinfo_ext4_timestamps *r = reply;
+ char buffer[100];
+
+ printf("\n");
+ printf("\tmkfs : %s\n", dump_ext4_time(buffer, r->mkfs_time));
+ printf("\tmount : %s\n", dump_ext4_time(buffer, r->mount_time));
+ printf("\twrite : %s\n", dump_ext4_time(buffer, r->write_time));
+ printf("\tfsck : %s\n", dump_ext4_time(buffer, r->last_check_time));
+ printf("\t1st-err : %s\n", dump_ext4_time(buffer, r->first_error_time));
+ printf("\tlast-err: %s\n", dump_ext4_time(buffer, r->last_error_time));
+}
+
static void dump_string(void *reply, unsigned int size)
{
char *s = reply, *p;
@@ -460,6 +494,7 @@ static const struct fsinfo_attribute fsinfo_attributes[] = {
FSINFO_STRING (FSINFO_ATTR_AFS_CELL_NAME, string),
FSINFO_STRING (FSINFO_ATTR_AFS_SERVER_NAME, string),
FSINFO_LIST_N (FSINFO_ATTR_AFS_SERVER_ADDRESSES, afs_fsinfo_server_address),
+ FSINFO_VSTRUCT (FSINFO_ATTR_EXT4_TIMESTAMPS, ext4_fsinfo_timestamps),
{}
};
^ permalink raw reply related
* [PATCH 12/14] fsinfo: Add support for AFS [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: dhowells, raven, mszeredi, christian, jannh, darrick.wong, kzak,
jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Add fsinfo support to the AFS filesystem. This allows the export of server
lists, amongst other things, which is necessary to implement some of the
AFS 'fs' command set, such as "checkservers", "getserverprefs" and
"whereis".
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/afs/internal.h | 1
fs/afs/super.c | 218 +++++++++++++++++++++++++++++++++++++++++++
include/uapi/linux/fsinfo.h | 15 +++
samples/vfs/test-fsinfo.c | 49 ++++++++++
4 files changed, 281 insertions(+), 2 deletions(-)
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 1d81fc4c3058..b4b2a8a18e9f 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -248,6 +248,7 @@ struct afs_super_info {
struct afs_volume *volume; /* volume record */
enum afs_flock_mode flock_mode:8; /* File locking emulation mode */
bool dyn_root; /* True if dynamic root */
+ bool autocell; /* True if autocell */
};
static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
diff --git a/fs/afs/super.c b/fs/afs/super.c
index dda7a9a66848..969248a192a2 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -26,9 +26,13 @@
#include <linux/sched.h>
#include <linux/nsproxy.h>
#include <linux/magic.h>
+#include <linux/fsinfo.h>
#include <net/net_namespace.h>
#include "internal.h"
+#ifdef CONFIG_FSINFO
+static int afs_fsinfo(struct path *path, struct fsinfo_context *ctx);
+#endif
static void afs_i_init_once(void *foo);
static void afs_kill_super(struct super_block *sb);
static struct inode *afs_alloc_inode(struct super_block *sb);
@@ -54,6 +58,9 @@ int afs_net_id;
static const struct super_operations afs_super_ops = {
.statfs = afs_statfs,
+#ifdef CONFIG_FSINFO
+ .fsinfo = afs_fsinfo,
+#endif
.alloc_inode = afs_alloc_inode,
.drop_inode = afs_drop_inode,
.destroy_inode = afs_destroy_inode,
@@ -193,7 +200,7 @@ static int afs_show_options(struct seq_file *m, struct dentry *root)
if (as->dyn_root)
seq_puts(m, ",dyn");
- if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(d_inode(root))->flags))
+ if (as->autocell)
seq_puts(m, ",autocell");
switch (as->flock_mode) {
case afs_flock_mode_unset: break;
@@ -458,7 +465,7 @@ static int afs_fill_super(struct super_block *sb, struct afs_fs_context *ctx)
if (IS_ERR(inode))
return PTR_ERR(inode);
- if (ctx->autocell || as->dyn_root)
+ if (as->autocell || as->dyn_root)
set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags);
ret = -ENOMEM;
@@ -498,6 +505,8 @@ static struct afs_super_info *afs_alloc_sbi(struct fs_context *fc)
as->cell = afs_get_cell(ctx->cell);
as->volume = __afs_get_volume(ctx->volume);
}
+ if (ctx->autocell)
+ as->autocell = true;
}
return as;
}
@@ -760,3 +769,208 @@ static int afs_statfs(struct dentry *dentry, struct kstatfs *buf)
return ret;
}
+
+#ifdef CONFIG_FSINFO
+static const struct fsinfo_timestamp_info afs_timestamp_info = {
+ .atime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .mtime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .ctime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+ .btime = {
+ .minimum = 0,
+ .maximum = UINT_MAX,
+ .gran_mantissa = 1,
+ .gran_exponent = 0,
+ },
+};
+
+static int afs_fsinfo_get_timestamp(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_timestamp_info *tsinfo = ctx->buffer;
+ *tsinfo = afs_timestamp_info;
+ return sizeof(*tsinfo);
+}
+
+static int afs_fsinfo_get_limits(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_limits *lim = ctx->buffer;
+
+ lim->max_file_size.hi = 0;
+ lim->max_file_size.lo = MAX_LFS_FILESIZE;
+ /* Inode numbers can be 96-bit on YFS, but that's hard to determine. */
+ lim->max_ino.hi = 0;
+ lim->max_ino.lo = UINT_MAX;
+ lim->max_hard_links = UINT_MAX;
+ lim->max_uid = UINT_MAX;
+ lim->max_gid = UINT_MAX;
+ lim->max_filename_len = AFSNAMEMAX - 1;
+ lim->max_symlink_len = AFSPATHMAX - 1;
+ return sizeof(*lim);
+}
+
+static int afs_fsinfo_get_supports(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_supports *p = ctx->buffer;
+
+ p->stx_mask = (STATX_TYPE | STATX_MODE |
+ STATX_NLINK |
+ STATX_UID | STATX_GID |
+ STATX_MTIME | STATX_INO |
+ STATX_SIZE);
+ p->stx_attributes = STATX_ATTR_AUTOMOUNT;
+ return sizeof(*p);
+}
+
+static int afs_fsinfo_get_features(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_features *p = ctx->buffer;
+
+ fsinfo_set_feature(p, FSINFO_FEAT_IS_NETWORK_FS);
+ fsinfo_set_feature(p, FSINFO_FEAT_AUTOMOUNTS);
+ fsinfo_set_feature(p, FSINFO_FEAT_ADV_LOCKS);
+ fsinfo_set_feature(p, FSINFO_FEAT_UIDS);
+ fsinfo_set_feature(p, FSINFO_FEAT_GIDS);
+ fsinfo_set_feature(p, FSINFO_FEAT_VOLUME_ID);
+ fsinfo_set_feature(p, FSINFO_FEAT_VOLUME_NAME);
+ fsinfo_set_feature(p, FSINFO_FEAT_IVER_MONO_INCR);
+ fsinfo_set_feature(p, FSINFO_FEAT_SYMLINKS);
+ fsinfo_set_feature(p, FSINFO_FEAT_HARD_LINKS_1DIR);
+ fsinfo_set_feature(p, FSINFO_FEAT_HAS_MTIME);
+ fsinfo_set_feature(p, FSINFO_FEAT_HAS_INODE_NUMBERS);
+ return sizeof(*p);
+}
+
+static int afs_dyn_fsinfo_get_features(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_features *p = ctx->buffer;
+
+ fsinfo_set_feature(p, FSINFO_FEAT_IS_AUTOMOUNTER_FS);
+ fsinfo_set_feature(p, FSINFO_FEAT_AUTOMOUNTS);
+ return sizeof(*p);
+}
+
+static int afs_fsinfo_get_volume_name(struct path *path, struct fsinfo_context *ctx)
+{
+ struct afs_super_info *as = AFS_FS_S(path->dentry->d_sb);
+ struct afs_volume *volume = as->volume;
+
+ memcpy(ctx->buffer, volume->name, volume->name_len);
+ return volume->name_len;
+}
+
+static int afs_fsinfo_get_cell_name(struct path *path, struct fsinfo_context *ctx)
+{
+ struct afs_super_info *as = AFS_FS_S(path->dentry->d_sb);
+ struct afs_cell *cell = as->cell;
+
+ memcpy(ctx->buffer, cell->name, cell->name_len);
+ return cell->name_len;
+}
+
+static int afs_fsinfo_get_server_name(struct path *path, struct fsinfo_context *ctx)
+{
+ struct afs_server_list *slist;
+ struct afs_super_info *as = AFS_FS_S(path->dentry->d_sb);
+ struct afs_volume *volume = as->volume;
+ struct afs_server *server;
+ int ret = -ENODATA;
+
+ read_lock(&volume->servers_lock);
+ slist = volume->servers;
+ if (slist) {
+ if (ctx->Nth < slist->nr_servers) {
+ server = slist->servers[ctx->Nth].server;
+ ret = sprintf(ctx->buffer, "%pU", &server->uuid);
+ }
+ }
+
+ read_unlock(&volume->servers_lock);
+ return ret;
+}
+
+static int afs_fsinfo_get_server_address(struct path *path, struct fsinfo_context *ctx)
+{
+ struct fsinfo_afs_server_address *p = ctx->buffer;
+ struct afs_server_list *slist;
+ struct afs_super_info *as = AFS_FS_S(path->dentry->d_sb);
+ struct afs_addr_list *alist;
+ struct afs_volume *volume = as->volume;
+ struct afs_server *server;
+ struct afs_net *net = afs_d2net(path->dentry);
+ unsigned int i;
+ int ret = -ENODATA;
+
+ read_lock(&volume->servers_lock);
+ slist = afs_get_serverlist(volume->servers);
+ read_unlock(&volume->servers_lock);
+
+ if (ctx->Nth >= slist->nr_servers)
+ goto put_slist;
+ server = slist->servers[ctx->Nth].server;
+
+ read_lock(&server->fs_lock);
+ alist = afs_get_addrlist(rcu_dereference_protected(
+ server->addresses,
+ lockdep_is_held(&server->fs_lock)));
+ read_unlock(&server->fs_lock);
+ if (!alist)
+ goto put_slist;
+
+ ret = alist->nr_addrs * sizeof(*p);
+ if (ret <= ctx->buf_size) {
+ for (i = 0; i < alist->nr_addrs; i++)
+ memcpy(&p[i].address, &alist->addrs[i],
+ sizeof(struct sockaddr_rxrpc));
+ }
+
+ afs_put_addrlist(alist);
+put_slist:
+ afs_put_serverlist(net, slist);
+ return ret;
+}
+
+static const struct fsinfo_attribute afs_fsinfo_attributes[] = {
+ FSINFO_VSTRUCT (FSINFO_ATTR_TIMESTAMP_INFO, afs_fsinfo_get_timestamp),
+ FSINFO_VSTRUCT (FSINFO_ATTR_LIMITS, afs_fsinfo_get_limits),
+ FSINFO_VSTRUCT (FSINFO_ATTR_SUPPORTS, afs_fsinfo_get_supports),
+ FSINFO_VSTRUCT (FSINFO_ATTR_FEATURES, afs_fsinfo_get_features),
+ FSINFO_STRING (FSINFO_ATTR_VOLUME_NAME, afs_fsinfo_get_volume_name),
+ FSINFO_STRING (FSINFO_ATTR_AFS_CELL_NAME, afs_fsinfo_get_cell_name),
+ FSINFO_STRING_N (FSINFO_ATTR_AFS_SERVER_NAME, afs_fsinfo_get_server_name),
+ FSINFO_LIST_N (FSINFO_ATTR_AFS_SERVER_ADDRESSES, afs_fsinfo_get_server_address),
+ {}
+};
+
+static const struct fsinfo_attribute afs_dyn_fsinfo_attributes[] = {
+ FSINFO_VSTRUCT(FSINFO_ATTR_TIMESTAMP_INFO, afs_fsinfo_get_timestamp),
+ FSINFO_VSTRUCT(FSINFO_ATTR_FEATURES, afs_dyn_fsinfo_get_features),
+ {}
+};
+
+static int afs_fsinfo(struct path *path, struct fsinfo_context *ctx)
+{
+ struct afs_super_info *as = AFS_FS_S(path->dentry->d_sb);
+ int ret;
+
+ if (as->dyn_root)
+ ret = fsinfo_get_attribute(path, ctx, afs_dyn_fsinfo_attributes);
+ else
+ ret = fsinfo_get_attribute(path, ctx, afs_fsinfo_attributes);
+ return ret;
+}
+
+#endif /* CONFIG_FSINFO */
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index 826b788b0795..154c13a55819 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -37,6 +37,10 @@
#define FSINFO_ATTR_MOUNT_POINT_FULL 0x203 /* Absolute path of mount (string) */
#define FSINFO_ATTR_MOUNT_CHILDREN 0x204 /* Children of this mount (list) */
+#define FSINFO_ATTR_AFS_CELL_NAME 0x300 /* AFS cell name (string) */
+#define FSINFO_ATTR_AFS_SERVER_NAME 0x301 /* Name of the Nth server (string) */
+#define FSINFO_ATTR_AFS_SERVER_ADDRESSES 0x302 /* List of addresses of the Nth server */
+
/*
* Optional fsinfo() parameter structure.
*
@@ -297,4 +301,15 @@ struct fsinfo_volume_uuid {
#define FSINFO_ATTR_VOLUME_UUID__STRUCT struct fsinfo_volume_uuid
+/*
+ * Information struct for fsinfo(FSINFO_ATTR_AFS_SERVER_ADDRESSES).
+ *
+ * Get the addresses of the Nth server for a network filesystem.
+ */
+struct fsinfo_afs_server_address {
+ struct __kernel_sockaddr_storage address;
+};
+
+#define FSINFO_ATTR_AFS_SERVER_ADDRESSES__STRUCT struct fsinfo_afs_server_address
+
#endif /* _UAPI_LINUX_FSINFO_H */
diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
index 91434f459ba5..82944f09e0c9 100644
--- a/samples/vfs/test-fsinfo.c
+++ b/samples/vfs/test-fsinfo.c
@@ -23,6 +23,7 @@
#include <linux/socket.h>
#include <sys/stat.h>
#include <arpa/inet.h>
+#include <linux/rxrpc.h>
#ifndef __NR_fsinfo
#define __NR_fsinfo -1
@@ -329,6 +330,50 @@ static void dump_fsinfo_generic_mount_child(void *reply, unsigned int size)
r->mnt_id, (unsigned long long)r->mnt_unique_id, r->notify_sum, mp);
}
+static void dump_afs_fsinfo_server_address(void *reply, unsigned int size)
+{
+ struct fsinfo_afs_server_address *f = reply;
+ struct sockaddr_storage *ss = (struct sockaddr_storage *)&f->address;
+ struct sockaddr_rxrpc *srx;
+ struct sockaddr_in6 *sin6;
+ struct sockaddr_in *sin;
+ char proto[32], buf[1024];
+
+ if (ss->ss_family == AF_RXRPC) {
+ srx = (struct sockaddr_rxrpc *)ss;
+ printf("%5u ", srx->srx_service);
+ switch (srx->transport_type) {
+ case SOCK_DGRAM:
+ sprintf(proto, "udp");
+ break;
+ case SOCK_STREAM:
+ sprintf(proto, "tcp");
+ break;
+ default:
+ sprintf(proto, "%3u", srx->transport_type);
+ break;
+ }
+ ss = (struct sockaddr_storage *)&srx->transport;
+ }
+
+ switch (ss->ss_family) {
+ case AF_INET:
+ sin = (struct sockaddr_in *)ss;
+ if (!inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf)))
+ break;
+ printf("%5u/%s %s\n", ntohs(sin->sin_port), proto, buf);
+ return;
+ case AF_INET6:
+ sin6 = (struct sockaddr_in6 *)ss;
+ if (!inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf)))
+ break;
+ printf("%5u/%s %s\n", ntohs(sin6->sin6_port), proto, buf);
+ return;
+ }
+
+ printf("family=%u\n", ss->ss_family);
+}
+
static void dump_string(void *reply, unsigned int size)
{
char *s = reply, *p;
@@ -411,6 +456,10 @@ static const struct fsinfo_attribute fsinfo_attributes[] = {
FSINFO_STRING_N (FSINFO_ATTR_MOUNT_POINT, string),
FSINFO_STRING_N (FSINFO_ATTR_MOUNT_POINT_FULL, string),
FSINFO_LIST (FSINFO_ATTR_MOUNT_CHILDREN, fsinfo_generic_mount_child),
+
+ FSINFO_STRING (FSINFO_ATTR_AFS_CELL_NAME, string),
+ FSINFO_STRING (FSINFO_ATTR_AFS_SERVER_NAME, string),
+ FSINFO_LIST_N (FSINFO_ATTR_AFS_SERVER_ADDRESSES, afs_fsinfo_server_address),
{}
};
^ permalink raw reply related
* [PATCH 11/14] fsinfo: Add API documentation [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: dhowells, raven, mszeredi, christian, jannh, darrick.wong, kzak,
jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Add API documentation for fsinfo.
Signed-off-by: David Howells <dhowells@redhat.com>
---
Documentation/filesystems/fsinfo.rst | 564 ++++++++++++++++++++++++++++++++++
1 file changed, 564 insertions(+)
create mode 100644 Documentation/filesystems/fsinfo.rst
diff --git a/Documentation/filesystems/fsinfo.rst b/Documentation/filesystems/fsinfo.rst
new file mode 100644
index 000000000000..1f02e7d53bed
--- /dev/null
+++ b/Documentation/filesystems/fsinfo.rst
@@ -0,0 +1,564 @@
+============================
+Filesystem Information Query
+============================
+
+The fsinfo() system call allows the querying of filesystem and filesystem
+security information beyond what stat(), statx() and statfs() can obtain. It
+does not require a file to be opened as does ioctl().
+
+fsinfo() may be called with a path, with open file descriptor or a with a mount
+object identifier.
+
+The fsinfo() system call needs to be configured on by enabling:
+
+ "File systems"/"Enable the fsinfo() system call" (CONFIG_FSINFO)
+
+This document has the following sections:
+
+.. contents:: :local:
+
+
+Overview
+========
+
+The fsinfo() system call retrieves one of a number of attributes, the IDs of
+which can be found in include/uapi/linux/fsinfo.h::
+
+ FSINFO_ATTR_STATFS - statfs()-style state
+ FSINFO_ATTR_IDS - Filesystem IDs
+ FSINFO_ATTR_LIMITS - Filesystem limits
+ ...
+ FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO - Information about an attribute
+ FSINFO_ATTR_FSINFO_ATTRIBUTES - List of available attributes
+ ...
+ FSINFO_ATTR_MOUNT_INFO - Information about the mount topology
+ ...
+
+Each attribute can have zero or more values, which can be of one of the
+following types:
+
+ * ``FSINFO_TYPE_VSTRUCT``. This is a structure with a version-dependent
+ length. New versions of the kernel may append more fields, though they are
+ not permitted to remove or replace old ones.
+
+ Older applications, expecting an older version of the field, can ask for a
+ shorter struct and will only get the fields they requested; newer
+ applications running on an older kernel will get the extra fields they
+ requested filled with zeros. Either way, the system call returns the size
+ of the internal struct, regardless of how much data it returned.
+
+ This allows for struct-type fields to be extended in future.
+
+ * ``FSINFO_TYPE_STRING``. This is a variable-length string of up to INT_MAX
+ characters (no NUL character is included). The returned string will be
+ truncated if the output buffer is too small. The total size of the string
+ is returned, regardless of any truncation.
+
+ * ``FSINFO_TYPE_OPAQUE``. This is a variable-length blob of indeterminate
+ structure. It may be up to INT_MAX bytes in size.
+
+ * ``FSINFO_TYPE_LIST``. This is a variable-length list of fixed-size
+ structures. The element size may not vary over time, so the element format
+ must be designed with care. The maximum length is INT_MAX bytes, though
+ this depends on the kernel being able to allocate an internal buffer large
+ enough.
+
+Value type is an inherent propery of an attribute and all the values of an
+attribute must be of that type. Each attribute can have a single value, a
+sequence of values or a sequence-of-sequences of values.
+
+
+Filesystem API
+==============
+
+If the filesystem wishes to override the generic queryable attributes or
+provide queryable attributes of its own, it should define a handler function
+and point the appropriate superblock op to it::
+
+ int (*fsinfo)(struct path *path, struct fsinfo_context *ctx);
+
+The core calls this function to see if it wants to handle the attribute. For
+each table of attibutes it has (and it can have more than one), it should
+call::
+
+ int fsinfo_get_attribute(struct path *path, struct fsinfo_context *ctx,
+ const struct fsinfo_attribute *attrs);
+
+to scan the table to see if the requested one is in there. This function also
+handles determining the size of struct attributes, enumerating attributes for
+the FSINFO_ATTR_FSINFO_ATTRIBUTES and querying information about an attribute
+for FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO.
+
+If it doesn't want to handle the function, -EOPNOTSUPP should be returned. The
+core will then examine the generic attribute table.
+
+
+Attribute Table
+---------------
+
+An attribute table is a sequence of ``struct fsinfo_attribute`` terminated with
+a blank entry. Entries can be created with a set of helper macros::
+
+ FSINFO_VSTRUCT(A,G)
+ FSINFO_VSTRUCT_N(A,G)
+ FSINFO_VSTRUCT_NM(A,G)
+ FSINFO_STRING(A,G)
+ FSINFO_STRING_N(A,G)
+ FSINFO_STRING_NM(A,G)
+ FSINFO_OPAQUE(A,G)
+ FSINFO_LIST(A,G)
+ FSINFO_LIST_N(A,G)
+
+The names of the macro are a combination of type (vstruct, string, opaque and
+list) and an optional qualifier, if the attribute has N values or N lots of M
+values. ``A`` is the name of the attribute and ``G`` is a function to get a
+value for that attribute.
+
+For vstruct- and list-type attributes, it is expected that there is a macro
+defined with the name ``A##__STRUCT`` that indicates the structure type.
+
+The get function needs to match the following type::
+
+ int (*get)(struct path *path, struct fsinfo_context *ctx);
+
+where "path" indicates the object to be queried and ctx is a context describing
+the parameters and the output buffer. The function should return the total
+size of the data it would like to produce or an error.
+
+
+Context Structure
+-----------------
+
+The context struct looks like::
+
+ struct fsinfo_context {
+ __u32 requested_attr;
+ __u32 Nth;
+ __u32 Mth;
+ bool want_size_only;
+ unsigned int skip;
+ unsigned int usage;
+ unsigned int buf_size;
+ void *buffer;
+ ...
+ };
+
+The fields relevant to the filesystem are as follows:
+
+ * ``requested_attr``
+
+ Which attribute is being requested. EOPNOTSUPP should be returned if the
+ attribute is not supported by the filesystem or the LSM.
+
+ * ``Nth`` and ``Mth``
+
+ Which value of an attribute is being requested.
+
+ For a single-value attribute Nth and Mth will both be 0.
+
+ For a "1D" attribute, Nth will indicate which value and Mth will always
+ be 0. Take, for example, FSINFO_ATTR_SERVER_NAME - for a network
+ filesystem, the superblock will be backed by a number of servers. This will
+ return the name of the Nth server. ENODATA will be returned if Nth goes
+ beyond the end of the array.
+
+ For a "2D" attribute, Mth will indicate the index in the Nth set of values.
+ Take, for example, an attribute for a network filesystems that returns
+ server addresses - each server may have one or more addresses. This could
+ return the Mth address of the Nth server. ENODATA should be returned if the
+ Nth set doesn't exist or the Mth element of the Nth set doesn't exist.
+
+ * ``want_size_only``
+
+ Is set to true if the caller only wants the size of the value so that the
+ get function doesn't have to make expensive calculations or calls to
+ retrieve the value.
+
+ * ``skip``
+
+ This indicates how far into the buffer the data to be returned starts. This
+ can be used to trim the front off the buffer or to handle backward-filling.
+
+ * ``usage``
+
+ This indicates how much of the buffer has been used so far for an list or
+ opaque type attribute. This is updated by the fsinfo_note_param*()
+ functions.
+
+ * ``buf_size``
+
+ This indicates the current size of the buffer. For the list type and the
+ opaque type this will be increased if the current buffer won't hold the
+ value and the filesystem will be called again.
+
+ * ``buffer``
+
+ This points to the output buffer. It will be buf_size in size and will be
+ resized if the returned size is larger than this.
+
+To simplify filesystem code, there will always be at least a minimal buffer
+available if a ->get() method gets called.
+
+
+Helper Functions
+================
+
+The API includes a number of helper functions:
+
+ * ``int fsinfo_string(const char *s, struct fsinfo_context *ctx);``
+
+ This places the specified string into the buffer set in the context. If the
+ string is NULL, the buffer will be left empty.
+
+ * ``int fsinfo_generic_timestamp_info(struct path *, struct fsinfo_context *);``
+ * ``int fsinfo_generic_supports(struct path *, struct fsinfo_context *);``
+ * ``int fsinfo_generic_limits(struct path *, struct fsinfo_context *);``
+
+ These set the generic information for timestamp resolution and range
+ information, supported features and number limits and are called for the
+ corresponding attributes if the filesystem doesn't override them.
+
+ If the filesystem does override them, it can call the above functions and
+ then amend the results.
+
+ * ``void fsinfo_set_feature(struct fsinfo_features *ft,
+ enum fsinfo_feature feature);``
+
+ This function sets a feature flag.
+
+ * ``void fsinfo_clear_feature(struct fsinfo_features *ft,
+ enum fsinfo_feature feature);``
+
+ This function clears a feature flag.
+
+ * ``void fsinfo_set_unix_features(struct fsinfo_features *ft);``
+
+ Set feature flags appropriate to the features of a standard UNIX filesystem,
+ such as having numeric UIDS and GIDS; allowing the creation of directories,
+ symbolic links, hard links, device files, FIFO and socket files; permitting
+ sparse files; and having access, change and modification times.
+
+
+Attribute Summary
+=================
+
+To summarise the attributes that are defined::
+
+ Symbolic name Type
+ ===================================== ===============
+ FSINFO_ATTR_STATFS vstruct
+ FSINFO_ATTR_IDS vstruct
+ FSINFO_ATTR_LIMITS vstruct
+ FSINFO_ATTR_SUPPORTS vstruct
+ FSINFO_ATTR_TIMESTAMP_INFO vstruct
+ FSINFO_ATTR_VOLUME_ID string
+ FSINFO_ATTR_VOLUME_UUID vstruct
+ FSINFO_ATTR_VOLUME_NAME string
+ FSINFO_ATTR_FEATURES vstruct
+ FSINFO_ATTR_SOURCE string
+ FSINFO_ATTR_CONFIGURATION string
+ FSINFO_ATTR_FS_STATISTICS string
+ FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO N × vstruct
+ FSINFO_ATTR_FSINFO_ATTRIBUTES list
+ FSINFO_ATTR_MOUNT_INFO vstruct
+ FSINFO_ATTR_MOUNT_PATH string
+ FSINFO_ATTR_MOUNT_POINT string
+ FSINFO_ATTR_MOUNT_CHILDREN list
+ FSINFO_ATTR_AFS_CELL_NAME string
+ FSINFO_ATTR_AFS_SERVER_NAME N × string
+ FSINFO_ATTR_AFS_SERVER_ADDRESSES N × list
+
+
+Attribute Catalogue
+===================
+
+A number of the attributes convey information about a filesystem superblock:
+
+ * ``FSINFO_ATTR_STATFS``
+
+ This struct-type attribute gives most of the equivalent data to statfs(),
+ but with all the fields as unconditional 64-bit or 128-bit integers. Note
+ that static data like IDs that don't change are retrieved with
+ FSINFO_ATTR_IDS instead.
+
+ Further, superblock flags (such as MS_RDONLY) are not exposed by this
+ attribute; rather the parameters must be listed and the attributes picked
+ out from that.
+
+ * ``FSINFO_ATTR_IDS``
+
+ This struct-type attribute conveys various identifiers used by the target
+ filesystem. This includes the filesystem name, the NFS filesystem ID, the
+ superblock ID used in notifications, the filesystem magic type number and
+ the primary device ID.
+
+ * ``FSINFO_ATTR_LIMITS``
+
+ This struct-type attribute conveys the limits on various aspects of a
+ filesystem, such as maximum file, symlink and xattr sizes, maxiumm filename
+ and xattr name length, maximum number of symlinks, maximum device major and
+ minor numbers and maximum UID, GID and project ID numbers.
+
+ * ``FSINFO_ATTR_SUPPORTS``
+
+ This struct-type attribute conveys information about the support the
+ filesystem has for various UAPI features of a filesystem. This includes
+ information about which bits are supported in various masks employed by the
+ statx system call, what FS_IOC_* flags are supported by ioctls and what
+ DOS/Windows file attribute flags are supported.
+
+ * ``FSINFO_ATTR_TIMESTAMP_INFO``
+
+ This struct-type attribute conveys information about the resolution and
+ range of the timestamps available in a filesystem. The resolutions are
+ given as a mantissa and exponent (resolution = mantissa * 10^exponent
+ seconds), where the exponent can be negative to indicate a sub-second
+ resolution (-9 being nanoseconds, for example).
+
+ * ``FSINFO_ATTR_VOLUME_ID``
+
+ This is a string-type attribute that conveys the superblock identifier for
+ the volume. By default it will be filled in from the contents of s_id from
+ the superblock. For a block-based filesystem, for example, this might be
+ the name of the primary block device.
+
+ * ``FSINFO_ATTR_VOLUME_UUID``
+
+ This is a struct-type attribute that conveys the UUID identifier for the
+ volume. By default it will be filled in from the contents of s_uuid from
+ the superblock. If this doesn't exist, it will be an entirely zeros.
+
+ * ``FSINFO_ATTR_VOLUME_NAME``
+
+ This is a string-type attribute that conveys the name of the volume. By
+ default it will return EOPNOTSUPP. For a disk-based filesystem, it might
+ convey the partition label; for a network-based filesystem, it might convey
+ the name of the remote volume.
+
+ * ``FSINFO_ATTR_FEATURES``
+
+ This is a special attribute, being a set of single-bit feature flags,
+ formatted as struct-type attribute. The meanings of the feature bits are
+ listed below - see the "Feature Bit Catalogue" section. The feature bits
+ are grouped numerically into bytes, such that features 0-7 are in byte 0,
+ 8-15 are in byte 1, 16-23 in byte 2 and so on.
+
+ Any feature bit that's not supported by the kernel will be set to false if
+ asked for. The highest supported feature is set at the beginning of the
+ structure.
+
+ * ``FSINFO_ATTR_SOURCE``
+ * ``FSINFO_ATTR_CONFIGURATION``
+ * ``FSINFO_ATTR_FS_STATISTICS``
+
+ These attributes return the mountpoint device name (as processed by the
+ filesystem), the superblock configuration (mount) options and the
+ superblock statistics in string form, as presented through a variety
+ of /proc files.
+
+
+Some attributes give information about fsinfo itself:
+
+ * ``FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO``
+
+ This struct-type attribute gives metadata about the attribute with the ID
+ specified by the Nth parameter, including its type, default size and
+ element size.
+
+ * ``FSINFO_ATTR_FSINFO_ATTRIBUTES``
+
+ This list-type attribute gives a list of the attribute IDs available at the
+ point of reference. FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO can then be used to
+ query each attribute.
+
+
+Some attributes give information about mount objects:
+
+ * ``FSINFO_ATTR_MOUNT_INFO``
+
+ This gives information about a particular mount point, including its IDs,
+ its topological relationships, its attributes and its event counters.
+
+ * ``FSINFO_ATTR_MOUNT_PATH``
+
+ This gives information about the path set by binding a mount, though it may
+ be overridden by the filesystem.
+
+ * ``FSINFO_ATTR_MOUNT_POINT``
+ * ``FSINFO_ATTR_MOUNT_POINT_FULL``
+
+ These give the path to the mount point for a mount object, in the former
+ relative to its parent mount's mount point (limited to chroot) and in the
+ latter as a full path from the chroot.
+
+ * ``FSINFO_ATTR_MOUNT_CHILDREN``
+
+ This gives a list of all the child mounts of the queried mount. This is
+ presented as tuples of { mount ID, mount uniquifier, event counter sum }
+ and includes at the end a tuple representing the queried mount.
+
+
+Finally there are filesystem-specific attributes, e.g.:
+
+ * ``FSINFO_ATTR_AFS_CELL_NAME``
+
+ This is a string-type attribute that retrieves the AFS cell name of the
+ target object.
+
+ * ``FSINFO_ATTR_AFS_SERVER_NAME``
+
+ This is a string-type attribute that conveys the name of the Nth server
+ backing a network-filesystem superblock.
+
+ * ``FSINFO_ATTR_AFS_SERVER_ADDRESSES``
+
+ This is a list-type attribute that conveys the addresses of the Nth server,
+ corresponding to the Nth server returned by FSINFO_ATTR_SERVER_NAME.
+
+
+Feature Bit Catalogue
+=====================
+
+The feature bits convey single true/false assertions about a specific instance
+of a filesystem (ie. a specific superblock). They are accessed using the
+"FSINFO_ATTR_FEATURE" attribute:
+
+ * ``FSINFO_FEAT_IS_KERNEL_FS``
+ * ``FSINFO_FEAT_IS_BLOCK_FS``
+ * ``FSINFO_FEAT_IS_FLASH_FS``
+ * ``FSINFO_FEAT_IS_NETWORK_FS``
+ * ``FSINFO_FEAT_IS_AUTOMOUNTER_FS``
+ * ``FSINFO_FEAT_IS_MEMORY_FS``
+
+ These indicate what kind of filesystem the target is: kernel API (proc),
+ block-based (ext4), flash/nvm-based (jffs2), remote over the network (NFS),
+ local quasi-filesystem that acts as a tray of mountpoints (autofs), plain
+ in-memory filesystem (shmem).
+
+ * ``FSINFO_FEAT_AUTOMOUNTS``
+
+ This indicate if a filesystem may have objects that are automount points.
+
+ * ``FSINFO_FEAT_ADV_LOCKS``
+ * ``FSINFO_FEAT_MAND_LOCKS``
+ * ``FSINFO_FEAT_LEASES``
+
+ These indicate if a filesystem supports advisory locks, mandatory locks or
+ leases.
+
+ * ``FSINFO_FEAT_UIDS``
+ * ``FSINFO_FEAT_GIDS``
+ * ``FSINFO_FEAT_PROJIDS``
+
+ These indicate if a filesystem supports/stores/transports numeric user IDs,
+ group IDs or project IDs. The "FSINFO_ATTR_LIMITS" attribute can be used
+ to find out the upper limits on the IDs values.
+
+ * ``FSINFO_FEAT_STRING_USER_IDS``
+
+ This indicates if a filesystem supports/stores/transports string user
+ identifiers.
+
+ * ``FSINFO_FEAT_GUID_USER_IDS``
+
+ This indicates if a filesystem supports/stores/transports Windows GUIDs as
+ user identifiers (eg. ntfs).
+
+ * ``FSINFO_FEAT_WINDOWS_ATTRS``
+
+ This indicates if a filesystem supports Windows FILE_* attribute bits
+ (eg. cifs, jfs). The "FSINFO_ATTR_SUPPORTS" attribute can be used to find
+ out which windows file attributes are supported by the filesystem.
+
+ * ``FSINFO_FEAT_USER_QUOTAS``
+ * ``FSINFO_FEAT_GROUP_QUOTAS``
+ * ``FSINFO_FEAT_PROJECT_QUOTAS``
+
+ These indicate if a filesystem supports quotas for users, groups or
+ projects.
+
+ * ``FSINFO_FEAT_XATTRS``
+
+ These indicate if a filesystem supports extended attributes. The
+ "FSINFO_ATTR_LIMITS" attribute can be used to find out the upper limits on
+ the supported name and body lengths.
+
+ * ``FSINFO_FEAT_JOURNAL``
+ * ``FSINFO_FEAT_DATA_IS_JOURNALLED``
+
+ These indicate whether the filesystem has a journal and whether data
+ changes are logged to it.
+
+ * ``FSINFO_FEAT_O_SYNC``
+ * ``FSINFO_FEAT_O_DIRECT``
+
+ These indicate whether the filesystem supports the O_SYNC and O_DIRECT
+ flags.
+
+ * ``FSINFO_FEAT_VOLUME_ID``
+ * ``FSINFO_FEAT_VOLUME_UUID``
+ * ``FSINFO_FEAT_VOLUME_NAME``
+ * ``FSINFO_FEAT_VOLUME_FSID``
+
+ These indicate whether ID, UUID, name and FSID identifiers actually exist
+ in the filesystem and thus might be considered persistent.
+
+ * ``FSINFO_FEAT_IVER_ALL_CHANGE``
+ * ``FSINFO_FEAT_IVER_DATA_CHANGE``
+ * ``FSINFO_FEAT_IVER_MONO_INCR``
+
+ These indicate whether i_version in the inode is supported and, if so, what
+ mode it operates in. The first two indicate if it's changed for any data
+ or metadata change, or whether it's only changed for any data changes; the
+ last indicates whether or not it's monotonically increasing for each such
+ change.
+
+ * ``FSINFO_FEAT_HARD_LINKS``
+ * ``FSINFO_FEAT_HARD_LINKS_1DIR``
+
+ These indicate whether the filesystem can have hard links made in it, and
+ whether they can be made between directory or only within the same
+ directory.
+
+ * ``FSINFO_FEAT_DIRECTORIES``
+ * ``FSINFO_FEAT_SYMLINKS``
+ * ``FSINFO_FEAT_DEVICE_FILES``
+ * ``FSINFO_FEAT_UNIX_SPECIALS``
+
+ These indicate whether directories; symbolic links; device files; or pipes
+ and sockets can be made within the filesystem.
+
+ * ``FSINFO_FEAT_RESOURCE_FORKS``
+
+ This indicates if the filesystem supports resource forks.
+
+ * ``FSINFO_FEAT_NAME_CASE_INDEP``
+ * ``FSINFO_FEAT_NAME_NON_UTF8``
+ * ``FSINFO_FEAT_NAME_HAS_CODEPAGE``
+
+ These indicate if the filesystem supports case-independent file names,
+ whether the filenames are non-utf8 (see the "FSINFO_ATTR_NAME_ENCODING"
+ attribute) and whether a codepage is in use to transliterate them (see
+ the "FSINFO_ATTR_NAME_CODEPAGE" attribute).
+
+ * ``FSINFO_FEAT_SPARSE``
+
+ This indicates if a filesystem supports sparse files.
+
+ * ``FSINFO_FEAT_NOT_PERSISTENT``
+
+ This indicates if a filesystem is not persistent.
+
+ * ``FSINFO_FEAT_NO_UNIX_MODE``
+
+ This indicates if a filesystem doesn't support UNIX mode bits (though they
+ may be manufactured from other bits, such as Windows file attribute flags).
+
+ * ``FSINFO_FEAT_HAS_ATIME``
+ * ``FSINFO_FEAT_HAS_BTIME``
+ * ``FSINFO_FEAT_HAS_CTIME``
+ * ``FSINFO_FEAT_HAS_MTIME``
+
+ These indicate which timestamps a filesystem supports (access, birth,
+ change, modify). The range and resolutions can be queried with the
+ "FSINFO_ATTR_TIMESTAMPS" attribute).
^ permalink raw reply related
* [PATCH 10/14] fsinfo: sample: Mount listing program [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: dhowells, raven, mszeredi, christian, jannh, darrick.wong, kzak,
jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Implement a program to demonstrate mount listing using the new fsinfo()
syscall. For example, to dump the tree from mount 21:
# ./test-mntinfo -m 21
MOUNT MOUNT ID CHANGE# AT P DEV TYPE
-------------------------------- ---------- -------- -- - ----- --------
21 21 0 e 4 0:14 sysfs
\_ kernel/security 24 0 e 4 0:8 securityfs
\_ fs/cgroup 28 4 2f 4 0:18 tmpfs
| \_ unified 29 0 e 4 0:19 cgroup2
| \_ systemd 30 0 e 4 0:1a cgroup
| \_ blkio 34 0 e 4 0:1e cgroup
| \_ net_cls,net_prio 35 0 e 4 0:1f cgroup
| \_ perf_event 36 0 e 4 0:20 cgroup
| \_ freezer 37 0 e 4 0:21 cgroup
| \_ devices 38 0 e 4 0:22 cgroup
| \_ cpu,cpuacct 39 0 e 4 0:23 cgroup
| \_ rdma 40 0 e 4 0:24 cgroup
| \_ memory 41 0 e 4 0:25 cgroup
| \_ cpuset 42 0 e 4 0:26 cgroup
| \_ hugetlb 43 0 e 4 0:27 cgroup
\_ fs/pstore 31 0 e 4 0:1b pstore
\_ firmware/efi/efivars 32 0 e 4 0:1c efivarfs
\_ fs/bpf 33 0 e 4 0:1d bpf
\_ kernel/config 92 0 0 4 0:28 configfs
\_ fs/selinux 44 0 0 4 0:11 selinuxfs
\_ kernel/debug 45 1 0 4 0:7 debugfs
Signed-off-by: David Howells <dhowells@redhat.com>
---
samples/vfs/Makefile | 2
samples/vfs/test-mntinfo.c | 277 ++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 279 insertions(+)
create mode 100644 samples/vfs/test-mntinfo.c
diff --git a/samples/vfs/Makefile b/samples/vfs/Makefile
index 9159ad1d7fc5..19be60ab950e 100644
--- a/samples/vfs/Makefile
+++ b/samples/vfs/Makefile
@@ -4,12 +4,14 @@
hostprogs := \
test-fsinfo \
test-fsmount \
+ test-mntinfo \
test-statx
always-y := $(hostprogs)
HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include
HOSTLDLIBS_test-fsinfo += -static -lm
+HOSTCFLAGS_test-mntinfo.o += -I$(objtree)/usr/include
HOSTCFLAGS_test-fsmount.o += -I$(objtree)/usr/include
HOSTCFLAGS_test-statx.o += -I$(objtree)/usr/include
diff --git a/samples/vfs/test-mntinfo.c b/samples/vfs/test-mntinfo.c
new file mode 100644
index 000000000000..5d2eb483e3e5
--- /dev/null
+++ b/samples/vfs/test-mntinfo.c
@@ -0,0 +1,277 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Test the fsinfo() system call
+ *
+ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ */
+
+#define _GNU_SOURCE
+#define _ATFILE_SOURCE
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <time.h>
+#include <math.h>
+#include <sys/syscall.h>
+#include <linux/fsinfo.h>
+#include <linux/socket.h>
+#include <linux/fcntl.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+
+#ifndef __NR_fsinfo
+#define __NR_fsinfo -1
+#endif
+
+static __attribute__((unused))
+ssize_t fsinfo(int dfd, const char *filename,
+ struct fsinfo_params *params, size_t params_size,
+ void *result_buffer, size_t result_buf_size)
+{
+ return syscall(__NR_fsinfo, dfd, filename,
+ params, params_size,
+ result_buffer, result_buf_size);
+}
+
+static char tree_buf[4096];
+static char bar_buf[4096];
+static unsigned int children_list_interval;
+
+/*
+ * Get an fsinfo attribute in a statically allocated buffer.
+ */
+static void get_attr(unsigned int mnt_id, unsigned int attr, unsigned int Nth,
+ void *buf, size_t buf_size)
+{
+ struct fsinfo_params params = {
+ .flags = FSINFO_FLAGS_QUERY_MOUNT,
+ .request = attr,
+ .Nth = Nth,
+ };
+ char file[32];
+ long ret;
+
+ sprintf(file, "%u", mnt_id);
+
+ memset(buf, 0xbd, buf_size);
+
+ ret = fsinfo(AT_FDCWD, file, ¶ms, sizeof(params), buf, buf_size);
+ if (ret == -1) {
+ fprintf(stderr, "mount-%s: %m\n", file);
+ exit(1);
+ }
+}
+
+/*
+ * Get an fsinfo attribute in a dynamically allocated buffer.
+ */
+static void *get_attr_alloc(unsigned int mnt_id, unsigned int attr,
+ unsigned int Nth, size_t *_size)
+{
+ struct fsinfo_params params = {
+ .flags = FSINFO_FLAGS_QUERY_MOUNT,
+ .request = attr,
+ .Nth = Nth,
+ };
+ size_t buf_size = 4096;
+ char file[32];
+ void *r;
+ long ret;
+
+ sprintf(file, "%u", mnt_id);
+
+ for (;;) {
+ r = malloc(buf_size);
+ if (!r) {
+ perror("malloc");
+ exit(1);
+ }
+ memset(r, 0xbd, buf_size);
+
+ ret = fsinfo(AT_FDCWD, file, ¶ms, sizeof(params), r, buf_size);
+ if (ret == -1) {
+ fprintf(stderr, "mount-%s: %x,%x,%x %m\n",
+ file, params.request, params.Nth, params.Mth);
+ exit(1);
+ }
+
+ if (ret <= buf_size) {
+ *_size = ret;
+ break;
+ }
+ buf_size = (ret + 4096 - 1) & ~(4096 - 1);
+ }
+
+ return r;
+}
+
+/*
+ * Display a mount and then recurse through its children.
+ */
+static void display_mount(unsigned int mnt_id, unsigned int depth, char *path)
+{
+ struct fsinfo_mount_child child;
+ struct fsinfo_mount_info info;
+ struct fsinfo_ids ids;
+ void *children;
+ unsigned int d;
+ size_t ch_size, p_size;
+ char dev[64];
+ int i, n, s;
+
+ get_attr(mnt_id, FSINFO_ATTR_MOUNT_INFO, 0, &info, sizeof(info));
+ get_attr(mnt_id, FSINFO_ATTR_IDS, 0, &ids, sizeof(ids));
+ if (depth > 0)
+ printf("%s", tree_buf);
+
+ s = strlen(path);
+ printf("%s", !s ? "\"\"" : path);
+ if (!s)
+ s += 2;
+ s += depth;
+ if (s < 38)
+ s = 38 - s;
+ else
+ s = 1;
+ printf("%*.*s", s, s, "");
+
+ sprintf(dev, "%x:%x", ids.f_dev_major, ids.f_dev_minor);
+ printf("%10u %8x %2x %x %5s %s",
+ info.mnt_id,
+ (info.sb_changes +
+ info.sb_notifications +
+ info.mnt_attr_changes +
+ info.mnt_topology_changes +
+ info.mnt_subtree_notifications),
+ info.attr, info.propagation,
+ dev, ids.f_fs_name);
+ putchar('\n');
+
+ children = get_attr_alloc(mnt_id, FSINFO_ATTR_MOUNT_CHILDREN, 0, &ch_size);
+ n = ch_size / children_list_interval - 1;
+
+ bar_buf[depth + 1] = '|';
+ if (depth > 0) {
+ tree_buf[depth - 4 + 1] = bar_buf[depth - 4 + 1];
+ tree_buf[depth - 4 + 2] = ' ';
+ }
+
+ tree_buf[depth + 0] = ' ';
+ tree_buf[depth + 1] = '\\';
+ tree_buf[depth + 2] = '_';
+ tree_buf[depth + 3] = ' ';
+ tree_buf[depth + 4] = 0;
+ d = depth + 4;
+
+ memset(&child, 0, sizeof(child));
+ for (i = 0; i < n; i++) {
+ void *p = children + i * children_list_interval;
+
+ if (sizeof(child) >= children_list_interval)
+ memcpy(&child, p, children_list_interval);
+ else
+ memcpy(&child, p, sizeof(child));
+
+ if (i == n - 1)
+ bar_buf[depth + 1] = ' ';
+ path = get_attr_alloc(child.mnt_id, FSINFO_ATTR_MOUNT_POINT,
+ 0, &p_size);
+ display_mount(child.mnt_id, d, path + 1);
+ free(path);
+ }
+
+ free(children);
+ if (depth > 0) {
+ tree_buf[depth - 4 + 1] = '\\';
+ tree_buf[depth - 4 + 2] = '_';
+ }
+ tree_buf[depth] = 0;
+}
+
+/*
+ * Find the ID of whatever is at the nominated path.
+ */
+static unsigned int lookup_mnt_by_path(const char *path)
+{
+ struct fsinfo_mount_info mnt;
+ struct fsinfo_params params = {
+ .flags = FSINFO_FLAGS_QUERY_PATH,
+ .request = FSINFO_ATTR_MOUNT_INFO,
+ };
+
+ if (fsinfo(AT_FDCWD, path, ¶ms, sizeof(params), &mnt, sizeof(mnt)) == -1) {
+ perror(path);
+ exit(1);
+ }
+
+ return mnt.mnt_id;
+}
+
+/*
+ * Determine the element size for the mount child list.
+ */
+static unsigned int query_list_element_size(int mnt_id, unsigned int attr)
+{
+ struct fsinfo_attribute_info attr_info;
+
+ get_attr(mnt_id, FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, attr,
+ &attr_info, sizeof(attr_info));
+ return attr_info.size;
+}
+
+/*
+ *
+ */
+int main(int argc, char **argv)
+{
+ unsigned int mnt_id;
+ char *path;
+ bool use_mnt_id = false;
+ int opt;
+
+ while ((opt = getopt(argc, argv, "m"))) {
+ switch (opt) {
+ case 'm':
+ use_mnt_id = true;
+ continue;
+ }
+ break;
+ }
+
+ argc -= optind;
+ argv += optind;
+
+ switch (argc) {
+ case 0:
+ mnt_id = lookup_mnt_by_path("/");
+ path = "ROOT";
+ break;
+ case 1:
+ path = argv[0];
+ if (use_mnt_id) {
+ mnt_id = strtoul(argv[0], NULL, 0);
+ break;
+ }
+
+ mnt_id = lookup_mnt_by_path(argv[0]);
+ break;
+ default:
+ printf("Format: test-mntinfo\n");
+ printf("Format: test-mntinfo <path>\n");
+ printf("Format: test-mntinfo -m <mnt_id>\n");
+ exit(2);
+ }
+
+ children_list_interval =
+ query_list_element_size(mnt_id, FSINFO_ATTR_MOUNT_CHILDREN);
+
+ printf("MOUNT MOUNT ID CHANGE# AT P DEV TYPE\n");
+ printf("------------------------------------- ---------- -------- -- - ----- --------\n");
+ display_mount(mnt_id, 0, path);
+ return 0;
+}
^ permalink raw reply related
* [PATCH 09/14] fsinfo: Provide notification overrun handling support [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: dhowells, raven, mszeredi, christian, jannh, darrick.wong, kzak,
jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Provide support for the handling of an overrun in a watch queue. In the
event that an overrun occurs, the watcher needs to be able to find out what
it was that they missed. To this end, previous patches added event
counters to the superblock and mount object structures.
To make them accessible, they can be accessed using fsinfo() and the
FSINFO_ATTR_MOUNT_INFO attribute.
struct fsinfo_mount_info {
__u64 mnt_unique_id;
__u32 sb_changes;
__u32 sb_notifications;
__u32 mnt_attr_changes;
__u32 mnt_topology_changes;
__u32 mnt_subtree_notifications;
...
};
There's a uniquifier and five event counters:
(1) mnt_unique_id - This is an effectively non-repeating ID given to each
mount object on creation. This allows the caller to check that the
mount ID didn't get reused (the 32-bit mount ID is more efficient to
look up).
(2) sb_changes - Count of superblock configuration changes.
(3) sb_notifications - Count of other superblock notifications (errors,
quota overruns, etc.).
(4) mnt_attr_changes - Count of attribute changes on a mount object.
(5) mnt_topology_changes - Count of alterations to the mount tree that
affected this node.
(6) mnt_subtree_notifications - Count of mount object event notifications
that were generated in the subtree rooted at this node. This excludes
events generated on this node itself and does not include superblock
events.
The counters are also accessible through the FSINFO_ATTR_MOUNT_CHILDREN
attribute, where a list of all the children of a mount can be scanned. The
record returned for each child includes the sum of the above five counters
for that child. An additional record is added at the end for the queried
object and that also includes the sum of its five counters
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/namespace.c | 31 ++++++++++++++++++++++++++-----
include/uapi/linux/fsinfo.h | 9 ++++++++-
samples/vfs/test-fsinfo.c | 7 +++++--
3 files changed, 39 insertions(+), 8 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index 88aef45bcfa8..2b651003e6af 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -4167,6 +4167,15 @@ int fsinfo_generic_mount_info(struct path *path, struct fsinfo_context *ctx)
p->mnt_unique_id = m->mnt_unique_id;
p->mnt_id = m->mnt_id;
p->parent_id = m->mnt_parent->mnt_id;
+#ifdef CONFIG_SB_NOTIFICATIONS
+ p->sb_changes = atomic_read(&sb->s_change_counter);
+ p->sb_notifications = atomic_read(&sb->s_notify_counter);
+#endif
+#ifdef CONFIG_MOUNT_NOTIFICATIONS
+ p->mnt_attr_changes = atomic_read(&m->mnt_attr_changes);
+ p->mnt_topology_changes = atomic_read(&m->mnt_topology_changes);
+ p->mnt_subtree_notifications = atomic_read(&m->mnt_subtree_notifications);
+#endif
get_fs_root(current->fs, &root);
if (path->mnt == root.mnt) {
@@ -4293,17 +4302,29 @@ int fsinfo_generic_mount_point_full(struct path *path, struct fsinfo_context *ct
static void fsinfo_store_mount(struct fsinfo_context *ctx, const struct mount *p)
{
struct fsinfo_mount_child record = {};
+ const struct super_block *sb = p->mnt.mnt_sb;
unsigned int usage = ctx->usage;
if (ctx->usage >= INT_MAX)
return;
ctx->usage = usage + sizeof(record);
+ if (!ctx->buffer || ctx->usage > ctx->buf_size)
+ return;
- if (ctx->buffer && ctx->usage <= ctx->buf_size) {
- record.mnt_unique_id = p->mnt_unique_id;
- record.mnt_id = p->mnt_id;
- memcpy(ctx->buffer + usage, &record, sizeof(record));
- }
+ record.mnt_unique_id = p->mnt_unique_id;
+ record.mnt_id = p->mnt_id;
+ record.notify_sum = 0;
+#ifdef CONFIG_SB_NOTIFICATIONS
+ record.notify_sum += (atomic_read(&sb->s_change_counter) +
+ atomic_read(&sb->s_notify_counter));
+#endif
+#ifdef CONFIG_MOUNT_NOTIFICATIONS
+ record.notify_sum += (atomic_read(&p->mnt_attr_changes) +
+ atomic_read(&p->mnt_topology_changes) +
+ atomic_read(&p->mnt_subtree_notifications));
+#endif
+
+ memcpy(ctx->buffer + usage, &record, sizeof(record));
}
/*
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index 909d6104933b..826b788b0795 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -104,6 +104,11 @@ struct fsinfo_mount_info {
__u32 from_id; /* Slave propagated from ID */
__u32 attr; /* MOUNT_ATTR_* flags */
__u32 propagation; /* MOUNT_PROPAGATION_* flags */
+ __u32 sb_changes; /* Number of sb configuration changes */
+ __u32 sb_notifications; /* Number of other sb notifications */
+ __u32 mnt_attr_changes; /* Number of attribute changes to this mount. */
+ __u32 mnt_topology_changes; /* Number of topology changes to this mount. */
+ __u32 mnt_subtree_notifications; /* Number of notifications in mount subtree */
};
#define FSINFO_ATTR_MOUNT_INFO__STRUCT struct fsinfo_mount_info
@@ -115,7 +120,9 @@ struct fsinfo_mount_info {
struct fsinfo_mount_child {
__u64 mnt_unique_id; /* Kernel-lifetime unique mount ID */
__u32 mnt_id; /* Mount identifier (use with AT_FSINFO_MOUNTID_PATH) */
- __u32 __padding[1];
+ __u32 notify_sum; /* Sum of sb_changes, sb_notifications, mnt_attr_changes,
+ * mnt_topology_changes and mnt_subtree_notifications.
+ */
};
#define FSINFO_ATTR_MOUNT_CHILDREN__STRUCT struct fsinfo_mount_child
diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
index bdc7ea952630..91434f459ba5 100644
--- a/samples/vfs/test-fsinfo.c
+++ b/samples/vfs/test-fsinfo.c
@@ -300,6 +300,9 @@ static void dump_fsinfo_generic_mount_info(void *reply, unsigned int size)
printf("\tgroup : %x\n", r->group_id);
printf("\tattr : %x\n", r->attr);
printf("\tpropag : %x\n", r->propagation);
+ printf("\tsb_nfy : changes=%u other=%u\n", r->sb_changes, r->sb_notifications);
+ printf("\tmnt_nfy : attr=%u topology=%u subtree=%u\n",
+ r->mnt_attr_changes, r->mnt_topology_changes, r->mnt_subtree_notifications);
}
static void dump_fsinfo_generic_mount_child(void *reply, unsigned int size)
@@ -322,8 +325,8 @@ static void dump_fsinfo_generic_mount_child(void *reply, unsigned int size)
mp = "<this>";
}
- printf("%8x %16llx %s\n",
- r->mnt_id, (unsigned long long)r->mnt_unique_id, mp);
+ printf("%8x %16llx %10u %s\n",
+ r->mnt_id, (unsigned long long)r->mnt_unique_id, r->notify_sum, mp);
}
static void dump_string(void *reply, unsigned int size)
^ permalink raw reply related
* [PATCH 08/14] fsinfo: Allow the mount topology propogation flags to be retrieved [ver #18]
From: David Howells @ 2020-03-09 14:02 UTC (permalink / raw)
To: torvalds, viro
Cc: dhowells, raven, mszeredi, christian, jannh, darrick.wong, kzak,
jlayton, linux-api, linux-fsdevel, linux-security-module,
linux-kernel
In-Reply-To: <158376244589.344135.12925590041630631412.stgit@warthog.procyon.org.uk>
Allow the mount topology propogation flags to be retrieved as part of the
FSINFO_ATTR_MOUNT_INFO attributes.
Signed-off-by: David Howells <dhowells@redhat.com>
---
fs/namespace.c | 7 ++++++-
include/uapi/linux/fsinfo.h | 2 +-
include/uapi/linux/mount.h | 10 +++++++++-
samples/vfs/test-fsinfo.c | 1 +
4 files changed, 17 insertions(+), 3 deletions(-)
diff --git a/fs/namespace.c b/fs/namespace.c
index a6cb8c6b004f..88aef45bcfa8 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -4177,15 +4177,20 @@ int fsinfo_generic_mount_info(struct path *path, struct fsinfo_context *ctx)
p->parent_id = p->mnt_id;
rcu_read_unlock();
}
- if (IS_MNT_SHARED(m))
+ if (IS_MNT_SHARED(m)) {
p->group_id = m->mnt_group_id;
+ p->propagation |= MOUNT_PROPAGATION_SHARED;
+ }
if (IS_MNT_SLAVE(m)) {
int master = m->mnt_master->mnt_group_id;
int dom = get_dominating_id(m, &root);
p->master_id = master;
if (dom && dom != master)
p->from_id = dom;
+ p->propagation |= MOUNT_PROPAGATION_SLAVE;
}
+ if (IS_MNT_UNBINDABLE(m))
+ p->propagation |= MOUNT_PROPAGATION_UNBINDABLE;
path_put(&root);
flags = READ_ONCE(m->mnt.mnt_flags);
diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
index 7a8b577f54b7..909d6104933b 100644
--- a/include/uapi/linux/fsinfo.h
+++ b/include/uapi/linux/fsinfo.h
@@ -103,7 +103,7 @@ struct fsinfo_mount_info {
__u32 master_id; /* Slave master group ID */
__u32 from_id; /* Slave propagated from ID */
__u32 attr; /* MOUNT_ATTR_* flags */
- __u32 __padding[1];
+ __u32 propagation; /* MOUNT_PROPAGATION_* flags */
};
#define FSINFO_ATTR_MOUNT_INFO__STRUCT struct fsinfo_mount_info
diff --git a/include/uapi/linux/mount.h b/include/uapi/linux/mount.h
index 96a0240f23fe..39e50fe9d8d9 100644
--- a/include/uapi/linux/mount.h
+++ b/include/uapi/linux/mount.h
@@ -105,7 +105,7 @@ enum fsconfig_command {
#define FSMOUNT_CLOEXEC 0x00000001
/*
- * Mount attributes.
+ * Mount object attributes (these are separate to filesystem attributes).
*/
#define MOUNT_ATTR_RDONLY 0x00000001 /* Mount read-only */
#define MOUNT_ATTR_NOSUID 0x00000002 /* Ignore suid and sgid bits */
@@ -117,4 +117,12 @@ enum fsconfig_command {
#define MOUNT_ATTR_STRICTATIME 0x00000020 /* - Always perform atime updates */
#define MOUNT_ATTR_NODIRATIME 0x00000080 /* Do not update directory access times */
+/*
+ * Mount object propogation attributes.
+ */
+#define MOUNT_PROPAGATION_UNBINDABLE 0x00000001 /* Mount is unbindable */
+#define MOUNT_PROPAGATION_SLAVE 0x00000002 /* Mount is slave */
+#define MOUNT_PROPAGATION_PRIVATE 0x00000000 /* Mount is private (ie. not shared) */
+#define MOUNT_PROPAGATION_SHARED 0x00000004 /* Mount is shared */
+
#endif /* _UAPI_LINUX_MOUNT_H */
diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
index 2f9fe3b24bca..bdc7ea952630 100644
--- a/samples/vfs/test-fsinfo.c
+++ b/samples/vfs/test-fsinfo.c
@@ -299,6 +299,7 @@ static void dump_fsinfo_generic_mount_info(void *reply, unsigned int size)
printf("\tparent : %x\n", r->parent_id);
printf("\tgroup : %x\n", r->group_id);
printf("\tattr : %x\n", r->attr);
+ printf("\tpropag : %x\n", r->propagation);
}
static void dump_fsinfo_generic_mount_child(void *reply, unsigned int size)
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox