Subversion Repositories shark

/*

 * Project: HARTIK (HA-rd R-eal TI-me K-ernel)

 *

 * Coordinators: Giorgio Buttazzo <giorgio@sssup.it>

 *               Gerardo Lamastra <gerardo@sssup.it>

 *

 * Authors     : Massimiliano Giorgi <massy@hartik.sssup.it>

 * (see authors.txt for full list of hartik's authors)

 *

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

 *

 * http://www.sssup.it

 * http://retis.sssup.it

 * http://hartik.sssup.it

 */

/*

 * Copyright (C) 2000 Massimiliano Giorgi

 *

 * 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

 *

 */

/*

 * CVS :        $Id: trace.c,v 1.1.1.1 2002-03-29 14:12:53 pj Exp $

 *

 * File:        $File$

 * Revision:    $Revision: 1.1.1.1 $

 * Last update: $Date: 2002-03-29 14:12:53 $

 */

#include <ll/sys/types.h>

#include <kernel/assert.h>

#include <kernel/func.h>

#include <kernel/log.h>

#include <kernel/trace.h>

#include <modules/trace.h>

#include <modules/traceevt.h>

#include <modules/tracestr.h>

/* Well...

 * TRC_init2() and tracer() must be called when the system is up,

 * so they can call functions of the unistd.h

 */

#include <fcntl.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

/* -- */

/*+ number of event per blocks +*/

#define TRC_BLOCKSIZE     1024 

/*+ numbers of tables can grow until this is raggiunto +*/

#define TRC_MAXNUMTABLES    48

/* -- */

#define DEBUG_INIT KERN_DEBUG

//#undef DEBUGINIT

#ifdef DEBUG_INIT

#define printk0(fmt,args...) printk(DEBUG_INIT fmt,##args)

#else

#define printk0(fmt,args...)

#endif

/* -- */

static __inline__ void *allocmemory(long size)

{

  SYS_FLAGS f;

  void *ptr;

  f=kern_fsave();

  ptr=kern_alloc(size+sizeof(long));

  kern_frestore(f);

  if (ptr!=NULL) {

    *((long*)ptr)=size;

    return (char *)ptr+sizeof(long);

  }

  return ptr;

}

static __inline__ void freememory(void *ptr)

{

  SYS_FLAGS f;

  long size;

  size=*(long*)((char *)ptr-sizeof(long));

  f=kern_fsave();

  kern_free(ptr-sizeof(long),size+sizeof(long));

  kern_frestore(f);

}

/* -- */

typedef struct TAGtrc_events {

  struct TAGtrc_events *next;

  trc_event_t event[TRC_BLOCKSIZE] __attribute__((packed));

} trc_events;

static int counter;

static int hoops;

static trc_events *acttable,*writable;

static int actindex,wriindex;

static int handle=-1;

static int numtables;

static TASK tracer(void *dummy)

{

  int index,n,res;

  res=0;

  for (;;) {

    while (counter>0) {

      kern_cli();

      if (acttable!=writable) {

        kern_sti();

        n=TRC_BLOCKSIZE-wriindex;

        res=write(handle,writable->event+wriindex,n*sizeof(trc_event_t));

        writable=writable->next;

        wriindex=0;

      } else {

        index=actindex;

        kern_sti();

        n=index-wriindex;

        assertk(n>0);

        res=write(handle,writable->event+wriindex,n*sizeof(trc_event_t));

        wriindex=index;

      }

      if (res!=n*sizeof(trc_event_t)) {

        res=-1;

        break;

      }

      counter-=n;

      assertk(counter>=0);

    }

    /* errors trap */

    if (res==-1) {

      SYS_FLAGS f;

      f=kern_fsave();

      printk(KERN_ERR "tracer task write error!");

      kern_frestore(f);

      for (;;) task_endcycle();

    }

    task_endcycle();

  }

}

static TRACE_PARMS defparms=BASE_TRACE;

static TRACE_PARMS *myparms=&defparms;

static void internal_trc_logevent(PID pid, int event, void *ptr, int size);

int TRC_init_phase1(TRACE_PARMS *inparms)

{

  trc_events *nexttable;

  printk0("tracer init: START phase1");

  acttable=allocmemory(sizeof(trc_events));

  if (acttable==NULL) goto ERROR;

  printk0("tracer init: first table created");

  nexttable=allocmemory(sizeof(trc_events));

  if (nexttable==NULL) {

    freememory(acttable);

    acttable=NULL;

    goto ERROR;

  }

  printk0("tracer init: second table created");

  acttable->next=nexttable;

  nexttable->next=acttable;

  actindex=0;

  writable=acttable;

  wriindex=0;

  counter=0;

  hoops=0;

  numtables=2;

  printk0("tracer init: internal variables initialized");

  if (inparms!=NULL) myparms=inparms;

  trc_resume();

  printk0("tracer init: END phase 1 (tracer started)");

  return 0;

ERROR:

  printk(KERN_ERR "tracer initialization fails!");

  return -1;

}

static void TRC_end(void *dummy);

int TRC_init_phase2(void)

