/*
 * 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/blockMapEntry.h#4 $
 */

#ifndef BLOCK_MAP_ENTRY_H
#define BLOCK_MAP_ENTRY_H

#include "blockMappingState.h"
#include "constants.h"
#include "numeric.h"
#include "types.h"

/**
 * The entry for each logical block in the block map is encoded into five
 * bytes, which saves space in both the on-disk and in-memory layouts. It
 * consists of the 36 low-order bits of a PhysicalBlockNumber (addressing 256
 * terabytes with a 4KB block size) and a 4-bit encoding of a
 * BlockMappingState.
 **/
typedef union __attribute__((packed)) blockMapEntry {
  struct __attribute__((packed)) {
    /**
     * Bits 7..4: The four highest bits of the 36-bit physical block number
     * Bits 3..0: The 4-bit BlockMappingState
     **/
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    unsigned mappingState  : 4;
    unsigned pbnHighNibble : 4;
#else
    unsigned pbnHighNibble : 4;
    unsigned mappingState  : 4;
#endif

    /** 32 low-order bits of the 36-bit PBN, in little-endian byte order */
    byte pbnLowWord[4];
  } fields;

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

#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 mappingState  : 4;
    unsigned pbnHighNibble : 4;
    uint32_t pbnLowWord;
  } littleEndian;
#endif
} BlockMapEntry;

/**
 * Unpack the fields of a BlockMapEntry, returning them as a DataLocation.
 *
 * @param entry   A pointer to the entry to unpack
 *
 * @return the location of the data mapped by the block map entry
 **/
static inline DataLocation unpackBlockMapEntry(const BlockMapEntry *entry)
{
  PhysicalBlockNumber low32 = getUInt32LE(entry->fields.pbnLowWord);
  PhysicalBlockNumber high4 = entry->fields.pbnHighNibble;
  return (DataLocation) {
    .pbn   = ((high4 << 32) | low32),
    .state = entry->fields.mappingState,
  };
}

/**********************************************************************/
static inline bool isMappedLocation(const DataLocation *location)
{
  return (location->state != MAPPING_STATE_UNMAPPED);
}

/**********************************************************************/
static inline bool isValidLocation(const DataLocation *location)
{
  if (location->pbn == ZERO_BLOCK) {
    return !isCompressed(location->state);
  } else {
    return isMappedLocation(location);
  }
}

/**
 * Pack a PhysicalBlockNumber into a BlockMapEntry.
 *
 * @param pbn            The physical block number to convert to its
 *                       packed five-byte representation
 * @param mappingState   The mapping state of the block
 *
 * @return the packed representation of the block number and mapping state
 *
 * @note unrepresentable high bits of the unpacked PBN are silently truncated
 **/
static inline BlockMapEntry packPBN(PhysicalBlockNumber pbn,
                                    BlockMappingState   mappingState)
{
  BlockMapEntry entry;
  entry.fields.mappingState  = (mappingState & 0x0F);
  entry.fields.pbnHighNibble = ((pbn >> 32) & 0x0F),
  storeUInt32LE(entry.fields.pbnLowWord, pbn & UINT_MAX);
  return entry;
}

#endif // BLOCK_MAP_ENTRY_H
