From patchwork Tue May 28 15:11:10 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965159 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id D7D726C5 for ; Tue, 28 May 2019 15:11:22 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C196228714 for ; Tue, 28 May 2019 15:11:22 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B516228893; Tue, 28 May 2019 15:11:22 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id E09FA287C9 for ; Tue, 28 May 2019 15:11:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726719AbfE1PLP (ORCPT ); Tue, 28 May 2019 11:11:15 -0400 Received: from mx1.redhat.com ([209.132.183.28]:41272 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726313AbfE1PLO (ORCPT ); Tue, 28 May 2019 11:11:14 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 0B950307D932; Tue, 28 May 2019 15:11:14 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id E404E5D997; Tue, 28 May 2019 15:11:11 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 01/25] vfs: syscall: Add fsinfo() to query filesystem information [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:10 +0100 Message-ID: <155905627049.1662.17033721577309385838.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.48]); Tue, 28 May 2019 15:11:14 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP 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 *filename, const struct fsinfo_params *params, void *buffer, size_t buf_size); The params parameter optionally points to a block of parameters: struct fsinfo_params { __u32 at_flags; __u32 request; __u32 Nth; __u32 Mth; __u32 __reserved[6]; }; If params is NULL, it is assumed params->request should be fsinfo_attr_statfs, params->Nth should be 0, params->Mth should be 0 and params->at_flags should be 0. If params is given, all of params->__reserved[] must be 0. dfd, filename and params->at_flags indicate the file to query. There is no equivalent of lstat() as that can be emulated with fsinfo() by setting AT_SYMLINK_NOFOLLOW in params->at_flags. There is also no equivalent of fstat() as that can be emulated by passing a NULL filename to fsinfo() with the fd of interest in dfd. AT_NO_AUTOMOUNT can also be used to an allow automount point to be queried without triggering it. params->request indicates the attribute/attributes to be queried. This can be one of: FSINFO_ATTR_STATFS - statfs-style info FSINFO_ATTR_FSINFO - Information about fsinfo() FSINFO_ATTR_IDS - Filesystem IDs FSINFO_ATTR_LIMITS - Filesystem limits FSINFO_ATTR_SUPPORTS - What's supported in statx(), IOC flags FSINFO_ATTR_CAPABILITIES - Filesystem capabilities 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_NAME_ENCODING - Filename encoding (string) FSINFO_ATTR_NAME_CODEPAGE - Filename codepage (string) 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. buffer and buf_size point to the reply buffer. The buffer is filled up to the specified size, even if this means truncating the reply. The full size of the reply is returned. 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 buf_size are 0, no copy will take place and the data size will be returned. At the moment, this will only work on x86_64 and i386 as it requires the system call to be wired up. Signed-off-by: David Howells cc: linux-api@vger.kernel.org --- arch/x86/entry/syscalls/syscall_32.tbl | 1 arch/x86/entry/syscalls/syscall_64.tbl | 1 fs/Kconfig | 7 fs/Makefile | 1 fs/fsinfo.c | 524 +++++++++++++++++++++++++++++++ include/linux/fs.h | 5 include/linux/fsinfo.h | 66 ++++ include/linux/syscalls.h | 4 include/uapi/linux/fsinfo.h | 211 ++++++++++++ kernel/sys_ni.c | 3 samples/vfs/Makefile | 4 samples/vfs/test-fsinfo.c | 544 ++++++++++++++++++++++++++++++++ 12 files changed, 1371 insertions(+) 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/x86/entry/syscalls/syscall_32.tbl b/arch/x86/entry/syscalls/syscall_32.tbl index ad968b7bac72..03decae51513 100644 --- a/arch/x86/entry/syscalls/syscall_32.tbl +++ b/arch/x86/entry/syscalls/syscall_32.tbl @@ -438,3 +438,4 @@ 431 i386 fsconfig sys_fsconfig __ia32_sys_fsconfig 432 i386 fsmount sys_fsmount __ia32_sys_fsmount 433 i386 fspick sys_fspick __ia32_sys_fspick +434 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 b4e6f9e6204a..ea63df9a1020 100644 --- a/arch/x86/entry/syscalls/syscall_64.tbl +++ b/arch/x86/entry/syscalls/syscall_64.tbl @@ -355,6 +355,7 @@ 431 common fsconfig __x64_sys_fsconfig 432 common fsmount __x64_sys_fsmount 433 common fspick __x64_sys_fspick +434 common fsinfo __x64_sys_fsinfo # # x32-specific system call numbers start at 512 to avoid cache impact diff --git a/fs/Kconfig b/fs/Kconfig index cbbffc8b9ef5..9e7d2f2c0111 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 c9aea23aba56..26eaeae4b9a1 100644 --- a/fs/Makefile +++ b/fs/Makefile @@ -53,6 +53,7 @@ obj-$(CONFIG_SYSCTL) += drop_caches.o obj-$(CONFIG_FHANDLE) += fhandle.o obj-$(CONFIG_FS_IOMAP) += iomap.o +obj-$(CONFIG_FSINFO) += fsinfo.o obj-y += quota/ diff --git a/fs/fsinfo.c b/fs/fsinfo.c new file mode 100644 index 000000000000..f9a63410e9a2 --- /dev/null +++ b/fs/fsinfo.c @@ -0,0 +1,524 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "internal.h" + +static u32 calc_mount_attrs(u32 mnt_flags) +{ + u32 attrs = 0; + + if (mnt_flags & MNT_READONLY) + attrs |= MOUNT_ATTR_RDONLY; + if (mnt_flags & MNT_NOSUID) + attrs |= MOUNT_ATTR_NOSUID; + if (mnt_flags & MNT_NODEV) + attrs |= MOUNT_ATTR_NODEV; + if (mnt_flags & MNT_NOEXEC) + attrs |= MOUNT_ATTR_NOEXEC; + if (mnt_flags & MNT_NODIRATIME) + attrs |= MOUNT_ATTR_NODIRATIME; + + if (mnt_flags & MNT_NOATIME) + attrs |= MOUNT_ATTR_NOATIME; + else if (mnt_flags & MNT_RELATIME) + attrs |= MOUNT_ATTR_RELATIME; + else + attrs |= MOUNT_ATTR_STRICTATIME; + return attrs; +} + +static u32 calc_sb_flags(u32 s_flags) +{ + u32 flags = 0; + + if (s_flags & SB_RDONLY) flags |= MS_RDONLY; + if (s_flags & SB_SYNCHRONOUS) flags |= MS_SYNCHRONOUS; + if (s_flags & SB_MANDLOCK) flags |= MS_MANDLOCK; + if (s_flags & SB_DIRSYNC) flags |= MS_DIRSYNC; + if (s_flags & SB_SILENT) flags |= MS_SILENT; + if (s_flags & SB_POSIXACL) flags |= MS_POSIXACL; + if (s_flags & SB_LAZYTIME) flags |= MS_LAZYTIME; + if (s_flags & SB_I_VERSION) flags |= MS_I_VERSION; + return flags; +} + +/* + * Get basic filesystem stats from statfs. + */ +static int fsinfo_generic_statfs(struct path *path, struct fsinfo_statfs *p) +{ + struct kstatfs buf; + int ret; + + ret = vfs_statfs(path, &buf); + if (ret < 0) + return ret; + + p->f_blocks = buf.f_blocks; + p->f_bfree = buf.f_bfree; + p->f_bavail = buf.f_bavail; + p->f_files = buf.f_files; + p->f_ffree = buf.f_ffree; + p->f_favail = buf.f_ffree; + p->f_bsize = buf.f_bsize; + p->f_frsize = buf.f_frsize; + + p->mnt_attrs = calc_mount_attrs(path->mnt->mnt_flags); + p->sb_flags = calc_sb_flags(path->mnt->mnt_sb->s_flags); + return sizeof(*p); +} + +static int fsinfo_generic_ids(struct path *path, struct fsinfo_ids *p) +{ + struct super_block *sb; + struct kstatfs buf; + int ret; + + ret = vfs_statfs(path, &buf); + if (ret < 0 && ret != -ENOSYS) + return ret; + + 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); + + memcpy(&p->f_fsid, &buf.f_fsid, sizeof(p->f_fsid)); + strlcpy(p->f_fs_name, path->dentry->d_sb->s_type->name, + sizeof(p->f_fs_name)); + return sizeof(*p); +} + +static int fsinfo_generic_limits(struct path *path, struct fsinfo_limits *lim) +{ + struct super_block *sb = path->dentry->d_sb; + + lim->max_file_size = sb->s_maxbytes; + lim->max_hard_links = sb->s_max_links; + lim->max_uid = UINT_MAX; + lim->max_gid = UINT_MAX; + lim->max_projid = UINT_MAX; + lim->max_filename_len = NAME_MAX; + lim->max_symlink_len = PAGE_SIZE; + lim->max_xattr_name_len = XATTR_NAME_MAX; + lim->max_xattr_body_len = XATTR_SIZE_MAX; + lim->max_dev_major = 0xffffff; + lim->max_dev_minor = 0xff; + return sizeof(*lim); +} + +static int fsinfo_generic_supports(struct path *path, struct fsinfo_supports *c) +{ + struct super_block *sb = path->dentry->d_sb; + + c->stx_mask = STATX_BASIC_STATS; + if (sb->s_d_op && sb->s_d_op->d_automount) + c->stx_attributes |= STATX_ATTR_AUTOMOUNT; + return sizeof(*c); +} + +static int fsinfo_generic_capabilities(struct path *path, + struct fsinfo_capabilities *c) +{ + struct super_block *sb = path->dentry->d_sb; + + if (sb->s_mtd) + fsinfo_set_cap(c, FSINFO_CAP_IS_FLASH_FS); + else if (sb->s_bdev) + fsinfo_set_cap(c, FSINFO_CAP_IS_BLOCK_FS); + + if (sb->s_quota_types & QTYPE_MASK_USR) + fsinfo_set_cap(c, FSINFO_CAP_USER_QUOTAS); + if (sb->s_quota_types & QTYPE_MASK_GRP) + fsinfo_set_cap(c, FSINFO_CAP_GROUP_QUOTAS); + if (sb->s_quota_types & QTYPE_MASK_PRJ) + fsinfo_set_cap(c, FSINFO_CAP_PROJECT_QUOTAS); + if (sb->s_d_op && sb->s_d_op->d_automount) + fsinfo_set_cap(c, FSINFO_CAP_AUTOMOUNTS); + if (sb->s_id[0]) + fsinfo_set_cap(c, FSINFO_CAP_VOLUME_ID); + + fsinfo_set_cap(c, FSINFO_CAP_HAS_ATIME); + fsinfo_set_cap(c, FSINFO_CAP_HAS_CTIME); + fsinfo_set_cap(c, FSINFO_CAP_HAS_MTIME); + return sizeof(*c); +} + +static int fsinfo_generic_timestamp_info(struct path *path, + struct fsinfo_timestamp_info *ts) +{ + struct super_block *sb = path->dentry->d_sb; + + /* If unset, assume 1s granularity */ + u16 mantissa = 1; + s8 exponent = 0; + + ts->minimum_timestamp = S64_MIN; + ts->maximum_timestamp = S64_MAX; + 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; + } +#define set_gran(x) \ + do { \ + ts->x##_mantissa = mantissa; \ + ts->x##_exponent = exponent; \ + } while (0) + set_gran(atime_gran); + set_gran(btime_gran); + set_gran(ctime_gran); + set_gran(mtime_gran); + return sizeof(*ts); +} + +static int fsinfo_generic_volume_uuid(struct path *path, + struct fsinfo_volume_uuid *vu) +{ + struct super_block *sb = path->dentry->d_sb; + + memcpy(vu, &sb->s_uuid, sizeof(*vu)); + return sizeof(*vu); +} + +static int fsinfo_generic_volume_id(struct path *path, char *buf) +{ + struct super_block *sb = path->dentry->d_sb; + size_t len = strlen(sb->s_id); + + memcpy(buf, sb->s_id, len + 1); + return len; +} + +static int fsinfo_generic_name_encoding(struct path *path, char *buf) +{ + static const char encoding[] = "utf8"; + + memcpy(buf, encoding, sizeof(encoding) - 1); + return sizeof(encoding) - 1; +} + +/* + * Implement some queries generically from stuff in the superblock. + */ +int generic_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ +#define _gen(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(path, params->buffer) + + switch (params->request) { + case _gen(STATFS, statfs); + case _gen(IDS, ids); + case _gen(LIMITS, limits); + case _gen(SUPPORTS, supports); + case _gen(CAPABILITIES, capabilities); + case _gen(TIMESTAMP_INFO, timestamp_info); + case _gen(VOLUME_UUID, volume_uuid); + case _gen(VOLUME_ID, volume_id); + case _gen(NAME_ENCODING, name_encoding); + default: + return -EOPNOTSUPP; + } +} +EXPORT_SYMBOL(generic_fsinfo); + +/* + * Retrieve the filesystem info. We make some stuff up if the operation is not + * supported. + */ +static int vfs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct dentry *dentry = path->dentry; + int (*fsinfo)(struct path *, struct fsinfo_kparams *); + int ret; + + if (params->request == FSINFO_ATTR_FSINFO) { + struct fsinfo_fsinfo *info = params->buffer; + + info->max_attr = FSINFO_ATTR__NR; + info->max_cap = FSINFO_CAP__NR; + return sizeof(*info); + } + + fsinfo = dentry->d_sb->s_op->fsinfo; + if (!fsinfo) { + if (!dentry->d_sb->s_op->statfs) + return -EOPNOTSUPP; + fsinfo = generic_fsinfo; + } + + ret = security_sb_statfs(dentry); + if (ret) + return ret; + + if (!params->overlarge) + return fsinfo(path, params); + + while (!signal_pending(current)) { + params->usage = 0; + ret = fsinfo(path, params); + if (ret <= (int)params->buf_size) + return ret; /* Error or it fitted */ + kvfree(params->buffer); + params->buffer = NULL; + params->buf_size = roundup(ret, PAGE_SIZE); + if (params->buf_size > INT_MAX) + return -ETOOSMALL; + params->buffer = kvmalloc(params->buf_size, GFP_KERNEL); + if (!params->buffer) + return -ENOMEM; + } + + return -ERESTARTSYS; +} + +static int vfs_fsinfo_path(int dfd, const char __user *filename, + struct fsinfo_kparams *params) +{ + struct path path; + unsigned lookup_flags = LOOKUP_FOLLOW | LOOKUP_AUTOMOUNT; + int ret = -EINVAL; + + if ((params->at_flags & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT | + AT_EMPTY_PATH)) != 0) + return -EINVAL; + + if (params->at_flags & AT_SYMLINK_NOFOLLOW) + lookup_flags &= ~LOOKUP_FOLLOW; + if (params->at_flags & AT_NO_AUTOMOUNT) + lookup_flags &= ~LOOKUP_AUTOMOUNT; + if (params->at_flags & AT_EMPTY_PATH) + lookup_flags |= LOOKUP_EMPTY; + +retry: + ret = user_path_at(dfd, filename, lookup_flags, &path); + if (ret) + goto out; + + ret = vfs_fsinfo(&path, params); + 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_kparams *params) +{ + struct fd f = fdget_raw(fd); + int ret = -EBADF; + + if (f.file) { + ret = vfs_fsinfo(&f.file->f_path, params); + fdput(f); + } + return ret; +} + +/* + * Return buffer information by requestable attribute. + * + * STRUCT indicates a fixed-size structure with only one instance. + * STRUCT_N indicates a 1D array of STRUCT, indexed by Nth + * STRUCT_NM indicates a 2D-array of STRUCT, indexed by Nth, Mth + * STRING indicates a string with only one instance. + * STRING_N indicates a 1D array of STRING, indexed by Nth + * STRING_NM indicates a 2D-array of STRING, indexed by Nth, Mth + * OPAQUE indicates a blob that can be larger than 4K. + * STRUCT_ARRAY indicates an array of structs that can be larger than 4K + * + * If an entry is marked STRUCT, STRUCT_N or STRUCT_NM then if no buffer is + * supplied to sys_fsinfo(), sys_fsinfo() will handle returning the buffer size + * without calling vfs_fsinfo() and the filesystem. + * + * No struct may have more than 4K bytes. + */ +struct fsinfo_attr_info { + u8 type; + u8 flags; + u16 size; +}; + +#define __FSINFO_STRUCT 0 +#define __FSINFO_STRING 1 +#define __FSINFO_OPAQUE 2 +#define __FSINFO_STRUCT_ARRAY 3 +#define __FSINFO_0 0 +#define __FSINFO_N 0x0001 +#define __FSINFO_NM 0x0002 + +#define _Z(T, F, S) { .type = __FSINFO_##T, .flags = __FSINFO_##F, .size = S } +#define FSINFO_STRING(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, 0, 0) +#define FSINFO_STRUCT(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, 0, sizeof(struct fsinfo_##Y)) +#define FSINFO_STRING_N(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, N, 0) +#define FSINFO_STRUCT_N(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, N, sizeof(struct fsinfo_##Y)) +#define FSINFO_STRING_NM(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, NM, 0) +#define FSINFO_STRUCT_NM(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, NM, sizeof(struct fsinfo_##Y)) +#define FSINFO_OPAQUE(X,Y) [FSINFO_ATTR_##X] = _Z(OPAQUE, 0, 0) +#define FSINFO_STRUCT_ARRAY(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT_ARRAY, 0, sizeof(struct fsinfo_##Y)) + +static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { + FSINFO_STRUCT (STATFS, statfs), + FSINFO_STRUCT (FSINFO, fsinfo), + FSINFO_STRUCT (IDS, ids), + FSINFO_STRUCT (LIMITS, limits), + FSINFO_STRUCT (CAPABILITIES, capabilities), + FSINFO_STRUCT (SUPPORTS, supports), + FSINFO_STRUCT (TIMESTAMP_INFO, timestamp_info), + FSINFO_STRING (VOLUME_ID, volume_id), + FSINFO_STRUCT (VOLUME_UUID, volume_uuid), + FSINFO_STRING (VOLUME_NAME, volume_name), + FSINFO_STRING (NAME_ENCODING, name_encoding), + FSINFO_STRING (NAME_CODEPAGE, name_codepage), +}; + +/** + * sys_fsinfo - System call to get filesystem information + * @dfd: Base directory to pathwalk from or fd referring to filesystem. + * @filename: Filesystem to query or NULL. + * @_params: Parameters to define request (or NULL for enhanced statfs). + * @user_buffer: Result buffer. + * @user_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 + * @user_buf_size is 0 or @user_buffer is NULL, only the size is returned. If + * the size of the value is larger than @user_buf_size, it will be truncated by + * the copy. If the size of the value is smaller than @user_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_DEFINE5(fsinfo, + int, dfd, const char __user *, filename, + struct fsinfo_params __user *, _params, + void __user *, user_buffer, size_t, user_buf_size) +{ + struct fsinfo_attr_info info; + struct fsinfo_params user_params; + struct fsinfo_kparams params; + unsigned int result_size; + int ret; + + memset(¶ms, 0, sizeof(params)); + + if (_params) { + if (copy_from_user(&user_params, _params, sizeof(user_params))) + return -EFAULT; + if (user_params.__reserved[0] || + user_params.__reserved[1] || + user_params.__reserved[2]) + return -EINVAL; + if (user_params.request >= FSINFO_ATTR__NR) + return -EOPNOTSUPP; + params.at_flags = user_params.at_flags; + params.request = user_params.request; + params.Nth = user_params.Nth; + params.Mth = user_params.Mth; + } else { + params.request = FSINFO_ATTR_STATFS; + } + + if (!user_buffer || !user_buf_size) { + user_buf_size = 0; + user_buffer = NULL; + } + + /* Allocate an appropriately-sized buffer. We will truncate the + * contents when we write the contents back to userspace. + */ + info = fsinfo_buffer_info[params.request]; + if (params.Nth != 0 && !(info.flags & (__FSINFO_N | __FSINFO_NM))) + return -ENODATA; + if (params.Mth != 0 && !(info.flags & __FSINFO_NM)) + return -ENODATA; + + switch (info.type) { + case __FSINFO_STRUCT: + params.buf_size = info.size; + if (user_buf_size == 0) + return info.size; /* We know how big the buffer should be */ + break; + + case __FSINFO_STRING: + params.buf_size = 4096; + break; + + case __FSINFO_OPAQUE: + case __FSINFO_STRUCT_ARRAY: + /* Opaque blob or array of struct elements. We also create a + * buffer that can be used for scratch space. + */ + ret = -ENOMEM; + params.scratch_buffer = kmalloc(4096, GFP_KERNEL); + if (!params.scratch_buffer) + goto error; + params.overlarge = true; + params.buf_size = 4096; + break; + + default: + return -ENOBUFS; + } + + /* We always allocate a buffer for a string, even if buf_size == 0 and + * we're not going to return any data. This means that the filesystem + * code needn't care about whether the buffer actually exists or not. + */ + ret = -ENOMEM; + params.buffer = kvzalloc(params.buf_size, GFP_KERNEL); + if (!params.buffer) + goto error_scratch; + + if (filename) + ret = vfs_fsinfo_path(dfd, filename, ¶ms); + else + ret = vfs_fsinfo_fd(dfd, ¶ms); + if (ret < 0) + goto error_buffer; + + result_size = ret; + if (result_size > user_buf_size) + result_size = user_buf_size; + + if (result_size > 0 && + copy_to_user(user_buffer, params.buffer, result_size)) { + ret = -EFAULT; + goto error_buffer; + } + + /* 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 (info.type == __FSINFO_STRUCT && + user_buf_size > result_size && + clear_user(user_buffer + result_size, user_buf_size - result_size) != 0) { + ret = -EFAULT; + goto error_buffer; + } + +error_buffer: + kvfree(params.buffer); +error_scratch: + kfree(params.scratch_buffer); +error: + return ret; +} diff --git a/include/linux/fs.h b/include/linux/fs.h index 6a38b7124143..71ce3b054c42 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -66,6 +66,8 @@ struct fscrypt_info; struct fscrypt_operations; struct fs_context; struct fs_parameter_description; +struct fsinfo_kparams; +enum fsinfo_attribute; extern void __init inode_init(void); extern void __init inode_init_early(void); @@ -1922,6 +1924,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_kparams *); +#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..e17e4f0bae18 --- /dev/null +++ b/include/linux/fsinfo.h @@ -0,0 +1,66 @@ +/* Filesystem information query + * + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public Licence + * as published by the Free Software Foundation; either version + * 2 of the Licence, or (at your option) any later version. + */ + +#ifndef _LINUX_FSINFO_H +#define _LINUX_FSINFO_H + +#ifdef CONFIG_FSINFO + +#include + +struct fsinfo_kparams { + __u32 at_flags; /* AT_SYMLINK_NOFOLLOW and similar */ + enum fsinfo_attribute request; /* What is being asking for */ + __u32 Nth; /* Instance of it (some may have multiple) */ + __u32 Mth; /* Subinstance */ + bool overlarge; /* T if the buffer may be resized */ + unsigned int usage; /* Amount of buffer used (overlarge=T) */ + unsigned int buf_size; /* Size of ->buffer[] */ + void *buffer; /* Where to place the reply */ + char *scratch_buffer; /* 4K scratch buffer (overlarge=T) */ +}; + +extern int generic_fsinfo(struct path *, struct fsinfo_kparams *); + +static inline void fsinfo_set_cap(struct fsinfo_capabilities *c, + enum fsinfo_capability cap) +{ + c->capabilities[cap / 8] |= 1 << (cap % 8); +} + +static inline void fsinfo_clear_cap(struct fsinfo_capabilities *c, + enum fsinfo_capability cap) +{ + c->capabilities[cap / 8] &= ~(1 << (cap % 8)); +} + +/** + * fsinfo_set_unix_caps - Set standard UNIX capabilities. + * @c: The capabilities mask to alter + */ +static inline void fsinfo_set_unix_caps(struct fsinfo_capabilities *caps) +{ + fsinfo_set_cap(caps, FSINFO_CAP_UIDS); + fsinfo_set_cap(caps, FSINFO_CAP_GIDS); + fsinfo_set_cap(caps, FSINFO_CAP_DIRECTORIES); + fsinfo_set_cap(caps, FSINFO_CAP_SYMLINKS); + fsinfo_set_cap(caps, FSINFO_CAP_HARD_LINKS); + fsinfo_set_cap(caps, FSINFO_CAP_DEVICE_FILES); + fsinfo_set_cap(caps, FSINFO_CAP_UNIX_SPECIALS); + fsinfo_set_cap(caps, FSINFO_CAP_SPARSE); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_ATIME); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_CTIME); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_MTIME); +} + +#endif /* CONFIG_FSINFO */ + +#endif /* _LINUX_FSINFO_H */ diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h index e2870fe1be5b..217d25b62b4f 100644 --- a/include/linux/syscalls.h +++ b/include/linux/syscalls.h @@ -50,6 +50,7 @@ struct stat64; struct statfs; struct statfs64; struct statx; +struct fsinfo_params; struct __sysctl_args; struct sysinfo; struct timespec; @@ -997,6 +998,9 @@ asmlinkage long sys_fspick(int dfd, const char __user *path, unsigned int flags) asmlinkage long sys_pidfd_send_signal(int pidfd, int sig, siginfo_t __user *info, unsigned int flags); +asmlinkage long sys_fsinfo(int dfd, const char __user *path, + struct fsinfo_params __user *params, + void __user *buffer, size_t buf_size); /* * Architecture-specific system calls diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h new file mode 100644 index 000000000000..0af09b7e734c --- /dev/null +++ b/include/uapi/linux/fsinfo.h @@ -0,0 +1,211 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +/* fsinfo() definitions. + * + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + */ +#ifndef _UAPI_LINUX_FSINFO_H +#define _UAPI_LINUX_FSINFO_H + +#include +#include + +/* + * The filesystem attributes that can be requested. Note that some attributes + * may have multiple instances which can be switched in the parameter block. + */ +enum fsinfo_attribute { + FSINFO_ATTR_STATFS = 0, /* statfs()-style state */ + FSINFO_ATTR_FSINFO = 1, /* Information about fsinfo() */ + FSINFO_ATTR_IDS = 2, /* Filesystem IDs */ + FSINFO_ATTR_LIMITS = 3, /* Filesystem limits */ + FSINFO_ATTR_SUPPORTS = 4, /* What's supported in statx, iocflags, ... */ + FSINFO_ATTR_CAPABILITIES = 5, /* Filesystem capabilities (bits) */ + FSINFO_ATTR_TIMESTAMP_INFO = 6, /* Inode timestamp info */ + FSINFO_ATTR_VOLUME_ID = 7, /* Volume ID (string) */ + FSINFO_ATTR_VOLUME_UUID = 8, /* Volume UUID (LE uuid) */ + FSINFO_ATTR_VOLUME_NAME = 9, /* Volume name (string) */ + FSINFO_ATTR_NAME_ENCODING = 10, /* Filename encoding (string) */ + FSINFO_ATTR_NAME_CODEPAGE = 11, /* Filename codepage (string) */ + FSINFO_ATTR__NR +}; + +/* + * Optional fsinfo() parameter structure. + * + * If this is not given, it is assumed that fsinfo_attr_statfs instance 0,0 is + * desired. + */ +struct fsinfo_params { + __u32 at_flags; /* AT_SYMLINK_NOFOLLOW and similar flags */ + __u32 request; /* What is being asking for (enum fsinfo_attribute) */ + __u32 Nth; /* Instance of it (some may have multiple) */ + __u32 Mth; /* Subinstance of Nth instance */ + __u64 __reserved[3]; /* Reserved params; all must be 0 */ +}; + +/* + * Information struct for fsinfo(fsinfo_attr_statfs). + * - This gives extended filesystem information. + */ +struct fsinfo_statfs { + __u64 f_type; /* Filesystem type from linux/magic.h [uncond] */ + __u64 f_bsize; /* Optimal block size */ + __u64 f_blocks; /* Total number of blocks in fs */ + __u64 f_bfree; /* Total number of free blocks */ + __u64 f_bavail; /* Number of free blocks available to ordinary user */ + __u64 f_files; /* Total number of file nodes in fs */ + __u64 f_ffree; /* Number of free file nodes */ + __u64 f_favail; /* Number of file nodes available to ordinary user */ + __u64 f_fsid; /* Filesystem identifier */ + __u64 f_namelen; /* Maximum filename length */ + __u64 f_frsize; /* Fragment size */ + __u64 sb_flags; /* Superblock flags (MS_*) */ + __u64 mnt_attrs; /* Mount attributes (MOUNT_ATTR_*) */ +}; + +/* + * 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]; + __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 __reserved[1]; +}; + +/* + * Information struct for fsinfo(fsinfo_attr_limits). + * + * List of supported filesystem limits. + */ +struct fsinfo_limits { + __u64 max_file_size; /* Maximum file size */ + __u64 max_uid; /* Maximum UID supported */ + __u64 max_gid; /* Maximum GID supported */ + __u64 max_projid; /* Maximum project ID supported */ + __u32 max_dev_major; /* Maximum device major representable */ + __u32 max_dev_minor; /* Maximum device minor representable */ + __u32 max_hard_links; /* Maximum number of hard links on a file */ + __u32 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 __reserved[1]; +}; + +/* + * 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 ioc_flags; /* What FS_IOC_* flags are supported */ + __u32 win_file_attrs; /* What DOS/Windows FILE_* attributes are supported */ + __u32 __reserved[1]; +}; + +/* + * Information struct for fsinfo(fsinfo_attr_capabilities). + * + * Bitmask indicating filesystem capabilities where renderable as single bits. + */ +enum fsinfo_capability { + FSINFO_CAP_IS_KERNEL_FS = 0, /* fs is kernel-special filesystem */ + FSINFO_CAP_IS_BLOCK_FS = 1, /* fs is block-based filesystem */ + FSINFO_CAP_IS_FLASH_FS = 2, /* fs is flash filesystem */ + FSINFO_CAP_IS_NETWORK_FS = 3, /* fs is network filesystem */ + FSINFO_CAP_IS_AUTOMOUNTER_FS = 4, /* fs is automounter special filesystem */ + FSINFO_CAP_IS_MEMORY_FS = 5, /* fs is memory-based filesystem */ + FSINFO_CAP_AUTOMOUNTS = 6, /* fs supports automounts */ + FSINFO_CAP_ADV_LOCKS = 7, /* fs supports advisory file locking */ + FSINFO_CAP_MAND_LOCKS = 8, /* fs supports mandatory file locking */ + FSINFO_CAP_LEASES = 9, /* fs supports file leases */ + FSINFO_CAP_UIDS = 10, /* fs supports numeric uids */ + FSINFO_CAP_GIDS = 11, /* fs supports numeric gids */ + FSINFO_CAP_PROJIDS = 12, /* fs supports numeric project ids */ + FSINFO_CAP_STRING_USER_IDS = 13, /* fs supports string user identifiers */ + FSINFO_CAP_GUID_USER_IDS = 14, /* fs supports GUID user identifiers */ + FSINFO_CAP_WINDOWS_ATTRS = 15, /* fs has windows attributes */ + FSINFO_CAP_USER_QUOTAS = 16, /* fs has per-user quotas */ + FSINFO_CAP_GROUP_QUOTAS = 17, /* fs has per-group quotas */ + FSINFO_CAP_PROJECT_QUOTAS = 18, /* fs has per-project quotas */ + FSINFO_CAP_XATTRS = 19, /* fs has xattrs */ + FSINFO_CAP_JOURNAL = 20, /* fs has a journal */ + FSINFO_CAP_DATA_IS_JOURNALLED = 21, /* fs is using data journalling */ + FSINFO_CAP_O_SYNC = 22, /* fs supports O_SYNC */ + FSINFO_CAP_O_DIRECT = 23, /* fs supports O_DIRECT */ + FSINFO_CAP_VOLUME_ID = 24, /* fs has a volume ID */ + FSINFO_CAP_VOLUME_UUID = 25, /* fs has a volume UUID */ + FSINFO_CAP_VOLUME_NAME = 26, /* fs has a volume name */ + FSINFO_CAP_VOLUME_FSID = 27, /* fs has a volume FSID */ + FSINFO_CAP_IVER_ALL_CHANGE = 28, /* i_version represents data + meta changes */ + FSINFO_CAP_IVER_DATA_CHANGE = 29, /* i_version represents data changes only */ + FSINFO_CAP_IVER_MONO_INCR = 30, /* i_version incremented monotonically */ + FSINFO_CAP_DIRECTORIES = 31, /* fs supports (sub)directories */ + FSINFO_CAP_SYMLINKS = 32, /* fs supports symlinks */ + FSINFO_CAP_HARD_LINKS = 33, /* fs supports hard links */ + FSINFO_CAP_HARD_LINKS_1DIR = 34, /* fs supports hard links in same dir only */ + FSINFO_CAP_DEVICE_FILES = 35, /* fs supports bdev, cdev */ + FSINFO_CAP_UNIX_SPECIALS = 36, /* fs supports pipe, fifo, socket */ + FSINFO_CAP_RESOURCE_FORKS = 37, /* fs supports resource forks/streams */ + FSINFO_CAP_NAME_CASE_INDEP = 38, /* Filename case independence is mandatory */ + FSINFO_CAP_NAME_NON_UTF8 = 39, /* fs has non-utf8 names */ + FSINFO_CAP_NAME_HAS_CODEPAGE = 40, /* fs has a filename codepage */ + FSINFO_CAP_SPARSE = 41, /* fs supports sparse files */ + FSINFO_CAP_NOT_PERSISTENT = 42, /* fs is not persistent */ + FSINFO_CAP_NO_UNIX_MODE = 43, /* fs does not support unix mode bits */ + FSINFO_CAP_HAS_ATIME = 44, /* fs supports access time */ + FSINFO_CAP_HAS_BTIME = 45, /* fs supports birth/creation time */ + FSINFO_CAP_HAS_CTIME = 46, /* fs supports change time */ + FSINFO_CAP_HAS_MTIME = 47, /* fs supports modification time */ + FSINFO_CAP__NR +}; + +struct fsinfo_capabilities { + __u8 capabilities[(FSINFO_CAP__NR + 7) / 8]; +}; + +/* + * Information struct for fsinfo(fsinfo_attr_timestamp_info). + */ +struct fsinfo_timestamp_info { + __s64 minimum_timestamp; /* Minimum timestamp value in seconds */ + __s64 maximum_timestamp; /* Maximum timestamp value in seconds */ + __u16 atime_gran_mantissa; /* Granularity(secs) = mant * 10^exp */ + __u16 btime_gran_mantissa; + __u16 ctime_gran_mantissa; + __u16 mtime_gran_mantissa; + __s8 atime_gran_exponent; + __s8 btime_gran_exponent; + __s8 ctime_gran_exponent; + __s8 mtime_gran_exponent; + __u32 __reserved[1]; +}; + +/* + * Information struct for fsinfo(fsinfo_attr_volume_uuid). + */ +struct fsinfo_volume_uuid { + __u8 uuid[16]; +}; + +/* + * Information struct for fsinfo(fsinfo_attr_fsinfo). + * + * This gives information about fsinfo() itself. + */ +struct fsinfo_fsinfo { + __u32 max_attr; /* Number of supported attributes (fsinfo_attr__nr) */ + __u32 max_cap; /* Number of supported capabilities (fsinfo_cap__nr) */ +}; + +#endif /* _UAPI_LINUX_FSINFO_H */ diff --git a/kernel/sys_ni.c b/kernel/sys_ni.c index 4d9ae5ea6caf..d1d9d76cae1e 100644 --- a/kernel/sys_ni.c +++ b/kernel/sys_ni.c @@ -71,6 +71,9 @@ COND_SYSCALL_COMPAT(epoll_pwait); /* fs/fcntl.c */ +/* fs/fsinfo.c */ +COND_SYSCALL(fsinfo); + /* fs/inotify_user.c */ COND_SYSCALL(inotify_init1); COND_SYSCALL(inotify_add_watch); diff --git a/samples/vfs/Makefile b/samples/vfs/Makefile index a3e4ffd4c773..d3cc8e9a4fd8 100644 --- a/samples/vfs/Makefile +++ b/samples/vfs/Makefile @@ -1,10 +1,14 @@ # List of programs to build hostprogs-y := \ + test-fsinfo \ test-fsmount \ test-statx # Tell kbuild to always build the programs always := $(hostprogs-y) +HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include +HOSTLDLIBS_test-fsinfo += -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..ae62c132bdc2 --- /dev/null +++ b/samples/vfs/test-fsinfo.c @@ -0,0 +1,544 @@ +/* Test the fsinfo() system call + * + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public Licence + * as published by the Free Software Foundation; either version + * 2 of the Licence, or (at your option) any later version. + */ + +#define _GNU_SOURCE +#define _ATFILE_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __NR_fsinfo +#define __NR_fsinfo -1 +#endif + +static bool debug = 0; + +static __attribute__((unused)) +ssize_t fsinfo(int dfd, const char *filename, struct fsinfo_params *params, + void *buffer, size_t buf_size) +{ + return syscall(__NR_fsinfo, dfd, filename, params, buffer, buf_size); +} + +struct fsinfo_attr_info { + unsigned char type; + unsigned char flags; + unsigned short size; +}; + +#define __FSINFO_STRUCT 0 +#define __FSINFO_STRING 1 +#define __FSINFO_OVER 2 +#define __FSINFO_STRUCT_ARRAY 3 +#define __FSINFO_0 0 +#define __FSINFO_N 0x0001 +#define __FSINFO_NM 0x0002 + +#define _Z(T, F, S) { .type = __FSINFO_##T, .flags = __FSINFO_##F, .size = S } +#define FSINFO_STRING(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, 0, 0) +#define FSINFO_STRUCT(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, 0, sizeof(struct fsinfo_##Y)) +#define FSINFO_STRING_N(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, N, 0) +#define FSINFO_STRUCT_N(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, N, sizeof(struct fsinfo_##Y)) +#define FSINFO_STRING_NM(X,Y) [FSINFO_ATTR_##X] = _Z(STRING, NM, 0) +#define FSINFO_STRUCT_NM(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT, NM, sizeof(struct fsinfo_##Y)) +#define FSINFO_OVERLARGE(X,Y) [FSINFO_ATTR_##X] = _Z(OVER, 0, 0) +#define FSINFO_STRUCT_ARRAY(X,Y) [FSINFO_ATTR_##X] = _Z(STRUCT_ARRAY, 0, sizeof(struct fsinfo_##Y)) + +static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { + FSINFO_STRUCT (STATFS, statfs), + FSINFO_STRUCT (FSINFO, fsinfo), + FSINFO_STRUCT (IDS, ids), + FSINFO_STRUCT (LIMITS, limits), + FSINFO_STRUCT (CAPABILITIES, capabilities), + FSINFO_STRUCT (SUPPORTS, supports), + FSINFO_STRUCT (TIMESTAMP_INFO, timestamp_info), + FSINFO_STRING (VOLUME_ID, volume_id), + FSINFO_STRUCT (VOLUME_UUID, volume_uuid), + FSINFO_STRING (VOLUME_NAME, volume_name), + FSINFO_STRING (NAME_ENCODING, name_encoding), + FSINFO_STRING (NAME_CODEPAGE, name_codepage), +}; + +#define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y +static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { + FSINFO_NAME (STATFS, statfs), + FSINFO_NAME (FSINFO, fsinfo), + FSINFO_NAME (IDS, ids), + FSINFO_NAME (LIMITS, limits), + FSINFO_NAME (CAPABILITIES, capabilities), + FSINFO_NAME (SUPPORTS, supports), + FSINFO_NAME (TIMESTAMP_INFO, timestamp_info), + FSINFO_NAME (VOLUME_ID, volume_id), + FSINFO_NAME (VOLUME_UUID, volume_uuid), + FSINFO_NAME (VOLUME_NAME, volume_name), + FSINFO_NAME (NAME_ENCODING, name_encoding), + FSINFO_NAME (NAME_CODEPAGE, name_codepage), +}; + +union reply { + char buffer[4096]; + struct fsinfo_statfs statfs; + struct fsinfo_fsinfo fsinfo; + struct fsinfo_ids ids; + struct fsinfo_limits limits; + struct fsinfo_supports supports; + struct fsinfo_capabilities caps; + struct fsinfo_timestamp_info timestamps; + struct fsinfo_volume_uuid uuid; +}; + +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_attr_STATFS(union reply *r, int size) +{ + struct fsinfo_statfs *f = &r->statfs; + + printf("\n"); + printf("\tblocks: n=%llu fr=%llu av=%llu\n", + (unsigned long long)f->f_blocks, + (unsigned long long)f->f_bfree, + (unsigned long long)f->f_bavail); + + printf("\tfiles : n=%llu fr=%llu av=%llu\n", + (unsigned long long)f->f_files, + (unsigned long long)f->f_ffree, + (unsigned long long)f->f_favail); + printf("\tbsize : %llu\n", f->f_bsize); + printf("\tfrsize: %llu\n", f->f_frsize); + printf("\tmntfl : %llx\n", (unsigned long long)f->mnt_attrs); + printf("\tsbfl : %llx\n", (unsigned long long)f->sb_flags); +} + +static void dump_attr_FSINFO(union reply *r, int size) +{ + struct fsinfo_fsinfo *f = &r->fsinfo; + + printf("max_attr=%u max_cap=%u\n", f->max_attr, f->max_cap); +} + +static void dump_attr_IDS(union reply *r, int size) +{ + struct fsinfo_ids *f = &r->ids; + + 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); +} + +static void dump_attr_LIMITS(union reply *r, int size) +{ + struct fsinfo_limits *f = &r->limits; + + printf("\n"); + printf("\tmax file size: %llx\n", + (unsigned long long)f->max_file_size); + 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 : %x\n", f->max_hard_links); + printf("\tmax xattr : n=%x b=%x\n", + f->max_xattr_name_len, f->max_xattr_body_len); + printf("\tmax len : file=%x sym=%x\n", + f->max_filename_len, f->max_symlink_len); +} + +static void dump_attr_SUPPORTS(union reply *r, int size) +{ + struct fsinfo_supports *f = &r->supports; + + printf("\n"); + printf("\tstx_attr=%llx\n", (unsigned long long)f->stx_attributes); + printf("\tstx_mask=%x\n", f->stx_mask); + printf("\tioc_flags=%x\n", f->ioc_flags); + printf("\twin_fattrs=%x\n", f->win_file_attrs); +} + +#define FSINFO_CAP_NAME(C) [FSINFO_CAP_##C] = #C +static const char *fsinfo_cap_names[FSINFO_CAP__NR] = { + FSINFO_CAP_NAME(IS_KERNEL_FS), + FSINFO_CAP_NAME(IS_BLOCK_FS), + FSINFO_CAP_NAME(IS_FLASH_FS), + FSINFO_CAP_NAME(IS_NETWORK_FS), + FSINFO_CAP_NAME(IS_AUTOMOUNTER_FS), + FSINFO_CAP_NAME(IS_MEMORY_FS), + FSINFO_CAP_NAME(AUTOMOUNTS), + FSINFO_CAP_NAME(ADV_LOCKS), + FSINFO_CAP_NAME(MAND_LOCKS), + FSINFO_CAP_NAME(LEASES), + FSINFO_CAP_NAME(UIDS), + FSINFO_CAP_NAME(GIDS), + FSINFO_CAP_NAME(PROJIDS), + FSINFO_CAP_NAME(STRING_USER_IDS), + FSINFO_CAP_NAME(GUID_USER_IDS), + FSINFO_CAP_NAME(WINDOWS_ATTRS), + FSINFO_CAP_NAME(USER_QUOTAS), + FSINFO_CAP_NAME(GROUP_QUOTAS), + FSINFO_CAP_NAME(PROJECT_QUOTAS), + FSINFO_CAP_NAME(XATTRS), + FSINFO_CAP_NAME(JOURNAL), + FSINFO_CAP_NAME(DATA_IS_JOURNALLED), + FSINFO_CAP_NAME(O_SYNC), + FSINFO_CAP_NAME(O_DIRECT), + FSINFO_CAP_NAME(VOLUME_ID), + FSINFO_CAP_NAME(VOLUME_UUID), + FSINFO_CAP_NAME(VOLUME_NAME), + FSINFO_CAP_NAME(VOLUME_FSID), + FSINFO_CAP_NAME(IVER_ALL_CHANGE), + FSINFO_CAP_NAME(IVER_DATA_CHANGE), + FSINFO_CAP_NAME(IVER_MONO_INCR), + FSINFO_CAP_NAME(DIRECTORIES), + FSINFO_CAP_NAME(SYMLINKS), + FSINFO_CAP_NAME(HARD_LINKS), + FSINFO_CAP_NAME(HARD_LINKS_1DIR), + FSINFO_CAP_NAME(DEVICE_FILES), + FSINFO_CAP_NAME(UNIX_SPECIALS), + FSINFO_CAP_NAME(RESOURCE_FORKS), + FSINFO_CAP_NAME(NAME_CASE_INDEP), + FSINFO_CAP_NAME(NAME_NON_UTF8), + FSINFO_CAP_NAME(NAME_HAS_CODEPAGE), + FSINFO_CAP_NAME(SPARSE), + FSINFO_CAP_NAME(NOT_PERSISTENT), + FSINFO_CAP_NAME(NO_UNIX_MODE), + FSINFO_CAP_NAME(HAS_ATIME), + FSINFO_CAP_NAME(HAS_BTIME), + FSINFO_CAP_NAME(HAS_CTIME), + FSINFO_CAP_NAME(HAS_MTIME), +}; + +static void dump_attr_CAPABILITIES(union reply *r, int size) +{ + struct fsinfo_capabilities *f = &r->caps; + int i; + + for (i = 0; i < sizeof(f->capabilities); i++) + printf("%02x", f->capabilities[i]); + printf("\n"); + for (i = 0; i < FSINFO_CAP__NR; i++) + if (f->capabilities[i / 8] & (1 << (i % 8))) + printf("\t- %s\n", fsinfo_cap_names[i]); +} + +static void dump_attr_TIMESTAMP_INFO(union reply *r, int size) +{ + struct fsinfo_timestamp_info *f = &r->timestamps; + + printf("range=%llx-%llx\n", + (unsigned long long)f->minimum_timestamp, + (unsigned long long)f->maximum_timestamp); + +#define print_time(G) \ + printf("\t"#G"time : gran=%gs\n", \ + (f->G##time_gran_mantissa * \ + pow(10., f->G##time_gran_exponent))) + print_time(a); + print_time(b); + print_time(c); + print_time(m); +} + +static void dump_attr_VOLUME_UUID(union reply *r, int size) +{ + struct fsinfo_volume_uuid *f = &r->uuid; + + 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]); +} + +/* + * + */ +typedef void (*dumper_t)(union reply *r, int size); + +#define FSINFO_DUMPER(N) [FSINFO_ATTR_##N] = dump_attr_##N +static const dumper_t fsinfo_attr_dumper[FSINFO_ATTR__NR] = { + FSINFO_DUMPER(STATFS), + FSINFO_DUMPER(FSINFO), + FSINFO_DUMPER(IDS), + FSINFO_DUMPER(LIMITS), + FSINFO_DUMPER(SUPPORTS), + FSINFO_DUMPER(CAPABILITIES), + FSINFO_DUMPER(TIMESTAMP_INFO), + FSINFO_DUMPER(VOLUME_UUID), +}; + +static void dump_fsinfo(enum fsinfo_attribute attr, + struct fsinfo_attr_info about, + union reply *r, int size) +{ + dumper_t dumper = fsinfo_attr_dumper[attr]; + unsigned int len; + + if (!dumper) { + printf("\n"); + return; + } + + len = about.size; + if (about.type == __FSINFO_STRUCT && size < len) { + printf("\n", size, len); + return; + } + + dumper(r, size); +} + +/* + * Try one subinstance of an attribute. + */ +static int try_one(const char *file, struct fsinfo_params *params, bool raw) +{ + struct fsinfo_attr_info about; + union reply *r; + size_t buf_size = 4096; + char *p; + int ret; + + for (;;) { + r = malloc(buf_size); + if (!r) { + perror("malloc"); + exit(1); + } + memset(r->buffer, 0xbd, buf_size); + + errno = 0; + ret = fsinfo(AT_FDCWD, file, params, r->buffer, buf_size); + if (params->request >= FSINFO_ATTR__NR) { + if (ret == -1 && errno == EOPNOTSUPP) + exit(0); + fprintf(stderr, "Unexpected error for too-large command %u: %m\n", + params->request); + exit(1); + } + if (ret == -1) + break; + + if (ret <= buf_size) + break; + buf_size = (ret + 4096 - 1) & ~(4096 - 1); + } + + if (debug) + printf("fsinfo(%s,%s,%u,%u) = %d: %m\n", + file, fsinfo_attr_names[params->request], + params->Nth, params->Mth, ret); + + about = fsinfo_buffer_info[params->request]; + if (ret == -1) { + if (errno == ENODATA) { + if (!(about.flags & (__FSINFO_N | __FSINFO_NM)) && + params->Nth == 0 && params->Mth == 0) { + fprintf(stderr, + "Unexpected ENODATA (%u[%u][%u])\n", + params->request, params->Nth, params->Mth); + exit(1); + } + return (params->Mth == 0) ? 2 : 1; + } + if (errno == EOPNOTSUPP) { + if (params->Nth > 0 || params->Mth > 0) { + fprintf(stderr, + "Should return -ENODATA (%u[%u][%u])\n", + params->request, params->Nth, params->Mth); + exit(1); + } + //printf("\e[33m%s\e[m: \n", + // fsinfo_attr_names[attr]); + return 2; + } + perror(file); + exit(1); + } + + if (raw) { + if (ret > 4096) + ret = 4096; + dump_hex((unsigned int *)r->buffer, 0, ret); + return 0; + } + + switch (about.flags & (__FSINFO_N | __FSINFO_NM)) { + case 0: + printf("\e[33m%s\e[m: ", + fsinfo_attr_names[params->request]); + break; + case __FSINFO_N: + printf("\e[33m%s[%u]\e[m: ", + fsinfo_attr_names[params->request], + params->Nth); + break; + case __FSINFO_NM: + printf("\e[33m%s[%u][%u]\e[m: ", + fsinfo_attr_names[params->request], + params->Nth, params->Mth); + break; + } + + switch (about.type) { + case __FSINFO_STRUCT: + dump_fsinfo(params->request, about, r, ret); + return 0; + + case __FSINFO_STRING: + if (ret >= 4096) { + ret = 4096; + r->buffer[4092] = '.'; + r->buffer[4093] = '.'; + r->buffer[4094] = '.'; + r->buffer[4095] = 0; + } else { + r->buffer[ret] = 0; + } + for (p = r->buffer; *p; p++) { + if (!isprint(*p)) { + printf("\n"); + continue; + } + } + printf("%s\n", r->buffer); + return 0; + + case __FSINFO_OVER: + return 0; + + case __FSINFO_STRUCT_ARRAY: + dump_fsinfo(params->request, about, r, ret); + return 0; + + default: + fprintf(stderr, "Fishy about %u %u,%u,%u\n", + params->request, about.type, about.flags, about.size); + exit(1); + } +} + +/* + * + */ +int main(int argc, char **argv) +{ + struct fsinfo_params params = { + .at_flags = AT_SYMLINK_NOFOLLOW, + }; + unsigned int attr; + int raw = 0, opt, Nth, Mth; + + while ((opt = getopt(argc, argv, "adlr"))) { + switch (opt) { + case 'a': + params.at_flags |= AT_NO_AUTOMOUNT; + continue; + case 'd': + debug = true; + continue; + case 'l': + params.at_flags &= ~AT_SYMLINK_NOFOLLOW; + continue; + case 'r': + raw = 1; + continue; + } + break; + } + + argc -= optind; + argv += optind; + + if (argc != 1) { + printf("Format: test-fsinfo [-alr] \n"); + exit(2); + } + + for (attr = 0; attr <= FSINFO_ATTR__NR; attr++) { + Nth = 0; + do { + Mth = 0; + do { + params.request = attr; + params.Nth = Nth; + params.Mth = Mth; + + switch (try_one(argv[0], ¶ms, 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 == %u\n", Mth); + break; + } + + } while (++Nth < 100); + + done_N: + if (Nth >= 100) { + fprintf(stderr, "Fishy: Nth == %u\n", Nth); + break; + } + } + + return 0; +} From patchwork Tue May 28 15:11:19 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965161 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E23326C5 for ; Tue, 28 May 2019 15:11:26 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id D1374285F7 for ; Tue, 28 May 2019 15:11:26 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id C5737288D2; Tue, 28 May 2019 15:11:26 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 65C7E287C6 for ; Tue, 28 May 2019 15:11:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727519AbfE1PLW (ORCPT ); Tue, 28 May 2019 11:11:22 -0400 Received: from mx1.redhat.com ([209.132.183.28]:1569 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726313AbfE1PLV (ORCPT ); Tue, 28 May 2019 11:11:21 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 9AC2AC0AEE5C; Tue, 28 May 2019 15:11:21 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 25A415D772; Tue, 28 May 2019 15:11:19 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 02/25] vfs: Allow fsinfo() to query what's in an fs_context [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:19 +0100 Message-ID: <155905627927.1662.13276277442207649583.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Tue, 28 May 2019 15:11:21 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Allow fsinfo() to be used to query the filesystem attached to an fs_context once a superblock has been created or if it comes from fspick(). This is done with something like: fd = fsopen("ext4", 0); ... fsconfig(fd, fsconfig_cmd_create, ...); fsinfo(fd, NULL, ...); Signed-off-by: David Howells --- fs/fsinfo.c | 30 +++++++++++++++++++++++++++++- fs/statfs.c | 2 +- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/fs/fsinfo.c b/fs/fsinfo.c index f9a63410e9a2..14db881dd02d 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include "internal.h" @@ -315,13 +316,40 @@ static int vfs_fsinfo_path(int dfd, const char __user *filename, return ret; } +static int vfs_fsinfo_fscontext(struct fs_context *fc, + struct fsinfo_kparams *params) +{ + int ret; + + if (fc->ops == &legacy_fs_context_ops) + return -EOPNOTSUPP; + + ret = mutex_lock_interruptible(&fc->uapi_mutex); + if (ret < 0) + return ret; + + ret = -EIO; + if (fc->root) { + struct path path = { .dentry = fc->root }; + + ret = vfs_fsinfo(&path, params); + } + + mutex_unlock(&fc->uapi_mutex); + return ret; +} + static int vfs_fsinfo_fd(unsigned int fd, struct fsinfo_kparams *params) { struct fd f = fdget_raw(fd); int ret = -EBADF; if (f.file) { - ret = vfs_fsinfo(&f.file->f_path, params); + if (f.file->f_op == &fscontext_fops) + ret = vfs_fsinfo_fscontext(f.file->private_data, + params); + else + ret = vfs_fsinfo(&f.file->f_path, params); fdput(f); } return ret; diff --git a/fs/statfs.c b/fs/statfs.c index eea7af6f2f22..b9b63d9f4f24 100644 --- a/fs/statfs.c +++ b/fs/statfs.c @@ -86,7 +86,7 @@ int vfs_statfs(const struct path *path, struct kstatfs *buf) int error; error = statfs_by_dentry(path->dentry, buf); - if (!error) + if (!error && path->mnt) buf->f_flags = calculate_f_flags(path->mnt); return error; } From patchwork Tue May 28 15:11:28 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965163 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id AF6666C5 for ; Tue, 28 May 2019 15:11:38 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 9CFA528893 for ; Tue, 28 May 2019 15:11:38 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 90DFF288C4; Tue, 28 May 2019 15:11:38 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 9439A1FF40 for ; Tue, 28 May 2019 15:11:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727543AbfE1PLc (ORCPT ); Tue, 28 May 2019 11:11:32 -0400 Received: from mx1.redhat.com ([209.132.183.28]:38554 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726313AbfE1PLc (ORCPT ); Tue, 28 May 2019 11:11:32 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id C483B3004425; Tue, 28 May 2019 15:11:31 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 216435D704; Tue, 28 May 2019 15:11:29 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 03/25] vfs: Allow fsinfo() to be used to query an fs parameter description [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:28 +0100 Message-ID: <155905628839.1662.2711565764006954008.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.49]); Tue, 28 May 2019 15:11:31 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Provide fsinfo() attributes that can be used to query a filesystem parameter description. To do this, fsinfo() can be called on an fs_context that doesn't yet have a superblock created and attached. It can be obtained by doing, for example: fd = fsopen("ext4", 0); struct fsinfo_param_name name; struct fsinfo_params params = { .request = fsinfo_attr_param_name, .Nth = 3, }; fsinfo(fd, NULL, ¶ms, &name, sizeof(name)); to query the 4th parameter name in the name to parameter ID mapping table. Signed-off-by: David Howells --- fs/fsinfo.c | 94 +++++++++++++++++++++++++++++ include/uapi/linux/fsinfo.h | 58 ++++++++++++++++++ samples/vfs/Makefile | 2 + samples/vfs/test-fs-query.c | 139 +++++++++++++++++++++++++++++++++++++++++++ samples/vfs/test-fsinfo.c | 14 ++++ 5 files changed, 307 insertions(+) create mode 100644 samples/vfs/test-fs-query.c diff --git a/fs/fsinfo.c b/fs/fsinfo.c index 14db881dd02d..c7f9c894c737 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -9,6 +9,7 @@ #include #include #include +#include #include #include "internal.h" @@ -210,12 +211,87 @@ static int fsinfo_generic_name_encoding(struct path *path, char *buf) return sizeof(encoding) - 1; } +static int fsinfo_generic_param_description(struct file_system_type *f, + struct fsinfo_kparams *params) +{ + const struct fs_parameter_description *desc = f->parameters; + const struct fs_parameter_spec *s; + const struct fs_parameter_enum *e; + struct fsinfo_param_description *p = params->buffer; + + if (desc && desc->specs) { + for (s = desc->specs; s->name; s++) {} + p->nr_params = s - desc->specs; + if (desc->enums) { + for (e = desc->enums; e->name[0]; e++) {} + p->nr_enum_names = e - desc->enums; + } + } + + return sizeof(*p); +} + +static int fsinfo_generic_param_specification(struct file_system_type *f, + struct fsinfo_kparams *params) +{ + const struct fs_parameter_description *desc = f->parameters; + const struct fs_parameter_spec *s; + struct fsinfo_param_specification *p = params->buffer; + unsigned int nth = params->Nth; + + if (!desc || !desc->specs) + return -ENODATA; + + for (s = desc->specs; s->name; s++) { + if (nth == 0) + goto found; + nth--; + } + + return -ENODATA; + +found: + p->type = s->type; + p->flags = s->flags; + p->opt = s->opt; + strlcpy(p->name, s->name, sizeof(p->name)); + return sizeof(*p); +} + +static int fsinfo_generic_param_enum(struct file_system_type *f, + struct fsinfo_kparams *params) +{ + const struct fs_parameter_description *desc = f->parameters; + const struct fs_parameter_enum *e; + struct fsinfo_param_enum *p = params->buffer; + unsigned int nth = params->Nth; + + if (!desc || !desc->enums) + return -ENODATA; + + for (e = desc->enums; e->name; e++) { + if (nth == 0) + goto found; + nth--; + } + + return -ENODATA; + +found: + p->opt = e->opt; + strlcpy(p->name, e->name, sizeof(p->name)); + return sizeof(*p); +} + /* * Implement some queries generically from stuff in the superblock. */ int generic_fsinfo(struct path *path, struct fsinfo_kparams *params) { + struct file_system_type *f = path->dentry->d_sb->s_type; + #define _gen(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(path, params->buffer) +#define _genf(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(f, params) switch (params->request) { case _gen(STATFS, statfs); @@ -227,6 +303,9 @@ int generic_fsinfo(struct path *path, struct fsinfo_kparams *params) case _gen(VOLUME_UUID, volume_uuid); case _gen(VOLUME_ID, volume_id); case _gen(NAME_ENCODING, name_encoding); + case _genf(PARAM_DESCRIPTION, param_description); + case _genf(PARAM_SPECIFICATION, param_specification); + case _genf(PARAM_ENUM, param_enum); default: return -EOPNOTSUPP; } @@ -319,11 +398,23 @@ static int vfs_fsinfo_path(int dfd, const char __user *filename, static int vfs_fsinfo_fscontext(struct fs_context *fc, struct fsinfo_kparams *params) { + struct file_system_type *f = fc->fs_type; int ret; if (fc->ops == &legacy_fs_context_ops) return -EOPNOTSUPP; + /* Filesystem parameter query is static information and doesn't need a + * lock to read it. + */ + switch (params->request) { + case _genf(PARAM_DESCRIPTION, param_description); + case _genf(PARAM_SPECIFICATION, param_specification); + case _genf(PARAM_ENUM, param_enum); + default: + break; + } + ret = mutex_lock_interruptible(&fc->uapi_mutex); if (ret < 0) return ret; @@ -410,6 +501,9 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRING (VOLUME_NAME, volume_name), FSINFO_STRING (NAME_ENCODING, name_encoding), FSINFO_STRING (NAME_CODEPAGE, name_codepage), + FSINFO_STRUCT (PARAM_DESCRIPTION, param_description), + FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), + FSINFO_STRUCT_N (PARAM_ENUM, param_enum), }; /** diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h index 0af09b7e734c..248c3c4a1e32 100644 --- a/include/uapi/linux/fsinfo.h +++ b/include/uapi/linux/fsinfo.h @@ -27,6 +27,9 @@ enum fsinfo_attribute { FSINFO_ATTR_VOLUME_NAME = 9, /* Volume name (string) */ FSINFO_ATTR_NAME_ENCODING = 10, /* Filename encoding (string) */ FSINFO_ATTR_NAME_CODEPAGE = 11, /* Filename codepage (string) */ + FSINFO_ATTR_PARAM_DESCRIPTION = 12, /* General fs parameter description */ + FSINFO_ATTR_PARAM_SPECIFICATION = 13, /* Nth parameter specification */ + FSINFO_ATTR_PARAM_ENUM = 14, /* Nth enum-to-val */ FSINFO_ATTR__NR }; @@ -208,4 +211,59 @@ struct fsinfo_fsinfo { __u32 max_cap; /* Number of supported capabilities (fsinfo_cap__nr) */ }; +/* + * Information struct for fsinfo(fsinfo_attr_param_description). + * + * Query the parameter set for a filesystem. + */ +struct fsinfo_param_description { + __u32 nr_params; /* Number of individual parameters */ + __u32 nr_enum_names; /* Number of enum names */ +}; + +/* + * Information struct for fsinfo(fsinfo_attr_param_specification). + * + * Query the specification of the Nth filesystem parameter. + */ +struct fsinfo_param_specification { + __u32 type; /* enum fsinfo_param_specification_type */ + __u32 flags; /* Qualifiers */ + __u32 opt; /* Corresponding params have same ID here */ + char name[240]; +}; + +enum fsinfo_param_specification_type { + FSINFO_PARAM_SPEC_NOT_DEFINED = 0, + FSINFO_PARAM_SPEC_IS_FLAG = 1, + FSINFO_PARAM_SPEC_IS_BOOL = 2, + FSINFO_PARAM_SPEC_IS_U32 = 3, + FSINFO_PARAM_SPEC_IS_U32_OCTAL = 4, + FSINFO_PARAM_SPEC_IS_U32_HEX = 5, + FSINFO_PARAM_SPEC_IS_S32 = 6, + FSINFO_PARAM_SPEC_IS_U64 = 7, + FSINFO_PARAM_SPEC_IS_ENUM = 8, + FSINFO_PARAM_SPEC_IS_STRING = 9, + FSINFO_PARAM_SPEC_IS_BLOB = 10, + FSINFO_PARAM_SPEC_IS_BLOCKDEV = 11, + FSINFO_PARAM_SPEC_IS_PATH = 12, + FSINFO_PARAM_SPEC_IS_FD = 13, + NR__FSINFO_PARAM_SPEC +}; + +#define FSINFO_PARAM_SPEC_VALUE_IS_OPTIONAL 0X00000001 +#define FSINFO_PARAM_SPEC_PREFIX_NO_IS_NEG 0X00000002 +#define FSINFO_PARAM_SPEC_EMPTY_STRING_IS_NEG 0X00000004 +#define FSINFO_PARAM_SPEC_DEPRECATED 0X00000008 + +/* + * Information struct for fsinfo(fsinfo_attr_param_enum). + * + * Query the Nth filesystem enum parameter value name. + */ +struct fsinfo_param_enum { + __u32 opt; /* ->opt of the relevant parameter specification */ + char name[252]; /* Name of the enum value */ +}; + #endif /* _UAPI_LINUX_FSINFO_H */ diff --git a/samples/vfs/Makefile b/samples/vfs/Makefile index d3cc8e9a4fd8..3c542d3b9479 100644 --- a/samples/vfs/Makefile +++ b/samples/vfs/Makefile @@ -1,6 +1,7 @@ # List of programs to build hostprogs-y := \ test-fsinfo \ + test-fs-query \ test-fsmount \ test-statx @@ -10,5 +11,6 @@ always := $(hostprogs-y) HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include HOSTLDLIBS_test-fsinfo += -lm +HOSTCFLAGS_test-fs-query.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-fs-query.c b/samples/vfs/test-fs-query.c new file mode 100644 index 000000000000..4ef978c5e90a --- /dev/null +++ b/samples/vfs/test-fs-query.c @@ -0,0 +1,139 @@ +/* Test using the fsinfo() system call to query mount parameters. + * + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public Licence + * as published by the Free Software Foundation; either version + * 2 of the Licence, or (at your option) any later version. + */ + +#define _GNU_SOURCE +#define _ATFILE_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __NR_fsopen +#define __NR_fsopen -1 +#endif +#ifndef __NR_fsinfo +#define __NR_fsinfo -1 +#endif + +static int fsopen(const char *fs_name, unsigned int flags) +{ + return syscall(__NR_fsopen, fs_name, flags); +} + +static ssize_t fsinfo(int dfd, const char *filename, struct fsinfo_params *params, + void *buffer, size_t buf_size) +{ + return syscall(__NR_fsinfo, dfd, filename, params, buffer, buf_size); +} + +static const char *param_types[NR__FSINFO_PARAM_SPEC] = { + [FSINFO_PARAM_SPEC_NOT_DEFINED] = "?undef", + [FSINFO_PARAM_SPEC_IS_FLAG] = "flag", + [FSINFO_PARAM_SPEC_IS_BOOL] = "bool", + [FSINFO_PARAM_SPEC_IS_U32] = "u32", + [FSINFO_PARAM_SPEC_IS_U32_OCTAL] = "octal", + [FSINFO_PARAM_SPEC_IS_U32_HEX] = "hex", + [FSINFO_PARAM_SPEC_IS_S32] = "s32", + [FSINFO_PARAM_SPEC_IS_U64] = "u64", + [FSINFO_PARAM_SPEC_IS_ENUM] = "enum", + [FSINFO_PARAM_SPEC_IS_STRING] = "string", + [FSINFO_PARAM_SPEC_IS_BLOB] = "binary", + [FSINFO_PARAM_SPEC_IS_BLOCKDEV] = "blockdev", + [FSINFO_PARAM_SPEC_IS_PATH] = "path", + [FSINFO_PARAM_SPEC_IS_FD] = "fd", +}; + +/* + * + */ +int main(int argc, char **argv) +{ + struct fsinfo_param_description desc; + struct fsinfo_param_specification spec; + struct fsinfo_param_enum enum_name; + + struct fsinfo_params params = { + .at_flags = AT_SYMLINK_NOFOLLOW, + }; + int fd; + + if (argc != 2) { + printf("Format: test-fs-query \n"); + exit(2); + } + + fd = fsopen(argv[1], 0); + if (fd == -1) { + perror(argv[1]); + exit(1); + } + + params.request = FSINFO_ATTR_PARAM_DESCRIPTION; + if (fsinfo(fd, NULL, ¶ms, &desc, sizeof(desc)) == -1) { + perror("fsinfo/desc"); + exit(1); + } + + printf("Filesystem %s has %u parameters\n", argv[1], desc.nr_params); + + params.request = FSINFO_ATTR_PARAM_SPECIFICATION; + for (params.Nth = 0; params.Nth < desc.nr_params; params.Nth++) { + char type[32]; + + if (fsinfo(fd, NULL, ¶ms, &spec, sizeof(spec)) == -1) { + if (errno == ENODATA) + break; + perror("fsinfo/spec"); + exit(1); + } + + if (spec.type < NR__FSINFO_PARAM_SPEC) + strcpy(type, param_types[spec.type]); + else + sprintf(type, "?%u", spec.type); + + printf("- PARAM[%3u] %-20s %3u %s%s%s%s%s\n", + params.Nth, + spec.name, + spec.opt, + type, + spec.flags & FSINFO_PARAM_SPEC_VALUE_IS_OPTIONAL ? ",opt" : "", + spec.flags & FSINFO_PARAM_SPEC_PREFIX_NO_IS_NEG ? ",neg-no" : "", + spec.flags & FSINFO_PARAM_SPEC_EMPTY_STRING_IS_NEG ? ",neg-empty" : "", + spec.flags & FSINFO_PARAM_SPEC_DEPRECATED ? ",dep" : ""); + } + + printf("Filesystem has %u enumeration values\n", desc.nr_enum_names); + + params.request = FSINFO_ATTR_PARAM_ENUM; + for (params.Nth = 0; params.Nth < desc.nr_enum_names; params.Nth++) { + if (fsinfo(fd, NULL, ¶ms, &enum_name, sizeof(enum_name)) == -1) { + if (errno == ENODATA) + break; + perror("fsinfo/enum"); + exit(1); + } + printf("- ENUM[%3u] %3u=%s\n", + params.Nth, enum_name.opt, enum_name.name); + } + return 0; +} diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index ae62c132bdc2..71c7b68e76b3 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -78,6 +78,9 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRING (VOLUME_NAME, volume_name), FSINFO_STRING (NAME_ENCODING, name_encoding), FSINFO_STRING (NAME_CODEPAGE, name_codepage), + FSINFO_STRUCT (PARAM_DESCRIPTION, param_description), + FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), + FSINFO_STRUCT_N (PARAM_ENUM, param_enum), }; #define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y @@ -94,6 +97,9 @@ static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { FSINFO_NAME (VOLUME_NAME, volume_name), FSINFO_NAME (NAME_ENCODING, name_encoding), FSINFO_NAME (NAME_CODEPAGE, name_codepage), + FSINFO_NAME (PARAM_DESCRIPTION, param_description), + FSINFO_NAME (PARAM_SPECIFICATION, param_specification), + FSINFO_NAME (PARAM_ENUM, param_enum), }; union reply { @@ -507,6 +513,14 @@ int main(int argc, char **argv) } for (attr = 0; attr <= FSINFO_ATTR__NR; attr++) { + switch (attr) { + case FSINFO_ATTR_PARAM_DESCRIPTION: + case FSINFO_ATTR_PARAM_SPECIFICATION: + case FSINFO_ATTR_PARAM_ENUM: + /* See test-fs-query.c instead */ + continue; + } + Nth = 0; do { Mth = 0; From patchwork Tue May 28 15:11:37 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965165 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id F050076 for ; Tue, 28 May 2019 15:11:45 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id DD761287C6 for ; Tue, 28 May 2019 15:11:45 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id D156E288D1; Tue, 28 May 2019 15:11:45 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 1458F287C6 for ; Tue, 28 May 2019 15:11:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727559AbfE1PLk (ORCPT ); Tue, 28 May 2019 11:11:40 -0400 Received: from mx1.redhat.com ([209.132.183.28]:58986 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726760AbfE1PLk (ORCPT ); Tue, 28 May 2019 11:11:40 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 4B3C3C05B00A; Tue, 28 May 2019 15:11:39 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id C309C173B0; Tue, 28 May 2019 15:11:37 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 04/25] vfs: Implement parameter value retrieval with fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:37 +0100 Message-ID: <155905629702.1662.7233272785972036117.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.31]); Tue, 28 May 2019 15:11:39 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Implement parameter value retrieval with fsinfo() - akin to parsing /proc/mounts. This allows all the parameters to be retrieved in one go with: struct fsinfo_params params = { .request = FSINFO_ATTR_PARAMETER, }; Each parameter comes as a pair of blobs with a length tacked on the front rather than using separators, since any printable character that could be used as a separator can be found in some value somewhere (including comma). In fact, cifs allows the separator to be set using the "sep=" option in parameter parsing. The length on the front of each blob is 1-3 bytes long. Each byte has a flag in bit 7 that's set if there are more bytes and clear on the last byte; bits 0-6 should be shifted and OR'd into the length count. The bytes are most-significant first. For example, 0x83 0xf5 0x06 is the length (0x03<<14 | 0x75<<7 | 0x06). As mentioned, each parameter comes as a pair of blobs in key, value order. The value has length zero if not present. So, for example: \x08compress\x04zlib from btrfs would be equivalent to "compress=zlib" and: \x02ro\x00\x06noexec\x00 would be equivalent to "ro,noexec". The test-fsinfo sample program is modified to dump the parameters. Signed-off-by: David Howells --- fs/fsinfo.c | 114 +++++++++++++++++++++++++++++++++++++++++++ include/linux/fsinfo.h | 3 + include/uapi/linux/fsinfo.h | 1 samples/vfs/test-fsinfo.c | 38 ++++++++++++++ 4 files changed, 156 insertions(+) diff --git a/fs/fsinfo.c b/fs/fsinfo.c index c7f9c894c737..2da321b34bdf 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -283,6 +283,25 @@ static int fsinfo_generic_param_enum(struct file_system_type *f, return sizeof(*p); } +static void fsinfo_insert_sb_flag_parameters(struct path *path, + struct fsinfo_kparams *params) +{ + int s_flags = READ_ONCE(path->dentry->d_sb->s_flags); + + if (s_flags & SB_DIRSYNC) + fsinfo_note_param(params, "dirsync", NULL); + if (s_flags & SB_LAZYTIME) + fsinfo_note_param(params, "lazytime", NULL); + if (s_flags & SB_MANDLOCK) + fsinfo_note_param(params, "mand", NULL); + if (s_flags & SB_POSIXACL) + fsinfo_note_param(params, "posixacl", NULL); + if (s_flags & SB_RDONLY) + fsinfo_note_param(params, "ro", NULL); + if (s_flags & SB_SYNCHRONOUS) + fsinfo_note_param(params, "sync", NULL); +} + /* * Implement some queries generically from stuff in the superblock. */ @@ -345,8 +364,17 @@ static int vfs_fsinfo(struct path *path, struct fsinfo_kparams *params) return fsinfo(path, params); while (!signal_pending(current)) { + if (params->request == FSINFO_ATTR_PARAMETERS) { + if (down_read_killable(&dentry->d_sb->s_umount) < 0) + return -ERESTARTSYS; + fsinfo_insert_sb_flag_parameters(path, params); + } + params->usage = 0; ret = fsinfo(path, params); + if (params->request == FSINFO_ATTR_PARAMETERS) + up_read(&dentry->d_sb->s_umount); + if (ret <= (int)params->buf_size) return ret; /* Error or it fitted */ kvfree(params->buffer); @@ -504,6 +532,7 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT (PARAM_DESCRIPTION, param_description), FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), FSINFO_STRUCT_N (PARAM_ENUM, param_enum), + FSINFO_OPAQUE (PARAMETERS, -), }; /** @@ -644,3 +673,88 @@ SYSCALL_DEFINE5(fsinfo, error: return ret; } + +/* + * Store a parameter into the user's parameter buffer. The key is prefixed by + * a single byte length (1-127) and the value by one (0-0x7f) or two bytes + * (0x80-0x3fff) or three bytes (0x4000-0x1fffff). + * + * Note that we must always make the size determination, even if the buffer is + * already full, so that we can tell the caller how much buffer we actually + * need. + */ +static void __fsinfo_note_param(struct fsinfo_kparams *params, const char *key, + const char *val, unsigned int vlen) +{ + char *p; + unsigned int usage; + int klen, total, vmeta; + u8 x; + + klen = strlen(key); + BUG_ON(klen < 1 || klen > 127); + BUG_ON(vlen > (1 << 21) - 1); + BUG_ON(vlen > 0 && !val); + + vmeta = (vlen <= 127) ? 1 : (vlen <= 127 * 127) ? 2 : 3; + + total = 1 + klen + vmeta + vlen; + + usage = params->usage; + params->usage = usage + total; + if (!params->buffer || params->usage > params->buf_size) + return; + + p = params->buffer + usage; + *p++ = klen; + p = memcpy(p, key, klen); + p += klen; + + /* The more significant groups of 7 bits in the size are included in + * most->least order with 0x80 OR'd in. The least significant 7 bits + * are last with the top bit clear. + */ + x = vlen >> 14; + if (x & 0x7f) + *p++ = 0x80 | x; + + x = vlen >> 7; + if (x & 0x7f) + *p++ = 0x80 | x; + + *p++ = vlen & 0x7f; + memcpy(p, val, vlen); +} + +/** + * fsinfo_note_param - Store a parameter for FSINFO_ATTR_PARAMETERS + * @params: The parameter buffer + * @key: The parameter's key + * @val: The parameter's value (or NULL) + */ +void fsinfo_note_param(struct fsinfo_kparams *params, const char *key, + const char *val) +{ + __fsinfo_note_param(params, key, val, val ? strlen(val) : 0); +} +EXPORT_SYMBOL(fsinfo_note_param); + +/** + * fsinfo_note_paramf - Store a formatted parameter for FSINFO_ATTR_PARAMETERS + * @params: The parameter buffer + * @key: The parameter's key + * @val_fmt: Format string for the parameter's value + */ +void fsinfo_note_paramf(struct fsinfo_kparams *params, const char *key, + const char *val_fmt, ...) +{ + va_list va; + int n; + + va_start(va, val_fmt); + n = vsnprintf(params->scratch_buffer, 4096, val_fmt, va); + va_end(va); + + __fsinfo_note_param(params, key, params->scratch_buffer, n); +} +EXPORT_SYMBOL(fsinfo_note_paramf); diff --git a/include/linux/fsinfo.h b/include/linux/fsinfo.h index e17e4f0bae18..3383027a6e9d 100644 --- a/include/linux/fsinfo.h +++ b/include/linux/fsinfo.h @@ -29,6 +29,9 @@ struct fsinfo_kparams { }; extern int generic_fsinfo(struct path *, struct fsinfo_kparams *); +extern void fsinfo_note_param(struct fsinfo_kparams *, const char *, const char *); +extern void fsinfo_note_paramf(struct fsinfo_kparams *, const char *, const char *, ...) + __printf(3, 4); static inline void fsinfo_set_cap(struct fsinfo_capabilities *c, enum fsinfo_capability cap) diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h index 248c3c4a1e32..0f134847e88b 100644 --- a/include/uapi/linux/fsinfo.h +++ b/include/uapi/linux/fsinfo.h @@ -30,6 +30,7 @@ enum fsinfo_attribute { FSINFO_ATTR_PARAM_DESCRIPTION = 12, /* General fs parameter description */ FSINFO_ATTR_PARAM_SPECIFICATION = 13, /* Nth parameter specification */ FSINFO_ATTR_PARAM_ENUM = 14, /* Nth enum-to-val */ + FSINFO_ATTR_PARAMETERS = 15, /* Mount parameters (large string) */ FSINFO_ATTR__NR }; diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index 71c7b68e76b3..2960fa2b9843 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -81,6 +81,7 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT (PARAM_DESCRIPTION, param_description), FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), FSINFO_STRUCT_N (PARAM_ENUM, param_enum), + FSINFO_OVERLARGE (PARAMETERS, -), }; #define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y @@ -100,6 +101,7 @@ static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { FSINFO_NAME (PARAM_DESCRIPTION, param_description), FSINFO_NAME (PARAM_SPECIFICATION, param_specification), FSINFO_NAME (PARAM_ENUM, param_enum), + FSINFO_NAME (PARAMETERS, parameters), }; union reply { @@ -345,6 +347,34 @@ static void dump_fsinfo(enum fsinfo_attribute attr, dumper(r, size); } +static void dump_params(struct fsinfo_attr_info about, union reply *r, int size) +{ + int len; + char *p = r->buffer, *e = p + size; + bool is_key = true; + + while (p < e) { + len = 0; + while (p[0] & 0x80) { + len <<= 7; + len |= *p++ & 0x7f; + } + + len <<= 7; + len |= *p++; + if (len > e - p) + break; + if (is_key || len) + printf("%s%*.*s", is_key ? "[PARM] " : "= ", len, len, p); + if (is_key) + putchar(' '); + else + putchar('\n'); + p += len; + is_key = !is_key; + } +} + /* * Try one subinstance of an attribute. */ @@ -420,6 +450,12 @@ static int try_one(const char *file, struct fsinfo_params *params, bool raw) return 0; } + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + if (ret == 0) + return 0; + } + switch (about.flags & (__FSINFO_N | __FSINFO_NM)) { case 0: printf("\e[33m%s\e[m: ", @@ -462,6 +498,8 @@ static int try_one(const char *file, struct fsinfo_params *params, bool raw) return 0; case __FSINFO_OVER: + if (params->request == FSINFO_ATTR_PARAMETERS) + dump_params(about, r, ret); return 0; case __FSINFO_STRUCT_ARRAY: From patchwork Tue May 28 15:11:44 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965167 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 731E66C5 for ; Tue, 28 May 2019 15:11:53 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 625A3288B6 for ; Tue, 28 May 2019 15:11:53 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 56F7C288D1; Tue, 28 May 2019 15:11:53 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 9AC3A28893 for ; Tue, 28 May 2019 15:11:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727606AbfE1PLs (ORCPT ); Tue, 28 May 2019 11:11:48 -0400 Received: from mx1.redhat.com ([209.132.183.28]:38589 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726760AbfE1PLr (ORCPT ); Tue, 28 May 2019 11:11:47 -0400 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E15B1307B963; Tue, 28 May 2019 15:11:46 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 50B81A6203; Tue, 28 May 2019 15:11:45 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 05/25] fsinfo: Implement retrieval of LSM parameters with fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:44 +0100 Message-ID: <155905630451.1662.10595357703610080056.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.47]); Tue, 28 May 2019 15:11:47 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Implement LSM parameter value retrieval with fsinfo() - akin to parsing /proc/mounts. This allows all the LSM parameters to be retrieved in one go with: struct fsinfo_params params = { .request = FSINFO_ATTR_LSM_PARAMETER, }; The format is a blob containing pairs of length-prefixed strings to avoid the need to escape commas and suchlike in the values. This is the same as for FSINFO_ATTR_PARAMETER. Signed-off-by: David Howells --- fs/fsinfo.c | 21 +++++++++++++++------ include/linux/lsm_hooks.h | 13 +++++++++++++ include/linux/security.h | 11 +++++++++++ include/uapi/linux/fsinfo.h | 1 + samples/vfs/test-fsinfo.c | 6 +++++- security/security.c | 12 ++++++++++++ 6 files changed, 57 insertions(+), 7 deletions(-) diff --git a/fs/fsinfo.c b/fs/fsinfo.c index 2da321b34bdf..256a87b62eed 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -341,7 +341,8 @@ static int vfs_fsinfo(struct path *path, struct fsinfo_kparams *params) int (*fsinfo)(struct path *, struct fsinfo_kparams *); int ret; - if (params->request == FSINFO_ATTR_FSINFO) { + switch (params->request) { + case FSINFO_ATTR_FSINFO: { struct fsinfo_fsinfo *info = params->buffer; info->max_attr = FSINFO_ATTR__NR; @@ -349,11 +350,18 @@ static int vfs_fsinfo(struct path *path, struct fsinfo_kparams *params) return sizeof(*info); } - fsinfo = dentry->d_sb->s_op->fsinfo; - if (!fsinfo) { - if (!dentry->d_sb->s_op->statfs) - return -EOPNOTSUPP; - fsinfo = generic_fsinfo; + case FSINFO_ATTR_LSM_PARAMETERS: + fsinfo = security_sb_fsinfo; + break; + + default: + fsinfo = dentry->d_sb->s_op->fsinfo; + if (!fsinfo) { + if (!dentry->d_sb->s_op->statfs) + return -EOPNOTSUPP; + fsinfo = generic_fsinfo; + } + break; } ret = security_sb_statfs(dentry); @@ -533,6 +541,7 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), FSINFO_STRUCT_N (PARAM_ENUM, param_enum), FSINFO_OPAQUE (PARAMETERS, -), + FSINFO_OPAQUE (LSM_PARAMETERS, -), }; /** diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h index 47f58cfb6a19..2474c3f785ca 100644 --- a/include/linux/lsm_hooks.h +++ b/include/linux/lsm_hooks.h @@ -108,6 +108,13 @@ * mountpoint. * @dentry is a handle on the superblock for the filesystem. * Return 0 if permission is granted. + * @sb_fsinfo: + * Query LSM information for a filesystem. + * @path is a handle on the superblock for the filesystem. + * @params is the fsinfo parameter and buffer block. + * - Currently, params->request can only be FSINFO_ATTR_LSM_PARAMETERS. + * Return the length of the data in the buffer (and can return -ENODATA to + * indicate no value under certain circumstances). * @sb_mount: * Check permission before an object specified by @dev_name is mounted on * the mount point named by @nd. For an ordinary mount, @dev_name @@ -1492,6 +1499,9 @@ union security_list_options { int (*sb_kern_mount)(struct super_block *sb); int (*sb_show_options)(struct seq_file *m, struct super_block *sb); int (*sb_statfs)(struct dentry *dentry); +#ifdef CONFIG_FSINFO + int (*sb_fsinfo)(struct path *path, struct fsinfo_kparams *params); +#endif int (*sb_mount)(const char *dev_name, const struct path *path, const char *type, unsigned long flags, void *data); int (*sb_umount)(struct vfsmount *mnt, int flags); @@ -1838,6 +1848,9 @@ struct security_hook_heads { struct hlist_head sb_kern_mount; struct hlist_head sb_show_options; struct hlist_head sb_statfs; +#ifdef CONFIG_FSINFO + struct hlist_head sb_fsinfo; +#endif struct hlist_head sb_mount; struct hlist_head sb_umount; struct hlist_head sb_pivotroot; diff --git a/include/linux/security.h b/include/linux/security.h index 659071c2e57c..23c8b602c0ab 100644 --- a/include/linux/security.h +++ b/include/linux/security.h @@ -57,6 +57,7 @@ struct mm_struct; struct fs_context; struct fs_parameter; enum fs_value_type; +struct fsinfo_kparams; /* Default (no) options for the capable function */ #define CAP_OPT_NONE 0x0 @@ -237,6 +238,9 @@ int security_sb_remount(struct super_block *sb, void *mnt_opts); int security_sb_kern_mount(struct super_block *sb); int security_sb_show_options(struct seq_file *m, struct super_block *sb); int security_sb_statfs(struct dentry *dentry); +#ifdef CONFIG_FSINFO +int security_sb_fsinfo(struct path *path, struct fsinfo_kparams *params); +#endif int security_sb_mount(const char *dev_name, const struct path *path, const char *type, unsigned long flags, void *data); int security_sb_umount(struct vfsmount *mnt, int flags); @@ -575,6 +579,13 @@ static inline int security_sb_statfs(struct dentry *dentry) return 0; } +#ifdef CONFIG_FSINFO +static inline int security_sb_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + return 0; +} +#endif + static inline int security_sb_mount(const char *dev_name, const struct path *path, const char *type, unsigned long flags, void *data) diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h index 0f134847e88b..dae2e8dd757e 100644 --- a/include/uapi/linux/fsinfo.h +++ b/include/uapi/linux/fsinfo.h @@ -31,6 +31,7 @@ enum fsinfo_attribute { FSINFO_ATTR_PARAM_SPECIFICATION = 13, /* Nth parameter specification */ FSINFO_ATTR_PARAM_ENUM = 14, /* Nth enum-to-val */ FSINFO_ATTR_PARAMETERS = 15, /* Mount parameters (large string) */ + FSINFO_ATTR_LSM_PARAMETERS = 16, /* LSM Mount parameters (large string) */ FSINFO_ATTR__NR }; diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index 2960fa2b9843..e98384e8fb46 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -82,6 +82,7 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT_N (PARAM_SPECIFICATION, param_specification), FSINFO_STRUCT_N (PARAM_ENUM, param_enum), FSINFO_OVERLARGE (PARAMETERS, -), + FSINFO_OVERLARGE (LSM_PARAMETERS, -), }; #define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y @@ -102,6 +103,7 @@ static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { FSINFO_NAME (PARAM_SPECIFICATION, param_specification), FSINFO_NAME (PARAM_ENUM, param_enum), FSINFO_NAME (PARAMETERS, parameters), + FSINFO_NAME (LSM_PARAMETERS, lsm_parameters), }; union reply { @@ -452,6 +454,7 @@ static int try_one(const char *file, struct fsinfo_params *params, bool raw) switch (params->request) { case FSINFO_ATTR_PARAMETERS: + case FSINFO_ATTR_LSM_PARAMETERS: if (ret == 0) return 0; } @@ -498,7 +501,8 @@ static int try_one(const char *file, struct fsinfo_params *params, bool raw) return 0; case __FSINFO_OVER: - if (params->request == FSINFO_ATTR_PARAMETERS) + if (params->request == FSINFO_ATTR_PARAMETERS || + params->request == FSINFO_ATTR_LSM_PARAMETERS) dump_params(about, r, ret); return 0; diff --git a/security/security.c b/security/security.c index 613a5c00e602..3af886e8fced 100644 --- a/security/security.c +++ b/security/security.c @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -821,6 +822,17 @@ int security_sb_statfs(struct dentry *dentry) return call_int_hook(sb_statfs, 0, dentry); } +#ifdef CONFIG_FSINFO +int security_sb_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + int ret = -ENODATA; + + if (params->request == FSINFO_ATTR_LSM_PARAMETERS) + ret = 0; /* This is cumulative amongst all LSMs */ + return call_int_hook(sb_fsinfo, ret, path, params); +} +#endif + int security_sb_mount(const char *dev_name, const struct path *path, const char *type, unsigned long flags, void *data) { From patchwork Tue May 28 15:11:52 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965169 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 716F276 for ; Tue, 28 May 2019 15:12:02 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 5DE06288C7 for ; Tue, 28 May 2019 15:12:02 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 520A2285F7; Tue, 28 May 2019 15:12:02 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 29009204FD for ; Tue, 28 May 2019 15:12:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727623AbfE1PL4 (ORCPT ); Tue, 28 May 2019 11:11:56 -0400 Received: from mx1.redhat.com ([209.132.183.28]:35532 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726760AbfE1PL4 (ORCPT ); Tue, 28 May 2019 11:11:56 -0400 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 8F137F9E8C; Tue, 28 May 2019 15:11:55 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id D5342A622F; Tue, 28 May 2019 15:11:52 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 06/25] vfs: Introduce a non-repeating system-unique superblock ID [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:11:52 +0100 Message-ID: <155905631215.1662.17611579248841782314.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.38]); Tue, 28 May 2019 15:11:55 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Introduce a non-repeating system-unique superblock ID that can be used to tag superblock notification messages. The ID is time-based to make it harder to use it as a covert communications channel. Make it so that this ID can be fetched by the fsinfo() system call. Signed-off-by: David Howells --- fs/fsinfo.c | 1 + fs/super.c | 24 ++++++++++++++++++++++++ include/linux/fs.h | 3 +++ samples/vfs/test-fsinfo.c | 1 + 4 files changed, 29 insertions(+) diff --git a/fs/fsinfo.c b/fs/fsinfo.c index 256a87b62eed..6afeabfe9451 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -92,6 +92,7 @@ static int fsinfo_generic_ids(struct path *path, struct fsinfo_ids *p) 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; memcpy(&p->f_fsid, &buf.f_fsid, sizeof(p->f_fsid)); strlcpy(p->f_fs_name, path->dentry->d_sb->s_type->name, diff --git a/fs/super.c b/fs/super.c index 27b3e41394c8..61819e8e5469 100644 --- a/fs/super.c +++ b/fs/super.c @@ -43,6 +43,8 @@ static int thaw_super_locked(struct super_block *sb); static LIST_HEAD(super_blocks); static DEFINE_SPINLOCK(sb_lock); +static u64 sb_last_identifier; +static u64 sb_identifier_offset; static char *sb_writers_name[SB_FREEZE_LEVELS] = { "sb_writers", @@ -187,6 +189,27 @@ static void destroy_unused_super(struct super_block *s) destroy_super_work(&s->destroy_work); } +/* + * Generate a unique identifier for a superblock. + */ +static void generate_super_id(struct super_block *s) +{ + u64 id = ktime_to_ns(ktime_get()); + + spin_lock(&sb_lock); + + id += sb_identifier_offset; + if (id <= sb_last_identifier) { + id = sb_last_identifier + 1; + sb_identifier_offset = sb_last_identifier - id; + } + + sb_last_identifier = id; + spin_unlock(&sb_lock); + + s->s_unique_id = id; +} + /** * alloc_super - create new superblock * @type: filesystem type superblock should belong to @@ -270,6 +293,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; + generate_super_id(s); return s; fail: diff --git a/include/linux/fs.h b/include/linux/fs.h index 71ce3b054c42..f1c74596cd77 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -1527,6 +1527,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 diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index e98384e8fb46..90926024e1c5 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -179,6 +179,7 @@ static void dump_attr_IDS(union reply *r, int size) 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_attr_LIMITS(union reply *r, int size) From patchwork Tue May 28 15:12:00 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965171 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 0AAF276 for ; Tue, 28 May 2019 15:12:09 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id EDB39287C9 for ; Tue, 28 May 2019 15:12:08 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id E2021288D8; Tue, 28 May 2019 15:12:08 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 2C980287C9 for ; Tue, 28 May 2019 15:12:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727657AbfE1PME (ORCPT ); Tue, 28 May 2019 11:12:04 -0400 Received: from mx1.redhat.com ([209.132.183.28]:46620 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727649AbfE1PMD (ORCPT ); Tue, 28 May 2019 11:12:03 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 1AA1E772EE; Tue, 28 May 2019 15:12:03 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 8BDCC5D9CC; Tue, 28 May 2019 15:12:01 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 07/25] vfs: Allow fsinfo() to look up a mount object by ID [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:00 +0100 Message-ID: <155905632078.1662.16360760230951885679.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.26]); Tue, 28 May 2019 15:12:03 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Allow the fsinfo() syscall to look up a mount object by ID rather than by pathname. This is necessary as there can be multiple mounts stacked up at the same pathname and there's no way to look through them otherwise. This is done by passing AT_FSINFO_MOUNTID_PATH to fsinfo() in the parameters and then passing the mount ID as a string to fsinfo() in place of the filename: struct fsinfo_params params = { .at_flags = AT_FSINFO_MOUNTID_PATH, .request = FSINFO_ATTR_IDS, }; ret = fsinfo(AT_FDCWD, "21", ¶ms, buffer, sizeof(buffer)); The caller is only permitted to query a mount object if the root directory of that mount connects directly to the current chroot if dfd == AT_FDCWD[*] or the directory specified by dfd otherwise. Note that this is not available to the pathwalk of any other syscall. [*] This needs to be something other than AT_FDCWD, perhaps AT_FDROOT. [!] This probably needs an LSM hook. [!] This might want to check the permissions on all the intervening dirs - but it would have to do that under RCU conditions. [!] This might want to check a CAP_* flag. Signed-off-by: David Howells --- fs/fsinfo.c | 55 ++++++++++++++++++++- fs/internal.h | 2 + fs/namespace.c | 117 +++++++++++++++++++++++++++++++++++++++++++- include/uapi/linux/fcntl.h | 2 + 4 files changed, 172 insertions(+), 4 deletions(-) diff --git a/fs/fsinfo.c b/fs/fsinfo.c index 6afeabfe9451..84fdcd35bb5e 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -483,6 +483,57 @@ static int vfs_fsinfo_fd(unsigned int fd, struct fsinfo_kparams *params) return ret; } +/* + * Look up the root of a mount object. This allows access to mount objects + * (and their attached superblocks) that can't be retrieved by path because + * they're entirely covered. + * + * We only permit access to a mount that has a direct path between either the + * dentry pointed to by dfd or to our chroot (if dfd is AT_FDCWD). + */ +static int vfs_fsinfo_mount(int dfd, const char __user *filename, + struct fsinfo_kparams *params) +{ + struct path path; + struct fd f = {}; + char *name; + long mnt_id; + int ret; + + if ((params->at_flags & ~AT_FSINFO_MOUNTID_PATH) || + !filename) + return -EINVAL; + + name = strndup_user(filename, 32); + if (IS_ERR(name)) + return PTR_ERR(name); + ret = kstrtoul(name, 0, &mnt_id); + if (ret < 0) + goto out_name; + if (mnt_id > INT_MAX) + goto out_name; + + if (dfd != AT_FDCWD) { + ret = -EBADF; + f = fdget_raw(dfd); + if (!f.file) + goto out_name; + } + + ret = lookup_mount_object(f.file ? &f.file->f_path : NULL, + mnt_id, &path); + if (ret < 0) + goto out_fd; + + ret = vfs_fsinfo(&path, params); + path_put(&path); +out_fd: + fdput(f); +out_name: + kfree(name); + return ret; +} + /* * Return buffer information by requestable attribute. * @@ -648,7 +699,9 @@ SYSCALL_DEFINE5(fsinfo, if (!params.buffer) goto error_scratch; - if (filename) + if (params.at_flags & AT_FSINFO_MOUNTID_PATH) + ret = vfs_fsinfo_mount(dfd, filename, ¶ms); + else if (filename) ret = vfs_fsinfo_path(dfd, filename, ¶ms); else ret = vfs_fsinfo_fd(dfd, ¶ms); diff --git a/fs/internal.h b/fs/internal.h index b089a489da1f..074b1c65e3bd 100644 --- a/fs/internal.h +++ b/fs/internal.h @@ -97,6 +97,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 lookup_mount_object(struct path *, int, struct path *); + /* * fs_struct.c */ diff --git a/fs/namespace.c b/fs/namespace.c index 1141641dff96..a49a7d9ed482 100644 --- a/fs/namespace.c +++ b/fs/namespace.c @@ -62,7 +62,7 @@ static int __init set_mphash_entries(char *str) __setup("mphash_entries=", set_mphash_entries); static u64 event; -static DEFINE_IDA(mnt_id_ida); +static DEFINE_IDR(mnt_id_ida); static DEFINE_IDA(mnt_group_ida); static struct hlist_head *mount_hashtable __read_mostly; @@ -101,17 +101,27 @@ static inline struct hlist_head *mp_hash(struct dentry *dentry) static int mnt_alloc_id(struct mount *mnt) { - int res = ida_alloc(&mnt_id_ida, GFP_KERNEL); + int res; + /* Allocate an ID, but don't set the pointer back to the mount until + * later, as once we do that, we have to follow RCU protocols to get + * rid of the mount struct. + */ + res = idr_alloc(&mnt_id_ida, NULL, 0, INT_MAX, GFP_KERNEL); if (res < 0) return res; mnt->mnt_id = res; return 0; } +static void mnt_publish_id(struct mount *mnt) +{ + idr_replace(&mnt_id_ida, mnt, mnt->mnt_id); +} + static void mnt_free_id(struct mount *mnt) { - ida_free(&mnt_id_ida, mnt->mnt_id); + idr_remove(&mnt_id_ida, mnt->mnt_id); } /* @@ -974,6 +984,7 @@ struct vfsmount *vfs_create_mount(struct fs_context *fc) lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &mnt->mnt.mnt_sb->s_mounts); unlock_mount_hash(); + mnt_publish_id(mnt); return &mnt->mnt; } EXPORT_SYMBOL(vfs_create_mount); @@ -1067,6 +1078,7 @@ static struct mount *clone_mnt(struct mount *old, struct dentry *root, lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &sb->s_mounts); unlock_mount_hash(); + mnt_publish_id(mnt); if ((flag & CL_SLAVE) || ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) { @@ -3988,3 +4000,102 @@ const struct proc_ns_operations mntns_operations = { .install = mntns_install, .owner = mntns_owner, }; + +/* + * See if one path point connects directly to another by ancestral relationship + * across mountpoints. Must call with the RCU read lock held. + */ +static bool are_paths_connected(struct path *ancestor, struct path *to_check) +{ + struct mount *mnt, *parent; + struct path cursor; + unsigned seq; + bool connected; + + seq = 0; +restart: + cursor = *to_check; + + read_seqbegin_or_lock(&rename_lock, &seq); + while (cursor.mnt != ancestor->mnt) { + mnt = real_mount(cursor.mnt); + parent = READ_ONCE(mnt->mnt_parent); + if (mnt == parent) + goto failed; + cursor.dentry = READ_ONCE(mnt->mnt_mountpoint); + cursor.mnt = &parent->mnt; + } + + while (cursor.dentry != ancestor->dentry) { + if (cursor.dentry == cursor.mnt->mnt_root || + IS_ROOT(cursor.dentry)) + goto failed; + cursor.dentry = READ_ONCE(cursor.dentry->d_parent); + } + + connected = true; +out: + done_seqretry(&rename_lock, seq); + return connected; + +failed: + if (need_seqretry(&rename_lock, seq)) { + seq = 1; + goto restart; + } + connected = false; + goto out; +} + +/** + * lookup_mount_object - Look up a vfsmount object by ID + * @root: The mount root must connect backwards to this point (or chroot if NULL). + * @id: The ID of the mountpoint. + * @_mntpt: Where to return the resulting mountpoint path. + * + * Look up the root of the mount with the corresponding ID. This is only + * permitted if that mount connects directly to the specified root/chroot. + */ +int lookup_mount_object(struct path *root, int mnt_id, struct path *_mntpt) +{ + struct mount *mnt; + struct path stop, mntpt = {}; + int ret = -EPERM; + + if (!root) + get_fs_root(current->fs, &stop); + else + stop = *root; + + rcu_read_lock(); + lock_mount_hash(); + mnt = idr_find(&mnt_id_ida, mnt_id); + if (!mnt) + goto out_unlock_mh; + if (mnt->mnt.mnt_flags & (MNT_SYNC_UMOUNT | MNT_UMOUNT | MNT_DOOMED)) + goto out_unlock_mh; + if (mnt_get_count(mnt) == 0) + goto out_unlock_mh; + mnt_add_count(mnt, 1); + mntpt.mnt = &mnt->mnt; + mntpt.dentry = dget(mnt->mnt.mnt_root); + unlock_mount_hash(); + + if (are_paths_connected(&stop, &mntpt)) { + *_mntpt = mntpt; + mntpt.mnt = NULL; + mntpt.dentry = NULL; + ret = 0; + } + +out_unlock: + rcu_read_unlock(); + if (!root) + path_put(&stop); + path_put(&mntpt); + return ret; + +out_unlock_mh: + unlock_mount_hash(); + goto out_unlock; +} diff --git a/include/uapi/linux/fcntl.h b/include/uapi/linux/fcntl.h index 1d338357df8a..d5828846bea6 100644 --- a/include/uapi/linux/fcntl.h +++ b/include/uapi/linux/fcntl.h @@ -91,6 +91,8 @@ #define AT_STATX_FORCE_SYNC 0x2000 /* - Force the attributes to be sync'd with the server */ #define AT_STATX_DONT_SYNC 0x4000 /* - Don't sync attributes with the server */ +#define AT_FSINFO_MOUNTID_PATH 0x2000 /* The path is a mount object ID, not an actual path */ + #define AT_RECURSIVE 0x8000 /* Apply to the entire subtree */ From patchwork Tue May 28 15:12:08 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965173 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8B88976 for ; Tue, 28 May 2019 15:12:16 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7B3142852C for ; Tue, 28 May 2019 15:12:16 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 6F408285F7; Tue, 28 May 2019 15:12:16 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 018AB285E0 for ; Tue, 28 May 2019 15:12:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727677AbfE1PML (ORCPT ); Tue, 28 May 2019 11:12:11 -0400 Received: from mx1.redhat.com ([209.132.183.28]:35616 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727013AbfE1PML (ORCPT ); Tue, 28 May 2019 11:12:11 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 8D1AADC8FB; Tue, 28 May 2019 15:12:10 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 102258C085; Tue, 28 May 2019 15:12:08 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 08/25] vfs: Add mount notification count [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:08 +0100 Message-ID: <155905632829.1662.713450430534562121.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.38]); Tue, 28 May 2019 15:12:10 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add a notification count on mount objects so that the user can easily check to see if a mount has changed its attributes or its children. Future patches will: (1) Provide this value through fsinfo() attributes. (2) Hook into the notify_mount() function to provide a notification interface for userspace to monitor. Signed-off-by: David Howells --- fs/mount.h | 22 ++++++++++++++++++++++ fs/namespace.c | 13 +++++++++++++ 2 files changed, 35 insertions(+) diff --git a/fs/mount.h b/fs/mount.h index 6250de544760..47795802f78e 100644 --- a/fs/mount.h +++ b/fs/mount.h @@ -70,6 +70,7 @@ struct mount { struct hlist_head mnt_pins; struct fs_pin mnt_umount; struct dentry *mnt_ex_mountpoint; + atomic_t mnt_notify_counter; /* Number of notifications generated */ } __randomize_layout; #define MNT_NS_INTERNAL ERR_PTR(-EINVAL) /* distinct from any mnt_namespace */ @@ -151,3 +152,24 @@ static inline bool is_anon_ns(struct mnt_namespace *ns) { return ns->seq == 0; } + +/* + * Type of mount topology change notification. + */ +enum mount_notification_subtype { + NOTIFY_MOUNT_NEW_MOUNT = 0, /* New mount added */ + NOTIFY_MOUNT_UNMOUNT = 1, /* Mount removed manually */ + NOTIFY_MOUNT_EXPIRY = 2, /* Automount expired */ + NOTIFY_MOUNT_READONLY = 3, /* Mount R/O state changed */ + NOTIFY_MOUNT_SETATTR = 4, /* Mount attributes changed */ + NOTIFY_MOUNT_MOVE_FROM = 5, /* Mount moved from here */ + NOTIFY_MOUNT_MOVE_TO = 6, /* Mount moved to here (compare op_id) */ +}; + +static inline void notify_mount(struct mount *changed, + struct mount *aux, + enum mount_notification_subtype subtype, + u32 info_flags) +{ + atomic_inc(&changed->mnt_notify_counter); +} diff --git a/fs/namespace.c b/fs/namespace.c index a49a7d9ed482..1450faab96b9 100644 --- a/fs/namespace.c +++ b/fs/namespace.c @@ -513,6 +513,8 @@ static int mnt_make_readonly(struct mount *mnt) smp_wmb(); mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; unlock_mount_hash(); + if (ret == 0) + notify_mount(mnt, NULL, NOTIFY_MOUNT_READONLY, 0x10000); return ret; } @@ -521,6 +523,7 @@ static int __mnt_unmake_readonly(struct mount *mnt) lock_mount_hash(); mnt->mnt.mnt_flags &= ~MNT_READONLY; unlock_mount_hash(); + notify_mount(mnt, NULL, NOTIFY_MOUNT_READONLY, 0); return 0; } @@ -833,6 +836,7 @@ static void umount_mnt(struct mount *mnt) { /* old mountpoint will be dropped when we can do that */ mnt->mnt_ex_mountpoint = mnt->mnt_mountpoint; + notify_mount(mnt->mnt_parent, mnt, NOTIFY_MOUNT_UNMOUNT, 0); unhash_mnt(mnt); } @@ -1472,6 +1476,7 @@ static void umount_tree(struct mount *mnt, enum umount_tree_flags how) p = list_first_entry(&tmp_list, struct mount, mnt_list); list_del_init(&p->mnt_expire); list_del_init(&p->mnt_list); + ns = p->mnt_ns; if (ns) { ns->mounts--; @@ -2095,7 +2100,10 @@ static int attach_recursive_mnt(struct mount *source_mnt, lock_mount_hash(); } if (parent_path) { + notify_mount(source_mnt->mnt_parent, source_mnt, + NOTIFY_MOUNT_MOVE_FROM, 0); detach_mnt(source_mnt, parent_path); + notify_mount(dest_mnt, source_mnt, NOTIFY_MOUNT_MOVE_TO, 0); attach_mnt(source_mnt, dest_mnt, dest_mp); touch_mnt_namespace(source_mnt->mnt_ns); } else { @@ -2104,6 +2112,9 @@ static int attach_recursive_mnt(struct mount *source_mnt, list_del_init(&source_mnt->mnt_ns->list); } mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt); + notify_mount(dest_mnt, source_mnt, NOTIFY_MOUNT_NEW_MOUNT, + source_mnt->mnt.mnt_sb->s_flags & SB_SUBMOUNT ? + 0x10000 : 0); commit_tree(source_mnt); } @@ -2480,6 +2491,7 @@ static void set_mount_attributes(struct mount *mnt, unsigned int mnt_flags) mnt->mnt.mnt_flags = mnt_flags; touch_mnt_namespace(mnt->mnt_ns); unlock_mount_hash(); + notify_mount(mnt, NULL, NOTIFY_MOUNT_SETATTR, 0); } /* @@ -2880,6 +2892,7 @@ void mark_mounts_for_expiry(struct list_head *mounts) if (!xchg(&mnt->mnt_expiry_mark, 1) || propagate_mount_busy(mnt, 1)) continue; + notify_mount(mnt, NULL, NOTIFY_MOUNT_EXPIRY, 0); list_move(&mnt->mnt_expire, &graveyard); } while (!list_empty(&graveyard)) { From patchwork Tue May 28 15:12:15 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965175 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 4B39076 for ; Tue, 28 May 2019 15:12:26 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 394B827FB1 for ; Tue, 28 May 2019 15:12:26 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 2D99228775; Tue, 28 May 2019 15:12:26 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 0DF0A27FB1 for ; Tue, 28 May 2019 15:12:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727710AbfE1PMU (ORCPT ); Tue, 28 May 2019 11:12:20 -0400 Received: from mx1.redhat.com ([209.132.183.28]:47434 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727013AbfE1PMU (ORCPT ); Tue, 28 May 2019 11:12:20 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id E5A1081114; Tue, 28 May 2019 15:12:19 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 98ED45D9CC; Tue, 28 May 2019 15:12:16 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 09/25] vfs: Allow mount information to be queried by fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:15 +0100 Message-ID: <155905633578.1662.8087594848892366318.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Tue, 28 May 2019 15:12:20 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Allow mount information, including information about the topology tree to be queried with the fsinfo() system call. Usage of AT_FSINFO_MOUNTID_PATH allows overlapping mounts to be queried. To this end, four fsinfo() attributes are provided: (1) FSINFO_ATTR_MOUNT_INFO. This is a structure providing information about a mount, including: - Mounted superblock ID. - Mount ID (as AT_FSINFO_MOUNTID_PATH). - Parent mount ID. - Mount attributes (eg. R/O, NOEXEC). - Number of change notifications generated. 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_DEVNAME. This a string providing the device name associated with the mount. Note that the device name may be a path that lies outside of the root. (3) 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 notification counter of the respective mount object. (4) FSINFO_ATTR_MOUNT_SUBMOUNT. This is a 1D array of strings, indexed with struct fsinfo_params::Nth. Each string is the relative pathname of the corresponding child returned by FSINFO_ATTR_MOUNT_CHILD. Note that paths in the mount at the base of the tree (whether that be dfd or chroot) are relative to the base of the tree, not the root directory of that mount. Signed-off-by: David Howells --- fs/d_path.c | 2 fs/fsinfo.c | 9 ++ fs/internal.h | 9 ++ fs/namespace.c | 175 +++++++++++++++++++++++++++++++++++++++++++ include/uapi/linux/fsinfo.h | 28 +++++++ samples/vfs/test-fsinfo.c | 47 +++++++++++- 6 files changed, 266 insertions(+), 4 deletions(-) diff --git a/fs/d_path.c b/fs/d_path.c index a7d0a96b35ce..89d77c264c5f 100644 --- a/fs/d_path.c +++ b/fs/d_path.c @@ -227,7 +227,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 84fdcd35bb5e..b9f8712907dc 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -312,6 +312,7 @@ int generic_fsinfo(struct path *path, struct fsinfo_kparams *params) #define _gen(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(path, params->buffer) #define _genf(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(f, params) +#define _genp(X, Y) FSINFO_ATTR_##X: return fsinfo_generic_##Y(path, params) switch (params->request) { case _gen(STATFS, statfs); @@ -326,6 +327,10 @@ int generic_fsinfo(struct path *path, struct fsinfo_kparams *params) case _genf(PARAM_DESCRIPTION, param_description); case _genf(PARAM_SPECIFICATION, param_specification); case _genf(PARAM_ENUM, param_enum); + case _genp(MOUNT_INFO, mount_info); + case _genp(MOUNT_DEVNAME, mount_devname); + case _genp(MOUNT_CHILDREN, mount_children); + case _genp(MOUNT_SUBMOUNT, mount_submount); default: return -EOPNOTSUPP; } @@ -594,6 +599,10 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT_N (PARAM_ENUM, param_enum), FSINFO_OPAQUE (PARAMETERS, -), FSINFO_OPAQUE (LSM_PARAMETERS, -), + FSINFO_STRUCT (MOUNT_INFO, mount_info), + FSINFO_STRING (MOUNT_DEVNAME, mount_devname), + FSINFO_STRUCT_ARRAY (MOUNT_CHILDREN, mount_child), + FSINFO_STRING_N (MOUNT_SUBMOUNT, mount_submount), }; /** diff --git a/fs/internal.h b/fs/internal.h index 074b1c65e3bd..bb3d8efa7f49 100644 --- a/fs/internal.h +++ b/fs/internal.h @@ -53,6 +53,11 @@ void __generic_write_end(struct inode *inode, loff_t pos, unsigned copied, */ 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 */ @@ -98,6 +103,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_info(struct path *, struct fsinfo_kparams *); +extern int fsinfo_generic_mount_devname(struct path *, struct fsinfo_kparams *); +extern int fsinfo_generic_mount_children(struct path *, struct fsinfo_kparams *); +extern int fsinfo_generic_mount_submount(struct path *, struct fsinfo_kparams *); /* * fs_struct.c diff --git a/fs/namespace.c b/fs/namespace.c index 1450faab96b9..ae03066b2d9b 100644 --- a/fs/namespace.c +++ b/fs/namespace.c @@ -29,6 +29,7 @@ #include #include #include +#include #include "pnode.h" #include "internal.h" @@ -4112,3 +4113,177 @@ int lookup_mount_object(struct path *root, int mnt_id, struct path *_mntpt) unlock_mount_hash(); goto out_unlock; } + +#ifdef CONFIG_FSINFO +int fsinfo_generic_mount_info(struct path *path, struct fsinfo_kparams *params) +{ + struct fsinfo_mount_info *p = params->buffer; + struct super_block *sb; + struct mount *m; + struct path root; + unsigned int flags; + + if (!path->mnt) + return -ENODATA; + + m = real_mount(path->mnt); + sb = m->mnt.mnt_sb; + + p->f_sb_id = sb->s_unique_id; + p->mnt_id = m->mnt_id; + p->parent_id = m->mnt_parent->mnt_id; + p->notify_counter = atomic_read(&m->mnt_notify_counter); + + 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); + p->master_id = master; + if (dom && dom != master) + p->from_id = dom; + } + path_put(&root); + + flags = READ_ONCE(m->mnt.mnt_flags); + if (flags & MNT_READONLY) + p->attr |= MOUNT_ATTR_RDONLY; + if (flags & MNT_NOSUID) + p->attr |= MOUNT_ATTR_NOSUID; + if (flags & MNT_NODEV) + p->attr |= MOUNT_ATTR_NODEV; + if (flags & MNT_NOEXEC) + p->attr |= MOUNT_ATTR_NOEXEC; + if (flags & MNT_NODIRATIME) + p->attr |= MOUNT_ATTR_NODIRATIME; + + if (flags & MNT_NOATIME) + p->attr |= MOUNT_ATTR_NOATIME; + else if (flags & MNT_RELATIME) + p->attr |= MOUNT_ATTR_RELATIME; + else + p->attr |= MOUNT_ATTR_STRICTATIME; + return sizeof(*p); +} + +int fsinfo_generic_mount_devname(struct path *path, struct fsinfo_kparams *params) +{ + struct mount *m; + size_t len; + + if (!path->mnt) + return -ENODATA; + + m = real_mount(path->mnt); + len = strlen(m->mnt_devname); + memcpy(params->buffer, m->mnt_devname, len); + return len; +} + +/* + * Store a mount record into the fsinfo buffer. + */ +static void store_mount_fsinfo(struct fsinfo_kparams *params, + struct fsinfo_mount_child *child) +{ + unsigned int usage = params->usage; + unsigned int total = sizeof(*child); + + if (params->usage >= INT_MAX) + return; + params->usage = usage + total; + if (params->buffer && params->usage <= params->buf_size) + memcpy(params->buffer + usage, child, total); +} + +/* + * Return information about the submounts relative to path. + */ +int fsinfo_generic_mount_children(struct path *path, struct fsinfo_kparams *params) +{ + struct fsinfo_mount_child record; + struct mount *m, *child; + + if (!path->mnt) + return -ENODATA; + + rcu_read_lock(); + + m = real_mount(path->mnt); + list_for_each_entry_rcu(child, &m->mnt_mounts, mnt_child) { + if (child->mnt_parent != m) + continue; + record.mnt_id = child->mnt_id; + record.notify_counter = atomic_read(&child->mnt_notify_counter); + store_mount_fsinfo(params, &record); + } + + record.mnt_id = m->mnt_id; + record.notify_counter = atomic_read(&m->mnt_notify_counter); + store_mount_fsinfo(params, &record); + + rcu_read_unlock(); + return params->usage; +} + +/* + * Return the path of the Nth submount relative to path. This is derived from + * d_path(), but the root determination is more complicated. + */ +int fsinfo_generic_mount_submount(struct path *path, struct fsinfo_kparams *params) +{ + struct mountpoint *mp; + struct mount *m, *child; + struct path mountpoint, root; + unsigned int n = params->Nth; + size_t len; + void *p; + + if (!path->mnt) + return -ENODATA; + + rcu_read_lock(); + + m = real_mount(path->mnt); + list_for_each_entry_rcu(child, &m->mnt_mounts, mnt_child) { + mp = READ_ONCE(child->mnt_mp); + if (child->mnt_parent != m || !mp) + continue; + if (n-- == 0) + goto found; + } + rcu_read_unlock(); + return -ENODATA; + +found: + mountpoint.mnt = path->mnt; + mountpoint.dentry = READ_ONCE(mp->m_dentry); + + get_fs_root_rcu(current->fs, &root); + if (root.mnt != path->mnt) { + root.mnt = path->mnt; + root.dentry = path->mnt->mnt_root; + } + + p = __d_path(&mountpoint, &root, params->buffer, params->buf_size); + rcu_read_unlock(); + + if (IS_ERR(p)) + return PTR_ERR(p); + if (!p) + return -EPERM; + + len = (params->buffer + params->buf_size) - p; + memmove(params->buffer, p, len); + return len; +} +#endif /* CONFIG_FSINFO */ diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h index dae2e8dd757e..7f7a75e9758a 100644 --- a/include/uapi/linux/fsinfo.h +++ b/include/uapi/linux/fsinfo.h @@ -32,6 +32,10 @@ enum fsinfo_attribute { FSINFO_ATTR_PARAM_ENUM = 14, /* Nth enum-to-val */ FSINFO_ATTR_PARAMETERS = 15, /* Mount parameters (large string) */ FSINFO_ATTR_LSM_PARAMETERS = 16, /* LSM Mount parameters (large string) */ + FSINFO_ATTR_MOUNT_INFO = 17, /* Mount object information */ + FSINFO_ATTR_MOUNT_DEVNAME = 18, /* Mount object device name (string) */ + FSINFO_ATTR_MOUNT_CHILDREN = 19, /* Submount list (array) */ + FSINFO_ATTR_MOUNT_SUBMOUNT = 20, /* Relative path of Nth submount (string) */ FSINFO_ATTR__NR }; @@ -268,4 +272,28 @@ struct fsinfo_param_enum { char name[252]; /* Name of the enum value */ }; +/* + * Information struct for fsinfo(FSINFO_ATTR_MOUNT_INFO). + */ +struct fsinfo_mount_info { + __u64 f_sb_id; /* Superblock ID */ + __u32 mnt_id; /* Mount identifier (use with AT_FSINFO_MOUNTID_PATH) */ + __u32 parent_id; /* Parent mount identifier */ + __u32 group_id; /* Mount group ID */ + __u32 master_id; /* Slave master group ID */ + __u32 from_id; /* Slave propogated from ID */ + __u32 attr; /* MOUNT_ATTR_* flags */ + __u32 notify_counter; /* Number of notifications generated. */ + __u32 __reserved[1]; +}; + +/* + * Information struct element for fsinfo(FSINFO_ATTR_MOUNT_CHILDREN). + * - An extra element is placed on the end representing the parent mount. + */ +struct fsinfo_mount_child { + __u32 mnt_id; /* Mount identifier (use with AT_FSINFO_MOUNTID_PATH) */ + __u32 notify_counter; /* Number of notifications generated on mount. */ +}; + #endif /* _UAPI_LINUX_FSINFO_H */ diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index 90926024e1c5..a838adcdca9e 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -21,10 +21,10 @@ #include #include #include -#include #include #include #include +#include #include #include @@ -83,6 +83,10 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRUCT_N (PARAM_ENUM, param_enum), FSINFO_OVERLARGE (PARAMETERS, -), FSINFO_OVERLARGE (LSM_PARAMETERS, -), + FSINFO_STRUCT (MOUNT_INFO, mount_info), + FSINFO_STRING (MOUNT_DEVNAME, mount_devname), + FSINFO_STRUCT_ARRAY (MOUNT_CHILDREN, mount_child), + FSINFO_STRING_N (MOUNT_SUBMOUNT, mount_submount), }; #define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y @@ -104,6 +108,10 @@ static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { FSINFO_NAME (PARAM_ENUM, param_enum), FSINFO_NAME (PARAMETERS, parameters), FSINFO_NAME (LSM_PARAMETERS, lsm_parameters), + FSINFO_NAME (MOUNT_INFO, mount_info), + FSINFO_NAME (MOUNT_DEVNAME, mount_devname), + FSINFO_NAME (MOUNT_CHILDREN, mount_children), + FSINFO_NAME (MOUNT_SUBMOUNT, mount_submount), }; union reply { @@ -116,6 +124,8 @@ union reply { struct fsinfo_capabilities caps; struct fsinfo_timestamp_info timestamps; struct fsinfo_volume_uuid uuid; + struct fsinfo_mount_info mount_info; + struct fsinfo_mount_child mount_children[1]; }; static void dump_hex(unsigned int *data, int from, int to) @@ -312,6 +322,29 @@ static void dump_attr_VOLUME_UUID(union reply *r, int size) f->uuid[14], f->uuid[15]); } +static void dump_attr_MOUNT_INFO(union reply *r, int size) +{ + struct fsinfo_mount_info *f = &r->mount_info; + + printf("\n"); + printf("\tsb_id : %llx\n", (unsigned long long)f->f_sb_id); + printf("\tmnt_id : %x\n", f->mnt_id); + printf("\tparent : %x\n", f->parent_id); + printf("\tgroup : %x\n", f->group_id); + printf("\tattr : %x\n", f->attr); + printf("\tnotifs : %x\n", f->notify_counter); +} + +static void dump_attr_MOUNT_CHILDREN(union reply *r, int size) +{ + struct fsinfo_mount_child *f = r->mount_children; + int i = 0; + + printf("\n"); + for (; size >= sizeof(*f); size -= sizeof(*f), f++) + printf("\t[%u] %8x %8x\n", i++, f->mnt_id, f->notify_counter); +} + /* * */ @@ -327,6 +360,8 @@ static const dumper_t fsinfo_attr_dumper[FSINFO_ATTR__NR] = { FSINFO_DUMPER(CAPABILITIES), FSINFO_DUMPER(TIMESTAMP_INFO), FSINFO_DUMPER(VOLUME_UUID), + FSINFO_DUMPER(MOUNT_INFO), + FSINFO_DUMPER(MOUNT_CHILDREN), }; static void dump_fsinfo(enum fsinfo_attribute attr, @@ -529,16 +564,21 @@ int main(int argc, char **argv) unsigned int attr; int raw = 0, opt, Nth, Mth; - while ((opt = getopt(argc, argv, "adlr"))) { + while ((opt = getopt(argc, argv, "Madlr"))) { switch (opt) { + case 'M': + params.at_flags = AT_FSINFO_MOUNTID_PATH; + continue; case 'a': params.at_flags |= AT_NO_AUTOMOUNT; + params.at_flags &= ~AT_FSINFO_MOUNTID_PATH; continue; case 'd': debug = true; continue; case 'l': params.at_flags &= ~AT_SYMLINK_NOFOLLOW; + params.at_flags &= ~AT_FSINFO_MOUNTID_PATH; continue; case 'r': raw = 1; @@ -551,7 +591,8 @@ int main(int argc, char **argv) argv += optind; if (argc != 1) { - printf("Format: test-fsinfo [-alr] \n"); + printf("Format: test-fsinfo [-adlr] \n"); + printf("Format: test-fsinfo [-dr] -M \n"); exit(2); } From patchwork Tue May 28 15:12:25 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965177 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id D355C76 for ; Tue, 28 May 2019 15:12:34 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id BE31228382 for ; Tue, 28 May 2019 15:12:34 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id B23C1285D2; Tue, 28 May 2019 15:12:34 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id A833728382 for ; Tue, 28 May 2019 15:12:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727741AbfE1PM3 (ORCPT ); Tue, 28 May 2019 11:12:29 -0400 Received: from mx1.redhat.com ([209.132.183.28]:52886 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727013AbfE1PM3 (ORCPT ); Tue, 28 May 2019 11:12:29 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 6BF7A3092670; Tue, 28 May 2019 15:12:28 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id E3820173CD; Tue, 28 May 2019 15:12:25 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 10/25] vfs: fsinfo sample: Mount listing program [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:25 +0100 Message-ID: <155905634517.1662.7843563955043166854.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.43]); Tue, 28 May 2019 15:12:28 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Implement a program to demonstrate mount listing using the new fsinfo() syscall, for example: # ./test-mntinfo ROOT 5d c ext4 8:12 \_ sys 13 8 sysfs 0:13 | \_ kernel/security 16 0 securityfs 0:7 | \_ fs/cgroup 1a 10 tmpfs 0:17 | | \_ unified 1b 0 cgroup2 0:18 | | \_ systemd 1c 0 cgroup 0:19 | | \_ freezer 20 0 cgroup 0:1d | | \_ cpu,cpuacct 21 0 cgroup 0:1e | | \_ memory 22 0 cgroup 0:1f | | \_ cpuset 23 0 cgroup 0:20 | | \_ hugetlb 24 0 cgroup 0:21 | | \_ net_cls,net_prio 25 0 cgroup 0:22 | | \_ blkio 26 0 cgroup 0:23 | | \_ perf_event 27 0 cgroup 0:24 | | \_ devices 28 0 cgroup 0:25 | | \_ rdma 29 0 cgroup 0:26 | \_ fs/pstore 1d 0 pstore 0:1a | \_ firmware/efi/efivars 1e 0 efivarfs 0:1b | \_ fs/bpf 1f 0 bpf 0:1c | \_ kernel/config 5a 0 configfs 0:10 | \_ fs/selinux 2a 0 selinuxfs 0:12 | \_ kernel/debug 2e 0 debugfs 0:8 \_ dev 15 4 devtmpfs 0:6 | \_ shm 17 0 tmpfs 0:14 | \_ pts 18 0 devpts 0:15 | \_ hugepages 2b 0 hugetlbfs 0:27 | \_ mqueue 2c 0 mqueue 0:11 \_ run 19 1 tmpfs 0:16 | \_ user/0 1b4 0 tmpfs 0:2d \_ proc 14 1 proc 0:4 | \_ sys/fs/binfmt_misc 2d 0 autofs 0:28 \_ tmp 2f 7d0 tmpfs 0:29 \_ var/cache/fscache 71 0 tmpfs 0:2a \_ boot 74 0 ext4 8:15 \_ home 74 0 ext4 8:15 \_ var/lib/nfs/rpc_pipefs bf 0 rpc_pipefs 0:2b \_ mnt 15b 5 tmpfs 0:2c | \_ foo 164 0 tmpfs 0:2e | \_ foo1 16d 0 tmpfs 0:2f | \_ foo2 176 0 tmpfs 0:30 | \_ foo3 17f 0 tmpfs 0:31 | \_ foo4 188 1 tmpfs 0:32 | \_ "" 191 0 tmpfs 0:33 \_ afs 19a 2 afs 0:34 \_ procyon.org.uk 1a3 0 afs 0:35 \_ grand.central.org 1ac 0 afs 0:36 Signed-off-by: David Howells --- samples/vfs/Makefile | 3 + samples/vfs/test-mntinfo.c | 239 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 242 insertions(+) create mode 100644 samples/vfs/test-mntinfo.c diff --git a/samples/vfs/Makefile b/samples/vfs/Makefile index 3c542d3b9479..d377b1f7de79 100644 --- a/samples/vfs/Makefile +++ b/samples/vfs/Makefile @@ -3,6 +3,7 @@ hostprogs-y := \ test-fsinfo \ test-fs-query \ test-fsmount \ + test-mntinfo \ test-statx # Tell kbuild to always build the programs @@ -10,6 +11,8 @@ always := $(hostprogs-y) HOSTCFLAGS_test-fsinfo.o += -I$(objtree)/usr/include HOSTLDLIBS_test-fsinfo += -lm +HOSTCFLAGS_test-mntinfo.o += -I$(objtree)/usr/include +HOSTLDLIBS_test-mntinfo += -lm HOSTCFLAGS_test-fs-query.o += -I$(objtree)/usr/include HOSTCFLAGS_test-fsmount.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..00fbefae98fa --- /dev/null +++ b/samples/vfs/test-mntinfo.c @@ -0,0 +1,239 @@ +/* Test the fsinfo() system call + * + * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved. + * Written by David Howells (dhowells@redhat.com) + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public Licence + * as published by the Free Software Foundation; either version + * 2 of the Licence, or (at your option) any later version. + */ + +#define _GNU_SOURCE +#define _ATFILE_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __NR_fsinfo +#define __NR_fsinfo -1 +#endif + +static __attribute__((unused)) +ssize_t fsinfo(int dfd, const char *filename, struct fsinfo_params *params, + void *buffer, size_t buf_size) +{ + return syscall(__NR_fsinfo, dfd, filename, params, buffer, buf_size); +} + +static char tree_buf[4096]; +static char bar_buf[4096]; + +/* + * Get an fsinfo attribute in a statically allocated buffer. + */ +static void get_attr(unsigned int mnt_id, enum fsinfo_attribute attr, + void *buf, size_t buf_size) +{ + struct fsinfo_params params = { + .at_flags = AT_FSINFO_MOUNTID_PATH, + .request = attr, + }; + char file[32]; + long ret; + + sprintf(file, "%u", mnt_id); + + memset(buf, 0xbd, buf_size); + + ret = fsinfo(AT_FDCWD, file, ¶ms, 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, enum fsinfo_attribute attr, + unsigned int Nth, size_t *_size) +{ + struct fsinfo_params params = { + .at_flags = AT_FSINFO_MOUNTID_PATH, + .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, r, buf_size); + if (ret == -1) { + fprintf(stderr, "mount-%s: %m\n", file); + 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 *children; + struct fsinfo_mount_info info; + struct fsinfo_ids ids; + unsigned int d; + size_t ch_size, p_size; + int i, n, s; + + get_attr(mnt_id, FSINFO_ATTR_MOUNT_INFO, &info, sizeof(info)); + get_attr(mnt_id, FSINFO_ATTR_IDS, &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 < 40) + s = 40 - s; + else + s = 1; + printf("%*.*s", s, s, ""); + + printf("%8x %8x %s %x:%x", + info.mnt_id, info.notify_counter, + ids.f_fs_name, ids.f_dev_major, ids.f_dev_minor); + putchar('\n'); + + children = get_attr_alloc(mnt_id, FSINFO_ATTR_MOUNT_CHILDREN, 0, &ch_size); + n = ch_size / sizeof(children[0]) - 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; + + for (i = 0; i < n; i++) { + if (i == n - 1) + bar_buf[depth + 1] = ' '; + path = get_attr_alloc(mnt_id, FSINFO_ATTR_MOUNT_SUBMOUNT, i, &p_size); + display_mount(children[i].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 = { + .request = FSINFO_ATTR_MOUNT_INFO, + }; + + if (fsinfo(AT_FDCWD, path, ¶ms, &mnt, sizeof(mnt)) == -1) { + perror(path); + exit(1); + } + + return mnt.mnt_id; +} + +/* + * + */ +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 \n"); + printf("Format: test-mntinfo -M \n"); + exit(2); + } + + display_mount(mnt_id, 0, path); + return 0; +} From patchwork Tue May 28 15:12:33 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965223 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id EB7B076 for ; Tue, 28 May 2019 15:19:56 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id DB42628900 for ; Tue, 28 May 2019 15:19:56 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id CFB7B288F3; Tue, 28 May 2019 15:19:56 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 75395288FD for ; Tue, 28 May 2019 15:19:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727558AbfE1PTw (ORCPT ); Tue, 28 May 2019 11:19:52 -0400 Received: from mx1.redhat.com ([209.132.183.28]:34302 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726698AbfE1PTv (ORCPT ); Tue, 28 May 2019 11:19:51 -0400 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 15D143002513; Tue, 28 May 2019 15:19:51 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 6EC2D78579; Tue, 28 May 2019 15:12:35 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 11/25] hugetlbfs: Add support for fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:33 +0100 Message-ID: <155905635365.1662.16642890243994690650.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.45]); Tue, 28 May 2019 15:19:51 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add support for fsinfo(). Signed-off-by: David Howells --- fs/hugetlbfs/inode.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c index 1dcc57189382..e6ecebd9ebc2 100644 --- a/fs/hugetlbfs/inode.c +++ b/fs/hugetlbfs/inode.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include #include @@ -958,6 +959,58 @@ static int hugetlbfs_show_options(struct seq_file *m, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +static int hugetlbfs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct dentry *dentry = path->dentry; + struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb); + struct hugepage_subpool *spool = sbinfo->spool; + unsigned long hpage_size = huge_page_size(sbinfo->hstate); + unsigned hpage_shift = huge_page_shift(sbinfo->hstate); + char mod; + + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID)) + fsinfo_note_paramf(params, "uid", "%u", + from_kuid_munged(&init_user_ns, + sbinfo->uid)); + + if (!gid_eq(sbinfo->gid, GLOBAL_ROOT_GID)) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, + sbinfo->gid)); + + if (spool && spool->max_hpages != -1) + fsinfo_note_paramf(params, "size", "%llu", + (unsigned long long)spool->max_hpages << hpage_shift); + + if (spool && spool->min_hpages != -1) + fsinfo_note_paramf(params, "min_size", "%llu", + (unsigned long long)spool->min_hpages << hpage_shift); + + hpage_size /= 1024; + mod = 'K'; + if (hpage_size >= 1024) { + hpage_size /= 1024; + mod = 'M'; + } + fsinfo_note_paramf(params, "pagesize", "%lu%c", hpage_size, mod); + + if (sbinfo->mode != 0755) + fsinfo_note_paramf(params, "mode", "%o", sbinfo->mode); + + if (sbinfo->max_inodes != -1) + fsinfo_note_paramf(params, "nr_inodes", "%lu", + sbinfo->max_inodes); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf) { struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb); @@ -1116,6 +1169,9 @@ static const struct super_operations hugetlbfs_ops = { .statfs = hugetlbfs_statfs, .put_super = hugetlbfs_put_super, .show_options = hugetlbfs_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = hugetlbfs_fsinfo, +#endif }; /* From patchwork Tue May 28 15:12:42 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965179 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 39AA76C5 for ; Tue, 28 May 2019 15:12:53 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 279BE2851B for ; Tue, 28 May 2019 15:12:53 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 1C3CD285D2; Tue, 28 May 2019 15:12:53 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7F5472851B for ; Tue, 28 May 2019 15:12:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727326AbfE1PMs (ORCPT ); Tue, 28 May 2019 11:12:48 -0400 Received: from mx1.redhat.com ([209.132.183.28]:48156 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726826AbfE1PMs (ORCPT ); Tue, 28 May 2019 11:12:48 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id CC0B73019882; Tue, 28 May 2019 15:12:47 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 9093D5DDD9; Tue, 28 May 2019 15:12:42 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 12/25] kernfs, cgroup: Add fsinfo support [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:42 +0100 Message-ID: <155905636240.1662.16803705540477209176.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.47]); Tue, 28 May 2019 15:12:47 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add support for fsinfo() to kernfs and cgroup. Signed-off-by: David Howells --- fs/kernfs/mount.c | 20 ++++++++++++++++++++ include/linux/kernfs.h | 4 ++++ kernel/cgroup/cgroup-v1.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ kernel/cgroup/cgroup.c | 19 +++++++++++++++++++ 4 files changed, 87 insertions(+) diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c index 9a4646eecb71..f40d467d274b 100644 --- a/fs/kernfs/mount.c +++ b/fs/kernfs/mount.c @@ -17,6 +17,7 @@ #include #include #include +#include #include "kernfs-internal.h" @@ -45,6 +46,22 @@ static int kernfs_sop_show_path(struct seq_file *sf, struct dentry *dentry) return 0; } +#ifdef CONFIG_FSINFO +static int kernfs_sop_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct kernfs_root *root = kernfs_root(kernfs_dentry_node(path->dentry)); + struct kernfs_syscall_ops *scops = root->syscall_ops; + int ret; + + if (scops && scops->fsinfo) { + ret = scops->fsinfo(root, params); + if (ret != -EAGAIN) + return ret; + } + return generic_fsinfo(path, params); +} +#endif + const struct super_operations kernfs_sops = { .statfs = simple_statfs, .drop_inode = generic_delete_inode, @@ -52,6 +69,9 @@ const struct super_operations kernfs_sops = { .show_options = kernfs_sop_show_options, .show_path = kernfs_sop_show_path, +#ifdef CONFIG_FSINFO + .fsinfo = kernfs_sop_fsinfo, +#endif }; /* diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h index 2bf477f86eb1..d01ec4dc2db1 100644 --- a/include/linux/kernfs.h +++ b/include/linux/kernfs.h @@ -27,6 +27,7 @@ struct super_block; struct file_system_type; struct poll_table_struct; struct fs_context; +struct fsinfo_kparams; struct kernfs_fs_context; struct kernfs_open_node; @@ -171,6 +172,9 @@ struct kernfs_node { */ struct kernfs_syscall_ops { int (*show_options)(struct seq_file *sf, struct kernfs_root *root); +#ifdef CONFIG_FSINFO + int (*fsinfo)(struct kernfs_root *root, struct fsinfo_kparams *params); +#endif int (*mkdir)(struct kernfs_node *parent, const char *name, umode_t mode); diff --git a/kernel/cgroup/cgroup-v1.c b/kernel/cgroup/cgroup-v1.c index 68ca5de7ec27..c8a85dfcac87 100644 --- a/kernel/cgroup/cgroup-v1.c +++ b/kernel/cgroup/cgroup-v1.c @@ -14,6 +14,7 @@ #include #include #include +#include #include @@ -921,6 +922,46 @@ const struct fs_parameter_description cgroup1_fs_parameters = { .specs = cgroup1_param_specs, }; +#ifdef CONFIG_FSINFO +static int cgroup1_fsinfo(struct kernfs_root *kf_root, struct fsinfo_kparams *params) +{ + struct cgroup_root *root = cgroup_root_from_kf(kf_root); + struct cgroup_subsys *ss; + int ssid; + + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + if (root->name[0]) + fsinfo_note_param(params, "name", root->name); + + if (test_bit(CGRP_CPUSET_CLONE_CHILDREN, &root->cgrp.flags)) + fsinfo_note_param(params, "clone_children", NULL); + if (root->flags & CGRP_ROOT_CPUSET_V2_MODE) + fsinfo_note_param(params, "noprefix", NULL); + if (root->flags & CGRP_ROOT_NOPREFIX) + fsinfo_note_param(params, "noprefix", NULL); + if (root->flags & CGRP_ROOT_XATTR) + fsinfo_note_param(params, "xattr", NULL); + + spin_lock(&release_agent_path_lock); + if (root->release_agent_path[0]) + fsinfo_note_param(params, "release_agent", + root->release_agent_path); + spin_unlock(&release_agent_path_lock); + + + for_each_subsys(ss, ssid) { + if (root->subsys_mask & (1 << ssid)) + fsinfo_note_param(params, ss->legacy_name, NULL); + } + return params->usage; + + default: + return -EAGAIN; /* Tell kernfs to call generic_fsinfo() */ + } +} +#endif /* CONFIG_FSINFO */ + int cgroup1_parse_param(struct fs_context *fc, struct fs_parameter *param) { struct cgroup_fs_context *ctx = cgroup_fc2context(fc); @@ -1114,6 +1155,9 @@ int cgroup1_reconfigure(struct fs_context *fc) struct kernfs_syscall_ops cgroup1_kf_syscall_ops = { .rename = cgroup1_rename, .show_options = cgroup1_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = cgroup1_fsinfo, +#endif .mkdir = cgroup_mkdir, .rmdir = cgroup_rmdir, .show_path = cgroup_show_path, diff --git a/kernel/cgroup/cgroup.c b/kernel/cgroup/cgroup.c index 4a0eb465d17e..7e32570905e9 100644 --- a/kernel/cgroup/cgroup.c +++ b/kernel/cgroup/cgroup.c @@ -55,6 +55,7 @@ #include #include #include +#include #include #include #include @@ -1858,6 +1859,21 @@ static int cgroup_show_options(struct seq_file *seq, struct kernfs_root *kf_root return 0; } +#ifdef CONFIG_FSINFO +static int cgroup_fsinfo(struct kernfs_root *kf_root, struct fsinfo_kparams *params) +{ + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + if (cgrp_dfl_root.flags & CGRP_ROOT_NS_DELEGATE) + fsinfo_note_param(params, "nsdelegate", NULL); + return params->usage; + + default: + return -EAGAIN; /* Tell kernfs to call generic_fsinfo() */ + } +} +#endif /* CONFIG_FSINFO */ + static int cgroup_reconfigure(struct fs_context *fc) { struct cgroup_fs_context *ctx = cgroup_fc2context(fc); @@ -5550,6 +5566,9 @@ int cgroup_rmdir(struct kernfs_node *kn) static struct kernfs_syscall_ops cgroup_kf_syscall_ops = { .show_options = cgroup_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = cgroup_fsinfo, +#endif .mkdir = cgroup_mkdir, .rmdir = cgroup_rmdir, .show_path = cgroup_show_path, From patchwork Tue May 28 15:12:53 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965181 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8C14B6C5 for ; Tue, 28 May 2019 15:13:00 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 79658285D2 for ; Tue, 28 May 2019 15:13:00 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 6DEE228775; Tue, 28 May 2019 15:13:00 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id DBBCA285D2 for ; Tue, 28 May 2019 15:12:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727786AbfE1PM4 (ORCPT ); Tue, 28 May 2019 11:12:56 -0400 Received: from mx1.redhat.com ([209.132.183.28]:55666 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726826AbfE1PMz (ORCPT ); Tue, 28 May 2019 11:12:55 -0400 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 4EC423083394; Tue, 28 May 2019 15:12:55 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id C1179AFE55; Tue, 28 May 2019 15:12:53 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 13/25] fsinfo: Support SELinux superblock parameter retrieval [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:12:53 +0100 Message-ID: <155905637302.1662.8473297942541287404.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.44]); Tue, 28 May 2019 15:12:55 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add support to SELinux for retrieval of the superblock parameters by fsinfo(FSINFO_ATTR_LSM_PARAMETERS). Signed-off-by: David Howells --- security/selinux/hooks.c | 41 +++++++++++++++++++++++++++++ security/selinux/include/security.h | 2 + security/selinux/ss/services.c | 49 +++++++++++++++++++++++++++++++++++ 3 files changed, 92 insertions(+) diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c index c61787b15f27..9b5dbdcde9e6 100644 --- a/security/selinux/hooks.c +++ b/security/selinux/hooks.c @@ -91,6 +91,7 @@ #include #include #include /* for hashlen_string() */ +#include #include #include "avc.h" @@ -2735,6 +2736,43 @@ static int selinux_sb_statfs(struct dentry *dentry) return superblock_has_perm(cred, dentry->d_sb, FILESYSTEM__GETATTR, &ad); } +#ifdef CONFIG_FSINFO +/* + * Retrieve the SELinux filesystem information, including mount parameters. + */ +static int selinux_sb_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct superblock_security_struct *sbsec = path->dentry->d_sb->s_security; + + switch (params->request) { + case FSINFO_ATTR_LSM_PARAMETERS: + if (!(sbsec->flags & SE_SBINITIALIZED) || + !selinux_state.initialized) + return params->usage; + + if (sbsec->flags & FSCONTEXT_MNT) + fsinfo_note_sid(params, FSCONTEXT_STR, sbsec->sid); + if (sbsec->flags & CONTEXT_MNT) + fsinfo_note_sid(params, CONTEXT_STR, sbsec->mntpoint_sid); + if (sbsec->flags & DEFCONTEXT_MNT) + fsinfo_note_sid(params, DEFCONTEXT_STR, sbsec->def_sid); + if (sbsec->flags & ROOTCONTEXT_MNT) { + struct dentry *root = sbsec->sb->s_root; + struct inode_security_struct *isec = backing_inode_security(root); + fsinfo_note_sid(params, ROOTCONTEXT_STR, isec->sid); + } + if (sbsec->flags & SBLABEL_MNT) + fsinfo_note_param(params, SECLABEL_STR, NULL); + + return params->usage; + + default: + return -ENODATA; + } + return 0; +} +#endif + static int selinux_mount(const char *dev_name, const struct path *path, const char *type, @@ -6761,6 +6799,9 @@ static struct security_hook_list selinux_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(sb_kern_mount, selinux_sb_kern_mount), LSM_HOOK_INIT(sb_show_options, selinux_sb_show_options), LSM_HOOK_INIT(sb_statfs, selinux_sb_statfs), +#ifdef CONFIG_FSINFO + LSM_HOOK_INIT(sb_fsinfo, selinux_sb_fsinfo), +#endif LSM_HOOK_INIT(sb_mount, selinux_mount), LSM_HOOK_INIT(sb_umount, selinux_umount), LSM_HOOK_INIT(sb_set_mnt_opts, selinux_set_mnt_opts), diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h index 111121281c47..e9617bfcc6ee 100644 --- a/security/selinux/include/security.h +++ b/security/selinux/include/security.h @@ -67,6 +67,7 @@ #define SECLABEL_STR "seclabel" struct netlbl_lsm_secattr; +struct fsinfo_kparams; extern int selinux_enabled; @@ -258,6 +259,7 @@ int security_sid_to_context_force(struct selinux_state *state, int security_sid_to_context_inval(struct selinux_state *state, u32 sid, char **scontext, u32 *scontext_len); +void fsinfo_note_sid(struct fsinfo_kparams *params, const char *key, u32 sid); int security_context_to_sid(struct selinux_state *state, const char *scontext, u32 scontext_len, diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c index cc043bc8fd4c..1111b02a999b 100644 --- a/security/selinux/ss/services.c +++ b/security/selinux/ss/services.c @@ -50,6 +50,7 @@ #include #include #include +#include #include #include "flask.h" @@ -1374,6 +1375,54 @@ int security_sid_to_context_inval(struct selinux_state *state, u32 sid, scontext_len, 1, 1); } +#ifdef CONFIG_FSINFO +void fsinfo_note_sid(struct fsinfo_kparams *params, const char *key, u32 sid) +{ + struct selinux_state *state = &selinux_state; + struct policydb *policydb; + struct context *context; + const char *val = "<<>>"; + char *p; + int n; + + if (!state->initialized) { + if (sid <= SECINITSID_NUM) { + val = initial_sid_to_string[sid]; + goto out; + } + + pr_err("SELinux: %s: called before initial " + "load_policy on unknown SID %d\n", __func__, sid); + goto out; + } + + read_lock(&state->ss->policy_rwlock); + + policydb = &state->ss->policydb; + context = sidtab_search(state->ss->sidtab, sid); + if (!context) { + pr_err("SELinux: %s: unrecognized SID %d\n", __func__, sid); + } else { + /* Copy the user name, role name and type name into the scratch + * buffer and then tack on the MLS. + */ + val = p = params->scratch_buffer; + n = sprintf(p, "%s:%s:%s", + sym_name(policydb, SYM_USERS, context->user - 1), + sym_name(policydb, SYM_ROLES, context->role - 1), + sym_name(policydb, SYM_TYPES, context->type - 1)); + + p += n; + mls_sid_to_context(policydb, context, &p); + *p = 0; + } + + read_unlock(&state->ss->policy_rwlock); +out: + fsinfo_note_param(params, key, val); +} +#endif + /* * Caveat: Mutates scontext. */ From patchwork Tue May 28 15:13:00 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965183 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 2E44576 for ; Tue, 28 May 2019 15:13:11 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 1CCA628538 for ; Tue, 28 May 2019 15:13:11 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 11641287C9; Tue, 28 May 2019 15:13:11 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id B037628775 for ; Tue, 28 May 2019 15:13:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727535AbfE1PNG (ORCPT ); Tue, 28 May 2019 11:13:06 -0400 Received: from mx1.redhat.com ([209.132.183.28]:38509 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727267AbfE1PNG (ORCPT ); Tue, 28 May 2019 11:13:06 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 2700E317914E; Tue, 28 May 2019 15:13:06 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 164872C31E; Tue, 28 May 2019 15:13:01 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 14/25] fsinfo: Support Smack superblock parameter retrieval [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:00 +0100 Message-ID: <155905638053.1662.16622749706126627482.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.41]); Tue, 28 May 2019 15:13:06 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add support to Smack for retrieval of the superblock parameters. Signed-off-by: David Howells --- security/smack/smack_lsm.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c index 0de725f88bed..0a1e88d50ad3 100644 --- a/security/smack/smack_lsm.c +++ b/security/smack/smack_lsm.c @@ -45,6 +45,7 @@ #include #include #include +#include #include "smack.h" #define TRANS_TRUE "TRUE" @@ -893,6 +894,45 @@ static int smack_sb_statfs(struct dentry *dentry) return rc; } +#ifdef CONFIG_FSINFO +/* + * Retrieve the Smack filesystem information, including mount parameters. + */ +static int smack_sb_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct superblock_smack *sp = path->dentry->d_sb->s_security; + + switch (params->request) { + case FSINFO_ATTR_LSM_PARAMETERS: { + struct dentry *root = path->dentry->d_sb->s_root; + struct inode *inode = d_backing_inode(root); + struct inode_smack *isp = inode->i_security; + + if (sp->smk_flags & SMK_SB_INITIALIZED) + return 0; + if (sp->smk_floor) + fsinfo_note_param(params, "fsfloor", sp->smk_floor->smk_known); + if (sp->smk_hat) + fsinfo_note_param(params, "fshat", sp->smk_hat->smk_known); + if (sp->smk_default) + fsinfo_note_param(params, "fsdefault", sp->smk_default->smk_known); + + if (sp->smk_root) { + if (isp && isp->smk_flags & SMK_INODE_TRANSMUTE) + fsinfo_note_param(params, "fstransmute", sp->smk_root->smk_known); + else + fsinfo_note_param(params, "fsroot", sp->smk_root->smk_known); + } + return params->usage; + } + + default: + return -ENODATA; + } + return 0; +} +#endif + /* * BPRM hooks */ @@ -4606,6 +4646,9 @@ static struct security_hook_list smack_hooks[] __lsm_ro_after_init = { LSM_HOOK_INIT(sb_free_mnt_opts, smack_free_mnt_opts), LSM_HOOK_INIT(sb_eat_lsm_opts, smack_sb_eat_lsm_opts), LSM_HOOK_INIT(sb_statfs, smack_sb_statfs), +#ifdef CONFIG_FSINFO + LSM_HOOK_INIT(sb_fsinfo, smack_sb_fsinfo), +#endif LSM_HOOK_INIT(sb_set_mnt_opts, smack_set_mnt_opts), LSM_HOOK_INIT(bprm_set_creds, smack_bprm_set_creds), From patchwork Tue May 28 15:13:11 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965185 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id DC9E876 for ; Tue, 28 May 2019 15:13:24 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C98F0287C6 for ; Tue, 28 May 2019 15:13:24 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id BDC44287C5; Tue, 28 May 2019 15:13:24 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id E39EA28560 for ; Tue, 28 May 2019 15:13:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727816AbfE1PNT (ORCPT ); Tue, 28 May 2019 11:13:19 -0400 Received: from mx1.redhat.com ([209.132.183.28]:57224 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726826AbfE1PNT (ORCPT ); Tue, 28 May 2019 11:13:19 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id B6B4330BC100; Tue, 28 May 2019 15:13:18 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id F39252D1B1; Tue, 28 May 2019 15:13:13 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 15/25] afs: Support fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:11 +0100 Message-ID: <155905639137.1662.16805896138242925406.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.45]); Tue, 28 May 2019 15:13:18 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Add fsinfo support to the AFS filesystem. Signed-off-by: David Howells --- fs/afs/internal.h | 1 fs/afs/super.c | 155 ++++++++++++++++++++++++++++++++++++++++++- fs/fsinfo.c | 3 + include/uapi/linux/fsinfo.h | 12 +++ samples/vfs/test-fsinfo.c | 33 +++++++++ 5 files changed, 202 insertions(+), 2 deletions(-) diff --git a/fs/afs/internal.h b/fs/afs/internal.h index 2073c1a3ab4b..da40ea036c6a 100644 --- a/fs/afs/internal.h +++ b/fs/afs/internal.h @@ -254,6 +254,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 f18911e8d770..2b1f37aa1b37 100644 --- a/fs/afs/super.c +++ b/fs/afs/super.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include "internal.h" @@ -35,6 +36,9 @@ static struct inode *afs_alloc_inode(struct super_block *sb); static void afs_destroy_inode(struct inode *inode); static void afs_free_inode(struct inode *inode); static int afs_statfs(struct dentry *dentry, struct kstatfs *buf); +#ifdef CONFIG_FSINFO +static int afs_fsinfo(struct path *path, struct fsinfo_kparams *params); +#endif static int afs_show_devname(struct seq_file *m, struct dentry *root); static int afs_show_options(struct seq_file *m, struct dentry *root); static int afs_init_fs_context(struct fs_context *fc); @@ -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, @@ -199,7 +206,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; @@ -463,7 +470,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; @@ -503,6 +510,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; } @@ -765,3 +774,145 @@ static int afs_statfs(struct dentry *dentry, struct kstatfs *buf) return ret; } + +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int afs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct fsinfo_timestamp_info *tsinfo; + struct fsinfo_server_address *addr; + struct fsinfo_capabilities *caps; + struct fsinfo_supports *sup; + struct dentry *dentry = path->dentry; + struct afs_server_list *slist; + struct afs_super_info *as = AFS_FS_S(dentry->d_sb); + struct afs_addr_list *alist; + struct afs_server *server; + struct afs_volume *volume = as->volume; + struct afs_cell *cell = as->cell; + struct afs_net *net = afs_d2net(dentry); + bool dyn_root = as->dyn_root; + int ret; + + switch (params->request) { + case FSINFO_ATTR_TIMESTAMP_INFO: + tsinfo = params->buffer; + tsinfo->minimum_timestamp = 0; + tsinfo->maximum_timestamp = UINT_MAX; + tsinfo->mtime_gran_mantissa = 1; + tsinfo->mtime_gran_exponent = 0; + return sizeof(*tsinfo); + + case FSINFO_ATTR_SUPPORTS: + sup = params->buffer; + sup->stx_mask = (STATX_TYPE | STATX_MODE | + STATX_NLINK | + STATX_UID | STATX_GID | + STATX_MTIME | STATX_INO | + STATX_SIZE); + sup->stx_attributes = STATX_ATTR_AUTOMOUNT; + return sizeof(*sup); + + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + if (dyn_root) { + fsinfo_set_cap(caps, FSINFO_CAP_IS_AUTOMOUNTER_FS); + fsinfo_set_cap(caps, FSINFO_CAP_AUTOMOUNTS); + } else { + fsinfo_set_cap(caps, FSINFO_CAP_IS_NETWORK_FS); + fsinfo_set_cap(caps, FSINFO_CAP_AUTOMOUNTS); + fsinfo_set_cap(caps, FSINFO_CAP_ADV_LOCKS); + fsinfo_set_cap(caps, FSINFO_CAP_UIDS); + fsinfo_set_cap(caps, FSINFO_CAP_GIDS); + fsinfo_set_cap(caps, FSINFO_CAP_VOLUME_ID); + fsinfo_set_cap(caps, FSINFO_CAP_VOLUME_NAME); + fsinfo_set_cap(caps, FSINFO_CAP_IVER_MONO_INCR); + fsinfo_set_cap(caps, FSINFO_CAP_SYMLINKS); + fsinfo_set_cap(caps, FSINFO_CAP_HARD_LINKS_1DIR); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_MTIME); + } + return sizeof(*caps); + + case FSINFO_ATTR_VOLUME_NAME: + if (dyn_root) + return -EOPNOTSUPP; + memcpy(params->buffer, volume->name, volume->name_len); + return volume->name_len; + + case FSINFO_ATTR_CELL_NAME: + if (dyn_root) + return -EOPNOTSUPP; + memcpy(params->buffer, cell->name, cell->name_len); + return cell->name_len; + + case FSINFO_ATTR_SERVER_NAME: + if (dyn_root) + return -EOPNOTSUPP; + read_lock(&volume->servers_lock); + slist = afs_get_serverlist(volume->servers); + read_unlock(&volume->servers_lock); + + if (params->Nth < slist->nr_servers) { + server = slist->servers[params->Nth].server; + ret = sprintf(params->buffer, "%pU", &server->uuid); + } else { + ret = -ENODATA; + } + + afs_put_serverlist(net, slist); + return ret; + + case FSINFO_ATTR_SERVER_ADDRESS: + addr = params->buffer; + if (dyn_root) + return -EOPNOTSUPP; + read_lock(&volume->servers_lock); + slist = afs_get_serverlist(volume->servers); + read_unlock(&volume->servers_lock); + + ret = -ENODATA; + if (params->Nth >= slist->nr_servers) + goto put_slist; + server = slist->servers[params->Nth].server; + + read_lock(&server->fs_lock); + alist = afs_get_addrlist(rcu_access_pointer(server->addresses)); + read_unlock(&server->fs_lock); + if (!alist) + goto put_slist; + + if (params->Mth >= alist->nr_addrs) + goto put_alist; + + memcpy(addr, &alist->addrs[params->Mth], + sizeof(struct sockaddr_rxrpc)); + ret = sizeof(*addr); + + put_alist: + afs_put_addrlist(alist); + put_slist: + afs_put_serverlist(net, slist); + return ret; + + case FSINFO_ATTR_PARAMETERS: + if (!dyn_root) + fsinfo_note_paramf(params, "source", "%c%s:%s%s", + volume->type == AFSVL_RWVOL ? '%' : '#', + cell->name, + volume->name, + volume->type == AFSVL_RWVOL ? "" : + volume->type == AFSVL_ROVOL ? ".readonly" : + ".backup"); + if (as->autocell) + fsinfo_note_param(params, "autocell", NULL); + if (dyn_root) + fsinfo_note_param(params, "dyn", NULL); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ diff --git a/fs/fsinfo.c b/fs/fsinfo.c index b9f8712907dc..3ec64d3cba08 100644 --- a/fs/fsinfo.c +++ b/fs/fsinfo.c @@ -603,6 +603,9 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRING (MOUNT_DEVNAME, mount_devname), FSINFO_STRUCT_ARRAY (MOUNT_CHILDREN, mount_child), FSINFO_STRING_N (MOUNT_SUBMOUNT, mount_submount), + FSINFO_STRING_N (SERVER_NAME, server_name), + FSINFO_STRUCT_NM (SERVER_ADDRESS, server_address), + FSINFO_STRING (CELL_NAME, cell_name), }; /** diff --git a/include/uapi/linux/fsinfo.h b/include/uapi/linux/fsinfo.h index 7f7a75e9758a..7247088332c2 100644 --- a/include/uapi/linux/fsinfo.h +++ b/include/uapi/linux/fsinfo.h @@ -36,6 +36,9 @@ enum fsinfo_attribute { FSINFO_ATTR_MOUNT_DEVNAME = 18, /* Mount object device name (string) */ FSINFO_ATTR_MOUNT_CHILDREN = 19, /* Submount list (array) */ FSINFO_ATTR_MOUNT_SUBMOUNT = 20, /* Relative path of Nth submount (string) */ + FSINFO_ATTR_SERVER_NAME = 21, /* Name of the Nth server (string) */ + FSINFO_ATTR_SERVER_ADDRESS = 22, /* Mth address of the Nth server */ + FSINFO_ATTR_CELL_NAME = 23, /* Cell name (string) */ FSINFO_ATTR__NR }; @@ -296,4 +299,13 @@ struct fsinfo_mount_child { __u32 notify_counter; /* Number of notifications generated on mount. */ }; +/* + * Information struct for fsinfo(fsinfo_attr_server_addresses). + * + * Find the Mth address of the Nth server for a network mount. + */ +struct fsinfo_server_address { + struct __kernel_sockaddr_storage address; +}; + #endif /* _UAPI_LINUX_FSINFO_H */ diff --git a/samples/vfs/test-fsinfo.c b/samples/vfs/test-fsinfo.c index a838adcdca9e..af29da74559e 100644 --- a/samples/vfs/test-fsinfo.c +++ b/samples/vfs/test-fsinfo.c @@ -87,6 +87,9 @@ static const struct fsinfo_attr_info fsinfo_buffer_info[FSINFO_ATTR__NR] = { FSINFO_STRING (MOUNT_DEVNAME, mount_devname), FSINFO_STRUCT_ARRAY (MOUNT_CHILDREN, mount_child), FSINFO_STRING_N (MOUNT_SUBMOUNT, mount_submount), + FSINFO_STRING_N (SERVER_NAME, server_name), + FSINFO_STRUCT_NM (SERVER_ADDRESS, server_address), + FSINFO_STRING (CELL_NAME, cell_name), }; #define FSINFO_NAME(X,Y) [FSINFO_ATTR_##X] = #Y @@ -112,6 +115,9 @@ static const char *fsinfo_attr_names[FSINFO_ATTR__NR] = { FSINFO_NAME (MOUNT_DEVNAME, mount_devname), FSINFO_NAME (MOUNT_CHILDREN, mount_children), FSINFO_NAME (MOUNT_SUBMOUNT, mount_submount), + FSINFO_NAME (SERVER_NAME, server_name), + FSINFO_NAME (SERVER_ADDRESS, server_address), + FSINFO_NAME (CELL_NAME, cell_name), }; union reply { @@ -126,6 +132,7 @@ union reply { struct fsinfo_volume_uuid uuid; struct fsinfo_mount_info mount_info; struct fsinfo_mount_child mount_children[1]; + struct fsinfo_server_address srv_addr; }; static void dump_hex(unsigned int *data, int from, int to) @@ -322,6 +329,31 @@ static void dump_attr_VOLUME_UUID(union reply *r, int size) f->uuid[14], f->uuid[15]); } +static void dump_attr_SERVER_ADDRESS(union reply *r, int size) +{ + struct fsinfo_server_address *f = &r->srv_addr; + struct sockaddr_in6 *sin6; + struct sockaddr_in *sin; + char buf[1024]; + + switch (f->address.ss_family) { + case AF_INET: + sin = (struct sockaddr_in *)&f->address; + if (!inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf))) + break; + printf("IPv4: %s\n", buf); + return; + case AF_INET6: + sin6 = (struct sockaddr_in6 *)&f->address; + if (!inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf))) + break; + printf("IPv6: %s\n", buf); + return; + } + + printf("family=%u\n", f->address.ss_family); +} + static void dump_attr_MOUNT_INFO(union reply *r, int size) { struct fsinfo_mount_info *f = &r->mount_info; @@ -362,6 +394,7 @@ static const dumper_t fsinfo_attr_dumper[FSINFO_ATTR__NR] = { FSINFO_DUMPER(VOLUME_UUID), FSINFO_DUMPER(MOUNT_INFO), FSINFO_DUMPER(MOUNT_CHILDREN), + FSINFO_DUMPER(SERVER_ADDRESS), }; static void dump_fsinfo(enum fsinfo_attribute attr, From patchwork Tue May 28 15:13:23 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965187 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C3B9A6C5 for ; Tue, 28 May 2019 15:13:31 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id B2F5328560 for ; Tue, 28 May 2019 15:13:31 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id A74C12872E; Tue, 28 May 2019 15:13:31 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id CC19A28538 for ; Tue, 28 May 2019 15:13:30 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727838AbfE1PN0 (ORCPT ); Tue, 28 May 2019 11:13:26 -0400 Received: from mx1.redhat.com ([209.132.183.28]:9254 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726826AbfE1PN0 (ORCPT ); Tue, 28 May 2019 11:13:26 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 379AE30BF4E5; Tue, 28 May 2019 15:13:26 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id B0ECBCA700; Tue, 28 May 2019 15:13:24 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 16/25] nfs: Support fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:23 +0100 Message-ID: <155905640395.1662.11340611657732220291.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.46]); Tue, 28 May 2019 15:13:26 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Allow fsinfo() to retrieve information about a superblock, including the values configured by the parameters passed at superblock creation. Signed-off-by: David Howells --- fs/nfs/fs_context.c | 163 +++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nfs/internal.h | 6 ++ fs/nfs/nfs4super.c | 3 + fs/nfs/super.c | 77 ++++++++++++++++++++++++ 4 files changed, 248 insertions(+), 1 deletion(-) diff --git a/fs/nfs/fs_context.c b/fs/nfs/fs_context.c index d05271b91e38..f550b0e54833 100644 --- a/fs/nfs/fs_context.c +++ b/fs/nfs/fs_context.c @@ -17,6 +17,8 @@ #include #include #include +#include +#include #include #include #include @@ -1407,3 +1409,164 @@ MODULE_ALIAS_FS("nfs4"); MODULE_ALIAS("nfs4"); EXPORT_SYMBOL_GPL(nfs4_fs_type); #endif /* CONFIG_NFS_V4 */ + +#ifdef CONFIG_FSINFO +/* + * Allow the filesystem parameters to be queried. + */ +int nfs_fsinfo_parameters(struct fsinfo_kparams *params, struct path *path, + const struct nfs_server *server) +{ + const struct nfs_client *client = server->nfs_client; + const struct sockaddr *sap = (const struct sockaddr *)&server->mountd_address; + unsigned int version = client->rpc_ops->version; + unsigned int sf = server->flags; + const char *b; + char *e; + int i; + + static const struct proc_nfs_info { + int flag; + const char *str; + const char *nostr; + } nfs_info[] = { + { NFS_MOUNT_SOFT, "soft", "hard" }, + { NFS_MOUNT_POSIX, "posix", "" }, + { NFS_MOUNT_NOCTO, "nocto", "" }, + { NFS_MOUNT_NOAC, "noac", "" }, + { NFS_MOUNT_NONLM, "nolock", "" }, + { NFS_MOUNT_NOACL, "noacl", "" }, + { NFS_MOUNT_NORDIRPLUS, "nordirplus", "" }, + { NFS_MOUNT_UNSHARED, "nosharecache", "" }, + { NFS_MOUNT_NORESVPORT, "noresvport", "" }, + }; + + rcu_read_lock(); + + b = params->scratch_buffer; + b = nfs_path(&e, path->mnt->mnt_root, params->scratch_buffer, params->buf_size, 0); + if (b < e) + fsinfo_note_param(params, "source", b); + + if (version == 4) + fsinfo_note_paramf(params, "vers", "4.%u", client->cl_minorversion); + else + fsinfo_note_paramf(params, "vers", "%u", version); + + fsinfo_note_paramf(params, "rsize", "%u", server->rsize); + fsinfo_note_paramf(params, "wsize", "%u", server->wsize); + if (server->bsize) + fsinfo_note_paramf(params, "bsize", "%u", server->bsize); + fsinfo_note_paramf(params, "namlen", "%u", server->namelen); + + if (server->acregmin != NFS_DEF_ACREGMIN*HZ) + fsinfo_note_paramf(params, "acregmin", "%u", server->acregmin/HZ); + if (server->acregmax != NFS_DEF_ACREGMAX*HZ) + fsinfo_note_paramf(params, "acregmin", "%u", server->acregmax/HZ); + if (server->acdirmin != NFS_DEF_ACDIRMIN*HZ) + fsinfo_note_paramf(params, "acdirmin", "%u", server->acdirmin/HZ); + if (server->acdirmax != NFS_DEF_ACDIRMAX*HZ) + fsinfo_note_paramf(params, "acdirmin", "%u", server->acdirmax/HZ); + + for (i = 0; i < ARRAY_SIZE(nfs_info); i++) { + if (sf & nfs_info[i].flag) + b = nfs_info[i].str; + else + b = nfs_info[i].nostr; + if (b[0]) + fsinfo_note_param(params, b, NULL); + } + + fsinfo_note_param(params, "proto", + rpc_peeraddr2str(server->client, RPC_DISPLAY_NETID)); + if (version != 4 || server->port != NFS_PORT) + fsinfo_note_paramf(params, "port", "%u", server->port); + + fsinfo_note_paramf(params, "timeo", "%lu", + 10U * server->client->cl_timeout->to_initval / HZ); + fsinfo_note_paramf(params, "retrans", "%u", + server->client->cl_timeout->to_retries); + fsinfo_note_param(params, "sec", + nfs_pseudoflavour_to_name(server->client->cl_auth->au_flavor)); + + if (server->options & NFS_OPTION_FSCACHE) + fsinfo_note_param(params, "fsc", NULL); + if (server->options & NFS_OPTION_MIGRATION) + fsinfo_note_param(params, "migration", NULL); + + if (server->flags & NFS_MOUNT_LOOKUP_CACHE_NONEG) { + if (server->flags & NFS_MOUNT_LOOKUP_CACHE_NONE) + fsinfo_note_param(params, "lookupcache", "none"); + else + fsinfo_note_param(params, "lookupcache", "pos"); + } + + switch (server->flags & (NFS_MOUNT_LOCAL_FLOCK | NFS_MOUNT_LOCAL_FCNTL)) { + case 0: b = "none"; break; + case NFS_MOUNT_LOCAL_FLOCK: b = "flock"; break; + case NFS_MOUNT_LOCAL_FCNTL: b = "posix"; break; + default: b = "all"; break; + } + fsinfo_note_param(params, "local_lock", b); + + if (version == 4) + fsinfo_note_param(params, "clientaddr", client->cl_ipaddr); + + if (version != 4 && !(server->flags & NFS_MOUNT_LEGACY_INTERFACE)) { + switch (sap->sa_family) { + case AF_INET: { + struct sockaddr_in *sin = (struct sockaddr_in *)sap; + fsinfo_note_paramf(params, "mountaddr", "%pI4", + &sin->sin_addr.s_addr); + break; + } + case AF_INET6: { + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sap; + fsinfo_note_paramf(params, "mountaddr", "%pI6c", + &sin6->sin6_addr); + break; + } + } + + if (server->mountd_port && + server->mountd_port != (unsigned short)NFS_UNSPEC_PORT) + fsinfo_note_paramf(params, "mountport", "%u", server->mountd_port); + + switch (sap->sa_family) { + case AF_INET: + switch (server->mountd_protocol) { + case IPPROTO_UDP: + b = RPCBIND_NETID_UDP; + break; + case IPPROTO_TCP: + b = RPCBIND_NETID_TCP; + break; + } + break; + case AF_INET6: + switch (server->mountd_protocol) { + case IPPROTO_UDP: + b = RPCBIND_NETID_UDP6; + break; + case IPPROTO_TCP: + b = RPCBIND_NETID_TCP6; + break; + } + break; + } + + if (b) + fsinfo_note_param(params, "mountproto", b); + + if (server->mountd_version) + fsinfo_note_paramf(params, "mountvers", "%u", + server->mountd_version); + } + + fsinfo_note_param(params, "addr", + rpc_peeraddr2str(server->nfs_client->cl_rpcclient, RPC_DISPLAY_ADDR)); + + rcu_read_unlock(); + return params->usage; +} +#endif /* CONFIG_FSINFO */ diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h index da088f5611f0..c218e715881d 100644 --- a/fs/nfs/internal.h +++ b/fs/nfs/internal.h @@ -244,6 +244,10 @@ extern const struct svc_version nfs4_callback_version4; /* fs_context.c */ extern struct file_system_type nfs_fs_type; +#ifdef CONFIG_FSINFO +extern int nfs_fsinfo_parameters(struct fsinfo_kparams *params, struct path *path, + const struct nfs_server *server); +#endif /* pagelist.c */ extern int __init nfs_init_nfspagecache(void); @@ -408,6 +412,7 @@ bool nfs_auth_info_match(const struct nfs_auth_info *, rpc_authflavor_t); int nfs_try_get_tree(struct fs_context *); int nfs_get_tree_common(struct fs_context *); void nfs_kill_super(struct super_block *); +const char *nfs_pseudoflavour_to_name(rpc_authflavor_t); extern struct rpc_stat nfs_rpcstat; @@ -455,6 +460,7 @@ extern void nfs_pageio_reset_read_mds(struct nfs_pageio_descriptor *pgio); /* super.c */ void nfs_umount_begin(struct super_block *); int nfs_statfs(struct dentry *, struct kstatfs *); +int nfs_fsinfo(struct path *, struct fsinfo_kparams *); int nfs_show_options(struct seq_file *, struct dentry *); int nfs_show_devname(struct seq_file *, struct dentry *); int nfs_show_path(struct seq_file *, struct dentry *); diff --git a/fs/nfs/nfs4super.c b/fs/nfs/nfs4super.c index 0240429ec596..22d8f2842ac1 100644 --- a/fs/nfs/nfs4super.c +++ b/fs/nfs/nfs4super.c @@ -31,6 +31,9 @@ static const struct super_operations nfs4_sops = { .show_devname = nfs_show_devname, .show_path = nfs_show_path, .show_stats = nfs_show_stats, +#ifdef CONFIG_FSINFO + .fsinfo = nfs_fsinfo, +#endif }; struct nfs_subversion nfs_v4 = { diff --git a/fs/nfs/super.c b/fs/nfs/super.c index c455ebeeadc9..dde6c59d0210 100644 --- a/fs/nfs/super.c +++ b/fs/nfs/super.c @@ -54,6 +54,7 @@ #include #include #include +#include #include @@ -81,6 +82,9 @@ const struct super_operations nfs_sops = { .show_devname = nfs_show_devname, .show_path = nfs_show_path, .show_stats = nfs_show_stats, +#ifdef CONFIG_FSINFO + .fsinfo = nfs_fsinfo, +#endif }; EXPORT_SYMBOL_GPL(nfs_sops); @@ -241,10 +245,81 @@ int nfs_statfs(struct dentry *dentry, struct kstatfs *buf) } EXPORT_SYMBOL_GPL(nfs_statfs); +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +int nfs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct fsinfo_server_address *addr; + struct fsinfo_capabilities *caps; + struct nfs_server *server = NFS_SB(path->dentry->d_sb); + struct nfs_client *client = server->nfs_client; + struct rpc_clnt *clnt; + struct rpc_xprt *xprt; + const char *str; + unsigned int version = client->rpc_ops->version; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_NETWORK_FS); + fsinfo_set_cap(caps, FSINFO_CAP_AUTOMOUNTS); + fsinfo_set_cap(caps, FSINFO_CAP_ADV_LOCKS); + fsinfo_set_cap(caps, FSINFO_CAP_UIDS); + fsinfo_set_cap(caps, FSINFO_CAP_GIDS); + fsinfo_set_cap(caps, FSINFO_CAP_O_SYNC); + fsinfo_set_cap(caps, FSINFO_CAP_O_DIRECT); + fsinfo_set_cap(caps, FSINFO_CAP_SYMLINKS); + fsinfo_set_cap(caps, FSINFO_CAP_HARD_LINKS); + fsinfo_set_cap(caps, FSINFO_CAP_DEVICE_FILES); + fsinfo_set_cap(caps, FSINFO_CAP_UNIX_SPECIALS); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_ATIME); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_CTIME); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_MTIME); + if (version == 4) { + fsinfo_set_cap(caps, FSINFO_CAP_LEASES); + fsinfo_set_cap(caps, FSINFO_CAP_IVER_ALL_CHANGE); + } + return sizeof(*caps); + + case FSINFO_ATTR_SERVER_NAME: + if (params->Nth || params->Mth) + return -ENODATA; + str = client->cl_hostname; + goto string; + + case FSINFO_ATTR_SERVER_ADDRESS: + if (params->Nth || params->Mth) + return -ENODATA; + addr = params->buffer; + clnt = client->cl_rpcclient; + rcu_read_lock(); + xprt = rcu_dereference(clnt->cl_xprt); + memcpy(&addr->address, &xprt->addr, xprt->addrlen); + rcu_read_unlock(); + return sizeof(*addr); + + case FSINFO_ATTR_PARAMETERS: + return nfs_fsinfo_parameters(params, path, server); + + default: + return generic_fsinfo(path, params); + } + +string: + if (!str) + return 0; + strcpy(params->buffer, str); + return strlen(params->buffer); +} +EXPORT_SYMBOL_GPL(nfs_fsinfo); +#endif /* CONFIG_FSINFO */ + /* * Map the security flavour number to a name */ -static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour) +const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour) { static const struct { rpc_authflavor_t flavour; From patchwork Tue May 28 15:13:31 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965189 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C9FA46C5 for ; Tue, 28 May 2019 15:13:40 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id B9E38287A2 for ; Tue, 28 May 2019 15:13:40 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id AEC7D28754; Tue, 28 May 2019 15:13:40 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 4738E28889 for ; Tue, 28 May 2019 15:13:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727873AbfE1PNf (ORCPT ); Tue, 28 May 2019 11:13:35 -0400 Received: from mx1.redhat.com ([209.132.183.28]:50126 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726826AbfE1PNf (ORCPT ); Tue, 28 May 2019 11:13:35 -0400 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id AD78330C319A; Tue, 28 May 2019 15:13:34 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 334277FD20; Tue, 28 May 2019 15:13:32 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 17/25] fsinfo: autofs - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:31 +0100 Message-ID: <155905641144.1662.13767023676855295385.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.40]); Tue, 28 May 2019 15:13:34 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Also add a simple FSINFO_ATTR_CAPABILITIES implementation. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/autofs/inode.c | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c index 58457ec0ab27..bd9126d8c541 100644 --- a/fs/autofs/inode.c +++ b/fs/autofs/inode.c @@ -11,6 +11,7 @@ #include #include #include +#include #include "autofs_i.h" @@ -101,6 +102,65 @@ static int autofs_show_options(struct seq_file *m, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int autofs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct autofs_sb_info *sbi = autofs_sbi(path->dentry->d_sb); + struct inode *inode = d_inode(path->dentry->d_sb->s_root); + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_AUTOMOUNTER_FS); + fsinfo_set_cap(caps, FSINFO_CAP_AUTOMOUNTS); + fsinfo_set_cap(caps, FSINFO_CAP_NOT_PERSISTENT); + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + fsinfo_note_paramf(params, "fd", "%d", sbi->pipefd); + if (!uid_eq(inode->i_uid, GLOBAL_ROOT_UID)) + fsinfo_note_paramf(params, "uid", "%u", + from_kuid_munged(&init_user_ns, inode->i_uid)); + if (!gid_eq(inode->i_gid, GLOBAL_ROOT_GID)) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, inode->i_gid)); + fsinfo_note_paramf(params, "pgrp", "%d", + pid_vnr(sbi->oz_pgrp)); + fsinfo_note_paramf(params, "timeout", "%lu", + sbi->exp_timeout/HZ); + fsinfo_note_paramf(params, "minproto", "%d", + sbi->min_proto); + fsinfo_note_paramf(params, "maxproto", "%d", + sbi->max_proto); + if (autofs_type_offset(sbi->type)) + fsinfo_note_param(params, "offset", NULL); + else if (autofs_type_direct(sbi->type)) + fsinfo_note_param(params, "direct", NULL); + else + fsinfo_note_param(params, "indirect", NULL); + if (sbi->flags & AUTOFS_SBI_STRICTEXPIRE) + fsinfo_note_param(params, "strictexpire", NULL); + if (sbi->flags & AUTOFS_SBI_IGNORE) + fsinfo_note_param(params, "ignore", NULL); +#ifdef CONFIG_CHECKPOINT_RESTORE + if (sbi->pipe) + fsinfo_note_paramf(params, "pipe_ino", + "%ld", file_inode(sbi->pipe)->i_ino); + else + fsinfo_note_param(params, "pipe_ino", "-1"); +#endif + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static void autofs_evict_inode(struct inode *inode) { clear_inode(inode); @@ -111,6 +171,9 @@ static const struct super_operations autofs_sops = { .statfs = simple_statfs, .show_options = autofs_show_options, .evict_inode = autofs_evict_inode, +#ifdef CONFIG_FSINFO + .fsinfo = autofs_fsinfo, +#endif }; struct autofs_fs_context { From patchwork Tue May 28 15:13:39 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965193 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 3811176 for ; Tue, 28 May 2019 15:13:50 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 2080028538 for ; Tue, 28 May 2019 15:13:50 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 14834287C5; Tue, 28 May 2019 15:13:50 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 84226287A2 for ; Tue, 28 May 2019 15:13:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727540AbfE1PNp (ORCPT ); Tue, 28 May 2019 11:13:45 -0400 Received: from mx1.redhat.com ([209.132.183.28]:49544 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726497AbfE1PNp (ORCPT ); Tue, 28 May 2019 11:13:45 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 7E84DC0AD2A7; Tue, 28 May 2019 15:13:44 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1A462D1A58; Tue, 28 May 2019 15:13:40 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 18/25] fsinfo: shmem - add tmpfs sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:39 +0100 Message-ID: <155905641991.1662.12764923887239561581.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Tue, 28 May 2019 15:13:44 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Also add a simple FSINFO_ATTR_CAPABILITIES implementation. Signed-off-by: Ian Kent Signed-off-by: David Howells --- mm/shmem.c | 71 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/mm/shmem.c b/mm/shmem.c index 38a77ee13db1..493d3c84e13b 100644 --- a/mm/shmem.c +++ b/mm/shmem.c @@ -39,6 +39,7 @@ #include #include #include +#include #include /* for arch/microblaze update_mmu_cache() */ @@ -1403,6 +1404,20 @@ static void shmem_show_mpol(struct seq_file *seq, struct mempolicy *mpol) seq_printf(seq, ",mpol=%s", buffer); } +#ifdef CONFIG_FSINFO +static void shmem_fsinfo_mpol(struct fsinfo_kparams *params, struct mempolicy *mpol) +{ + char buffer[64]; + + if (!mpol || mpol->mode == MPOL_DEFAULT) + return; /* show nothing */ + + mpol_to_str(buffer, sizeof(buffer), mpol); + + fsinfo_note_paramf(params, "mpol", "%s", buffer); +} +#endif + static struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo) { struct mempolicy *mpol = NULL; @@ -1418,6 +1433,11 @@ static struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo) static inline void shmem_show_mpol(struct seq_file *seq, struct mempolicy *mpol) { } +#ifdef CONFIG_FSINFO +static void shmem_fsinfo_mpol(struct fsinfo_kparams *params, struct mempolicy *mpol) +{ +} +#endif static inline struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo) { return NULL; @@ -3478,7 +3498,9 @@ static int shmem_parse_param(struct fs_context *fc, struct fs_parameter *param) struct shmem_fs_context *ctx = fc->fs_private; struct fs_parse_result result; unsigned long long size; +#ifdef CONFIG_NUMA struct mempolicy *mpol; +#endif char *rest; int opt; @@ -3623,6 +3645,52 @@ static int shmem_show_options(struct seq_file *seq, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +static int shmem_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct shmem_sb_info *sbinfo = SHMEM_SB(path->dentry->d_sb); + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_unix_caps(caps); + fsinfo_set_cap(caps, FSINFO_CAP_IS_MEMORY_FS); + fsinfo_set_cap(caps, FSINFO_CAP_NOT_PERSISTENT); +#ifdef CONFIG_TMPFS_XATTR + fsinfo_set_cap(caps, FSINFO_CAP_XATTRS); +#endif + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + if (sbinfo->max_blocks != shmem_default_max_blocks()) + fsinfo_note_paramf(params, "size", "%luk", + sbinfo->max_blocks << (PAGE_SHIFT - 10)); + if (sbinfo->max_inodes != shmem_default_max_inodes()) + fsinfo_note_paramf(params, "nr_inodes", + "%lu", sbinfo->max_inodes); + if (sbinfo->mode != (0777 | S_ISVTX)) + fsinfo_note_paramf(params, "mode", + "%03ho", sbinfo->mode); + if (!uid_eq(sbinfo->uid, GLOBAL_ROOT_UID)) + fsinfo_note_paramf(params, "uid", "%u", + from_kuid_munged(&init_user_ns, sbinfo->uid)); + if (!gid_eq(sbinfo->gid, GLOBAL_ROOT_GID)) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, sbinfo->gid)); +#ifdef CONFIG_TRANSPARENT_HUGE_PAGECACHE + /* Rightly or wrongly, show huge mount option unmasked by shmem_huge */ + if (sbinfo->huge) + fsinfo_note_paramf(params, "huge", "%s", + shmem_format_huge(sbinfo->huge)); +#endif + shmem_fsinfo_mpol(params, sbinfo->mpol); + return params->usage; + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ #endif /* CONFIG_TMPFS */ static void shmem_put_super(struct super_block *sb) @@ -3854,6 +3922,9 @@ static const struct super_operations shmem_ops = { #ifdef CONFIG_TMPFS .statfs = shmem_statfs, .show_options = shmem_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = shmem_fsinfo, +#endif #endif .evict_inode = shmem_evict_inode, .drop_inode = generic_delete_inode, From patchwork Tue May 28 15:13:49 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965195 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 48E6176 for ; Tue, 28 May 2019 15:13:57 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 37DD52858E for ; Tue, 28 May 2019 15:13:57 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 2C88228606; Tue, 28 May 2019 15:13:57 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id C6590288B2 for ; Tue, 28 May 2019 15:13:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727901AbfE1PNw (ORCPT ); Tue, 28 May 2019 11:13:52 -0400 Received: from mx1.redhat.com ([209.132.183.28]:42722 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726497AbfE1PNw (ORCPT ); Tue, 28 May 2019 11:13:52 -0400 Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id DA751307D96F; Tue, 28 May 2019 15:13:51 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 7F3F5173B0; Tue, 28 May 2019 15:13:50 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 19/25] fsinfo: proc - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:49 +0100 Message-ID: <155905642971.1662.2801058772112807295.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.48]); Tue, 28 May 2019 15:13:51 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Also add a simple FSINFO_ATTR_CAPABILITIES implementation. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/proc/inode.c | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/fs/proc/inode.c b/fs/proc/inode.c index 5f8d215b3fd0..0f6c122d22f0 100644 --- a/fs/proc/inode.c +++ b/fs/proc/inode.c @@ -24,6 +24,7 @@ #include #include #include +#include #include @@ -115,6 +116,38 @@ static int proc_show_options(struct seq_file *seq, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int proc_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct super_block *sb = path->dentry->d_sb; + struct pid_namespace *pid = sb->s_fs_info; + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_KERNEL_FS); + fsinfo_set_cap(caps, FSINFO_CAP_NOT_PERSISTENT); + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + if (!gid_eq(pid->pid_gid, GLOBAL_ROOT_GID)) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, pid->pid_gid)); + if (pid->hide_pid != HIDEPID_OFF) + fsinfo_note_paramf(params, "hidepid", + "%u", pid->hide_pid); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + const struct super_operations proc_sops = { .alloc_inode = proc_alloc_inode, .free_inode = proc_free_inode, @@ -122,6 +155,9 @@ const struct super_operations proc_sops = { .evict_inode = proc_evict_inode, .statfs = simple_statfs, .show_options = proc_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = proc_fsinfo, +#endif }; enum {BIAS = -1U<<31}; From patchwork Tue May 28 15:13:57 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965199 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6941315E6 for ; Tue, 28 May 2019 15:14:13 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 5852F2863F for ; Tue, 28 May 2019 15:14:13 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 568C72851B; Tue, 28 May 2019 15:14:13 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id E2458287A2 for ; Tue, 28 May 2019 15:14:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727631AbfE1POA (ORCPT ); Tue, 28 May 2019 11:14:00 -0400 Received: from mx1.redhat.com ([209.132.183.28]:36922 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726497AbfE1PN7 (ORCPT ); Tue, 28 May 2019 11:13:59 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 2F119D4015; Tue, 28 May 2019 15:13:59 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id CAE18112A283; Tue, 28 May 2019 15:13:57 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 20/25] fsinfo: devpts - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:13:57 +0100 Message-ID: <155905643707.1662.9338994077777129914.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.38]); Tue, 28 May 2019 15:13:59 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Also add a simple FSINFO_ATTR_CAPABILITIES implementation. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/devpts/inode.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c index 3aa73a2ec2f1..12fece8913d2 100644 --- a/fs/devpts/inode.c +++ b/fs/devpts/inode.c @@ -28,6 +28,7 @@ #include #include #include +#include #define DEVPTS_DEFAULT_MODE 0600 /* @@ -401,9 +402,50 @@ static int devpts_show_options(struct seq_file *seq, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int devpts_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct pts_fs_info *fsi = DEVPTS_SB(path->dentry->d_sb); + struct pts_mount_opts *opts = &fsi->mount_opts; + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_KERNEL_FS); + fsinfo_set_cap(caps, FSINFO_CAP_NOT_PERSISTENT); + fsinfo_set_cap(caps, FSINFO_CAP_UIDS); + fsinfo_set_cap(caps, FSINFO_CAP_GIDS); + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + if (opts->setuid) + fsinfo_note_paramf(params, "uid", "%u", + from_kuid_munged(&init_user_ns, opts->uid)); + if (opts->setgid) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, opts->gid)); + fsinfo_note_paramf(params, "mode", "%03o", opts->mode); + fsinfo_note_paramf(params, "ptmxmode", "%03o", opts->ptmxmode); + if (opts->max < NR_UNIX98_PTY_MAX) + fsinfo_note_paramf(params, "max", "%d", opts->max); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static const struct super_operations devpts_sops = { .statfs = simple_statfs, .show_options = devpts_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = devpts_fsinfo, +#endif }; static int devpts_fill_super(struct super_block *s, struct fs_context *fc) From patchwork Tue May 28 15:14:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965197 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8557976 for ; Tue, 28 May 2019 15:14:11 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 74A94204FD for ; Tue, 28 May 2019 15:14:11 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 68F0F285F7; Tue, 28 May 2019 15:14:11 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 0F2A828893 for ; Tue, 28 May 2019 15:14:11 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727955AbfE1POH (ORCPT ); Tue, 28 May 2019 11:14:07 -0400 Received: from mx1.redhat.com ([209.132.183.28]:35143 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727921AbfE1POG (ORCPT ); Tue, 28 May 2019 11:14:06 -0400 Received: from smtp.corp.redhat.com (int-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.11]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 7F468301988B; Tue, 28 May 2019 15:14:06 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 29E44C087F; Tue, 28 May 2019 15:14:05 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 21/25] fsinfo: pstore - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:14:04 +0100 Message-ID: <155905644440.1662.3745883327641806605.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.11 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.47]); Tue, 28 May 2019 15:14:06 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/pstore/inode.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c index 4640debf8755..44f4ffc4436e 100644 --- a/fs/pstore/inode.c +++ b/fs/pstore/inode.c @@ -36,6 +36,7 @@ #include #include #include +#include #include "internal.h" @@ -281,6 +282,33 @@ static int pstore_show_options(struct seq_file *m, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int pstore_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_FLASH_FS); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_CTIME); + fsinfo_set_cap(caps, FSINFO_CAP_HAS_MTIME); + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + if (kmsg_bytes != PSTORE_DEFAULT_KMSG_BYTES) + fsinfo_note_paramf(params, "kmsg_bytes", "%lu", kmsg_bytes); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static int pstore_reconfigure(struct fs_context *fc) { sync_filesystem(fc->root->d_sb); @@ -293,6 +321,9 @@ static const struct super_operations pstore_ops = { .drop_inode = generic_delete_inode, .evict_inode = pstore_evict_inode, .show_options = pstore_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = pstore_fsinfo, +#endif }; static struct super_block *pstore_sb; From patchwork Tue May 28 15:14:11 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965201 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id C942B76 for ; Tue, 28 May 2019 15:14:20 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id B8A93287C6 for ; Tue, 28 May 2019 15:14:20 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id ACF1A287E7; Tue, 28 May 2019 15:14:20 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 079D0287C6 for ; Tue, 28 May 2019 15:14:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727985AbfE1POP (ORCPT ); Tue, 28 May 2019 11:14:15 -0400 Received: from mx1.redhat.com ([209.132.183.28]:42860 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726969AbfE1POO (ORCPT ); Tue, 28 May 2019 11:14:14 -0400 Received: from smtp.corp.redhat.com (int-mx08.intmail.prod.int.phx2.redhat.com [10.5.11.23]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id D103A307D942; Tue, 28 May 2019 15:14:13 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 7A959EE1B4; Tue, 28 May 2019 15:14:12 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 22/25] fsinfo: debugfs - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:14:11 +0100 Message-ID: <155905645172.1662.12893154635552209881.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.23 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.48]); Tue, 28 May 2019 15:14:13 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Also add a simple FSINFO_ATTR_CAPABILITIES implementation. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/debugfs/inode.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c index 24354ccdc968..74b499c964f3 100644 --- a/fs/debugfs/inode.c +++ b/fs/debugfs/inode.c @@ -24,6 +24,7 @@ #include #include #include +#include #include "internal.h" @@ -143,6 +144,39 @@ static int debugfs_show_options(struct seq_file *m, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int debugfs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct debugfs_fs_info *fsi = path->dentry->d_sb->s_fs_info; + struct fsinfo_capabilities *caps; + + switch (params->request) { + case FSINFO_ATTR_CAPABILITIES: + caps = params->buffer; + fsinfo_set_cap(caps, FSINFO_CAP_IS_KERNEL_FS); + fsinfo_set_cap(caps, FSINFO_CAP_NOT_PERSISTENT); + return sizeof(*caps); + + case FSINFO_ATTR_PARAMETERS: + if (!uid_eq(fsi->uid, GLOBAL_ROOT_UID)) + fsinfo_note_paramf(params, "uid", "%u", + from_kuid_munged(&init_user_ns, fsi->uid)); + if (!gid_eq(fsi->gid, GLOBAL_ROOT_GID)) + fsinfo_note_paramf(params, "gid", "%u", + from_kgid_munged(&init_user_ns, fsi->gid)); + if (fsi->mode != DEBUGFS_DEFAULT_MODE) + fsinfo_note_paramf(params, "mode", "%o", fsi->mode); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static void debugfs_free_inode(struct inode *inode) { if (S_ISLNK(inode->i_mode)) @@ -154,6 +188,9 @@ static const struct super_operations debugfs_super_operations = { .statfs = simple_statfs, .show_options = debugfs_show_options, .free_inode = debugfs_free_inode, +#ifdef CONFIG_FSINFO + .fsinfo = debugfs_fsinfo, +#endif }; static void debugfs_release_dentry(struct dentry *dentry) From patchwork Tue May 28 15:14:19 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965203 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 8C87C6C5 for ; Tue, 28 May 2019 15:14:23 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 79D2828889 for ; Tue, 28 May 2019 15:14:23 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 6E0D8287C6; Tue, 28 May 2019 15:14:23 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 1502C287E7 for ; Tue, 28 May 2019 15:14:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728007AbfE1POW (ORCPT ); Tue, 28 May 2019 11:14:22 -0400 Received: from mx1.redhat.com ([209.132.183.28]:60450 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726969AbfE1POV (ORCPT ); Tue, 28 May 2019 11:14:21 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 2A55BC01F278; Tue, 28 May 2019 15:14:21 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id C6B4DD468D; Tue, 28 May 2019 15:14:19 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 23/25] fsinfo: bpf - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:14:19 +0100 Message-ID: <155905645905.1662.13856174905974520945.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.31]); Tue, 28 May 2019 15:14:21 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Signed-off-by: Ian Kent Signed-off-by: David Howells --- kernel/bpf/inode.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/kernel/bpf/inode.c b/kernel/bpf/inode.c index 6e22363054b1..49ac30424dd1 100644 --- a/kernel/bpf/inode.c +++ b/kernel/bpf/inode.c @@ -23,6 +23,7 @@ #include #include #include +#include enum bpf_type { BPF_TYPE_UNSPEC = 0, @@ -567,6 +568,26 @@ static int bpf_show_options(struct seq_file *m, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +/* + * Get filesystem information. + */ +static int bpf_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + umode_t mode = d_inode(path->dentry)->i_mode & S_IALLUGO & ~S_ISVTX; + + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + if (mode != S_IRWXUGO) + fsinfo_note_paramf(params, "mode", "%o", mode); + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static void bpf_free_inode(struct inode *inode) { enum bpf_type type; @@ -583,6 +604,9 @@ static const struct super_operations bpf_super_ops = { .drop_inode = generic_delete_inode, .show_options = bpf_show_options, .free_inode = bpf_free_inode, +#ifdef CONFIG_FSINFO + .fsinfo = bpf_fsinfo, +#endif }; enum { From patchwork Tue May 28 15:14:26 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965205 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id BDE736C5 for ; Tue, 28 May 2019 15:14:35 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id AD172287A6 for ; Tue, 28 May 2019 15:14:35 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id A0DD3288B6; Tue, 28 May 2019 15:14:35 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 379EB287A6 for ; Tue, 28 May 2019 15:14:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728025AbfE1PO3 (ORCPT ); Tue, 28 May 2019 11:14:29 -0400 Received: from mx1.redhat.com ([209.132.183.28]:49910 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726736AbfE1PO3 (ORCPT ); Tue, 28 May 2019 11:14:29 -0400 Received: from smtp.corp.redhat.com (int-mx07.intmail.prod.int.phx2.redhat.com [10.5.11.22]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 79D2CC05D419; Tue, 28 May 2019 15:14:28 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 232011133A5D; Tue, 28 May 2019 15:14:26 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 24/25] fsinfo: ufs - add sb operation fsinfo() [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:14:26 +0100 Message-ID: <155905646637.1662.2508556539065009207.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.84 on 10.5.11.22 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.32]); Tue, 28 May 2019 15:14:28 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Ian Kent The new fsinfo() system call adds a new super block operation ->fsinfo() which is used by file systems to provide file system specific information for fsinfo() requests. The fsinfo() request FSINFO_ATTR_PARAMETERS provides the same function as sb operation ->show_options() so it needs to be implemented by any file system that provides ->show_options() as a minimum. Signed-off-by: Ian Kent Signed-off-by: David Howells --- fs/ufs/super.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/fs/ufs/super.c b/fs/ufs/super.c index 84c0c5178cd2..6395ce4da5e6 100644 --- a/fs/ufs/super.c +++ b/fs/ufs/super.c @@ -89,6 +89,7 @@ #include #include #include +#include #include "ufs_fs.h" #include "ufs.h" @@ -1401,6 +1402,59 @@ static int ufs_show_options(struct seq_file *seq, struct dentry *root) return 0; } +#ifdef CONFIG_FSINFO +static int ufs_fsinfo_print_token(struct fsinfo_kparams *params, const char *token) +{ + char *new, *key, *value; + + new = kstrdup(token, GFP_KERNEL); + if (!new) + return -ENOMEM; + + key = new; + value = strchr(new, '='); + if (value) + *value++ = '\0'; + + fsinfo_note_param(params, key, value); + + kfree(new); + return 0; +} + +/* + * Get filesystem information. + */ +static int ufs_fsinfo(struct path *path, struct fsinfo_kparams *params) +{ + struct ufs_sb_info *sbi = UFS_SB(path->dentry->d_sb); + unsigned mval = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE; + const struct match_token *tp = tokens; + int ret; + + switch (params->request) { + case FSINFO_ATTR_PARAMETERS: + while (tp->token != Opt_onerror_panic && tp->token != mval) + ++tp; + BUG_ON(tp->token == Opt_onerror_panic); + ret = ufs_fsinfo_print_token(params, tp->pattern); + if (ret) + return ret; + mval = sbi->s_mount_opt & UFS_MOUNT_ONERROR; + while (tp->token != Opt_err && tp->token != mval) + ++tp; + BUG_ON(tp->token == Opt_err); + ret = ufs_fsinfo_print_token(params, tp->pattern); + if (ret) + return ret; + return params->usage; + + default: + return generic_fsinfo(path, params); + } +} +#endif /* CONFIG_FSINFO */ + static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf) { struct super_block *sb = dentry->d_sb; @@ -1496,6 +1550,9 @@ static const struct super_operations ufs_super_ops = { .statfs = ufs_statfs, .remount_fs = ufs_remount, .show_options = ufs_show_options, +#ifdef CONFIG_FSINFO + .fsinfo = ufs_fsinfo, +#endif }; static struct dentry *ufs_mount(struct file_system_type *fs_type, From patchwork Tue May 28 15:14:33 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 10965207 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E6C7876 for ; Tue, 28 May 2019 15:14:44 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id D4A76287C5 for ; Tue, 28 May 2019 15:14:44 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id C7F08287A2; Tue, 28 May 2019 15:14:44 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 4FE122851B for ; Tue, 28 May 2019 15:14:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727645AbfE1POi (ORCPT ); Tue, 28 May 2019 11:14:38 -0400 Received: from mx1.redhat.com ([209.132.183.28]:60532 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726736AbfE1POh (ORCPT ); Tue, 28 May 2019 11:14:37 -0400 Received: from smtp.corp.redhat.com (int-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 139EDC05B00A; Tue, 28 May 2019 15:14:37 +0000 (UTC) Received: from warthog.procyon.org.uk (ovpn-125-65.rdu2.redhat.com [10.10.125.65]) by smtp.corp.redhat.com (Postfix) with ESMTP id 68A1BD7A76; Tue, 28 May 2019 15:14:34 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH 25/25] fsinfo: Add API documentation [ver #13] From: David Howells To: viro@zeniv.linux.org.uk Cc: dhowells@redhat.com, raven@themaw.net, linux-api@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, mszeredi@redhat.com Date: Tue, 28 May 2019 16:14:33 +0100 Message-ID: <155905647369.1662.10806818386998503329.stgit@warthog.procyon.org.uk> In-Reply-To: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> References: <155905626142.1662.18430571708534506785.stgit@warthog.procyon.org.uk> User-Agent: StGit/unknown-version MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.31]); Tue, 28 May 2019 15:14:37 +0000 (UTC) Sender: linux-fsdevel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-fsdevel@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP --- Documentation/filesystems/fsinfo.rst | 571 ++++++++++++++++++++++++++++++++++ 1 file changed, 571 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..3e4d64cc04b1 --- /dev/null +++ b/Documentation/filesystems/fsinfo.rst @@ -0,0 +1,571 @@ +================================ +Filesystem Information Retrieval +================================ + +The fsinfo() system call allows the retrieval of filesystem and filesystem +security information beyond what stat(), statx() and statfs() can query. It +does not require a file to be opened as does ioctl(). + +fsinfo() may be called on a path, an open file descriptor, a filesystem-context +file descriptor as allocated by fsopen() or fspick() or a mount ID (allowing +for mounts concealed by overmounts to be accessed). + +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, specified by +the "fsinfo_attribute" enumeration:: + + FSINFO_ATTR_STATFS - statfs()-style state + FSINFO_ATTR_FSINFO - Information about fsinfo() itself + FSINFO_ATTR_IDS - Filesystem IDs + FSINFO_ATTR_LIMITS - Filesystem limits + ... + +Each attribute has one of a number of types and, moreover, may have multiple +values, accessible as a 1D-array or a 2D array-of-arrays. The attribute types +are: + + * ``Struct``. 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 kernel returns the actual size + of the internal struct, regardless of how much data it returned. + + This allows for struct-type fields to be extended in future. + + * ``String``. This is a variable-length string of up to 4096 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. + + * ``Array``. This is a variable-length array 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. + + * ``Opaque``. This is a variable-length blob of indeterminate structure. It + may be up to INT_MAX bytes in size. + + +Filesystem API +============== + +The filesystem is called through a superblock_operations method:: + + int (*fsinfo) (struct path *path, struct fsinfo_kparams *params); + +where "path" indicates the object to be queried and params indicates the +parameters and the output buffer description. The function should return the +total size of the data it would like to produce or an error. + +The parameter struct looks like:: + + struct fsinfo_kparams { + enum fsinfo_attribute request; + __u32 Nth; + __u32 Mth; + unsigned int buf_size; + unsigned int usage; + void *buffer; + char *scratch_buffer; + ... + }; + +The fields relevant to the filesystem are as follows: + + * ``request`` + + 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, Take, for example, FSINFO_ATTR_SERVER_ADDRESS - each + server listed by FSINFO_ATTR_SERVER_NAME may have one or more addresses. + This will return the Mth address of the Nth server. ENODATA will be + returned if the Nth set doesn't exist or the Mth element of the Nth set + doesn't exist. + + * ``buf_size`` + + This indicates the current size of the buffer. For the array 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. + + * ``usage`` + + This indicates how much of the buffer has been used so far for an array or + opaque type attribute. This is updated by the fsinfo_note_param*() + functions. + + * ``buffer`` + + This points to the output buffer. For struct-type and string-type + attributes it will always be big enough; for array- and opaque-type, it will + be buf_size in size and will be resized if the returned size is larger than + this. + + * ``scratch_buffer`` + + For array- and opaque-type attributes, this will point to a 4096-byte + scratch buffer. Sometimes the value needs to be generated by sprintf(), + say, to find out how big is going to be, but that might not be possible in + the main buffer without risking an overrun. + +To simplify filesystem code, there will always be at least a minimal buffer +available if the ->fsinfo() method gets called - and the filesystem should +always write what it can into the buffer. It's possible that the fsinfo() +system call will then throw the contents away and just return the length. + + +Helper Functions +================ + +The API includes a number of helper functions: + + * ``int generic_fsinfo(struct path *path, struct fsinfo_kparams *params);`` + + This is the function that does default actions for filling out attribute + values from standard data, such as may be found in the file_system_type + struct and the super_block struct. It also generates -EOPNOTSUPP for + unsupported attributes. + + This should be called by a filesystem if it doesn't want to handle an + attribute. The filesystem may also call this function and then adjust the + information returned, such as changing the listed capability flags. + + * ``void fsinfo_set_cap(struct fsinfo_capabilities *c, + enum fsinfo_capability cap);`` + + This function sets a capability flag. + + * ``void fsinfo_clear_cap(struct fsinfo_capabilities *c, + enum fsinfo_capability cap);`` + + This function clears a capability flag. + + * ``void fsinfo_set_unix_caps(struct fsinfo_capabilities *caps);`` + + Set capability 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. + + * ``void fsinfo_note_param(struct fsinfo_kparams *params, const char *key, + const char *val);`` + + This function writes a pair of strings with prepended lengths into + params->buffer, if there's space, and always updates params->usage. The + assumption is that the caller of s->s_op->fsinfo() will resize the buffer if + the usage grew too large and call again. + + This is intended for use with FSINFO_ATTR_{,LSM_}PARAMETERS, but is not + limited to those. The format allows binary data, though this API function + does not support anything with NUL characters in it. + + Note that this function will not sleep, so is safe to take with locks held. + + * ``void fsinfo_note_paramf(struct fsinfo_kparams *params, const char *key, + const char *val_fmt, ...);`` + + This function is a simple wrapper around fsinfo_note_param(), writing the + value using vsnprintf() into params->scratch_buffer and then jumping to + fsinfo_note_param(). + + +Attribute Summary +================= + +To summarise the attributes that are defined:: + + Symbolic name Type + ===================================== =============== + FSINFO_ATTR_STATFS struct + FSINFO_ATTR_FSINFO struct + FSINFO_ATTR_IDS struct + FSINFO_ATTR_LIMITS struct + FSINFO_ATTR_SUPPORTS struct + FSINFO_ATTR_CAPABILITIES struct + FSINFO_ATTR_TIMESTAMP_INFO struct + FSINFO_ATTR_VOLUME_ID string + FSINFO_ATTR_VOLUME_UUID struct + FSINFO_ATTR_VOLUME_NAME string + FSINFO_ATTR_NAME_ENCODING string + FSINFO_ATTR_NAME_CODEPAGE string + FSINFO_ATTR_PARAM_DESCRIPTION struct + FSINFO_ATTR_PARAM_SPECIFICATION N × struct + FSINFO_ATTR_PARAM_ENUM N × struct + FSINFO_ATTR_PARAMETERS opaque + FSINFO_ATTR_LSM_PARAMETERS opaque + FSINFO_ATTR_MOUNT_INFO struct + FSINFO_ATTR_MOUNT_DEVNAME string + FSINFO_ATTR_MOUNT_CHILDREN array + FSINFO_ATTR_MOUNT_SUBMOUNT N × string + FSINFO_ATTR_SERVER_NAME N × string + FSINFO_ATTR_SERVER_ADDRESS N × M × struct + FSINFO_ATTR_CELL_NAME string + + +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 integers. Note that static + data like IDs that don't change are retrieved with FSINFO_ATTR_IDS instead. + + * ``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_CAPABILITIES`` + + This is a special attribute, being a set of single-bit capability flags, + formatted as struct-type attribute. The meanings of the capability bits + are listed below - see the "Capability Bit Catalogue" section. The + capability bits are grouped numerically into bytes, such that capilities + 0-7 are in byte 0, 8-15 are in byte 1, 16-23 in byte 2 and so on. + + Any capability bit that's not supported by the kernel will be set to false + if asked for. The highest supported capability can be obtained from + attribute "FSINFO_ATTR_FSINFO". + + * ``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_NAME_ENCODING`` + + This is a string-type attribute that returns the type of encoding used for + filenames in the medium. By default this will be filled in with "utf8". + Not all filesystems can support that, however, so this may indicate a + restriction on what characters can be used. + + * ``FSINFO_ATTR_NAME_CODEPAGE`` + + This is a string-type attribute that returns the name of the codepage used + to transliterate a Linux utf8 filename into whatever the medium supports. + By default it returns EOPNOTSUPP. + + +The next attributes give information about the mount parameter parsers and the +mount parameters values stored in a superblock and its security data. The +first few of these can be queried on the file descriptor returned by fsopen() +before any superblock is attached: + + * ``FSINFO_ATTR_PARAM_DESCRIPTION`` + + This is a struct-type attribute that returns summary information about what + mount options are available on a filesystem, including the number of + parameters and the number of enum symbols. + + * ``FSINFO_ATTR_PARAM_SPECIFICATION`` + + This is a 1D array of struct-type attributes, indicating the type, + qualifiers, name and an option ID for the Nth mount parameter. Parameters + that have the same option ID are presumed to be synonyms. + + * ``FSINFO_ATTR_PARAM_ENUM`` + + This is a 1D array of struct-type attributes, indicating the Nth value + symbol for the set of enumeration-type parameters. All the values are in + the same table, so they can be matched to the parameter by option ID, and + each option ID may have several entries, each with a different name. + + * ``FSINFO_ATTR_PARAMETERS`` + * ``FSINFO_ATTR_LSM_PARAMETERS`` + + These are a pair of opaque blobs that list all the mount parameter values + currently set on a superblock. The first set come from the filesystem and + the second is from the LSMs - and, as such, convey security information, + such as labelling. + + Inside the filesystem or LSM, the parameter values should be read in one go + under lock to avoid races with remount if necessary. + + Each opaque blob is encoded as a series of pairs of elements, where each + element begins with a length. The first element of each pair is the key + name and the second is the value (which may contain commas, binary data, + NUL chars). + + An element length is encoded as a series of bytes in most->least signifcant + order. Each byte contributes 7 bits to the length. The MSB in each byte + is set if there's another byte of length information following on (ie. all + but the last byte in the length have the MSB set). + + +Then there are attributes that convey information about the mount topology: + + * ``FSINFO_ATTR_MOUNT_INFO`` + + This struct-type attribute conveys information about a mount topology node + rather than a superblock. This includes the ID of the superblock mounted + there and the ID of the mount node, its parent, group, master and + propagation source. It also contains the attribute flags for the mount and + a change notification counter so that it can be quickly determined if that + node changed. + + * ``FSINFO_ATTR_MOUNT_DEVNAME`` + + This string-type attribute returns the "device name" that was supplied when + the mount object was created. + + * ``FSINFO_ATTR_MOUNT_CHILDREN`` + + This is an array-type attribute that conveys a set of structs, each of + which indicates the mount ID of a child and the change counter for that + child. The kernel also tags an extra element on the end that indicates the + ID and change counter of the queried object. This allows a conflicting + change to be quickly detected by comparing the before and after counters. + + * ``FSINFO_ATTR_MOUNT_SUBMOUNT`` + + This is a string-type attribute that conveys the pathname of the Nth + mountpoint under the target mount, relative to the mount root or the + chroot, whichever is closer. These correspond on a 1:1 basis with the + eleemnts in the FSINFO_ATTR_MOUNT_CHROOT list. + +Then there are filesystem-specific attributes. + + * ``FSINFO_ATTR_SERVER_NAME`` + + This is a string-type attribute that conveys the name of the Nth server + backing a network-filesystem superblock. + + * ``FSINFO_ATTR_SERVER_ADDRESS`` + + This is a struct-type attribute that conveys the Mth address of the Nth + server, as returned by FSINFO_ATTR_SERVER_NAME. + + * ``FSINFO_ATTR_CELL_NAME`` + + This is a string-type attribute that retrieves the AFS cell name of the + target object. + + +Lastly, one attribute gives information about fsinfo() itself: + + * ``FSINFO_ATTR_FSINFO`` + + This struct-type attribute gives information about the fsinfo() system call + itself, including the maximum number of attributes supported and the + maximum number of capability bits supported. + + +Capability Bit Catalogue +======================== + +The capability bits convey single true/false assertions about a specific +instance of a filesystem (ie. a specific superblock). They are accessed using +the "FSINFO_ATTR_CAPABILITY" attribute: + + * ``FSINFO_CAP_IS_KERNEL_FS`` + * ``FSINFO_CAP_IS_BLOCK_FS`` + * ``FSINFO_CAP_IS_FLASH_FS`` + * ``FSINFO_CAP_IS_NETWORK_FS`` + * ``FSINFO_CAP_IS_AUTOMOUNTER_FS`` + * ``FSINFO_CAP_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_CAP_AUTOMOUNTS`` + + This indicate if a filesystem may have objects that are automount points. + + * ``FSINFO_CAP_ADV_LOCKS`` + * ``FSINFO_CAP_MAND_LOCKS`` + * ``FSINFO_CAP_LEASES`` + + These indicate if a filesystem supports advisory locks, mandatory locks or + leases. + + * ``FSINFO_CAP_UIDS`` + * ``FSINFO_CAP_GIDS`` + * ``FSINFO_CAP_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_CAP_STRING_USER_IDS`` + + This indicates if a filesystem supports/stores/transports string user + identifiers. + + * ``FSINFO_CAP_GUID_USER_IDS`` + + This indicates if a filesystem supports/stores/transports Windows GUIDs as + user identifiers (eg. ntfs). + + * ``FSINFO_CAP_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_CAP_USER_QUOTAS`` + * ``FSINFO_CAP_GROUP_QUOTAS`` + * ``FSINFO_CAP_PROJECT_QUOTAS`` + + These indicate if a filesystem supports quotas for users, groups or + projects. + + * ``FSINFO_CAP_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_CAP_JOURNAL`` + * ``FSINFO_CAP_DATA_IS_JOURNALLED`` + + These indicate whether the filesystem has a journal and whether data + changes are logged to it. + + * ``FSINFO_CAP_O_SYNC`` + * ``FSINFO_CAP_O_DIRECT`` + + These indicate whether the filesystem supports the O_SYNC and O_DIRECT + flags. + + * ``FSINFO_CAP_VOLUME_ID`` + * ``FSINFO_CAP_VOLUME_UUID`` + * ``FSINFO_CAP_VOLUME_NAME`` + * ``FSINFO_CAP_VOLUME_FSID`` + + These indicate whether ID, UUID, name and FSID identifiers actually exist + in the filesystem and thus might be considered persistent. + + * ``FSINFO_CAP_IVER_ALL_CHANGE`` + * ``FSINFO_CAP_IVER_DATA_CHANGE`` + * ``FSINFO_CAP_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_CAP_HARD_LINKS`` + * ``FSINFO_CAP_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_CAP_DIRECTORIES`` + * ``FSINFO_CAP_SYMLINKS`` + * ``FSINFO_CAP_DEVICE_FILES`` + * ``FSINFO_CAP_UNIX_SPECIALS`` + + These indicate whether directories; symbolic links; device files; or pipes + and sockets can be made within the filesystem. + + * ``FSINFO_CAP_RESOURCE_FORKS`` + + This indicates if the filesystem supports resource forks. + + * ``FSINFO_CAP_NAME_CASE_INDEP`` + * ``FSINFO_CAP_NAME_NON_UTF8`` + * ``FSINFO_CAP_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_CAP_SPARSE`` + + This indicates if a filesystem supports sparse files. + + * ``FSINFO_CAP_NOT_PERSISTENT`` + + This indicates if a filesystem is not persistent. + + * ``FSINFO_CAP_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_CAP_HAS_ATIME`` + * ``FSINFO_CAP_HAS_BTIME`` + * ``FSINFO_CAP_HAS_CTIME`` + * ``FSINFO_CAP_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).