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>
 *   Massimiliano Giorgi <massy@gandalf.sssup.it>
 *   Luca Abeni          <luca@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
 */

/*
 * Copyright (C) 1999 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:52 pj Exp $
 *
 * File:        $File$
 * Revision:    $Revision: 1.1.1.1 $
 * Last update: $Date: 2002-03-29 14:12:52 $
 */

#include <ll/sys/types.h>
#include <ll/stdlib.h>
#include <ll/string.h>

#include <kernel/func.h>
#include <kernel/trace.h>

#include <trace/types.h>
#include <trace/trace.h>
#include <trace/queues.h>

#include <bits/limits.h>

#define TRC_MAXQUEUES 5

/*
 *
 */

static char basepath[PATH_MAX];

void trc_create_name(char *basename, int uniq, char *pathname)
{
  if (uniq) sprintf(pathname,"%s/%s%i",basepath,basename,uniq);
  else      sprintf(pathname,"%s/%s",basepath,basename);
}

/*
 *
 */

#define FLAG_NOTRACE 0x01

typedef struct TAGtrc_evtinfo_t {
  trc_queue_t *queue;
  unsigned    flags;
} trc_evtinfo_t;

/* -- */

trc_evtinfo_t eventstable[TRC_NUMEVENTS];

int (*createqueue[TRC_QUEUETYPESNUMBER])(trc_queue_t *, void *);
int (*activatequeue[TRC_QUEUETYPESNUMBER])(void *,int);
int (*terminatequeue[TRC_QUEUETYPESNUMBER])(void *);

trc_queue_t queuetable[TRC_MAXQUEUES];
trc_queue_t queuesink;
int numqueues;

/* -- */

static trc_event_t *dummy_get(void *foo)
{  
  return NULL;
}

static int dummy_post(void *foo)
{
  return 0;
}

static int dummy_createqueue(trc_queue_t *queue, void *unused)
{
  queue->get=dummy_get;
  queue->post=dummy_post;
  queue->data=NULL;
  return 0;
}

static int dummy_terminatequeue(void *unused)
{
  return 0;
}

static int dummy_activatequeue(void *unused, int unused2)
{
  return 0;
}

/* -- */

int trc_register_queuetype(int queuetype,
                           int(*creat)(trc_queue_t *, void *),
                           int(*activate)(void *,int),
                           int(*term)(void *))
{
  if (queuetype<0||queuetype>=TRC_QUEUETYPESNUMBER) return -1;
  createqueue[queuetype]=creat;
  activatequeue[queuetype]=activate;
  terminatequeue[queuetype]=term;
  return 0;
}

int trc_create_queue(int queuetype, void *args)
{
  int res;

  if (createqueue[queuetype]==dummy_createqueue) return -1;
  if (numqueues==TRC_MAXQUEUES) return -1;
  res=createqueue[queuetype](&queuetable[numqueues],args);
  if (res) return -1;
  queuetable[numqueues].type=queuetype;
  numqueues++;
  return numqueues-1;
}

/* -- */

static void (*old_logevent)(int event, void *ptr)=NULL;
static void internal_trc_logevent(int, void *ptr);

static void trc_end(void *unused)
{
  int i;
 
  printk(KERN_INFO "tracer shutdown...");
 
  /* suspend event logging */
  trc_suspend();

  /* for safety: send all events to the sink queue */
  for (i=0;i<TRC_NUMEVENTS;i++) {
    eventstable[i].queue=&queuesink;
    eventstable[i].flags|=FLAG_NOTRACE;
  }
 
  /* terminate all queues */
  for (i=0;i<numqueues;i++)
    terminatequeue[queuetable[i].type](queuetable[i].data);
}

static int internal_trc_resume(void);
static int internal_trc_suspend(void);

int TRC_init_phase1(TRC_PARMS *parms)
{
  int i;
 
  printk(KERN_INFO "initializing tracer...");
 
  for (i=0;i<TRC_QUEUETYPESNUMBER;i++) {
    createqueue[i]=dummy_createqueue;
    terminatequeue[i]=dummy_terminatequeue;
  }
  dummy_createqueue(&queuesink,NULL);
  numqueues=0;
 
  for (i=0;i<TRC_NUMEVENTS;i++) {
    eventstable[i].queue=&queuesink;
    eventstable[i].flags=FLAG_NOTRACE;
  }
 
  i=sys_atrunlevel(trc_end,NULL,RUNLEVEL_SHUTDOWN);

  {
    TRC_PARMS m;
    trc_default_parms(m);
    if (parms==NULL) parms=&m;

    strncpy(basepath,parms->path,sizeof(basepath));
    basepath[sizeof(basepath)-1]='\0';
  }

  trc_suspend=internal_trc_suspend;
  trc_resume=internal_trc_resume;
   
  trc_resume();
  return 0;
}

