Subversion Repositories openrisc_me

/*
 ============================================================================
 _SERVTGT
 $Id: _servtgt.c,v 1.2 2001-09-27 12:02:01 chris Exp $
 ============================================================================
*/
 
 
#include <string.h>		
#include <rtems.h>
#include <rtems/error.h>
 
#include <rdbg/rdbg.h>
#include <rdbg/rdbg_f.h>
#include <rdbg/servrpc.h>	
#include <errno.h>
#include <sys/socket.h>		
#include <assert.h>
#include <rtems/score/cpu.h>
 
#ifdef DDEBUG
#define Ptrace	TgtDbgPtrace
#else
#define Ptrace	TgtRealPtrace
#endif
 
extern int errno;
 
rtems_id eventTaskId;
rtems_id serializeSemId;
rtems_id wakeupEventSemId;
 
CPU_Exception_frame Idle_frame;
 
/* -----------------------------------------------------------------
   TgtRealPtrace - lowest level ptrace() wrapper
   ----------------------------------------------------------------- */
 
    int
TgtRealPtrace(int req, PID aid, char* addr, int d, void* addr2)
{
    return ptrace(req, aid, addr, d, addr2);
}
 
 
 
/* -----------------------------------------------------------------------
   TgtChange() is called when the system stops.
   It informs the generic layers must be informed of
   that fact. 
   ----------------------------------------------------------------------- */
 
    static int
TgtChange (PID pid, CPU_Exception_frame* ctx, int status)
{
 
    if (TgtHandleChildChange (pid, &status, NULL, ctx)) {
      TgtNotifyWaitChange (pid, status, -1);
    }
 
    return 0;
}
 
/* -----------------------------------------------------------------------
   eventTask
   ----------------------------------------------------------------------- */
 
