/*

 * 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