/*
* 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.
*
* $Id: //eng/vdo-releases/aluminum/src/c++/vdo/base/types.h#14 $
*/
#ifndef TYPES_H
#define TYPES_H
#include "blockMappingState.h"
#include "common.h"
#include "statusCodes.h"
/**
* A size type in blocks.
**/
typedef uint64_t BlockCount;
/**
* The size of a block.
**/
typedef uint16_t BlockSize;
/**
* A count of compressed fragments
**/
typedef uint8_t CompressedFragmentCount;
/**
* A CRC-32 checksum
**/
typedef uint32_t CRC32Checksum;
/**
* A height within a tree.
**/
typedef uint8_t Height;
/**
* The logical block number as used by the consumer.
**/
typedef uint64_t LogicalBlockNumber;
/**
* The type of the nonce used to identify instances of VDO.
**/
typedef uint64_t Nonce;
/**
* A size in pages.
**/
typedef uint32_t PageCount;
/**
* A page number.
**/
typedef uint32_t PageNumber;
/**
* The size of a page. Must be evenly divisible by block size.
**/
typedef uint32_t PageSize;
/**
* The physical (well, less logical) block number at which the block is found
* on the underlying device.
**/
typedef uint64_t PhysicalBlockNumber;
/**
* A release version number. These numbers are used to make the numbering
* space for component versions independent across release branches.
*
* Really an enum, but we have to specify the size for encoding; see
* releaseVersions.h for the enumeration values.
**/
typedef uint32_t ReleaseVersionNumber;
/**
* A count of tree roots.
**/
typedef uint8_t RootCount;
/**
* A number of sectors.
**/
typedef uint8_t SectorCount;
/**
* A sequence number.
**/
typedef uint64_t SequenceNumber;
/**
* A size type in slabs.
**/
typedef uint16_t SlabCount;
/**
* A slot in a bin or block map page.
**/
typedef uint16_t SlotNumber;
/**
* A number of VIOs.
**/
typedef uint16_t VIOCount;
/**
* A VDO thread configuration.
**/
typedef struct threadConfig ThreadConfig;
/**
* A thread counter
**/
typedef uint8_t ThreadCount;
/**
* A thread ID
*
* Base-code threads are numbered sequentially starting from 0.
**/
typedef uint8_t ThreadID;
/**
* The thread ID returned when the current base code thread ID cannot be found
* or is otherwise undefined.
**/
static const ThreadID INVALID_THREAD_ID = (ThreadID) -1;
/**
* A zone counter
**/
typedef uint8_t ZoneCount;
/**
* The type of request a VIO is performing
**/
typedef enum __attribute__((packed)) vioOperation {
VIO_UNSPECIFIED_OPERATION = 0,
VIO_READ = 1,
VIO_WRITE = 2,
VIO_READ_MODIFY_WRITE = VIO_READ | VIO_WRITE,
VIO_READ_WRITE_MASK = VIO_READ_MODIFY_WRITE,
VIO_FLUSH_BEFORE = 4,
VIO_FLUSH_AFTER = 8,
} VIOOperation;
/**
* VIO types for statistics and instrumentation.
**/
typedef enum __attribute__((packed)) {
VIO_TYPE_UNINITIALIZED = 0,
VIO_TYPE_DATA,
VIO_TYPE_BLOCK_ALLOCATOR,
VIO_TYPE_BLOCK_MAP,
VIO_TYPE_BLOCK_MAP_INTERIOR,
VIO_TYPE_COMPRESSED_BLOCK,
VIO_TYPE_PARTITION_COPY,
VIO_TYPE_RECOVERY_JOURNAL,
VIO_TYPE_SLAB_JOURNAL,
VIO_TYPE_SLAB_SUMMARY,
VIO_TYPE_SUPER_BLOCK,
VIO_TYPE_TEST,
} VIOType;
/**
* The current operation on a physical block (from the point of view of the
* recovery journal, slab journals, and reference counts.
**/
typedef enum __attribute__((packed)) {
DATA_DECREMENT = 0,
DATA_INCREMENT = 1,
BLOCK_MAP_DECREMENT = 2,
BLOCK_MAP_INCREMENT = 3,
} JournalOperation;
/**
* Partition IDs are encoded in the volume layout in the super block.
**/
typedef enum __attribute__((packed)) {
BLOCK_MAP_PARTITION = 0,
BLOCK_ALLOCATOR_PARTITION = 1,
RECOVERY_JOURNAL_PARTITION = 2,
SLAB_SUMMARY_PARTITION = 3,
} PartitionID;
/**
* Check whether a VIOType is for servicing an external data request.
*
* @param vioType The VIOType to check
**/
static inline bool isDataVIOType(VIOType vioType)
{
return (vioType == VIO_TYPE_DATA);
}
/**
* Check whether a VIOType is for compressed block writes
*
* @param vioType The VIOType to check
**/
static inline bool isCompressedWriteVIOType(VIOType vioType)
{
return (vioType == VIO_TYPE_COMPRESSED_BLOCK);
}
/**
* Check whether a VIOType is for metadata
*
* @param vioType The VIOType to check
**/
static inline bool isMetadataVIOType(VIOType vioType)
{
return ((vioType != VIO_TYPE_UNINITIALIZED)
&& !isDataVIOType(vioType)
&& !isCompressedWriteVIOType(vioType));
}
/**
* Priority levels for asynchronous I/O operations performed on a VIO.
**/
typedef enum __attribute__((packed)) vioPriority {
VIO_PRIORITY_LOW = 0,
VIO_PRIORITY_DATA = VIO_PRIORITY_LOW,
VIO_PRIORITY_COMPRESSED_DATA = VIO_PRIORITY_DATA,
VIO_PRIORITY_METADATA,
VIO_PRIORITY_HIGH,
} VIOPriority;
/**
* Metadata types for the VDO.
**/
typedef enum __attribute__((packed)) {
VDO_METADATA_RECOVERY_JOURNAL = 1,
VDO_METADATA_SLAB_JOURNAL,
} VDOMetadataType;
/**
* The possible write policy values.
**/
typedef enum {
WRITE_POLICY_SYNC, ///< All writes are synchronous, i. e., they
///< are acknowledged only when the data is
///< written to stable storage.
WRITE_POLICY_ASYNC, ///< Writes are acknowledged when the data is
///< cached for writing to stable storage, subject
///< to resiliency guarantees specified elsewhere.
///< After a crash, the data will be either old or
///< new value for unflushed writes, never garbage.
WRITE_POLICY_ASYNC_UNSAFE, ///< Writes are acknowledged when the data is
///< cached for writing to stable storage, subject
///< to resiliency guarantees specified elsewhere.
WRITE_POLICY_AUTO, ///< The appropriate policy is chosen based on the
///< underlying device
} WritePolicy;
typedef enum {
ZONE_TYPE_ADMIN,
ZONE_TYPE_JOURNAL,
ZONE_TYPE_LOGICAL,
ZONE_TYPE_PHYSICAL,
} ZoneType;
/**
* A position in the block map where a block map entry is stored.
**/
typedef struct {
PhysicalBlockNumber pbn;
SlotNumber slot;
} BlockMapSlot;
/**
* A position in the arboreal block map at a specific level.
**/
typedef struct {
PageNumber pageIndex;
BlockMapSlot blockMapSlot;
} BlockMapTreeSlot;
/**
* The configuration of a single slab derived from the configured block size
* and slab size.
**/
typedef struct slabConfig {
BlockCount slabBlocks; ///< total number of blocks in the slab
BlockCount dataBlocks; ///< number of blocks available for data
BlockCount referenceCountBlocks; ///< number of blocks for refCounts
BlockCount slabJournalBlocks; ///< number of blocks for the slab journal
/**
* Number of blocks after which the slab journal starts pushing out a
* ReferenceBlock for each new entry it receives.
**/
BlockCount slabJournalFlushingThreshold;
/**
* Number of blocks after which the slab journal pushes out all
* ReferenceBlocks and makes all VIOs wait.
**/
BlockCount slabJournalBlockingThreshold;
/**
* Number of blocks after which the slab must be scrubbed before coming
* online.
**/
BlockCount slabJournalScrubbingThreshold;
} __attribute__((packed)) SlabConfig;
/**
* The configuration of the VDO service.
**/
typedef struct vdoConfig {
BlockCount logicalBlocks; ///< number of logical blocks
BlockCount physicalBlocks; ///< number of physical blocks
BlockCount slabSize; ///< number of blocks in a slab
BlockCount recoveryJournalSize; ///< number of recovery journal blocks
BlockCount slabJournalBlocks; ///< number of slab journal blocks
} __attribute__((packed)) VDOConfig;
/**
* The configuration parameters of the VDO service specified at load time.
**/
typedef struct vdoLoadConfig {
/** the offset on the physical layer where the VDO begins */
PhysicalBlockNumber firstBlockOffset;
/** the expected release version number of the VDO */
ReleaseVersionNumber releaseVersion;
/** the expected nonce of the VDO */
Nonce nonce;
/** the thread configuration of the VDO */
ThreadConfig *threadConfig;
/** the page cache size, in pages */
PageCount cacheSize;
/** whether writes are synchronous */
WritePolicy writePolicy;
/** the maximum age of a dirty block map page in recovery journal blocks */
BlockCount maximumAge;
} VDOLoadConfig;
/**
* Forward declarations of abstract types
**/
typedef struct actionManager ActionManager;
typedef struct allocatingVIO AllocatingVIO;
typedef struct allocationSelector AllocationSelector;
typedef struct blockAllocator BlockAllocator;
typedef struct blockMap BlockMap;
typedef struct blockMapTreeZone BlockMapTreeZone;
typedef struct blockMapZone BlockMapZone;
typedef struct dataVIO DataVIO;
typedef struct flusher Flusher;
typedef struct forest Forest;
typedef struct hashLock HashLock;
typedef struct hashZone HashZone;
typedef struct indexConfig IndexConfig;
typedef struct inputBin InputBin;
typedef struct lbnLock LBNLock;
typedef struct lockCounter LockCounter;
typedef struct logicalZone LogicalZone;
typedef struct logicalZones LogicalZones;
typedef struct pbnLock PBNLock;
typedef struct physicalLayer PhysicalLayer;
typedef struct physicalZone PhysicalZone;
typedef struct recoveryJournal RecoveryJournal;
typedef struct readOnlyNotifier ReadOnlyNotifier;
typedef struct refCounts RefCounts;
typedef struct vdoSlab Slab;
typedef struct slabDepot SlabDepot;
typedef struct slabJournal SlabJournal;
typedef struct slabJournalEntry SlabJournalEntry;
typedef struct slabScrubber SlabScrubber;
typedef struct slabSummary SlabSummary;
typedef struct slabSummaryZone SlabSummaryZone;
typedef struct vdo VDO;
typedef struct vdoCompletion VDOCompletion;
typedef struct vdoExtent VDOExtent;
typedef struct vdoFlush VDOFlush;
typedef struct vdoLayout VDOLayout;
typedef struct vdoStatistics VDOStatistics;
typedef struct vio VIO;
typedef struct vioPool VIOPool;
typedef struct {
PhysicalBlockNumber pbn;
BlockMappingState state;
} DataLocation;
typedef struct {
PhysicalBlockNumber pbn;
BlockMappingState state;
PhysicalZone *zone;
} ZonedPBN;
/**
* Callback which will be called by the VDO when all of the VIOs in the
* extent have been processed.
*
* @param extent The extent which is complete
**/
typedef void VDOExtentCallback(VDOExtent *extent);
/**
* An asynchronous operation.
*
* @param vio The VIO on which to operate
**/
typedef void AsyncOperation(VIO *vio);
/**
* An asynchronous compressed write operation.
*
* @param allocatingVIO The AllocatingVIO to write
**/
typedef void CompressedWriter(AllocatingVIO *allocatingVIO);
/**
* An asynchronous data operation.
*
* @param dataVIO The DataVIO on which to operate
**/
typedef void AsyncDataOperation(DataVIO *dataVIO);
/**
* A reference to a completion which (the reference) can be enqueued
* for completion on a specified thread.
**/
typedef struct enqueueable {
VDOCompletion *completion;
} Enqueueable;
#endif // TYPES_H