/*

 * 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/fixedLayout.c#3 $

 */

#include "fixedLayout.h"

#include "buffer.h"

#include "logger.h"

#include "memoryAlloc.h"

#include "header.h"

#include "statusCodes.h"

const BlockCount ALL_FREE_BLOCKS = (uint64_t) -1;

struct fixedLayout {

  PhysicalBlockNumber  firstFree;

  PhysicalBlockNumber  lastFree;

  size_t               numPartitions;

  Partition           *head;

};

struct partition {

  PartitionID          id;     // The id of this partition

  FixedLayout         *layout; // The layout to which this partition belongs

  PhysicalBlockNumber  offset; // The offset into the layout of this partition

  PhysicalBlockNumber  base;   // The untranslated number of the first block

  BlockCount           count;  // The number of blocks in the partition

  Partition           *next;   // A pointer to the next partition in the layout

};

typedef struct {

  PhysicalBlockNumber firstFree;

  PhysicalBlockNumber lastFree;

  byte                partitionCount;

} __attribute__((packed)) Layout3_0;

typedef struct {

  PartitionID         id;

  PhysicalBlockNumber offset;

  PhysicalBlockNumber base;

  BlockCount          count;

} __attribute__((packed)) Partition3_0;

static const Header LAYOUT_HEADER_3_0 = {

  .id = FIXED_LAYOUT,

  .version = {

    .majorVersion = 3,

    .minorVersion = 0,

  },

  .size = sizeof(Layout3_0),   // Minimum size (contains no partitions)

};

/**********************************************************************/

int makeFixedLayout(BlockCount            totalBlocks,

                    PhysicalBlockNumber   startOffset,

                    FixedLayout         **layoutPtr)

{

  FixedLayout *layout;

  int result = ALLOCATE(1, FixedLayout, "fixed layout", &layout);

  if (result != UDS_SUCCESS) {

    return result;

  }

  layout->firstFree     = startOffset;

  layout->lastFree      = startOffset + totalBlocks;

  layout->numPartitions = 0;

  layout->head          = NULL;

  *layoutPtr = layout;

  return VDO_SUCCESS;

}

/**********************************************************************/

void freeFixedLayout(FixedLayout **layoutPtr)

{

  FixedLayout *layout = *layoutPtr;

  if (layout == NULL) {

    return;

  }

  while (layout->head != NULL) {

    Partition *part = layout->head;

    layout->head = part->next;

    FREE(part);

  }

  FREE(layout);

  *layoutPtr = NULL;

}

/**********************************************************************/

BlockCount getTotalFixedLayoutSize(const FixedLayout *layout)

{

  BlockCount size = getFixedLayoutBlocksAvailable(layout);

  for (Partition *partition = layout->head; partition != NULL;

       partition = partition->next) {

    size += partition->count;

  }

  return size;

}

/**********************************************************************/

int getPartition(FixedLayout *layout, PartitionID id, Partition **partitionPtr)

{

  for (Partition *partition = layout->head; partition != NULL;

       partition = partition->next) {

    if (partition->id == id) {

      if (partitionPtr != NULL) {

        *partitionPtr = partition;

      }

      return VDO_SUCCESS;

    }

  }

  return VDO_UNKNOWN_PARTITION;

}

/**********************************************************************/

int translateToPBN(const Partition     *partition,

                   PhysicalBlockNumber  partitionBlockNumber,

                   PhysicalBlockNumber *layerBlockNumber)

{

  if (partition == NULL) {

    *layerBlockNumber = partitionBlockNumber;

    return VDO_SUCCESS;

  }

  if (partitionBlockNumber < partition->base) {

    return VDO_OUT_OF_RANGE;

  }

  PhysicalBlockNumber offsetFromBase = partitionBlockNumber - partition->base;

  if (offsetFromBase >= partition->count) {

    return VDO_OUT_OF_RANGE;

  }

  *layerBlockNumber = partition->offset + offsetFromBase;

  return VDO_SUCCESS;

}

/**********************************************************************/

int translateFromPBN(const Partition     *partition,

                     PhysicalBlockNumber  layerBlockNumber,

                     PhysicalBlockNumber *partitionBlockNumberPtr)

{

  if (partition == NULL) {

    *partitionBlockNumberPtr = layerBlockNumber;

    return VDO_SUCCESS;

  }

  if (layerBlockNumber < partition->offset) {

    return VDO_OUT_OF_RANGE;

  }

  PhysicalBlockNumber partitionBlockNumber

    = layerBlockNumber - partition->offset;

  if (partitionBlockNumber >= partition->count) {

    return VDO_OUT_OF_RANGE;

  }

  *partitionBlockNumberPtr = partitionBlockNumber + partition->base;

  return VDO_SUCCESS;

}

/**********************************************************************/

BlockCount getFixedLayoutBlocksAvailable(const FixedLayout *layout)

{

  return layout->lastFree - layout->firstFree;

}

