/*
 * Copyright Red Hat
 *
 * 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/compressionState.c#2 $
 */

#include "compressionStateInternals.h"

#include "dataVIO.h"
#include "packer.h"

static const uint32_t STATUS_MASK           = 0xff;
static const uint32_t MAY_NOT_COMPRESS_MASK = 0x80000000;

/**********************************************************************/
VIOCompressionState getCompressionState(DataVIO *dataVIO)
{
  uint32_t packedValue = atomicLoad32(&dataVIO->compression.state);
  return (VIOCompressionState) {
    .status         = packedValue & STATUS_MASK,
    .mayNotCompress = ((packedValue & MAY_NOT_COMPRESS_MASK) != 0),
  };
}

/**
 * Convert a VIOCompressionState into a uint32_t which may be stored
 * atomically.
 *
 * @param state  The state to convert
 *
 * @return The compression state packed into a uint32_t
 **/
__attribute__((warn_unused_result))
static uint32_t packState(VIOCompressionState state)
{
  return state.status | (state.mayNotCompress ? MAY_NOT_COMPRESS_MASK : 0);
}

/**********************************************************************/
bool setCompressionState(DataVIO             *dataVIO,
                         VIOCompressionState  state,
                         VIOCompressionState  newState)
{
  return compareAndSwap32(&dataVIO->compression.state, packState(state),
                          packState(newState));
}

/**
 * Advance to the next compression state along the compression path.
 *
 * @param dataVIO  The DataVIO to advance
 *
 * @return The new compression status of the DataVIO
 **/
static VIOCompressionStatus advanceStatus(DataVIO *dataVIO)
{
  for (;;) {
    VIOCompressionState state = getCompressionState(dataVIO);
    if (state.status == VIO_POST_PACKER) {
      // We're already in the last state.
      return state.status;
    }

    VIOCompressionState newState = state;
    if (state.mayNotCompress) {
      // Compression has been dis-allowed for this VIO, so skip the rest of the
      // path and go to the end.
      newState.status = VIO_POST_PACKER;
    } else {
      // Go to the next state.
      newState.status++;
    }

    if (setCompressionState(dataVIO, state, newState)) {
      return newState.status;
    }

    // Another thread changed the state out from under us so try again.
  }
}

/**********************************************************************/
bool mayCompressDataVIO(DataVIO *dataVIO)
{
  if (!hasAllocation(dataVIO)
      || ((getWritePolicy(getVDOFromDataVIO(dataVIO)) != WRITE_POLICY_SYNC)
          && vioRequiresFlushAfter(dataVIOAsVIO(dataVIO)))
      || !getVDOCompressing(getVDOFromDataVIO(dataVIO))) {
    /*
     * If this VIO didn't get an allocation, the compressed write probably
     * won't either, so don't try compressing it. Also, if compression is off,
     * don't compress.
     */
    setCompressionDone(dataVIO);
    return false;
  }

  if (dataVIO->hashLock == NULL) {
    // DataVIOs without a HashLock (which should be extremely rare) aren't
    // able to share the packer's PBN lock, so don't try to compress them.
    return false;
  }

  return (advanceStatus(dataVIO) == VIO_COMPRESSING);
}

/**********************************************************************/
bool mayPackDataVIO(DataVIO *dataVIO)
{
  if (!isSufficientlyCompressible(dataVIO)
      || !getVDOCompressing(getVDOFromDataVIO(dataVIO))
      || getCompressionState(dataVIO).mayNotCompress) {
    // If the data in this VIO doesn't compress, or compression is off, or
    // compression for this VIO has been canceled, don't send it to the packer.
    setCompressionDone(dataVIO);
    return false;
  }

  return true;
}

/**********************************************************************/
bool mayBlockInPacker(DataVIO *dataVIO)
{
  return (advanceStatus(dataVIO) == VIO_PACKING);
}

/**********************************************************************/
bool mayWriteCompressedDataVIO(DataVIO *dataVIO)
{
  advanceStatus(dataVIO);
  return !getCompressionState(dataVIO).mayNotCompress;
}

/**********************************************************************/
void setCompressionDone(DataVIO *dataVIO)
{
  for (;;) {
    VIOCompressionState state = getCompressionState(dataVIO);
    if (state.status == VIO_POST_PACKER) {
      // The VIO is already done.
      return;
    }

    // If compression was cancelled on this VIO, preserve that fact.
    VIOCompressionState newState = {
      .status         = VIO_POST_PACKER,
      .mayNotCompress = true,
    };
    if (setCompressionState(dataVIO, state, newState)) {
      return;
    }
  }
}

/**********************************************************************/
bool cancelCompression(DataVIO *dataVIO)
{
  VIOCompressionState state;
  for (;;) {
    state = getCompressionState(dataVIO);
    if (state.mayNotCompress || (state.status == VIO_POST_PACKER)) {
      // This DataVIO is already set up to not block in the packer.
      break;
    }

    VIOCompressionState newState = {
      .status         = state.status,
      .mayNotCompress = true,
    };
    if (setCompressionState(dataVIO, state, newState)) {
      break;
    }
  }

  return ((state.status == VIO_PACKING) && !state.mayNotCompress);
}
