Subversion Repositories shark

/*

 * Project: S.Ha.R.K.

 *

 * Coordinators:

 *   Giorgio Buttazzo    <giorgio@sssup.it>

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *

 * Authors     :

 *   Paolo Gai           <pj@gandalf.sssup.it>

 *   (see the web pages for full authors list)

 *

 * ReTiS Lab (Scuola Superiore S.Anna - Pisa - Italy)

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://shark.sssup.it

 */

/**

 ------------

 CVS :        $Id: kern.c,v 1.2 2002-11-11 08:34:08 pj Exp $

 File:        $File$

 Revision:    $Revision: 1.2 $

 Last update: $Date: 2002-11-11 08:34:08 $

 ------------

 This file contains:

 - the kernel system variables

 - the errno functions

 - the scheduler, capacity timer, and grarantee

 - the sys_abort, sys_end, sys_gettime

**/

/*

 * Copyright (C) 2000 Paolo Gai

 *

 * 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 <stdarg.h>

#include <ll/ll.h>

#include <ll/stdlib.h>

#include <ll/stdio.h>

#include <ll/string.h>

#include <kernel/config.h>

#include <kernel/model.h>

#include <kernel/const.h>

#include <sys/types.h>

#include <kernel/types.h>

#include <kernel/descr.h>

#include <errno.h>

#include <kernel/var.h>

#include <kernel/func.h>

#include <kernel/trace.h>

/*----------------------------------------------------------------------*/

/* Kernel System variables                                              */

/*----------------------------------------------------------------------*/

int global_errnumber;   /*+ Errno used in system initialization  +*/

CONTEXT global_context; /*+ Context used during initialization;

                            It references also a safe stack      +*/

int task_counter;       /*+ Application task counter. It represent

                            the number of Application tasks in the

                            system. When all Application Tasks end,

                            also the system ends.                +*/

int system_counter;     /*+ System task counter. It represent

                            the number of System tasks in the

                            system with the NO_KILL flag reset.

                            When all Application Tasks end,

                            the system waits for the end of the

                            system tasks and then it ends.       +*/

PID exec;               /*+ Task advised by the scheduler        +*/

PID exec_shadow;        /*+ Currently executing task             +*/

IQUEUE freedesc;        /*+ Free descriptor handled as a queue   +*/

DWORD sys_tick;         /*+ System tick (in usec)                +*/

struct timespec schedule_time;

                        /*+ Timer read at each call to schedule()+*/

int   cap_timer;        /*+ the capacity event posted when the

                            task starts                          +*/

struct timespec cap_lasttime;

                        /*+ the time at whitch the capacity

                            event is posted. Normally, it is

                            equal to schedule_time               +*/

DWORD sched_levels;     /*+ Schedule levels active in the system +*/

DWORD res_levels;       /*+ Resource levels active in the system +*/

/*+ Process descriptor table +*/

proc_des proc_table[MAX_PROC];

/*+ Level descriptor table +*/

level_des *level_table[MAX_SCHED_LEVEL];

/*+ Resource descriptor table +*/

resource_des *resource_table[MAX_RES_LEVEL];

/*+ This variable is set by the system call sys_end() or sys_abort().

    When a sys_end() or sys_abort is called into an event handler,

    we don't have to change context in the reschedule().

    look at kernel/event.c +*/

int mustexit = 0;

/*+ this is the system runlevel... it may be from 0 to 4:

    1 - running

    2 - shutdown

    3 - before halting

    4 - halting

+*/

int runlevel;

/*+ this variable is set to 1 into call_runlevel_func (look at init.c)

    ad it is used because the task_activate (look at activate.c) must

    work in a different way when the system is in the global_context +*/

int calling_runlevel_func;

/*----------------------------------------------------------------------*/

/* Kernel internal functions                                            */

/*----------------------------------------------------------------------*/

/*+ errno Handling: this functions returns the correct address for errno.

    The address returned can be either the global errno or the errno local

    to the execution task */

static int *__errnumber()

{

  if (exec_shadow == -1)

    return &global_errnumber;

  else

    return &(proc_table[exec_shadow].errnumber);

}

/*+ this is the capacity timer. it fires when the running task has expired

    his time contained in the avail_time field. The event is tipically

    posted in the scheduler() after the task_dispatch. The task_dispatch

    can modify the avail_time field to reach his scheduling purposes.

    The wcet field is NOT used in the Generic kernel. it is initialized at

    init time to 0. +*/

