Introduce fsquota package
This introduces a new fsquota package and
a few low-level support packages to simplify the
management of filesystem quotas.
To expose an API that's nice to use while staying
performant and safe the new fsinfo syscall is being
used. Since that syscall is not yet in mainline it has
been backported to our 5.6 kernel.
Test Plan:
Manually validated on our kernel, automated
tests are pending some Bazel work to be able to run them
inside our own kernel.
X-Origin-Diff: phab/D462
GitOrigin-RevId: bb463056589d2b13b7cf32d48ab0b884e70b1bad
diff --git a/core/pkg/fsquota/BUILD.bazel b/core/pkg/fsquota/BUILD.bazel
new file mode 100644
index 0000000..6971929
--- /dev/null
+++ b/core/pkg/fsquota/BUILD.bazel
@@ -0,0 +1,16 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+ name = "go_default_library",
+ srcs = [
+ "fsinfo.go",
+ "fsquota.go",
+ ],
+ importpath = "git.monogon.dev/source/nexantic.git/core/pkg/fsquota",
+ visibility = ["//visibility:public"],
+ deps = [
+ "//core/pkg/fsquota/fsxattrs:go_default_library",
+ "//core/pkg/fsquota/quotactl:go_default_library",
+ "@org_golang_x_sys//unix:go_default_library",
+ ],
+)
diff --git a/core/pkg/fsquota/fsinfo.go b/core/pkg/fsquota/fsinfo.go
new file mode 100644
index 0000000..e40a533
--- /dev/null
+++ b/core/pkg/fsquota/fsinfo.go
@@ -0,0 +1,59 @@
+// Copyright 2020 The Monogon Project Authors.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fsquota
+
+import (
+ "fmt"
+ "os"
+ "unsafe"
+
+ "golang.org/x/sys/unix"
+)
+
+// This requires fsinfo() support, which is not yet in any stable kernel.
+// Our kernel has that syscall backported. This would otherwise be an extremely expensive
+// operation and also involve lots of logic from our side.
+
+// From syscall_64.tbl
+const sys_fsinfo = 441
+
+// From uapi/linux/fsinfo.h
+const fsinfo_attr_source = 0x09
+const fsinfo_flags_query_path = 0x0000
+const fsinfo_flags_query_fd = 0x0001
+
+type fsinfoParams struct {
+ resolveFlags uint64
+ atFlags uint32
+ flags uint32
+ request uint32
+ nth uint32
+ mth uint32
+}
+
+func fsinfoGetSource(dir *os.File) (string, error) {
+ buf := make([]byte, 256)
+ params := fsinfoParams{
+ flags: fsinfo_flags_query_fd,
+ request: fsinfo_attr_source,
+ }
+ n, _, err := unix.Syscall6(sys_fsinfo, dir.Fd(), 0, uintptr(unsafe.Pointer(¶ms)), unsafe.Sizeof(params), uintptr(unsafe.Pointer(&buf[0])), 128)
+ if err != unix.Errno(0) {
+ return "", fmt.Errorf("failed to call fsinfo: %w", err)
+ }
+ return string(buf[:n]), nil
+}
diff --git a/core/pkg/fsquota/fsquota.go b/core/pkg/fsquota/fsquota.go
new file mode 100644
index 0000000..f4f4050
--- /dev/null
+++ b/core/pkg/fsquota/fsquota.go
@@ -0,0 +1,145 @@
+// Copyright 2020 The Monogon Project Authors.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package fsquota provides a simplified interface to interact with Linux's filesystem qouta API.
+// It only supports setting quotas on directories, not groups or users.
+// Quotas need to be already enabled on the filesystem to be able to use them using this package.
+// See the quotactl package if you intend to use this on a filesystem where quotas need to be
+// enabled manually.
+package fsquota
+
+import (
+ "fmt"
+ "math"
+ "os"
+
+ "git.monogon.dev/source/nexantic.git/core/pkg/fsquota/fsxattrs"
+ "git.monogon.dev/source/nexantic.git/core/pkg/fsquota/quotactl"
+ "golang.org/x/sys/unix"
+)
+
+// SetQuota sets the quota of bytes and/or inodes in a given path. To not set a limit, set the
+// corresponding argument to zero. Setting both arguments to zero removes the quota entirely.
+// This function can only be called on an empty directory. It can't be used to create a quota
+// below a directory which already has a quota since Linux doesn't offer hierarchical quotas.
+func SetQuota(path string, maxBytes uint64, maxInodes uint64) error {
+ dir, err := os.Open(path)
+ if err != nil {
+ return err
+ }
+ defer dir.Close()
+ source, err := fsinfoGetSource(dir)
+ if err != nil {
+ return err
+ }
+ var valid uint32
+ if maxBytes > 0 {
+ valid |= quotactl.FlagBLimitsValid
+ }
+ if maxInodes > 0 {
+ valid |= quotactl.FlagILimitsValid
+ }
+
+ attrs, err := fsxattrs.Get(dir)
+ if err != nil {
+ return err
+ }
+
+ var lastID uint32 = attrs.ProjectID
+ if lastID == 0 {
+ // No project/quota exists for this directory, assign a new project quota
+ // TODO(lorenz): This is racy, but the kernel does not support atomically assigning
+ // quotas. So this needs to be added to the kernels setquota interface. Due to the short
+ // time window and infrequent calls this should not be an immediate issue.
+ for {
+ quota, err := quotactl.GetNextQuota(source, quotactl.QuotaTypeProject, lastID)
+ if err == unix.ENOENT || err == unix.ESRCH {
+ // We have enumerated all quotas, nothing exists here
+ break
+ } else if err != nil {
+ return fmt.Errorf("failed to call GetNextQuota: %w", err)
+ }
+ if quota.ID > lastID+1 {
+ // Take the first ID in the quota ID gap
+ lastID++
+ break
+ }
+ lastID++
+ }
+ }
+
+ // If both limits are zero, this is a delete operation, process it as such
+ if maxBytes == 0 && maxInodes == 0 {
+ valid = quotactl.FlagBLimitsValid | quotactl.FlagILimitsValid
+ attrs.ProjectID = 0
+ attrs.Flags &= ^fsxattrs.FlagProjectInherit
+ } else {
+ attrs.ProjectID = lastID
+ attrs.Flags |= fsxattrs.FlagProjectInherit
+ }
+
+ if err := fsxattrs.Set(dir, attrs); err != nil {
+ return err
+ }
+
+ // Always round up to the nearest block size
+ bytesLimitBlocks := uint64(math.Ceil(float64(maxBytes) / float64(1024)))
+
+ return quotactl.SetQuota(source, quotactl.QuotaTypeProject, lastID, "actl.Quota{
+ BHardLimit: bytesLimitBlocks,
+ BSoftLimit: bytesLimitBlocks,
+ IHardLimit: maxInodes,
+ ISoftLimit: maxInodes,
+ Valid: valid,
+ })
+}
+
+type Quota struct {
+ Bytes uint64
+ BytesUsed uint64
+ Inodes uint64
+ InodesUsed uint64
+}
+
+// GetQuota returns the current active quota and its utilization at the given path
+func GetQuota(path string) (*Quota, error) {
+ dir, err := os.Open(path)
+ if err != nil {
+ return nil, err
+ }
+ defer dir.Close()
+ source, err := fsinfoGetSource(dir)
+ if err != nil {
+ return nil, err
+ }
+ attrs, err := fsxattrs.Get(dir)
+ if err != nil {
+ return nil, err
+ }
+ if attrs.ProjectID == 0 {
+ return nil, os.ErrNotExist
+ }
+ quota, err := quotactl.GetQuota(source, quotactl.QuotaTypeProject, attrs.ProjectID)
+ if err != nil {
+ return nil, err
+ }
+ return &Quota{
+ Bytes: quota.BHardLimit,
+ BytesUsed: quota.CurSpace,
+ Inodes: quota.IHardLimit,
+ InodesUsed: quota.CurInodes,
+ }, nil
+}
diff --git a/core/pkg/fsquota/fsxattrs/BUILD.bazel b/core/pkg/fsquota/fsxattrs/BUILD.bazel
new file mode 100644
index 0000000..64cbf9a
--- /dev/null
+++ b/core/pkg/fsquota/fsxattrs/BUILD.bazel
@@ -0,0 +1,9 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+ name = "go_default_library",
+ srcs = ["fsxattrs.go"],
+ importpath = "git.monogon.dev/source/nexantic.git/core/pkg/fsquota/fsxattrs",
+ visibility = ["//visibility:public"],
+ deps = ["@org_golang_x_sys//unix:go_default_library"],
+)
diff --git a/core/pkg/fsquota/fsxattrs/fsxattrs.go b/core/pkg/fsquota/fsxattrs/fsxattrs.go
new file mode 100644
index 0000000..1d455eb
--- /dev/null
+++ b/core/pkg/fsquota/fsxattrs/fsxattrs.go
@@ -0,0 +1,77 @@
+// Copyright 2020 The Monogon Project Authors.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package fsxattrs
+
+import (
+ "fmt"
+ "os"
+ "unsafe"
+
+ "golang.org/x/sys/unix"
+)
+
+type FSXAttrFlag uint32
+
+// Defined in uapi/linux/fs.h
+const (
+ FlagRealtime FSXAttrFlag = 0x00000001
+ FlagPreallocated FSXAttrFlag = 0x00000002
+ FlagImmutable FSXAttrFlag = 0x00000008
+ FlagAppend FSXAttrFlag = 0x00000010
+ FlagSync FSXAttrFlag = 0x00000020
+ FlagNoATime FSXAttrFlag = 0x00000040
+ FlagNoDump FSXAttrFlag = 0x00000080
+ FlagRealtimeInherit FSXAttrFlag = 0x00000100
+ FlagProjectInherit FSXAttrFlag = 0x00000200
+ FlagNoSymlinks FSXAttrFlag = 0x00000400
+ FlagExtentSize FSXAttrFlag = 0x00000800
+ FlagNoDefragment FSXAttrFlag = 0x00002000
+ FlagFilestream FSXAttrFlag = 0x00004000
+ FlagDAX FSXAttrFlag = 0x00008000
+ FlagCOWExtentSize FSXAttrFlag = 0x00010000
+ FlagHasAttribute FSXAttrFlag = 0x80000000
+)
+
+// FS_IOC_FSGETXATTR/FS_IOC_FSSETXATTR are defined in uapi/linux/fs.h
+const FS_IOC_FSGETXATTR = 0x801c581f
+const FS_IOC_FSSETXATTR = 0x401c5820
+
+type FSXAttrs struct {
+ Flags FSXAttrFlag
+ ExtentSize uint32
+ ExtentCount uint32
+ ProjectID uint32
+ CoWExtentSize uint32
+ _pad [8]byte
+}
+
+func Get(file *os.File) (*FSXAttrs, error) {
+ var attrs FSXAttrs
+ _, _, errno := unix.Syscall(unix.SYS_IOCTL, file.Fd(), FS_IOC_FSGETXATTR, uintptr(unsafe.Pointer(&attrs)))
+ if errno != 0 {
+ return nil, fmt.Errorf("failed to execute getFSXAttrs: %v", errno)
+ }
+ return &attrs, nil
+}
+
+func Set(file *os.File, attrs *FSXAttrs) error {
+ _, _, errno := unix.Syscall(unix.SYS_IOCTL, file.Fd(), FS_IOC_FSSETXATTR, uintptr(unsafe.Pointer(attrs)))
+ if errno != 0 {
+ return fmt.Errorf("failed to execute setFSXAttrs: %v", errno)
+ }
+ return nil
+}
diff --git a/core/pkg/fsquota/quotactl/BUILD.bazel b/core/pkg/fsquota/quotactl/BUILD.bazel
new file mode 100644
index 0000000..de5d085
--- /dev/null
+++ b/core/pkg/fsquota/quotactl/BUILD.bazel
@@ -0,0 +1,9 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+ name = "go_default_library",
+ srcs = ["quotactl.go"],
+ importpath = "git.monogon.dev/source/nexantic.git/core/pkg/fsquota/quotactl",
+ visibility = ["//visibility:public"],
+ deps = ["@org_golang_x_sys//unix:go_default_library"],
+)
diff --git a/core/pkg/fsquota/quotactl/quotactl.go b/core/pkg/fsquota/quotactl/quotactl.go
new file mode 100644
index 0000000..5ed77d7
--- /dev/null
+++ b/core/pkg/fsquota/quotactl/quotactl.go
@@ -0,0 +1,233 @@
+// Copyright 2020 The Monogon Project Authors.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package quotactl implements a low-level wrapper around the modern portion of Linux's
+// quotactl() syscall. See the fsquota package for a nicer interface to the most common part
+// of this API.
+package quotactl
+
+import (
+ "fmt"
+ "unsafe"
+
+ "golang.org/x/sys/unix"
+)
+
+type QuotaType uint
+
+const (
+ QuotaTypeUser QuotaType = iota
+ QuotaTypeGroup
+ QuotaTypeProject
+)
+
+const (
+ Q_SYNC uint = ((0x800001 + iota) << 8)
+ Q_QUOTAON
+ Q_QUOTAOFF
+ Q_GETFMT
+ Q_GETINFO
+ Q_SETINFO
+ Q_GETQUOTA
+ Q_SETQUOTA
+ Q_GETNEXTQUOTA
+)
+
+const (
+ FlagBLimitsValid = 1 << iota
+ FlagSpaceValid
+ FlagILimitsValid
+ FlagInodesValid
+ FlagBTimeValid
+ FlagITimeValid
+)
+
+type DQInfo struct {
+ Bgrace uint64
+ Igrace uint64
+ Flags uint32
+ Valid uint32
+}
+
+type Quota struct {
+ BHardLimit uint64 // Both Byte limits are prescaled by 1024 (so are in KiB), but CurSpace is in B
+ BSoftLimit uint64
+ CurSpace uint64
+ IHardLimit uint64
+ ISoftLimit uint64
+ CurInodes uint64
+ BTime uint64
+ ITime uint64
+ Valid uint32
+}
+
+type NextDQBlk struct {
+ HardLimitBytes uint64
+ SoftLimitBytes uint64
+ CurrentBytes uint64
+ HardLimitInodes uint64
+ SoftLimitInodes uint64
+ CurrentInodes uint64
+ BTime uint64
+ ITime uint64
+ Valid uint32
+ ID uint32
+}
+
+type QuotaFormat uint32
+
+// Collected from quota_format_type structs
+const (
+ // QuotaFormatNone is a special case where all quota information is
+ // stored inside filesystem metadata and thus requires no quotaFilePath.
+ QuotaFormatNone QuotaFormat = 0
+ QuotaFormatVFSOld QuotaFormat = 1
+ QuotaFormatVFSV0 QuotaFormat = 2
+ QuotaFormatOCFS2 QuotaFormat = 3
+ QuotaFormatVFSV1 QuotaFormat = 4
+)
+
+// QuotaOn turns quota accounting and enforcement on
+func QuotaOn(device string, qtype QuotaType, quotaFormat QuotaFormat, quotaFilePath string) error {
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return err
+ }
+ pathArg, err := unix.BytePtrFromString(quotaFilePath)
+ if err != nil {
+ return err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_QUOTAON|uint(qtype)), uintptr(unsafe.Pointer(devArg)), uintptr(quotaFormat), uintptr(unsafe.Pointer(pathArg)), 0, 0)
+ if err != unix.Errno(0) {
+ return err
+ }
+ return nil
+}
+
+// QuotaOff turns quotas off
+func QuotaOff(device string, qtype QuotaType) error {
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_QUOTAOFF|uint(qtype)), uintptr(unsafe.Pointer(devArg)), 0, 0, 0, 0)
+ if err != unix.Errno(0) {
+ return err
+ }
+ return nil
+}
+
+// GetFmt gets the quota format used on given filesystem
+func GetFmt(device string, qtype QuotaType) (uint32, error) {
+ var fmt uint32
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return 0, err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_GETFMT|uint(qtype)), uintptr(unsafe.Pointer(devArg)), 0, uintptr(unsafe.Pointer(&fmt)), 0, 0)
+ if err != unix.Errno(0) {
+ return 0, err
+ }
+ return fmt, nil
+}
+
+// GetInfo gets information about quota files
+func GetInfo(device string, qtype QuotaType) (*DQInfo, error) {
+ var info DQInfo
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return nil, err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_GETINFO|uint(qtype)), uintptr(unsafe.Pointer(devArg)), 0, uintptr(unsafe.Pointer(&info)), 0, 0)
+ if err != unix.Errno(0) {
+ return nil, err
+ }
+ return &info, nil
+}
+
+// SetInfo sets information about quota files
+func SetInfo(device string, qtype QuotaType, info *DQInfo) error {
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_SETINFO|uint(qtype)), uintptr(unsafe.Pointer(devArg)), 0, uintptr(unsafe.Pointer(info)), 0, 0)
+ if err != unix.Errno(0) {
+ return err
+ }
+ return nil
+}
+
+// GetQuota gets user quota structure
+func GetQuota(device string, qtype QuotaType, id uint32) (*Quota, error) {
+ var info Quota
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return nil, err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_GETQUOTA|uint(qtype)), uintptr(unsafe.Pointer(devArg)), uintptr(id), uintptr(unsafe.Pointer(&info)), 0, 0)
+ if err != unix.Errno(0) {
+ return nil, err
+ }
+ return &info, nil
+}
+
+// GetNextQuota gets disk limits and usage > ID
+func GetNextQuota(device string, qtype QuotaType, id uint32) (*NextDQBlk, error) {
+ var info NextDQBlk
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return nil, err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_GETNEXTQUOTA|uint(qtype)), uintptr(unsafe.Pointer(devArg)), uintptr(id), uintptr(unsafe.Pointer(&info)), 0, 0)
+ if err != unix.Errno(0) {
+ return nil, err
+ }
+ return &info, nil
+}
+
+// SetQuota sets the given quota
+func SetQuota(device string, qtype QuotaType, id uint32, quota *Quota) error {
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_SETQUOTA|uint(qtype)), uintptr(unsafe.Pointer(devArg)), uintptr(id), uintptr(unsafe.Pointer(quota)), 0, 0)
+ if err != unix.Errno(0) {
+ return fmt.Errorf("failed to set quota: %w", err)
+ }
+ return nil
+}
+
+// Sync syncs disk copy of filesystems quotas. If device is empty it syncs all filesystems.
+func Sync(device string) error {
+ if device != "" {
+ devArg, err := unix.BytePtrFromString(device)
+ if err != nil {
+ return err
+ }
+ _, _, err = unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_SYNC), uintptr(unsafe.Pointer(devArg)), 0, 0, 0, 0)
+ if err != unix.Errno(0) {
+ return err
+ }
+ } else {
+ _, _, err := unix.Syscall6(unix.SYS_QUOTACTL, uintptr(Q_SYNC), 0, 0, 0, 0, 0)
+ if err != unix.Errno(0) {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/third_party/linux/external.bzl b/third_party/linux/external.bzl
index 1690205..6057543 100644
--- a/third_party/linux/external.bzl
+++ b/third_party/linux/external.bzl
@@ -28,6 +28,10 @@
patches = [
# Enable built-in cmdline for efistub
"//third_party/linux/external:0001-x86-Allow-built-in-command-line-to-work-in-early-ker.patch",
+ # Add fsinfo() syscall
+ "//third_party/linux/external:0002-watch_queue-Introduce-a-non-repeating-system-unique-.patch",
+ "//third_party/linux/external:0003-fsinfo-Add-fsinfo-syscall-to-query-filesystem-inform.patch",
+ "//third_party/linux/external:0004-fsinfo-Allow-retrieval-of-superblock-devname-options.patch",
],
sha256 = sums[version],
strip_prefix = "linux-" + version,
diff --git a/third_party/linux/external/0002-watch_queue-Introduce-a-non-repeating-system-unique-.patch b/third_party/linux/external/0002-watch_queue-Introduce-a-non-repeating-system-unique-.patch
new file mode 100644
index 0000000..c3d4367
--- /dev/null
+++ b/third_party/linux/external/0002-watch_queue-Introduce-a-non-repeating-system-unique-.patch
@@ -0,0 +1,98 @@
+From 695a880f7d1bf86090dae3c32e3dc67c30917267 Mon Sep 17 00:00:00 2001
+From: David Howells <dhowells@redhat.com>
+Date: Fri, 5 Jul 2019 11:10:10 +0100
+Subject: [PATCH 2/4] watch_queue: Introduce a non-repeating system-unique
+ superblock ID
+
+Introduce an (effectively) non-repeating system-unique superblock ID that
+can be used to determine that two object are in the same superblock without
+risking reuse of the ID in the meantime (as is possible with device IDs).
+
+The ID is time-based to make it harder to use it as a covert communications
+channel.
+
+In future patches, this ID will be used to tag superblock notification
+messages. It will also be made queryable.
+
+Signed-off-by: David Howells <dhowells@redhat.com>
+---
+ fs/internal.h | 1 +
+ fs/super.c | 24 ++++++++++++++++++++++++
+ include/linux/fs.h | 3 +++
+ 3 files changed, 28 insertions(+)
+
+diff --git a/fs/internal.h b/fs/internal.h
+index f3f280b952a3..a0d90f23593c 100644
+--- a/fs/internal.h
++++ b/fs/internal.h
+@@ -109,6 +109,7 @@ extern int reconfigure_super(struct fs_context *);
+ extern bool trylock_super(struct super_block *sb);
+ extern struct super_block *user_get_super(dev_t);
+ extern bool mount_capable(struct fs_context *);
++extern void vfs_generate_unique_id(u64 *);
+
+ /*
+ * open.c
+diff --git a/fs/super.c b/fs/super.c
+index cd352530eca9..ececa5695fd1 100644
+--- a/fs/super.c
++++ b/fs/super.c
+@@ -44,6 +44,8 @@ static int thaw_super_locked(struct super_block *sb);
+
+ static LIST_HEAD(super_blocks);
+ static DEFINE_SPINLOCK(sb_lock);
++static u64 vfs_last_identifier;
++static u64 vfs_identifier_offset;
+
+ static char *sb_writers_name[SB_FREEZE_LEVELS] = {
+ "sb_writers",
+@@ -273,6 +275,7 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,
+ goto fail;
+ if (list_lru_init_memcg(&s->s_inode_lru, &s->s_shrink))
+ goto fail;
++ vfs_generate_unique_id(&s->s_unique_id);
+ return s;
+
+ fail:
+@@ -1867,3 +1870,24 @@ int thaw_super(struct super_block *sb)
+ return thaw_super_locked(sb);
+ }
+ EXPORT_SYMBOL(thaw_super);
++
++/*
++ * Generate a unique identifier for a superblock or mount object.
++ */
++void vfs_generate_unique_id(u64 *_id)
++{
++ u64 id = ktime_to_ns(ktime_get());
++
++ spin_lock(&sb_lock);
++
++ id += vfs_identifier_offset;
++ if (id <= vfs_last_identifier) {
++ id = vfs_last_identifier + 1;
++ vfs_identifier_offset = vfs_last_identifier - id;
++ }
++
++ vfs_last_identifier = id;
++ spin_unlock(&sb_lock);
++
++ *_id = id;
++}
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index abedbffe2c9e..fb0db8474141 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -1549,6 +1549,9 @@ struct super_block {
+
+ spinlock_t s_inode_wblist_lock;
+ struct list_head s_inodes_wb; /* writeback inodes */
++
++ /* Superblock event notifications */
++ u64 s_unique_id;
+ } __randomize_layout;
+
+ /* Helper functions so that in most cases filesystems will
+--
+2.20.1
+
diff --git a/third_party/linux/external/0003-fsinfo-Add-fsinfo-syscall-to-query-filesystem-inform.patch b/third_party/linux/external/0003-fsinfo-Add-fsinfo-syscall-to-query-filesystem-inform.patch
new file mode 100644
index 0000000..91ae975
--- /dev/null
+++ b/third_party/linux/external/0003-fsinfo-Add-fsinfo-syscall-to-query-filesystem-inform.patch
@@ -0,0 +1,1937 @@
+From c91b96ad3f53de22e11d6692d2d8a80ed611a5a5 Mon Sep 17 00:00:00 2001
+From: David Howells <dhowells@redhat.com>
+Date: Fri, 6 Mar 2020 14:59:51 +0000
+Subject: [PATCH 3/4] fsinfo: Add fsinfo() syscall to query filesystem
+ information
+
+Add a system call to allow filesystem information to be queried. A request
+value can be given to indicate the desired attribute. Support is provided
+for enumerating multi-value attributes.
+
+===============
+NEW SYSTEM CALL
+===============
+
+The new system call looks like:
+
+ int ret = fsinfo(int dfd,
+ const char *pathname,
+ const struct fsinfo_params *params,
+ size_t params_size,
+ void *result_buffer,
+ size_t result_buf_size);
+
+The params parameter optionally points to a block of parameters:
+
+ struct fsinfo_params {
+ __u64 resolve_flags;
+ __u32 at_flags;
+ __u32 flags;
+ __u32 request;
+ __u32 Nth;
+ __u32 Mth;
+ };
+
+If params is NULL, the default is that params->request is
+FSINFO_ATTR_STATFS and all the other fields are 0. params_size indicates
+the size of the parameter struct. If the parameter block is short compared
+to what the kernel expects, the missing length will be set to 0; if the
+parameter block is longer, an error will be given if the excess is not all
+zeros.
+
+The object to be queried is specified as follows - part param->flags
+indicates the type of reference:
+
+ (1) FSINFO_FLAGS_QUERY_PATH - dfd, pathname and at_flags indicate a
+ filesystem object to query.
+
+ There is no separate system call providing an analogue of lstat() -
+ AT_SYMLINK_NOFOLLOW should be set in at_flags instead.
+ AT_NO_AUTOMOUNT can also be used to an allow automount point to be
+ queried without triggering it.
+
+ RESOLVE_* flags can also be set in resolve_flags to further restrict
+ the patchwalk.
+
+ (2) FSINFO_FLAGS_QUERY_FD - dfd indicates a file descriptor pointing to
+ the filesystem object to query. pathname should be NULL.
+
+ (3) FSINFO_FLAGS_QUERY_MOUNT - pathname indicates the numeric ID of the
+ mountpoint to query as a string. dfd is used to constrain which
+ mounts can be accessed. If dfd is AT_FDCWD, the mount must be within
+ the subtree rooted at chroot, otherwise the mount must be within the
+ subtree rooted at the directory specified by dfd.
+
+ (4) In the future FSINFO_FLAGS_QUERY_FSCONTEXT will be added - dfd will
+ indicate a context handle fd obtained from fsopen() or fspick(),
+ allowing that to be queried before the target superblock is attached
+ to the filesystem or even created.
+
+params->request indicates the attribute/attributes to be queried. This can
+be one of:
+
+ FSINFO_ATTR_STATFS - statfs-style info
+ FSINFO_ATTR_IDS - Filesystem IDs
+ FSINFO_ATTR_LIMITS - Filesystem limits
+ FSINFO_ATTR_SUPPORTS - Support for statx, ioctl, etc.
+ FSINFO_ATTR_TIMESTAMP_INFO - Inode timestamp info
+ FSINFO_ATTR_VOLUME_ID - Volume ID (string)
+ FSINFO_ATTR_VOLUME_UUID - Volume UUID
+ FSINFO_ATTR_VOLUME_NAME - Volume name (string)
+ FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO - Information about attr Nth
+ FSINFO_ATTR_FSINFO_ATTRIBUTES - List of supported attrs
+
+Some attributes (such as the servers backing a network filesystem) can have
+multiple values. These can be enumerated by setting params->Nth and
+params->Mth to 0, 1, ... until ENODATA is returned.
+
+result_buffer and result_buf_size point to the reply buffer. The buffer is
+filled up to the specified size, even if this means truncating the reply.
+The size of the full reply is returned, irrespective of the amount data
+that was copied. In future versions, this will allow extra fields to be
+tacked on to the end of the reply, but anyone not expecting them will only
+get the subset they're expecting. If either buffer of result_buf_size are
+0, no copy will take place and the data size will be returned.
+
+Backported for Linux 5.6 by Lorenz Brun <lorenz@nexantic.com>
+
+Signed-off-by: David Howells <dhowells@redhat.com>
+cc: linux-api@vger.kernel.org
+---
+ arch/alpha/kernel/syscalls/syscall.tbl | 1 +
+ arch/arm/tools/syscall.tbl | 1 +
+ arch/arm64/include/asm/unistd.h | 2 +-
+ arch/arm64/include/asm/unistd32.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/fsinfo.c | 586 ++++++++++++++++++
+ include/linux/fs.h | 4 +
+ include/linux/fsinfo.h | 73 +++
+ include/linux/syscalls.h | 4 +
+ include/uapi/asm-generic/unistd.h | 4 +-
+ include/uapi/linux/fsinfo.h | 187 ++++++
+ kernel/sys_ni.c | 1 +
+ samples/vfs/Makefile | 5 +
+ samples/vfs/test-fsinfo.c | 633 ++++++++++++++++++++
+ 29 files changed, 1523 insertions(+), 2 deletions(-)
+ create mode 100644 fs/fsinfo.c
+ create mode 100644 include/linux/fsinfo.h
+ create mode 100644 include/uapi/linux/fsinfo.h
+ create mode 100644 samples/vfs/test-fsinfo.c
+
+diff --git a/arch/alpha/kernel/syscalls/syscall.tbl b/arch/alpha/kernel/syscalls/syscall.tbl
+index 36d42da7466a..59388edc444a 100644
+--- a/arch/alpha/kernel/syscalls/syscall.tbl
++++ b/arch/alpha/kernel/syscalls/syscall.tbl
+@@ -477,3 +477,4 @@
+ # 545 reserved for clone3
+ 547 common openat2 sys_openat2
+ 548 common pidfd_getfd sys_pidfd_getfd
++551 common fsinfo sys_fsinfo
+diff --git a/arch/arm/tools/syscall.tbl b/arch/arm/tools/syscall.tbl
+index 4d1cf74a2caa..a670f6add5ab 100644
+--- a/arch/arm/tools/syscall.tbl
++++ b/arch/arm/tools/syscall.tbl
+@@ -451,3 +451,4 @@
+ 435 common clone3 sys_clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/arm64/include/asm/unistd.h b/arch/arm64/include/asm/unistd.h
+index 803039d504de..86a9d7b3eabe 100644
+--- a/arch/arm64/include/asm/unistd.h
++++ b/arch/arm64/include/asm/unistd.h
+@@ -38,7 +38,7 @@
+ #define __ARM_NR_compat_set_tls (__ARM_NR_COMPAT_BASE + 5)
+ #define __ARM_NR_COMPAT_END (__ARM_NR_COMPAT_BASE + 0x800)
+
+-#define __NR_compat_syscalls 439
++#define __NR_compat_syscalls 442
+ #endif
+
+ #define __ARCH_WANT_SYS_CLONE
+diff --git a/arch/arm64/include/asm/unistd32.h b/arch/arm64/include/asm/unistd32.h
+index c1c61635f89c..1f7d2c8d481a 100644
+--- a/arch/arm64/include/asm/unistd32.h
++++ b/arch/arm64/include/asm/unistd32.h
+@@ -883,6 +883,8 @@ __SYSCALL(__NR_clone3, sys_clone3)
+ __SYSCALL(__NR_openat2, sys_openat2)
+ #define __NR_pidfd_getfd 438
+ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
++#define __NR_fsinfo 441
++__SYSCALL(__NR_fsinfo, sys_fsinfo)
+
+ /*
+ * Please add new compat syscalls above this comment and update
+diff --git a/arch/ia64/kernel/syscalls/syscall.tbl b/arch/ia64/kernel/syscalls/syscall.tbl
+index 042911e670b8..2a4aea2f1050 100644
+--- a/arch/ia64/kernel/syscalls/syscall.tbl
++++ b/arch/ia64/kernel/syscalls/syscall.tbl
+@@ -358,3 +358,4 @@
+ # 435 reserved for clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/m68k/kernel/syscalls/syscall.tbl b/arch/m68k/kernel/syscalls/syscall.tbl
+index f4f49fcb76d0..9e254f0ef8ea 100644
+--- a/arch/m68k/kernel/syscalls/syscall.tbl
++++ b/arch/m68k/kernel/syscalls/syscall.tbl
+@@ -437,3 +437,4 @@
+ 435 common clone3 __sys_clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/microblaze/kernel/syscalls/syscall.tbl b/arch/microblaze/kernel/syscalls/syscall.tbl
+index 4c67b11f9c9e..75924284ee3b 100644
+--- a/arch/microblaze/kernel/syscalls/syscall.tbl
++++ b/arch/microblaze/kernel/syscalls/syscall.tbl
+@@ -443,3 +443,4 @@
+ 435 common clone3 sys_clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/mips/kernel/syscalls/syscall_n32.tbl b/arch/mips/kernel/syscalls/syscall_n32.tbl
+index 1f9e8ad636cc..4e03df1d67d0 100644
+--- a/arch/mips/kernel/syscalls/syscall_n32.tbl
++++ b/arch/mips/kernel/syscalls/syscall_n32.tbl
+@@ -376,3 +376,4 @@
+ 435 n32 clone3 __sys_clone3
+ 437 n32 openat2 sys_openat2
+ 438 n32 pidfd_getfd sys_pidfd_getfd
++441 n32 fsinfo sys_fsinfo
+diff --git a/arch/mips/kernel/syscalls/syscall_n64.tbl b/arch/mips/kernel/syscalls/syscall_n64.tbl
+index c0b9d802dbf6..fdcc5ca0a776 100644
+--- a/arch/mips/kernel/syscalls/syscall_n64.tbl
++++ b/arch/mips/kernel/syscalls/syscall_n64.tbl
+@@ -352,3 +352,4 @@
+ 435 n64 clone3 __sys_clone3
+ 437 n64 openat2 sys_openat2
+ 438 n64 pidfd_getfd sys_pidfd_getfd
++441 n64 fsinfo sys_fsinfo
+diff --git a/arch/mips/kernel/syscalls/syscall_o32.tbl b/arch/mips/kernel/syscalls/syscall_o32.tbl
+index ac586774c980..17fb101db45c 100644
+--- a/arch/mips/kernel/syscalls/syscall_o32.tbl
++++ b/arch/mips/kernel/syscalls/syscall_o32.tbl
+@@ -425,3 +425,4 @@
+ 435 o32 clone3 __sys_clone3
+ 437 o32 openat2 sys_openat2
+ 438 o32 pidfd_getfd sys_pidfd_getfd
++441 o32 fsinfo sys_fsinfo
+diff --git a/arch/parisc/kernel/syscalls/syscall.tbl b/arch/parisc/kernel/syscalls/syscall.tbl
+index 52a15f5cd130..daa7f0c22da0 100644
+--- a/arch/parisc/kernel/syscalls/syscall.tbl
++++ b/arch/parisc/kernel/syscalls/syscall.tbl
+@@ -435,3 +435,4 @@
+ 435 common clone3 sys_clone3_wrapper
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/powerpc/kernel/syscalls/syscall.tbl b/arch/powerpc/kernel/syscalls/syscall.tbl
+index 35b61bfc1b1a..ad1de6e3e866 100644
+--- a/arch/powerpc/kernel/syscalls/syscall.tbl
++++ b/arch/powerpc/kernel/syscalls/syscall.tbl
+@@ -519,3 +519,4 @@
+ 435 nospu clone3 ppc_clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/s390/kernel/syscalls/syscall.tbl b/arch/s390/kernel/syscalls/syscall.tbl
+index bd7bd3581a0f..915ee9824956 100644
+--- a/arch/s390/kernel/syscalls/syscall.tbl
++++ b/arch/s390/kernel/syscalls/syscall.tbl
+@@ -440,3 +440,4 @@
+ 435 common clone3 sys_clone3 sys_clone3
+ 437 common openat2 sys_openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo sys_fsinfo
+diff --git a/arch/sh/kernel/syscalls/syscall.tbl b/arch/sh/kernel/syscalls/syscall.tbl
+index c7a30fcd135f..35facfae37c9 100644
+--- a/arch/sh/kernel/syscalls/syscall.tbl
++++ b/arch/sh/kernel/syscalls/syscall.tbl
+@@ -440,3 +440,4 @@
+ # 435 reserved for clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/sparc/kernel/syscalls/syscall.tbl b/arch/sparc/kernel/syscalls/syscall.tbl
+index f13615ecdecc..45adfd34b654 100644
+--- a/arch/sparc/kernel/syscalls/syscall.tbl
++++ b/arch/sparc/kernel/syscalls/syscall.tbl
+@@ -483,3 +483,4 @@
+ # 435 reserved for clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/arch/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl
+index c17cb77eb150..37aa4ed3dbef 100644
+--- a/arch/x86/entry/syscalls/syscall_32.tbl
++++ b/arch/x86/entry/syscalls/syscall_32.tbl
+@@ -442,3 +442,4 @@
+ 435 i386 clone3 sys_clone3 __ia32_sys_clone3
+ 437 i386 openat2 sys_openat2 __ia32_sys_openat2
+ 438 i386 pidfd_getfd sys_pidfd_getfd __ia32_sys_pidfd_getfd
++441 i386 fsinfo sys_fsinfo __ia32_sys_fsinfo
+diff --git a/arch/x86/entry/syscalls/syscall_64.tbl b/arch/x86/entry/syscalls/syscall_64.tbl
+index 44d510bc9b78..eacf0b7c5c3d 100644
+--- a/arch/x86/entry/syscalls/syscall_64.tbl
++++ b/arch/x86/entry/syscalls/syscall_64.tbl
+@@ -359,6 +359,7 @@
+ 435 common clone3 __x64_sys_clone3/ptregs
+ 437 common openat2 __x64_sys_openat2
+ 438 common pidfd_getfd __x64_sys_pidfd_getfd
++441 common fsinfo __x64_sys_fsinfo
+
+ #
+ # x32-specific system call numbers start at 512 to avoid cache impact
+diff --git a/arch/xtensa/kernel/syscalls/syscall.tbl b/arch/xtensa/kernel/syscalls/syscall.tbl
+index 85a9ab1bc04d..4d7803550754 100644
+--- a/arch/xtensa/kernel/syscalls/syscall.tbl
++++ b/arch/xtensa/kernel/syscalls/syscall.tbl
+@@ -408,3 +408,4 @@
+ 435 common clone3 sys_clone3
+ 437 common openat2 sys_openat2
+ 438 common pidfd_getfd sys_pidfd_getfd
++441 common fsinfo sys_fsinfo
+diff --git a/fs/Kconfig b/fs/Kconfig
+index 708ba336e689..1d1b48059ec9 100644
+--- a/fs/Kconfig
++++ b/fs/Kconfig
+@@ -15,6 +15,13 @@ config VALIDATE_FS_PARSER
+ Enable this to perform validation of the parameter description for a
+ filesystem when it is registered.
+
++config FSINFO
++ bool "Enable the fsinfo() system call"
++ help
++ Enable the file system information querying system call to allow
++ comprehensive information to be retrieved about a filesystem,
++ superblock or mount object.
++
+ if BLOCK
+
+ config FS_IOMAP
+diff --git a/fs/Makefile b/fs/Makefile
+index 505e51166973..b5cc9bcd17a4 100644
+--- a/fs/Makefile
++++ b/fs/Makefile
+@@ -54,6 +54,7 @@ obj-$(CONFIG_COREDUMP) += coredump.o
+ obj-$(CONFIG_SYSCTL) += drop_caches.o
+
+ obj-$(CONFIG_FHANDLE) += fhandle.o
++obj-$(CONFIG_FSINFO) += fsinfo.o
+ obj-y += iomap/
+
+ obj-y += quota/
+diff --git a/fs/fsinfo.c b/fs/fsinfo.c
+new file mode 100644
+index 000000000000..1830c73f37a7
+--- /dev/null
++++ b/fs/fsinfo.c
+@@ -0,0 +1,586 @@
++// SPDX-License-Identifier: GPL-2.0
++/* Filesystem information query.
++ *
++ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
++ * Written by David Howells (dhowells@redhat.com)
++ */
++#include <linux/syscalls.h>
++#include <linux/fs.h>
++#include <linux/file.h>
++#include <linux/mount.h>
++#include <linux/namei.h>
++#include <linux/statfs.h>
++#include <linux/security.h>
++#include <linux/uaccess.h>
++#include <linux/fsinfo.h>
++#include <uapi/linux/mount.h>
++#include "internal.h"
++
++/**
++ * fsinfo_string - Store a NUL-terminated string as an fsinfo attribute value.
++ * @s: The string to store (may be NULL)
++ * @ctx: The parameter context
++ */
++int fsinfo_string(const char *s, struct fsinfo_context *ctx)
++{
++ unsigned int len;
++ char *p = ctx->buffer;
++ int ret = 0;
++
++ if (s) {
++ len = min_t(size_t, strlen(s), ctx->buf_size - 1);
++ if (!ctx->want_size_only) {
++ memcpy(p, s, len);
++ p[len] = 0;
++ }
++ ret = len;
++ }
++
++ return ret;
++}
++EXPORT_SYMBOL(fsinfo_string);
++
++/*
++ * Get basic filesystem stats from statfs.
++ */
++static int fsinfo_generic_statfs(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_statfs *p = ctx->buffer;
++ struct kstatfs buf;
++ int ret;
++
++ ret = vfs_statfs(path, &buf);
++ if (ret < 0)
++ return ret;
++
++ p->f_blocks.lo = buf.f_blocks;
++ p->f_bfree.lo = buf.f_bfree;
++ p->f_bavail.lo = buf.f_bavail;
++ p->f_files.lo = buf.f_files;
++ p->f_ffree.lo = buf.f_ffree;
++ p->f_favail.lo = buf.f_ffree;
++ p->f_bsize = buf.f_bsize;
++ p->f_frsize = buf.f_frsize;
++ return sizeof(*p);
++}
++
++static int fsinfo_generic_ids(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_ids *p = ctx->buffer;
++ struct super_block *sb;
++ struct kstatfs buf;
++ int ret;
++
++ ret = vfs_statfs(path, &buf);
++ if (ret < 0 && ret != -ENOSYS)
++ return ret;
++ if (ret == 0)
++ memcpy(&p->f_fsid, &buf.f_fsid, sizeof(p->f_fsid));
++
++ sb = path->dentry->d_sb;
++ p->f_fstype = sb->s_magic;
++ p->f_dev_major = MAJOR(sb->s_dev);
++ p->f_dev_minor = MINOR(sb->s_dev);
++ p->f_sb_id = sb->s_unique_id;
++ strlcpy(p->f_fs_name, sb->s_type->name, sizeof(p->f_fs_name));
++ return sizeof(*p);
++}
++
++int fsinfo_generic_limits(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_limits *p = ctx->buffer;
++ struct super_block *sb = path->dentry->d_sb;
++
++ p->max_file_size.hi = 0;
++ p->max_file_size.lo = sb->s_maxbytes;
++ p->max_ino.hi = 0;
++ p->max_ino.lo = UINT_MAX;
++ p->max_hard_links = sb->s_max_links;
++ p->max_uid = UINT_MAX;
++ p->max_gid = UINT_MAX;
++ p->max_projid = UINT_MAX;
++ p->max_filename_len = NAME_MAX;
++ p->max_symlink_len = PATH_MAX;
++ p->max_xattr_name_len = XATTR_NAME_MAX;
++ p->max_xattr_body_len = XATTR_SIZE_MAX;
++ p->max_dev_major = 0xffffff;
++ p->max_dev_minor = 0xff;
++ return sizeof(*p);
++}
++EXPORT_SYMBOL(fsinfo_generic_limits);
++
++int fsinfo_generic_supports(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_supports *p = ctx->buffer;
++ struct super_block *sb = path->dentry->d_sb;
++
++ p->stx_mask = STATX_BASIC_STATS;
++ if (sb->s_d_op && sb->s_d_op->d_automount)
++ p->stx_attributes |= STATX_ATTR_AUTOMOUNT;
++ return sizeof(*p);
++}
++EXPORT_SYMBOL(fsinfo_generic_supports);
++
++static const struct fsinfo_timestamp_info fsinfo_default_timestamp_info = {
++ .atime = {
++ .minimum = S64_MIN,
++ .maximum = S64_MAX,
++ .gran_mantissa = 1,
++ .gran_exponent = 0,
++ },
++ .mtime = {
++ .minimum = S64_MIN,
++ .maximum = S64_MAX,
++ .gran_mantissa = 1,
++ .gran_exponent = 0,
++ },
++ .ctime = {
++ .minimum = S64_MIN,
++ .maximum = S64_MAX,
++ .gran_mantissa = 1,
++ .gran_exponent = 0,
++ },
++ .btime = {
++ .minimum = S64_MIN,
++ .maximum = S64_MAX,
++ .gran_mantissa = 1,
++ .gran_exponent = 0,
++ },
++};
++
++int fsinfo_generic_timestamp_info(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_timestamp_info *p = ctx->buffer;
++ struct super_block *sb = path->dentry->d_sb;
++ s8 exponent;
++
++ *p = fsinfo_default_timestamp_info;
++
++ if (sb->s_time_gran < 1000000000) {
++ if (sb->s_time_gran < 1000)
++ exponent = -9;
++ else if (sb->s_time_gran < 1000000)
++ exponent = -6;
++ else
++ exponent = -3;
++
++ p->atime.gran_exponent = exponent;
++ p->mtime.gran_exponent = exponent;
++ p->ctime.gran_exponent = exponent;
++ p->btime.gran_exponent = exponent;
++ }
++
++ return sizeof(*p);
++}
++EXPORT_SYMBOL(fsinfo_generic_timestamp_info);
++
++static int fsinfo_generic_volume_uuid(struct path *path, struct fsinfo_context *ctx)
++{
++ struct fsinfo_volume_uuid *p = ctx->buffer;
++ struct super_block *sb = path->dentry->d_sb;
++
++ memcpy(p, &sb->s_uuid, sizeof(*p));
++ return sizeof(*p);
++}
++
++static int fsinfo_generic_volume_id(struct path *path, struct fsinfo_context *ctx)
++{
++ return fsinfo_string(path->dentry->d_sb->s_id, ctx);
++}
++
++static const struct fsinfo_attribute fsinfo_common_attributes[] = {
++ FSINFO_VSTRUCT (FSINFO_ATTR_STATFS, fsinfo_generic_statfs),
++ FSINFO_VSTRUCT (FSINFO_ATTR_IDS, fsinfo_generic_ids),
++ FSINFO_VSTRUCT (FSINFO_ATTR_LIMITS, fsinfo_generic_limits),
++ FSINFO_VSTRUCT (FSINFO_ATTR_SUPPORTS, fsinfo_generic_supports),
++ FSINFO_VSTRUCT (FSINFO_ATTR_TIMESTAMP_INFO, fsinfo_generic_timestamp_info),
++ FSINFO_STRING (FSINFO_ATTR_VOLUME_ID, fsinfo_generic_volume_id),
++ FSINFO_VSTRUCT (FSINFO_ATTR_VOLUME_UUID, fsinfo_generic_volume_uuid),
++
++ FSINFO_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, (void *)123UL),
++ FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, (void *)123UL),
++ {}
++};
++
++/*
++ * Determine an attribute's minimum buffer size and, if the buffer is large
++ * enough, get the attribute value.
++ */
++static int fsinfo_get_this_attribute(struct path *path,
++ struct fsinfo_context *ctx,
++ const struct fsinfo_attribute *attr)
++{
++ int buf_size;
++
++ if (ctx->Nth != 0 && !(attr->flags & (FSINFO_FLAGS_N | FSINFO_FLAGS_NM)))
++ return -ENODATA;
++ if (ctx->Mth != 0 && !(attr->flags & FSINFO_FLAGS_NM))
++ return -ENODATA;
++
++ switch (attr->type) {
++ case FSINFO_TYPE_VSTRUCT:
++ ctx->clear_tail = true;
++ buf_size = attr->size;
++ break;
++ case FSINFO_TYPE_STRING:
++ case FSINFO_TYPE_OPAQUE:
++ case FSINFO_TYPE_LIST:
++ buf_size = 4096;
++ break;
++ default:
++ return -ENOPKG;
++ }
++
++ if (ctx->buf_size < buf_size)
++ return buf_size;
++
++ return attr->get(path, ctx);
++}
++
++static void fsinfo_attributes_insert(struct fsinfo_context *ctx,
++ const struct fsinfo_attribute *attr)
++{
++ __u32 *p = ctx->buffer;
++ unsigned int i;
++
++ if (ctx->usage >= ctx->buf_size ||
++ ctx->buf_size - ctx->usage < sizeof(__u32)) {
++ ctx->usage += sizeof(__u32);
++ return;
++ }
++
++ for (i = 0; i < ctx->usage / sizeof(__u32); i++)
++ if (p[i] == attr->attr_id)
++ return;
++
++ p[i] = attr->attr_id;
++ ctx->usage += sizeof(__u32);
++}
++
++static int fsinfo_list_attributes(struct path *path,
++ struct fsinfo_context *ctx,
++ const struct fsinfo_attribute *attributes)
++{
++ const struct fsinfo_attribute *a;
++
++ for (a = attributes; a->get; a++)
++ fsinfo_attributes_insert(ctx, a);
++ return -EOPNOTSUPP; /* We want to go through all the lists */
++}
++
++static int fsinfo_get_attribute_info(struct path *path,
++ struct fsinfo_context *ctx,
++ const struct fsinfo_attribute *attributes)
++{
++ const struct fsinfo_attribute *a;
++ struct fsinfo_attribute_info *p = ctx->buffer;
++
++ if (!ctx->buf_size)
++ return sizeof(*p);
++
++ for (a = attributes; a->get; a++) {
++ if (a->attr_id == ctx->Nth) {
++ p->attr_id = a->attr_id;
++ p->type = a->type;
++ p->flags = a->flags;
++ p->size = a->size;
++ p->size = a->size;
++ return sizeof(*p);
++ }
++ }
++ return -EOPNOTSUPP; /* We want to go through all the lists */
++}
++
++/**
++ * fsinfo_get_attribute - Look up and handle an attribute
++ * @path: The object to query
++ * @params: Parameters to define a request and place to store result
++ * @attributes: List of attributes to search.
++ *
++ * Look through a list of attributes for one that matches the requested
++ * attribute then call the handler for it.
++ */
++int fsinfo_get_attribute(struct path *path, struct fsinfo_context *ctx,
++ const struct fsinfo_attribute *attributes)
++{
++ const struct fsinfo_attribute *a;
++
++ switch (ctx->requested_attr) {
++ case FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO:
++ return fsinfo_get_attribute_info(path, ctx, attributes);
++ case FSINFO_ATTR_FSINFO_ATTRIBUTES:
++ return fsinfo_list_attributes(path, ctx, attributes);
++ default:
++ for (a = attributes; a->get; a++)
++ if (a->attr_id == ctx->requested_attr)
++ return fsinfo_get_this_attribute(path, ctx, a);
++ return -EOPNOTSUPP;
++ }
++}
++EXPORT_SYMBOL(fsinfo_get_attribute);
++
++/**
++ * generic_fsinfo - Handle an fsinfo attribute generically
++ * @path: The object to query
++ * @params: Parameters to define a request and place to store result
++ */
++static int fsinfo_call(struct path *path, struct fsinfo_context *ctx)
++{
++ int ret;
++
++ if (path->dentry->d_sb->s_op->fsinfo) {
++ ret = path->dentry->d_sb->s_op->fsinfo(path, ctx);
++ if (ret != -EOPNOTSUPP)
++ return ret;
++ }
++ ret = fsinfo_get_attribute(path, ctx, fsinfo_common_attributes);
++ if (ret != -EOPNOTSUPP)
++ return ret;
++
++ switch (ctx->requested_attr) {
++ case FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO:
++ return -ENODATA;
++ case FSINFO_ATTR_FSINFO_ATTRIBUTES:
++ return ctx->usage;
++ default:
++ return -EOPNOTSUPP;
++ }
++}
++
++/**
++ * vfs_fsinfo - Retrieve filesystem information
++ * @path: The object to query
++ * @params: Parameters to define a request and place to store result
++ *
++ * Get an attribute on a filesystem or an object within a filesystem. The
++ * filesystem attribute to be queried is indicated by @ctx->requested_attr, and
++ * if it's a multi-valued attribute, the particular value is selected by
++ * @ctx->Nth and then @ctx->Mth.
++ *
++ * For common attributes, a value may be fabricated if it is not supported by
++ * the filesystem.
++ *
++ * On success, the size of the attribute's value is returned (0 is a valid
++ * size). A buffer will have been allocated and will be pointed to by
++ * @ctx->buffer. The caller must free this with kvfree().
++ *
++ * Errors can also be returned: -ENOMEM if a buffer cannot be allocated, -EPERM
++ * or -EACCES if permission is denied by the LSM, -EOPNOTSUPP if an attribute
++ * doesn't exist for the specified object or -ENODATA if the attribute exists,
++ * but the Nth,Mth value does not exist. -EMSGSIZE indicates that the value is
++ * unmanageable internally and -ENOPKG indicates other internal failure.
++ *
++ * Errors such as -EIO may also come from attempts to access media or servers
++ * to obtain the requested information if it's not immediately to hand.
++ *
++ * [*] Note that the caller may set @ctx->want_size_only if it only wants the
++ * size of the value and not the data. If this is set, a buffer may not be
++ * allocated under some circumstances. This is intended for size query by
++ * userspace.
++ *
++ * [*] Note that @ctx->clear_tail will be returned set if the data should be
++ * padded out with zeros when writing it to userspace.
++ */
++static int vfs_fsinfo(struct path *path, struct fsinfo_context *ctx)
++{
++ struct dentry *dentry = path->dentry;
++ int ret;
++
++ ret = security_sb_statfs(dentry);
++ if (ret)
++ return ret;
++
++ /* Call the handler to find out the buffer size required. */
++ ctx->buf_size = 0;
++ ret = fsinfo_call(path, ctx);
++ if (ret < 0 || ctx->want_size_only)
++ return ret;
++ ctx->buf_size = ret;
++
++ do {
++ /* Allocate a buffer of the requested size. */
++ if (ctx->buf_size > INT_MAX)
++ return -EMSGSIZE;
++ ctx->buffer = kvzalloc(ctx->buf_size, GFP_KERNEL);
++ if (!ctx->buffer)
++ return -ENOMEM;
++
++ ctx->usage = 0;
++ ctx->skip = 0;
++ ret = fsinfo_call(path, ctx);
++ if (IS_ERR_VALUE((long)ret))
++ return ret;
++ if ((unsigned int)ret <= ctx->buf_size)
++ return ret; /* It fitted */
++
++ /* We need to resize the buffer */
++ ctx->buf_size = roundup(ret, PAGE_SIZE);
++ kvfree(ctx->buffer);
++ ctx->buffer = NULL;
++ } while (!signal_pending(current));
++
++ return -ERESTARTSYS;
++}
++
++static int vfs_fsinfo_path(int dfd, const char __user *pathname,
++ const struct fsinfo_params *up,
++ struct fsinfo_context *ctx)
++{
++ struct path path;
++ unsigned lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT;
++ int ret = -EINVAL;
++
++ if (up->resolve_flags & ~VALID_RESOLVE_FLAGS)
++ return -EINVAL;
++ if (up->at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |
++ AT_EMPTY_PATH))
++ return -EINVAL;
++
++ if (up->resolve_flags & RESOLVE_NO_XDEV)
++ lookup_flags |= LOOKUP_NO_XDEV;
++ if (up->resolve_flags & RESOLVE_NO_MAGICLINKS)
++ lookup_flags |= LOOKUP_NO_MAGICLINKS;
++ if (up->resolve_flags & RESOLVE_NO_SYMLINKS)
++ lookup_flags |= LOOKUP_NO_SYMLINKS;
++ if (up->resolve_flags & RESOLVE_BENEATH)
++ lookup_flags |= LOOKUP_BENEATH;
++ if (up->resolve_flags & RESOLVE_IN_ROOT)
++ lookup_flags |= LOOKUP_IN_ROOT;
++ if (up->at_flags & AT_SYMLINK_NOFOLLOW)
++ lookup_flags &= ~LOOKUP_FOLLOW;
++ if (up->at_flags & AT_NO_AUTOMOUNT)
++ lookup_flags &= ~LOOKUP_AUTOMOUNT;
++ if (up->at_flags & AT_EMPTY_PATH)
++ lookup_flags |= LOOKUP_EMPTY;
++
++retry:
++ ret = user_path_at(dfd, pathname, lookup_flags, &path);
++ if (ret)
++ goto out;
++
++ ret = vfs_fsinfo(&path, ctx);
++ path_put(&path);
++ if (retry_estale(ret, lookup_flags)) {
++ lookup_flags |= LOOKUP_REVAL;
++ goto retry;
++ }
++out:
++ return ret;
++}
++
++static int vfs_fsinfo_fd(unsigned int fd, struct fsinfo_context *ctx)
++{
++ struct fd f = fdget_raw(fd);
++ int ret = -EBADF;
++
++ if (f.file) {
++ ret = vfs_fsinfo(&f.file->f_path, ctx);
++ fdput(f);
++ }
++ return ret;
++}
++
++/**
++ * sys_fsinfo - System call to get filesystem information
++ * @dfd: Base directory to pathwalk from or fd referring to filesystem.
++ * @pathname: Filesystem to query or NULL.
++ * @params: Parameters to define request (NULL: FSINFO_ATTR_STATFS).
++ * @params_size: Size of parameter buffer.
++ * @result_buffer: Result buffer.
++ * @result_buf_size: Size of result buffer.
++ *
++ * Get information on a filesystem. The filesystem attribute to be queried is
++ * indicated by @_params->request, and some of the attributes can have multiple
++ * values, indexed by @_params->Nth and @_params->Mth. If @_params is NULL,
++ * then the 0th fsinfo_attr_statfs attribute is queried. If an attribute does
++ * not exist, EOPNOTSUPP is returned; if the Nth,Mth value does not exist,
++ * ENODATA is returned.
++ *
++ * On success, the size of the attribute's value is returned. If
++ * @result_buf_size is 0 or @result_buffer is NULL, only the size is returned.
++ * If the size of the value is larger than @result_buf_size, it will be
++ * truncated by the copy. If the size of the value is smaller than
++ * @result_buf_size then the excess buffer space will be cleared. The full
++ * size of the value will be returned, irrespective of how much data is
++ * actually placed in the buffer.
++ */
++SYSCALL_DEFINE6(fsinfo,
++ int, dfd,
++ const char __user *, pathname,
++ const struct fsinfo_params __user *, params,
++ size_t, params_size,
++ void __user *, result_buffer,
++ size_t, result_buf_size)
++{
++ struct fsinfo_context ctx;
++ struct fsinfo_params user_params;
++ unsigned int result_size;
++ void *r;
++ int ret;
++
++ if ((!params && params_size) ||
++ ( params && !params_size) ||
++ (!result_buffer && result_buf_size) ||
++ ( result_buffer && !result_buf_size))
++ return -EINVAL;
++ if (result_buf_size > UINT_MAX)
++ return -EOVERFLOW;
++
++ memset(&ctx, 0, sizeof(ctx));
++ ctx.requested_attr = FSINFO_ATTR_STATFS;
++ ctx.flags = FSINFO_FLAGS_QUERY_PATH;
++ ctx.want_size_only = (result_buf_size == 0);
++
++ if (params) {
++ ret = copy_struct_from_user(&user_params, sizeof(user_params),
++ params, params_size);
++ if (ret < 0)
++ return ret;
++ if (user_params.flags & ~FSINFO_FLAGS_QUERY_MASK)
++ return -EINVAL;
++ ctx.flags = user_params.flags;
++ ctx.requested_attr = user_params.request;
++ ctx.Nth = user_params.Nth;
++ ctx.Mth = user_params.Mth;
++ }
++
++ switch (ctx.flags & FSINFO_FLAGS_QUERY_MASK) {
++ case FSINFO_FLAGS_QUERY_PATH:
++ ret = vfs_fsinfo_path(dfd, pathname, &user_params, &ctx);
++ break;
++ case FSINFO_FLAGS_QUERY_FD:
++ if (pathname)
++ return -EINVAL;
++ ret = vfs_fsinfo_fd(dfd, &ctx);
++ break;
++ default:
++ return -EINVAL;
++ }
++
++ if (ret < 0)
++ goto error;
++
++ r = ctx.buffer + ctx.skip;
++ result_size = min_t(size_t, ret, result_buf_size);
++ if (result_size > 0 &&
++ copy_to_user(result_buffer, r, result_size) != 0) {
++ ret = -EFAULT;
++ goto error;
++ }
++
++ /* Clear any part of the buffer that we won't fill if we're putting a
++ * struct in there. Strings, opaque objects and arrays are expected to
++ * be variable length.
++ */
++ if (ctx.clear_tail &&
++ result_buf_size > result_size &&
++ clear_user(result_buffer + result_size,
++ result_buf_size - result_size) != 0) {
++ ret = -EFAULT;
++ goto error;
++ }
++
++error:
++ kvfree(ctx.buffer);
++ return ret;
++}
+diff --git a/include/linux/fs.h b/include/linux/fs.h
+index fb0db8474141..13270f1a8663 100644
+--- a/include/linux/fs.h
++++ b/include/linux/fs.h
+@@ -68,6 +68,7 @@ struct fsverity_info;
+ struct fsverity_operations;
+ struct fs_context;
+ struct fs_parameter_spec;
++struct fsinfo_context;
+
+ extern void __init inode_init(void);
+ extern void __init inode_init_early(void);
+@@ -1958,6 +1959,9 @@ struct super_operations {
+ int (*thaw_super) (struct super_block *);
+ int (*unfreeze_fs) (struct super_block *);
+ int (*statfs) (struct dentry *, struct kstatfs *);
++#ifdef CONFIG_FSINFO
++ int (*fsinfo)(struct path *, struct fsinfo_context *);
++#endif
+ int (*remount_fs) (struct super_block *, int *, char *);
+ void (*umount_begin) (struct super_block *);
+
+diff --git a/include/linux/fsinfo.h b/include/linux/fsinfo.h
+new file mode 100644
+index 000000000000..bf806669b4fb
+--- /dev/null
++++ b/include/linux/fsinfo.h
+@@ -0,0 +1,73 @@
++// SPDX-License-Identifier: GPL-2.0
++/* Filesystem information query
++ *
++ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
++ * Written by David Howells (dhowells@redhat.com)
++ */
++
++#ifndef _LINUX_FSINFO_H
++#define _LINUX_FSINFO_H
++
++#ifdef CONFIG_FSINFO
++
++#include <uapi/linux/fsinfo.h>
++
++struct path;
++
++#define FSINFO_NORMAL_ATTR_MAX_SIZE 4096
++
++struct fsinfo_context {
++ __u32 flags; /* [in] FSINFO_FLAGS_* */
++ __u32 requested_attr; /* [in] What is being asking for */
++ __u32 Nth; /* [in] Instance of it (some may have multiple) */
++ __u32 Mth; /* [in] Subinstance */
++ bool want_size_only; /* [in] Just want to know the size, not the data */
++ bool clear_tail; /* [out] T if tail of buffer should be cleared */
++ unsigned int skip; /* [out] Number of bytes to skip in buffer */
++ unsigned int usage; /* [tmp] Amount of buffer used (if large) */
++ unsigned int buf_size; /* [tmp] Size of ->buffer[] */
++ void *buffer; /* [out] The reply buffer */
++};
++
++/*
++ * A filesystem information attribute definition.
++ */
++struct fsinfo_attribute {
++ unsigned int attr_id; /* The ID of the attribute */
++ enum fsinfo_value_type type:8; /* The type of the attribute's value(s) */
++ unsigned int flags:8;
++ unsigned int size:16; /* - Value size (FSINFO_STRUCT/LIST) */
++ int (*get)(struct path *path, struct fsinfo_context *params);
++};
++
++#define __FSINFO(A, T, S, G, F) \
++ { .attr_id = A, .type = T, .flags = F, .size = S, .get = G }
++
++#define _FSINFO(A, T, S, G) __FSINFO(A, T, S, G, 0)
++#define _FSINFO_N(A, T, S, G) __FSINFO(A, T, S, G, FSINFO_FLAGS_N)
++#define _FSINFO_NM(A, T, S, G) __FSINFO(A, T, S, G, FSINFO_FLAGS_NM)
++
++#define _FSINFO_VSTRUCT(A,S,G) _FSINFO (A, FSINFO_TYPE_VSTRUCT, sizeof(S), G)
++#define _FSINFO_VSTRUCT_N(A,S,G) _FSINFO_N (A, FSINFO_TYPE_VSTRUCT, sizeof(S), G)
++#define _FSINFO_VSTRUCT_NM(A,S,G) _FSINFO_NM(A, FSINFO_TYPE_VSTRUCT, sizeof(S), G)
++
++#define FSINFO_VSTRUCT(A,G) _FSINFO_VSTRUCT (A, A##__STRUCT, G)
++#define FSINFO_VSTRUCT_N(A,G) _FSINFO_VSTRUCT_N (A, A##__STRUCT, G)
++#define FSINFO_VSTRUCT_NM(A,G) _FSINFO_VSTRUCT_NM(A, A##__STRUCT, G)
++#define FSINFO_STRING(A,G) _FSINFO (A, FSINFO_TYPE_STRING, 0, G)
++#define FSINFO_STRING_N(A,G) _FSINFO_N (A, FSINFO_TYPE_STRING, 0, G)
++#define FSINFO_STRING_NM(A,G) _FSINFO_NM(A, FSINFO_TYPE_STRING, 0, G)
++#define FSINFO_OPAQUE(A,G) _FSINFO (A, FSINFO_TYPE_OPAQUE, 0, G)
++#define FSINFO_LIST(A,G) _FSINFO (A, FSINFO_TYPE_LIST, sizeof(A##__STRUCT), G)
++#define FSINFO_LIST_N(A,G) _FSINFO_N (A, FSINFO_TYPE_LIST, sizeof(A##__STRUCT), G)
++
++extern int fsinfo_string(const char *, struct fsinfo_context *);
++extern int fsinfo_generic_timestamp_info(struct path *, struct fsinfo_context *);
++extern int fsinfo_generic_supports(struct path *, struct fsinfo_context *);
++extern int fsinfo_generic_limits(struct path *, struct fsinfo_context *);
++extern int fsinfo_get_attribute(struct path *, struct fsinfo_context *,
++ const struct fsinfo_attribute *);
++
++#endif /* CONFIG_FSINFO */
++
++#endif /* _LINUX_FSINFO_H */
+diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
+index 1815065d52f3..623f61dcdb9b 100644
+--- a/include/linux/syscalls.h
++++ b/include/linux/syscalls.h
+@@ -47,6 +47,7 @@ struct stat64;
+ struct statfs;
+ struct statfs64;
+ struct statx;
++struct fsinfo_params;
+ struct __sysctl_args;
+ struct sysinfo;
+ struct timespec;
+@@ -1003,6 +1004,9 @@ asmlinkage long sys_pidfd_send_signal(int pidfd, int sig,
+ siginfo_t __user *info,
+ unsigned int flags);
+ asmlinkage long sys_pidfd_getfd(int pidfd, int fd, unsigned int flags);
++asmlinkage long sys_fsinfo(int dfd, const char __user *pathname,
++ struct fsinfo_params __user *params, size_t params_size,
++ void __user *result_buffer, size_t result_buf_size);
+
+ /*
+ * Architecture-specific system calls
+diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/unistd.h
+index 3a3201e4618e..1708d24cf98d 100644
+--- a/include/uapi/asm-generic/unistd.h
++++ b/include/uapi/asm-generic/unistd.h
+@@ -855,9 +855,11 @@ __SYSCALL(__NR_clone3, sys_clone3)
+ __SYSCALL(__NR_openat2, sys_openat2)
+ #define __NR_pidfd_getfd 438
+ __SYSCALL(__NR_pidfd_getfd, sys_pidfd_getfd)
++#define __NR_fsinfo 441
++__SYSCALL(__NR_fsinfo, sys_fsinfo)
+
+ #undef __NR_syscalls
+-#define __NR_syscalls 439
++#define __NR_syscalls 442
+
+ /*
+ * 32 bit systems traditionally used different
+diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
+new file mode 100644
+index 000000000000..e9b35b9b7629
+--- /dev/null
++++ b/include/uapi/linux/fsinfo.h
+@@ -0,0 +1,187 @@
++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
++/* fsinfo() definitions.
++ *
++ * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
++ * Written by David Howells (dhowells@redhat.com)
++ */
++#ifndef _UAPI_LINUX_FSINFO_H
++#define _UAPI_LINUX_FSINFO_H
++
++#include <linux/types.h>
++#include <linux/socket.h>
++#include <linux/openat2.h>
++
++/*
++ * The filesystem attributes that can be requested. Note that some attributes
++ * may have multiple instances which can be switched in the parameter block.
++ */
++#define FSINFO_ATTR_STATFS 0x00 /* statfs()-style state */
++#define FSINFO_ATTR_IDS 0x01 /* Filesystem IDs */
++#define FSINFO_ATTR_LIMITS 0x02 /* Filesystem limits */
++#define FSINFO_ATTR_SUPPORTS 0x03 /* What's supported in statx, iocflags, ... */
++#define FSINFO_ATTR_TIMESTAMP_INFO 0x04 /* Inode timestamp info */
++#define FSINFO_ATTR_VOLUME_ID 0x05 /* Volume ID (string) */
++#define FSINFO_ATTR_VOLUME_UUID 0x06 /* Volume UUID (LE uuid) */
++#define FSINFO_ATTR_VOLUME_NAME 0x07 /* Volume name (string) */
++
++#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) */
++
++/*
++ * Optional fsinfo() parameter structure.
++ *
++ * If this is not given, it is assumed that fsinfo_attr_statfs instance 0,0 is
++ * desired.
++ */
++struct fsinfo_params {
++ __u64 resolve_flags; /* RESOLVE_* flags */
++ __u32 at_flags; /* AT_* flags */
++ __u32 flags; /* Flags controlling fsinfo() specifically */
++#define FSINFO_FLAGS_QUERY_MASK 0x0007 /* What object should fsinfo() query? */
++#define FSINFO_FLAGS_QUERY_PATH 0x0000 /* - path, specified by dirfd,pathname,AT_EMPTY_PATH */
++#define FSINFO_FLAGS_QUERY_FD 0x0001 /* - fd specified by dirfd */
++ __u32 request; /* ID of requested attribute */
++ __u32 Nth; /* Instance of it (some may have multiple) */
++ __u32 Mth; /* Subinstance of Nth instance */
++};
++
++enum fsinfo_value_type {
++ FSINFO_TYPE_VSTRUCT = 0, /* Version-lengthed struct (up to 4096 bytes) */
++ FSINFO_TYPE_STRING = 1, /* NUL-term var-length string (up to 4095 chars) */
++ FSINFO_TYPE_OPAQUE = 2, /* Opaque blob (unlimited size) */
++ FSINFO_TYPE_LIST = 3, /* List of ints/structs (unlimited size) */
++};
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO).
++ *
++ * This gives information about the attributes supported by fsinfo for the
++ * given path.
++ */
++struct fsinfo_attribute_info {
++ unsigned int attr_id; /* The ID of the attribute */
++ enum fsinfo_value_type type; /* The type of the attribute's value(s) */
++ unsigned int flags;
++#define FSINFO_FLAGS_N 0x01 /* - Attr has a set of values */
++#define FSINFO_FLAGS_NM 0x02 /* - Attr has a set of sets of values */
++ unsigned int size; /* - Value size (FSINFO_STRUCT/FSINFO_LIST) */
++};
++
++#define FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO__STRUCT struct fsinfo_attribute_info
++#define FSINFO_ATTR_FSINFO_ATTRIBUTES__STRUCT __u32
++
++struct fsinfo_u128 {
++#if defined(__BYTE_ORDER) ? __BYTE_ORDER == __BIG_ENDIAN : defined(__BIG_ENDIAN)
++ __u64 hi;
++ __u64 lo;
++#elif defined(__BYTE_ORDER) ? __BYTE_ORDER == __LITTLE_ENDIAN : defined(__LITTLE_ENDIAN)
++ __u64 lo;
++ __u64 hi;
++#endif
++};
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_STATFS).
++ * - This gives extended filesystem information.
++ */
++struct fsinfo_statfs {
++ struct fsinfo_u128 f_blocks; /* Total number of blocks in fs */
++ struct fsinfo_u128 f_bfree; /* Total number of free blocks */
++ struct fsinfo_u128 f_bavail; /* Number of free blocks available to ordinary user */
++ struct fsinfo_u128 f_files; /* Total number of file nodes in fs */
++ struct fsinfo_u128 f_ffree; /* Number of free file nodes */
++ struct fsinfo_u128 f_favail; /* Number of file nodes available to ordinary user */
++ __u64 f_bsize; /* Optimal block size */
++ __u64 f_frsize; /* Fragment size */
++};
++
++#define FSINFO_ATTR_STATFS__STRUCT struct fsinfo_statfs
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_IDS).
++ *
++ * List of basic identifiers as is normally found in statfs().
++ */
++struct fsinfo_ids {
++ char f_fs_name[15 + 1]; /* Filesystem name */
++ __u64 f_fsid; /* Short 64-bit Filesystem ID (as statfs) */
++ __u64 f_sb_id; /* Internal superblock ID for sbnotify()/mntnotify() */
++ __u32 f_fstype; /* Filesystem type from linux/magic.h [uncond] */
++ __u32 f_dev_major; /* As st_dev_* from struct statx [uncond] */
++ __u32 f_dev_minor;
++ __u32 __padding[1];
++};
++
++#define FSINFO_ATTR_IDS__STRUCT struct fsinfo_ids
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_LIMITS).
++ *
++ * List of supported filesystem limits.
++ */
++struct fsinfo_limits {
++ struct fsinfo_u128 max_file_size; /* Maximum file size */
++ struct fsinfo_u128 max_ino; /* Maximum inode number */
++ __u64 max_uid; /* Maximum UID supported */
++ __u64 max_gid; /* Maximum GID supported */
++ __u64 max_projid; /* Maximum project ID supported */
++ __u64 max_hard_links; /* Maximum number of hard links on a file */
++ __u64 max_xattr_body_len; /* Maximum xattr content length */
++ __u32 max_xattr_name_len; /* Maximum xattr name length */
++ __u32 max_filename_len; /* Maximum filename length */
++ __u32 max_symlink_len; /* Maximum symlink content length */
++ __u32 max_dev_major; /* Maximum device major representable */
++ __u32 max_dev_minor; /* Maximum device minor representable */
++ __u32 __padding[1];
++};
++
++#define FSINFO_ATTR_LIMITS__STRUCT struct fsinfo_limits
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_SUPPORTS).
++ *
++ * What's supported in various masks, such as statx() attribute and mask bits
++ * and IOC flags.
++ */
++struct fsinfo_supports {
++ __u64 stx_attributes; /* What statx::stx_attributes are supported */
++ __u32 stx_mask; /* What statx::stx_mask bits are supported */
++ __u32 fs_ioc_getflags; /* What FS_IOC_GETFLAGS may return */
++ __u32 fs_ioc_setflags_set; /* What FS_IOC_SETFLAGS may set */
++ __u32 fs_ioc_setflags_clear; /* What FS_IOC_SETFLAGS may clear */
++ __u32 win_file_attrs; /* What DOS/Windows FILE_* attributes are supported */
++ __u32 __padding[1];
++};
++
++#define FSINFO_ATTR_SUPPORTS__STRUCT struct fsinfo_supports
++
++struct fsinfo_timestamp_one {
++ __s64 minimum; /* Minimum timestamp value in seconds */
++ __s64 maximum; /* Maximum timestamp value in seconds */
++ __u16 gran_mantissa; /* Granularity(secs) = mant * 10^exp */
++ __s8 gran_exponent;
++ __u8 __padding[5];
++};
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_TIMESTAMP_INFO).
++ */
++struct fsinfo_timestamp_info {
++ struct fsinfo_timestamp_one atime; /* Access time */
++ struct fsinfo_timestamp_one mtime; /* Modification time */
++ struct fsinfo_timestamp_one ctime; /* Change time */
++ struct fsinfo_timestamp_one btime; /* Birth/creation time */
++};
++
++#define FSINFO_ATTR_TIMESTAMP_INFO__STRUCT struct fsinfo_timestamp_info
++
++/*
++ * Information struct for fsinfo(FSINFO_ATTR_VOLUME_UUID).
++ */
++struct fsinfo_volume_uuid {
++ __u8 uuid[16];
++};
++
++#define FSINFO_ATTR_VOLUME_UUID__STRUCT struct fsinfo_volume_uuid
++
++#endif /* _UAPI_LINUX_FSINFO_H */
+diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c
+index 3b69a560a7ac..58246e6b5603 100644
+--- a/kernel/sys_ni.c
++++ b/kernel/sys_ni.c
+@@ -51,6 +51,7 @@ COND_SYSCALL_COMPAT(io_pgetevents);
+ COND_SYSCALL(io_uring_setup);
+ COND_SYSCALL(io_uring_enter);
+ COND_SYSCALL(io_uring_register);
++COND_SYSCALL(fsinfo);
+
+ /* fs/xattr.c */
+
+diff --git a/samples/vfs/Makefile b/samples/vfs/Makefile
+index 65acdde5c117..9159ad1d7fc5 100644
+--- a/samples/vfs/Makefile
++++ b/samples/vfs/Makefile
+@@ -1,10 +1,15 @@
+ # SPDX-License-Identifier: GPL-2.0-only
+ # List of programs to build
++
+ hostprogs := \
++ test-fsinfo \
+ test-fsmount \
+ test-statx
+
+ always-y := $(hostprogs)
+
++HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include
++HOSTLDLIBS_test-fsinfo += -static -lm
++
+ HOSTCFLAGS_test-fsmount.o += -I$(objtree)/usr/include
+ HOSTCFLAGS_test-statx.o += -I$(objtree)/usr/include
+diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
+new file mode 100644
+index 000000000000..2b53c735d330
+--- /dev/null
++++ b/samples/vfs/test-fsinfo.c
+@@ -0,0 +1,633 @@
++// 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 <fcntl.h>
++#include <sys/syscall.h>
++#include <linux/fsinfo.h>
++#include <linux/socket.h>
++#include <sys/stat.h>
++#include <arpa/inet.h>
++
++#ifndef __NR_fsinfo
++#define __NR_fsinfo -1
++#endif
++
++static bool debug = 0;
++static bool list_last;
++
++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);
++}
++
++struct fsinfo_attribute {
++ unsigned int attr_id;
++ enum fsinfo_value_type type;
++ unsigned int size;
++ const char *name;
++ void (*dump)(void *reply, unsigned int size);
++};
++
++static const struct fsinfo_attribute fsinfo_attributes[];
++
++static ssize_t get_fsinfo(const char *, const char *, struct fsinfo_params *, void **);
++
++static void dump_hex(unsigned int *data, int from, int to)
++{
++ unsigned offset, print_offset = 1, col = 0;
++
++ from /= 4;
++ to = (to + 3) / 4;
++
++ for (offset = from; offset < to; offset++) {
++ if (print_offset) {
++ printf("%04x: ", offset * 8);
++ print_offset = 0;
++ }
++ printf("%08x", data[offset]);
++ col++;
++ if ((col & 3) == 0) {
++ printf("\n");
++ print_offset = 1;
++ } else {
++ printf(" ");
++ }
++ }
++
++ if (!print_offset)
++ printf("\n");
++}
++
++static void dump_attribute_info(void *reply, unsigned int size)
++{
++ struct fsinfo_attribute_info *attr_info = reply;
++ const struct fsinfo_attribute *attr;
++ char type[32], val_size[32];
++
++ switch (attr_info->type) {
++ case FSINFO_TYPE_VSTRUCT: strcpy(type, "V-STRUCT"); break;
++ case FSINFO_TYPE_STRING: strcpy(type, "STRING"); break;
++ case FSINFO_TYPE_OPAQUE: strcpy(type, "OPAQUE"); break;
++ case FSINFO_TYPE_LIST: strcpy(type, "LIST"); break;
++ default:
++ sprintf(type, "type-%x", attr_info->type);
++ break;
++ }
++
++ if (attr_info->flags & FSINFO_FLAGS_N)
++ strcat(type, " x N");
++ else if (attr_info->flags & FSINFO_FLAGS_NM)
++ strcat(type, " x NM");
++
++ for (attr = fsinfo_attributes; attr->name; attr++)
++ if (attr->attr_id == attr_info->attr_id)
++ break;
++
++ if (attr_info->size)
++ sprintf(val_size, "%u", attr_info->size);
++ else
++ strcpy(val_size, "-");
++
++ printf("%8x %-12s %08x %5s %s\n",
++ attr_info->attr_id,
++ type,
++ attr_info->flags,
++ val_size,
++ attr->name ? attr->name : "");
++}
++
++static void dump_fsinfo_generic_statfs(void *reply, unsigned int size)
++{
++ struct fsinfo_statfs *f = reply;
++
++ printf("\n");
++ printf("\tblocks : n=%llu fr=%llu av=%llu\n",
++ (unsigned long long)f->f_blocks.lo,
++ (unsigned long long)f->f_bfree.lo,
++ (unsigned long long)f->f_bavail.lo);
++
++ printf("\tfiles : n=%llu fr=%llu av=%llu\n",
++ (unsigned long long)f->f_files.lo,
++ (unsigned long long)f->f_ffree.lo,
++ (unsigned long long)f->f_favail.lo);
++ printf("\tbsize : %llu\n", f->f_bsize);
++ printf("\tfrsize : %llu\n", f->f_frsize);
++}
++
++static void dump_fsinfo_generic_ids(void *reply, unsigned int size)
++{
++ struct fsinfo_ids *f = reply;
++
++ printf("\n");
++ printf("\tdev : %02x:%02x\n", f->f_dev_major, f->f_dev_minor);
++ printf("\tfs : type=%x name=%s\n", f->f_fstype, f->f_fs_name);
++ printf("\tfsid : %llx\n", (unsigned long long)f->f_fsid);
++ printf("\tsbid : %llx\n", (unsigned long long)f->f_sb_id);
++}
++
++static void dump_fsinfo_generic_limits(void *reply, unsigned int size)
++{
++ struct fsinfo_limits *f = reply;
++
++ printf("\n");
++ printf("\tmax file size: %llx%016llx\n",
++ (unsigned long long)f->max_file_size.hi,
++ (unsigned long long)f->max_file_size.lo);
++ printf("\tmax ino : %llx%016llx\n",
++ (unsigned long long)f->max_ino.hi,
++ (unsigned long long)f->max_ino.lo);
++ printf("\tmax ids : u=%llx g=%llx p=%llx\n",
++ (unsigned long long)f->max_uid,
++ (unsigned long long)f->max_gid,
++ (unsigned long long)f->max_projid);
++ printf("\tmax dev : maj=%x min=%x\n",
++ f->max_dev_major, f->max_dev_minor);
++ printf("\tmax links : %llx\n",
++ (unsigned long long)f->max_hard_links);
++ printf("\tmax xattr : n=%x b=%llx\n",
++ f->max_xattr_name_len,
++ (unsigned long long)f->max_xattr_body_len);
++ printf("\tmax len : file=%x sym=%x\n",
++ f->max_filename_len, f->max_symlink_len);
++}
++
++static void dump_fsinfo_generic_supports(void *reply, unsigned int size)
++{
++ struct fsinfo_supports *f = reply;
++
++ printf("\n");
++ printf("\tstx_attr : %llx\n", (unsigned long long)f->stx_attributes);
++ printf("\tstx_mask : %x\n", f->stx_mask);
++ printf("\tfs_ioc_*flags: get=%x set=%x clr=%x\n",
++ f->fs_ioc_getflags, f->fs_ioc_setflags_set, f->fs_ioc_setflags_clear);
++ printf("\twin_fattrs : %x\n", f->win_file_attrs);
++}
++
++static void print_time(struct fsinfo_timestamp_one *t, char stamp)
++{
++ printf("\t%ctime : gran=%gs range=%llx-%llx\n",
++ stamp,
++ t->gran_mantissa * pow(10., t->gran_exponent),
++ (long long)t->minimum,
++ (long long)t->maximum);
++}
++
++static void dump_fsinfo_generic_timestamp_info(void *reply, unsigned int size)
++{
++ struct fsinfo_timestamp_info *f = reply;
++
++ printf("\n");
++ print_time(&f->atime, 'a');
++ print_time(&f->mtime, 'm');
++ print_time(&f->ctime, 'c');
++ print_time(&f->btime, 'b');
++}
++
++static void dump_fsinfo_generic_volume_uuid(void *reply, unsigned int size)
++{
++ struct fsinfo_volume_uuid *f = reply;
++
++ printf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x"
++ "-%02x%02x%02x%02x%02x%02x\n",
++ f->uuid[ 0], f->uuid[ 1],
++ f->uuid[ 2], f->uuid[ 3],
++ f->uuid[ 4], f->uuid[ 5],
++ f->uuid[ 6], f->uuid[ 7],
++ f->uuid[ 8], f->uuid[ 9],
++ f->uuid[10], f->uuid[11],
++ f->uuid[12], f->uuid[13],
++ f->uuid[14], f->uuid[15]);
++}
++
++static void dump_string(void *reply, unsigned int size)
++{
++ char *s = reply, *p;
++ bool nl = false, last_nl = false;
++
++ p = s;
++ if (size >= 4096) {
++ size = 4096;
++ p[4092] = '.';
++ p[4093] = '.';
++ p[4094] = '.';
++ p[4095] = 0;
++ } else {
++ p[size] = 0;
++ }
++
++ for (p = s; *p; p++) {
++ if (*p == '\n') {
++ last_nl = nl = true;
++ continue;
++ }
++ last_nl = false;
++ if (!isprint(*p) && *p != '\t')
++ *p = '?';
++ }
++
++ if (nl)
++ putchar('\n');
++ printf("%s", s);
++ if (!last_nl)
++ putchar('\n');
++}
++
++#define dump_fsinfo_meta_attribute_info (void *)0x123
++#define dump_fsinfo_meta_attributes (void *)0x123
++
++/*
++ *
++ */
++#define __FSINFO(A, T, S, G, F, N) \
++ { .attr_id = A, .type = T, .size = S, .name = N, .dump = dump_##G }
++
++#define _FSINFO(A,T,S,G,N) __FSINFO(A, T, S, G, 0, N)
++#define _FSINFO_N(A,T,S,G,N) __FSINFO(A, T, S, G, FSINFO_FLAGS_N, N)
++#define _FSINFO_NM(A,T,S,G,N) __FSINFO(A, T, S, G, FSINFO_FLAGS_NM, N)
++
++#define _FSINFO_VSTRUCT(A,S,G,N) _FSINFO (A, FSINFO_TYPE_VSTRUCT, sizeof(S), G, N)
++#define _FSINFO_VSTRUCT_N(A,S,G,N) _FSINFO_N (A, FSINFO_TYPE_VSTRUCT, sizeof(S), G, N)
++#define _FSINFO_VSTRUCT_NM(A,S,G,N) _FSINFO_NM(A, FSINFO_TYPE_VSTRUCT, sizeof(S), G, N)
++
++#define FSINFO_VSTRUCT(A,G) _FSINFO_VSTRUCT (A, A##__STRUCT, G, #A)
++#define FSINFO_VSTRUCT_N(A,G) _FSINFO_VSTRUCT_N (A, A##__STRUCT, G, #A)
++#define FSINFO_VSTRUCT_NM(A,G) _FSINFO_VSTRUCT_NM(A, A##__STRUCT, G, #A)
++#define FSINFO_STRING(A,G) _FSINFO (A, FSINFO_TYPE_STRING, 0, G, #A)
++#define FSINFO_STRING_N(A,G) _FSINFO_N (A, FSINFO_TYPE_STRING, 0, G, #A)
++#define FSINFO_STRING_NM(A,G) _FSINFO_NM(A, FSINFO_TYPE_STRING, 0, G, #A)
++#define FSINFO_OPAQUE(A,G) _FSINFO (A, FSINFO_TYPE_OPAQUE, 0, G, #A)
++#define FSINFO_LIST(A,G) _FSINFO (A, FSINFO_TYPE_LIST, sizeof(A##__STRUCT), G, #A)
++#define FSINFO_LIST_N(A,G) _FSINFO_N (A, FSINFO_TYPE_LIST, sizeof(A##__STRUCT), G, #A)
++
++static const struct fsinfo_attribute fsinfo_attributes[] = {
++ FSINFO_VSTRUCT (FSINFO_ATTR_STATFS, fsinfo_generic_statfs),
++ FSINFO_VSTRUCT (FSINFO_ATTR_IDS, fsinfo_generic_ids),
++ FSINFO_VSTRUCT (FSINFO_ATTR_LIMITS, fsinfo_generic_limits),
++ FSINFO_VSTRUCT (FSINFO_ATTR_SUPPORTS, fsinfo_generic_supports),
++ FSINFO_VSTRUCT (FSINFO_ATTR_TIMESTAMP_INFO, fsinfo_generic_timestamp_info),
++ FSINFO_STRING (FSINFO_ATTR_VOLUME_ID, string),
++ FSINFO_VSTRUCT (FSINFO_ATTR_VOLUME_UUID, fsinfo_generic_volume_uuid),
++ FSINFO_STRING (FSINFO_ATTR_VOLUME_NAME, string),
++ FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, fsinfo_meta_attribute_info),
++ FSINFO_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, fsinfo_meta_attributes),
++ {}
++};
++
++static void dump_value(unsigned int attr_id,
++ const struct fsinfo_attribute *attr,
++ const struct fsinfo_attribute_info *attr_info,
++ void *reply, unsigned int size)
++{
++ if (!attr || !attr->dump) {
++ printf("<no dumper>\n");
++ return;
++ }
++
++ if (attr->type == FSINFO_TYPE_VSTRUCT && size < attr->size) {
++ printf("<short data %u/%u>\n", size, attr->size);
++ return;
++ }
++
++ attr->dump(reply, size);
++}
++
++static void dump_list(unsigned int attr_id,
++ const struct fsinfo_attribute *attr,
++ const struct fsinfo_attribute_info *attr_info,
++ void *reply, unsigned int size)
++{
++ size_t elem_size = attr_info->size;
++ unsigned int ix = 0;
++
++ printf("\n");
++ if (!attr || !attr->dump) {
++ printf("<no dumper>\n");
++ return;
++ }
++
++ if (attr->type == FSINFO_TYPE_VSTRUCT && size < attr->size) {
++ printf("<short data %u/%u>\n", size, attr->size);
++ return;
++ }
++
++ list_last = false;
++ while (size >= elem_size) {
++ printf("\t[%02x] ", ix);
++ if (size == elem_size)
++ list_last = true;
++ attr->dump(reply, size);
++ reply += elem_size;
++ size -= elem_size;
++ ix++;
++ }
++}
++
++/*
++ * Call fsinfo, expanding the buffer as necessary.
++ */
++static ssize_t get_fsinfo(const char *file, const char *name,
++ struct fsinfo_params *params, void **_r)
++{
++ ssize_t ret;
++ size_t buf_size = 4096;
++ void *r;
++
++ for (;;) {
++ r = malloc(buf_size);
++ if (!r) {
++ perror("malloc");
++ exit(1);
++ }
++ memset(r, 0xbd, buf_size);
++
++ errno = 0;
++ ret = fsinfo(AT_FDCWD, file, params, sizeof(*params), r, buf_size - 1);
++ if (ret == -1)
++ goto error;
++
++ if (ret <= buf_size - 1)
++ break;
++ buf_size = (ret + 4096 - 1) & ~(4096 - 1);
++ }
++
++ if (debug)
++ printf("fsinfo(%s,%s,%u,%u) = %zd\n",
++ file, name, params->Nth, params->Mth, ret);
++
++ ((char *)r)[ret] = 0;
++ *_r = r;
++ return ret;
++
++error:
++ *_r = NULL;
++ free(r);
++ if (debug)
++ printf("fsinfo(%s,%s,%u,%u) = %m\n",
++ file, name, params->Nth, params->Mth);
++ return ret;
++}
++
++/*
++ * Try one subinstance of an attribute.
++ */
++static int try_one(const char *file, struct fsinfo_params *params,
++ const struct fsinfo_attribute_info *attr_info, bool raw)
++{
++ const struct fsinfo_attribute *attr;
++ const char *name;
++ size_t size = 4096;
++ char namebuf[32];
++ void *r;
++
++ for (attr = fsinfo_attributes; attr->name; attr++) {
++ if (attr->attr_id == params->request) {
++ name = attr->name;
++ if (strncmp(name, "fsinfo_generic_", 15) == 0)
++ name += 15;
++ goto found;
++ }
++ }
++
++ sprintf(namebuf, "<unknown-%x>", params->request);
++ name = namebuf;
++ attr = NULL;
++
++found:
++ size = get_fsinfo(file, name, params, &r);
++
++ if (size == -1) {
++ if (errno == ENODATA) {
++ if (!(attr_info->flags & (FSINFO_FLAGS_N | FSINFO_FLAGS_NM)) &&
++ params->Nth == 0 && params->Mth == 0) {
++ fprintf(stderr,
++ "Unexpected ENODATA (0x%x{%u}{%u})\n",
++ params->request, params->Nth, params->Mth);
++ exit(1);
++ }
++ free(r);
++ return (params->Mth == 0) ? 2 : 1;
++ }
++ if (errno == EOPNOTSUPP) {
++ if (params->Nth > 0 || params->Mth > 0) {
++ fprintf(stderr,
++ "Should return -ENODATA (0x%x{%u}{%u})\n",
++ params->request, params->Nth, params->Mth);
++ exit(1);
++ }
++ //printf("\e[33m%s\e[m: <not supported>\n",
++ // fsinfo_attr_names[attr]);
++ free(r);
++ return 2;
++ }
++ perror(file);
++ exit(1);
++ }
++
++ if (raw) {
++ if (size > 4096)
++ size = 4096;
++ dump_hex(r, 0, size);
++ free(r);
++ return 0;
++ }
++
++ switch (attr_info->flags & (FSINFO_FLAGS_N | FSINFO_FLAGS_NM)) {
++ case 0:
++ printf("\e[33m%s\e[m: ", name);
++ break;
++ case FSINFO_FLAGS_N:
++ printf("\e[33m%s{%u}\e[m: ", name, params->Nth);
++ break;
++ case FSINFO_FLAGS_NM:
++ printf("\e[33m%s{%u,%u}\e[m: ", name, params->Nth, params->Mth);
++ break;
++ }
++
++ switch (attr_info->type) {
++ case FSINFO_TYPE_VSTRUCT:
++ case FSINFO_TYPE_STRING:
++ dump_value(params->request, attr, attr_info, r, size);
++ free(r);
++ return 0;
++
++ case FSINFO_TYPE_LIST:
++ dump_list(params->request, attr, attr_info, r, size);
++ free(r);
++ return 0;
++
++ case FSINFO_TYPE_OPAQUE:
++ free(r);
++ return 0;
++
++ default:
++ fprintf(stderr, "Fishy about %u 0x%x,%x,%x\n",
++ params->request, attr_info->type, attr_info->flags, attr_info->size);
++ exit(1);
++ }
++}
++
++static int cmp_u32(const void *a, const void *b)
++{
++ return *(const int *)a - *(const int *)b;
++}
++
++/*
++ *
++ */
++int main(int argc, char **argv)
++{
++ struct fsinfo_attribute_info attr_info;
++ struct fsinfo_params params = {
++ .at_flags = AT_SYMLINK_NOFOLLOW,
++ .flags = FSINFO_FLAGS_QUERY_PATH,
++ };
++ unsigned int *attrs, ret, nr, i;
++ bool meta = false;
++ int raw = 0, opt, Nth, Mth;
++
++ while ((opt = getopt(argc, argv, "Madlr"))) {
++ switch (opt) {
++ case 'M':
++ meta = true;
++ continue;
++ case 'a':
++ params.at_flags |= AT_NO_AUTOMOUNT;
++ params.flags = FSINFO_FLAGS_QUERY_PATH;
++ continue;
++ case 'd':
++ debug = true;
++ continue;
++ case 'l':
++ params.at_flags &= ~AT_SYMLINK_NOFOLLOW;
++ params.flags = FSINFO_FLAGS_QUERY_PATH;
++ continue;
++ case 'r':
++ raw = 1;
++ continue;
++ }
++ break;
++ }
++
++ argc -= optind;
++ argv += optind;
++
++ if (argc != 1) {
++ printf("Format: test-fsinfo [-Madlr] <path>\n");
++ exit(2);
++ }
++
++ /* Retrieve a list of supported attribute IDs */
++ params.request = FSINFO_ATTR_FSINFO_ATTRIBUTES;
++ params.Nth = 0;
++ params.Mth = 0;
++ ret = get_fsinfo(argv[0], "attributes", ¶ms, (void **)&attrs);
++ if (ret == -1) {
++ fprintf(stderr, "Unable to get attribute list: %m\n");
++ exit(1);
++ }
++
++ if (ret % sizeof(attrs[0])) {
++ fprintf(stderr, "Bad length of attribute list (0x%x)\n", ret);
++ exit(2);
++ }
++
++ nr = ret / sizeof(attrs[0]);
++ qsort(attrs, nr, sizeof(attrs[0]), cmp_u32);
++
++ if (meta) {
++ printf("ATTR ID TYPE FLAGS SIZE NAME\n");
++ printf("======== ============ ======== ===== =========\n");
++ for (i = 0; i < nr; i++) {
++ params.request = FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO;
++ params.Nth = attrs[i];
++ params.Mth = 0;
++ ret = fsinfo(AT_FDCWD, argv[0],
++ ¶ms, sizeof(params),
++ &attr_info, sizeof(attr_info));
++ if (ret == -1) {
++ fprintf(stderr, "Can't get info for attribute %x: %m\n", attrs[i]);
++ exit(1);
++ }
++
++ dump_attribute_info(&attr_info, ret);
++ }
++ exit(0);
++ }
++
++ for (i = 0; i < nr; i++) {
++ params.request = FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO;
++ params.Nth = attrs[i];
++ params.Mth = 0;
++ ret = fsinfo(AT_FDCWD, argv[0],
++ ¶ms, sizeof(params),
++ &attr_info, sizeof(attr_info));
++ if (ret == -1) {
++ fprintf(stderr, "Can't get info for attribute %x: %m\n", attrs[i]);
++ exit(1);
++ }
++
++ if (attrs[i] == FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO ||
++ attrs[i] == FSINFO_ATTR_FSINFO_ATTRIBUTES)
++ continue;
++
++ if (attrs[i] != attr_info.attr_id) {
++ fprintf(stderr, "ID for %03x returned %03x\n",
++ attrs[i], attr_info.attr_id);
++ break;
++ }
++ Nth = 0;
++ do {
++ Mth = 0;
++ do {
++ params.request = attrs[i];
++ params.Nth = Nth;
++ params.Mth = Mth;
++
++ switch (try_one(argv[0], ¶ms, &attr_info, raw)) {
++ case 0:
++ continue;
++ case 1:
++ goto done_M;
++ case 2:
++ goto done_N;
++ }
++ } while (++Mth < 100);
++
++ done_M:
++ if (Mth >= 100) {
++ fprintf(stderr, "Fishy: Mth %x[%u][%u]\n", attrs[i], Nth, Mth);
++ break;
++ }
++
++ } while (++Nth < 100);
++
++ done_N:
++ if (Nth >= 100) {
++ fprintf(stderr, "Fishy: Nth %x[%u]\n", attrs[i], Nth);
++ break;
++ }
++ }
++
++ return 0;
++}
+--
+2.20.1
+
diff --git a/third_party/linux/external/0004-fsinfo-Allow-retrieval-of-superblock-devname-options.patch b/third_party/linux/external/0004-fsinfo-Allow-retrieval-of-superblock-devname-options.patch
new file mode 100644
index 0000000..86ba2cc
--- /dev/null
+++ b/third_party/linux/external/0004-fsinfo-Allow-retrieval-of-superblock-devname-options.patch
@@ -0,0 +1,183 @@
+From fa2ff1a0da263362a2c98c8cfe68bcac3a323ac4 Mon Sep 17 00:00:00 2001
+From: David Howells <dhowells@redhat.com>
+Date: Tue, 3 Mar 2020 14:29:27 +0000
+Subject: [PATCH 4/4] fsinfo: Allow retrieval of superblock devname, options
+ and stats
+
+Provide fsinfo() attributes to retrieve superblock device name, options,
+and statistics in string form. The following attributes are defined:
+
+ FSINFO_ATTR_SOURCE - Mount-specific device name
+ FSINFO_ATTR_CONFIGURATION - Mount options
+ FSINFO_ATTR_FS_STATISTICS - Filesystem statistics
+
+FSINFO_ATTR_SOURCE could be made indexable by params->Nth to handle the
+case where there is more than one source (e.g. the bcachefs filesystem).
+
+Signed-off-by: David Howells <dhowells@redhat.com>
+---
+ fs/fsinfo.c | 41 +++++++++++++++++++++++++++++++++++++
+ fs/internal.h | 2 ++
+ fs/namespace.c | 39 +++++++++++++++++++++++++++++++++++
+ include/uapi/linux/fsinfo.h | 3 +++
+ samples/vfs/test-fsinfo.c | 4 ++++
+ 5 files changed, 89 insertions(+)
+
+diff --git a/fs/fsinfo.c b/fs/fsinfo.c
+index 1830c73f37a7..3ed43c5a10e8 100644
+--- a/fs/fsinfo.c
++++ b/fs/fsinfo.c
+@@ -188,6 +188,44 @@ static int fsinfo_generic_volume_id(struct path *path, struct fsinfo_context *ct
+ return fsinfo_string(path->dentry->d_sb->s_id, ctx);
+ }
+
++/*
++ * Retrieve the superblock configuration (mount options) as a comma-separated
++ * string. The initial comma is stripped off.
++ */
++static int fsinfo_generic_seq_read(struct path *path, struct fsinfo_context *ctx)
++{
++ struct super_block *sb = path->dentry->d_sb;
++ struct seq_file m = {
++ .buf = ctx->buffer,
++ .size = ctx->buf_size,
++ };
++ int ret = 0;
++
++ switch (ctx->requested_attr) {
++ case FSINFO_ATTR_CONFIGURATION:
++ if (sb->s_op->show_options)
++ ret = sb->s_op->show_options(&m, path->mnt->mnt_root);
++ break;
++
++ case FSINFO_ATTR_FS_STATISTICS:
++ if (sb->s_op->show_stats)
++ ret = sb->s_op->show_stats(&m, path->mnt->mnt_root);
++ break;
++ }
++
++ if (ret < 0)
++ return ret;
++ if (seq_has_overflowed(&m))
++ return ctx->buf_size + PAGE_SIZE;
++ if (ctx->requested_attr == FSINFO_ATTR_CONFIGURATION) {
++ if (m.count > 0 && ((char *)ctx->buffer)[0] == ',') {
++ m.count--;
++ ctx->skip = 1;
++ }
++ }
++ return m.count;
++}
++
+ static const struct fsinfo_attribute fsinfo_common_attributes[] = {
+ FSINFO_VSTRUCT (FSINFO_ATTR_STATFS, fsinfo_generic_statfs),
+ FSINFO_VSTRUCT (FSINFO_ATTR_IDS, fsinfo_generic_ids),
+@@ -196,6 +234,9 @@ static const struct fsinfo_attribute fsinfo_common_attributes[] = {
+ FSINFO_VSTRUCT (FSINFO_ATTR_TIMESTAMP_INFO, fsinfo_generic_timestamp_info),
+ FSINFO_STRING (FSINFO_ATTR_VOLUME_ID, fsinfo_generic_volume_id),
+ FSINFO_VSTRUCT (FSINFO_ATTR_VOLUME_UUID, fsinfo_generic_volume_uuid),
++ 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_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, (void *)123UL),
+ FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, (void *)123UL),
+diff --git a/fs/internal.h b/fs/internal.h
+index a0d90f23593c..6f2cc77bf38d 100644
+--- a/fs/internal.h
++++ b/fs/internal.h
+@@ -91,6 +91,8 @@ extern int __mnt_want_write_file(struct file *);
+ extern void __mnt_drop_write_file(struct file *);
+
+ extern void dissolve_on_fput(struct vfsmount *);
++extern int fsinfo_generic_mount_source(struct path *, struct fsinfo_context *);
++
+ /*
+ * fs_struct.c
+ */
+diff --git a/fs/namespace.c b/fs/namespace.c
+index 85b5f7bea82e..b4951e2afae1 100644
+--- a/fs/namespace.c
++++ b/fs/namespace.c
+@@ -30,6 +30,7 @@
+ #include <uapi/linux/mount.h>
+ #include <linux/fs_context.h>
+ #include <linux/shmem_fs.h>
++#include <linux/fsinfo.h>
+
+ #include "pnode.h"
+ #include "internal.h"
+@@ -3975,3 +3976,41 @@ const struct proc_ns_operations mntns_operations = {
+ .install = mntns_install,
+ .owner = mntns_owner,
+ };
++
++#ifdef CONFIG_FSINFO
++static inline void mangle(struct seq_file *m, const char *s)
++{
++ seq_escape(m, s, " \t\n\\");
++}
++
++/*
++ * Return the mount source/device name as seen from this mountpoint. Shared
++ * mounts may vary here and the filesystem is permitted to substitute its own
++ * rendering.
++ */
++int fsinfo_generic_mount_source(struct path *path, struct fsinfo_context *ctx)
++{
++ struct super_block *sb = path->mnt->mnt_sb;
++ struct mount *mnt = real_mount(path->mnt);
++ struct seq_file m = {
++ .buf = ctx->buffer,
++ .size = ctx->buf_size,
++ };
++ int ret;
++
++ if (sb->s_op->show_devname) {
++ ret = sb->s_op->show_devname(&m, mnt->mnt.mnt_root);
++ if (ret < 0)
++ return ret;
++ } else {
++ if (!mnt->mnt_devname)
++ return fsinfo_string("none", ctx);
++ mangle(&m, mnt->mnt_devname);
++ }
++
++ if (seq_has_overflowed(&m))
++ return ctx->buf_size + PAGE_SIZE;
++ return m.count;
++}
++
++#endif /* CONFIG_FSINFO */
+diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h
+index e9b35b9b7629..d3722c7142a6 100644
+--- a/include/uapi/linux/fsinfo.h
++++ b/include/uapi/linux/fsinfo.h
+@@ -23,6 +23,9 @@
+ #define FSINFO_ATTR_VOLUME_ID 0x05 /* Volume ID (string) */
+ #define FSINFO_ATTR_VOLUME_UUID 0x06 /* Volume UUID (LE uuid) */
+ #define FSINFO_ATTR_VOLUME_NAME 0x07 /* Volume name (string) */
++#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_FSINFO_ATTRIBUTE_INFO 0x100 /* Information about attr N (for path) */
+ #define FSINFO_ATTR_FSINFO_ATTRIBUTES 0x101 /* List of supported attrs (for path) */
+diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c
+index 2b53c735d330..1797f7b8d08a 100644
+--- a/samples/vfs/test-fsinfo.c
++++ b/samples/vfs/test-fsinfo.c
+@@ -289,6 +289,10 @@ static const struct fsinfo_attribute fsinfo_attributes[] = {
+ FSINFO_STRING (FSINFO_ATTR_VOLUME_ID, string),
+ FSINFO_VSTRUCT (FSINFO_ATTR_VOLUME_UUID, fsinfo_generic_volume_uuid),
+ FSINFO_STRING (FSINFO_ATTR_VOLUME_NAME, string),
++ FSINFO_STRING (FSINFO_ATTR_SOURCE, string),
++ FSINFO_STRING (FSINFO_ATTR_CONFIGURATION, string),
++ FSINFO_STRING (FSINFO_ATTR_FS_STATISTICS, string),
++
+ FSINFO_VSTRUCT_N(FSINFO_ATTR_FSINFO_ATTRIBUTE_INFO, fsinfo_meta_attribute_info),
+ FSINFO_LIST (FSINFO_ATTR_FSINFO_ATTRIBUTES, fsinfo_meta_attributes),
+ {}
+--
+2.20.1
+
diff --git a/third_party/linux/linux-smalltown.config b/third_party/linux/linux-smalltown.config
index 4aa051d..9c01456 100644
--- a/third_party/linux/linux-smalltown.config
+++ b/third_party/linux/linux-smalltown.config
@@ -2667,6 +2667,7 @@
#
CONFIG_DCACHE_WORD_ACCESS=y
# CONFIG_VALIDATE_FS_PARSER is not set
+CONFIG_FSINFO=y
CONFIG_FS_IOMAP=y
# CONFIG_EXT2_FS is not set
# CONFIG_EXT3_FS is not set
@@ -2681,7 +2682,7 @@
# CONFIG_REISERFS_FS is not set
# CONFIG_JFS_FS is not set
CONFIG_XFS_FS=y
-# CONFIG_XFS_QUOTA is not set
+CONFIG_XFS_QUOTA=y
# CONFIG_XFS_POSIX_ACL is not set
# CONFIG_XFS_RT is not set
# CONFIG_XFS_ONLINE_SCRUB is not set
@@ -2706,7 +2707,13 @@
CONFIG_DNOTIFY=y
CONFIG_INOTIFY_USER=y
# CONFIG_FANOTIFY is not set
-# CONFIG_QUOTA is not set
+CONFIG_QUOTA=y
+# CONFIG_QUOTA_NETLINK_INTERFACE is not set
+CONFIG_PRINT_QUOTA_WARNING=y
+# CONFIG_QUOTA_DEBUG is not set
+# CONFIG_QFMT_V1 is not set
+# CONFIG_QFMT_V2 is not set
+CONFIG_QUOTACTL=y
# CONFIG_AUTOFS4_FS is not set
# CONFIG_AUTOFS_FS is not set
# CONFIG_FUSE_FS is not set