/*
 * 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/kernel/instanceNumber.c#1 $
 */

#include "instanceNumber.h"

#include <linux/bitops.h>
#include <linux/mutex.h>

#include "memoryAlloc.h"
#include "numUtils.h"
#include "permassert.h"

/*
 * Track in-use instance numbers using a flat bit array.
 *
 * O(n) run time isn't ideal, but if we have 1000 VDO devices in use
 * simultaneously we still only need to scan 16 words, so it's not
 * likely to be a big deal compared to other resource usage.
 */

enum {
  /**
   * This minimum size for the bit array creates a numbering space of 0-999,
   * which allows successive starts of the same volume to have different
   * instance numbers in any reasonably-sized test. Changing instances on
   * restart allows vdoMonReport to detect that the ephemeral stats have reset
   * to zero.
   **/
  BIT_COUNT_MINIMUM   = 1000,
  /** Grow the bit array by this many bits when needed */
  BIT_COUNT_INCREMENT = 100,
};

static struct mutex   instanceNumberLock;
static unsigned int   bitCount;
static unsigned long *words;
static unsigned int   instanceCount;
static unsigned int   nextInstance;

/**
 * Return the number of bytes needed to store a bit array of the specified
 * capacity in an array of unsigned longs.
 *
 * @param bitCount  The number of bits the array must hold
 *
 * @return the number of bytes needed for the array reperesentation
 **/
static size_t getBitArraySize(unsigned int bitCount)
{
  // Round up to a multiple of the word size and convert to a byte count.
  return (computeBucketCount(bitCount, BITS_PER_LONG) * sizeof(unsigned long));
}

/**
 * Re-allocate the bitmap word array so there will more instance numbers that
 * can be allocated. Since the array is initially NULL, this also initializes
 * the array the first time we allocate an instance number.
 *
 * @return UDS_SUCCESS or an error code from the allocation
 **/
static int growBitArray(void)
{
  unsigned int newCount = maxUInt(bitCount + BIT_COUNT_INCREMENT,
                                  BIT_COUNT_MINIMUM);
  unsigned long *newWords;
  int result = reallocateMemory(words,
                                getBitArraySize(bitCount),
                                getBitArraySize(newCount),
                                "instance number bit array",
                                &newWords);
  if (result != UDS_SUCCESS) {
    return result;
  }

  bitCount = newCount;
  words    = newWords;
  return UDS_SUCCESS;
}

/**********************************************************************/
static int allocateKVDOInstanceLocked(unsigned int *instancePtr)
{
  // If there are no unallocated instances, grow the bit array.
  if (instanceCount >= bitCount) {
    int result = growBitArray();
    if (result != UDS_SUCCESS) {
      return result;
    }
  }

  // There must be a zero bit somewhere now. Find it, starting just after the
  // last instance allocated.
  unsigned int instance = find_next_zero_bit(words, bitCount, nextInstance);
  if (instance >= bitCount) {
    // Nothing free after nextInstance, so wrap around to instance zero.
    instance = find_first_zero_bit(words, bitCount);
    int result = ASSERT(instance < bitCount, "impossibly, no zero bit found");
    if (result != UDS_SUCCESS) {
      return result;
    }
  }

  __set_bit(instance, words);
  instanceCount += 1;
  nextInstance = instance + 1;
  *instancePtr = instance;
  return UDS_SUCCESS;
}

/**********************************************************************/
int allocateKVDOInstance(unsigned int *instancePtr)
{
  mutex_lock(&instanceNumberLock);
  int result = allocateKVDOInstanceLocked(instancePtr);
  mutex_unlock(&instanceNumberLock);
  return result;
}

/**********************************************************************/
void releaseKVDOInstance(unsigned int instance)
{
  mutex_lock(&instanceNumberLock);
  if (instance >= bitCount) {
    ASSERT_LOG_ONLY(false, "instance number %u must be less than bit count %u",
                    instance, bitCount);
  } else if (test_bit(instance, words) == 0) {
    ASSERT_LOG_ONLY(false, "instance number %u must be allocated", instance);
  } else {
    __clear_bit(instance, words);
    instanceCount -= 1;
  }
  mutex_unlock(&instanceNumberLock);
}

/**********************************************************************/
void initializeInstanceNumberTracking(void)
{
  mutex_init(&instanceNumberLock);
}

/**********************************************************************/
void cleanUpInstanceNumberTracking(void)
{
  ASSERT_LOG_ONLY(instanceCount == 0,
                  "should have no instance numbers still in use, but have %u",
                  instanceCount);
  FREE(words);
  words = NULL;
  bitCount = 0;
  instanceCount = 0;
  nextInstance = 0;
  mutex_destroy(&instanceNumberLock);
}