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

#include "limiter.h"

#include <linux/sched.h>

/**********************************************************************/
void getLimiterValuesAtomically(Limiter  *limiter,
                                uint32_t *active,
                                uint32_t *maximum)
{
  spin_lock(&limiter->lock);
  *active  = limiter->active;
  *maximum = limiter->maximum;
  spin_unlock(&limiter->lock);
}

/**********************************************************************/
void initializeLimiter(Limiter *limiter, uint32_t limit)
{
  limiter->active  = 0;
  limiter->limit   = limit;
  limiter->maximum = 0;
  init_waitqueue_head(&limiter->waiterQueue);
  spin_lock_init(&limiter->lock);
}

/**********************************************************************/
bool limiterIsIdle(Limiter *limiter)
{
  spin_lock(&limiter->lock);
  bool idle = limiter->active == 0;
  spin_unlock(&limiter->lock);
  return idle;
}

/**********************************************************************/
void limiterReleaseMany(Limiter *limiter, uint32_t count)
{
  spin_lock(&limiter->lock);
  limiter->active -= count;
  spin_unlock(&limiter->lock);
  if (waitqueue_active(&limiter->waiterQueue)) {
    wake_up_nr(&limiter->waiterQueue, count);
  }
}

/**********************************************************************/
void limiterWaitForIdle(Limiter *limiter)
{
  spin_lock(&limiter->lock);
  while (limiter->active > 0) {
    DEFINE_WAIT(wait);
    prepare_to_wait_exclusive(&limiter->waiterQueue, &wait,
                              TASK_UNINTERRUPTIBLE);
    spin_unlock(&limiter->lock);
    io_schedule();
    spin_lock(&limiter->lock);
    finish_wait(&limiter->waiterQueue, &wait);
  };
  spin_unlock(&limiter->lock);
}

/**
 * Take one permit from the limiter, if one is available, and update
 * the maximum active count if appropriate.
 *
 * The limiter's lock must already be locked.
 *
 * @param limiter  The limiter to update
 *
 * @return  true iff the permit was acquired
 **/
static bool takePermitLocked(Limiter *limiter)
{
  if (limiter->active >= limiter->limit) {
    return false;
  }
  limiter->active += 1;
  if (limiter->active > limiter->maximum) {
    limiter->maximum = limiter->active;
  }
  return true;
}

/**********************************************************************/
void limiterWaitForOneFree(Limiter *limiter)
{
  spin_lock(&limiter->lock);
  while (!takePermitLocked(limiter)) {
    DEFINE_WAIT(wait);
    prepare_to_wait_exclusive(&limiter->waiterQueue, &wait,
                              TASK_UNINTERRUPTIBLE);
    spin_unlock(&limiter->lock);
    io_schedule();
    spin_lock(&limiter->lock);
    finish_wait(&limiter->waiterQueue, &wait);
  };
  spin_unlock(&limiter->lock);
}

/**********************************************************************/
bool limiterPoll(Limiter *limiter)
{
  spin_lock(&limiter->lock);
  bool acquired = takePermitLocked(limiter);
  spin_unlock(&limiter->lock);
  return acquired;
}