rtems_task eventTask( rtems_task_argument pid)
{
  Exception_context *ctx;
 
  DPRINTF (("event task: pid %d\n", pid));
 
 
  /*
   * we spend all our time waiting for a semaphore.
   * If wait change, we send info
   */
 
  for (;;){	
    DPRINTF (("Event Task: wait event\n"));
    rtems_semaphore_obtain(wakeupEventSemId, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    DPRINTF (("Event Task: wake up !!!!!!!!!!!!!\n"));
 
    errno = 0;
    ctx = GetExceptCtx(currentTargetThread);
 
    CheckForSingleStep(ctx->ctx);
 
    TgtChange(pid, ctx->ctx,STS_MAKESIG(ExcepToSig(ctx)));
 
  }
}
 
/* -------------------------------------------------------------------
   MyThreadIdle -
 
   This task is used to initiate the exception mechanism:
   It calls the enterDebug function with justSaveContext=1
   only to push a first valid context in the list
   ---------------------------------------------------------------------*/
 
rtems_task MyThreadIdle(rtems_task_argument argument)
{
  enterRdbg();
  rtems_task_delete( RTEMS_SELF );
}
 
/* -----------------------------------------------------------------------
   TgtAttach - attach to a process that is running without control.
 
   Notes:
      - this function performs a ptrace ATTACH equivalent (attaching to a
	process that we do not control now).
   ----------------------------------------------------------------------- */
 
Boolean TgtAttach(
  int		conn_idx,	/* client that is requesting */
  PID		pid)		/* process to attach to */
{
  rtems_name task_name;
  rtems_status_code status;
  rtems_id debugId;
 
  errno = 0;
 
  DPRINTF (("TgtAttach pid=%d\n",pid));
 
  Ptrace(RPT_ATTACH, pid, NULL, 0, NULL);
  if (errno)
    return(False);		/* failed */
 
  TgtCreateNew(pid, conn_idx, 0, NULL, False);
 
 
  connect_rdbg_exception();
 
  /*
   * Create the attach debuger task
   */
  task_name = rtems_build_name( 'E', 'v', 'n', 't' );
  if ((status = rtems_task_create( task_name, 10, 24576,
				   RTEMS_INTERRUPT_LEVEL(0),
				   RTEMS_DEFAULT_ATTRIBUTES | RTEMS_SYSTEM_TASK,
				   &eventTaskId ))
      != RTEMS_SUCCESSFUL){
    printf("status = %d\n",status);
    rtems_panic ("Can't create task.\n");
  }
 
  status = rtems_task_start(eventTaskId, eventTask, pid);
 
  status = rtems_semaphore_create (rtems_build_name('D', 'B', 'G', 's'),
				   1,
				   RTEMS_FIFO |
				   RTEMS_COUNTING_SEMAPHORE |
				   RTEMS_NO_INHERIT_PRIORITY |
				   RTEMS_NO_PRIORITY_CEILING |
				   RTEMS_LOCAL,
				   0,
				   &serializeSemId);
  if (status != RTEMS_SUCCESSFUL)
    rtems_panic ("Can't create serialize semaphore: `%s'\n",rtems_status_text(status));
 
  status = rtems_semaphore_create (rtems_build_name('D', 'B', 'G', 'w'),
				   0,
				   RTEMS_FIFO |
				   RTEMS_COUNTING_SEMAPHORE |
				   RTEMS_NO_INHERIT_PRIORITY |
				   RTEMS_NO_PRIORITY_CEILING |
				   RTEMS_LOCAL,
				   0,
				   &wakeupEventSemId);
  if (status != RTEMS_SUCCESSFUL)
    rtems_panic ("Can't create wakeup semaphore: `%s'\n",rtems_status_text(status));
 
  /*
   * Create the MyThreadIdle task to init Exception mechanism 
   */
  task_name = rtems_build_name( 'R', 'i', 'n', 'i' );
  if ((status = rtems_task_create( task_name, 10, 24576,
				   RTEMS_INTERRUPT_LEVEL(0),
				   RTEMS_DEFAULT_ATTRIBUTES,
				   &debugId ))
      != RTEMS_SUCCESSFUL){
    printf("status = %d\n",status);
    rtems_panic ("Can't create task.\n");
  }
 
  status = rtems_task_start(debugId, MyThreadIdle, pid);
 
  return(True);
}
 
/* -----------------------------------------------------------------------
   TgtPtrace - handle ptrace requests for server.
   ----------------------------------------------------------------------- */
 
int TgtPtrace(		
  int		req,
  PID		pid,
  char		*addr,
  int		data,
  void		*addr2)
{
  if ((req == RPT_SINGLESTEP || req == RPT_CONT)
  &&  addr2)			/* clear then step */
  {				/* addr2 is the old value */
    int		ret;
 
    errno = 0;
    TgtBreakRestoreOrig (pid, addr, addr2);
    ret = Ptrace(RPT_SINGLESTEP, pid, addr, data, NULL); /* step over */
    if (ret)		/* error, cannot single-step */
    {
      int pid_idx = FindPidEntry (pid);
      TgtBreakCancelStep (&pid_list [pid_idx]);
    }
    return(ret);		/* failed or done */
  }
  else
    return(Ptrace(req, pid, addr, data, addr2)); /* normal call */
}
 
/* -----------------------------------------------------------------
   TgtGetThreadName - get thread name
   --------------------------------------------------------------- */
 
int TgtGetThreadName (
   PID_LIST     *plst,		/* Process entry */
   unsigned     Id,             /* Thread ID */
   char    	*ThrName)		/* Thread name */
{
    int index;
    unsigned name;
 
    if ( Id <_Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id &&
	 Id >_Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id) {
 
      index = Id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
      name = *(unsigned*)(_Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index]->name);
      ThrName[0] = (char)((name >> 24) & 0xFF );
      ThrName[1] = (char)((name >> 16) & 0xFF );
      ThrName[2] = (char)((name >> 8)  & 0xFF );
      ThrName[3] = (char)( name        & 0xFF );
      ThrName[4] = 0x0;
      return 0;
    }
 
    if ( Id <_Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id &&
	 Id >_Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id) {
 
      index = Id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
      name = *(unsigned*)(_Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index]->name);
      ThrName[0] = (char)((name >> 24) & 0xFF );
      ThrName[1] = (char)((name >> 16) & 0xFF );
      ThrName[2] = (char)((name >> 8)  & 0xFF );
      ThrName[3] = (char)( name        & 0xFF );
      ThrName[4] = 0x0;
      return 0;
    }
 
 
    return -1;
 
}
 
/* -----------------------------------------------------------------
   TgtThreadList - return all the threads in the system
   ----------------------------------------------------------------- */
 
    int
TgtThreadList (
  PID_LIST* plst,		/* Process entry */
  unsigned* threads,		/* Output buffer */
  unsigned size)		/* Output buffer size */
{
    int curr = 0;
    Objects_Id  id;     
    unsigned index;
 
    id = _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
 
    while (id < _Objects_Information_table[OBJECTS_RTEMS_TASKS]->maximum_id){
      index = id - _Objects_Information_table[OBJECTS_RTEMS_TASKS]->minimum_id;
      if ( _Objects_Information_table[OBJECTS_RTEMS_TASKS]->local_table[1+index] != NULL){
      threads[curr] = (unsigned) id;
      curr++;
      }
      id ++;
    }
 
    id = _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
 
    while (id < _Objects_Information_table[OBJECTS_POSIX_THREADS]->maximum_id){
      index = id - _Objects_Information_table[OBJECTS_POSIX_THREADS]->minimum_id;
      if ( _Objects_Information_table[OBJECTS_POSIX_THREADS]->local_table[1+index] != NULL){
      threads[curr] = (unsigned) id;
      curr++;
      }
      id ++;
    }
 
    return curr;
}