void capacity_timer(void *arg)

{

  /* the capacity event is served, so at the epilogue we

     don't have to erase it */

  cap_timer = NIL;

//  kern_printf("cap%d ",exec_shadow);

  /* When we reschedule, the call to task_epilogue check the slice and

     put the task in the queue's tail */

  event_need_reschedule();

}

/*+

  Generic Scheduler:

  This function select the next task that should be executed.

  The selection is made calling the level schedulers.

  It assume that THERE IS a task that can be scheduled in one

  level.

  The general scheduler:

  - first, it checks for interrupts.

  - then, it calls the epilogue of the task pointed in exec_shadow

  - after that, it calls the level schedulers

  - then it sets exec and it follows the shadow chain

  - finally it calls task_dispatch for the new task (the shadow!!!),

    saying if exec != exec_shadow

+*/

void scheduler(void)

{

  LEVEL l;    /* a counter                                     */

  TIME tx;    /* a dummy used for time computation             */

  struct timespec ty; /* a dummy used for time computation     */

  PID p;      /* p is the task chosen by the level scheduler   */

  int ok;     /* 1 only if the task chosen by the level scheduler

                 is eligible (normally, it is; but in some server

                 it is not always true (i.e., CBS))            */

  PID old_exec_shadow;

  if ( (exec_shadow != -1 &&

       (proc_table[exec_shadow].control & NO_PREEMPT) ) )

    return;

  /*

  exec_shadow = exec = -1 only if the scheduler is called from:

   . task_endcycle

   . task_kill

   . task_extract

   . task_sleep

   . task_delay

  and from the system startup routines.

  Normally, the scheduler is called with exec & co != -1...

  if exec & co. is set to -1 before calling scheduler(), the following

  stuffs have to be executed before the call

  - get the schedule_time

  - account the capacity if necessary

  - call an epilogue

  */

  if (exec_shadow != -1) {

    // ok is set 4 debug :-(

    ok = ll_gettime(TIME_EXACT, &schedule_time);

//    kern_printf("(%d sched s%d ns%d)", ok, schedule_time.tv_sec, schedule_time.tv_nsec);

    /* manage the capacity event */

    SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);

    tx = TIMESPEC2USEC(&ty);

    proc_table[exec_shadow].avail_time -= tx;

    jet_update_slice(tx);

    /* if the event didn't fire before, we delete it. */

    if (cap_timer != NIL) {

      event_delete(cap_timer);

      cap_timer = NIL;

    }

    /* then, we call the epilogue. the epilogue tipically checks the

       avail_time field... */

//  kern_printf("(e%d)",exec_shadow);

    l = proc_table[exec_shadow].task_level;

    level_table[l]->task_epilogue(l,exec_shadow);

  }

  l = 0;

  for(;;) {

    do {

      p = level_table[l]->level_scheduler(l);

      if (p != NIL)

        ok = level_table[ proc_table[p].task_level ]->

          task_eligible(proc_table[p].task_level,p);

      else

        ok = 0;

    } while (ok < 0); /* repeat the level scheduler if the task isn't

                         eligible... (ex. in the aperiodic servers...) */

    if (p != NIL) break;

    l++;            /* THERE MUST BE a level with a task to schedule */

  };

  /* tracer stuff */

  //trc_logevent(exec,TRC_SCHEDULE,NULL,0);

  /* we follow the shadow chain */

  old_exec_shadow=exec_shadow;

  exec_shadow = exec = p;

  while (exec_shadow != proc_table[exec_shadow].shadow)

    exec_shadow = proc_table[exec_shadow].shadow;

  /* tracer stuff */

  //trc_logevent(exec_shadow,TRC_DISPATCH,NULL,0);

  if (old_exec_shadow!=exec_shadow)

    trc_logevent(TRC_SCHEDULE,&exec_shadow);

  //  kern_printf("[%i->%i]",old_exec_shadow,exec_shadow);

  /* we control the correctness of the shadows when we kill */

  proc_table[exec_shadow].status = EXE;

  //kern_printf("(d%d)",exec_shadow);

  l = proc_table[exec_shadow].task_level;

  level_table[l]->task_dispatch(l, exec_shadow, exec!=exec_shadow);

  /* Finally,we post the capacity event, BUT

     . only if the task require that

     . only if exec==exec_shadow (if a task is blocked we don't want

       to check the capacity!!!) */

  if ((proc_table[exec_shadow].control & CONTROL_CAP)

      && exec==exec_shadow) {

    TIMESPEC_ASSIGN(&ty, &schedule_time);

    ADDUSEC2TIMESPEC(proc_table[exec_shadow].avail_time,&ty);

//    kern_printf("³s%d ns%d sched s%d ns%d³",ty.tv_sec,ty.tv_nsec, schedule_time.tv_sec, schedule_time.tv_nsec);

    cap_timer = kern_event_post(&ty, capacity_timer, NULL);

  }

  /* set the time at witch the task is scheduled */

  TIMESPEC_ASSIGN(&cap_lasttime, &schedule_time);

  //if (runlevel != 1) kern_printf("(s%d)",exec_shadow);

}

