/*
 * 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/packedRecoveryJournalBlock.h#3 $
 */

#ifndef PACKED_RECOVERY_JOURNAL_BLOCK_H
#define PACKED_RECOVERY_JOURNAL_BLOCK_H

#include "numeric.h"

#include "constants.h"
#include "recoveryJournalEntry.h"
#include "types.h"

typedef struct {
  SequenceNumber    blockMapHead;       // Block map head sequence number
  SequenceNumber    slabJournalHead;    // Slab journal head sequence number
  SequenceNumber    sequenceNumber;     // Sequence number for this block
  Nonce             nonce;              // A given VDO instance's nonce
  BlockCount        logicalBlocksUsed;  // Count of logical blocks in use
  BlockCount        blockMapDataBlocks; // Count of allocated block map pages
  JournalEntryCount entryCount;         // Number of entries written
  uint8_t           checkByte;          // The protection check byte
  uint8_t           recoveryCount;      // The number of recoveries completed
  VDOMetadataType   metadataType;       // Metadata type
} RecoveryBlockHeader;

/**
 * The packed, on-disk representation of a recovery journal block header.
 * All fields are kept in little-endian byte order.
 **/
typedef union __attribute__((packed)) {
  struct __attribute__((packed)) {
    /** Block map head 64-bit sequence number */
    byte    blockMapHead[8];

    /** Slab journal head 64-bit sequence number */
    byte    slabJournalHead[8];

    /** The 64-bit sequence number for this block */
    byte    sequenceNumber[8];

    /** A given VDO instance's 64-bit nonce */
    byte    nonce[8];

    /** 8-bit metadata type (should always be one for the recovery journal) */
    uint8_t metadataType;

    /** 16-bit count of the entries encoded in the block */
    byte    entryCount[2];

    /** 64-bit count of the logical blocks used when this block was opened */
    byte    logicalBlocksUsed[8];

    /** 64-bit count of the block map blocks used when this block was opened */
    byte    blockMapDataBlocks[8];

    /** The protection check byte */
    uint8_t checkByte;

    /** The number of recoveries completed */
    uint8_t recoveryCount;
  } fields;

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

#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    blockMapHead;
    SequenceNumber    slabJournalHead;
    SequenceNumber    sequenceNumber;
    Nonce             nonce;
    VDOMetadataType   metadataType;
    JournalEntryCount entryCount;
    BlockCount        logicalBlocksUsed;
    BlockCount        blockMapDataBlocks;
    uint8_t           checkByte;
    uint8_t           recoveryCount;
  } littleEndian;
#endif
} PackedJournalHeader;

typedef struct {
  /** The protection check byte */
  uint8_t checkByte;

  /** The number of recoveries completed */
  uint8_t recoveryCount;

  /** The number of entries in this sector */
  uint8_t entryCount;

  /** Journal entries for this sector */
  PackedRecoveryJournalEntry entries[];
} __attribute__((packed)) PackedJournalSector;

enum {
  // Allowing more than 311 entries in each block changes the math
  // concerning the amortization of metadata writes and recovery speed.
  RECOVERY_JOURNAL_ENTRIES_PER_BLOCK = 311,
  /** The number of entries in each sector (except the last) when filled */
  RECOVERY_JOURNAL_ENTRIES_PER_SECTOR
    = ((VDO_SECTOR_SIZE - sizeof(PackedJournalSector))
       / sizeof(PackedRecoveryJournalEntry)),
  /** The number of entries in the last sector when a block is full */
  RECOVERY_JOURNAL_ENTRIES_PER_LAST_SECTOR
    = (RECOVERY_JOURNAL_ENTRIES_PER_BLOCK
       % RECOVERY_JOURNAL_ENTRIES_PER_SECTOR),
};

/**
 * Find the recovery journal sector from the block header and sector number.
 *
 * @param header        The header of the recovery journal block
 * @param sectorNumber  The index of the sector (1-based)
 *
 * @return A packed recovery journal sector
 **/
__attribute__((warn_unused_result))
static inline
PackedJournalSector *getJournalBlockSector(PackedJournalHeader *header,
                                           int                  sectorNumber)
{
  char *sectorData = ((char *) header) + (VDO_SECTOR_SIZE * sectorNumber);
  return (PackedJournalSector *) sectorData;
}

/**
 * Generate the packed representation of a recovery block header.
 *
 * @param header  The header containing the values to encode
 * @param packed  The header into which to pack the values
 **/
static inline void packRecoveryBlockHeader(const RecoveryBlockHeader *header,
                                           PackedJournalHeader       *packed)
{
  storeUInt64LE(packed->fields.blockMapHead,       header->blockMapHead);
  storeUInt64LE(packed->fields.slabJournalHead,    header->slabJournalHead);
  storeUInt64LE(packed->fields.sequenceNumber,     header->sequenceNumber);
  storeUInt64LE(packed->fields.nonce,              header->nonce);
  storeUInt64LE(packed->fields.logicalBlocksUsed,  header->logicalBlocksUsed);
  storeUInt64LE(packed->fields.blockMapDataBlocks, header->blockMapDataBlocks);
  storeUInt16LE(packed->fields.entryCount,         header->entryCount);

  packed->fields.checkByte = header->checkByte;
  packed->fields.recoveryCount = header->recoveryCount;
  packed->fields.metadataType = header->metadataType;
}

/**
 * Decode the packed representation of a recovery block header.
 *
 * @param packed  The packed header to decode
 * @param header  The header into which to unpack the values
 **/
static inline void unpackRecoveryBlockHeader(const PackedJournalHeader *packed,
                                             RecoveryBlockHeader       *header)
{
  *header = (RecoveryBlockHeader) {
    .blockMapHead       = getUInt64LE(packed->fields.blockMapHead),
    .slabJournalHead    = getUInt64LE(packed->fields.slabJournalHead),
    .sequenceNumber     = getUInt64LE(packed->fields.sequenceNumber),
    .nonce              = getUInt64LE(packed->fields.nonce),
    .logicalBlocksUsed  = getUInt64LE(packed->fields.logicalBlocksUsed),
    .blockMapDataBlocks = getUInt64LE(packed->fields.blockMapDataBlocks),
    .entryCount         = getUInt16LE(packed->fields.entryCount),
    .checkByte          = packed->fields.checkByte,
    .recoveryCount      = packed->fields.recoveryCount,
    .metadataType       = packed->fields.metadataType,
  };
}

#endif // PACKED_RECOVERY_JOURNAL_BLOCK_H