/*
 * 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. 
 *
 * $Id: //eng/vdo-releases/aluminum/src/c++/vdo/base/slabJournalInternals.h#8 $
 */

#ifndef SLAB_JOURNAL_INTERNALS_H
#define SLAB_JOURNAL_INTERNALS_H

#include "slabJournal.h"

#include "numeric.h"

#include "blockAllocatorInternals.h"
#include "blockMapEntry.h"
#include "journalPoint.h"
#include "slab.h"
#include "slabSummary.h"
#include "statistics.h"
#include "waitQueue.h"

/**
 * Slab journal blocks may have one of two formats, depending upon whether or
 * not any of the entries in the block are block map increments. Since the
 * steady state for a VDO is that all of the necessary block map pages will
 * be allocated, most slab journal blocks will have only data entries. Such
 * blocks can hold more entries, hence the two formats.
 **/

/** A single slab journal entry */
struct slabJournalEntry {
  SlabBlockNumber  sbn;
  JournalOperation operation;
};

/** A single slab journal entry in its on-disk form */
typedef union {
  struct __attribute__((packed)) {
    uint8_t offsetLow8;
    uint8_t offsetMid8;

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned offsetHigh7 : 7;
    unsigned increment   : 1;
#else
    unsigned increment   : 1;
    unsigned offsetHigh7 : 7;
#endif
  } fields;

  // A raw view of the packed encoding.
  uint8_t raw[3];

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  // This view is only valid on little-endian machines and is only present for
  // ease of directly examining packed entries in GDB.
  struct __attribute__((packed)) {
    unsigned offset    : 23;
    unsigned increment : 1;
  } littleEndian;
#endif
} __attribute__((packed)) PackedSlabJournalEntry;

/** The unpacked representation of the header of a slab journal block */
typedef struct {
  /** Sequence number for head of journal */
  SequenceNumber     head;
  /** Sequence number for this block */
  SequenceNumber     sequenceNumber;
  /** The nonce for a given VDO instance */
  Nonce              nonce;
  /** Recovery journal point for last entry */
  JournalPoint       recoveryPoint;
  /** Metadata type */
  VDOMetadataType    metadataType;
  /** Whether this block contains block map increments */
  bool               hasBlockMapIncrements;
  /** The number of entries in the block */
  JournalEntryCount  entryCount;
} SlabJournalBlockHeader;

/**
 * The packed, on-disk representation of a slab journal block header.
 * All fields are kept in little-endian byte order.
 **/
typedef union __attribute__((packed)) {
  struct __attribute__((packed)) {
    /** 64-bit sequence number for head of journal */
    byte               head[8];
    /** 64-bit sequence number for this block */
    byte               sequenceNumber[8];
    /** Recovery journal point for last entry, packed into 64 bits */
    PackedJournalPoint recoveryPoint;
    /** The 64-bit nonce for a given VDO instance */
    byte               nonce[8];
    /** 8-bit metadata type (should always be two, for the slab journal) */
    uint8_t            metadataType;
    /** Whether this block contains block map increments */
    bool               hasBlockMapIncrements;
    /** 16-bit count of the entries encoded in the block */
    byte               entryCount[2];
  } fields;

  // A raw view of the packed encoding.
  uint8_t raw[8 + 8 + 8 + 8 + 1 + 1 + 2];

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  // This view is only valid on little-endian machines and is only present for
  // ease of directly examining packed entries in GDB.
  struct __attribute__((packed)) {
    SequenceNumber     head;
    SequenceNumber     sequenceNumber;
    PackedJournalPoint recoveryPoint;
    Nonce              nonce;
    VDOMetadataType    metadataType;
    bool               hasBlockMapIncrements;
    JournalEntryCount  entryCount;
  } littleEndian;
#endif
} PackedSlabJournalBlockHeader;

enum {
  SLAB_JOURNAL_PAYLOAD_SIZE
    = VDO_BLOCK_SIZE - sizeof(PackedSlabJournalBlockHeader),
  SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK = (SLAB_JOURNAL_PAYLOAD_SIZE * 8) / 25,
  SLAB_JOURNAL_ENTRY_TYPES_SIZE = ((SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK - 1)
                                   / 8) + 1,
  SLAB_JOURNAL_ENTRIES_PER_BLOCK = (SLAB_JOURNAL_PAYLOAD_SIZE
                                    / sizeof(PackedSlabJournalEntry)),
};

