/*

 * 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/volumeStore.c#2 $

 */

#include "geometry.h"

#include "indexLayout.h"

#include "logger.h"

#include "uds-error.h"

#include "volumeStore.h"

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

void closeVolumeStore(struct volume_store *volumeStore)

{

#ifdef __KERNEL__

  if (volumeStore->vs_client != NULL) {

    dm_bufio_client_destroy(volumeStore->vs_client);

    volumeStore->vs_client = NULL;

  }

#else

  if (volumeStore->vs_region != NULL) {

    putIORegion(volumeStore->vs_region);

    volumeStore->vs_region = NULL;

  }

#endif

}

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

void destroyVolumePage(struct volume_page *volumePage)

{

#ifdef __KERNEL__

  releaseVolumePage(volumePage);

#else

  FREE(volumePage->vp_data);

  volumePage->vp_data = NULL;

#endif

}

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

int initializeVolumePage(const struct geometry *geometry,

                         struct volume_page    *volumePage)

{

#ifdef __KERNEL__

  volumePage->vp_buffer = NULL;

  return UDS_SUCCESS;

#else

  return ALLOCATE_IO_ALIGNED(geometry->bytesPerPage, byte, __func__,

                             &volumePage->vp_data);

#endif

}

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

int openVolumeStore(struct volume_store *volumeStore,

                    IndexLayout  *layout,

                    unsigned int  reservedBuffers __attribute__((unused)),

                    size_t        bytesPerPage)

{

#ifdef __KERNEL__

  return openVolumeBufio(layout, bytesPerPage, reservedBuffers,

                         &volumeStore->vs_client);

#else

  volumeStore->vs_bytesPerPage = bytesPerPage;

  return openVolumeRegion(layout, &volumeStore->vs_region);

#endif

}

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

void prefetchVolumePages(const struct volume_store *vs __attribute__((unused)),

                         unsigned int physicalPage __attribute__((unused)),

                         unsigned int pageCount __attribute__((unused)))

{

#ifdef __KERNEL__

  dm_bufio_prefetch(vs->vs_client, physicalPage, pageCount);

#else

  // Nothing to do in user mode

#endif

}

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

int prepareToWriteVolumePage(const struct volume_store *volumeStore

                             __attribute__((unused)),

                             unsigned int         physicalPage

                             __attribute__((unused)),

                             struct volume_page  *volumePage

                             __attribute__((unused)))

{

#ifdef __KERNEL__

  releaseVolumePage(volumePage);

  struct dm_buffer *buffer = NULL;

  byte *data = dm_bufio_new(volumeStore->vs_client, physicalPage, &buffer);

  if (IS_ERR(data)) {

    return -PTR_ERR(data);

  }

  volumePage->vp_buffer = buffer;

#else

  // Nothing to do in user mode

#endif

  return UDS_SUCCESS;

}

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

int readVolumePage(const struct volume_store *volumeStore,

                   unsigned int               physicalPage,

                   struct volume_page        *volumePage)

{

#ifdef __KERNEL__

  releaseVolumePage(volumePage);

  byte *data = dm_bufio_read(volumeStore->vs_client, physicalPage,

                             &volumePage->vp_buffer);

  if (IS_ERR(data)) {

    return logWarningWithStringError(-PTR_ERR(data),

                                     "error reading physical page %u",

                                     physicalPage);

  }

#else

  off_t offset = (off_t) physicalPage * volumeStore->vs_bytesPerPage;

  int result = readFromRegion(volumeStore->vs_region, offset,

                              getPageData(volumePage),

                              volumeStore->vs_bytesPerPage, NULL);

  if (result != UDS_SUCCESS) {

    return logWarningWithStringError(result,

                                     "error reading physical page %u",

                                     physicalPage);

  }

#endif

  return UDS_SUCCESS;

}

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

void releaseVolumePage(struct volume_page *volumePage __attribute__((unused)))

{

#ifdef __KERNEL__

  if (volumePage->vp_buffer != NULL) {

    dm_bufio_release(volumePage->vp_buffer);

    volumePage->vp_buffer = NULL;

  }

#else

  // Nothing to do in user mode

#endif

}

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

void swapVolumePages(struct volume_page *volumePage1,

                     struct volume_page *volumePage2)

{

  struct volume_page temp = *volumePage1;

  *volumePage1 = *volumePage2;

  *volumePage2 = temp;

}

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

int syncVolumeStore(const struct volume_store *volumeStore)

{

#ifdef __KERNEL__

  int result = -dm_bufio_write_dirty_buffers(volumeStore->vs_client);

#else

  int result = syncRegionContents(volumeStore->vs_region);

#endif

  if (result != UDS_SUCCESS) {

    return logErrorWithStringError(result, "cannot sync chapter to volume");

  }

  return UDS_SUCCESS;

}

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

int writeVolumePage(const struct volume_store *volumeStore,

                    unsigned int               physicalPage,

                    struct volume_page        *volumePage)

{

#ifdef __KERNEL__

  dm_bufio_mark_buffer_dirty(volumePage->vp_buffer);

  return UDS_SUCCESS;

#else

  off_t offset = (off_t) physicalPage * volumeStore->vs_bytesPerPage;

  return writeToRegion(volumeStore->vs_region, offset, getPageData(volumePage),

                       volumeStore->vs_bytesPerPage,

                       volumeStore->vs_bytesPerPage);

#endif

}