/**

 * Allocate a partition. The partition will be attached to the partition

 * list in the layout.

 *

 * @param layout     The layout containing the partition

 * @param id         The id of the partition

 * @param offset     The offset into the layout at which the partition begins

 * @param base       The number of the first block for users of the partition

 * @param blockCount The number of blocks in the partition

 *

 * @return VDO_SUCCESS or an error

 **/

static int allocatePartition(FixedLayout         *layout,

                             byte                 id,

                             PhysicalBlockNumber  offset,

                             PhysicalBlockNumber  base,

                             BlockCount           blockCount)

{

  Partition *partition;

  int result = ALLOCATE(1, Partition, "fixed layout partition", &partition);

  if (result != UDS_SUCCESS) {

    return result;

  }

  partition->id                  = id;

  partition->layout              = layout;

  partition->offset              = offset;

  partition->base                = base;

  partition->count               = blockCount;

  partition->next                = layout->head;

  layout->head                   = partition;

  return VDO_SUCCESS;

}

/**********************************************************************/

int makeFixedLayoutPartition(FixedLayout         *layout,

                             PartitionID          id,

                             BlockCount           blockCount,

                             PartitionDirection   direction,

                             PhysicalBlockNumber  base)

{

  BlockCount freeBlocks = layout->lastFree - layout->firstFree;

  if (blockCount == ALL_FREE_BLOCKS) {

    if (freeBlocks == 0) {

      return VDO_NO_SPACE;

    } else {

      blockCount = freeBlocks;

    }

  } else if (blockCount > freeBlocks) {

    return VDO_NO_SPACE;

  }

  int result = getPartition(layout, id, NULL);

  if (result != VDO_UNKNOWN_PARTITION) {

    return VDO_PARTITION_EXISTS;

  }

  PhysicalBlockNumber offset = ((direction == FROM_END)

                                ? (layout->lastFree - blockCount)

                                : layout->firstFree);

  result = allocatePartition(layout, id, offset, base, blockCount);

  if (result != VDO_SUCCESS) {

    return result;

  }

  layout->numPartitions++;

  if (direction == FROM_END) {

    layout->lastFree = layout->lastFree - blockCount;

  } else {

    layout->firstFree += blockCount;

  }

  return VDO_SUCCESS;

}

/**********************************************************************/

BlockCount getFixedLayoutPartitionSize(const Partition *partition)

{

  return partition->count;

}

/**********************************************************************/

PhysicalBlockNumber getFixedLayoutPartitionOffset(const Partition *partition)

{

  return partition->offset;

}

/**********************************************************************/

PhysicalBlockNumber getFixedLayoutPartitionBase(const Partition *partition)

{

  return partition->base;

}

/**********************************************************************/

static inline size_t getEncodedSize(const FixedLayout *layout)

{

  return sizeof(Layout3_0) + (sizeof(Partition3_0) * layout->numPartitions);

}

/**********************************************************************/

size_t getFixedLayoutEncodedSize(const FixedLayout *layout)

{

  return ENCODED_HEADER_SIZE + getEncodedSize(layout);

}

/**

 * Encode a null-terminated list of fixed layout partitions into a buffer

 * using partition format 3.0.

 *

 * @param layout  The layout containing the list of partitions to encode

 * @param buffer  A buffer positioned at the start of the encoding

 *

 * @return UDS_SUCCESS or an error code

 **/

static int encodePartitions_3_0(const FixedLayout *layout, Buffer *buffer)

{

  for (const Partition *partition = layout->head;

       partition != NULL;

       partition = partition->next) {

    STATIC_ASSERT_SIZEOF(PartitionID, sizeof(byte));

    int result = putByte(buffer, partition->id);

    if (result != UDS_SUCCESS) {

      return result;

    }

    result = putUInt64LEIntoBuffer(buffer, partition->offset);

    if (result != UDS_SUCCESS) {

      return result;

    }

    result = putUInt64LEIntoBuffer(buffer, partition->base);

    if (result != UDS_SUCCESS) {

      return result;

    }

    result = putUInt64LEIntoBuffer(buffer, partition->count);

    if (result != UDS_SUCCESS) {

      return result;

    }

  }

  return UDS_SUCCESS;

}

/**

 * Encode the header fields of a fixed layout into a buffer using layout

 * format 3.0.

 *

 * @param layout  The layout to encode

 * @param buffer  A buffer positioned at the start of the encoding

 *

 * @return UDS_SUCCESS or an error code

 **/

static int encodeLayout_3_0(const FixedLayout *layout, Buffer *buffer)

{

  int result = ASSERT(layout->numPartitions <= UINT8_MAX,

                      "fixed layout partition count must fit in a byte");

  if (result != UDS_SUCCESS) {

    return result;

  }

  result = putUInt64LEIntoBuffer(buffer, layout->firstFree);

  if (result != UDS_SUCCESS) {

    return result;

  }

  result = putUInt64LEIntoBuffer(buffer, layout->lastFree);

  if (result != UDS_SUCCESS) {

    return result;

  }

  return putByte(buffer, layout->numPartitions);

}