/*+

  Guarantee:

  This function guarantees the system: it calls the

  level_guarantee of each level that have that function != NULL

  The guarantee is based on a utilization factor basis.

  We mantain only a DWORD. num has to be interpreted as num/MAX_DWORD

  free bandwidth.

+*/

int guarantee()

{

  bandwidth_t num=MAX_BANDWIDTH;

  int l;

  for (l =0; l<MAX_SCHED_LEVEL && level_table[l]->level_guarantee; l++)

    if (!level_table[l]->level_guarantee(l,&num))

      return -1;

  return 0; /* OK */

}

/*----------------------------------------------------------------------*/

/* Context switch handling functions                                    */

/*----------------------------------------------------------------------*/

/* this function is called every time a context change occurs,

   when a task is preempted by an event called into an IRQ */

void kern_after_dispatch()

{

  /* every time a task wakes up from an IRQ, it has to check for async

     cancellation */

  check_killed_async();

  /* Then, look for pending signal delivery */

  kern_deliver_pending_signals();

}

/*----------------------------------------------------------------------*/

/* Kernel main system functions                                         */

/*----------------------------------------------------------------------*/

extern int trc_systemevents(trc_event_t *evt, int event, void *ptr);

/*+

  This function initialize

  - the virtual machine (timer, interrupt, mem)

  the system's structures (queues, tables) , & the two task main &

  dummy, that are always present

+*/

void __kernel_init__(struct multiboot_info *multiboot)