{

  trc_event_t event;

  SOFT_TASK_MODEL model;

  int res;

  PID pid;

  printk0("tracer init: START phase 2");

  /* for safety */

  if (acttable==NULL) return -1;

  printk0("tracer init: safety test passed");

  handle=open(myparms->filename,O_CREAT|O_TRUNC|O_WRONLY);  

  if (handle==-1) goto ERROR;

  printk0("tracer init: file opened");

  event.size=sizeof(trc_event_t);

  event.what=TRC_INITLOG;

  event.x.id=TRC_INITID;

  //cprintf("size=====%li\n",sizeof(trc_event_t));

  res=write(handle,&event,sizeof(trc_event_t));

  if (res!=sizeof(trc_event_t)) goto ERROR;

  printk0("tracer init: write");

  soft_task_default_model(model);

  soft_task_def_system(model);

  soft_task_def_notrace(model);

  soft_task_def_periodic(model);

  soft_task_def_period(model,myparms->period);

  soft_task_def_met(model,myparms->slice);

  soft_task_def_wcet(model,myparms->slice);

  pid=task_create("sysTracer",tracer,&model,NULL);

  if (pid==-1) goto ERROR;

  task_activate(pid);

  printk0("tracer init: tracer task created and activated");

  //sys_atexit(TRC_end,(void*)handle,BEFORE_EXIT);

  printk0("tracer init: END phase 2");

  printk (KERN_NOTICE "tracer started!");

  return 0;

ERROR:

  kern_cli();

  freememory(acttable->next);

  freememory(acttable);

  acttable=NULL;

  kern_sti();

  if (handle!=-1) close(handle);

  printk(KERN_ERR "tracer initialization fails (%s)!",strerror(errno));

  return -1;

}

static void (*old_logevent)(PID pid, int event, void *ptr, int size)=NULL;

int trc_resume(void)

{

  SYS_FLAGS f;

  int ret=-1;

  f=kern_fsave();

  if (acttable!=NULL&&old_logevent==NULL) {  

    old_logevent=trc_logevent;

    trc_logevent=internal_trc_logevent;

    ret=0;

  }

  kern_frestore(f);

  return ret;

}

int trc_suspend(void)

{

  SYS_FLAGS f;

  int ret=-1;

  f=kern_fsave();

  if (acttable!=NULL&&old_logevent!=NULL) {    

    trc_logevent=old_logevent;

    old_logevent=NULL;

    ret=0;

  }

  kern_frestore(f);

  return 0;

}

static void TRC_end(void *dummy)

{

  printk(KERN_INFO "shuting down tracer...");

  trc_suspend();

  if (counter>0) {

    /* wait a bit for flushing events queue */

    int x=30;

    while (counter>0) {

      cprintf("<%li>",(long)counter);

      task_delay(100000); // 100msec

      if (x--==0) break;

    }

  }

  close(handle);

  printk(KERN_DEBUG "tracer hoops:     %5i",hoops);

  printk(KERN_DEBUG "tracer numtables: %5i",numtables);  

}

static trc_event_t *getrecord(void)

{

  trc_events  *newtable;

  trc_event_t *event;

  event=&acttable->event[actindex];

  actindex++;

  if (actindex==TRC_BLOCKSIZE) {

    actindex=0;    

    if (acttable->next==writable) {

      if (numtables==TRC_MAXNUMTABLES) {

        hoops++;

        actindex=TRC_BLOCKSIZE-1;

        return NULL;

      }

      newtable=allocmemory(sizeof(trc_events));

      if (newtable==NULL) {

        hoops++;

        actindex=TRC_BLOCKSIZE-1;

        return NULL;

      }

      newtable->next=acttable->next;

      acttable->next=newtable;

      acttable=newtable;

      numtables++;

    }

    else acttable=acttable->next;    

  }

  return event;

}

static void internal_trc_logevent(int event, PID pid, void *ptr, int size)

{

  SYS_FLAGS f;

  trc_event_t *evt;

  if (acttable==NULL) return;

  f=kern_fsave();

  evt=getrecord();  

  if (evt!=NULL) {

    evt->size=sizeof(trc_event_t);

    evt->what=event;

    if ((event&0xff00)==(TRC_USR_EVENTS<<8)) {

          evt->x.user.when=ll_gettime(TIME_EXACT,NULL);

          evt->x.user.who=(pid==TRC_NOPID?exec_shadow:pid);

          if (ptr!=NULL) memcpy(&evt->x.user.info,ptr,TRC_MAXUSERINFO);  

    } else

      switch (event) {

        case TRC_TASKNAME:

          evt->x.tskname.who=pid;

          memcpy(&evt->x.tskname.name,ptr,TRC_MAXNAMESIZE);

          break;

        case TRC_SCHEDULE:

          evt->x.sched.when=ll_gettime(TIME_EXACT,NULL);

          memcpy(&evt->x.sched.info,ptr,sizeof(trc_schedule_t));

          break;

        default:

          evt->x.norm.when=ll_gettime(TIME_EXACT,NULL);

          evt->x.norm.who=pid;

          break;

      }

    counter++;

  }

  kern_frestore(f);

  return;

}