From: Mike Snitzer <snitzer@xxxxxxxxxx>
Also update target major version number.
All info is (or will be) accessible through alternative interfaces
(e.g. "dmsetup message", module params, etc).
Signed-off-by: Mike Snitzer <snitzer@xxxxxxxxxx>
Signed-off-by: Ken Raeburn <raeburn@xxxxxxxxxx>
Signed-off-by: Matthew Sakai <msakai@xxxxxxxxxx>
---
drivers/md/dm-vdo/Makefile | 4 -
drivers/md/dm-vdo/dedupe.c | 70 +-
drivers/md/dm-vdo/dedupe.h | 2 +-
drivers/md/dm-vdo/dm-vdo-target.c | 44 +-
drivers/md/dm-vdo/logger.c | 5 -
drivers/md/dm-vdo/logger.h | 2 -
drivers/md/dm-vdo/pool-sysfs-stats.c | 2063 --------------------------
drivers/md/dm-vdo/pool-sysfs.c | 198 ---
drivers/md/dm-vdo/pool-sysfs.h | 19 -
drivers/md/dm-vdo/status-codes.c | 1 -
drivers/md/dm-vdo/status-codes.h | 2 -
drivers/md/dm-vdo/sysfs.c | 82 -
drivers/md/dm-vdo/uds-sysfs.c | 187 ---
drivers/md/dm-vdo/uds-sysfs.h | 12 -
drivers/md/dm-vdo/vdo.c | 54 +-
drivers/md/dm-vdo/vdo.h | 13 -
16 files changed, 9 insertions(+), 2749 deletions(-)
delete mode 100644 drivers/md/dm-vdo/pool-sysfs-stats.c
delete mode 100644 drivers/md/dm-vdo/pool-sysfs.c
delete mode 100644 drivers/md/dm-vdo/pool-sysfs.h
delete mode 100644 drivers/md/dm-vdo/sysfs.c
delete mode 100644 drivers/md/dm-vdo/uds-sysfs.c
delete mode 100644 drivers/md/dm-vdo/uds-sysfs.h
diff --git a/drivers/md/dm-vdo/Makefile b/drivers/md/dm-vdo/Makefile
index 502a7a0acbdb..33e09abc6acd 100644
--- a/drivers/md/dm-vdo/Makefile
+++ b/drivers/md/dm-vdo/Makefile
@@ -28,19 +28,15 @@ dm-vdo-objs := \
packer.o \
permassert.o \
physical-zone.o \
- pool-sysfs.o \
- pool-sysfs-stats.o \
priority-table.o \
recovery-journal.o \
repair.o \
slab-depot.o \
status-codes.o \
string-utils.o \
- sysfs.o \
thread-device.o \
thread-registry.o \
thread-utils.o \
- uds-sysfs.o \
vdo.o \
vio.o \
wait-queue.o \
diff --git a/drivers/md/dm-vdo/dedupe.c b/drivers/md/dm-vdo/dedupe.c
index 52bdf657db64..8550a9a7958b 100644
--- a/drivers/md/dm-vdo/dedupe.c
+++ b/drivers/md/dm-vdo/dedupe.c
@@ -120,7 +120,6 @@
#include <linux/atomic.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
-#include <linux/kobject.h>
#include <linux/list.h>
#include <linux/ratelimit.h>
#include <linux/spinlock.h>
@@ -279,7 +278,6 @@ struct hash_lock {
struct hash_zones {
struct action_manager *manager;
- struct kobject dedupe_directory;
struct uds_parameters parameters;
struct uds_index_session *index_session;
struct ratelimit_state ratelimiter;
@@ -2022,56 +2020,6 @@ void vdo_share_compressed_write_lock(struct data_vio *data_vio,
VDO_ASSERT_LOG_ONLY(claimed, "impossible to fail to claim an initial increment");
}
-static void dedupe_kobj_release(struct kobject *directory)
-{
- vdo_free(container_of(directory, struct hash_zones, dedupe_directory));
-}
-
-static ssize_t dedupe_status_show(struct kobject *directory, struct attribute *attr,
- char *buf)
-{
- struct uds_attribute *ua = container_of(attr, struct uds_attribute, attr);
- struct hash_zones *zones = container_of(directory, struct hash_zones,
- dedupe_directory);
-
- if (ua->show_string != NULL)
- return sprintf(buf, "%s\n", ua->show_string(zones));
- else
- return -EINVAL;
-}
-
-static ssize_t dedupe_status_store(struct kobject *kobj __always_unused,
- struct attribute *attr __always_unused,
- const char *buf __always_unused,
- size_t length __always_unused)
-{
- return -EINVAL;
-}
-
-/*----------------------------------------------------------------------*/
-
-static const struct sysfs_ops dedupe_sysfs_ops = {
- .show = dedupe_status_show,
- .store = dedupe_status_store,
-};
-
-static struct uds_attribute dedupe_status_attribute = {
- .attr = {.name = "status", .mode = 0444, },
- .show_string = vdo_get_dedupe_index_state_name,
-};
-
-static struct attribute *dedupe_attrs[] = {
- &dedupe_status_attribute.attr,
- NULL,
-};
-ATTRIBUTE_GROUPS(dedupe);
-
-static const struct kobj_type dedupe_directory_type = {
- .release = dedupe_kobj_release,
- .sysfs_ops = &dedupe_sysfs_ops,
- .default_groups = dedupe_groups,
-};
-
static void start_uds_queue(void *ptr)
{
/*
@@ -2266,7 +2214,6 @@ static int initialize_index(struct vdo *vdo, struct hash_zones *zones)
vdo_initialize_completion(&zones->completion, vdo, VDO_HASH_ZONES_COMPLETION);
vdo_set_completion_callback(&zones->completion, change_dedupe_state,
vdo->thread_config.dedupe_thread);
- kobject_init(&zones->dedupe_directory, &dedupe_directory_type);
return VDO_SUCCESS;
}
@@ -2537,10 +2484,7 @@ void vdo_free_hash_zones(struct hash_zones *zones)
vdo_finish_dedupe_index(zones);
ratelimit_state_exit(&zones->ratelimiter);
- if (vdo_get_admin_state_code(&zones->state) == VDO_ADMIN_STATE_NEW)
- vdo_free(zones);
- else
- kobject_put(&zones->dedupe_directory);
+ vdo_free(zones);
}
static void initiate_suspend_index(struct admin_state *state)
@@ -3047,17 +2991,9 @@ int vdo_message_dedupe_index(struct hash_zones *zones, const char *name)
return -EINVAL;
}
-int vdo_add_dedupe_index_sysfs(struct hash_zones *zones)
+void vdo_set_dedupe_state_normal(struct hash_zones *zones)
{
- int result = kobject_add(&zones->dedupe_directory,
- &zones->completion.vdo->vdo_directory, "dedupe");
-
- if (result == 0) {
- vdo_set_admin_state_code(&zones->state,
- VDO_ADMIN_STATE_NORMAL_OPERATION);
- }
-
- return result;
+ vdo_set_admin_state_code(&zones->state, VDO_ADMIN_STATE_NORMAL_OPERATION);
}
/* If create_flag, create a new index without first attempting to load an existing index. */
diff --git a/drivers/md/dm-vdo/dedupe.h b/drivers/md/dm-vdo/dedupe.h
index 1566fc972ea7..9000d6f3eece 100644
--- a/drivers/md/dm-vdo/dedupe.h
+++ b/drivers/md/dm-vdo/dedupe.h
@@ -97,7 +97,7 @@ u64 vdo_get_dedupe_index_timeout_count(struct hash_zones *zones);
int vdo_message_dedupe_index(struct hash_zones *zones, const char *name);
-int vdo_add_dedupe_index_sysfs(struct hash_zones *zones);
+void vdo_set_dedupe_state_normal(struct hash_zones *zones);
void vdo_start_dedupe_index(struct hash_zones *zones, bool create_flag);
diff --git a/drivers/md/dm-vdo/dm-vdo-target.c b/drivers/md/dm-vdo/dm-vdo-target.c
index 5f607dbb16e9..c6ee8161ba62 100644
--- a/drivers/md/dm-vdo/dm-vdo-target.c
+++ b/drivers/md/dm-vdo/dm-vdo-target.c
@@ -27,7 +27,6 @@
#include "logger.h"
#include "memory-alloc.h"
#include "message-stats.h"
-#include "pool-sysfs.h"
#include "recovery-journal.h"
#include "repair.h"
#include "slab-depot.h"
@@ -36,7 +35,6 @@
#include "thread-device.h"
#include "thread-registry.h"
#include "types.h"
-#include "uds-sysfs.h"
#include "vdo.h"
#include "vio.h"
@@ -54,7 +52,6 @@ enum admin_phases {
GROW_PHYSICAL_PHASE_END,
GROW_PHYSICAL_PHASE_ERROR,
LOAD_PHASE_START,
- LOAD_PHASE_STATS,
LOAD_PHASE_LOAD_DEPOT,
LOAD_PHASE_MAKE_DIRTY,
LOAD_PHASE_PREPARE_TO_ALLOCATE,
@@ -104,7 +101,6 @@ static const char * const ADMIN_PHASE_NAMES[] = {
"GROW_PHYSICAL_PHASE_END",
"GROW_PHYSICAL_PHASE_ERROR",
"LOAD_PHASE_START",
- "LOAD_PHASE_STATS",
"LOAD_PHASE_LOAD_DEPOT",
"LOAD_PHASE_MAKE_DIRTY",
"LOAD_PHASE_PREPARE_TO_ALLOCATE",
@@ -947,8 +943,8 @@ static void vdo_io_hints(struct dm_target *ti, struct queue_limits *limits)
* blocked task warnings in kernel logs. In order to avoid these warnings, we choose to
* use the smallest reasonable value.
*
- * The value is displayed in sysfs, and also used by dm-thin to determine whether to pass
- * down discards. The block layer splits large discards on this boundary when this is set.
+ * The value is used by dm-thin to determine whether to pass down discards. The block layer
+ * splits large discards on this boundary when this is set.
*/
limits->max_discard_sectors =
(vdo->device_config->max_discard_blocks * VDO_SECTORS_PER_BLOCK);
@@ -2174,32 +2170,6 @@ static enum slab_depot_load_type get_load_type(struct vdo *vdo)
return VDO_SLAB_DEPOT_NORMAL_LOAD;
}
-/**
- * vdo_initialize_kobjects() - Initialize the vdo sysfs directory.
- * @vdo: The vdo being initialized.
- *
- * Return: VDO_SUCCESS or an error code.
- */
-static int vdo_initialize_kobjects(struct vdo *vdo)
-{
- int result;
- struct dm_target *target = vdo->device_config->owning_target;
- struct mapped_device *md = dm_table_get_md(target->table);
-
- kobject_init(&vdo->vdo_directory, &vdo_directory_type);
- vdo->sysfs_added = true;
- result = kobject_add(&vdo->vdo_directory, &disk_to_dev(dm_disk(md))->kobj,
- "vdo");
- if (result != 0)
- return VDO_CANT_ADD_SYSFS_NODE;
-
- result = vdo_add_dedupe_index_sysfs(vdo->hash_zones);
- if (result != 0)
- return VDO_CANT_ADD_SYSFS_NODE;
-
- return vdo_add_sysfs_stats_dir(vdo);
-}
-
/**
* load_callback() - Callback to do the destructive parts of loading a VDO.
* @completion: The sub-task completion.
@@ -2225,11 +2195,8 @@ static void load_callback(struct vdo_completion *completion)
vdo_allow_read_only_mode_entry(completion);
return;
- case LOAD_PHASE_STATS:
- vdo_continue_completion(completion, vdo_initialize_kobjects(vdo));
- return;
-
case LOAD_PHASE_LOAD_DEPOT:
+ vdo_set_dedupe_state_normal(vdo->hash_zones);
if (vdo_is_read_only(vdo)) {
/*
* In read-only mode we don't use the allocator and it may not even be
@@ -2866,7 +2833,7 @@ static void vdo_resume(struct dm_target *ti)
static struct target_type vdo_target_bio = {
.features = DM_TARGET_SINGLETON,
.name = "vdo",
- .version = { 8, 2, 0 },
+ .version = { 9, 0, 0 },
.module = THIS_MODULE,
.ctr = vdo_ctr,
.dtr = vdo_dtr,
@@ -2905,8 +2872,6 @@ static int __init vdo_init(void)
/* Memory tracking must be initialized first for accurate accounting. */
vdo_memory_init();
- uds_init_sysfs();
-
vdo_initialize_thread_device_registry();
vdo_initialize_device_registry_once();
uds_log_info("loaded version %s", CURRENT_VERSION);
@@ -2933,7 +2898,6 @@ static int __init vdo_init(void)
static void __exit vdo_exit(void)
{
vdo_module_destroy();
- uds_put_sysfs();
/* Memory tracking cleanup must be done last. */
vdo_memory_exit();
}
diff --git a/drivers/md/dm-vdo/logger.c b/drivers/md/dm-vdo/logger.c
index a50edb0331fc..bac28fff622d 100644
--- a/drivers/md/dm-vdo/logger.c
+++ b/drivers/md/dm-vdo/logger.c
@@ -56,11 +56,6 @@ int uds_get_log_level(void)
return log_level;
}
-void uds_set_log_level(int new_log_level)
-{
- log_level = new_log_level;
-}
-
int uds_log_string_to_priority(const char *string)
{
int i;
diff --git a/drivers/md/dm-vdo/logger.h b/drivers/md/dm-vdo/logger.h
index 4e2f18042ba7..ceb07aa3231f 100644
--- a/drivers/md/dm-vdo/logger.h
+++ b/drivers/md/dm-vdo/logger.h
@@ -37,8 +37,6 @@
int uds_get_log_level(void);
-void uds_set_log_level(int new_log_level);
-
int uds_log_string_to_priority(const char *string);
const char *uds_log_priority_to_string(int priority);
diff --git a/drivers/md/dm-vdo/pool-sysfs-stats.c b/drivers/md/dm-vdo/pool-sysfs-stats.c
deleted file mode 100644
index ae3838894a1c..000000000000
--- a/drivers/md/dm-vdo/pool-sysfs-stats.c
+++ /dev/null
@@ -1,2063 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright 2023 Red Hat
- */
-
-#include <linux/mutex.h>
-
-#include "logger.h"
-#include "string-utils.h"
-
-#include "dedupe.h"
-#include "pool-sysfs.h"
-#include "statistics.h"
-#include "vdo.h"
-
-struct pool_stats_attribute {
- struct attribute attr;
- ssize_t (*print)(struct vdo_statistics *stats, char *buf);
-};
-
-static ssize_t pool_stats_attr_show(struct kobject *directory,
- struct attribute *attr,
- char *buf)
-{
- ssize_t size;
- struct pool_stats_attribute *pool_stats_attr =
- container_of(attr, struct pool_stats_attribute, attr);
- struct vdo *vdo = container_of(directory, struct vdo, stats_directory);
-
- if (pool_stats_attr->print == NULL)
- return -EINVAL;
-
- mutex_lock(&vdo->stats_mutex);
- vdo_fetch_statistics(vdo, &vdo->stats_buffer);
- size = pool_stats_attr->print(&vdo->stats_buffer, buf);
- mutex_unlock(&vdo->stats_mutex);
-
- return size;
-}
-
-const struct sysfs_ops vdo_pool_stats_sysfs_ops = {
- .show = pool_stats_attr_show,
- .store = NULL,
-};
-
-/* Number of blocks used for data */
-static ssize_t
-pool_stats_print_data_blocks_used(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->data_blocks_used);
-}
-
-static struct pool_stats_attribute pool_stats_attr_data_blocks_used = {
- .attr = { .name = "data_blocks_used", .mode = 0444, },
- .print = pool_stats_print_data_blocks_used,
-};
-
-/* Number of blocks used for VDO metadata */
-static ssize_t
-pool_stats_print_overhead_blocks_used(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->overhead_blocks_used);
-}
-
-static struct pool_stats_attribute pool_stats_attr_overhead_blocks_used = {
- .attr = { .name = "overhead_blocks_used", .mode = 0444, },
- .print = pool_stats_print_overhead_blocks_used,
-};
-
-/* Number of logical blocks that are currently mapped to physical blocks */
-static ssize_t
-pool_stats_print_logical_blocks_used(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->logical_blocks_used);
-}
-
-static struct pool_stats_attribute pool_stats_attr_logical_blocks_used = {
- .attr = { .name = "logical_blocks_used", .mode = 0444, },
- .print = pool_stats_print_logical_blocks_used,
-};
-
-/* number of physical blocks */
-static ssize_t
-pool_stats_print_physical_blocks(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->physical_blocks);
-}
-
-static struct pool_stats_attribute pool_stats_attr_physical_blocks = {
- .attr = { .name = "physical_blocks", .mode = 0444, },
- .print = pool_stats_print_physical_blocks,
-};
-
-/* number of logical blocks */
-static ssize_t
-pool_stats_print_logical_blocks(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->logical_blocks);
-}
-
-static struct pool_stats_attribute pool_stats_attr_logical_blocks = {
- .attr = { .name = "logical_blocks", .mode = 0444, },
- .print = pool_stats_print_logical_blocks,
-};
-
-/* Size of the block map page cache, in bytes */
-static ssize_t
-pool_stats_print_block_map_cache_size(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map_cache_size);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_cache_size = {
- .attr = { .name = "block_map_cache_size", .mode = 0444, },
- .print = pool_stats_print_block_map_cache_size,
-};
-
-/* The physical block size */
-static ssize_t
-pool_stats_print_block_size(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_size);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_size = {
- .attr = { .name = "block_size", .mode = 0444, },
- .print = pool_stats_print_block_size,
-};
-
-/* Number of times the VDO has successfully recovered */
-static ssize_t
-pool_stats_print_complete_recoveries(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->complete_recoveries);
-}
-
-static struct pool_stats_attribute pool_stats_attr_complete_recoveries = {
- .attr = { .name = "complete_recoveries", .mode = 0444, },
- .print = pool_stats_print_complete_recoveries,
-};
-
-/* Number of times the VDO has recovered from read-only mode */
-static ssize_t
-pool_stats_print_read_only_recoveries(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->read_only_recoveries);
-}
-
-static struct pool_stats_attribute pool_stats_attr_read_only_recoveries = {
- .attr = { .name = "read_only_recoveries", .mode = 0444, },
- .print = pool_stats_print_read_only_recoveries,
-};
-
-/* String describing the operating mode of the VDO */
-static ssize_t
-pool_stats_print_mode(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%s\n", stats->mode);
-}
-
-static struct pool_stats_attribute pool_stats_attr_mode = {
- .attr = { .name = "mode", .mode = 0444, },
- .print = pool_stats_print_mode,
-};
-
-/* Whether the VDO is in recovery mode */
-static ssize_t
-pool_stats_print_in_recovery_mode(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%d\n", stats->in_recovery_mode);
-}
-
-static struct pool_stats_attribute pool_stats_attr_in_recovery_mode = {
- .attr = { .name = "in_recovery_mode", .mode = 0444, },
- .print = pool_stats_print_in_recovery_mode,
-};
-
-/* What percentage of recovery mode work has been completed */
-static ssize_t
-pool_stats_print_recovery_percentage(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->recovery_percentage);
-}
-
-static struct pool_stats_attribute pool_stats_attr_recovery_percentage = {
- .attr = { .name = "recovery_percentage", .mode = 0444, },
- .print = pool_stats_print_recovery_percentage,
-};
-
-/* Number of compressed data items written since startup */
-static ssize_t
-pool_stats_print_packer_compressed_fragments_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->packer.compressed_fragments_written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_packer_compressed_fragments_written = {
- .attr = { .name = "packer_compressed_fragments_written", .mode = 0444, },
- .print = pool_stats_print_packer_compressed_fragments_written,
-};
-
-/* Number of blocks containing compressed items written since startup */
-static ssize_t
-pool_stats_print_packer_compressed_blocks_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->packer.compressed_blocks_written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_packer_compressed_blocks_written = {
- .attr = { .name = "packer_compressed_blocks_written", .mode = 0444, },
- .print = pool_stats_print_packer_compressed_blocks_written,
-};
-
-/* Number of VIOs that are pending in the packer */
-static ssize_t
-pool_stats_print_packer_compressed_fragments_in_packer(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->packer.compressed_fragments_in_packer);
-}
-
-static struct pool_stats_attribute pool_stats_attr_packer_compressed_fragments_in_packer = {
- .attr = { .name = "packer_compressed_fragments_in_packer", .mode = 0444, },
- .print = pool_stats_print_packer_compressed_fragments_in_packer,
-};
-
-/* The total number of slabs from which blocks may be allocated */
-static ssize_t
-pool_stats_print_allocator_slab_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->allocator.slab_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_allocator_slab_count = {
- .attr = { .name = "allocator_slab_count", .mode = 0444, },
- .print = pool_stats_print_allocator_slab_count,
-};
-
-/* The total number of slabs from which blocks have ever been allocated */
-static ssize_t
-pool_stats_print_allocator_slabs_opened(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->allocator.slabs_opened);
-}
-
-static struct pool_stats_attribute pool_stats_attr_allocator_slabs_opened = {
- .attr = { .name = "allocator_slabs_opened", .mode = 0444, },
- .print = pool_stats_print_allocator_slabs_opened,
-};
-
-/* The number of times since loading that a slab has been re-opened */
-static ssize_t
-pool_stats_print_allocator_slabs_reopened(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->allocator.slabs_reopened);
-}
-
-static struct pool_stats_attribute pool_stats_attr_allocator_slabs_reopened = {
- .attr = { .name = "allocator_slabs_reopened", .mode = 0444, },
- .print = pool_stats_print_allocator_slabs_reopened,
-};
-
-/* Number of times the on-disk journal was full */
-static ssize_t
-pool_stats_print_journal_disk_full(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.disk_full);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_disk_full = {
- .attr = { .name = "journal_disk_full", .mode = 0444, },
- .print = pool_stats_print_journal_disk_full,
-};
-
-/* Number of times the recovery journal requested slab journal commits. */
-static ssize_t
-pool_stats_print_journal_slab_journal_commits_requested(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.slab_journal_commits_requested);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_slab_journal_commits_requested = {
- .attr = { .name = "journal_slab_journal_commits_requested", .mode = 0444, },
- .print = pool_stats_print_journal_slab_journal_commits_requested,
-};
-
-/* The total number of items on which processing has started */
-static ssize_t
-pool_stats_print_journal_entries_started(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.entries.started);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_entries_started = {
- .attr = { .name = "journal_entries_started", .mode = 0444, },
- .print = pool_stats_print_journal_entries_started,
-};
-
-/* The total number of items for which a write operation has been issued */
-static ssize_t
-pool_stats_print_journal_entries_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.entries.written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_entries_written = {
- .attr = { .name = "journal_entries_written", .mode = 0444, },
- .print = pool_stats_print_journal_entries_written,
-};
-
-/* The total number of items for which a write operation has completed */
-static ssize_t
-pool_stats_print_journal_entries_committed(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.entries.committed);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_entries_committed = {
- .attr = { .name = "journal_entries_committed", .mode = 0444, },
- .print = pool_stats_print_journal_entries_committed,
-};
-
-/* The total number of items on which processing has started */
-static ssize_t
-pool_stats_print_journal_blocks_started(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.blocks.started);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_blocks_started = {
- .attr = { .name = "journal_blocks_started", .mode = 0444, },
- .print = pool_stats_print_journal_blocks_started,
-};
-
-/* The total number of items for which a write operation has been issued */
-static ssize_t
-pool_stats_print_journal_blocks_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.blocks.written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_blocks_written = {
- .attr = { .name = "journal_blocks_written", .mode = 0444, },
- .print = pool_stats_print_journal_blocks_written,
-};
-
-/* The total number of items for which a write operation has completed */
-static ssize_t
-pool_stats_print_journal_blocks_committed(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->journal.blocks.committed);
-}
-
-static struct pool_stats_attribute pool_stats_attr_journal_blocks_committed = {
- .attr = { .name = "journal_blocks_committed", .mode = 0444, },
- .print = pool_stats_print_journal_blocks_committed,
-};
-
-/* Number of times the on-disk journal was full */
-static ssize_t
-pool_stats_print_slab_journal_disk_full_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_journal.disk_full_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_journal_disk_full_count = {
- .attr = { .name = "slab_journal_disk_full_count", .mode = 0444, },
- .print = pool_stats_print_slab_journal_disk_full_count,
-};
-
-/* Number of times an entry was added over the flush threshold */
-static ssize_t
-pool_stats_print_slab_journal_flush_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_journal.flush_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_journal_flush_count = {
- .attr = { .name = "slab_journal_flush_count", .mode = 0444, },
- .print = pool_stats_print_slab_journal_flush_count,
-};
-
-/* Number of times an entry was added over the block threshold */
-static ssize_t
-pool_stats_print_slab_journal_blocked_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_journal.blocked_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_journal_blocked_count = {
- .attr = { .name = "slab_journal_blocked_count", .mode = 0444, },
- .print = pool_stats_print_slab_journal_blocked_count,
-};
-
-/* Number of times a tail block was written */
-static ssize_t
-pool_stats_print_slab_journal_blocks_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_journal.blocks_written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_journal_blocks_written = {
- .attr = { .name = "slab_journal_blocks_written", .mode = 0444, },
- .print = pool_stats_print_slab_journal_blocks_written,
-};
-
-/* Number of times we had to wait for the tail to write */
-static ssize_t
-pool_stats_print_slab_journal_tail_busy_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_journal.tail_busy_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_journal_tail_busy_count = {
- .attr = { .name = "slab_journal_tail_busy_count", .mode = 0444, },
- .print = pool_stats_print_slab_journal_tail_busy_count,
-};
-
-/* Number of blocks written */
-static ssize_t
-pool_stats_print_slab_summary_blocks_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->slab_summary.blocks_written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_slab_summary_blocks_written = {
- .attr = { .name = "slab_summary_blocks_written", .mode = 0444, },
- .print = pool_stats_print_slab_summary_blocks_written,
-};
-
-/* Number of reference blocks written */
-static ssize_t
-pool_stats_print_ref_counts_blocks_written(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->ref_counts.blocks_written);
-}
-
-static struct pool_stats_attribute pool_stats_attr_ref_counts_blocks_written = {
- .attr = { .name = "ref_counts_blocks_written", .mode = 0444, },
- .print = pool_stats_print_ref_counts_blocks_written,
-};
-
-/* number of dirty (resident) pages */
-static ssize_t
-pool_stats_print_block_map_dirty_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.dirty_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_dirty_pages = {
- .attr = { .name = "block_map_dirty_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_dirty_pages,
-};
-
-/* number of clean (resident) pages */
-static ssize_t
-pool_stats_print_block_map_clean_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.clean_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_clean_pages = {
- .attr = { .name = "block_map_clean_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_clean_pages,
-};
-
-/* number of free pages */
-static ssize_t
-pool_stats_print_block_map_free_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.free_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_free_pages = {
- .attr = { .name = "block_map_free_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_free_pages,
-};
-
-/* number of pages in failed state */
-static ssize_t
-pool_stats_print_block_map_failed_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.failed_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_failed_pages = {
- .attr = { .name = "block_map_failed_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_failed_pages,
-};
-
-/* number of pages incoming */
-static ssize_t
-pool_stats_print_block_map_incoming_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.incoming_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_incoming_pages = {
- .attr = { .name = "block_map_incoming_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_incoming_pages,
-};
-
-/* number of pages outgoing */
-static ssize_t
-pool_stats_print_block_map_outgoing_pages(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.outgoing_pages);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_outgoing_pages = {
- .attr = { .name = "block_map_outgoing_pages", .mode = 0444, },
- .print = pool_stats_print_block_map_outgoing_pages,
-};
-
-/* how many times free page not avail */
-static ssize_t
-pool_stats_print_block_map_cache_pressure(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->block_map.cache_pressure);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_cache_pressure = {
- .attr = { .name = "block_map_cache_pressure", .mode = 0444, },
- .print = pool_stats_print_block_map_cache_pressure,
-};
-
-/* number of get_vdo_page() calls for read */
-static ssize_t
-pool_stats_print_block_map_read_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.read_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_read_count = {
- .attr = { .name = "block_map_read_count", .mode = 0444, },
- .print = pool_stats_print_block_map_read_count,
-};
-
-/* number of get_vdo_page() calls for write */
-static ssize_t
-pool_stats_print_block_map_write_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.write_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_write_count = {
- .attr = { .name = "block_map_write_count", .mode = 0444, },
- .print = pool_stats_print_block_map_write_count,
-};
-
-/* number of times pages failed to read */
-static ssize_t
-pool_stats_print_block_map_failed_reads(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.failed_reads);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_failed_reads = {
- .attr = { .name = "block_map_failed_reads", .mode = 0444, },
- .print = pool_stats_print_block_map_failed_reads,
-};
-
-/* number of times pages failed to write */
-static ssize_t
-pool_stats_print_block_map_failed_writes(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.failed_writes);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_failed_writes = {
- .attr = { .name = "block_map_failed_writes", .mode = 0444, },
- .print = pool_stats_print_block_map_failed_writes,
-};
-
-/* number of gets that are reclaimed */
-static ssize_t
-pool_stats_print_block_map_reclaimed(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.reclaimed);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_reclaimed = {
- .attr = { .name = "block_map_reclaimed", .mode = 0444, },
- .print = pool_stats_print_block_map_reclaimed,
-};
-
-/* number of gets for outgoing pages */
-static ssize_t
-pool_stats_print_block_map_read_outgoing(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.read_outgoing);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_read_outgoing = {
- .attr = { .name = "block_map_read_outgoing", .mode = 0444, },
- .print = pool_stats_print_block_map_read_outgoing,
-};
-
-/* number of gets that were already there */
-static ssize_t
-pool_stats_print_block_map_found_in_cache(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.found_in_cache);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_found_in_cache = {
- .attr = { .name = "block_map_found_in_cache", .mode = 0444, },
- .print = pool_stats_print_block_map_found_in_cache,
-};
-
-/* number of gets requiring discard */
-static ssize_t
-pool_stats_print_block_map_discard_required(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.discard_required);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_discard_required = {
- .attr = { .name = "block_map_discard_required", .mode = 0444, },
- .print = pool_stats_print_block_map_discard_required,
-};
-
-/* number of gets enqueued for their page */
-static ssize_t
-pool_stats_print_block_map_wait_for_page(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.wait_for_page);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_wait_for_page = {
- .attr = { .name = "block_map_wait_for_page", .mode = 0444, },
- .print = pool_stats_print_block_map_wait_for_page,
-};
-
-/* number of gets that have to fetch */
-static ssize_t
-pool_stats_print_block_map_fetch_required(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.fetch_required);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_fetch_required = {
- .attr = { .name = "block_map_fetch_required", .mode = 0444, },
- .print = pool_stats_print_block_map_fetch_required,
-};
-
-/* number of page fetches */
-static ssize_t
-pool_stats_print_block_map_pages_loaded(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.pages_loaded);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_pages_loaded = {
- .attr = { .name = "block_map_pages_loaded", .mode = 0444, },
- .print = pool_stats_print_block_map_pages_loaded,
-};
-
-/* number of page saves */
-static ssize_t
-pool_stats_print_block_map_pages_saved(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.pages_saved);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_pages_saved = {
- .attr = { .name = "block_map_pages_saved", .mode = 0444, },
- .print = pool_stats_print_block_map_pages_saved,
-};
-
-/* the number of flushes issued */
-static ssize_t
-pool_stats_print_block_map_flush_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->block_map.flush_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_block_map_flush_count = {
- .attr = { .name = "block_map_flush_count", .mode = 0444, },
- .print = pool_stats_print_block_map_flush_count,
-};
-
-/* Number of times the UDS advice proved correct */
-static ssize_t
-pool_stats_print_hash_lock_dedupe_advice_valid(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->hash_lock.dedupe_advice_valid);
-}
-
-static struct pool_stats_attribute pool_stats_attr_hash_lock_dedupe_advice_valid = {
- .attr = { .name = "hash_lock_dedupe_advice_valid", .mode = 0444, },
- .print = pool_stats_print_hash_lock_dedupe_advice_valid,
-};
-
-/* Number of times the UDS advice proved incorrect */
-static ssize_t
-pool_stats_print_hash_lock_dedupe_advice_stale(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->hash_lock.dedupe_advice_stale);
-}
-
-static struct pool_stats_attribute pool_stats_attr_hash_lock_dedupe_advice_stale = {
- .attr = { .name = "hash_lock_dedupe_advice_stale", .mode = 0444, },
- .print = pool_stats_print_hash_lock_dedupe_advice_stale,
-};
-
-/* Number of writes with the same data as another in-flight write */
-static ssize_t
-pool_stats_print_hash_lock_concurrent_data_matches(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->hash_lock.concurrent_data_matches);
-}
-
-static struct pool_stats_attribute pool_stats_attr_hash_lock_concurrent_data_matches = {
- .attr = { .name = "hash_lock_concurrent_data_matches", .mode = 0444, },
- .print = pool_stats_print_hash_lock_concurrent_data_matches,
-};
-
-/* Number of writes whose hash collided with an in-flight write */
-static ssize_t
-pool_stats_print_hash_lock_concurrent_hash_collisions(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->hash_lock.concurrent_hash_collisions);
-}
-
-static struct pool_stats_attribute pool_stats_attr_hash_lock_concurrent_hash_collisions = {
- .attr = { .name = "hash_lock_concurrent_hash_collisions", .mode = 0444, },
- .print = pool_stats_print_hash_lock_concurrent_hash_collisions,
-};
-
-/* Current number of dedupe queries that are in flight */
-static ssize_t
-pool_stats_print_hash_lock_curr_dedupe_queries(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->hash_lock.curr_dedupe_queries);
-}
-
-static struct pool_stats_attribute pool_stats_attr_hash_lock_curr_dedupe_queries = {
- .attr = { .name = "hash_lock_curr_dedupe_queries", .mode = 0444, },
- .print = pool_stats_print_hash_lock_curr_dedupe_queries,
-};
-
-/* number of times VDO got an invalid dedupe advice PBN from UDS */
-static ssize_t
-pool_stats_print_errors_invalid_advice_pbn_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->errors.invalid_advice_pbn_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_errors_invalid_advice_pbn_count = {
- .attr = { .name = "errors_invalid_advice_pbn_count", .mode = 0444, },
- .print = pool_stats_print_errors_invalid_advice_pbn_count,
-};
-
-/* number of times a VIO completed with a VDO_NO_SPACE error */
-static ssize_t
-pool_stats_print_errors_no_space_error_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->errors.no_space_error_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_errors_no_space_error_count = {
- .attr = { .name = "errors_no_space_error_count", .mode = 0444, },
- .print = pool_stats_print_errors_no_space_error_count,
-};
-
-/* number of times a VIO completed with a VDO_READ_ONLY error */
-static ssize_t
-pool_stats_print_errors_read_only_error_count(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->errors.read_only_error_count);
-}
-
-static struct pool_stats_attribute pool_stats_attr_errors_read_only_error_count = {
- .attr = { .name = "errors_read_only_error_count", .mode = 0444, },
- .print = pool_stats_print_errors_read_only_error_count,
-};
-
-/* The VDO instance */
-static ssize_t
-pool_stats_print_instance(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->instance);
-}
-
-static struct pool_stats_attribute pool_stats_attr_instance = {
- .attr = { .name = "instance", .mode = 0444, },
- .print = pool_stats_print_instance,
-};
-
-/* Current number of active VIOs */
-static ssize_t
-pool_stats_print_current_vios_in_progress(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->current_vios_in_progress);
-}
-
-static struct pool_stats_attribute pool_stats_attr_current_vios_in_progress = {
- .attr = { .name = "current_vios_in_progress", .mode = 0444, },
- .print = pool_stats_print_current_vios_in_progress,
-};
-
-/* Maximum number of active VIOs */
-static ssize_t
-pool_stats_print_max_vios(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%u\n", stats->max_vios);
-}
-
-static struct pool_stats_attribute pool_stats_attr_max_vios = {
- .attr = { .name = "max_vios", .mode = 0444, },
- .print = pool_stats_print_max_vios,
-};
-
-/* Number of times the UDS index was too slow in responding */
-static ssize_t
-pool_stats_print_dedupe_advice_timeouts(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->dedupe_advice_timeouts);
-}
-
-static struct pool_stats_attribute pool_stats_attr_dedupe_advice_timeouts = {
- .attr = { .name = "dedupe_advice_timeouts", .mode = 0444, },
- .print = pool_stats_print_dedupe_advice_timeouts,
-};
-
-/* Number of flush requests submitted to the storage device */
-static ssize_t
-pool_stats_print_flush_out(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->flush_out);
-}
-
-static struct pool_stats_attribute pool_stats_attr_flush_out = {
- .attr = { .name = "flush_out", .mode = 0444, },
- .print = pool_stats_print_flush_out,
-};
-
-/* Logical block size */
-static ssize_t
-pool_stats_print_logical_block_size(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->logical_block_size);
-}
-
-static struct pool_stats_attribute pool_stats_attr_logical_block_size = {
- .attr = { .name = "logical_block_size", .mode = 0444, },
- .print = pool_stats_print_logical_block_size,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_in_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_read = {
- .attr = { .name = "bios_in_read", .mode = 0444, },
- .print = pool_stats_print_bios_in_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_in_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_write = {
- .attr = { .name = "bios_in_write", .mode = 0444, },
- .print = pool_stats_print_bios_in_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_in_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_empty_flush = {
- .attr = { .name = "bios_in_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_in_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_discard = {
- .attr = { .name = "bios_in_discard", .mode = 0444, },
- .print = pool_stats_print_bios_in_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_in_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_flush = {
- .attr = { .name = "bios_in_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_in_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_fua = {
- .attr = { .name = "bios_in_fua", .mode = 0444, },
- .print = pool_stats_print_bios_in_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_in_partial_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_read = {
- .attr = { .name = "bios_in_partial_read", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_in_partial_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_write = {
- .attr = { .name = "bios_in_partial_write", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_in_partial_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_empty_flush = {
- .attr = { .name = "bios_in_partial_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_in_partial_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_discard = {
- .attr = { .name = "bios_in_partial_discard", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_in_partial_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_flush = {
- .attr = { .name = "bios_in_partial_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_in_partial_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_partial.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_partial_fua = {
- .attr = { .name = "bios_in_partial_fua", .mode = 0444, },
- .print = pool_stats_print_bios_in_partial_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_out_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_read = {
- .attr = { .name = "bios_out_read", .mode = 0444, },
- .print = pool_stats_print_bios_out_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_out_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_write = {
- .attr = { .name = "bios_out_write", .mode = 0444, },
- .print = pool_stats_print_bios_out_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_out_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_empty_flush = {
- .attr = { .name = "bios_out_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_out_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_out_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_discard = {
- .attr = { .name = "bios_out_discard", .mode = 0444, },
- .print = pool_stats_print_bios_out_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_out_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_flush = {
- .attr = { .name = "bios_out_flush", .mode = 0444, },
- .print = pool_stats_print_bios_out_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_out_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_fua = {
- .attr = { .name = "bios_out_fua", .mode = 0444, },
- .print = pool_stats_print_bios_out_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_meta_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_read = {
- .attr = { .name = "bios_meta_read", .mode = 0444, },
- .print = pool_stats_print_bios_meta_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_meta_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_write = {
- .attr = { .name = "bios_meta_write", .mode = 0444, },
- .print = pool_stats_print_bios_meta_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_meta_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_empty_flush = {
- .attr = { .name = "bios_meta_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_meta_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_meta_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_discard = {
- .attr = { .name = "bios_meta_discard", .mode = 0444, },
- .print = pool_stats_print_bios_meta_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_meta_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_flush = {
- .attr = { .name = "bios_meta_flush", .mode = 0444, },
- .print = pool_stats_print_bios_meta_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_meta_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_fua = {
- .attr = { .name = "bios_meta_fua", .mode = 0444, },
- .print = pool_stats_print_bios_meta_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_journal_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_read = {
- .attr = { .name = "bios_journal_read", .mode = 0444, },
- .print = pool_stats_print_bios_journal_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_journal_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_write = {
- .attr = { .name = "bios_journal_write", .mode = 0444, },
- .print = pool_stats_print_bios_journal_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_journal_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_empty_flush = {
- .attr = { .name = "bios_journal_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_journal_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_journal_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_discard = {
- .attr = { .name = "bios_journal_discard", .mode = 0444, },
- .print = pool_stats_print_bios_journal_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_journal_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_flush = {
- .attr = { .name = "bios_journal_flush", .mode = 0444, },
- .print = pool_stats_print_bios_journal_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_journal_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_fua = {
- .attr = { .name = "bios_journal_fua", .mode = 0444, },
- .print = pool_stats_print_bios_journal_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_page_cache_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_read = {
- .attr = { .name = "bios_page_cache_read", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_page_cache_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_write = {
- .attr = { .name = "bios_page_cache_write", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_page_cache_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_empty_flush = {
- .attr = { .name = "bios_page_cache_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_page_cache_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_discard = {
- .attr = { .name = "bios_page_cache_discard", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_page_cache_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_flush = {
- .attr = { .name = "bios_page_cache_flush", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_page_cache_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_fua = {
- .attr = { .name = "bios_page_cache_fua", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_out_completed_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_read = {
- .attr = { .name = "bios_out_completed_read", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_out_completed_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_write = {
- .attr = { .name = "bios_out_completed_write", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_out_completed_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_empty_flush = {
- .attr = { .name = "bios_out_completed_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_out_completed_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_discard = {
- .attr = { .name = "bios_out_completed_discard", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_out_completed_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_flush = {
- .attr = { .name = "bios_out_completed_flush", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_out_completed_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_out_completed.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_out_completed_fua = {
- .attr = { .name = "bios_out_completed_fua", .mode = 0444, },
- .print = pool_stats_print_bios_out_completed_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_meta_completed_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_read = {
- .attr = { .name = "bios_meta_completed_read", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_meta_completed_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_write = {
- .attr = { .name = "bios_meta_completed_write", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_meta_completed_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_empty_flush = {
- .attr = { .name = "bios_meta_completed_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_meta_completed_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_discard = {
- .attr = { .name = "bios_meta_completed_discard", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_meta_completed_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_flush = {
- .attr = { .name = "bios_meta_completed_flush", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_meta_completed_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_meta_completed.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_meta_completed_fua = {
- .attr = { .name = "bios_meta_completed_fua", .mode = 0444, },
- .print = pool_stats_print_bios_meta_completed_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_journal_completed_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_read = {
- .attr = { .name = "bios_journal_completed_read", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_journal_completed_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_write = {
- .attr = { .name = "bios_journal_completed_write", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_journal_completed_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_empty_flush = {
- .attr = { .name = "bios_journal_completed_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_journal_completed_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_discard = {
- .attr = { .name = "bios_journal_completed_discard", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_journal_completed_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_flush = {
- .attr = { .name = "bios_journal_completed_flush", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_journal_completed_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_journal_completed.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_journal_completed_fua = {
- .attr = { .name = "bios_journal_completed_fua", .mode = 0444, },
- .print = pool_stats_print_bios_journal_completed_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_read = {
- .attr = { .name = "bios_page_cache_completed_read", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_write = {
- .attr = { .name = "bios_page_cache_completed_write", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_empty_flush = {
- .attr = { .name = "bios_page_cache_completed_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_discard = {
- .attr = { .name = "bios_page_cache_completed_discard", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_flush = {
- .attr = { .name = "bios_page_cache_completed_flush", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_page_cache_completed_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_page_cache_completed.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_page_cache_completed_fua = {
- .attr = { .name = "bios_page_cache_completed_fua", .mode = 0444, },
- .print = pool_stats_print_bios_page_cache_completed_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_acknowledged_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_read = {
- .attr = { .name = "bios_acknowledged_read", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_acknowledged_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_write = {
- .attr = { .name = "bios_acknowledged_write", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_acknowledged_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_empty_flush = {
- .attr = { .name = "bios_acknowledged_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_acknowledged_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_discard = {
- .attr = { .name = "bios_acknowledged_discard", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_acknowledged_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_flush = {
- .attr = { .name = "bios_acknowledged_flush", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_acknowledged_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_fua = {
- .attr = { .name = "bios_acknowledged_fua", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_read = {
- .attr = { .name = "bios_acknowledged_partial_read", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_write = {
- .attr = { .name = "bios_acknowledged_partial_write", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_empty_flush = {
- .attr = { .name = "bios_acknowledged_partial_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_discard = {
- .attr = { .name = "bios_acknowledged_partial_discard", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_flush = {
- .attr = { .name = "bios_acknowledged_partial_flush", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_acknowledged_partial_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_acknowledged_partial.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_acknowledged_partial_fua = {
- .attr = { .name = "bios_acknowledged_partial_fua", .mode = 0444, },
- .print = pool_stats_print_bios_acknowledged_partial_fua,
-};
-
-/* Number of REQ_OP_READ bios */
-static ssize_t
-pool_stats_print_bios_in_progress_read(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.read);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_read = {
- .attr = { .name = "bios_in_progress_read", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_read,
-};
-
-/* Number of REQ_OP_WRITE bios with data */
-static ssize_t
-pool_stats_print_bios_in_progress_write(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.write);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_write = {
- .attr = { .name = "bios_in_progress_write", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_write,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH and containing no data */
-static ssize_t
-pool_stats_print_bios_in_progress_empty_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.empty_flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_empty_flush = {
- .attr = { .name = "bios_in_progress_empty_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_empty_flush,
-};
-
-/* Number of REQ_OP_DISCARD bios */
-static ssize_t
-pool_stats_print_bios_in_progress_discard(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.discard);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_discard = {
- .attr = { .name = "bios_in_progress_discard", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_discard,
-};
-
-/* Number of bios tagged with REQ_PREFLUSH */
-static ssize_t
-pool_stats_print_bios_in_progress_flush(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.flush);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_flush = {
- .attr = { .name = "bios_in_progress_flush", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_flush,
-};
-
-/* Number of bios tagged with REQ_FUA */
-static ssize_t
-pool_stats_print_bios_in_progress_fua(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->bios_in_progress.fua);
-}
-
-static struct pool_stats_attribute pool_stats_attr_bios_in_progress_fua = {
- .attr = { .name = "bios_in_progress_fua", .mode = 0444, },
- .print = pool_stats_print_bios_in_progress_fua,
-};
-
-/* Tracked bytes currently allocated. */
-static ssize_t
-pool_stats_print_memory_usage_bytes_used(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->memory_usage.bytes_used);
-}
-
-static struct pool_stats_attribute pool_stats_attr_memory_usage_bytes_used = {
- .attr = { .name = "memory_usage_bytes_used", .mode = 0444, },
- .print = pool_stats_print_memory_usage_bytes_used,
-};
-
-/* Maximum tracked bytes allocated. */
-static ssize_t
-pool_stats_print_memory_usage_peak_bytes_used(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->memory_usage.peak_bytes_used);
-}
-
-static struct pool_stats_attribute pool_stats_attr_memory_usage_peak_bytes_used = {
- .attr = { .name = "memory_usage_peak_bytes_used", .mode = 0444, },
- .print = pool_stats_print_memory_usage_peak_bytes_used,
-};
-
-/* Number of records stored in the index */
-static ssize_t
-pool_stats_print_index_entries_indexed(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.entries_indexed);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_entries_indexed = {
- .attr = { .name = "index_entries_indexed", .mode = 0444, },
- .print = pool_stats_print_index_entries_indexed,
-};
-
-/* Number of post calls that found an existing entry */
-static ssize_t
-pool_stats_print_index_posts_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.posts_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_posts_found = {
- .attr = { .name = "index_posts_found", .mode = 0444, },
- .print = pool_stats_print_index_posts_found,
-};
-
-/* Number of post calls that added a new entry */
-static ssize_t
-pool_stats_print_index_posts_not_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.posts_not_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_posts_not_found = {
- .attr = { .name = "index_posts_not_found", .mode = 0444, },
- .print = pool_stats_print_index_posts_not_found,
-};
-
-/* Number of query calls that found an existing entry */
-static ssize_t
-pool_stats_print_index_queries_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.queries_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_queries_found = {
- .attr = { .name = "index_queries_found", .mode = 0444, },
- .print = pool_stats_print_index_queries_found,
-};
-
-/* Number of query calls that added a new entry */
-static ssize_t
-pool_stats_print_index_queries_not_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.queries_not_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_queries_not_found = {
- .attr = { .name = "index_queries_not_found", .mode = 0444, },
- .print = pool_stats_print_index_queries_not_found,
-};
-
-/* Number of update calls that found an existing entry */
-static ssize_t
-pool_stats_print_index_updates_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.updates_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_updates_found = {
- .attr = { .name = "index_updates_found", .mode = 0444, },
- .print = pool_stats_print_index_updates_found,
-};
-
-/* Number of update calls that added a new entry */
-static ssize_t
-pool_stats_print_index_updates_not_found(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.updates_not_found);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_updates_not_found = {
- .attr = { .name = "index_updates_not_found", .mode = 0444, },
- .print = pool_stats_print_index_updates_not_found,
-};
-
-/* Number of entries discarded */
-static ssize_t
-pool_stats_print_index_entries_discarded(struct vdo_statistics *stats, char *buf)
-{
- return sprintf(buf, "%llu\n", stats->index.entries_discarded);
-}
-
-static struct pool_stats_attribute pool_stats_attr_index_entries_discarded = {
- .attr = { .name = "index_entries_discarded", .mode = 0444, },
- .print = pool_stats_print_index_entries_discarded,
-};
-
-struct attribute *vdo_pool_stats_attrs[] = {
- &pool_stats_attr_data_blocks_used.attr,
- &pool_stats_attr_overhead_blocks_used.attr,
- &pool_stats_attr_logical_blocks_used.attr,
- &pool_stats_attr_physical_blocks.attr,
- &pool_stats_attr_logical_blocks.attr,
- &pool_stats_attr_block_map_cache_size.attr,
- &pool_stats_attr_block_size.attr,
- &pool_stats_attr_complete_recoveries.attr,
- &pool_stats_attr_read_only_recoveries.attr,
- &pool_stats_attr_mode.attr,
- &pool_stats_attr_in_recovery_mode.attr,
- &pool_stats_attr_recovery_percentage.attr,
- &pool_stats_attr_packer_compressed_fragments_written.attr,
- &pool_stats_attr_packer_compressed_blocks_written.attr,
- &pool_stats_attr_packer_compressed_fragments_in_packer.attr,
- &pool_stats_attr_allocator_slab_count.attr,
- &pool_stats_attr_allocator_slabs_opened.attr,
- &pool_stats_attr_allocator_slabs_reopened.attr,
- &pool_stats_attr_journal_disk_full.attr,
- &pool_stats_attr_journal_slab_journal_commits_requested.attr,
- &pool_stats_attr_journal_entries_started.attr,
- &pool_stats_attr_journal_entries_written.attr,
- &pool_stats_attr_journal_entries_committed.attr,
- &pool_stats_attr_journal_blocks_started.attr,
- &pool_stats_attr_journal_blocks_written.attr,
- &pool_stats_attr_journal_blocks_committed.attr,
- &pool_stats_attr_slab_journal_disk_full_count.attr,
- &pool_stats_attr_slab_journal_flush_count.attr,
- &pool_stats_attr_slab_journal_blocked_count.attr,
- &pool_stats_attr_slab_journal_blocks_written.attr,
- &pool_stats_attr_slab_journal_tail_busy_count.attr,
- &pool_stats_attr_slab_summary_blocks_written.attr,
- &pool_stats_attr_ref_counts_blocks_written.attr,
- &pool_stats_attr_block_map_dirty_pages.attr,
- &pool_stats_attr_block_map_clean_pages.attr,
- &pool_stats_attr_block_map_free_pages.attr,
- &pool_stats_attr_block_map_failed_pages.attr,
- &pool_stats_attr_block_map_incoming_pages.attr,
- &pool_stats_attr_block_map_outgoing_pages.attr,
- &pool_stats_attr_block_map_cache_pressure.attr,
- &pool_stats_attr_block_map_read_count.attr,
- &pool_stats_attr_block_map_write_count.attr,
- &pool_stats_attr_block_map_failed_reads.attr,
- &pool_stats_attr_block_map_failed_writes.attr,
- &pool_stats_attr_block_map_reclaimed.attr,
- &pool_stats_attr_block_map_read_outgoing.attr,
- &pool_stats_attr_block_map_found_in_cache.attr,
- &pool_stats_attr_block_map_discard_required.attr,
- &pool_stats_attr_block_map_wait_for_page.attr,
- &pool_stats_attr_block_map_fetch_required.attr,
- &pool_stats_attr_block_map_pages_loaded.attr,
- &pool_stats_attr_block_map_pages_saved.attr,
- &pool_stats_attr_block_map_flush_count.attr,
- &pool_stats_attr_hash_lock_dedupe_advice_valid.attr,
- &pool_stats_attr_hash_lock_dedupe_advice_stale.attr,
- &pool_stats_attr_hash_lock_concurrent_data_matches.attr,
- &pool_stats_attr_hash_lock_concurrent_hash_collisions.attr,
- &pool_stats_attr_hash_lock_curr_dedupe_queries.attr,
- &pool_stats_attr_errors_invalid_advice_pbn_count.attr,
- &pool_stats_attr_errors_no_space_error_count.attr,
- &pool_stats_attr_errors_read_only_error_count.attr,
- &pool_stats_attr_instance.attr,
- &pool_stats_attr_current_vios_in_progress.attr,
- &pool_stats_attr_max_vios.attr,
- &pool_stats_attr_dedupe_advice_timeouts.attr,
- &pool_stats_attr_flush_out.attr,
- &pool_stats_attr_logical_block_size.attr,
- &pool_stats_attr_bios_in_read.attr,
- &pool_stats_attr_bios_in_write.attr,
- &pool_stats_attr_bios_in_empty_flush.attr,
- &pool_stats_attr_bios_in_discard.attr,
- &pool_stats_attr_bios_in_flush.attr,
- &pool_stats_attr_bios_in_fua.attr,
- &pool_stats_attr_bios_in_partial_read.attr,
- &pool_stats_attr_bios_in_partial_write.attr,
- &pool_stats_attr_bios_in_partial_empty_flush.attr,
- &pool_stats_attr_bios_in_partial_discard.attr,
- &pool_stats_attr_bios_in_partial_flush.attr,
- &pool_stats_attr_bios_in_partial_fua.attr,
- &pool_stats_attr_bios_out_read.attr,
- &pool_stats_attr_bios_out_write.attr,
- &pool_stats_attr_bios_out_empty_flush.attr,
- &pool_stats_attr_bios_out_discard.attr,
- &pool_stats_attr_bios_out_flush.attr,
- &pool_stats_attr_bios_out_fua.attr,
- &pool_stats_attr_bios_meta_read.attr,
- &pool_stats_attr_bios_meta_write.attr,
- &pool_stats_attr_bios_meta_empty_flush.attr,
- &pool_stats_attr_bios_meta_discard.attr,
- &pool_stats_attr_bios_meta_flush.attr,
- &pool_stats_attr_bios_meta_fua.attr,
- &pool_stats_attr_bios_journal_read.attr,
- &pool_stats_attr_bios_journal_write.attr,
- &pool_stats_attr_bios_journal_empty_flush.attr,
- &pool_stats_attr_bios_journal_discard.attr,
- &pool_stats_attr_bios_journal_flush.attr,
- &pool_stats_attr_bios_journal_fua.attr,
- &pool_stats_attr_bios_page_cache_read.attr,
- &pool_stats_attr_bios_page_cache_write.attr,
- &pool_stats_attr_bios_page_cache_empty_flush.attr,
- &pool_stats_attr_bios_page_cache_discard.attr,
- &pool_stats_attr_bios_page_cache_flush.attr,
- &pool_stats_attr_bios_page_cache_fua.attr,
- &pool_stats_attr_bios_out_completed_read.attr,
- &pool_stats_attr_bios_out_completed_write.attr,
- &pool_stats_attr_bios_out_completed_empty_flush.attr,
- &pool_stats_attr_bios_out_completed_discard.attr,
- &pool_stats_attr_bios_out_completed_flush.attr,
- &pool_stats_attr_bios_out_completed_fua.attr,
- &pool_stats_attr_bios_meta_completed_read.attr,
- &pool_stats_attr_bios_meta_completed_write.attr,
- &pool_stats_attr_bios_meta_completed_empty_flush.attr,
- &pool_stats_attr_bios_meta_completed_discard.attr,
- &pool_stats_attr_bios_meta_completed_flush.attr,
- &pool_stats_attr_bios_meta_completed_fua.attr,
- &pool_stats_attr_bios_journal_completed_read.attr,
- &pool_stats_attr_bios_journal_completed_write.attr,
- &pool_stats_attr_bios_journal_completed_empty_flush.attr,
- &pool_stats_attr_bios_journal_completed_discard.attr,
- &pool_stats_attr_bios_journal_completed_flush.attr,
- &pool_stats_attr_bios_journal_completed_fua.attr,
- &pool_stats_attr_bios_page_cache_completed_read.attr,
- &pool_stats_attr_bios_page_cache_completed_write.attr,
- &pool_stats_attr_bios_page_cache_completed_empty_flush.attr,
- &pool_stats_attr_bios_page_cache_completed_discard.attr,
- &pool_stats_attr_bios_page_cache_completed_flush.attr,
- &pool_stats_attr_bios_page_cache_completed_fua.attr,
- &pool_stats_attr_bios_acknowledged_read.attr,
- &pool_stats_attr_bios_acknowledged_write.attr,
- &pool_stats_attr_bios_acknowledged_empty_flush.attr,
- &pool_stats_attr_bios_acknowledged_discard.attr,
- &pool_stats_attr_bios_acknowledged_flush.attr,
- &pool_stats_attr_bios_acknowledged_fua.attr,
- &pool_stats_attr_bios_acknowledged_partial_read.attr,
- &pool_stats_attr_bios_acknowledged_partial_write.attr,
- &pool_stats_attr_bios_acknowledged_partial_empty_flush.attr,
- &pool_stats_attr_bios_acknowledged_partial_discard.attr,
- &pool_stats_attr_bios_acknowledged_partial_flush.attr,
- &pool_stats_attr_bios_acknowledged_partial_fua.attr,
- &pool_stats_attr_bios_in_progress_read.attr,
- &pool_stats_attr_bios_in_progress_write.attr,
- &pool_stats_attr_bios_in_progress_empty_flush.attr,
- &pool_stats_attr_bios_in_progress_discard.attr,
- &pool_stats_attr_bios_in_progress_flush.attr,
- &pool_stats_attr_bios_in_progress_fua.attr,
- &pool_stats_attr_memory_usage_bytes_used.attr,
- &pool_stats_attr_memory_usage_peak_bytes_used.attr,
- &pool_stats_attr_index_entries_indexed.attr,
- &pool_stats_attr_index_posts_found.attr,
- &pool_stats_attr_index_posts_not_found.attr,
- &pool_stats_attr_index_queries_found.attr,
- &pool_stats_attr_index_queries_not_found.attr,
- &pool_stats_attr_index_updates_found.attr,
- &pool_stats_attr_index_updates_not_found.attr,
- &pool_stats_attr_index_entries_discarded.attr,
- NULL,
-};
diff --git a/drivers/md/dm-vdo/pool-sysfs.c b/drivers/md/dm-vdo/pool-sysfs.c
deleted file mode 100644
index 6769c5711cbc..000000000000
--- a/drivers/md/dm-vdo/pool-sysfs.c
+++ /dev/null
@@ -1,198 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright 2023 Red Hat
- */
-
-#include "pool-sysfs.h"
-
-#include <linux/kstrtox.h>
-
-#include "memory-alloc.h"
-#include "string-utils.h"
-
-#include "data-vio.h"
-#include "dedupe.h"
-#include "vdo.h"
-
-struct pool_attribute {
- struct attribute attr;
- ssize_t (*show)(struct vdo *vdo, char *buf);
- ssize_t (*store)(struct vdo *vdo, const char *value, size_t count);
-};
-
-static ssize_t vdo_pool_attr_show(struct kobject *directory, struct attribute *attr,
- char *buf)
-{
- struct pool_attribute *pool_attr = container_of(attr, struct pool_attribute,
- attr);
- struct vdo *vdo = container_of(directory, struct vdo, vdo_directory);
-
- if (pool_attr->show == NULL)
- return -EINVAL;
- return pool_attr->show(vdo, buf);
-}
-
-static ssize_t vdo_pool_attr_store(struct kobject *directory, struct attribute *attr,
- const char *buf, size_t length)
-{
- struct pool_attribute *pool_attr = container_of(attr, struct pool_attribute,
- attr);
- struct vdo *vdo = container_of(directory, struct vdo, vdo_directory);
-
- if (pool_attr->store == NULL)
- return -EINVAL;
- return pool_attr->store(vdo, buf, length);
-}
-
-static const struct sysfs_ops vdo_pool_sysfs_ops = {
- .show = vdo_pool_attr_show,
- .store = vdo_pool_attr_store,
-};
-
-static ssize_t pool_compressing_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%s\n", (vdo_get_compressing(vdo) ? "1" : "0"));
-}
-
-static ssize_t pool_discards_active_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n",
- get_data_vio_pool_active_discards(vdo->data_vio_pool));
-}
-
-static ssize_t pool_discards_limit_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n", get_data_vio_pool_discard_limit(vdo->data_vio_pool));
-}
-
-static ssize_t pool_discards_limit_store(struct vdo *vdo, const char *buf, size_t length)
-{
- unsigned int value;
- int result;
-
- if ((length > 12) || (kstrtouint(buf, 10, &value) < 0) || (value < 1))
- return -EINVAL;
-
- result = set_data_vio_pool_discard_limit(vdo->data_vio_pool, value);
- if (result != VDO_SUCCESS)
- return -EINVAL;
-
- return length;
-}
-
-static ssize_t pool_discards_maximum_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n",
- get_data_vio_pool_maximum_discards(vdo->data_vio_pool));
-}
-
-static ssize_t pool_instance_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n", vdo->instance);
-}
-
-static ssize_t pool_requests_active_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n",
- get_data_vio_pool_active_requests(vdo->data_vio_pool));
-}
-
-static ssize_t pool_requests_limit_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n", get_data_vio_pool_request_limit(vdo->data_vio_pool));
-}
-
-static ssize_t pool_requests_maximum_show(struct vdo *vdo, char *buf)
-{
- return sprintf(buf, "%u\n",
- get_data_vio_pool_maximum_requests(vdo->data_vio_pool));
-}
-
-static void vdo_pool_release(struct kobject *directory)
-{
- vdo_free(container_of(directory, struct vdo, vdo_directory));
-}
-
-static struct pool_attribute vdo_pool_compressing_attr = {
- .attr = {
- .name = "compressing",
- .mode = 0444,
- },
- .show = pool_compressing_show,
-};
-
-static struct pool_attribute vdo_pool_discards_active_attr = {
- .attr = {
- .name = "discards_active",
- .mode = 0444,
- },
- .show = pool_discards_active_show,
-};
-
-static struct pool_attribute vdo_pool_discards_limit_attr = {
- .attr = {
- .name = "discards_limit",
- .mode = 0644,
- },
- .show = pool_discards_limit_show,
- .store = pool_discards_limit_store,
-};
-
-static struct pool_attribute vdo_pool_discards_maximum_attr = {
- .attr = {
- .name = "discards_maximum",
- .mode = 0444,
- },
- .show = pool_discards_maximum_show,
-};
-
-static struct pool_attribute vdo_pool_instance_attr = {
- .attr = {
- .name = "instance",
- .mode = 0444,
- },
- .show = pool_instance_show,
-};
-
-static struct pool_attribute vdo_pool_requests_active_attr = {
- .attr = {
- .name = "requests_active",
- .mode = 0444,
- },
- .show = pool_requests_active_show,
-};
-
-static struct pool_attribute vdo_pool_requests_limit_attr = {
- .attr = {
- .name = "requests_limit",
- .mode = 0444,
- },
- .show = pool_requests_limit_show,
-};
-
-static struct pool_attribute vdo_pool_requests_maximum_attr = {
- .attr = {
- .name = "requests_maximum",
- .mode = 0444,
- },
- .show = pool_requests_maximum_show,
-};
-
-static struct attribute *pool_attrs[] = {
- &vdo_pool_compressing_attr.attr,
- &vdo_pool_discards_active_attr.attr,
- &vdo_pool_discards_limit_attr.attr,
- &vdo_pool_discards_maximum_attr.attr,
- &vdo_pool_instance_attr.attr,
- &vdo_pool_requests_active_attr.attr,
- &vdo_pool_requests_limit_attr.attr,
- &vdo_pool_requests_maximum_attr.attr,
- NULL,
-};
-ATTRIBUTE_GROUPS(pool);
-
-const struct kobj_type vdo_directory_type = {
- .release = vdo_pool_release,
- .sysfs_ops = &vdo_pool_sysfs_ops,
- .default_groups = pool_groups,
-};
diff --git a/drivers/md/dm-vdo/pool-sysfs.h b/drivers/md/dm-vdo/pool-sysfs.h
deleted file mode 100644
index 00e680924dc1..000000000000
--- a/drivers/md/dm-vdo/pool-sysfs.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- * Copyright 2023 Red Hat
- */
-
-#ifndef VDO_POOL_SYSFS_H
-#define VDO_POOL_SYSFS_H
-
-#include <linux/kobject.h>
-
-/* The kobj_type used for setting up the kernel layer kobject. */
-extern const struct kobj_type vdo_directory_type;
-
-/* The sysfs_ops used for the "statistics" subdirectory. */
-extern const struct sysfs_ops vdo_pool_stats_sysfs_ops;
-/* The attribute used for the "statistics" subdirectory. */
-extern struct attribute *vdo_pool_stats_attrs[];
-
-#endif /* VDO_POOL_SYSFS_H */
diff --git a/drivers/md/dm-vdo/status-codes.c b/drivers/md/dm-vdo/status-codes.c
index 92c42b8bbb8b..42e87b2344bc 100644
--- a/drivers/md/dm-vdo/status-codes.c
+++ b/drivers/md/dm-vdo/status-codes.c
@@ -38,7 +38,6 @@ const struct error_info vdo_status_list[] = {
{ "VDO_BAD_NONCE", "Bad nonce" },
{ "VDO_JOURNAL_OVERFLOW", "Journal sequence number overflow" },
{ "VDO_INVALID_ADMIN_STATE", "Invalid operation for current state" },
- { "VDO_CANT_ADD_SYSFS_NODE", "Failed to add sysfs node" },
};
static atomic_t vdo_status_codes_registered = ATOMIC_INIT(0);
diff --git a/drivers/md/dm-vdo/status-codes.h b/drivers/md/dm-vdo/status-codes.h
index eb847def8eb4..72da04159f88 100644
--- a/drivers/md/dm-vdo/status-codes.h
+++ b/drivers/md/dm-vdo/status-codes.h
@@ -72,8 +72,6 @@ enum vdo_status_codes {
VDO_JOURNAL_OVERFLOW,
/* the VDO is not in a state to perform an admin operation */
VDO_INVALID_ADMIN_STATE,
- /* failure adding a sysfs node */
- VDO_CANT_ADD_SYSFS_NODE,
/* one more than last error code */
VDO_STATUS_CODE_LAST,
VDO_STATUS_CODE_BLOCK_END = VDO_ERRORS_BLOCK_END
diff --git a/drivers/md/dm-vdo/sysfs.c b/drivers/md/dm-vdo/sysfs.c
deleted file mode 100644
index 70feffe9d4c4..000000000000
--- a/drivers/md/dm-vdo/sysfs.c
+++ /dev/null
@@ -1,82 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright 2023 Red Hat
- */
-
-#include <linux/module.h>
-
-#include "logger.h"
-
-#include "constants.h"
-#include "dedupe.h"
-#include "vdo.h"
-
-static int vdo_log_level_show(char *buf, const struct kernel_param *kp)
-{
- return sprintf(buf, "%s\n", uds_log_priority_to_string(uds_get_log_level()));
-}
-
-static int vdo_log_level_store(const char *buf, const struct kernel_param *kp)
-{
- static char internal_buf[11];
-
- int n = strlen(buf);
-
- if (n > 10)
- return -EINVAL;
-
- memset(internal_buf, '\000', sizeof(internal_buf));
- memcpy(internal_buf, buf, n);
- if (internal_buf[n - 1] == '\n')
- internal_buf[n - 1] = '\000';
- uds_set_log_level(uds_log_string_to_priority(internal_buf));
- return 0;
-}
-
-
-static int vdo_dedupe_timeout_interval_store(const char *buf,
- const struct kernel_param *kp)
-{
- int result = param_set_uint(buf, kp);
-
- if (result != 0)
- return result;
- vdo_set_dedupe_index_timeout_interval(*(uint *)kp->arg);
- return 0;
-}
-
-static int vdo_min_dedupe_timer_interval_store(const char *buf,
- const struct kernel_param *kp)
-{
- int result = param_set_uint(buf, kp);
-
- if (result != 0)
- return result;
- vdo_set_dedupe_index_min_timer_interval(*(uint *)kp->arg);
- return 0;
-}
-
-static const struct kernel_param_ops log_level_ops = {
- .set = vdo_log_level_store,
- .get = vdo_log_level_show,
-};
-
-
-static const struct kernel_param_ops dedupe_timeout_ops = {
- .set = vdo_dedupe_timeout_interval_store,
- .get = param_get_uint,
-};
-
-static const struct kernel_param_ops dedupe_timer_ops = {
- .set = vdo_min_dedupe_timer_interval_store,
- .get = param_get_uint,
-};
-
-module_param_cb(log_level, &log_level_ops, NULL, 0644);
-
-
-module_param_cb(deduplication_timeout_interval, &dedupe_timeout_ops,
- &vdo_dedupe_index_timeout_interval, 0644);
-
-module_param_cb(min_deduplication_timer_interval, &dedupe_timer_ops,
- &vdo_dedupe_index_min_timer_interval, 0644);
diff --git a/drivers/md/dm-vdo/uds-sysfs.c b/drivers/md/dm-vdo/uds-sysfs.c
deleted file mode 100644
index 753d81d6f207..000000000000
--- a/drivers/md/dm-vdo/uds-sysfs.c
+++ /dev/null
@@ -1,187 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * Copyright 2023 Red Hat
- */
-
-#include "uds-sysfs.h"
-
-#include <linux/kobject.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include "logger.h"
-#include "memory-alloc.h"
-#include "string-utils.h"
-
-#include "indexer.h"
-
-#define UDS_SYSFS_NAME "uds"
-
-static struct {
- /* /sys/uds */
- struct kobject kobj;
- /* /sys/uds/parameter */
- struct kobject parameter_kobj;
-
- /* These flags are used to ensure a clean shutdown */
-
- /* /sys/uds flag */
- bool flag;
- /* /sys/uds/parameter flag */
- bool parameter_flag;
-} object_root;
-
-static char *buffer_to_string(const char *buf, size_t length)
-{
- char *string;
-
- if (vdo_allocate(length + 1, char, __func__, &string) != VDO_SUCCESS)
- return NULL;
-
- memcpy(string, buf, length);
- string[length] = '\0';
- if (string[length - 1] == '\n')
- string[length - 1] = '\0';
-
- return string;
-}
-
-/*
- * This is the code for any directory in the /sys/<module_name> tree that contains no regular files
- * (only subdirectories).
- */
-
-static void empty_release(struct kobject *kobj)
-{
-}
-
-static ssize_t empty_show(struct kobject *kobj, struct attribute *attr, char *buf)
-{
- return 0;
-}
-
-static ssize_t empty_store(struct kobject *kobj, struct attribute *attr, const char *buf,
- size_t length)
-{
- return length;
-}
-
-static const struct sysfs_ops empty_ops = {
- .show = empty_show,
- .store = empty_store,
-};
-
-static struct attribute *empty_attrs[] = {
- NULL,
-};
-ATTRIBUTE_GROUPS(empty);
-
-static const struct kobj_type empty_object_type = {
- .release = empty_release,
- .sysfs_ops = &empty_ops,
- .default_groups = empty_groups,
-};
-
-/*
- * This is the code for the /sys/<module_name>/parameter directory.
- * <dir>/log_level UDS_LOG_LEVEL
- */
-
-struct parameter_attribute {
- struct attribute attr;
- const char *(*show_string)(void);
- void (*store_string)(const char *string);
-};
-
-static ssize_t parameter_show(struct kobject *kobj, struct attribute *attr, char *buf)
-{
- struct parameter_attribute *pa;
-
- pa = container_of(attr, struct parameter_attribute, attr);
- if (pa->show_string != NULL)
- return sprintf(buf, "%s\n", pa->show_string());
- else
- return -EINVAL;
-}
-
-static ssize_t parameter_store(struct kobject *kobj, struct attribute *attr,
- const char *buf, size_t length)
-{
- char *string;
- struct parameter_attribute *pa;
-
- pa = container_of(attr, struct parameter_attribute, attr);
- if (pa->store_string == NULL)
- return -EINVAL;
- string = buffer_to_string(buf, length);
- if (string == NULL)
- return -ENOMEM;
-
- pa->store_string(string);
- vdo_free(string);
- return length;
-}
-
-static const char *parameter_show_log_level(void)
-{
- return uds_log_priority_to_string(uds_get_log_level());
-}
-
-static void parameter_store_log_level(const char *string)
-{
- uds_set_log_level(uds_log_string_to_priority(string));
-}
-
-static struct parameter_attribute log_level_attr = {
- .attr = { .name = "log_level", .mode = 0600 },
- .show_string = parameter_show_log_level,
- .store_string = parameter_store_log_level,
-};
-
-static struct attribute *parameter_attrs[] = {
- &log_level_attr.attr,
- NULL,
-};
-ATTRIBUTE_GROUPS(parameter);
-
-static const struct sysfs_ops parameter_ops = {
- .show = parameter_show,
- .store = parameter_store,
-};
-
-static const struct kobj_type parameter_object_type = {
- .release = empty_release,
- .sysfs_ops = ¶meter_ops,
- .default_groups = parameter_groups,
-};
-
-int uds_init_sysfs(void)
-{
- int result;
-
- memset(&object_root, 0, sizeof(object_root));
- kobject_init(&object_root.kobj, &empty_object_type);
- result = kobject_add(&object_root.kobj, NULL, UDS_SYSFS_NAME);
- if (result == 0) {
- object_root.flag = true;
- kobject_init(&object_root.parameter_kobj, ¶meter_object_type);
- result = kobject_add(&object_root.parameter_kobj, &object_root.kobj,
- "parameter");
- if (result == 0)
- object_root.parameter_flag = true;
- }
-
- if (result != 0)
- uds_put_sysfs();
-
- return result;
-}
-
-void uds_put_sysfs(void)
-{
- if (object_root.parameter_flag)
- kobject_put(&object_root.parameter_kobj);
-
- if (object_root.flag)
- kobject_put(&object_root.kobj);
-}
diff --git a/drivers/md/dm-vdo/uds-sysfs.h b/drivers/md/dm-vdo/uds-sysfs.h
deleted file mode 100644
index c3d00a7187bd..000000000000
--- a/drivers/md/dm-vdo/uds-sysfs.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- * Copyright 2023 Red Hat
- */
-
-#ifndef UDS_SYSFS_H
-#define UDS_SYSFS_H
-
-int uds_init_sysfs(void);
-void uds_put_sysfs(void);
-
-#endif /* UDS_SYSFS_H */
diff --git a/drivers/md/dm-vdo/vdo.c b/drivers/md/dm-vdo/vdo.c
index 11be2ab17e29..28e6352c758e 100644
--- a/drivers/md/dm-vdo/vdo.c
+++ b/drivers/md/dm-vdo/vdo.c
@@ -53,7 +53,6 @@
#include "logical-zone.h"
#include "packer.h"
#include "physical-zone.h"
-#include "pool-sysfs.h"
#include "recovery-journal.h"
#include "slab-depot.h"
#include "statistics.h"
@@ -691,13 +690,6 @@ void vdo_destroy(struct vdo *vdo)
vdo->allocations_allowed = true;
- /* Stop services that need to gather VDO statistics from the worker threads. */
- if (vdo->sysfs_added) {
- init_completion(&vdo->stats_shutdown);
- kobject_put(&vdo->stats_directory);
- wait_for_completion(&vdo->stats_shutdown);
- }
-
finish_vdo(vdo);
unregister_vdo(vdo);
free_data_vio_pool(vdo->data_vio_pool);
@@ -732,15 +724,7 @@ void vdo_destroy(struct vdo *vdo)
vdo_free(vdo_forget(vdo->compression_context));
}
-
- /*
- * The call to kobject_put on the kobj sysfs node will decrement its reference count; when
- * the count goes to zero the VDO object will be freed as a side effect.
- */
- if (!vdo->sysfs_added)
- vdo_free(vdo);
- else
- kobject_put(&vdo->vdo_directory);
+ vdo_free(vdo);
}
static int initialize_super_block(struct vdo *vdo, struct vdo_super_block *super_block)
@@ -817,42 +801,6 @@ void vdo_load_super_block(struct vdo *vdo, struct vdo_completion *parent)
REQ_OP_READ);
}
-/**
- * pool_stats_release() - Signal that sysfs stats have been shut down.
- * @directory: The vdo stats directory.
- */
-static void pool_stats_release(struct kobject *directory)
-{
- struct vdo *vdo = container_of(directory, struct vdo, stats_directory);
-
- complete(&vdo->stats_shutdown);
-}
-
-ATTRIBUTE_GROUPS(vdo_pool_stats);
-static const struct kobj_type stats_directory_type = {
- .release = pool_stats_release,
- .sysfs_ops = &vdo_pool_stats_sysfs_ops,
- .default_groups = vdo_pool_stats_groups,
-};
-
-/**
- * vdo_add_sysfs_stats_dir() - Add the stats directory to the vdo sysfs directory.
- * @vdo: The vdo.
- *
- * Return: VDO_SUCCESS or an error.
- */
-int vdo_add_sysfs_stats_dir(struct vdo *vdo)
-{
- int result;
-
- kobject_init(&vdo->stats_directory, &stats_directory_type);
- result = kobject_add(&vdo->stats_directory, &vdo->vdo_directory, "statistics");
- if (result != 0)
- return VDO_CANT_ADD_SYSFS_NODE;
-
- return VDO_SUCCESS;
-}
-
/**
* vdo_get_backing_device() - Get the block device object underlying a vdo.
* @vdo: The vdo.
diff --git a/drivers/md/dm-vdo/vdo.h b/drivers/md/dm-vdo/vdo.h
index 01558fc67f24..483ae873e002 100644
--- a/drivers/md/dm-vdo/vdo.h
+++ b/drivers/md/dm-vdo/vdo.h
@@ -10,7 +10,6 @@
#include <linux/blk_types.h>
#include <linux/completion.h>
#include <linux/dm-kcopyd.h>
-#include <linux/kobject.h>
#include <linux/list.h>
#include <linux/spinlock.h>
@@ -248,11 +247,6 @@ struct vdo {
struct vdo_statistics stats_buffer;
/* Protects the stats_buffer */
struct mutex stats_mutex;
- /* true if sysfs directory is set up */
- bool sysfs_added;
- /* Used when shutting down the sysfs statistics */
- struct completion stats_shutdown;
-
/* A list of all device_configs referencing this vdo */
struct list_head device_config_list;
@@ -264,15 +258,10 @@ struct vdo {
u64 starting_sector_offset;
struct volume_geometry geometry;
- /* For sysfs */
- struct kobject vdo_directory;
- struct kobject stats_directory;
-
/* N blobs of context data for LZ4 code, one per CPU thread. */
char **compression_context;
};
-
/**
* vdo_uses_bio_ack_queue() - Indicate whether the vdo is configured to use a separate work queue
* for acknowledging received and processed bios.
@@ -315,8 +304,6 @@ void vdo_destroy(struct vdo *vdo);
void vdo_load_super_block(struct vdo *vdo, struct vdo_completion *parent);
-int __must_check vdo_add_sysfs_stats_dir(struct vdo *vdo);
-
struct block_device * __must_check vdo_get_backing_device(const struct vdo *vdo);
const char * __must_check vdo_get_device_name(const struct dm_target *target);
--
2.42.0