{

  int i,j;                                              /* counters */

  struct ll_initparms parms;                          /* for the VM */

//  extern void C8042_restore(void);              /* an exit function */

  int aborting;          /* it is set if we are aborting the system */

  /*

   * Runlevel 0: kernel startup

   *

   *

   */

  runlevel = 0;

  /* The kernel startup MUST proceed with int disabled!    */

  kern_cli();

  /* First we initialize the memory allocator, because it is needed by

     __kernel_register_levels__     */

  kern_mem_init(multiboot);

  /* Clear the task descriptors */

  for (i = 0; i < MAX_PROC; i++) {

     proc_table[i].task_level   = -1;

     proc_table[i].stack        = NULL;

     proc_table[i].name[0]      = 0;

     proc_table[i].status       = FREE;

     proc_table[i].pclass       = 0;

     proc_table[i].group        = 0;

     proc_table[i].stacksize    = 0;

     proc_table[i].control      = 0;

     proc_table[i].frozen_activations = 0;

     proc_table[i].sigmask      = 0;

     proc_table[i].sigpending   = 0;

     NULL_TIMESPEC(&proc_table[i].request_time);

     proc_table[i].avail_time   = 0;

     proc_table[i].shadow       = i;

     proc_table[i].cleanup_stack= NULL;

     proc_table[i].errnumber    = 0;

     //proc_table[i].priority     = 0;

     //NULL_TIMESPEC(&proc_table[i].timespec_priority);

     proc_table[i].delay_timer  = -1;

     proc_table[i].wcet         = -1;

     proc_table[i].jet_tvalid   = 0;

     proc_table[i].jet_curr     = 0;

     proc_table[i].jet_max      = 0;

     proc_table[i].jet_sum      = 0;

     proc_table[i].jet_n        = 0;

     for (j=0; j<JET_TABLE_DIM; j++)

        proc_table[i].jet_table[j] = 0;

     proc_table[i].waiting_for_me = NIL;

     proc_table[i].return_value   = NULL;

     for (j=0; j<PTHREAD_KEYS_MAX; j++)

       proc_table[i].keys[j] = NULL;

  }

  /* set up the free descriptor queue */

  //  for (i = 0; i < MAX_PROC-1; i++) proc_table[i].next = i+1;

  //  proc_table[MAX_PROC-1].next = NIL;

  //  for (i = MAX_PROC-1; i > 0; i--) proc_table[i].prev = i-1;

  //  proc_table[0].prev = NIL;

  //  freedesc = 0;

  iq_init(&freedesc, NULL, 0);

  for (i = 0; i < MAX_PROC; i++)

    iq_insertlast(i,&freedesc);

  /* Set up the varius stuff */

  global_errnumber = 0;

  task_counter     = 0;

  system_counter   = 0;

  exec             = -1;

  exec_shadow      = -1;

  cap_timer        = -1;

  NULL_TIMESPEC(&cap_lasttime);

  sched_levels     = 0;  /* They are not registered yet... */

  res_levels       = 0;

  calling_runlevel_func = 0;

  /* Clear the key-specific data */

  task_specific_data_init();

  /* Clear exit and init functions */

  runlevel_init();

  /* Init VM layer (Interrupts, levels & memory management)           */

  /* for old exception handling, use excirq_init() */

  signals_init();

  sys_tick = __kernel_register_levels__(multiboot);

  /* tracer stuff */

  /*

  trc_register_eventclass(TRC_CLASS_SYSTEM,

                          TRC_SYSTEMNUMBER,

                          trc_systemevents);

  */

  /* test on system tick */

  if (sys_tick>=55000)  {

     printk("The system tick must be less than 55 mSec!");

     l1_exit(0);

  }

  /* OSLib initialization */

  if (sys_tick)

    parms.mode = LL_PERIODIC;

  else

    parms.mode = LL_ONESHOT; // one shot!!!

  parms.tick = sys_tick;

  /*

   * Runlevel 1: Let's go!!!!

   *

   *

   */

  runlevel = RUNLEVEL_INIT;

  ll_init();

  event_init(&parms);

  seterrnumber(__errnumber);

  event_setprologue(event_resetepilogue);

  event_setlasthandler(kern_after_dispatch);

  /* call the init functions */

  call_runlevel_func(RUNLEVEL_INIT, 0);

  /* reset keyboard after exit */

//  sys_atexit((void(*)(void *))C8042_restore,NULL,AFTER_EXIT);

  /* tracer stuff */

  trc_resume();

  /* exec and exec_shadow are already = -1 */

  ll_gettime(TIME_EXACT, &schedule_time);

  scheduler();

  global_context = ll_context_from(); /* It will be used by sys_end */

  ll_context_to(proc_table[exec_shadow].context);

  /*

   *

   * Now the system starts!!!

   * (hoping that someone has created some task(s) )

   * The function returns only at system end...

   *

   */

  /*

   * Runlevel 2: Shutting down the system... :-(

   *

   *

   */

  event_setlasthandler(NULL);

  // ll_abort(666); 

  /* tracer stuff */

  trc_suspend();

  runlevel = RUNLEVEL_SHUTDOWN;

  /* 1 when the error code is != 0 */

  aborting = global_errnumber > 0;

  //kern_printf("after  - system_counter=%d, task_counter = %d\n",

  //         system_counter,task_counter); 

  call_runlevel_func(RUNLEVEL_SHUTDOWN, aborting);

  //kern_printf("before - system_counter=%d, task_counter = %d\n",

  //          system_counter,task_counter);

  if (system_counter) {

    /* To shutdown the kernel correctly, we have to wait that all the SYSTEM

       tasks that are killable will die...

       We don't mess about the user task... we only kill them and reschedule

       The only thing important is that the system tasks shut down correctly.

       We do nothing for user tasks that remain active (because, for example,

       they have the cancelability set to deferred) when the system goes to

       runlevel 3 */

    //kern_printf("Û%lu",ll_gettime(TIME_EXACT,NULL));

    kill_user_tasks();

    //kern_printf("Û%lu",ll_gettime(TIME_EXACT,NULL)); 

    /* we have to go again in multitasking mode!!! */

    mustexit = 0;

    /* exec and exec_shadow are already = -1 */

    ll_gettime(TIME_EXACT, &schedule_time);

    global_context = ll_context_from(); /* It will be used by sys_end */

    scheduler();

    event_setlasthandler(kern_after_dispatch);

    ll_context_to(proc_table[exec_shadow].context);

    event_setlasthandler(NULL);

  }

  /*

   * Runlevel 3: Before Halting the system

   *

   *

   */

  runlevel = RUNLEVEL_BEFORE_EXIT;

  /* the field global_errnumber is

     =0  if the system normally ends

     !=0 if an abort is issued

  */

  //kern_printf("Chiamo exit Functions\n"); 

  call_runlevel_func(RUNLEVEL_BEFORE_EXIT, aborting);

  //kern_printf("Dopo exit Functions\n"); 

  /* Shut down the VM layer */

  ll_end();

  /*

   * Runlevel 4: After halting...

   *

   *

   */

  runlevel = RUNLEVEL_AFTER_EXIT;

  //kern_printf("prima before Functions\n"); 

  call_runlevel_func(RUNLEVEL_AFTER_EXIT, 0);

  //kern_printf("dopo before Functions\n"); 

  kern_cli();

  if (global_errnumber) {

    /* vm_abort called */

    kern_printf("Abort detected\nCode : %u\n",global_errnumber);

    l1_exit(-1);

  }

  l1_exit(0); // System terminated normally

}