/** The payload of a slab journal block which has block map increments */
typedef struct {
  /* The entries themselves */
  PackedSlabJournalEntry entries[SLAB_JOURNAL_FULL_ENTRIES_PER_BLOCK];
  /* The bit map indicating which entries are block map increments */
  byte                   entryTypes[SLAB_JOURNAL_ENTRY_TYPES_SIZE];
} __attribute__((packed)) FullSlabJournalEntries;

typedef union {
  /* Entries which include block map increments */
  FullSlabJournalEntries fullEntries;
  /* Entries which are only data updates */
  PackedSlabJournalEntry entries[SLAB_JOURNAL_ENTRIES_PER_BLOCK];
  /* Ensure the payload fills to the end of the block */
  byte                   space[SLAB_JOURNAL_PAYLOAD_SIZE];
} __attribute__((packed)) SlabJournalPayload;

typedef struct {
  PackedSlabJournalBlockHeader header;
  SlabJournalPayload           payload;
} __attribute__((packed)) PackedSlabJournalBlock;

typedef struct {
  uint16_t       count;
  SequenceNumber recoveryStart;
} JournalLock;

struct slabJournal {
  /** A waiter object for getting a VIO pool entry */
  Waiter                       resourceWaiter;
  /** A waiter object for updating the slab summary */
  Waiter                       slabSummaryWaiter;
  /** A waiter object for getting an extent with which to flush */
  Waiter                       flushWaiter;
  /** The queue of VIOs waiting to make an entry */
  WaitQueue                    entryWaiters;
  /** The parent slab reference of this journal */
  Slab                        *slab;

  /** Whether a tail block commit is pending */
  bool                         waitingToCommit;
  /** Whether the journal is updating the slab summary */
  bool                         updatingSlabSummary;
  /** Whether the journal is adding entries from the entryWaiters queue */
  bool                         addingEntries;
  /** Whether a partial write is in progress */
  bool                         partialWriteInProgress;

  /** The oldest block in the journal on disk */
  SequenceNumber               head;
  /** The oldest block in the journal which may not be reaped */
  SequenceNumber               unreapable;
  /** The end of the half-open interval of the active journal */
  SequenceNumber               tail;
  /** The next journal block to be committed */
  SequenceNumber               nextCommit;
  /** The tail sequence number that is written in the slab summary */
  SequenceNumber               summarized;
  /** The tail sequence number that was last summarized in slab summary */
  SequenceNumber               lastSummarized;

  /** The sequence number of the recovery journal lock */
  SequenceNumber               recoveryLock;

  /**
   * The number of entries which fit in a single block. Can't use the constant
   * because unit tests change this number.
   **/
  JournalEntryCount            entriesPerBlock;
  /**
   * The number of full entries which fit in a single block. Can't use the
   * constant because unit tests change this number.
   **/
  JournalEntryCount            fullEntriesPerBlock;

  /** The recovery journal of the VDO (slab journal holds locks on it) */
  RecoveryJournal             *recoveryJournal;

  /** The slab summary to update tail block location */
  SlabSummaryZone             *summary;
  /** The statistics shared by all slab journals in our physical zone */
  AtomicSlabJournalStatistics *events;
  /** A ring of the VIO pool entries for outstanding journal block writes */
  RingNode                     uncommittedBlocks;

  /**
   * The current tail block header state. This will be packed into
   * the block just before it is written.
   **/
  SlabJournalBlockHeader       tailHeader;
  /** A pointer to a block-sized buffer holding the packed block data */
  PackedSlabJournalBlock      *block;

  /** The number of blocks in the on-disk journal */
  BlockCount                   size;
  /** The number of blocks at which to start pushing reference blocks */
  BlockCount                   flushingThreshold;
  /** The number of blocks at which all reference blocks should be writing */
  BlockCount                   flushingDeadline;
  /** The number of blocks at which to wait for reference blocks to write */
  BlockCount                   blockingThreshold;
  /** The number of blocks at which to scrub the slab before coming online */
  BlockCount                   scrubbingThreshold;

  /** This node is for BlockAllocator to keep a queue of dirty journals */
  RingNode                     dirtyNode;

  /** The lock for the oldest unreaped block of the journal */
  JournalLock                 *reapLock;
  /** The locks for each on disk block */
  JournalLock                  locks[];
};