int TRC_init_phase2(void)
{
  int i;
  for (i=0;i<numqueues;i++)
    activatequeue[queuetable[i].type](queuetable[i].data,i+1);
  return 0;
}

static int internal_trc_resume(void)
{
  SYS_FLAGS f;
  int ret=-1;
  f=kern_fsave();
  if (old_logevent==NULL) {  
    old_logevent=trc_logevent;
    trc_logevent=internal_trc_logevent;
    ret=0;
  }
  kern_frestore(f);
  return ret;
}

static int internal_trc_suspend(void)
{
  SYS_FLAGS f;
  int ret=-1;
  f=kern_fsave();
  if (old_logevent!=NULL) {    
    trc_logevent=old_logevent;
    old_logevent=NULL;
    ret=0;
  }
  kern_frestore(f);
  return 0;
}

static void internal_trc_logevent(int event, void *ptr)
{
  trc_event_t   *evt;
  trc_queue_t   *queue;
  SYS_FLAGS f;

  f=kern_fsave();

  if (eventstable[event].flags&FLAG_NOTRACE) {
    kern_frestore(f);
    return;
  }
  queue=eventstable[event].queue;
 
  evt=queue->get(queue->data);
  if (evt!=NULL) {
    evt->event=event;
    evt->time=ll_gettime(TIME_EXACT,NULL);
    memcpy(&evt->x,ptr,sizeof(trc_allevents_t));
    queue->post(queue->data);
  }
 
  kern_frestore(f);
}

/*
 *
 *
 *
 */

int classtable[TRC_NUMCLASSES+1]={
  TRC_F_TRACER,
  TRC_F_SYSTEM,
  TRC_F_USER,
  TRC_F_LL,
  TRC_F_SEM,
  TRC_F_LAST
};

#define checkevent(x)   if ((x)<0||(x)>=TRC_NUMEVENTS) return -1
#define checkqueue(x)   if ((x)<0||(x)>=numqueues) return -1
#define checkclass(x)   if ((x)<0||(x)>=TRC_NUMCLASSES) return -1

int trc_assign_event_to_queue(int event, int queue)
{
  checkevent(event);
  checkqueue(queue);
  eventstable[event].queue=&queuetable[queue];
  return 0;
}

int trc_assign_class_to_queue(int class, int queue)
{
  int i;
  checkqueue(queue);
  checkclass(class);
  for (i=classtable[class];i<classtable[class+1];i++)
    eventstable[i].queue=&queuetable[queue];
  return 0;
}

int trc_notrace_event(int event)
{
  checkevent(event);
  eventstable[event].flags|=FLAG_NOTRACE;
  return 0;
}

int trc_trace_event(int event)
{
  checkevent(event);
  eventstable[event].flags&=~FLAG_NOTRACE;
  return 0;
}

int trc_notrace_class(int class)
{
  int i;
  checkclass(class);
  for (i=classtable[class];i<classtable[class+1];i++)
    eventstable[i].flags|=FLAG_NOTRACE;
  return 0;
}

int trc_trace_class(int class)
{
  int i;
  checkclass(class);
  for (i=classtable[class];i<classtable[class+1];i++)
    eventstable[i].flags&=~FLAG_NOTRACE;
  return 0;
}


/* -- */

int TRC_init_phase1_standard(void)
{
  int qf,qc;
  int res;
 
  res=TRC_init_phase1(NULL);
  if (res) return res;

  res=trc_register_circular_queue();
  if (res) return res;
  res=trc_register_fixed_queue();
  if (res) return res;

  qc=trc_create_queue(TRC_CIRCULAR_QUEUE,NULL);
  qf=trc_create_queue(TRC_FIXED_QUEUE,NULL);
  if (qc==-1||qf==-1) return -97;

  res=trc_trace_class(TRC_CLASS_SYSTEM);
  if (res) return res;
  res=trc_assign_class_to_queue(TRC_CLASS_SYSTEM,qc);
  if (res) return res;

  return 0;
}

int TRC_init_phase2_standard(void)
{
  return TRC_init_phase2();
}