Statsfs: a new ram-based file sytem for Linux kernel statistics
cover Statsfs: a new ram-based file sytem for Linux kernel statistics
There is currently no common way for Linux kernel subsystems to expose statistics to userspace shared throughout the Linux kernel; subsystems have to take care of gathering and displaying statistics by themselves, for example in the form of files in debugfs. For example KVM has its own code section that takes care of this in virt/kvm/kvm_main.c, where it sets up debugfs handlers for displaying values and aggregating them from various subfolders to obtain information about the system state (i.e. displaying the total number of exits, calculated by summing all exits of all cpus of all running virtual machines).
Allowing each section of the kernel to do so has two disadvantages. First, it will introduce redundant code. Second, debugfs is anyway not the right place for statistics (for example it is affected by lockdown)
In this patch series I introduce statsfs, a synthetic ram-based virtual filesystem that takes care of gathering and displaying statistics for the Linux kernel subsystems.
The file system is mounted on /sys/kernel/stats and would be already used by kvm. Statsfs was initially introduced by Paolo Bonzini [1].
Statsfs offers a generic and stable API, allowing any kind of directory/file organization and supporting multiple kind of aggregations (not only sum, but also average, max, min and count_zero) and data types (all unsigned and signed types plus boolean). The implementation, which is a generalization of KVM’s debugfs statistics code, takes care of gathering and displaying information at run time; users only need to specify the values to be included in each source.
Statsfs would also be a different mountpoint from debugfs, and would not suffer from limited access due to the security lock down patches. Its main function is to display each statistics as a file in the desired folder hierarchy defined through the API. Statsfs files can be read, and possibly cleared if their file mode allows it.
Statsfs has two main components: the public API defined by include/linux/statsfs.h, and the virtual file system which should end up in /sys/kernel/stats.
The API has two main elements, values and sources. Kernel subsystems like KVM can use the API to create a source, add child sources/values/aggregates and register it to the root source (that on the virtual fs would be /sys/kernel/statsfs).
Sources are created via statsfs_source_create(), and each source becomes a directory in the file system. Sources form a parent-child relationship; root sources are added to the file system via statsfs_source_register(). Every other source is added to or removed from a parent through the statsfs_source_add_subordinate and statsfs_source_remote_subordinate APIs. Once a source is created and added to the tree (via add_subordinate), it will be used to compute aggregate values in the parent source.
Values represent quantites that are gathered by the statsfs user. Examples of values include the number of vm exits of a given kind, the amount of memory used by some data structure, the length of the longest hash table chain, or anything like that. Values are defined with the statsfs_source_add_values function. Each value is defined by a struct statsfs_value; the same statsfs_value can be added to many different sources. A value can be considered "simple" if it fetches data from a user-provided location, or "aggregate" if it groups all values in the subordinates sources that include the same statsfs_value.
For more information, please consult the kerneldoc documentation in patch 2 and the sample uses in the kunit tests and in KVM.
This series of patches is based on my previous series "libfs: group and simplify linux fs code" and the single patch sent to kvm "kvm_host: unify VM_STAT and VCPU_STAT definitions in a single place". The former simplifies code duplicated in debugfs and tracefs (from which statsfs is based on), the latter groups all macros definition for statistics in kvm in a single common file shared by all architectures.
Patch 1 adds a new refcount and kref destructor wrappers that take a semaphore, as those are used later by statsfs. Patch 2 introduces the statsfs API, patch 3 provides extensive tests that can also be used as example on how to use the API and patch 4 adds the file system support. Finally, patch 5 provides a real-life example of statsfs usage in KVM.
Emanuele Giuseppe Esposito (5):
refcount, kref: add dec-and-test wrappers for rw_semaphores statsfs API: create, add and remove statsfs sources and values
kunit: tests for statsfs API
statsfs fs: virtual fs to show stats to the end-user
kvm_main: replace debugfs with statsfs
arch/arm64/kvm/guest.c | 2 +- arch/mips/kvm/mips.c | 2 +- arch/powerpc/kvm/book3s.c | 6 +- arch/powerpc/kvm/booke.c | 8 +- arch/s390/kvm/kvm-s390.c | 16 +- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/Makefile | 2 +- arch/x86/kvm/debugfs.c | 64 -- arch/x86/kvm/statsfs.c | 49 ++ arch/x86/kvm/x86.c | 6 +- fs/Kconfig | 13 + fs/Makefile | 1 + fs/statsfs/Makefile | 6 + fs/statsfs/inode.c | 337 ++++++++++ fs/statsfs/internal.h | 35 + fs/statsfs/statsfs-tests.c | 1067 +++++++++++++++++++++++++++++++ fs/statsfs/statsfs.c | 780 ++++++++++++++++++++++ include/linux/kref.h | 11 + include/linux/kvm_host.h | 39 +- include/linux/refcount.h | 2 + include/linux/statsfs.h | 234 +++++++ include/uapi/linux/magic.h | 1 + lib/refcount.c | 32 + tools/lib/api/fs/fs.c | 21 + virt/kvm/arm/arm.c | 2 +- virt/kvm/kvm_main.c | 314 ++------- 26 files changed, 2670 insertions(+), 382 deletions(-) delete mode 100644 arch/x86/kvm/debugfs.c create mode 100644 arch/x86/kvm/statsfs.c create mode 100644 fs/statsfs/Makefile create mode 100644 fs/statsfs/inode.c create mode 100644 fs/statsfs/internal.h create mode 100644 fs/statsfs/statsfs-tests.c create mode 100644 fs/statsfs/statsfs.c create mode 100644 include/linux/statsfs.h
Signature · 1 line
2.25.2
RFC PATCH 1/5 refcount, kref: add dec-and-test wrappers for rw_semaphores
Similar to the existing functions that take a mutex or spinlock if and only if a reference count is decremented to zero, these new function take an rwsem for writing just before the refcount reaches 0 (and call a user-provided function in the case of kref_put_rwsem).
These will be used for statsfs_source data structures, which are protected by an rw_semaphore to allow concurrent sysfs reads.
--- include/linux/kref.h | 11 +++++++++++ include/linux/refcount.h | 2 ++ lib/refcount.c | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 45 insertions(+)
include/linux/kref.h +11 -0
@@ -79,6 +79,17 @@ static inline int kref_put_mutex(struct kref *kref,return 0 ; } +static inline int kref_put_rwsem (struct kref *kref, +void (*release)(struct kref *kref), +struct rw_semaphore *rwsem) +{ +if (refcount_dec_and_down_write (&kref->refcount, rwsem)) { +release (kref); +return 1 ; + } +return 0 ; +} +static inline int kref_put_lock (struct kref *kref,void (*release)(struct kref *kref),spinlock_t *lock)
include/linux/refcount.h +2 -0
@@ -99,6 +99,7 @@#include <linux/spinlock_types.h> struct mutex ; +struct rw_semaphore ;/** * struct refcount_t - variant of atomic_t specialized for reference counts
@@ -313,6 +314,7 @@ static inline void refcount_dec(refcount_t *r)extern __must_check bool refcount_dec_if_one (refcount_t *r);extern __must_check bool refcount_dec_not_one (refcount_t *r);extern __must_check bool refcount_dec_and_mutex_lock (refcount_t *r,struct mutex *lock); +extern __must_check bool refcount_dec_and_down_write (refcount_t *r,struct rw_semaphore *rwsem);extern __must_check bool refcount_dec_and_lock (refcount_t *r,spinlock_t *lock); extern __must_check bool refcount_dec_and_lock_irqsave(refcount_t *r, spinlock_t *lock,
lib/refcount.c +32 -0
@@ -4,6 +4,7 @@*/ #include <linux/mutex.h> +#include <linux/rwsem.h> #include <linux/refcount.h> #include <linux/spinlock.h> #include <linux/bug.h>
@@ -94,6 +95,37 @@ bool refcount_dec_not_one(refcount_t *r) }EXPORT_SYMBOL (refcount_dec_not_one); +/** +* refcount_dec_and_down_write - return holding rwsem for writing if able to decrement +* refcount to 0 +* @r: the refcount +* @lock: the mutex to be locked +* +* Similar to atomic_dec_and_mutex_lock(), it will WARN on underflow and fail +* to decrement when saturated at REFCOUNT_SATURATED. +* +* Provides release memory ordering, such that prior loads and stores are done +* before, and provides a control dependency such that free() must come after. +* See the comment on top. +* +* Return: true and hold rwsem for writing if able to decrement refcount to 0, false +* otherwise +*/ +bool refcount_dec_and_down_write (refcount_t *r,struct rw_semaphore *lock) +{ +if (refcount_dec_not_one (r)) +return false; + +down_write (lock); +if (!refcount_dec_and_test (r)) { +up_write (lock); +return false; + } + +return true; +} +EXPORT_SYMBOL (refcount_dec_and_down_write); +/** * refcount_dec_and_mutex_lock - return holding mutex if able to decrement * refcount to 0
Signature · 1 line
2.25.2
RFC PATCH 2/5 statsfs API: create, add and remove statsfs sources and values
In reply to Emanuele Giuseppe EspositoIntroduction to the statsfs API, that allows to easily create, add and remove statsfs sources and values. The API allows to easily building the statistics directory tree to automatically gather them for the linux kernel. The main functionalities are: create a source, add child sources/values/aggregates, register it to the root source (that on the virtual fs would be /sys/kernel/statsfs), ad perform a search for a value/aggregate.
This allows creating any kind of source tree, making it more flexible also to future readjustments.
The API representation is only logical and will be backed up by a virtual file system in patch 4.
Its usage will be shared between the statsfs file system and the end-users like kvm, the former calling it when it needs to display and clear statistics, the latter to add values and sources.
--- fs/Kconfig | 7 + fs/Makefile | 1 + fs/statsfs/Makefile | 4 + fs/statsfs/internal.h | 20 ++ fs/statsfs/statsfs.c | 618 ++++++++++++++++++++++++++++++++++++++++ include/linux/statsfs.h | 222 +++++++++++++++ 6 files changed, 872 insertions(+) create mode 100644 fs/statsfs/Makefile create mode 100644 fs/statsfs/internal.h create mode 100644 fs/statsfs/statsfs.c create mode 100644 include/linux/statsfs.h
fs/Kconfig +7 -0
@@ -328,4 +328,11 @@ source "fs/unicode/Kconfig" config IO_WQ bool +config STATS_FS + bool "Statistics Filesystem" + default y + help + statsfs is a virtual file system that provides counters and other + statistics about the running kernel. + endmenu
fs/Makefile +1 -0
@@ -125,6 +125,7 @@ obj-$(CONFIG_BEFS_FS) += befs/ obj-$(CONFIG_HOSTFS) += hostfs/ obj-$(CONFIG_CACHEFILES) += cachefiles/ obj-$(CONFIG_DEBUG_FS) += debugfs/ +obj-$(CONFIG_STATS_FS) += statsfs/ obj-$(CONFIG_TRACING) += tracefs/ obj-$(CONFIG_OCFS2_FS) += ocfs2/ obj-$(CONFIG_BTRFS_FS) += btrfs/
fs/statsfs/Makefile new file +4 -0
@@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0-only +statsfs-objs := statsfs.o + +obj-$(CONFIG_STATS_FS) += statsfs.o
fs/statsfs/internal.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _STATSFS_INTERNAL_H_ +#define _STATSFS_INTERNAL_H_ + +#include <linux/list.h> +#include <linux/kref.h> +#include <linux/rwsem.h> +#include <linux/statsfs.h> + +/* values, grouped by base */ +struct statsfs_value_source { +void *base_addr; +bool files_created; +struct statsfs_value *values; +struct list_head list_element; +}; + +int statsfs_val_get_mode (struct statsfs_value *val); + +#endif /* _STATSFS_INTERNAL_H_ */
fs/statsfs/statsfs.c new file +618 -0
618 lines not on this page · raw message
include/linux/statsfs.h new file +222 -0
222 lines not on this page · raw message
Signature · 1 line
2.25.2
Re: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
fs/statsfs/statsfs.c line 37
Quoted 8 lines · Emanuele Giuseppe Esposito
fs/statsfs/statsfs.c new file +8
-0+static struct statsfs_value *find_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) { +if (entry == val) { +WARN_ON (strcmp (entry->name, val->name) !=0 );
Umm. 'entry' and 'val' are pointers. So if entry is equal to val, how could entry->name and val->name not be the same thing?
fs/statsfs/statsfs.c line 73
Quoted 12 lines
fs/statsfs/statsfs.c new file +12
-0+/* Called with rwsem held for writing */ +static struct statsfs_value_source *create_value_source (void *base) +{ +struct statsfs_value_source *val_src; + + val_src =kzalloc (sizeof (struct statsfs_value_source ),GFP_KERNEL ); +if (!val_src) +return ERR_PTR (-ENOMEM ); + + val_src->base_addr = base; + val_src->list_element = + (struct list_head )LIST_HEAD_INIT (val_src->list_element);
This is not how LIST_HEAD_INIT is generally used, but see below.
Quoted 12 lines
fs/statsfs/statsfs.c new file +12
-0+int statsfs_source_add_values (struct statsfs_source *source, +struct statsfs_value *stat,void *ptr) +{ +struct statsfs_value_source *val_src; +struct statsfs_value_source *entry; + +down_write (&source->rwsem); + +list_for_each_entry (entry, &source->values_head, list_element) { +if (entry->base_addr == ptr && entry->values == stat) { +up_write (&source->rwsem); +return -EEXIST ;
fs/statsfs/statsfs.c line 99
Quoted 10 lines
fs/statsfs/statsfs.c new file +10
-0+ } + } + + val_src =create_value_source (ptr); + val_src->values = (struct statsfs_value *)stat; + +/* add the val_src to the source list */ +list_add (&val_src->list_element, &source->values_head); + +up_write (&source->rwsem);
I dislike this use of doubly linked lists. I would suggest using an allocating XArray to store your values. Something like this:
+int statsfs_source_add_values(struct statsfs_source *source,
+ struct statsfs_value *stat, void *ptr)
+{
+ struct statsfs_value_source *entry, *val_src;
+ unsigned long index;
+ int err = -EEXIST;
+
+ val_src = create_value_source(ptr);
+ val_src->values = stat;
+
+ xa_lock(&source->values);
+ xa_for_each(&source->values, index, entry) {
+ if (entry->base_addr == ptr && entry->values == stat)
+ goto out;
+ }
+
+ err = __xa_alloc(&source->values, &val_src->id, val_src, xa_limit_32b,
+ GFP_KERNEL);
+out:
+ xa_unlock(&source->values);
+ if (err)
+ kfree(val_src);
+ return err;
+}
Using an XArray avoids the occasional latency problems you can see with rwsems, as well as being more cache-effective than a linked list.
Re: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
Quoted 12 lines · Matthew Wilcox
fs/statsfs/statsfs.c line 37
Quoted 8 lines · Emanuele Giuseppe Esposito
fs/statsfs/statsfs.c new file +8
-0+static struct statsfs_value *find_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) { +if (entry == val) { +WARN_ON (strcmp (entry->name, val->name) !=0 );Umm. 'entry' and 'val' are pointers. So if entry is equal to val, how could
entry->nameandval->namenot be the same thing?
Good catch, I'll get rid of that check.
Quoted 27 lines
(quoted diff) +24
-0+int statsfs_source_add_values(struct statsfs_source *source, + struct statsfs_value *stat, void *ptr) +{ + struct statsfs_value_source *entry, *val_src; + unsigned long index; + int err = -EEXIST; + + val_src = create_value_source(ptr); + val_src->values = stat; + + xa_lock(&source->values); + xa_for_each(&source->values, index, entry) { + if (entry->base_addr == ptr && entry->values == stat) + goto out; + } + + err = __xa_alloc(&source->values, &val_src->id, val_src, xa_limit_32b, + GFP_KERNEL); +out: + xa_unlock(&source->values); + if (err) + kfree(val_src); + return err; +}
Quoted 2 lines
Using an XArray avoids the occasional latency problems you can see with rwsems, as well as being more cache-effective than a linked list.
I didn't know about XArrays, I'll give them a look. I will also fix the list initialization with INIT_LIST_HEAD.
Thank you for the above example, but I don't think that each source would have more than 2 or 3 value_sources, so using a linked list there should be fine. However, this might be a good point for the subordinates list.
Regarding the locking, the rwsem is also used to protect the other lists and dentry of the source, so it wouldn't be removed anyways.
Thank you,
Emanuele
RFC PATCH 2/5 statsfs API: create, add and remove statsfs
In reply to Matthew WilcoxHi Mattew,
I am trying to apply your Xarrays suggestion, but I don't understand how to make them properly work. In particular, the __xa_alloc function always returns -EINVAL.
I tried to follow the Xarrays kernel doc and the example you provided to replace the subordinates linked list, but alloc always returns that error.
Below you can find the changes I intended to do.
Can you help me?
Thank you,
Emanuele
------ 8< -----------
From ad5d20b6ce7995b2d1164104cf958f7bc3e692fa Mon Sep 17 00:00:00 2001
From: Emanuele Giuseppe Esposito <[email protected]>
Date: Tue, 28 Apr 2020 12:21:00 +0200
Subject: [PATCH] statsfs: switch subordinate sources to xarray
--- fs/statsfs/statsfs.c | 45 +++++++++++++++++++++++++++-------------- include/linux/statsfs.h | 5 ++--- 2 files changed, 32 insertions(+), 18 deletions(-)
fs/statsfs/statsfs.c +30 -15
@@ -107,11 +107,12 @@ const struct file_operations statsfs_ops = {static void statsfs_source_remove_files_locked (struct statsfs_source *src) {struct statsfs_source *child; +unsigned long index;if (src->source_dentry ==NULL )return ; -list_for_each_entry (child, &src->subordinates_head, list_element) + xa_for_each (&src->subordinates, index, child)statsfs_source_remove_files (child);statsfs_remove_recursive (src->source_dentry);
@@ -180,6 +181,7 @@ static void statsfs_create_files_recursive_locked(struct statsfs_source *source, struct dentry *parent_dentry) {struct statsfs_source *child; +unsigned long index;/* first check values in this folder, since it might be new */ if (!source->source_dentry) {
@@ -189,7 +191,7 @@ static void statsfs_create_files_recursive_locked(struct statsfs_source *source,statsfs_create_files_locked (source); -list_for_each_entry (child, &source->subordinates_head, list_element) { + xa_for_each (&source->subordinates, index, child) {if (child->source_dentry ==NULL ) {/* assume that if child has a folder, * also the sub-child have that.
@@ -258,10 +260,23 @@ EXPORT_SYMBOL_GPL(statsfs_source_add_values);void statsfs_source_add_subordinate (struct statsfs_source *source,struct statsfs_source *sub) { +int err; +uint32_t index; +down_write (&source->rwsem);statsfs_source_get (sub); -list_add (&sub->list_element, &source->subordinates_head); + err =__xa_alloc (&source->subordinates, &index, sub, xa_limit_32b, +GFP_KERNEL ); + +if (err) { +printk (KERN_ERR "Failed to insert subordinate %s\n" +"Too many subordinates in source %s\n" , + sub->name, source->name); +up_write (&source->rwsem); +return ; + } +if (source->source_dentry)statsfs_create_files_recursive_locked (sub, source->source_dentry);
@@ -276,10 +291,11 @@ statsfs_source_remove_subordinate_locked(struct statsfs_source *source, struct statsfs_source *sub) {struct statsfs_source *src_entry; +unsigned long index; -list_for_each_entry (src_entry, &source->subordinates_head, list_element) { + xa_for_each (&source->subordinates, index, src_entry) {if (src_entry == sub) { -list_del_init (&src_entry->list_element); +xa_erase (&source->subordinates, index);statsfs_source_remove_files (src_entry);statsfs_source_put (src_entry);return ;
@@ -431,13 +447,13 @@ static void do_recursive_aggregation(struct statsfs_source *root, struct statsfs_aggregate_value *agg) {struct statsfs_source *subordinate; +unsigned long index;/* search all simple values in this folder */ search_all_simple_values (root, ref_src_entry, val, agg);/* recursively search in all subfolders */ -list_for_each_entry (subordinate, &root->subordinates_head, - list_element) { + xa_for_each (&root->subordinates, index, subordinate) {down_read (&subordinate->rwsem);do_recursive_aggregation (subordinate, ref_src_entry, val, agg);up_read (&subordinate->rwsem);
@@ -571,13 +587,13 @@ static void do_recursive_clean(struct statsfs_source *root, struct statsfs_value *val) {struct statsfs_source *subordinate; +unsigned long index;/* search all simple values in this folder */ set_all_simple_values (root, ref_src_entry, val);/* recursively search in all subfolders */ -list_for_each_entry (subordinate, &root->subordinates_head, - list_element) { + xa_for_each (&root->subordinates, index, subordinate) {down_read (&subordinate->rwsem);do_recursive_clean (subordinate, ref_src_entry, val);up_read (&subordinate->rwsem);
@@ -703,9 +719,10 @@ EXPORT_SYMBOL_GPL(statsfs_source_revoke);*/ static void statsfs_source_destroy (struct kref *kref_source) { -struct statsfs_value_source *val_src_entry;struct list_head *it, *safe; +struct statsfs_value_source *val_src_entry;struct statsfs_source *child, *source; +unsigned long index; source = container_of(kref_source, struct statsfs_source, refcount);
@@ -717,15 +734,14 @@ static void statsfs_source_destroy(struct kref *kref_source) }/* iterate through the subordinates and delete them */ -list_for_each_safe (it, safe, &source->subordinates_head) { - child = list_entry(it, struct statsfs_source, list_element); + xa_for_each (&source->subordinates, index, child)statsfs_source_remove_subordinate_locked (source, child); - }statsfs_source_remove_files_locked (source);up_write (&source->rwsem);kfree (source->name); +xa_destroy (&source->subordinates);kfree (source); }
@@ -761,8 +777,7 @@ struct statsfs_source *statsfs_source_create(const char *fmt, ...)init_rwsem (&ret->rwsem);INIT_LIST_HEAD (&ret->values_head); -INIT_LIST_HEAD (&ret->subordinates_head); -INIT_LIST_HEAD (&ret->list_element); +xa_init (&ret->subordinates);return ret; }
include/linux/statsfs.h +2 -3
@@ -11,6 +11,7 @@#define _STATSFS_H_#include <linux/list.h> +#include <linux/xarray.h> /* Used to distinguish signed types */ #define STATSFS_SIGN 0x8000
@@ -64,9 +65,7 @@ struct statsfs_source {struct list_head values_head;/* list of struct statsfs_source for subordinate sources */ -struct list_head subordinates_head; - -struct list_head list_element; +struct xarray subordinates;struct rw_semaphore rwsem;
Signature · 1 line
2.25.2
Re: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
In reply to Emanuele Giuseppe EspositoQuoted 3 lines · Emanuele Giuseppe Esposito
Introduction to the statsfs API, that allows to easily create, add and remove statsfs sources and values.
Not a huge issue, but IMHO the "statsfs" name is confusingly similar to the existing "statfs" function name. Could you name this interface something more distinct? Even "fs_stats" or "stats_fs" or similar would at least be visibly different.
Cheers, Andreas
Quoted 947 lines
The API allows to easily building
the statistics directory tree to automatically gather them for the linux kernel. The main functionalities are: create a source, add child sources/values/aggregates, register it to the root source (that on the virtual fs would be/sys/kernel/statsfs), ad perform a search for a value/aggregate.This allows creating any kind of source tree, making it more flexible also to future readjustments.
The API representation is only logical and will be backed up by a virtual file system in patch 4.
Its usage will be shared between the statsfs file system and the end-users like kvm, the former calling it when it needs to display and clear statistics, the latter to add values and sources.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
fs/Kconfig | 7 + fs/Makefile | 1 + fs/statsfs/Makefile | 4 + fs/statsfs/internal.h | 20 ++ fs/statsfs/statsfs.c | 618 ++++++++++++++++++++++++++++++++++++++++ include/linux/statsfs.h | 222 +++++++++++++++ 6 files changed, 872 insertions(+)create mode 100644
fs/statsfs/Makefile
create mode 100644fs/statsfs/internal.h
create mode 100644fs/statsfs/statsfs.c
create mode 100644include/linux/statsfs.hfs/Kconfig +0
-0@@ -328,4 +328,11 @@ source "fs/unicode/Kconfig"config
IO_WQ
boolfs/Kconfig +7
-0+config STATS_FS + bool "Statistics Filesystem" + default y + help + statsfs is a virtual file system that provides counters and other + statistics about the running kernel. +endmenu
fs/Makefile +0
-0@@ -125,6 +125,7 @@ obj-$(CONFIG_BEFS_FS) += befs/obj-$(CONFIG_HOSTFS) += hostfs/
obj-$(CONFIG_CACHEFILES) += cachefiles/
obj-$(CONFIG_DEBUG_FS) += debugfs/
+obj-$(CONFIG_STATS_FS) += statsfs/
obj-$(CONFIG_TRACING) += tracefs/
obj-$(CONFIG_OCFS2_FS) += ocfs2/
obj-$(CONFIG_BTRFS_FS) += btrfs/fs/statsfs/Makefile new file +4
-0@@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0-only +statsfs-objs := statsfs.o + +obj-$(CONFIG_STATS_FS) += statsfs.ofs/statsfs/internal.h new file +20
-0@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _STATSFS_INTERNAL_H_ +#define _STATSFS_INTERNAL_H_ + +#include <linux/list.h> +#include <linux/kref.h> +#include <linux/rwsem.h> +#include <linux/statsfs.h> + +/* values, grouped by base */ +struct statsfs_value_source { +void *base_addr; +bool files_created; +struct statsfs_value *values; +struct list_head list_element; +}; + +int statsfs_val_get_mode (struct statsfs_value *val); + +#endif /* _STATSFS_INTERNAL_H_ */ fs/statsfs/statsfs.c new file +618
-0@@ -0,0 +1,618 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/module.h> +#include <linux/errno.h> +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/slab.h> +#include <linux/rwsem.h> +#include <linux/list.h> +#include <linux/kref.h> +#include <linux/limits.h> +#include <linux/statsfs.h> + +#include "internal.h" + +struct statsfs_aggregate_value { +uint64_t sum, min, max; +uint32_t count, count_zero; +}; + +static int is_val_signed (struct statsfs_value *val) +{ +return val->type &STATSFS_SIGN ; +} + +int statsfs_val_get_mode (struct statsfs_value *val) +{ +return val->mode ? val->mode :0644 ; +} + +static struct statsfs_value *find_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) { +if (entry == val) { +WARN_ON (strcmp (entry->name, val->name) !=0 ); +return entry; + } + } +return NULL ; +} + +static struct statsfs_value * +search_value_in_source (struct statsfs_source *src,struct statsfs_value *arg, +struct statsfs_value_source **val_src) +{ +struct statsfs_value *entry; +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { + entry =find_value (src_entry, arg); +if (entry) { + *val_src = src_entry; +return entry; + } + } + +return NULL ; +} + +/* Called with rwsem held for writing */ +static struct statsfs_value_source *create_value_source (void *base) +{ +struct statsfs_value_source *val_src; + + val_src =kzalloc (sizeof (struct statsfs_value_source ),GFP_KERNEL ); +if (!val_src) +return ERR_PTR (-ENOMEM ); + + val_src->base_addr = base; + val_src->list_element = + (struct list_head )LIST_HEAD_INIT (val_src->list_element); + +return val_src; +} + +int statsfs_source_add_values (struct statsfs_source *source, +struct statsfs_value *stat,void *ptr) +{ +struct statsfs_value_source *val_src; +struct statsfs_value_source *entry; + +down_write (&source->rwsem); + +list_for_each_entry (entry, &source->values_head, list_element) { +if (entry->base_addr == ptr && entry->values == stat) { +up_write (&source->rwsem); +return -EEXIST ; + } + } + + val_src =create_value_source (ptr); + val_src->values = (struct statsfs_value *)stat; + +/* add the val_src to the source list */ +list_add (&val_src->list_element, &source->values_head); + +up_write (&source->rwsem); + +return 0 ; +} +EXPORT_SYMBOL_GPL (statsfs_source_add_values); + +void statsfs_source_add_subordinate (struct statsfs_source *source, +struct statsfs_source *sub) +{ +down_write (&source->rwsem); + +statsfs_source_get (sub); +list_add (&sub->list_element, &source->subordinates_head); + +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_add_subordinate); + +/* Called with rwsem held for writing */ +static void +statsfs_source_remove_subordinate_locked (struct statsfs_source *source, +struct statsfs_source *sub) +{ +struct list_head *it, *safe; +struct statsfs_source *src_entry; + +list_for_each_safe (it, safe, &source->subordinates_head) { + src_entry = list_entry(it, struct statsfs_source, list_element); +if (src_entry == sub) { +WARN_ON (strcmp (src_entry->name, sub->name) !=0 ); +list_del_init (&src_entry->list_element); +statsfs_source_put (src_entry); +return ; + } + } +} + +void statsfs_source_remove_subordinate (struct statsfs_source *source, +struct statsfs_source *sub) +{ +down_write (&source->rwsem); +statsfs_source_remove_subordinate_locked (source, sub); +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_remove_subordinate); + +/* Called with rwsem held for reading */ +static uint64_t get_simple_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +uint64_t value_found; +void *address; + + address = src->base_addr + val->offset; + +switch (val->type) { +case STATSFS_U8 : + value_found = *((uint8_t *)address); +break ; +case STATSFS_U8 |STATSFS_SIGN : + value_found = *((int8_t *)address); +break ; +case STATSFS_U16 : + value_found = *((uint16_t *)address); +break ; +case STATSFS_U16 |STATSFS_SIGN : + value_found = *((int16_t *)address); +break ; +case STATSFS_U32 : + value_found = *((uint32_t *)address); +break ; +case STATSFS_U32 |STATSFS_SIGN : + value_found = *((int32_t *)address); +break ; +case STATSFS_U64 : + value_found = *((uint64_t *)address); +break ; +case STATSFS_U64 |STATSFS_SIGN : + value_found = *((int64_t *)address); +break ; +case STATSFS_BOOL : + value_found = *((uint8_t *)address); +break ; +default : + value_found =0 ; +break ; + } + +return value_found; +} + +/* Called with rwsem held for reading */ +static void clear_simple_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +void *address; + + address = src->base_addr + val->offset; + +switch (val->type) { +case STATSFS_U8 : + *((uint8_t *)address) =0 ; +break ; +case STATSFS_U8 |STATSFS_SIGN : + *((int8_t *)address) =0 ; +break ; +case STATSFS_U16 : + *((uint16_t *)address) =0 ; +break ; +case STATSFS_U16 |STATSFS_SIGN : + *((int16_t *)address) =0 ; +break ; +case STATSFS_U32 : + *((uint32_t *)address) =0 ; +break ; +case STATSFS_U32 |STATSFS_SIGN : + *((int32_t *)address) =0 ; +break ; +case STATSFS_U64 : + *((uint64_t *)address) =0 ; +break ; +case STATSFS_U64 |STATSFS_SIGN : + *((int64_t *)address) =0 ; +break ; +case STATSFS_BOOL : + *((uint8_t *)address) =0 ; +break ; +default : +break ; + } +} + +/* Called with rwsem held for reading */ +static void search_all_simple_values (struct statsfs_source *src, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val, +struct statsfs_aggregate_value *agg) +{ +struct statsfs_value_source *src_entry; +uint64_t value_found; + +list_for_each_entry (src_entry, &src->values_head, list_element) { +/* skip aggregates */ +if (src_entry->base_addr ==NULL ) +continue ; + +/* useless to search here */ +if (src_entry->values != ref_src_entry->values) +continue ; + +/* must be here */ + value_found =get_simple_value (src_entry, val); + agg->sum += value_found; + agg->count++; + agg->count_zero += (value_found ==0 ); + +if (is_val_signed (val)) { + agg->max = (((int64_t )value_found) >= + ((int64_t )agg->max)) ? + value_found : + agg->max; + agg->min = (((int64_t )value_found) <= + ((int64_t )agg->min)) ? + value_found : + agg->min; + }else { + agg->max = (value_found >= agg->max) ? value_found : + agg->max; + agg->min = (value_found <= agg->min) ? value_found : + agg->min; + } + } +} + +/* Called with rwsem held for reading */ +static void do_recursive_aggregation (struct statsfs_source *root, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val, +struct statsfs_aggregate_value *agg) +{ +struct statsfs_source *subordinate; + +/* search all simple values in this folder */ +search_all_simple_values (root, ref_src_entry, val, agg); + +/* recursively search in all subfolders */ +list_for_each_entry (subordinate, &root->subordinates_head, + list_element) { +down_read (&subordinate->rwsem); +do_recursive_aggregation (subordinate, ref_src_entry, val, agg); +up_read (&subordinate->rwsem); + } +} + +/* Called with rwsem held for reading */ +static void init_aggregate_value (struct statsfs_aggregate_value *agg, +struct statsfs_value *val) +{ + agg->count = agg->count_zero = agg->sum =0 ; +if (is_val_signed (val)) { + agg->max =S64_MIN ; + agg->min =S64_MAX ; + }else { + agg->max =0 ; + agg->min =U64_MAX ; + } +} + +/* Called with rwsem held for reading */ +static void store_final_value (struct statsfs_aggregate_value *agg, +struct statsfs_value *val,uint64_t *ret) +{ +int operation; + + operation = val->aggr_kind |is_val_signed (val); + +switch (operation) { +case STATSFS_AVG : + *ret = agg->count ? agg->sum / agg->count :0 ; +break ; +case STATSFS_AVG |STATSFS_SIGN : + *ret = agg->count ? ((int64_t )agg->sum) / agg->count :0 ; +break ; +case STATSFS_SUM : +case STATSFS_SUM |STATSFS_SIGN : + *ret = agg->sum; +break ; +case STATSFS_MIN : +case STATSFS_MIN |STATSFS_SIGN : + *ret = agg->min; +break ; +case STATSFS_MAX : +case STATSFS_MAX |STATSFS_SIGN : + *ret = agg->max; +break ; +case STATSFS_COUNT_ZERO : +case STATSFS_COUNT_ZERO |STATSFS_SIGN : + *ret = agg->count_zero; +break ; +default : +break ; + } +} + +/* Called with rwsem held for reading */ +static int statsfs_source_get_value_locked (struct statsfs_source *source, +struct statsfs_value *arg, +uint64_t *ret) +{ +struct statsfs_value_source *src_entry; +struct statsfs_value *found; +struct statsfs_aggregate_value aggr; + + *ret =0 ; + +if (!arg) +return -ENOENT ; + +/* look in simple values */ + found =search_value_in_source (source, arg, &src_entry); + +if (!found) { +printk (KERN_ERR "Statsfs: Value in source \"%s\" not found!\n" , + source->name); +return -ENOENT ; + } + +if (src_entry->base_addr !=NULL ) { + *ret =get_simple_value (src_entry, found); +return 0 ; + } + +/* look in aggregates */ +init_aggregate_value (&aggr, found); +do_recursive_aggregation (source, src_entry, found, &aggr); +store_final_value (&aggr, found, ret); + +return 0 ; +} + +int statsfs_source_get_value (struct statsfs_source *source, +struct statsfs_value *arg,uint64_t *ret) +{ +int retval; + +down_read (&source->rwsem); + retval =statsfs_source_get_value_locked (source, arg, ret); +up_read (&source->rwsem); + +return retval; +} +EXPORT_SYMBOL_GPL (statsfs_source_get_value); + +/* Called with rwsem held for reading */ +static void set_all_simple_values (struct statsfs_source *src, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val) +{ +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { +/* skip aggregates */ +if (src_entry->base_addr ==NULL ) +continue ; + +/* wrong to search here */ +if (src_entry->values != ref_src_entry->values) +continue ; + +if (src_entry->base_addr && + src_entry->values == ref_src_entry->values) +clear_simple_value (src_entry, val); + } +} + +/* Called with rwsem held for reading */ +static void do_recursive_clean (struct statsfs_source *root, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val) +{ +struct statsfs_source *subordinate; + +/* search all simple values in this folder */ +set_all_simple_values (root, ref_src_entry, val); + +/* recursively search in all subfolders */ +list_for_each_entry (subordinate, &root->subordinates_head, + list_element) { +down_read (&subordinate->rwsem); +do_recursive_clean (subordinate, ref_src_entry, val); +up_read (&subordinate->rwsem); + } +} + +/* Called with rwsem held for reading */ +static int statsfs_source_clear_locked (struct statsfs_source *source, +struct statsfs_value *val) +{ +struct statsfs_value_source *src_entry; +struct statsfs_value *found; + +if (!val) +return -ENOENT ; + +/* look in simple values */ + found =search_value_in_source (source, val, &src_entry); + +if (!found) { +printk (KERN_ERR "Statsfs: Value in source \"%s\" not found!\n" , + source->name); +return -ENOENT ; + } + +if (src_entry->base_addr !=NULL ) { +clear_simple_value (src_entry, found); +return 0 ; + } + +/* look in aggregates */ +do_recursive_clean (source, src_entry, found); + +return 0 ; +} + +int statsfs_source_clear (struct statsfs_source *source, +struct statsfs_value *val) +{ +int retval; + +down_read (&source->rwsem); + retval =statsfs_source_clear_locked (source, val); +up_read (&source->rwsem); + +return retval; +} + +/* Called with rwsem held for reading */ +static struct statsfs_value * +find_value_by_name (struct statsfs_value_source *src,char *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) +if (!strcmp (entry->name, val)) +return entry; + +return NULL ; +} + +/* Called with rwsem held for reading */ +static struct statsfs_value * +search_in_source_by_name (struct statsfs_source *src,char *name) +{ +struct statsfs_value *entry; +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { + entry =find_value_by_name (src_entry, name); +if (entry) +return entry; + } + +return NULL ; +} + +int statsfs_source_get_value_by_name (struct statsfs_source *source,char *name, +uint64_t *ret) +{ +struct statsfs_value *val; +int retval; + +down_read (&source->rwsem); + val =search_in_source_by_name (source, name); + +if (!val) { + *ret =0 ; +up_read (&source->rwsem); +return -ENOENT ; + } + + retval =statsfs_source_get_value_locked (source, val, ret); +up_read (&source->rwsem); + +return retval; +} +EXPORT_SYMBOL_GPL (statsfs_source_get_value_by_name); + +void statsfs_source_get (struct statsfs_source *source) +{ +kref_get (&source->refcount); +} +EXPORT_SYMBOL_GPL (statsfs_source_get); + +void statsfs_source_revoke (struct statsfs_source *source) +{ +struct list_head *it, *safe; +struct statsfs_value_source *val_src_entry; + +down_write (&source->rwsem); + +list_for_each_safe (it, safe, &source->values_head) { + val_src_entry = list_entry(it, struct statsfs_value_source, + list_element); + val_src_entry->base_addr =NULL ; + } + +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_revoke); + +/* Called with rwsem held for writing +* +* The refcount is 0 and the lock was taken before refcount +* went from 1 to 0 +*/ +static void statsfs_source_destroy (struct kref *kref_source) +{ +struct statsfs_value_source *val_src_entry; +struct list_head *it, *safe; +struct statsfs_source *child, *source; + + source = container_of(kref_source, struct statsfs_source, refcount); + +/* iterate through the values and delete them */ +list_for_each_safe (it, safe, &source->values_head) { + val_src_entry = list_entry(it, struct statsfs_value_source, + list_element); +kfree (val_src_entry); + } + +/* iterate through the subordinates and delete them */ +list_for_each_safe (it, safe, &source->subordinates_head) { + child = list_entry(it, struct statsfs_source, list_element); +statsfs_source_remove_subordinate_locked (source, child); + } + + +up_write (&source->rwsem); +kfree (source->name); +kfree (source); +} + +void statsfs_source_put (struct statsfs_source *source) +{ +kref_put_rwsem (&source->refcount, statsfs_source_destroy, + &source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_put); + +struct statsfs_source *statsfs_source_create (const char *fmt, ...) +{ +va_list ap; +char buf[100 ]; +struct statsfs_source *ret; +int char_needed; + +va_start (ap, fmt); + char_needed =vsnprintf (buf,100 , fmt, ap); +va_end (ap); + + ret =kzalloc (sizeof (struct statsfs_source ),GFP_KERNEL ); +if (!ret) +return ERR_PTR (-ENOMEM ); + + ret->name =kstrdup (buf,GFP_KERNEL ); +if (!ret->name) { +kfree (ret); +return ERR_PTR (-ENOMEM ); + } + +kref_init (&ret->refcount); +init_rwsem (&ret->rwsem); + +INIT_LIST_HEAD (&ret->values_head); +INIT_LIST_HEAD (&ret->subordinates_head); +INIT_LIST_HEAD (&ret->list_element); + +return ret; +} +EXPORT_SYMBOL_GPL (statsfs_source_create);include/linux/statsfs.h new file +222
-1@@ -0,0 +1,222 @@ +/* SPDX-License-Identifier: GPL-2.0 +* +* statsfs.h - a tiny little statistics file system +* +* Copyright (C) 2020 Emanuele Giuseppe Esposito +* Copyright (C) 2020 Redhat. +* +*/ + +#ifndef _STATSFS_H_ +#define _STATSFS_H_ + +#include <linux/list.h> + +/* Used to distinguish signed types */ +#define STATSFS_SIGN 0x8000 + +struct statsfs_source ; + +enum stat_type { +STATSFS_U8 =0 , +STATSFS_U16 =1 , +STATSFS_U32 =2 , +STATSFS_U64 =3 , +STATSFS_BOOL =4 , +STATSFS_S8 =STATSFS_U8 |STATSFS_SIGN , +STATSFS_S16 =STATSFS_U16 |STATSFS_SIGN , +STATSFS_S32 =STATSFS_U32 |STATSFS_SIGN , +STATSFS_S64 =STATSFS_U64 |STATSFS_SIGN , +}; + +enum stat_aggr { +STATSFS_NONE =0 , +STATSFS_SUM , +STATSFS_MIN , +STATSFS_MAX , +STATSFS_COUNT_ZERO , +STATSFS_AVG , +}; + +struct statsfs_value { +/* Name of the stat */ +char *name; + +/* Offset from base address to field containing the value */ +int offset; + +/* Type of the stat BOOL,U64,... */ +enum stat_type type; + +/* Aggregate type: MIN, MAX, SUM,... */ +enum stat_aggr aggr_kind; + +/* File mode */ +uint16_t mode; +}; + +struct statsfs_source { +struct kref refcount; + +char *name; + +/* list of source statsfs_value_source*/ +struct list_head values_head; + +/* list of struct statsfs_source for subordinate sources */ +struct list_head subordinates_head; + +struct list_head list_element; + +struct rw_semaphore rwsem; + +struct dentry *source_dentry; +}; + +/** +* statsfs_source_create - create a statsfs_source +* Creates a statsfs_source with the given name. This +* does not mean it will be backed by the filesystem yet, it will only +* be visible to the user once one of its parents (or itself) are +* registered in statsfs. +* +* Returns a pointer to a statsfs_source if it succeeds. +* This or one of the parents' pointer must be passed to the statsfs_put() +* function when the file is to be removed. If an error occurs, +* ERR_PTR(-ERROR) will be returned. +*/ +struct statsfs_source *statsfs_source_create (const char *fmt, ...); + +/** +* statsfs_source_add_values - adds values to the given source +* @source: a pointer to the source that will receive the values +* @val: a pointer to the NULL terminated statsfs_value array to add +* @base_ptr: a pointer to the base pointer used by these values +* +* In addition to adding values to the source, also create the +* files in the filesystem if the source already is backed up by a directory. +* +* Returns 0 it succeeds. If the value are already in the +* source and have the same base_ptr, -EEXIST is returned. +*/ +int statsfs_source_add_values (struct statsfs_source *source, +struct statsfs_value *val,void *base_ptr); + +/** +* statsfs_source_add_subordinate - adds a child to the given source +* @parent: a pointer to the parent source +* @child: a pointer to child source to add +* +* Recursively create all files in the statsfs filesystem +* only if the parent has already a dentry (created with +* statsfs_source_register). +* This avoids the case where this function is called before register. +*/ +void statsfs_source_add_subordinate (struct statsfs_source *parent, +struct statsfs_source *child); + +/** +* statsfs_source_remove_subordinate - removes a child from the given source +* @parent: a pointer to the parent source +* @child: a pointer to child source to remove +* +* Look if there is such child in the parent. If so, +* it will remove all its files and call statsfs_put on the child. +*/ +void statsfs_source_remove_subordinate (struct statsfs_source *parent, +struct statsfs_source *child); + +/** +* statsfs_source_get_value - search a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @val: a pointer to the statsfs_value to search +* @ret: a pointer to the uint64_t that will hold the found value +* +* Look up in the source if a value with same value pointer +* exists. +* If not, it will return -ENOENT. If it exists and it's a simple value +* (not an aggregate), the value that it points to will be returned. +* If it exists and it's an aggregate (aggr_type != STATSFS_NONE), all +* subordinates will be recursively searched and every simple value match +* will be used to aggregate the final result. For example if it's a sum, +* all suboordinates having the same value will be sum together. +* +* This function will return 0 it succeeds. +*/ +int statsfs_source_get_value (struct statsfs_source *source, +struct statsfs_value *val,uint64_t *ret); + +/** +* statsfs_source_get_value_by_name - search a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @name: a pointer to the string representing the value to search +* (for example "exits") +* @ret: a pointer to the uint64_t that will hold the found value +* +* Same as statsfs_source_get_value, but initially the name is used +* to search in the given source if there is a value with a matching +* name. If so, statsfs_source_get_value will be called with the found +* value, otherwise -ENOENT will be returned. +*/ +int statsfs_source_get_value_by_name (struct statsfs_source *source,char *name, +uint64_t *ret); + +/** +* statsfs_source_clear - search and clears a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @val: a pointer to the statsfs_value to search +* +* Look up in the source if a value with same value pointer +* exists. +* If not, it will return -ENOENT. If it exists and it's a simple value +* (not an aggregate), the value that it points to will be set to 0. +* If it exists and it's an aggregate (aggr_type != STATSFS_NONE), all +* subordinates will be recursively searched and every simple value match +* will be set to 0. +* +* This function will return 0 it succeeds. +*/ +int statsfs_source_clear (struct statsfs_source *source, +struct statsfs_value *val); + +/** +* statsfs_source_revoke - disconnect the source from its backing data +* @source: a pointer to the source that will be revoked +* +* Ensure that statsfs will not access the data that were passed to +* statsfs_source_add_value for this source. +* +* Because open files increase the reference count for a statsfs_source, +* the source can end up living longer than the data that provides the +* values for the source. Calling statsfs_source_revoke just before the +* backing data is freed avoids accesses to freed data structures. The +* sources will return 0. +*/ +void statsfs_source_revoke (struct statsfs_source *source); + +/** +* statsfs_source_get - increases refcount of source +* @source: a pointer to the source whose refcount will be increased +*/ +void statsfs_source_get (struct statsfs_source *source); + +/** +* statsfs_source_put - decreases refcount of source and deletes if needed +* @source: a pointer to the source whose refcount will be decreased +* +* If refcount arrives to zero, take care of deleting +* and free the source resources and files, by firstly recursively calling +* statsfs_source_remove_subordinate to the child and then deleting +* its own files and allocations. +*/ +void statsfs_source_put (struct statsfs_source *source); + +/** +* statsfs_initialized - returns true if statsfs fs has been registered +*/ +bool statsfs_initialized (void ); + +#endif --
Quoted 2 lines
2.25.2
Cheers, Andreas
Re: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
Quoted 9 lines · Andreas Dilger
Quoted 3 lines · Emanuele Giuseppe Esposito
Introduction to the statsfs API, that allows to easily create, add and remove statsfs sources and values.
Not a huge issue, but IMHO the "statsfs" name is confusingly similar to the existing "statfs" function name. Could you name this interface something more distinct? Even "
fs_stats" or "stats_fs" or similar would at least be visibly different.
You're right, thanks for pointing that out. I am going to change all functions and files into stats_fs. The filesystem name, however, will still stay statsfs because it follows the same naming as debugfs/tracecfs/securityfs and won't interfere or be confused with statfs functions.
Thank you,
Emanuele
Quoted 960 lines
Cheers, Andreas
Quoted 947 lines
The API allows to easily building
the statistics directory tree to automatically gather them for the linux kernel. The main functionalities are: create a source, add child sources/values/aggregates, register it to the root source (that on the virtual fs would be/sys/kernel/statsfs), ad perform a search for a value/aggregate.This allows creating any kind of source tree, making it more flexible also to future readjustments.
The API representation is only logical and will be backed up by a virtual file system in patch 4.
Its usage will be shared between the statsfs file system and the end-users like kvm, the former calling it when it needs to display and clear statistics, the latter to add values and sources.Signed-off-by Emanuele Giuseppe Esposito <[email protected]>---
fs/Kconfig | 7 + fs/Makefile | 1 + fs/statsfs/Makefile | 4 + fs/statsfs/internal.h | 20 ++ fs/statsfs/statsfs.c | 618 ++++++++++++++++++++++++++++++++++++++++ include/linux/statsfs.h | 222 +++++++++++++++ 6 files changed, 872 insertions(+)create mode 100644
fs/statsfs/Makefile
create mode 100644fs/statsfs/internal.h
create mode 100644fs/statsfs/statsfs.c
create mode 100644include/linux/statsfs.hfs/Kconfig +0
-0@@ -328,4 +328,11 @@ source "fs/unicode/Kconfig"config
IO_WQ
boolfs/Kconfig +7
-0+config STATS_FS + bool "Statistics Filesystem" + default y + help + statsfs is a virtual file system that provides counters and other + statistics about the running kernel. +endmenu
fs/Makefile +0
-0@@ -125,6 +125,7 @@ obj-$(CONFIG_BEFS_FS) += befs/obj-$(CONFIG_HOSTFS) += hostfs/
obj-$(CONFIG_CACHEFILES) += cachefiles/
obj-$(CONFIG_DEBUG_FS) += debugfs/
+obj-$(CONFIG_STATS_FS) += statsfs/
obj-$(CONFIG_TRACING) += tracefs/
obj-$(CONFIG_OCFS2_FS) += ocfs2/
obj-$(CONFIG_BTRFS_FS) += btrfs/fs/statsfs/Makefile new file +4
-0@@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0-only +statsfs-objs := statsfs.o + +obj-$(CONFIG_STATS_FS) += statsfs.ofs/statsfs/internal.h new file +20
-0@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _STATSFS_INTERNAL_H_ +#define _STATSFS_INTERNAL_H_ + +#include <linux/list.h> +#include <linux/kref.h> +#include <linux/rwsem.h> +#include <linux/statsfs.h> + +/* values, grouped by base */ +struct statsfs_value_source { +void *base_addr; +bool files_created; +struct statsfs_value *values; +struct list_head list_element; +}; + +int statsfs_val_get_mode (struct statsfs_value *val); + +#endif /* _STATSFS_INTERNAL_H_ */ fs/statsfs/statsfs.c new file +618
-0@@ -0,0 +1,618 @@ +// SPDX-License-Identifier: GPL-2.0 +#include <linux/module.h> +#include <linux/errno.h> +#include <linux/file.h> +#include <linux/fs.h> +#include <linux/slab.h> +#include <linux/rwsem.h> +#include <linux/list.h> +#include <linux/kref.h> +#include <linux/limits.h> +#include <linux/statsfs.h> + +#include "internal.h" + +struct statsfs_aggregate_value { +uint64_t sum, min, max; +uint32_t count, count_zero; +}; + +static int is_val_signed (struct statsfs_value *val) +{ +return val->type &STATSFS_SIGN ; +} + +int statsfs_val_get_mode (struct statsfs_value *val) +{ +return val->mode ? val->mode :0644 ; +} + +static struct statsfs_value *find_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) { +if (entry == val) { +WARN_ON (strcmp (entry->name, val->name) !=0 ); +return entry; + } + } +return NULL ; +} + +static struct statsfs_value * +search_value_in_source (struct statsfs_source *src,struct statsfs_value *arg, +struct statsfs_value_source **val_src) +{ +struct statsfs_value *entry; +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { + entry =find_value (src_entry, arg); +if (entry) { + *val_src = src_entry; +return entry; + } + } + +return NULL ; +} + +/* Called with rwsem held for writing */ +static struct statsfs_value_source *create_value_source (void *base) +{ +struct statsfs_value_source *val_src; + + val_src =kzalloc (sizeof (struct statsfs_value_source ),GFP_KERNEL ); +if (!val_src) +return ERR_PTR (-ENOMEM ); + + val_src->base_addr = base; + val_src->list_element = + (struct list_head )LIST_HEAD_INIT (val_src->list_element); + +return val_src; +} + +int statsfs_source_add_values (struct statsfs_source *source, +struct statsfs_value *stat,void *ptr) +{ +struct statsfs_value_source *val_src; +struct statsfs_value_source *entry; + +down_write (&source->rwsem); + +list_for_each_entry (entry, &source->values_head, list_element) { +if (entry->base_addr == ptr && entry->values == stat) { +up_write (&source->rwsem); +return -EEXIST ; + } + } + + val_src =create_value_source (ptr); + val_src->values = (struct statsfs_value *)stat; + +/* add the val_src to the source list */ +list_add (&val_src->list_element, &source->values_head); + +up_write (&source->rwsem); + +return 0 ; +} +EXPORT_SYMBOL_GPL (statsfs_source_add_values); + +void statsfs_source_add_subordinate (struct statsfs_source *source, +struct statsfs_source *sub) +{ +down_write (&source->rwsem); + +statsfs_source_get (sub); +list_add (&sub->list_element, &source->subordinates_head); + +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_add_subordinate); + +/* Called with rwsem held for writing */ +static void +statsfs_source_remove_subordinate_locked (struct statsfs_source *source, +struct statsfs_source *sub) +{ +struct list_head *it, *safe; +struct statsfs_source *src_entry; + +list_for_each_safe (it, safe, &source->subordinates_head) { + src_entry = list_entry(it, struct statsfs_source, list_element); +if (src_entry == sub) { +WARN_ON (strcmp (src_entry->name, sub->name) !=0 ); +list_del_init (&src_entry->list_element); +statsfs_source_put (src_entry); +return ; + } + } +} + +void statsfs_source_remove_subordinate (struct statsfs_source *source, +struct statsfs_source *sub) +{ +down_write (&source->rwsem); +statsfs_source_remove_subordinate_locked (source, sub); +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_remove_subordinate); + +/* Called with rwsem held for reading */ +static uint64_t get_simple_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +uint64_t value_found; +void *address; + + address = src->base_addr + val->offset; + +switch (val->type) { +case STATSFS_U8 : + value_found = *((uint8_t *)address); +break ; +case STATSFS_U8 |STATSFS_SIGN : + value_found = *((int8_t *)address); +break ; +case STATSFS_U16 : + value_found = *((uint16_t *)address); +break ; +case STATSFS_U16 |STATSFS_SIGN : + value_found = *((int16_t *)address); +break ; +case STATSFS_U32 : + value_found = *((uint32_t *)address); +break ; +case STATSFS_U32 |STATSFS_SIGN : + value_found = *((int32_t *)address); +break ; +case STATSFS_U64 : + value_found = *((uint64_t *)address); +break ; +case STATSFS_U64 |STATSFS_SIGN : + value_found = *((int64_t *)address); +break ; +case STATSFS_BOOL : + value_found = *((uint8_t *)address); +break ; +default : + value_found =0 ; +break ; + } + +return value_found; +} + +/* Called with rwsem held for reading */ +static void clear_simple_value (struct statsfs_value_source *src, +struct statsfs_value *val) +{ +void *address; + + address = src->base_addr + val->offset; + +switch (val->type) { +case STATSFS_U8 : + *((uint8_t *)address) =0 ; +break ; +case STATSFS_U8 |STATSFS_SIGN : + *((int8_t *)address) =0 ; +break ; +case STATSFS_U16 : + *((uint16_t *)address) =0 ; +break ; +case STATSFS_U16 |STATSFS_SIGN : + *((int16_t *)address) =0 ; +break ; +case STATSFS_U32 : + *((uint32_t *)address) =0 ; +break ; +case STATSFS_U32 |STATSFS_SIGN : + *((int32_t *)address) =0 ; +break ; +case STATSFS_U64 : + *((uint64_t *)address) =0 ; +break ; +case STATSFS_U64 |STATSFS_SIGN : + *((int64_t *)address) =0 ; +break ; +case STATSFS_BOOL : + *((uint8_t *)address) =0 ; +break ; +default : +break ; + } +} + +/* Called with rwsem held for reading */ +static void search_all_simple_values (struct statsfs_source *src, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val, +struct statsfs_aggregate_value *agg) +{ +struct statsfs_value_source *src_entry; +uint64_t value_found; + +list_for_each_entry (src_entry, &src->values_head, list_element) { +/* skip aggregates */ +if (src_entry->base_addr ==NULL ) +continue ; + +/* useless to search here */ +if (src_entry->values != ref_src_entry->values) +continue ; + +/* must be here */ + value_found =get_simple_value (src_entry, val); + agg->sum += value_found; + agg->count++; + agg->count_zero += (value_found ==0 ); + +if (is_val_signed (val)) { + agg->max = (((int64_t )value_found) >= + ((int64_t )agg->max)) ? + value_found : + agg->max; + agg->min = (((int64_t )value_found) <= + ((int64_t )agg->min)) ? + value_found : + agg->min; + }else { + agg->max = (value_found >= agg->max) ? value_found : + agg->max; + agg->min = (value_found <= agg->min) ? value_found : + agg->min; + } + } +} + +/* Called with rwsem held for reading */ +static void do_recursive_aggregation (struct statsfs_source *root, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val, +struct statsfs_aggregate_value *agg) +{ +struct statsfs_source *subordinate; + +/* search all simple values in this folder */ +search_all_simple_values (root, ref_src_entry, val, agg); + +/* recursively search in all subfolders */ +list_for_each_entry (subordinate, &root->subordinates_head, + list_element) { +down_read (&subordinate->rwsem); +do_recursive_aggregation (subordinate, ref_src_entry, val, agg); +up_read (&subordinate->rwsem); + } +} + +/* Called with rwsem held for reading */ +static void init_aggregate_value (struct statsfs_aggregate_value *agg, +struct statsfs_value *val) +{ + agg->count = agg->count_zero = agg->sum =0 ; +if (is_val_signed (val)) { + agg->max =S64_MIN ; + agg->min =S64_MAX ; + }else { + agg->max =0 ; + agg->min =U64_MAX ; + } +} + +/* Called with rwsem held for reading */ +static void store_final_value (struct statsfs_aggregate_value *agg, +struct statsfs_value *val,uint64_t *ret) +{ +int operation; + + operation = val->aggr_kind |is_val_signed (val); + +switch (operation) { +case STATSFS_AVG : + *ret = agg->count ? agg->sum / agg->count :0 ; +break ; +case STATSFS_AVG |STATSFS_SIGN : + *ret = agg->count ? ((int64_t )agg->sum) / agg->count :0 ; +break ; +case STATSFS_SUM : +case STATSFS_SUM |STATSFS_SIGN : + *ret = agg->sum; +break ; +case STATSFS_MIN : +case STATSFS_MIN |STATSFS_SIGN : + *ret = agg->min; +break ; +case STATSFS_MAX : +case STATSFS_MAX |STATSFS_SIGN : + *ret = agg->max; +break ; +case STATSFS_COUNT_ZERO : +case STATSFS_COUNT_ZERO |STATSFS_SIGN : + *ret = agg->count_zero; +break ; +default : +break ; + } +} + +/* Called with rwsem held for reading */ +static int statsfs_source_get_value_locked (struct statsfs_source *source, +struct statsfs_value *arg, +uint64_t *ret) +{ +struct statsfs_value_source *src_entry; +struct statsfs_value *found; +struct statsfs_aggregate_value aggr; + + *ret =0 ; + +if (!arg) +return -ENOENT ; + +/* look in simple values */ + found =search_value_in_source (source, arg, &src_entry); + +if (!found) { +printk (KERN_ERR "Statsfs: Value in source \"%s\" not found!\n" , + source->name); +return -ENOENT ; + } + +if (src_entry->base_addr !=NULL ) { + *ret =get_simple_value (src_entry, found); +return 0 ; + } + +/* look in aggregates */ +init_aggregate_value (&aggr, found); +do_recursive_aggregation (source, src_entry, found, &aggr); +store_final_value (&aggr, found, ret); + +return 0 ; +} + +int statsfs_source_get_value (struct statsfs_source *source, +struct statsfs_value *arg,uint64_t *ret) +{ +int retval; + +down_read (&source->rwsem); + retval =statsfs_source_get_value_locked (source, arg, ret); +up_read (&source->rwsem); + +return retval; +} +EXPORT_SYMBOL_GPL (statsfs_source_get_value); + +/* Called with rwsem held for reading */ +static void set_all_simple_values (struct statsfs_source *src, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val) +{ +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { +/* skip aggregates */ +if (src_entry->base_addr ==NULL ) +continue ; + +/* wrong to search here */ +if (src_entry->values != ref_src_entry->values) +continue ; + +if (src_entry->base_addr && + src_entry->values == ref_src_entry->values) +clear_simple_value (src_entry, val); + } +} + +/* Called with rwsem held for reading */ +static void do_recursive_clean (struct statsfs_source *root, +struct statsfs_value_source *ref_src_entry, +struct statsfs_value *val) +{ +struct statsfs_source *subordinate; + +/* search all simple values in this folder */ +set_all_simple_values (root, ref_src_entry, val); + +/* recursively search in all subfolders */ +list_for_each_entry (subordinate, &root->subordinates_head, + list_element) { +down_read (&subordinate->rwsem); +do_recursive_clean (subordinate, ref_src_entry, val); +up_read (&subordinate->rwsem); + } +} + +/* Called with rwsem held for reading */ +static int statsfs_source_clear_locked (struct statsfs_source *source, +struct statsfs_value *val) +{ +struct statsfs_value_source *src_entry; +struct statsfs_value *found; + +if (!val) +return -ENOENT ; + +/* look in simple values */ + found =search_value_in_source (source, val, &src_entry); + +if (!found) { +printk (KERN_ERR "Statsfs: Value in source \"%s\" not found!\n" , + source->name); +return -ENOENT ; + } + +if (src_entry->base_addr !=NULL ) { +clear_simple_value (src_entry, found); +return 0 ; + } + +/* look in aggregates */ +do_recursive_clean (source, src_entry, found); + +return 0 ; +} + +int statsfs_source_clear (struct statsfs_source *source, +struct statsfs_value *val) +{ +int retval; + +down_read (&source->rwsem); + retval =statsfs_source_clear_locked (source, val); +up_read (&source->rwsem); + +return retval; +} + +/* Called with rwsem held for reading */ +static struct statsfs_value * +find_value_by_name (struct statsfs_value_source *src,char *val) +{ +struct statsfs_value *entry; + +for (entry = src->values; entry->name; entry++) +if (!strcmp (entry->name, val)) +return entry; + +return NULL ; +} + +/* Called with rwsem held for reading */ +static struct statsfs_value * +search_in_source_by_name (struct statsfs_source *src,char *name) +{ +struct statsfs_value *entry; +struct statsfs_value_source *src_entry; + +list_for_each_entry (src_entry, &src->values_head, list_element) { + entry =find_value_by_name (src_entry, name); +if (entry) +return entry; + } + +return NULL ; +} + +int statsfs_source_get_value_by_name (struct statsfs_source *source,char *name, +uint64_t *ret) +{ +struct statsfs_value *val; +int retval; + +down_read (&source->rwsem); + val =search_in_source_by_name (source, name); + +if (!val) { + *ret =0 ; +up_read (&source->rwsem); +return -ENOENT ; + } + + retval =statsfs_source_get_value_locked (source, val, ret); +up_read (&source->rwsem); + +return retval; +} +EXPORT_SYMBOL_GPL (statsfs_source_get_value_by_name); + +void statsfs_source_get (struct statsfs_source *source) +{ +kref_get (&source->refcount); +} +EXPORT_SYMBOL_GPL (statsfs_source_get); + +void statsfs_source_revoke (struct statsfs_source *source) +{ +struct list_head *it, *safe; +struct statsfs_value_source *val_src_entry; + +down_write (&source->rwsem); + +list_for_each_safe (it, safe, &source->values_head) { + val_src_entry = list_entry(it, struct statsfs_value_source, + list_element); + val_src_entry->base_addr =NULL ; + } + +up_write (&source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_revoke); + +/* Called with rwsem held for writing +* +* The refcount is 0 and the lock was taken before refcount +* went from 1 to 0 +*/ +static void statsfs_source_destroy (struct kref *kref_source) +{ +struct statsfs_value_source *val_src_entry; +struct list_head *it, *safe; +struct statsfs_source *child, *source; + + source = container_of(kref_source, struct statsfs_source, refcount); + +/* iterate through the values and delete them */ +list_for_each_safe (it, safe, &source->values_head) { + val_src_entry = list_entry(it, struct statsfs_value_source, + list_element); +kfree (val_src_entry); + } + +/* iterate through the subordinates and delete them */ +list_for_each_safe (it, safe, &source->subordinates_head) { + child = list_entry(it, struct statsfs_source, list_element); +statsfs_source_remove_subordinate_locked (source, child); + } + + +up_write (&source->rwsem); +kfree (source->name); +kfree (source); +} + +void statsfs_source_put (struct statsfs_source *source) +{ +kref_put_rwsem (&source->refcount, statsfs_source_destroy, + &source->rwsem); +} +EXPORT_SYMBOL_GPL (statsfs_source_put); + +struct statsfs_source *statsfs_source_create (const char *fmt, ...) +{ +va_list ap; +char buf[100 ]; +struct statsfs_source *ret; +int char_needed; + +va_start (ap, fmt); + char_needed =vsnprintf (buf,100 , fmt, ap); +va_end (ap); + + ret =kzalloc (sizeof (struct statsfs_source ),GFP_KERNEL ); +if (!ret) +return ERR_PTR (-ENOMEM ); + + ret->name =kstrdup (buf,GFP_KERNEL ); +if (!ret->name) { +kfree (ret); +return ERR_PTR (-ENOMEM ); + } + +kref_init (&ret->refcount); +init_rwsem (&ret->rwsem); + +INIT_LIST_HEAD (&ret->values_head); +INIT_LIST_HEAD (&ret->subordinates_head); +INIT_LIST_HEAD (&ret->list_element); + +return ret; +} +EXPORT_SYMBOL_GPL (statsfs_source_create);include/linux/statsfs.h new file +222
-1@@ -0,0 +1,222 @@ +/* SPDX-License-Identifier: GPL-2.0 +* +* statsfs.h - a tiny little statistics file system +* +* Copyright (C) 2020 Emanuele Giuseppe Esposito +* Copyright (C) 2020 Redhat. +* +*/ + +#ifndef _STATSFS_H_ +#define _STATSFS_H_ + +#include <linux/list.h> + +/* Used to distinguish signed types */ +#define STATSFS_SIGN 0x8000 + +struct statsfs_source ; + +enum stat_type { +STATSFS_U8 =0 , +STATSFS_U16 =1 , +STATSFS_U32 =2 , +STATSFS_U64 =3 , +STATSFS_BOOL =4 , +STATSFS_S8 =STATSFS_U8 |STATSFS_SIGN , +STATSFS_S16 =STATSFS_U16 |STATSFS_SIGN , +STATSFS_S32 =STATSFS_U32 |STATSFS_SIGN , +STATSFS_S64 =STATSFS_U64 |STATSFS_SIGN , +}; + +enum stat_aggr { +STATSFS_NONE =0 , +STATSFS_SUM , +STATSFS_MIN , +STATSFS_MAX , +STATSFS_COUNT_ZERO , +STATSFS_AVG , +}; + +struct statsfs_value { +/* Name of the stat */ +char *name; + +/* Offset from base address to field containing the value */ +int offset; + +/* Type of the stat BOOL,U64,... */ +enum stat_type type; + +/* Aggregate type: MIN, MAX, SUM,... */ +enum stat_aggr aggr_kind; + +/* File mode */ +uint16_t mode; +}; + +struct statsfs_source { +struct kref refcount; + +char *name; + +/* list of source statsfs_value_source*/ +struct list_head values_head; + +/* list of struct statsfs_source for subordinate sources */ +struct list_head subordinates_head; + +struct list_head list_element; + +struct rw_semaphore rwsem; + +struct dentry *source_dentry; +}; + +/** +* statsfs_source_create - create a statsfs_source +* Creates a statsfs_source with the given name. This +* does not mean it will be backed by the filesystem yet, it will only +* be visible to the user once one of its parents (or itself) are +* registered in statsfs. +* +* Returns a pointer to a statsfs_source if it succeeds. +* This or one of the parents' pointer must be passed to the statsfs_put() +* function when the file is to be removed. If an error occurs, +* ERR_PTR(-ERROR) will be returned. +*/ +struct statsfs_source *statsfs_source_create (const char *fmt, ...); + +/** +* statsfs_source_add_values - adds values to the given source +* @source: a pointer to the source that will receive the values +* @val: a pointer to the NULL terminated statsfs_value array to add +* @base_ptr: a pointer to the base pointer used by these values +* +* In addition to adding values to the source, also create the +* files in the filesystem if the source already is backed up by a directory. +* +* Returns 0 it succeeds. If the value are already in the +* source and have the same base_ptr, -EEXIST is returned. +*/ +int statsfs_source_add_values (struct statsfs_source *source, +struct statsfs_value *val,void *base_ptr); + +/** +* statsfs_source_add_subordinate - adds a child to the given source +* @parent: a pointer to the parent source +* @child: a pointer to child source to add +* +* Recursively create all files in the statsfs filesystem +* only if the parent has already a dentry (created with +* statsfs_source_register). +* This avoids the case where this function is called before register. +*/ +void statsfs_source_add_subordinate (struct statsfs_source *parent, +struct statsfs_source *child); + +/** +* statsfs_source_remove_subordinate - removes a child from the given source +* @parent: a pointer to the parent source +* @child: a pointer to child source to remove +* +* Look if there is such child in the parent. If so, +* it will remove all its files and call statsfs_put on the child. +*/ +void statsfs_source_remove_subordinate (struct statsfs_source *parent, +struct statsfs_source *child); + +/** +* statsfs_source_get_value - search a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @val: a pointer to the statsfs_value to search +* @ret: a pointer to the uint64_t that will hold the found value +* +* Look up in the source if a value with same value pointer +* exists. +* If not, it will return -ENOENT. If it exists and it's a simple value +* (not an aggregate), the value that it points to will be returned. +* If it exists and it's an aggregate (aggr_type != STATSFS_NONE), all +* subordinates will be recursively searched and every simple value match +* will be used to aggregate the final result. For example if it's a sum, +* all suboordinates having the same value will be sum together. +* +* This function will return 0 it succeeds. +*/ +int statsfs_source_get_value (struct statsfs_source *source, +struct statsfs_value *val,uint64_t *ret); + +/** +* statsfs_source_get_value_by_name - search a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @name: a pointer to the string representing the value to search +* (for example "exits") +* @ret: a pointer to the uint64_t that will hold the found value +* +* Same as statsfs_source_get_value, but initially the name is used +* to search in the given source if there is a value with a matching +* name. If so, statsfs_source_get_value will be called with the found +* value, otherwise -ENOENT will be returned. +*/ +int statsfs_source_get_value_by_name (struct statsfs_source *source,char *name, +uint64_t *ret); + +/** +* statsfs_source_clear - search and clears a value in the source (and +* subordinates) +* @source: a pointer to the source that will be searched +* @val: a pointer to the statsfs_value to search +* +* Look up in the source if a value with same value pointer +* exists. +* If not, it will return -ENOENT. If it exists and it's a simple value +* (not an aggregate), the value that it points to will be set to 0. +* If it exists and it's an aggregate (aggr_type != STATSFS_NONE), all +* subordinates will be recursively searched and every simple value match +* will be set to 0. +* +* This function will return 0 it succeeds. +*/ +int statsfs_source_clear (struct statsfs_source *source, +struct statsfs_value *val); + +/** +* statsfs_source_revoke - disconnect the source from its backing data +* @source: a pointer to the source that will be revoked +* +* Ensure that statsfs will not access the data that were passed to +* statsfs_source_add_value for this source. +* +* Because open files increase the reference count for a statsfs_source, +* the source can end up living longer than the data that provides the +* values for the source. Calling statsfs_source_revoke just before the +* backing data is freed avoids accesses to freed data structures. The +* sources will return 0. +*/ +void statsfs_source_revoke (struct statsfs_source *source); + +/** +* statsfs_source_get - increases refcount of source +* @source: a pointer to the source whose refcount will be increased +*/ +void statsfs_source_get (struct statsfs_source *source); + +/** +* statsfs_source_put - decreases refcount of source and deletes if needed +* @source: a pointer to the source whose refcount will be decreased +* +* If refcount arrives to zero, take care of deleting +* and free the source resources and files, by firstly recursively calling +* statsfs_source_remove_subordinate to the child and then deleting +* its own files and allocations. +*/ +void statsfs_source_put (struct statsfs_source *source); + +/** +* statsfs_initialized - returns true if statsfs fs has been registered +*/ +bool statsfs_initialized (void ); + +#endif --Quoted 2 lines
2.25.2
Cheers, Andreas
Re: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
In reply to Emanuele Giuseppe Espositofs/Kconfig source "fs/unicode/Kconfig" · line 333
Quoted 11 lines · Emanuele Giuseppe Esposito
fs/Kconfig +3
-0@@ -328,4 +328,11 @@ source "fs/unicode/Kconfig" config IO_WQ bool +config STATS_FS + bool "Statistics Filesystem" + default y
Not default y. We don't enable things that are not required. Unless you have a convincing argument otherwise.
Quoted 5 lines
fs/Kconfig +4
-0+ help + statsfs is a virtual file system that provides counters and other + statistics about the running kernel. + endmenu
Signature · 1 line
~Randy
Paolo Bonzini
maintainerRe: [RFC PATCH 2/5] statsfs API: create, add and remove statsfs sources and values
Quoted 6 lines · Randy Dunlap
fs/Kconfig source "fs/unicode/Kconfig" · line 333
Quoted 3 lines
fs/Kconfig +3
-0+config STATS_FS + bool "Statistics Filesystem" + default yNot default y. We don't enable things that are not required. Unless you have a convincing argument otherwise.
I think the best solution is to add stubs to include/linux/statsfs.h, and use "imply STATS_FS" in KVM. This would still "default y" when a subsystem that uses the filesystem is in use, but not otherwise.
Paolo
RFC PATCH 3/5 kunit: tests for statsfs API
In reply to Emanuele Giuseppe EspositoAdd kunit tests to extensively test the statsfs API functionality.
In order to run them, the kernel .config must set CONFIG_KUNIT=y and a new .kunitconfig file must be created with CONFIG_STATS_FS=y and CONFIG_STATS_FS_TEST=y
Tests can be then started by running the following command from the root directory of the linux kernel source tree:./tools/testing/kunit/kunit.py run --timeout=30 --jobs=nproc --all
--- fs/Kconfig | 6 + fs/statsfs/Makefile | 2 + fs/statsfs/statsfs-tests.c | 1067 ++++++++++++++++++++++++++++++++++++ 3 files changed, 1075 insertions(+) create mode 100644 fs/statsfs/statsfs-tests.c
fs/Kconfig +6 -0
@@ -335,4 +335,10 @@ config STATS_FS statsfs is a virtual file system that provides counters and other statistics about the running kernel. +config STATS_FS_TEST + bool "Tests for statsfs" + depends on STATS_FS && KUNIT + help + statsfs tests for the statsfs API. + endmenu
fs/statsfs/Makefile +2 -0
@@ -1,4 +1,6 @@ # SPDX-License-Identifier: GPL-2.0-only statsfs-objs := statsfs.o +statsfs-tests-objs := statsfs-tests.o obj-$(CONFIG_STATS_FS) += statsfs.o +obj-$(CONFIG_STATS_FS_TEST) += statsfs-tests.o
fs/statsfs/statsfs-tests.c new file +1067 -0
1,067 lines not on this page · raw message
Signature · 1 line
2.25.2
Re: [RFC PATCH 3/5] kunit: tests for statsfs API
fs/Kconfig config STATS_FS · line 340
Quoted 11 lines · Emanuele Giuseppe Esposito
fs/Kconfig +3
-0@@ -335,4 +335,10 @@ config STATS_FS statsfs is a virtual file system that provides counters and other statistics about the running kernel. +config STATS_FS_TEST + bool "Tests for statsfs" + depends on STATS_FS && KUNIT
The 2 lines above should be indented with one tab, not spaces.
fs/Kconfig config STATS_FS · line 344
Quoted 4 lines
fs/Kconfig +3
-0+ help + statsfs tests for the statsfs API. + endmenu
thanks.
Signature · 1 line
~Randy
RFC PATCH 4/5 statsfs fs: virtual fs to show stats to the end-user
In reply to Emanuele Giuseppe EspositoAdd virtual fs that maps statsfs sources with directories, and values (simple or aggregates) to files.
Every time a file is read/cleared, the fs internally invokes the statsfs API to get/set the requested value.
fs/statsfs/inode.cis pretty much similar to what is done in fs/debugfs/inode.c, with the exception that the API is only composed by statsfs_create_file, statsfs_create_dir and statsfs_remove.
--- fs/statsfs/Makefile | 2 +- fs/statsfs/inode.c | 337 +++++++++++++++++++++++++++++++++++++ fs/statsfs/internal.h | 15 ++ fs/statsfs/statsfs.c | 162 ++++++++++++++++++ include/linux/statsfs.h | 12 ++ include/uapi/linux/magic.h | 1 + tools/lib/api/fs/fs.c | 21 +++ 7 files changed, 549 insertions(+), 1 deletion(-) create mode 100644 fs/statsfs/inode.c
fs/statsfs/Makefile +1 -1
@@ -1,5 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only -statsfs-objs := statsfs.o +statsfs-objs := inode.o statsfs.o statsfs-tests-objs := statsfs-tests.o obj-$(CONFIG_STATS_FS) += statsfs.o
fs/statsfs/inode.c new file +337 -0
337 lines not on this page · raw message
fs/statsfs/internal.h +15 -0
@@ -15,6 +15,21 @@ struct statsfs_value_source { struct list_head list_element; }; +struct statsfs_data_inode { +struct statsfs_source *src; +struct statsfs_value *val; +}; + +extern const struct file_operations statsfs_ops; + +struct dentry *statsfs_create_file (struct statsfs_value *val, +struct statsfs_source *src); + +struct dentry *statsfs_create_dir (const char *name,struct dentry *parent); + +void statsfs_remove (struct dentry *dentry); +#define statsfs_remove_recursive statsfs_remove +int statsfs_val_get_mode (struct statsfs_value *val);#endif /* _STATSFS_INTERNAL_H_ */
fs/statsfs/statsfs.c +162 -0
208 lines not on this page · raw message
include/linux/statsfs.h +12 -0
@@ -87,6 +87,18 @@ struct statsfs_source {*/ struct statsfs_source *statsfs_source_create (const char *fmt, ...); +/** +* statsfs_source_register - register a source in the statsfs filesystem +* @source: a pointer to the source that will be registered +* +* TAdd the given folder as direct child of /sys/kernel/statsfs. +* It also starts to recursively search its own child and create all folders +* and files if they weren't already. All subsequent add_subordinate calls +* on the same source that is used in this function will create corresponding +* files and directories. +*/ +void statsfs_source_register (struct statsfs_source *source); +/** * statsfs_source_add_values - adds values to the given source * @source: a pointer to the source that will receive the values
include/uapi/linux/magic.h +1 -0
@@ -10,6 +10,7 @@#define CRAMFS_MAGIC 0x28cd3d45/* some random number */ #define CRAMFS_MAGIC_WEND 0x453dcd28/* magic number with the wrong endianess */ #define DEBUGFS_MAGIC 0x64626720 +#define STATSFS_MAGIC 0x73746174#define SECURITYFS_MAGIC 0x73636673#define SELINUX_MAGIC 0xf97cff8c#define SMACK_MAGIC 0x43415d53/* "SMAC" */
tools/lib/api/fs/fs.c +21 -0
@@ -35,6 +35,10 @@#define TRACEFS_MAGIC 0x74726163#endif +#ifndef STATSFS_MAGIC +#define STATSFS_MAGIC 0x73746174 +#endif +#ifndef HUGETLBFS_MAGIC #define HUGETLBFS_MAGIC 0x958458f6#endif
@@ -76,6 +80,16 @@ static const char * const tracefs__known_mountpoints[] = { 0, }; +#ifndef STATSFS_DEFAULT_PATH +#define STATSFS_DEFAULT_PATH "/sys/kernel/statsfs" +#endif + +static const char *const statsfs__known_mountpoints[] = { +STATSFS_DEFAULT_PATH , +"/statsfs" , +0 , +}; +static const char *const hugetlbfs__known_mountpoints[] = {0 , };
@@ -100,6 +114,7 @@ enum {FS__TRACEFS =3 ,FS__HUGETLBFS =4 ,FS__BPF_FS =5 , + FS__STATSFS = 6, };#ifndef TRACEFS_MAGIC
@@ -127,6 +142,11 @@ static struct fs fs__entries[] = { .mounts = tracefs__known_mountpoints, .magic = TRACEFS_MAGIC, }, + [FS__STATSFS] = { + .name = "statsfs", + .mounts = statsfs__known_mountpoints, + .magic = STATSFS_MAGIC, + }, [FS__HUGETLBFS] = { .name = "hugetlbfs", .mounts = hugetlbfs__known_mountpoints,
@@ -297,6 +317,7 @@ FS(sysfs, FS__SYSFS);FS (procfs,FS__PROCFS );FS (debugfs,FS__DEBUGFS );FS (tracefs,FS__TRACEFS ); +FS (statsfs,FS__STATSFS );FS (hugetlbfs,FS__HUGETLBFS );FS (bpf_fs,FS__BPF_FS );
Signature · 1 line
2.25.2
RFC PATCH 5/5 kvm_main: replace debugfs with statsfs
In reply to Emanuele Giuseppe EspositoUse statsfs API instead of debugfs to create sources and add values.
This also requires to change all architecture files to replace the old debugfs_entries with statsfs_vcpu_entries and statsfs_vm_entries.
The files/folders name and organization is kept unchanged, and a symlink in sys/kernel/debugfs/kvm is left for backward compatibility.
--- arch/arm64/kvm/guest.c | 2 +- arch/mips/kvm/mips.c | 2 +- arch/powerpc/kvm/book3s.c | 6 +- arch/powerpc/kvm/booke.c | 8 +- arch/s390/kvm/kvm-s390.c | 16 +- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/Makefile | 2 +- arch/x86/kvm/debugfs.c | 64 ------- arch/x86/kvm/statsfs.c | 49 +++++ arch/x86/kvm/x86.c | 6 +- include/linux/kvm_host.h | 39 +--- virt/kvm/arm/arm.c | 2 +- virt/kvm/kvm_main.c | 314 ++++---------------------------- 13 files changed, 130 insertions(+), 382 deletions(-) delete mode 100644 arch/x86/kvm/debugfs.c create mode 100644 arch/x86/kvm/statsfs.c
arch/arm64/kvm/guest.c +1 -1
@@ -29,7 +29,7 @@#include "trace.h" -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("halt_successful_poll" , halt_successful_poll),VCPU_STAT ("halt_attempted_poll" , halt_attempted_poll),VCPU_STAT ("halt_poll_invalid" , halt_poll_invalid),
arch/mips/kvm/mips.c +1 -1
@@ -39,7 +39,7 @@#define VECTORSPACING 0x100/* for EI/VI mode */ #endif -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("wait" , wait_exits),VCPU_STAT ("cache" , cache_exits),VCPU_STAT ("signal" , signal_exits),
arch/powerpc/kvm/book3s.c +5 -1
@@ -38,7 +38,7 @@/* #define EXIT_DEBUG */ -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("exits" , sum_exits),VCPU_STAT ("mmio" , mmio_exits),VCPU_STAT ("sig" , signal_exits),
@@ -66,6 +66,10 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {VCPU_STAT ("pthru_all" , pthru_all),VCPU_STAT ("pthru_host" , pthru_host),VCPU_STAT ("pthru_bad_aff" , pthru_bad_aff), + { NULL } +}; + +struct statsfs_value statsfs_vm_entries[] = { VM_STAT("largepages_2M", num_2M_pages, .mode = 0444), VM_STAT("largepages_1G", num_1G_pages, .mode = 0444), { NULL }
arch/powerpc/kvm/booke.c +6 -2
@@ -35,7 +35,12 @@unsigned long kvmppc_booke_handlers; -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vm_entries[] = { +VM_STAT ("remote_tlb_flush" , remote_tlb_flush), + {NULL } +}; + +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("mmio" , mmio_exits),VCPU_STAT ("sig" , signal_exits),VCPU_STAT ("itlb_r" , itlb_real_miss_exits),
@@ -54,7 +59,6 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {VCPU_STAT ("halt_wakeup" , halt_wakeup),VCPU_STAT ("doorbell" , dbell_exits),VCPU_STAT ("guest doorbell" , gdbell_exits), -VM_STAT ("remote_tlb_flush" , remote_tlb_flush), { NULL } };
arch/s390/kvm/kvm-s390.c +10 -6
@@ -57,7 +57,16 @@#define VCPU_IRQS_MAX_BUF (sizeof(struct kvm_s390_irq) * \ (KVM_MAX_VCPUS + LOCAL_IRQS)) -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vm_entries[] = { +VM_STAT ("inject_float_mchk" , inject_float_mchk), +VM_STAT ("inject_io" , inject_io), +VM_STAT ("inject_pfault_done" , inject_pfault_done), +VM_STAT ("inject_service_signal" , inject_service_signal), +VM_STAT ("inject_virtio" , inject_virtio), + {NULL } +}; + +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("userspace_handled" , exit_userspace),VCPU_STAT ("exit_null" , exit_null),VCPU_STAT ("exit_validity" , exit_validity),
@@ -95,18 +104,13 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {VCPU_STAT ("inject_ckc" , inject_ckc),VCPU_STAT ("inject_cputm" , inject_cputm),VCPU_STAT ("inject_external_call" , inject_external_call), -VM_STAT ("inject_float_mchk" , inject_float_mchk),VCPU_STAT ("inject_emergency_signal" , inject_emergency_signal), -VM_STAT ("inject_io" , inject_io),VCPU_STAT ("inject_mchk" , inject_mchk), -VM_STAT ("inject_pfault_done" , inject_pfault_done),VCPU_STAT ("inject_program" , inject_program),VCPU_STAT ("inject_restart" , inject_restart), -VM_STAT ("inject_service_signal" , inject_service_signal),VCPU_STAT ("inject_set_prefix" , inject_set_prefix),VCPU_STAT ("inject_stop_signal" , inject_stop_signal),VCPU_STAT ("inject_pfault_init" , inject_pfault_init), -VM_STAT ("inject_virtio" , inject_virtio),VCPU_STAT ("instruction_epsw" , instruction_epsw),VCPU_STAT ("instruction_gs" , instruction_gs), VCPU_STAT("instruction_io_other", instruction_io_other),
arch/x86/include/asm/kvm_host.h +1 -1
@@ -35,7 +35,7 @@#include <asm/kvm_vcpu_regs.h> #include <asm/hyperv-tlfs.h> -#define __KVM_HAVE_ARCH_VCPU_DEBUGFS +#define __KVM_HAVE_ARCH_VCPU_STATSFS#define KVM_MAX_VCPUS 288#define KVM_SOFT_MAX_VCPUS 240
arch/x86/kvm/Makefile +1 -1
@@ -11,7 +11,7 @@ kvm-$(CONFIG_KVM_ASYNC_PF) += $(KVM)/async_pf.o kvm-y += x86.o emulate.o i8259.o irq.o lapic.o \ i8254.o ioapic.o irq_comm.o cpuid.o pmu.o mtrr.o \ - hyperv.o debugfs.o mmu/mmu.o mmu/page_track.o + hyperv.o statsfs.o mmu/mmu.o mmu/page_track.o kvm-intel-y += vmx/vmx.o vmx/vmenter.o vmx/pmu_intel.o vmx/vmcs12.o vmx/evmcs.o vmx/nested.o kvm-amd-y += svm/svm.o svm/vmenter.o svm/pmu.o svm/nested.o svm/avic.o svm/sev.o
arch/x86/kvm/debugfs.c deleted +0 -64
64 lines not on this page · raw message
arch/x86/kvm/statsfs.c new file +49 -0
49 lines not on this page · raw message
arch/x86/kvm/x86.c +5 -1
@@ -190,7 +190,7 @@ static u64 __read_mostly host_xss;u64 __read_mostly supported_xss;EXPORT_SYMBOL_GPL (supported_xss); -struct kvm_stats_debugfs_item debugfs_entries[] = { +struct statsfs_value statsfs_vcpu_entries[] = {VCPU_STAT ("pf_fixed" , pf_fixed),VCPU_STAT ("pf_guest" , pf_guest),VCPU_STAT ("tlb_flush" , tlb_flush),
@@ -217,6 +217,10 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {VCPU_STAT ("nmi_injections" , nmi_injections),VCPU_STAT ("req_event" , req_event),VCPU_STAT ("l1d_flush" , l1d_flush), + { NULL } +}; + +struct statsfs_value statsfs_vm_entries[] = {VM_STAT ("mmu_shadow_zapped" , mmu_shadow_zapped),VM_STAT ("mmu_pte_write" , mmu_pte_write), VM_STAT("mmu_pte_updated", mmu_pte_updated),
include/linux/kvm_host.h +10 -29
@@ -27,6 +27,7 @@#include <linux/refcount.h> #include <linux/nospec.h> #include <asm/signal.h> +#include <linux/statsfs.h> #include <linux/kvm.h> #include <linux/kvm_para.h>
@@ -318,7 +319,7 @@ struct kvm_vcpu {bool preempted;bool ready;struct kvm_vcpu_arch arch; -struct dentry *debugfs_dentry; +struct statsfs_source *statsfs_src; };static inline int kvm_vcpu_exiting_guest_mode (struct kvm_vcpu *vcpu)
@@ -498,8 +499,7 @@ struct kvm {long tlbs_dirty;struct list_head devices;u64 manual_dirty_log_protect; -struct dentry *debugfs_dentry; -struct kvm_stat_data **debugfs_stat_data; +struct statsfs_source *statsfs_src;struct srcu_struct srcu;struct srcu_struct irq_srcu;pid_t userspace_pid;
@@ -880,8 +880,8 @@ int kvm_arch_vcpu_create(struct kvm_vcpu *vcpu);void kvm_arch_vcpu_postcreate (struct kvm_vcpu *vcpu);void kvm_arch_vcpu_destroy (struct kvm_vcpu *vcpu); -#ifdef __KVM_HAVE_ARCH_VCPU_DEBUGFS -void kvm_arch_create_vcpu_debugfs (struct kvm_vcpu *vcpu); +#ifdef __KVM_HAVE_ARCH_VCPU_STATSFS +void kvm_arch_create_vcpu_statsfs (struct kvm_vcpu *vcpu);#endif int kvm_arch_hardware_enable (void );
@@ -1110,33 +1110,14 @@ static inline bool kvm_is_error_gpa(struct kvm *kvm, gpa_t gpa)return kvm_is_error_hva (hva); } -enum kvm_stat_kind { -KVM_STAT_VM , -KVM_STAT_VCPU , -}; - -struct kvm_stat_data { -struct kvm *kvm; -struct kvm_stats_debugfs_item *dbgfs_item; -}; - -struct kvm_stats_debugfs_item { -const char *name; -int offset; -enum kvm_stat_kind kind; -int mode; -}; - -#define KVM_DBGFS_GET_MODE (dbgfs_item) \ - ((dbgfs_item)->mode ? (dbgfs_item)->mode : 0644) -#define VM_STAT (n, x, ...) \ - { n, offsetof(struct kvm, stat.x), KVM_STAT_VM, ## __VA_ARGS__ } + { n, offsetof(struct kvm, stat.x), STATSFS_U64, STATSFS_SUM, ## __VA_ARGS__ }#define VCPU_STAT (n, x, ...) \ - { n, offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU, ## __VA_ARGS__ } + { n, offsetof(struct kvm_vcpu, stat.x), STATSFS_U64, STATSFS_SUM, ## __VA_ARGS__ } -extern struct kvm_stats_debugfs_item debugfs_entries[]; -extern struct dentry *kvm_debugfs_dir; +extern struct statsfs_value statsfs_vcpu_entries[]; +extern struct statsfs_value statsfs_vm_entries[]; +extern struct statsfs_source *kvm_statsfs_dir;#if defined(CONFIG_MMU_NOTIFIER ) && defined(KVM_ARCH_WANT_MMU_NOTIFIER )static inline int mmu_notifier_retry (struct kvm *kvm,unsigned long mmu_seq)
virt/kvm/arm/arm.c +1 -1
@@ -140,7 +140,7 @@ int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)return ret; } -int kvm_arch_create_vcpu_debugfs (struct kvm_vcpu *vcpu) +int kvm_arch_create_vcpu_statsfs (struct kvm_vcpu *vcpu) {return 0 ; }
virt/kvm/kvm_main.c +40 -274
436 lines not on this page · raw message
Signature · 1 line
2.25.2
Re: [RFC PATCH 5/5] kvm_main: replace debugfs with statsfs
Quoted 18 lines · Emanuele Giuseppe Esposito
Use statsfs API instead of debugfs to create sources and add values.
This also requires to change all architecture files to replace the old
debugfs_entrieswithstatsfs_vcpu_entriesandstatsfs_vm_entries.The files/folders name and organization is kept unchanged, and a symlink in sys/kernel/debugfs/kvm is left for backward compatibility.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- arch/arm64/kvm/guest.c | 2 +- arch/mips/kvm/mips.c | 2 +- arch/powerpc/kvm/book3s.c | 6 +- arch/powerpc/kvm/booke.c | 8 +- arch/s390/kvm/kvm-s390.c | 16 +- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/Makefile | 2 +- arch/x86/kvm/debugfs.c | 64 -------
Quoted 8 lines
arch/x86/kvm/statsfs.c | 49 +++++ arch/x86/kvm/x86.c | 6 +- include/linux/kvm_host.h | 39 +--- virt/kvm/arm/arm.c | 2 +- virt/kvm/kvm_main.c | 314 ++++---------------------------- 13 files changed, 130 insertions(+), 382 deletions(-) delete mode 100644 arch/x86/kvm/debugfs.c create mode 100644 arch/x86/kvm/statsfs.c
You might want to select STATS_FS here (or depend on it if it is required), or you could provide stubs in <linux/statsfs.h> for the cases of STATS_FS is not set/enabled.
Signature · 1 line
~Randy
Re: [RFC PATCH 5/5] kvm_main: replace debugfs with statsfs
Quoted 29 lines · Randy Dunlap
Quoted 24 lines · Emanuele Giuseppe Esposito
Use statsfs API instead of debugfs to create sources and add values.
This also requires to change all architecture files to replace the old
debugfs_entrieswithstatsfs_vcpu_entriesandstatsfs_vm_entries.The files/folders name and organization is kept unchanged, and a symlink in sys/kernel/debugfs/kvm is left for backward compatibility.
Signed-off-by Emanuele Giuseppe Esposito <[email protected]>--- arch/arm64/kvm/guest.c | 2 +- arch/mips/kvm/mips.c | 2 +- arch/powerpc/kvm/book3s.c | 6 +- arch/powerpc/kvm/booke.c | 8 +- arch/s390/kvm/kvm-s390.c | 16 +- arch/x86/include/asm/kvm_host.h | 2 +- arch/x86/kvm/Makefile | 2 +- arch/x86/kvm/debugfs.c | 64 ------- arch/x86/kvm/statsfs.c | 49 +++++ arch/x86/kvm/x86.c | 6 +- include/linux/kvm_host.h | 39 +--- virt/kvm/arm/arm.c | 2 +- virt/kvm/kvm_main.c | 314 ++++---------------------------- 13 files changed, 130 insertions(+), 382 deletions(-)Quoted 2 lines
delete mode 100644
arch/x86/kvm/debugfs.c
create mode 100644arch/x86/kvm/statsfs.c
Quoted 3 lines
You might want to select
STATS_FShere (or depend on it if it is required), or you could provide stubs in <linux/statsfs.h> for the cases ofSTATS_FSis not set/enabled.
Currently debugfs is not present in the kvm Kconfig, but implements empty stubs as you suggested. I guess it would be a good idea to do the same for statsfs.
Paolo, what do you think?
Regarding the other suggestions, you are right, I will apply them in v2.
Thank you,
Emanuele
Paolo Bonzini
maintainerRe: [RFC PATCH 5/5] kvm_main: replace debugfs with statsfs
Quoted 7 lines · Emanuele Giuseppe Esposito
Quoted 6 lines
You might want to select
STATS_FShere (or depend on it if it is required),
or you could provide stubs in <linux/statsfs.h> for the cases ofSTATS_FSis not set/enabled.
Quoted 7 lines
Currently debugfs is not present in the kvm
Kconfig, but implements empty stubs as you suggested. I guess it would be a good idea to do the same for statsfs.Paolo, what do you think?
Regarding the other suggestions, you are right, I will apply them in v2.
I replied in v2 - basically "imply" STATS_FS here instead of "selecting" it.
Paolo