/*

 * 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/recoveryJournalEntry.h#1 $

 */

#ifndef RECOVERY_JOURNAL_ENTRY_H

#define RECOVERY_JOURNAL_ENTRY_H

#include "numeric.h"

#include "blockMapEntry.h"

#include "journalPoint.h"

#include "types.h"

/**

 * A recovery journal entry stores two physical locations: a data location

 * that is the value of a single mapping in the block map tree, and the

 * location of the block map page and and slot that is either acquiring or

 * releasing a reference to the data location. The journal entry also stores

 * an operation code that says whether the reference is being acquired (an

 * increment) or released (a decrement), and whether the mapping is for a

 * logical block or for the block map tree itself.

 **/

typedef struct {

  BlockMapSlot     slot;

  DataLocation     mapping;

  JournalOperation operation;

} RecoveryJournalEntry;

/** The packed, on-disk representation of a recovery journal entry. */

typedef union __attribute__((packed)) {

  struct __attribute__((packed)) {

    /**

     * In little-endian bit order:

     * Bits 15..12:  The four highest bits of the 36-bit physical block number

     *               of the block map tree page

     * Bits 11..2:   The 10-bit block map page slot number

     * Bits 1..0:    The 2-bit JournalOperation of the entry

     **/

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

    unsigned operation     : 2;

    unsigned slotLow       : 6;

    unsigned slotHigh      : 4;

    unsigned pbnHighNibble : 4;

#else

    unsigned slotLow       : 6;

    unsigned operation     : 2;

    unsigned pbnHighNibble : 4;

    unsigned slotHigh      : 4;

#endif

    /**

     * Bits 47..16:  The 32 low-order bits of the block map page PBN,

     *               in little-endian byte order

     **/

    byte pbnLowWord[4];

    /**

     * Bits 87..48:  The five-byte block map entry encoding the location that

     *               was or will be stored in the block map page slot

     **/

    BlockMapEntry blockMapEntry;

  } fields;

  // A raw view of the packed encoding.

  uint8_t raw[11];

#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      operation     : 2;

    unsigned      slot          : 10;

    unsigned      pbnHighNibble : 4;

    uint32_t      pbnLowWord;

    BlockMapEntry blockMapEntry;

  } littleEndian;

#endif

} PackedRecoveryJournalEntry;

/**

 * Return the packed, on-disk representation of a recovery journal entry.

 *

 * @param entry   The journal entry to pack

 *

 * @return  The packed representation of the journal entry

 **/

static inline PackedRecoveryJournalEntry

packRecoveryJournalEntry(const RecoveryJournalEntry *entry)

{

  PackedRecoveryJournalEntry packed = {

    .fields = {

      .operation     = entry->operation,

      .slotLow       = entry->slot.slot & 0x3F,

      .slotHigh      = (entry->slot.slot >> 6) & 0x0F,

      .pbnHighNibble = (entry->slot.pbn >> 32) & 0x0F,

      .blockMapEntry = packPBN(entry->mapping.pbn, entry->mapping.state),

    }

  };

  storeUInt32LE(packed.fields.pbnLowWord, entry->slot.pbn & UINT_MAX);

  return packed;

}

/**

 * Unpack the on-disk representation of a recovery journal entry.

 *

 * @param entry  The recovery journal entry to unpack

 *

 * @return  The unpacked entry

 **/

static inline RecoveryJournalEntry

unpackRecoveryJournalEntry(const PackedRecoveryJournalEntry *entry)

{

  PhysicalBlockNumber low32 = getUInt32LE(entry->fields.pbnLowWord);

  PhysicalBlockNumber high4 = entry->fields.pbnHighNibble;

  return (RecoveryJournalEntry) {

    .operation = entry->fields.operation,

    .slot      = {

      .pbn  = ((high4 << 32) | low32),

      .slot = (entry->fields.slotLow | (entry->fields.slotHigh << 6)),

    },

    .mapping = unpackBlockMapEntry(&entry->fields.blockMapEntry),

  };

}

#endif // RECOVERY_JOURNAL_ENTRY_H