/**********************************************************************/

int encodeFixedLayout(const FixedLayout *layout, Buffer *buffer)

{

  if (!ensureAvailableSpace(buffer, getFixedLayoutEncodedSize(layout))) {

    return UDS_BUFFER_ERROR;

  }

  Header header = LAYOUT_HEADER_3_0;

  header.size = getEncodedSize(layout);

  int result = encodeHeader(&header, buffer);

  if (result != UDS_SUCCESS) {

    return result;

  }

  size_t initialLength = contentLength(buffer);

  result = encodeLayout_3_0(layout, buffer);

  if (result != UDS_SUCCESS) {

    return result;

  }

  size_t encodedSize = contentLength(buffer) - initialLength;

  result = ASSERT(encodedSize == sizeof(Layout3_0),

                "encoded size of fixed layout header must match structure");

  if (result != UDS_SUCCESS) {

    return result;

  }

  result = encodePartitions_3_0(layout, buffer);

  if (result != UDS_SUCCESS) {

    return result;

  }

  encodedSize = contentLength(buffer) - initialLength;

  return ASSERT(encodedSize == header.size,

                "encoded size of fixed layout must match header size");

}

/**

 * Decode a sequence of fixed layout partitions from a buffer

 * using partition format 3.0.

 *

 * @param buffer  A buffer positioned at the start of the encoding

 * @param layout  The layout in which to allocate the decoded partitions

 *

 * @return UDS_SUCCESS or an error code

 **/

static int decodePartitions_3_0(Buffer *buffer, FixedLayout *layout)

{

  for (size_t i = 0; i < layout->numPartitions; i++) {

    byte id;

    int result = getByte(buffer, &id;;

    if (result != UDS_SUCCESS) {

      return result;

    }

    uint64_t offset;

    result = getUInt64LEFromBuffer(buffer, &offset);

    if (result != UDS_SUCCESS) {

      return result;

    }

    uint64_t base;

    result = getUInt64LEFromBuffer(buffer, &base);

    if (result != UDS_SUCCESS) {

      return result;

    }

    uint64_t count;

    result = getUInt64LEFromBuffer(buffer, &count);

    if (result != UDS_SUCCESS) {

      return result;

    }

    result = allocatePartition(layout, id, offset, base, count);

    if (result != VDO_SUCCESS) {

      return result;

    }

  }

  return UDS_SUCCESS;

}

/**

 * Decode the header fields of a fixed layout from a buffer using layout

 * format 3.0.

 *

 * @param buffer  A buffer positioned at the start of the encoding

 * @param layout  The structure to receive the decoded fields

 *

 * @return UDS_SUCCESS or an error code

 **/

static int decodeLayout_3_0(Buffer *buffer, Layout3_0 *layout)

{

  size_t initialLength = contentLength(buffer);

  PhysicalBlockNumber firstFree;

  int result = getUInt64LEFromBuffer(buffer, &firstFree);

  if (result != UDS_SUCCESS) {

    return result;

  }

  PhysicalBlockNumber lastFree;

  result = getUInt64LEFromBuffer(buffer, &lastFree);

  if (result != UDS_SUCCESS) {

    return result;

  }

  byte partitionCount;

  result = getByte(buffer, &partitionCount);

  if (result != UDS_SUCCESS) {

    return result;

  }

  *layout = (Layout3_0) {

    .firstFree      = firstFree,

    .lastFree       = lastFree,

    .partitionCount = partitionCount,

  };

  size_t decodedSize = initialLength - contentLength(buffer);

  return ASSERT(decodedSize == sizeof(Layout3_0),

                "decoded size of fixed layout header must match structure");

}

/**********************************************************************/

int decodeFixedLayout(Buffer *buffer, FixedLayout **layoutPtr)

{

  Header header;

  int result = decodeHeader(buffer, &header);

  if (result != UDS_SUCCESS) {

    return result;

  }

  // Layout is variable size, so only do a minimum size check here.

  result = validateHeader(&LAYOUT_HEADER_3_0, &header, false, __func__);

  if (result != VDO_SUCCESS) {

    return result;

  }

  Layout3_0 layoutHeader;

  result = decodeLayout_3_0(buffer, &layoutHeader);

  if (result != UDS_SUCCESS) {

    return result;

  }

  if (contentLength(buffer)

      < (sizeof(Partition3_0) * layoutHeader.partitionCount)) {

    return VDO_UNSUPPORTED_VERSION;

  }

  FixedLayout *layout;

  result = ALLOCATE(1, FixedLayout, "fixed layout", &layout);

  if (result != UDS_SUCCESS) {

    return result;

  }

  layout->firstFree     = layoutHeader.firstFree;

  layout->lastFree      = layoutHeader.lastFree;

  layout->numPartitions = layoutHeader.partitionCount;

  result = decodePartitions_3_0(buffer, layout);

  if (result != VDO_SUCCESS) {

    freeFixedLayout(&layout);

    return result;

  }

  *layoutPtr = layout;

  return VDO_SUCCESS;

}