/*

 * 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/uds-releases/jasper/src/uds/bufferedReader.c#5 $

 */

#include "bufferedReader.h"

#include "compiler.h"

#include "ioFactory.h"

#include "logger.h"

#include "memoryAlloc.h"

#include "numeric.h"

#ifndef __KERNEL__

/*

 * Define sector_t.  The kernel really wants us to use it.  The code becomes

 * ugly if we need to #ifdef every usage of sector_t.  Note that the of #define

 * means that even if a user mode include typedefs sector_t, it will not affect

 * this module.

 */

#define sector_t uint64_t

#endif

struct bufferedReader {

#ifdef __KERNEL__

  // IOFactory owning the block device

  IOFactory              *br_factory;

  // The dm_bufio_client to read from

  struct dm_bufio_client *br_client;

  // The current dm_buffer

  struct dm_buffer       *br_buffer;

  // The number of blocks that can be read from

  sector_t                br_limit;

  // Number of the current block

  sector_t                br_blockNumber;

#else

  // Region to read from

  IORegion               *br_region;

  // Number of the current block

  uint64_t                br_blockNumber;

#endif

  // Start of the buffer

  byte                   *br_start;

  // End of the data read from the buffer

  byte                   *br_pointer;

};

#ifdef __KERNEL__

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

static void readAhead(BufferedReader *br, sector_t blockNumber)

{

  if (blockNumber < br->br_limit) {

    enum { MAX_READ_AHEAD = 4 };

    size_t readAhead = minSizeT(MAX_READ_AHEAD, br->br_limit - blockNumber);

    dm_bufio_prefetch(br->br_client, blockNumber, readAhead);

  }

}

#endif

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

#ifdef __KERNEL__

int makeBufferedReader(IOFactory               *factory,

                       struct dm_bufio_client  *client,

                       sector_t                 blockLimit,

                       BufferedReader         **readerPtr)

{

  BufferedReader *reader = NULL;

  int result = ALLOCATE(1, BufferedReader, "buffered reader", &reader);

  if (result != UDS_SUCCESS) {

    return result;

  }

  *reader = (BufferedReader) {

    .br_factory     = factory,

    .br_client      = client,

    .br_buffer      = NULL,

    .br_limit       = blockLimit,

    .br_blockNumber = 0,

    .br_start       = NULL,

    .br_pointer     = NULL,

  };

  readAhead(reader,0);

  getIOFactory(factory);

  *readerPtr = reader;

  return UDS_SUCCESS;

}

#else

int makeBufferedReader(IORegion *region, BufferedReader **readerPtr)

{

  byte *data;

  int result = ALLOCATE_IO_ALIGNED(UDS_BLOCK_SIZE, byte,

                                   "buffer writer buffer", &data);

  if (result != UDS_SUCCESS) {

    return result;

  }

  BufferedReader *reader = NULL;

  result = ALLOCATE(1, BufferedReader, "buffered reader", &reader);

  if (result != UDS_SUCCESS) {

    FREE(data);

    return result;

  }

  *reader = (BufferedReader) {

    .br_region      = region,

    .br_blockNumber = 0,

    .br_start       = data,

    .br_pointer     = NULL,

  };

  getIORegion(region);

  *readerPtr = reader;

  return UDS_SUCCESS;

}

#endif

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

void freeBufferedReader(BufferedReader *br)

{

  if (br == NULL) {

    return;

  }

#ifdef __KERNEL__

  if (br->br_buffer != NULL) {

    dm_bufio_release(br->br_buffer);

  }

  dm_bufio_client_destroy(br->br_client);

  putIOFactory(br->br_factory);

#else

  putIORegion(br->br_region);

  FREE(br->br_start);

#endif

  FREE(br);

}

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

static int positionReader(BufferedReader *br,

                          sector_t        blockNumber,

                          off_t           offset)

{

  if ((br->br_pointer == NULL) || (blockNumber != br->br_blockNumber)) {

#ifdef __KERNEL__

    if (blockNumber >= br->br_limit) {

      return UDS_OUT_OF_RANGE;

    }

    if (br->br_buffer != NULL) {

      dm_bufio_release(br->br_buffer);

      br->br_buffer = NULL;

    }

    struct dm_buffer *buffer = NULL;

    void *data = dm_bufio_read(br->br_client, blockNumber, &buffer);

    if (IS_ERR(data)) {

      return -PTR_ERR(data);

    }

    br->br_buffer = buffer;

    br->br_start  = data;

    if (blockNumber == br->br_blockNumber + 1) {

      readAhead(br, blockNumber + 1);

    }

#else

    int result = readFromRegion(br->br_region, blockNumber * UDS_BLOCK_SIZE,

                                br->br_start, UDS_BLOCK_SIZE, NULL);

    if (result != UDS_SUCCESS) {

      logWarningWithStringError(result, "%s got readFromRegion error",

                                __func__);

      return result;

    }

#endif

  }

  br->br_blockNumber = blockNumber;

  br->br_pointer     = br->br_start + offset;

  return UDS_SUCCESS;

}

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

static size_t bytesRemainingInReadBuffer(BufferedReader *br)

{

  return (br->br_pointer == NULL

          ? 0

          : br->br_start + UDS_BLOCK_SIZE - br->br_pointer);

}

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

int readFromBufferedReader(BufferedReader *br, void *data, size_t length)

{

  byte *dp = data;

  int result = UDS_SUCCESS;

  while (length > 0) {

    if (bytesRemainingInReadBuffer(br) == 0) {

      sector_t blockNumber = br->br_blockNumber;

      if (br->br_pointer != NULL) {

        ++blockNumber;

      }

      result = positionReader(br, blockNumber, 0);

      if (result != UDS_SUCCESS) {

        break;

      }

    }

    size_t avail = bytesRemainingInReadBuffer(br);

    size_t chunk = minSizeT(length, avail);

    memcpy(dp, br->br_pointer, chunk);

    length         -= chunk;

    dp             += chunk;

    br->br_pointer += chunk;

  }

  if (((result == UDS_OUT_OF_RANGE) || (result == UDS_END_OF_FILE))

      && (dp - (byte *) data > 0)) {

    result = UDS_SHORT_READ;

  }

  return result;

}

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

int verifyBufferedData(BufferedReader *br,

                       const void     *value,

                       size_t          length)

{

  const byte *vp = value;

  sector_t startingBlockNumber = br->br_blockNumber;

  int      startingOffset      = br->br_pointer - br->br_start;

  while (length > 0) {

    if (bytesRemainingInReadBuffer(br) == 0) {

      sector_t blockNumber = br->br_blockNumber;

      if (br->br_pointer != NULL) {

        ++blockNumber;

      }

      int result = positionReader(br, blockNumber, 0);

      if (result != UDS_SUCCESS) {

        positionReader(br, startingBlockNumber, startingOffset);

        return UDS_CORRUPT_FILE;

      }

    }

    size_t avail = bytesRemainingInReadBuffer(br);

    size_t chunk = minSizeT(length, avail);

    if (memcmp(vp, br->br_pointer, chunk) != 0) {

      positionReader(br, startingBlockNumber, startingOffset);

      return UDS_CORRUPT_FILE;

    }

    length         -= chunk;

    vp             += chunk;

    br->br_pointer += chunk;

  }

  return UDS_SUCCESS;

}