/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 */

#include "dedupeIndex.h"

#include "logger.h"

#include "poolSysfs.h"

#include "statistics.h"

#include "statusProcfs.h"

#include "threadDevice.h"

#include "vdo.h"

typedef struct poolStatsAttribute {

  struct attribute attr;

  ssize_t (*show)(KernelLayer *layer, char *buf);

} PoolStatsAttribute;

static ssize_t poolStatsAttrShow(struct kobject   *kobj,

                                 struct attribute *attr,

                                 char             *buf)

{

  PoolStatsAttribute *poolStatsAttr = container_of(attr, PoolStatsAttribute,

                                                   attr);

  if (poolStatsAttr->show == NULL) {

    return -EINVAL;

  }

  KernelLayer *layer = container_of(kobj, KernelLayer, statsDirectory);

  return poolStatsAttr->show(layer, buf);

}

struct sysfs_ops poolStatsSysfsOps = {

  .show  = poolStatsAttrShow,

  .store = NULL,

};

/**********************************************************************/

/** Number of blocks used for data */

static ssize_t poolStatsDataBlocksUsedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.dataBlocksUsed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsDataBlocksUsedAttr = {

  .attr  = { .name = "data_blocks_used", .mode = 0444, },

  .show  = poolStatsDataBlocksUsedShow,

};

/**********************************************************************/

/** Number of blocks used for VDO metadata */

static ssize_t poolStatsOverheadBlocksUsedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.overheadBlocksUsed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsOverheadBlocksUsedAttr = {

  .attr  = { .name = "overhead_blocks_used", .mode = 0444, },

  .show  = poolStatsOverheadBlocksUsedShow,

};

/**********************************************************************/

/** Number of logical blocks that are currently mapped to physical blocks */

static ssize_t poolStatsLogicalBlocksUsedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.logicalBlocksUsed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsLogicalBlocksUsedAttr = {

  .attr  = { .name = "logical_blocks_used", .mode = 0444, },

  .show  = poolStatsLogicalBlocksUsedShow,

};

/**********************************************************************/

/** number of physical blocks */

static ssize_t poolStatsPhysicalBlocksShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.physicalBlocks);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsPhysicalBlocksAttr = {

  .attr  = { .name = "physical_blocks", .mode = 0444, },

  .show  = poolStatsPhysicalBlocksShow,

};

/**********************************************************************/

/** number of logical blocks */

static ssize_t poolStatsLogicalBlocksShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.logicalBlocks);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsLogicalBlocksAttr = {

  .attr  = { .name = "logical_blocks", .mode = 0444, },

  .show  = poolStatsLogicalBlocksShow,

};

/**********************************************************************/

/** Size of the block map page cache, in bytes */

static ssize_t poolStatsBlockMapCacheSizeShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMapCacheSize);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapCacheSizeAttr = {

  .attr  = { .name = "block_map_cache_size", .mode = 0444, },

  .show  = poolStatsBlockMapCacheSizeShow,

};

/**********************************************************************/

/** String describing the active write policy of the VDO */

static ssize_t poolStatsWritePolicyShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%s\n", layer->vdoStatsStorage.writePolicy);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsWritePolicyAttr = {

  .attr  = { .name = "write_policy", .mode = 0444, },

  .show  = poolStatsWritePolicyShow,

};

/**********************************************************************/

/** The physical block size */

static ssize_t poolStatsBlockSizeShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockSize);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockSizeAttr = {

  .attr  = { .name = "block_size", .mode = 0444, },

  .show  = poolStatsBlockSizeShow,

};

/**********************************************************************/

/** Number of times the VDO has successfully recovered */

static ssize_t poolStatsCompleteRecoveriesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.completeRecoveries);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsCompleteRecoveriesAttr = {

  .attr  = { .name = "complete_recoveries", .mode = 0444, },

  .show  = poolStatsCompleteRecoveriesShow,

};

/**********************************************************************/

/** Number of times the VDO has recovered from read-only mode */

static ssize_t poolStatsReadOnlyRecoveriesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.readOnlyRecoveries);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsReadOnlyRecoveriesAttr = {

  .attr  = { .name = "read_only_recoveries", .mode = 0444, },

  .show  = poolStatsReadOnlyRecoveriesShow,

};

/**********************************************************************/

/** String describing the operating mode of the VDO */

static ssize_t poolStatsModeShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%s\n", layer->vdoStatsStorage.mode);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsModeAttr = {

  .attr  = { .name = "mode", .mode = 0444, },

  .show  = poolStatsModeShow,

};