void internal_sys_end(int i)

{

  LEVEL l;    /* a counter                                     */

  TIME tx;    /* a dummy used for time computation             */

  struct timespec ty; /* a dummy used for time computation     */

  //kern_printf("mustexit=%d",mustexit);

  if (!mustexit) {

    if (!ll_ActiveInt())

      proc_table[exec_shadow].context = kern_context_save();

    global_errnumber = i;

    mustexit = 1;

    if (exec_shadow != -1) {

      ll_gettime(TIME_EXACT, &schedule_time);

      /* manage the capacity event */

      SUBTIMESPEC(&schedule_time, &cap_lasttime, &ty);

      tx = TIMESPEC2USEC(&ty);

      proc_table[exec_shadow].avail_time -= tx;

      jet_update_slice(tx);

      /* if the event didn't fire before, we delete it. */

      if (cap_timer != NIL) {

        event_delete(cap_timer);

        cap_timer = NIL;

      }

      /* then, we call the epilogue. the epilogue tipically checks the

         avail_time field... */

      l = proc_table[exec_shadow].task_level;

      level_table[l]->task_epilogue(l,exec_shadow);

      exec_shadow = exec = -1;

    }

    if (ll_ActiveInt())

      ll_context_to(global_context);

    else

      kern_context_load(global_context);

  }

  //kern_printf("fine sysend");

  /* the control reach this line only if we call sys_end() into an event

     handler (for example, if the event raises an exception with

     SA_USEFAST active and the exception calls sys_end() ) */

}

/*+ Close the system & return to HOST OS.

    Can be called from all the tasks...

    The first time it is called it jumps to the global context

    The second time it jumps only if there are no system task remaining

    The error code passed is 0... (it is saved on the first call!!!) +*/

void sys_end(void)

{

  SYS_FLAGS f;

  /* the sys_end change the context to the global context.

     when the first time is called, it simply kills all the users tasks

     and waits the system tasks to end... */

  /*kern_printf("°sys_end %d°",exec_shadow);*/

  /*return;*/

  f = kern_fsave();

  if (runlevel != RUNLEVEL_INIT && system_counter) {

    kern_frestore(f);

    return;

  }

  internal_sys_end(0);

  kern_frestore(f);

}

/*+ Close the system & return to HOST OS.

    Can be called from all the tasks...

    The first time it is called it works as the sys_end

    The second time it jumps every time

    The error code passed is 0... +*/

void sys_abort(int err)

{

  /* the sys_end change the context to the global context.

     when the first time is called, it simply kills all the users tasks

     and waits the system tasks to end... */

  internal_sys_end(err);

}

/*+ equal to sys_end! +*/

void _exit(int status)

{

  SYS_FLAGS f;

  /* the sys_end change the context to the global context.

     when the first time is called, it simply kills all the users tasks

     and waits the system tasks to end... */

  /*kern_printf("°sys_end %d°",exec_shadow);*/

  /*return;*/

  f = kern_fsave();

  if (runlevel != RUNLEVEL_INIT && system_counter) {

    kern_frestore(f);

    return;

  }

  internal_sys_end(status);

  kern_frestore(f);

}

/* this function is never called... used for the OSLib */

void sys_abort_tail(int code)

{

 //DUMMY!!!!

}

/*+ this primitive returns the time read from the system timer +*/

TIME sys_gettime(struct timespec *t)

{

  SYS_FLAGS f;

  TIME x;

  f = kern_fsave();

  x = ll_gettime(TIME_EXACT,t);

  kern_frestore(f);

  return x;

}