/* Copyright (C) 2004 David Decotigny

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. 
*/

#include <sos/errno.h>
#include <sos/klibc.h>
#include <sos/assert.h>
#include <sos/list.h>

#include "sched.h"


/**
 * The definition of the scheduler queue. We could have used a normal
 * kwaitq here, it would have had the same properties. But, in the
 * definitive version (O(1) scheduler), the structure has to be a bit
 * more complicated. So, in order to keep the changes as small as
 * possible between this version and the definitive one, we don't use
 * kwaitq here.
 */
static struct
{
  unsigned int nr_threads;
  struct sos_thread *thread_list;
} ready_queue;


sos_ret_t sos_sched_subsystem_setup()
{
  memset(& ready_queue, 0x0, sizeof(ready_queue));

  return SOS_OK;
}


/**
 * Helper function to add a thread in a ready queue AND to change the
 * state of the given thread to "READY".
 *
 * @param insert_at_tail TRUE to tell to add the thread at the end of
 * the ready list. Otherwise it is added at the head of it.
 */
static sos_ret_t add_in_ready_queue(struct sos_thread *thr,
				    sos_bool_t insert_at_tail)
{

  SOS_ASSERT_FATAL( (SOS_THR_CREATED == thr->state)
		    || (SOS_THR_RUNNING == thr->state) /* Yield */
		    || (SOS_THR_BLOCKED == thr->state) );

  /* Add the thread to the CPU queue */
  if (insert_at_tail)
    list_add_tail_named(ready_queue.thread_list, thr,
			ready.rdy_prev, ready.rdy_next);
  else
    list_add_head_named(ready_queue.thread_list, thr,
			ready.rdy_prev, ready.rdy_next);
  ready_queue.nr_threads ++;

  /* Ok, thread is now really ready to be (re)started */
  thr->state = SOS_THR_READY;

  return SOS_OK;
}


sos_ret_t sos_sched_set_ready(struct sos_thread *thr)
{
  sos_ret_t retval;

  /* Don't do anything for already ready threads */
  if (SOS_THR_READY == thr->state)
    return SOS_OK;

  /* Real-time thread: schedule it for the present turn */
  retval = add_in_ready_queue(thr, TRUE);

  return retval;
}


struct sos_thread * sos_reschedule(struct sos_thread *current_thread,
				   sos_bool_t do_yield)
{

  if (SOS_THR_ZOMBIE == current_thread->state)
    {
      /* Don't think of returning to this thread since it is
	 terminated */
      /* Nop */
    }
  else if (SOS_THR_BLOCKED != current_thread->state)
    {
      /* Take into account the current executing thread unless it is
	 marked blocked */
      if (do_yield)
	/* Ok, reserve it for next turn */
	add_in_ready_queue(current_thread, TRUE);
      else
	/* Put it at the head of the active list */
	add_in_ready_queue(current_thread, FALSE);
    }

  /* The next thread is that at the head of the ready list */
  if (ready_queue.nr_threads > 0)
    {
      struct sos_thread *next_thr;

      /* Queue is not empty: take the thread at its head */
      next_thr = list_pop_head_named(ready_queue.thread_list,
				     ready.rdy_prev, ready.rdy_next);
      ready_queue.nr_threads --;

      return next_thr;
    }

  SOS_FATAL_ERROR("No kernel thread ready ?!");
  return NULL;
}