/**********************************************************************/

/** Whether the VDO is in recovery mode */

static ssize_t poolStatsInRecoveryModeShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%d\n", layer->vdoStatsStorage.inRecoveryMode);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsInRecoveryModeAttr = {

  .attr  = { .name = "in_recovery_mode", .mode = 0444, },

  .show  = poolStatsInRecoveryModeShow,

};

/**********************************************************************/

/** What percentage of recovery mode work has been completed */

static ssize_t poolStatsRecoveryPercentageShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%u\n", layer->vdoStatsStorage.recoveryPercentage);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsRecoveryPercentageAttr = {

  .attr  = { .name = "recovery_percentage", .mode = 0444, },

  .show  = poolStatsRecoveryPercentageShow,

};

/**********************************************************************/

/** Number of compressed data items written since startup */

static ssize_t poolStatsPackerCompressedFragmentsWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedFragmentsWritten);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsPackerCompressedFragmentsWrittenAttr = {

  .attr  = { .name = "packer_compressed_fragments_written", .mode = 0444, },

  .show  = poolStatsPackerCompressedFragmentsWrittenShow,

};

/**********************************************************************/

/** Number of blocks containing compressed items written since startup */

static ssize_t poolStatsPackerCompressedBlocksWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedBlocksWritten);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsPackerCompressedBlocksWrittenAttr = {

  .attr  = { .name = "packer_compressed_blocks_written", .mode = 0444, },

  .show  = poolStatsPackerCompressedBlocksWrittenShow,

};

/**********************************************************************/

/** Number of VIOs that are pending in the packer */

static ssize_t poolStatsPackerCompressedFragmentsInPackerShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.packer.compressedFragmentsInPacker);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsPackerCompressedFragmentsInPackerAttr = {

  .attr  = { .name = "packer_compressed_fragments_in_packer", .mode = 0444, },

  .show  = poolStatsPackerCompressedFragmentsInPackerShow,

};

/**********************************************************************/

/** The total number of slabs from which blocks may be allocated */

static ssize_t poolStatsAllocatorSlabCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsAllocatorSlabCountAttr = {

  .attr  = { .name = "allocator_slab_count", .mode = 0444, },

  .show  = poolStatsAllocatorSlabCountShow,

};

/**********************************************************************/

/** The total number of slabs from which blocks have ever been allocated */

static ssize_t poolStatsAllocatorSlabsOpenedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabsOpened);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsAllocatorSlabsOpenedAttr = {

  .attr  = { .name = "allocator_slabs_opened", .mode = 0444, },

  .show  = poolStatsAllocatorSlabsOpenedShow,

};

/**********************************************************************/

/** The number of times since loading that a slab has been re-opened */

static ssize_t poolStatsAllocatorSlabsReopenedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.allocator.slabsReopened);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsAllocatorSlabsReopenedAttr = {

  .attr  = { .name = "allocator_slabs_reopened", .mode = 0444, },

  .show  = poolStatsAllocatorSlabsReopenedShow,

};

/**********************************************************************/

/** Number of times the on-disk journal was full */

static ssize_t poolStatsJournalDiskFullShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.diskFull);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalDiskFullAttr = {

  .attr  = { .name = "journal_disk_full", .mode = 0444, },

  .show  = poolStatsJournalDiskFullShow,

};

/**********************************************************************/

/** Number of times the recovery journal requested slab journal commits. */

static ssize_t poolStatsJournalSlabJournalCommitsRequestedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.slabJournalCommitsRequested);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalSlabJournalCommitsRequestedAttr = {

  .attr  = { .name = "journal_slab_journal_commits_requested", .mode = 0444, },

  .show  = poolStatsJournalSlabJournalCommitsRequestedShow,

};

/**********************************************************************/

/** The total number of items on which processing has started */

static ssize_t poolStatsJournalEntriesStartedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.started);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalEntriesStartedAttr = {

  .attr  = { .name = "journal_entries_started", .mode = 0444, },

  .show  = poolStatsJournalEntriesStartedShow,

};

/**********************************************************************/

/** The total number of items for which a write operation has been issued */

static ssize_t poolStatsJournalEntriesWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.written);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalEntriesWrittenAttr = {

  .attr  = { .name = "journal_entries_written", .mode = 0444, },

  .show  = poolStatsJournalEntriesWrittenShow,

};

