/*
 * Copyright Red Hat
 *
 * 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,
};