/**
 * Get the slab journal block offset of the given sequence number.
 *
 * @param journal   The slab journal
 * @param sequence  The sequence number
 *
 * @return the offset corresponding to the sequence number
 **/
__attribute__((warn_unused_result))
static inline TailBlockOffset
getSlabJournalBlockOffset(SlabJournal *journal, SequenceNumber sequence)
{
  return (sequence % journal->size);
}

/**
 * Encode a slab journal entry (exposed for unit tests).
 *
 * @param tailHeader  The unpacked header for the block
 * @param payload     The journal block payload to hold the entry
 * @param sbn         The slab block number of the entry to encode
 * @param operation   The type of the entry
 **/
void encodeSlabJournalEntry(SlabJournalBlockHeader *tailHeader,
                            SlabJournalPayload     *payload,
                            SlabBlockNumber         sbn,
                            JournalOperation        operation);

/**
 * Decode a slab journal entry.
 *
 * @param block       The journal block holding the entry
 * @param entryCount  The number of the entry
 *
 * @return The decoded entry
 **/
SlabJournalEntry decodeSlabJournalEntry(PackedSlabJournalBlock *block,
                                        JournalEntryCount       entryCount)
  __attribute__((warn_unused_result));

/**
 * Generate the packed encoding of a slab journal entry.
 *
 * @param packed       The entry into which to pack the values
 * @param sbn          The slab block number of the entry to encode
 * @param isIncrement  The increment flag
 **/
static inline void packSlabJournalEntry(PackedSlabJournalEntry *packed,
                                        SlabBlockNumber         sbn,
                                        bool                    isIncrement)
{
  packed->fields.offsetLow8  = (sbn & 0x0000FF);
  packed->fields.offsetMid8  = (sbn & 0x00FF00) >> 8;
  packed->fields.offsetHigh7 = (sbn & 0x7F0000) >> 16;
  packed->fields.increment   = isIncrement ? 1 : 0;
}

/**
 * Decode the packed representation of a slab journal entry.
 *
 * @param packed  The packed entry to decode
 *
 * @return The decoded slab journal entry
 **/
__attribute__((warn_unused_result))
static inline
SlabJournalEntry unpackSlabJournalEntry(const PackedSlabJournalEntry *packed)
{
  SlabJournalEntry entry;
  entry.sbn = packed->fields.offsetHigh7;
  entry.sbn <<= 8;
  entry.sbn |= packed->fields.offsetMid8;
  entry.sbn <<= 8;
  entry.sbn |= packed->fields.offsetLow8;
  entry.operation
    = (packed->fields.increment ? DATA_INCREMENT : DATA_DECREMENT);
  return entry;
}

/**
 * Generate the packed representation of a slab block header.
 *
 * @param header  The header containing the values to encode
 * @param packed  The header into which to pack the values
 **/
static inline
void packSlabJournalBlockHeader(const SlabJournalBlockHeader *header,
                                PackedSlabJournalBlockHeader *packed)
{
  storeUInt64LE(packed->fields.head,           header->head);
  storeUInt64LE(packed->fields.sequenceNumber, header->sequenceNumber);
  storeUInt64LE(packed->fields.nonce,          header->nonce);
  storeUInt16LE(packed->fields.entryCount,     header->entryCount);

  packed->fields.metadataType          = header->metadataType;
  packed->fields.hasBlockMapIncrements = header->hasBlockMapIncrements;

  packJournalPoint(&header->recoveryPoint, &packed->fields.recoveryPoint);
}

/**
 * Decode the packed representation of a slab block header.
 *
 * @param packed  The packed header to decode
 * @param header  The header into which to unpack the values
 **/
static inline
void unpackSlabJournalBlockHeader(const PackedSlabJournalBlockHeader *packed,
                                  SlabJournalBlockHeader             *header)
{
  *header = (SlabJournalBlockHeader) {
    .head                  = getUInt64LE(packed->fields.head),
    .sequenceNumber        = getUInt64LE(packed->fields.sequenceNumber),
    .nonce                 = getUInt64LE(packed->fields.nonce),
    .entryCount            = getUInt16LE(packed->fields.entryCount),
    .metadataType          = packed->fields.metadataType,
    .hasBlockMapIncrements = packed->fields.hasBlockMapIncrements,
  };
  unpackJournalPoint(&packed->fields.recoveryPoint, &header->recoveryPoint);
}

#endif // SLAB_JOURNAL_INTERNALS_H