/**********************************************************************/

/** The total number of items for which a write operation has completed */

static ssize_t poolStatsJournalEntriesCommittedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.entries.committed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalEntriesCommittedAttr = {

  .attr  = { .name = "journal_entries_committed", .mode = 0444, },

  .show  = poolStatsJournalEntriesCommittedShow,

};

/**********************************************************************/

/** The total number of items on which processing has started */

static ssize_t poolStatsJournalBlocksStartedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.started);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalBlocksStartedAttr = {

  .attr  = { .name = "journal_blocks_started", .mode = 0444, },

  .show  = poolStatsJournalBlocksStartedShow,

};

/**********************************************************************/

/** The total number of items for which a write operation has been issued */

static ssize_t poolStatsJournalBlocksWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.written);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalBlocksWrittenAttr = {

  .attr  = { .name = "journal_blocks_written", .mode = 0444, },

  .show  = poolStatsJournalBlocksWrittenShow,

};

/**********************************************************************/

/** The total number of items for which a write operation has completed */

static ssize_t poolStatsJournalBlocksCommittedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.journal.blocks.committed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsJournalBlocksCommittedAttr = {

  .attr  = { .name = "journal_blocks_committed", .mode = 0444, },

  .show  = poolStatsJournalBlocksCommittedShow,

};

/**********************************************************************/

/** Number of times the on-disk journal was full */

static ssize_t poolStatsSlabJournalDiskFullCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.diskFullCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabJournalDiskFullCountAttr = {

  .attr  = { .name = "slab_journal_disk_full_count", .mode = 0444, },

  .show  = poolStatsSlabJournalDiskFullCountShow,

};

/**********************************************************************/

/** Number of times an entry was added over the flush threshold */

static ssize_t poolStatsSlabJournalFlushCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.flushCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabJournalFlushCountAttr = {

  .attr  = { .name = "slab_journal_flush_count", .mode = 0444, },

  .show  = poolStatsSlabJournalFlushCountShow,

};

/**********************************************************************/

/** Number of times an entry was added over the block threshold */

static ssize_t poolStatsSlabJournalBlockedCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.blockedCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabJournalBlockedCountAttr = {

  .attr  = { .name = "slab_journal_blocked_count", .mode = 0444, },

  .show  = poolStatsSlabJournalBlockedCountShow,

};

/**********************************************************************/

/** Number of times a tail block was written */

static ssize_t poolStatsSlabJournalBlocksWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.blocksWritten);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabJournalBlocksWrittenAttr = {

  .attr  = { .name = "slab_journal_blocks_written", .mode = 0444, },

  .show  = poolStatsSlabJournalBlocksWrittenShow,

};

/**********************************************************************/

/** Number of times we had to wait for the tail to write */

static ssize_t poolStatsSlabJournalTailBusyCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabJournal.tailBusyCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabJournalTailBusyCountAttr = {

  .attr  = { .name = "slab_journal_tail_busy_count", .mode = 0444, },

  .show  = poolStatsSlabJournalTailBusyCountShow,

};

/**********************************************************************/

/** Number of blocks written */

static ssize_t poolStatsSlabSummaryBlocksWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.slabSummary.blocksWritten);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsSlabSummaryBlocksWrittenAttr = {

  .attr  = { .name = "slab_summary_blocks_written", .mode = 0444, },

  .show  = poolStatsSlabSummaryBlocksWrittenShow,

};

/**********************************************************************/

/** Number of reference blocks written */

static ssize_t poolStatsRefCountsBlocksWrittenShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.refCounts.blocksWritten);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsRefCountsBlocksWrittenAttr = {

  .attr  = { .name = "ref_counts_blocks_written", .mode = 0444, },

  .show  = poolStatsRefCountsBlocksWrittenShow,

};

/**********************************************************************/

/** number of dirty (resident) pages */

static ssize_t poolStatsBlockMapDirtyPagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.dirtyPages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapDirtyPagesAttr = {

  .attr  = { .name = "block_map_dirty_pages", .mode = 0444, },

  .show  = poolStatsBlockMapDirtyPagesShow,

};

/**********************************************************************/

/** number of clean (resident) pages */

static ssize_t poolStatsBlockMapCleanPagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.cleanPages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapCleanPagesAttr = {

  .attr  = { .name = "block_map_clean_pages", .mode = 0444, },

  .show  = poolStatsBlockMapCleanPagesShow,

};

/**********************************************************************/

/** number of free pages */

static ssize_t poolStatsBlockMapFreePagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.freePages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapFreePagesAttr = {

  .attr  = { .name = "block_map_free_pages", .mode = 0444, },

  .show  = poolStatsBlockMapFreePagesShow,

};

/**********************************************************************/

/** number of pages in failed state */

static ssize_t poolStatsBlockMapFailedPagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.failedPages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapFailedPagesAttr = {

  .attr  = { .name = "block_map_failed_pages", .mode = 0444, },

  .show  = poolStatsBlockMapFailedPagesShow,

};

/**********************************************************************/

/** number of pages incoming */

static ssize_t poolStatsBlockMapIncomingPagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.incomingPages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapIncomingPagesAttr = {

  .attr  = { .name = "block_map_incoming_pages", .mode = 0444, },

  .show  = poolStatsBlockMapIncomingPagesShow,

};

/**********************************************************************/

/** number of pages outgoing */

static ssize_t poolStatsBlockMapOutgoingPagesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.outgoingPages);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapOutgoingPagesAttr = {

  .attr  = { .name = "block_map_outgoing_pages", .mode = 0444, },

  .show  = poolStatsBlockMapOutgoingPagesShow,

};

/**********************************************************************/

/** how many times free page not avail */

static ssize_t poolStatsBlockMapCachePressureShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%" PRIu32 "\n", layer->vdoStatsStorage.blockMap.cachePressure);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapCachePressureAttr = {

  .attr  = { .name = "block_map_cache_pressure", .mode = 0444, },

  .show  = poolStatsBlockMapCachePressureShow,

};

/**********************************************************************/

/** number of getVDOPageAsync() for read */

static ssize_t poolStatsBlockMapReadCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.readCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapReadCountAttr = {

  .attr  = { .name = "block_map_read_count", .mode = 0444, },

  .show  = poolStatsBlockMapReadCountShow,

};

/**********************************************************************/

/** number or getVDOPageAsync() for write */

static ssize_t poolStatsBlockMapWriteCountShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.writeCount);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapWriteCountAttr = {

  .attr  = { .name = "block_map_write_count", .mode = 0444, },

  .show  = poolStatsBlockMapWriteCountShow,

};

/**********************************************************************/

/** number of times pages failed to read */

static ssize_t poolStatsBlockMapFailedReadsShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.failedReads);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapFailedReadsAttr = {

  .attr  = { .name = "block_map_failed_reads", .mode = 0444, },

  .show  = poolStatsBlockMapFailedReadsShow,

};

/**********************************************************************/

/** number of times pages failed to write */

static ssize_t poolStatsBlockMapFailedWritesShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.failedWrites);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapFailedWritesAttr = {

  .attr  = { .name = "block_map_failed_writes", .mode = 0444, },

  .show  = poolStatsBlockMapFailedWritesShow,

};

/**********************************************************************/

/** number of gets that are reclaimed */

static ssize_t poolStatsBlockMapReclaimedShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.reclaimed);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapReclaimedAttr = {

  .attr  = { .name = "block_map_reclaimed", .mode = 0444, },

  .show  = poolStatsBlockMapReclaimedShow,

};

/**********************************************************************/

/** number of gets for outgoing pages */

static ssize_t poolStatsBlockMapReadOutgoingShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.readOutgoing);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapReadOutgoingAttr = {

  .attr  = { .name = "block_map_read_outgoing", .mode = 0444, },

  .show  = poolStatsBlockMapReadOutgoingShow,

};

/**********************************************************************/

/** number of gets that were already there */

static ssize_t poolStatsBlockMapFoundInCacheShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.foundInCache);

  mutex_unlock(&layer->statsMutex);

  return retval;

}

static PoolStatsAttribute poolStatsBlockMapFoundInCacheAttr = {

  .attr  = { .name = "block_map_found_in_cache", .mode = 0444, },

  .show  = poolStatsBlockMapFoundInCacheShow,

};

/**********************************************************************/

/** number of gets requiring discard */

static ssize_t poolStatsBlockMapDiscardRequiredShow(KernelLayer *layer, char *buf)

{

  ssize_t retval;

  mutex_lock(&layer->statsMutex);

  getKVDOStatistics(&layer->kvdo, &layer->vdoStatsStorage);

  retval = sprintf(buf, "%llu\n", layer->vdoStatsStorage.blockMap.discardRequired);

  mutex_unlock(&layer->statsMutex);

  return retval;

}