/* * Copyright (c) 2020 Red Hat, Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. */ #include "dedupeIndex.h" #include "logger.h" #include "poolSysfs.h" #include "statistics.h" #include "statusProcfs.h" #include "threadDevice.h" #include "vdo.h" typedef struct poolStatsAttribute { struct attribute attr; ssize_t (*show)(KernelLayer *layer, char *buf); } PoolStatsAttribute; static ssize_t poolStatsAttrShow(struct kobject *kobj, struct attribute *attr, char *buf) { PoolStatsAttribute *poolStatsAttr = container_of(attr, PoolStatsAttribute, attr); if (poolStatsAttr->show == NULL) { return -EINVAL; } KernelLayer *layer = container_of(kobj, KernelLayer, statsDirectory); return poolStatsAttr->show(layer, buf); } struct sysfs_ops poolStatsSysfsOps = { .show = poolStatsAttrShow, .store = NULL, }; /**********************************************************************/ /** Number of blocks used for data */ static ssize_t poolStatsDataBlocksUsedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.dataBlocksUsed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsDataBlocksUsedAttr = { .attr = { .name = "data_blocks_used", .mode = 0444, }, .show = poolStatsDataBlocksUsedShow, }; /**********************************************************************/ /** Number of blocks used for VDO metadata */ static ssize_t poolStatsOverheadBlocksUsedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.overheadBlocksUsed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsOverheadBlocksUsedAttr = { .attr = { .name = "overhead_blocks_used", .mode = 0444, }, .show = poolStatsOverheadBlocksUsedShow, }; /**********************************************************************/ /** Number of logical blocks that are currently mapped to physical blocks */ static ssize_t poolStatsLogicalBlocksUsedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.logicalBlocksUsed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsLogicalBlocksUsedAttr = { .attr = { .name = "logical_blocks_used", .mode = 0444, }, .show = poolStatsLogicalBlocksUsedShow, }; /**********************************************************************/ /** number of physical blocks */ static ssize_t poolStatsPhysicalBlocksShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.physicalBlocks); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsPhysicalBlocksAttr = { .attr = { .name = "physical_blocks", .mode = 0444, }, .show = poolStatsPhysicalBlocksShow, }; /**********************************************************************/ /** number of logical blocks */ static ssize_t poolStatsLogicalBlocksShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.logicalBlocks); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsLogicalBlocksAttr = { .attr = { .name = "logical_blocks", .mode = 0444, }, .show = poolStatsLogicalBlocksShow, }; /**********************************************************************/ /** Size of the block map page cache, in bytes */ static ssize_t poolStatsBlockMapCacheSizeShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMapCacheSize); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapCacheSizeAttr = { .attr = { .name = "block_map_cache_size", .mode = 0444, }, .show = poolStatsBlockMapCacheSizeShow, }; /**********************************************************************/ /** String describing the active write policy of the VDO */ static ssize_t poolStatsWritePolicyShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%s\n", layer->vdoStatsStorage.writePolicy); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsWritePolicyAttr = { .attr = { .name = "write_policy", .mode = 0444, }, .show = poolStatsWritePolicyShow, }; /**********************************************************************/ /** The physical block size */ static ssize_t poolStatsBlockSizeShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockSize); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockSizeAttr = { .attr = { .name = "block_size", .mode = 0444, }, .show = poolStatsBlockSizeShow, }; /**********************************************************************/ /** Number of times the VDO has successfully recovered */ static ssize_t poolStatsCompleteRecoveriesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.completeRecoveries); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsCompleteRecoveriesAttr = { .attr = { .name = "complete_recoveries", .mode = 0444, }, .show = poolStatsCompleteRecoveriesShow, }; /**********************************************************************/ /** Number of times the VDO has recovered from read-only mode */ static ssize_t poolStatsReadOnlyRecoveriesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.readOnlyRecoveries); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsReadOnlyRecoveriesAttr = { .attr = { .name = "read_only_recoveries", .mode = 0444, }, .show = poolStatsReadOnlyRecoveriesShow, }; /**********************************************************************/ /** String describing the operating mode of the VDO */ static ssize_t poolStatsModeShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%s\n", layer->vdoStatsStorage.mode); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsModeAttr = { .attr = { .name = "mode", .mode = 0444, }, .show = poolStatsModeShow, }; /**********************************************************************/ /** Whether the VDO is in recovery mode */ static ssize_t poolStatsInRecoveryModeShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%d\n", layer->vdoStatsStorage.inRecoveryMode); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsInRecoveryModeAttr = { .attr = { .name = "in_recovery_mode", .mode = 0444, }, .show = poolStatsInRecoveryModeShow, }; /**********************************************************************/ /** What percentage of recovery mode work has been completed */ static ssize_t poolStatsRecoveryPercentageShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%u\n", layer->vdoStatsStorage.recoveryPercentage); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsRecoveryPercentageAttr = { .attr = { .name = "recovery_percentage", .mode = 0444, }, .show = poolStatsRecoveryPercentageShow, }; /**********************************************************************/ /** Number of compressed data items written since startup */ static ssize_t poolStatsPackerCompressedFragmentsWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedFragmentsWritten); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsPackerCompressedFragmentsWrittenAttr = { .attr = { .name = "packer_compressed_fragments_written", .mode = 0444, }, .show = poolStatsPackerCompressedFragmentsWrittenShow, }; /**********************************************************************/ /** Number of blocks containing compressed items written since startup */ static ssize_t poolStatsPackerCompressedBlocksWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedBlocksWritten); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsPackerCompressedBlocksWrittenAttr = { .attr = { .name = "packer_compressed_blocks_written", .mode = 0444, }, .show = poolStatsPackerCompressedBlocksWrittenShow, }; /**********************************************************************/ /** Number of VIOs that are pending in the packer */ static ssize_t poolStatsPackerCompressedFragmentsInPackerShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedFragmentsInPacker); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsPackerCompressedFragmentsInPackerAttr = { .attr = { .name = "packer_compressed_fragments_in_packer", .mode = 0444, }, .show = poolStatsPackerCompressedFragmentsInPackerShow, }; /**********************************************************************/ /** The total number of slabs from which blocks may be allocated */ static ssize_t poolStatsAllocatorSlabCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsAllocatorSlabCountAttr = { .attr = { .name = "allocator_slab_count", .mode = 0444, }, .show = poolStatsAllocatorSlabCountShow, }; /**********************************************************************/ /** The total number of slabs from which blocks have ever been allocated */ static ssize_t poolStatsAllocatorSlabsOpenedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabsOpened); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsAllocatorSlabsOpenedAttr = { .attr = { .name = "allocator_slabs_opened", .mode = 0444, }, .show = poolStatsAllocatorSlabsOpenedShow, }; /**********************************************************************/ /** The number of times since loading that a slab has been re-opened */ static ssize_t poolStatsAllocatorSlabsReopenedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabsReopened); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsAllocatorSlabsReopenedAttr = { .attr = { .name = "allocator_slabs_reopened", .mode = 0444, }, .show = poolStatsAllocatorSlabsReopenedShow, }; /**********************************************************************/ /** Number of times the on-disk journal was full */ static ssize_t poolStatsJournalDiskFullShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.diskFull); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalDiskFullAttr = { .attr = { .name = "journal_disk_full", .mode = 0444, }, .show = poolStatsJournalDiskFullShow, }; /**********************************************************************/ /** Number of times the recovery journal requested slab journal commits. */ static ssize_t poolStatsJournalSlabJournalCommitsRequestedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.slabJournalCommitsRequested); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalSlabJournalCommitsRequestedAttr = { .attr = { .name = "journal_slab_journal_commits_requested", .mode = 0444, }, .show = poolStatsJournalSlabJournalCommitsRequestedShow, }; /**********************************************************************/ /** The total number of items on which processing has started */ static ssize_t poolStatsJournalEntriesStartedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.started); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalEntriesStartedAttr = { .attr = { .name = "journal_entries_started", .mode = 0444, }, .show = poolStatsJournalEntriesStartedShow, }; /**********************************************************************/ /** The total number of items for which a write operation has been issued */ static ssize_t poolStatsJournalEntriesWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.written); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalEntriesWrittenAttr = { .attr = { .name = "journal_entries_written", .mode = 0444, }, .show = poolStatsJournalEntriesWrittenShow, }; /**********************************************************************/ /** The total number of items for which a write operation has completed */ static ssize_t poolStatsJournalEntriesCommittedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.committed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalEntriesCommittedAttr = { .attr = { .name = "journal_entries_committed", .mode = 0444, }, .show = poolStatsJournalEntriesCommittedShow, }; /**********************************************************************/ /** The total number of items on which processing has started */ static ssize_t poolStatsJournalBlocksStartedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.started); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalBlocksStartedAttr = { .attr = { .name = "journal_blocks_started", .mode = 0444, }, .show = poolStatsJournalBlocksStartedShow, }; /**********************************************************************/ /** The total number of items for which a write operation has been issued */ static ssize_t poolStatsJournalBlocksWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.written); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalBlocksWrittenAttr = { .attr = { .name = "journal_blocks_written", .mode = 0444, }, .show = poolStatsJournalBlocksWrittenShow, }; /**********************************************************************/ /** The total number of items for which a write operation has completed */ static ssize_t poolStatsJournalBlocksCommittedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.committed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsJournalBlocksCommittedAttr = { .attr = { .name = "journal_blocks_committed", .mode = 0444, }, .show = poolStatsJournalBlocksCommittedShow, }; /**********************************************************************/ /** Number of times the on-disk journal was full */ static ssize_t poolStatsSlabJournalDiskFullCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.diskFullCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabJournalDiskFullCountAttr = { .attr = { .name = "slab_journal_disk_full_count", .mode = 0444, }, .show = poolStatsSlabJournalDiskFullCountShow, }; /**********************************************************************/ /** Number of times an entry was added over the flush threshold */ static ssize_t poolStatsSlabJournalFlushCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.flushCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabJournalFlushCountAttr = { .attr = { .name = "slab_journal_flush_count", .mode = 0444, }, .show = poolStatsSlabJournalFlushCountShow, }; /**********************************************************************/ /** Number of times an entry was added over the block threshold */ static ssize_t poolStatsSlabJournalBlockedCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.blockedCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabJournalBlockedCountAttr = { .attr = { .name = "slab_journal_blocked_count", .mode = 0444, }, .show = poolStatsSlabJournalBlockedCountShow, }; /**********************************************************************/ /** Number of times a tail block was written */ static ssize_t poolStatsSlabJournalBlocksWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.blocksWritten); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabJournalBlocksWrittenAttr = { .attr = { .name = "slab_journal_blocks_written", .mode = 0444, }, .show = poolStatsSlabJournalBlocksWrittenShow, }; /**********************************************************************/ /** Number of times we had to wait for the tail to write */ static ssize_t poolStatsSlabJournalTailBusyCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.tailBusyCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabJournalTailBusyCountAttr = { .attr = { .name = "slab_journal_tail_busy_count", .mode = 0444, }, .show = poolStatsSlabJournalTailBusyCountShow, }; /**********************************************************************/ /** Number of blocks written */ static ssize_t poolStatsSlabSummaryBlocksWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabSummary.blocksWritten); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsSlabSummaryBlocksWrittenAttr = { .attr = { .name = "slab_summary_blocks_written", .mode = 0444, }, .show = poolStatsSlabSummaryBlocksWrittenShow, }; /**********************************************************************/ /** Number of reference blocks written */ static ssize_t poolStatsRefCountsBlocksWrittenShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.refCounts.blocksWritten); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsRefCountsBlocksWrittenAttr = { .attr = { .name = "ref_counts_blocks_written", .mode = 0444, }, .show = poolStatsRefCountsBlocksWrittenShow, }; /**********************************************************************/ /** number of dirty (resident) pages */ static ssize_t poolStatsBlockMapDirtyPagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.dirtyPages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapDirtyPagesAttr = { .attr = { .name = "block_map_dirty_pages", .mode = 0444, }, .show = poolStatsBlockMapDirtyPagesShow, }; /**********************************************************************/ /** number of clean (resident) pages */ static ssize_t poolStatsBlockMapCleanPagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.cleanPages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapCleanPagesAttr = { .attr = { .name = "block_map_clean_pages", .mode = 0444, }, .show = poolStatsBlockMapCleanPagesShow, }; /**********************************************************************/ /** number of free pages */ static ssize_t poolStatsBlockMapFreePagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.freePages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFreePagesAttr = { .attr = { .name = "block_map_free_pages", .mode = 0444, }, .show = poolStatsBlockMapFreePagesShow, }; /**********************************************************************/ /** number of pages in failed state */ static ssize_t poolStatsBlockMapFailedPagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.failedPages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFailedPagesAttr = { .attr = { .name = "block_map_failed_pages", .mode = 0444, }, .show = poolStatsBlockMapFailedPagesShow, }; /**********************************************************************/ /** number of pages incoming */ static ssize_t poolStatsBlockMapIncomingPagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.incomingPages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapIncomingPagesAttr = { .attr = { .name = "block_map_incoming_pages", .mode = 0444, }, .show = poolStatsBlockMapIncomingPagesShow, }; /**********************************************************************/ /** number of pages outgoing */ static ssize_t poolStatsBlockMapOutgoingPagesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.outgoingPages); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapOutgoingPagesAttr = { .attr = { .name = "block_map_outgoing_pages", .mode = 0444, }, .show = poolStatsBlockMapOutgoingPagesShow, }; /**********************************************************************/ /** how many times free page not avail */ static ssize_t poolStatsBlockMapCachePressureShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.cachePressure); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapCachePressureAttr = { .attr = { .name = "block_map_cache_pressure", .mode = 0444, }, .show = poolStatsBlockMapCachePressureShow, }; /**********************************************************************/ /** number of getVDOPageAsync() for read */ static ssize_t poolStatsBlockMapReadCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.readCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapReadCountAttr = { .attr = { .name = "block_map_read_count", .mode = 0444, }, .show = poolStatsBlockMapReadCountShow, }; /**********************************************************************/ /** number or getVDOPageAsync() for write */ static ssize_t poolStatsBlockMapWriteCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.writeCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapWriteCountAttr = { .attr = { .name = "block_map_write_count", .mode = 0444, }, .show = poolStatsBlockMapWriteCountShow, }; /**********************************************************************/ /** number of times pages failed to read */ static ssize_t poolStatsBlockMapFailedReadsShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.failedReads); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFailedReadsAttr = { .attr = { .name = "block_map_failed_reads", .mode = 0444, }, .show = poolStatsBlockMapFailedReadsShow, }; /**********************************************************************/ /** number of times pages failed to write */ static ssize_t poolStatsBlockMapFailedWritesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.failedWrites); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFailedWritesAttr = { .attr = { .name = "block_map_failed_writes", .mode = 0444, }, .show = poolStatsBlockMapFailedWritesShow, }; /**********************************************************************/ /** number of gets that are reclaimed */ static ssize_t poolStatsBlockMapReclaimedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.reclaimed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapReclaimedAttr = { .attr = { .name = "block_map_reclaimed", .mode = 0444, }, .show = poolStatsBlockMapReclaimedShow, }; /**********************************************************************/ /** number of gets for outgoing pages */ static ssize_t poolStatsBlockMapReadOutgoingShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.readOutgoing); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapReadOutgoingAttr = { .attr = { .name = "block_map_read_outgoing", .mode = 0444, }, .show = poolStatsBlockMapReadOutgoingShow, }; /**********************************************************************/ /** number of gets that were already there */ static ssize_t poolStatsBlockMapFoundInCacheShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.foundInCache); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFoundInCacheAttr = { .attr = { .name = "block_map_found_in_cache", .mode = 0444, }, .show = poolStatsBlockMapFoundInCacheShow, }; /**********************************************************************/ /** number of gets requiring discard */ static ssize_t poolStatsBlockMapDiscardRequiredShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.discardRequired); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapDiscardRequiredAttr = { .attr = { .name = "block_map_discard_required", .mode = 0444, }, .show = poolStatsBlockMapDiscardRequiredShow, }; /**********************************************************************/ /** number of gets enqueued for their page */ static ssize_t poolStatsBlockMapWaitForPageShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.waitForPage); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapWaitForPageAttr = { .attr = { .name = "block_map_wait_for_page", .mode = 0444, }, .show = poolStatsBlockMapWaitForPageShow, }; /**********************************************************************/ /** number of gets that have to fetch */ static ssize_t poolStatsBlockMapFetchRequiredShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.fetchRequired); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFetchRequiredAttr = { .attr = { .name = "block_map_fetch_required", .mode = 0444, }, .show = poolStatsBlockMapFetchRequiredShow, }; /**********************************************************************/ /** number of page fetches */ static ssize_t poolStatsBlockMapPagesLoadedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.pagesLoaded); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapPagesLoadedAttr = { .attr = { .name = "block_map_pages_loaded", .mode = 0444, }, .show = poolStatsBlockMapPagesLoadedShow, }; /**********************************************************************/ /** number of page saves */ static ssize_t poolStatsBlockMapPagesSavedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.pagesSaved); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapPagesSavedAttr = { .attr = { .name = "block_map_pages_saved", .mode = 0444, }, .show = poolStatsBlockMapPagesSavedShow, }; /**********************************************************************/ /** the number of flushes issued */ static ssize_t poolStatsBlockMapFlushCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.flushCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBlockMapFlushCountAttr = { .attr = { .name = "block_map_flush_count", .mode = 0444, }, .show = poolStatsBlockMapFlushCountShow, }; /**********************************************************************/ /** Number of times the UDS advice proved correct */ static ssize_t poolStatsHashLockDedupeAdviceValidShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.hashLock.dedupeAdviceValid); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsHashLockDedupeAdviceValidAttr = { .attr = { .name = "hash_lock_dedupe_advice_valid", .mode = 0444, }, .show = poolStatsHashLockDedupeAdviceValidShow, }; /**********************************************************************/ /** Number of times the UDS advice proved incorrect */ static ssize_t poolStatsHashLockDedupeAdviceStaleShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.hashLock.dedupeAdviceStale); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsHashLockDedupeAdviceStaleAttr = { .attr = { .name = "hash_lock_dedupe_advice_stale", .mode = 0444, }, .show = poolStatsHashLockDedupeAdviceStaleShow, }; /**********************************************************************/ /** Number of writes with the same data as another in-flight write */ static ssize_t poolStatsHashLockConcurrentDataMatchesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.hashLock.concurrentDataMatches); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsHashLockConcurrentDataMatchesAttr = { .attr = { .name = "hash_lock_concurrent_data_matches", .mode = 0444, }, .show = poolStatsHashLockConcurrentDataMatchesShow, }; /**********************************************************************/ /** Number of writes whose hash collided with an in-flight write */ static ssize_t poolStatsHashLockConcurrentHashCollisionsShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.hashLock.concurrentHashCollisions); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsHashLockConcurrentHashCollisionsAttr = { .attr = { .name = "hash_lock_concurrent_hash_collisions", .mode = 0444, }, .show = poolStatsHashLockConcurrentHashCollisionsShow, }; /**********************************************************************/ /** number of times VDO got an invalid dedupe advice PBN from UDS */ static ssize_t poolStatsErrorsInvalidAdvicePBNCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.errors.invalidAdvicePBNCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsErrorsInvalidAdvicePBNCountAttr = { .attr = { .name = "errors_invalid_advicePBNCount", .mode = 0444, }, .show = poolStatsErrorsInvalidAdvicePBNCountShow, }; /**********************************************************************/ /** number of times a VIO completed with a VDO_NO_SPACE error */ static ssize_t poolStatsErrorsNoSpaceErrorCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.errors.noSpaceErrorCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsErrorsNoSpaceErrorCountAttr = { .attr = { .name = "errors_no_space_error_count", .mode = 0444, }, .show = poolStatsErrorsNoSpaceErrorCountShow, }; /**********************************************************************/ /** number of times a VIO completed with a VDO_READ_ONLY error */ static ssize_t poolStatsErrorsReadOnlyErrorCountShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage); retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.errors.readOnlyErrorCount); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsErrorsReadOnlyErrorCountAttr = { .attr = { .name = "errors_read_only_error_count", .mode = 0444, }, .show = poolStatsErrorsReadOnlyErrorCountShow, }; /**********************************************************************/ /** The VDO instance */ static ssize_t poolStatsInstanceShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->kernelStatsStorage.instance); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsInstanceAttr = { .attr = { .name = "instance", .mode = 0444, }, .show = poolStatsInstanceShow, }; /**********************************************************************/ /** Current number of active VIOs */ static ssize_t poolStatsCurrentVIOsInProgressShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->kernelStatsStorage.currentVIOsInProgress); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsCurrentVIOsInProgressAttr = { .attr = { .name = "currentVIOs_in_progress", .mode = 0444, }, .show = poolStatsCurrentVIOsInProgressShow, }; /**********************************************************************/ /** Maximum number of active VIOs */ static ssize_t poolStatsMaxVIOsShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->kernelStatsStorage.maxVIOs); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsMaxVIOsAttr = { .attr = { .name = "maxVIOs", .mode = 0444, }, .show = poolStatsMaxVIOsShow, }; /**********************************************************************/ /** Number of times the UDS index was too slow in responding */ static ssize_t poolStatsDedupeAdviceTimeoutsShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.dedupeAdviceTimeouts); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsDedupeAdviceTimeoutsAttr = { .attr = { .name = "dedupe_advice_timeouts", .mode = 0444, }, .show = poolStatsDedupeAdviceTimeoutsShow, }; /**********************************************************************/ /** Number of flush requests submitted to the storage device */ static ssize_t poolStatsFlushOutShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.flushOut); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsFlushOutAttr = { .attr = { .name = "flush_out", .mode = 0444, }, .show = poolStatsFlushOutShow, }; /**********************************************************************/ /** Logical block size */ static ssize_t poolStatsLogicalBlockSizeShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.logicalBlockSize); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsLogicalBlockSizeAttr = { .attr = { .name = "logical_block_size", .mode = 0444, }, .show = poolStatsLogicalBlockSizeShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosInReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosIn.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInReadAttr = { .attr = { .name = "bios_in_read", .mode = 0444, }, .show = poolStatsBiosInReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosInWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosIn.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInWriteAttr = { .attr = { .name = "bios_in_write", .mode = 0444, }, .show = poolStatsBiosInWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosInDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosIn.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInDiscardAttr = { .attr = { .name = "bios_in_discard", .mode = 0444, }, .show = poolStatsBiosInDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosInFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosIn.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInFlushAttr = { .attr = { .name = "bios_in_flush", .mode = 0444, }, .show = poolStatsBiosInFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosInFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosIn.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInFuaAttr = { .attr = { .name = "bios_in_fua", .mode = 0444, }, .show = poolStatsBiosInFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosInPartialReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInPartial.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInPartialReadAttr = { .attr = { .name = "bios_in_partial_read", .mode = 0444, }, .show = poolStatsBiosInPartialReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosInPartialWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInPartial.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInPartialWriteAttr = { .attr = { .name = "bios_in_partial_write", .mode = 0444, }, .show = poolStatsBiosInPartialWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosInPartialDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInPartial.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInPartialDiscardAttr = { .attr = { .name = "bios_in_partial_discard", .mode = 0444, }, .show = poolStatsBiosInPartialDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosInPartialFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInPartial.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInPartialFlushAttr = { .attr = { .name = "bios_in_partial_flush", .mode = 0444, }, .show = poolStatsBiosInPartialFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosInPartialFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInPartial.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInPartialFuaAttr = { .attr = { .name = "bios_in_partial_fua", .mode = 0444, }, .show = poolStatsBiosInPartialFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosOutReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOut.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutReadAttr = { .attr = { .name = "bios_out_read", .mode = 0444, }, .show = poolStatsBiosOutReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosOutWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOut.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutWriteAttr = { .attr = { .name = "bios_out_write", .mode = 0444, }, .show = poolStatsBiosOutWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosOutDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOut.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutDiscardAttr = { .attr = { .name = "bios_out_discard", .mode = 0444, }, .show = poolStatsBiosOutDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosOutFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOut.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutFlushAttr = { .attr = { .name = "bios_out_flush", .mode = 0444, }, .show = poolStatsBiosOutFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosOutFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOut.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutFuaAttr = { .attr = { .name = "bios_out_fua", .mode = 0444, }, .show = poolStatsBiosOutFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosMetaReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMeta.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaReadAttr = { .attr = { .name = "bios_meta_read", .mode = 0444, }, .show = poolStatsBiosMetaReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosMetaWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMeta.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaWriteAttr = { .attr = { .name = "bios_meta_write", .mode = 0444, }, .show = poolStatsBiosMetaWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosMetaDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMeta.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaDiscardAttr = { .attr = { .name = "bios_meta_discard", .mode = 0444, }, .show = poolStatsBiosMetaDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosMetaFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMeta.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaFlushAttr = { .attr = { .name = "bios_meta_flush", .mode = 0444, }, .show = poolStatsBiosMetaFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosMetaFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMeta.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaFuaAttr = { .attr = { .name = "bios_meta_fua", .mode = 0444, }, .show = poolStatsBiosMetaFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosJournalReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournal.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalReadAttr = { .attr = { .name = "bios_journal_read", .mode = 0444, }, .show = poolStatsBiosJournalReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosJournalWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournal.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalWriteAttr = { .attr = { .name = "bios_journal_write", .mode = 0444, }, .show = poolStatsBiosJournalWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosJournalDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournal.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalDiscardAttr = { .attr = { .name = "bios_journal_discard", .mode = 0444, }, .show = poolStatsBiosJournalDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosJournalFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournal.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalFlushAttr = { .attr = { .name = "bios_journal_flush", .mode = 0444, }, .show = poolStatsBiosJournalFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosJournalFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournal.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalFuaAttr = { .attr = { .name = "bios_journal_fua", .mode = 0444, }, .show = poolStatsBiosJournalFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosPageCacheReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCache.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheReadAttr = { .attr = { .name = "bios_page_cache_read", .mode = 0444, }, .show = poolStatsBiosPageCacheReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosPageCacheWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCache.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheWriteAttr = { .attr = { .name = "bios_page_cache_write", .mode = 0444, }, .show = poolStatsBiosPageCacheWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosPageCacheDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCache.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheDiscardAttr = { .attr = { .name = "bios_page_cache_discard", .mode = 0444, }, .show = poolStatsBiosPageCacheDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosPageCacheFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCache.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheFlushAttr = { .attr = { .name = "bios_page_cache_flush", .mode = 0444, }, .show = poolStatsBiosPageCacheFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosPageCacheFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCache.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheFuaAttr = { .attr = { .name = "bios_page_cache_fua", .mode = 0444, }, .show = poolStatsBiosPageCacheFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosOutCompletedReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOutCompleted.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutCompletedReadAttr = { .attr = { .name = "bios_out_completed_read", .mode = 0444, }, .show = poolStatsBiosOutCompletedReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosOutCompletedWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOutCompleted.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutCompletedWriteAttr = { .attr = { .name = "bios_out_completed_write", .mode = 0444, }, .show = poolStatsBiosOutCompletedWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosOutCompletedDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOutCompleted.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutCompletedDiscardAttr = { .attr = { .name = "bios_out_completed_discard", .mode = 0444, }, .show = poolStatsBiosOutCompletedDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosOutCompletedFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOutCompleted.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutCompletedFlushAttr = { .attr = { .name = "bios_out_completed_flush", .mode = 0444, }, .show = poolStatsBiosOutCompletedFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosOutCompletedFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosOutCompleted.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosOutCompletedFuaAttr = { .attr = { .name = "bios_out_completed_fua", .mode = 0444, }, .show = poolStatsBiosOutCompletedFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosMetaCompletedReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMetaCompleted.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaCompletedReadAttr = { .attr = { .name = "bios_meta_completed_read", .mode = 0444, }, .show = poolStatsBiosMetaCompletedReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosMetaCompletedWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMetaCompleted.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaCompletedWriteAttr = { .attr = { .name = "bios_meta_completed_write", .mode = 0444, }, .show = poolStatsBiosMetaCompletedWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosMetaCompletedDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMetaCompleted.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaCompletedDiscardAttr = { .attr = { .name = "bios_meta_completed_discard", .mode = 0444, }, .show = poolStatsBiosMetaCompletedDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosMetaCompletedFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMetaCompleted.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaCompletedFlushAttr = { .attr = { .name = "bios_meta_completed_flush", .mode = 0444, }, .show = poolStatsBiosMetaCompletedFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosMetaCompletedFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosMetaCompleted.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosMetaCompletedFuaAttr = { .attr = { .name = "bios_meta_completed_fua", .mode = 0444, }, .show = poolStatsBiosMetaCompletedFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosJournalCompletedReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournalCompleted.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalCompletedReadAttr = { .attr = { .name = "bios_journal_completed_read", .mode = 0444, }, .show = poolStatsBiosJournalCompletedReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosJournalCompletedWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournalCompleted.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalCompletedWriteAttr = { .attr = { .name = "bios_journal_completed_write", .mode = 0444, }, .show = poolStatsBiosJournalCompletedWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosJournalCompletedDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournalCompleted.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalCompletedDiscardAttr = { .attr = { .name = "bios_journal_completed_discard", .mode = 0444, }, .show = poolStatsBiosJournalCompletedDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosJournalCompletedFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournalCompleted.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalCompletedFlushAttr = { .attr = { .name = "bios_journal_completed_flush", .mode = 0444, }, .show = poolStatsBiosJournalCompletedFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosJournalCompletedFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosJournalCompleted.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosJournalCompletedFuaAttr = { .attr = { .name = "bios_journal_completed_fua", .mode = 0444, }, .show = poolStatsBiosJournalCompletedFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosPageCacheCompletedReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCacheCompleted.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheCompletedReadAttr = { .attr = { .name = "bios_page_cache_completed_read", .mode = 0444, }, .show = poolStatsBiosPageCacheCompletedReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosPageCacheCompletedWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCacheCompleted.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheCompletedWriteAttr = { .attr = { .name = "bios_page_cache_completed_write", .mode = 0444, }, .show = poolStatsBiosPageCacheCompletedWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosPageCacheCompletedDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCacheCompleted.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheCompletedDiscardAttr = { .attr = { .name = "bios_page_cache_completed_discard", .mode = 0444, }, .show = poolStatsBiosPageCacheCompletedDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosPageCacheCompletedFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCacheCompleted.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheCompletedFlushAttr = { .attr = { .name = "bios_page_cache_completed_flush", .mode = 0444, }, .show = poolStatsBiosPageCacheCompletedFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosPageCacheCompletedFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosPageCacheCompleted.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosPageCacheCompletedFuaAttr = { .attr = { .name = "bios_page_cache_completed_fua", .mode = 0444, }, .show = poolStatsBiosPageCacheCompletedFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosAcknowledgedReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledged.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedReadAttr = { .attr = { .name = "bios_acknowledged_read", .mode = 0444, }, .show = poolStatsBiosAcknowledgedReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosAcknowledgedWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledged.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedWriteAttr = { .attr = { .name = "bios_acknowledged_write", .mode = 0444, }, .show = poolStatsBiosAcknowledgedWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosAcknowledgedDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledged.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedDiscardAttr = { .attr = { .name = "bios_acknowledged_discard", .mode = 0444, }, .show = poolStatsBiosAcknowledgedDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosAcknowledgedFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledged.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedFlushAttr = { .attr = { .name = "bios_acknowledged_flush", .mode = 0444, }, .show = poolStatsBiosAcknowledgedFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosAcknowledgedFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledged.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedFuaAttr = { .attr = { .name = "bios_acknowledged_fua", .mode = 0444, }, .show = poolStatsBiosAcknowledgedFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosAcknowledgedPartialReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledgedPartial.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedPartialReadAttr = { .attr = { .name = "bios_acknowledged_partial_read", .mode = 0444, }, .show = poolStatsBiosAcknowledgedPartialReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosAcknowledgedPartialWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledgedPartial.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedPartialWriteAttr = { .attr = { .name = "bios_acknowledged_partial_write", .mode = 0444, }, .show = poolStatsBiosAcknowledgedPartialWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosAcknowledgedPartialDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledgedPartial.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedPartialDiscardAttr = { .attr = { .name = "bios_acknowledged_partial_discard", .mode = 0444, }, .show = poolStatsBiosAcknowledgedPartialDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosAcknowledgedPartialFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledgedPartial.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedPartialFlushAttr = { .attr = { .name = "bios_acknowledged_partial_flush", .mode = 0444, }, .show = poolStatsBiosAcknowledgedPartialFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosAcknowledgedPartialFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosAcknowledgedPartial.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosAcknowledgedPartialFuaAttr = { .attr = { .name = "bios_acknowledged_partial_fua", .mode = 0444, }, .show = poolStatsBiosAcknowledgedPartialFuaShow, }; /**********************************************************************/ /** Number of not REQ_WRITE bios */ static ssize_t poolStatsBiosInProgressReadShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInProgress.read); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInProgressReadAttr = { .attr = { .name = "bios_in_progress_read", .mode = 0444, }, .show = poolStatsBiosInProgressReadShow, }; /**********************************************************************/ /** Number of REQ_WRITE bios */ static ssize_t poolStatsBiosInProgressWriteShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInProgress.write); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInProgressWriteAttr = { .attr = { .name = "bios_in_progress_write", .mode = 0444, }, .show = poolStatsBiosInProgressWriteShow, }; /**********************************************************************/ /** Number of REQ_DISCARD bios */ static ssize_t poolStatsBiosInProgressDiscardShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInProgress.discard); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInProgressDiscardAttr = { .attr = { .name = "bios_in_progress_discard", .mode = 0444, }, .show = poolStatsBiosInProgressDiscardShow, }; /**********************************************************************/ /** Number of REQ_FLUSH bios */ static ssize_t poolStatsBiosInProgressFlushShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInProgress.flush); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInProgressFlushAttr = { .attr = { .name = "bios_in_progress_flush", .mode = 0444, }, .show = poolStatsBiosInProgressFlushShow, }; /**********************************************************************/ /** Number of REQ_FUA bios */ static ssize_t poolStatsBiosInProgressFuaShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.biosInProgress.fua); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsBiosInProgressFuaAttr = { .attr = { .name = "bios_in_progress_fua", .mode = 0444, }, .show = poolStatsBiosInProgressFuaShow, }; /**********************************************************************/ /** Tracked bytes currently allocated. */ static ssize_t poolStatsMemoryUsageBytesUsedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.memoryUsage.bytesUsed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsMemoryUsageBytesUsedAttr = { .attr = { .name = "memory_usage_bytes_used", .mode = 0444, }, .show = poolStatsMemoryUsageBytesUsedShow, }; /**********************************************************************/ /** Maximum tracked bytes allocated. */ static ssize_t poolStatsMemoryUsagePeakBytesUsedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.memoryUsage.peakBytesUsed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsMemoryUsagePeakBytesUsedAttr = { .attr = { .name = "memory_usage_peak_bytes_used", .mode = 0444, }, .show = poolStatsMemoryUsagePeakBytesUsedShow, }; /**********************************************************************/ /** Number of chunk names stored in the index */ static ssize_t poolStatsIndexEntriesIndexedShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.entriesIndexed); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexEntriesIndexedAttr = { .attr = { .name = "index_entries_indexed", .mode = 0444, }, .show = poolStatsIndexEntriesIndexedShow, }; /**********************************************************************/ /** Number of post calls that found an existing entry */ static ssize_t poolStatsIndexPostsFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.postsFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexPostsFoundAttr = { .attr = { .name = "index_posts_found", .mode = 0444, }, .show = poolStatsIndexPostsFoundShow, }; /**********************************************************************/ /** Number of post calls that added a new entry */ static ssize_t poolStatsIndexPostsNotFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.postsNotFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexPostsNotFoundAttr = { .attr = { .name = "index_posts_not_found", .mode = 0444, }, .show = poolStatsIndexPostsNotFoundShow, }; /**********************************************************************/ /** Number of query calls that found an existing entry */ static ssize_t poolStatsIndexQueriesFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.queriesFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexQueriesFoundAttr = { .attr = { .name = "index_queries_found", .mode = 0444, }, .show = poolStatsIndexQueriesFoundShow, }; /**********************************************************************/ /** Number of query calls that added a new entry */ static ssize_t poolStatsIndexQueriesNotFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.queriesNotFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexQueriesNotFoundAttr = { .attr = { .name = "index_queries_not_found", .mode = 0444, }, .show = poolStatsIndexQueriesNotFoundShow, }; /**********************************************************************/ /** Number of update calls that found an existing entry */ static ssize_t poolStatsIndexUpdatesFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.updatesFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexUpdatesFoundAttr = { .attr = { .name = "index_updates_found", .mode = 0444, }, .show = poolStatsIndexUpdatesFoundShow, }; /**********************************************************************/ /** Number of update calls that added a new entry */ static ssize_t poolStatsIndexUpdatesNotFoundShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%llu\n", layer->kernelStatsStorage.index.updatesNotFound); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexUpdatesNotFoundAttr = { .attr = { .name = "index_updates_not_found", .mode = 0444, }, .show = poolStatsIndexUpdatesNotFoundShow, }; /**********************************************************************/ /** Current number of dedupe queries that are in flight */ static ssize_t poolStatsIndexCurrDedupeQueriesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->kernelStatsStorage.index.currDedupeQueries); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexCurrDedupeQueriesAttr = { .attr = { .name = "index_curr_dedupe_queries", .mode = 0444, }, .show = poolStatsIndexCurrDedupeQueriesShow, }; /**********************************************************************/ /** Maximum number of dedupe queries that have been in flight */ static ssize_t poolStatsIndexMaxDedupeQueriesShow(KernelLayer *layer, char *buf) { ssize_t retval; mutex_lock(&layer->statsMutex); getKernelStats(layer, &layer->kernelStatsStorage); retval = sprintf(buf, "%" PRIu32 "\n", layer->kernelStatsStorage.index.maxDedupeQueries); mutex_unlock(&layer->statsMutex); return retval; } static PoolStatsAttribute poolStatsIndexMaxDedupeQueriesAttr = { .attr = { .name = "index_max_dedupe_queries", .mode = 0444, }, .show = poolStatsIndexMaxDedupeQueriesShow, }; struct attribute *poolStatsAttrs[] = { &poolStatsDataBlocksUsedAttr.attr, &poolStatsOverheadBlocksUsedAttr.attr, &poolStatsLogicalBlocksUsedAttr.attr, &poolStatsPhysicalBlocksAttr.attr, &poolStatsLogicalBlocksAttr.attr, &poolStatsBlockMapCacheSizeAttr.attr, &poolStatsWritePolicyAttr.attr, &poolStatsBlockSizeAttr.attr, &poolStatsCompleteRecoveriesAttr.attr, &poolStatsReadOnlyRecoveriesAttr.attr, &poolStatsModeAttr.attr, &poolStatsInRecoveryModeAttr.attr, &poolStatsRecoveryPercentageAttr.attr, &poolStatsPackerCompressedFragmentsWrittenAttr.attr, &poolStatsPackerCompressedBlocksWrittenAttr.attr, &poolStatsPackerCompressedFragmentsInPackerAttr.attr, &poolStatsAllocatorSlabCountAttr.attr, &poolStatsAllocatorSlabsOpenedAttr.attr, &poolStatsAllocatorSlabsReopenedAttr.attr, &poolStatsJournalDiskFullAttr.attr, &poolStatsJournalSlabJournalCommitsRequestedAttr.attr, &poolStatsJournalEntriesStartedAttr.attr, &poolStatsJournalEntriesWrittenAttr.attr, &poolStatsJournalEntriesCommittedAttr.attr, &poolStatsJournalBlocksStartedAttr.attr, &poolStatsJournalBlocksWrittenAttr.attr, &poolStatsJournalBlocksCommittedAttr.attr, &poolStatsSlabJournalDiskFullCountAttr.attr, &poolStatsSlabJournalFlushCountAttr.attr, &poolStatsSlabJournalBlockedCountAttr.attr, &poolStatsSlabJournalBlocksWrittenAttr.attr, &poolStatsSlabJournalTailBusyCountAttr.attr, &poolStatsSlabSummaryBlocksWrittenAttr.attr, &poolStatsRefCountsBlocksWrittenAttr.attr, &poolStatsBlockMapDirtyPagesAttr.attr, &poolStatsBlockMapCleanPagesAttr.attr, &poolStatsBlockMapFreePagesAttr.attr, &poolStatsBlockMapFailedPagesAttr.attr, &poolStatsBlockMapIncomingPagesAttr.attr, &poolStatsBlockMapOutgoingPagesAttr.attr, &poolStatsBlockMapCachePressureAttr.attr, &poolStatsBlockMapReadCountAttr.attr, &poolStatsBlockMapWriteCountAttr.attr, &poolStatsBlockMapFailedReadsAttr.attr, &poolStatsBlockMapFailedWritesAttr.attr, &poolStatsBlockMapReclaimedAttr.attr, &poolStatsBlockMapReadOutgoingAttr.attr, &poolStatsBlockMapFoundInCacheAttr.attr, &poolStatsBlockMapDiscardRequiredAttr.attr, &poolStatsBlockMapWaitForPageAttr.attr, &poolStatsBlockMapFetchRequiredAttr.attr, &poolStatsBlockMapPagesLoadedAttr.attr, &poolStatsBlockMapPagesSavedAttr.attr, &poolStatsBlockMapFlushCountAttr.attr, &poolStatsHashLockDedupeAdviceValidAttr.attr, &poolStatsHashLockDedupeAdviceStaleAttr.attr, &poolStatsHashLockConcurrentDataMatchesAttr.attr, &poolStatsHashLockConcurrentHashCollisionsAttr.attr, &poolStatsErrorsInvalidAdvicePBNCountAttr.attr, &poolStatsErrorsNoSpaceErrorCountAttr.attr, &poolStatsErrorsReadOnlyErrorCountAttr.attr, &poolStatsInstanceAttr.attr, &poolStatsCurrentVIOsInProgressAttr.attr, &poolStatsMaxVIOsAttr.attr, &poolStatsDedupeAdviceTimeoutsAttr.attr, &poolStatsFlushOutAttr.attr, &poolStatsLogicalBlockSizeAttr.attr, &poolStatsBiosInReadAttr.attr, &poolStatsBiosInWriteAttr.attr, &poolStatsBiosInDiscardAttr.attr, &poolStatsBiosInFlushAttr.attr, &poolStatsBiosInFuaAttr.attr, &poolStatsBiosInPartialReadAttr.attr, &poolStatsBiosInPartialWriteAttr.attr, &poolStatsBiosInPartialDiscardAttr.attr, &poolStatsBiosInPartialFlushAttr.attr, &poolStatsBiosInPartialFuaAttr.attr, &poolStatsBiosOutReadAttr.attr, &poolStatsBiosOutWriteAttr.attr, &poolStatsBiosOutDiscardAttr.attr, &poolStatsBiosOutFlushAttr.attr, &poolStatsBiosOutFuaAttr.attr, &poolStatsBiosMetaReadAttr.attr, &poolStatsBiosMetaWriteAttr.attr, &poolStatsBiosMetaDiscardAttr.attr, &poolStatsBiosMetaFlushAttr.attr, &poolStatsBiosMetaFuaAttr.attr, &poolStatsBiosJournalReadAttr.attr, &poolStatsBiosJournalWriteAttr.attr, &poolStatsBiosJournalDiscardAttr.attr, &poolStatsBiosJournalFlushAttr.attr, &poolStatsBiosJournalFuaAttr.attr, &poolStatsBiosPageCacheReadAttr.attr, &poolStatsBiosPageCacheWriteAttr.attr, &poolStatsBiosPageCacheDiscardAttr.attr, &poolStatsBiosPageCacheFlushAttr.attr, &poolStatsBiosPageCacheFuaAttr.attr, &poolStatsBiosOutCompletedReadAttr.attr, &poolStatsBiosOutCompletedWriteAttr.attr, &poolStatsBiosOutCompletedDiscardAttr.attr, &poolStatsBiosOutCompletedFlushAttr.attr, &poolStatsBiosOutCompletedFuaAttr.attr, &poolStatsBiosMetaCompletedReadAttr.attr, &poolStatsBiosMetaCompletedWriteAttr.attr, &poolStatsBiosMetaCompletedDiscardAttr.attr, &poolStatsBiosMetaCompletedFlushAttr.attr, &poolStatsBiosMetaCompletedFuaAttr.attr, &poolStatsBiosJournalCompletedReadAttr.attr, &poolStatsBiosJournalCompletedWriteAttr.attr, &poolStatsBiosJournalCompletedDiscardAttr.attr, &poolStatsBiosJournalCompletedFlushAttr.attr, &poolStatsBiosJournalCompletedFuaAttr.attr, &poolStatsBiosPageCacheCompletedReadAttr.attr, &poolStatsBiosPageCacheCompletedWriteAttr.attr, &poolStatsBiosPageCacheCompletedDiscardAttr.attr, &poolStatsBiosPageCacheCompletedFlushAttr.attr, &poolStatsBiosPageCacheCompletedFuaAttr.attr, &poolStatsBiosAcknowledgedReadAttr.attr, &poolStatsBiosAcknowledgedWriteAttr.attr, &poolStatsBiosAcknowledgedDiscardAttr.attr, &poolStatsBiosAcknowledgedFlushAttr.attr, &poolStatsBiosAcknowledgedFuaAttr.attr, &poolStatsBiosAcknowledgedPartialReadAttr.attr, &poolStatsBiosAcknowledgedPartialWriteAttr.attr, &poolStatsBiosAcknowledgedPartialDiscardAttr.attr, &poolStatsBiosAcknowledgedPartialFlushAttr.attr, &poolStatsBiosAcknowledgedPartialFuaAttr.attr, &poolStatsBiosInProgressReadAttr.attr, &poolStatsBiosInProgressWriteAttr.attr, &poolStatsBiosInProgressDiscardAttr.attr, &poolStatsBiosInProgressFlushAttr.attr, &poolStatsBiosInProgressFuaAttr.attr, &poolStatsMemoryUsageBytesUsedAttr.attr, &poolStatsMemoryUsagePeakBytesUsedAttr.attr, &poolStatsIndexEntriesIndexedAttr.attr, &poolStatsIndexPostsFoundAttr.attr, &poolStatsIndexPostsNotFoundAttr.attr, &poolStatsIndexQueriesFoundAttr.attr, &poolStatsIndexQueriesNotFoundAttr.attr, &poolStatsIndexUpdatesFoundAttr.attr, &poolStatsIndexUpdatesNotFoundAttr.attr, &poolStatsIndexCurrDedupeQueriesAttr.attr, &poolStatsIndexMaxDedupeQueriesAttr.attr, NULL, };