URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [rtems/] [c/] [src/] [librdbg/] [src/] [servrpc.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 **********************************************************************
 *
 *  Component:  RDBG
 *  Module:     servrpc.c
 *
 *  Synopsis:   support routines for RPC dispatch for remote debug server.
 *              Main server dispatch routines from RPC to support remote debug.
 *
 * $Id: servrpc.c,v 1.2 2001-09-27 12:02:01 chris Exp $
 *
 **********************************************************************
 */
 
#include <string.h>
#include <sys/errno.h>
#include <rdbg/rdbg.h>
#include <rdbg/remdeb.h>
#include <rdbg/servrpc.h>
 
/************************************************************************/
 
/* -----------------------------------------------------------------------
   open_connex_2_svc - setup a new connection from a client.
 
   Notes:
      - this function creates a new connection to a client. It allocates
        an entry in the connection structure and fills in the information
        sent and implied by the message.
      - a client connection entry is needed for all further messages to work
        properly.
   ----------------------------------------------------------------------- */
 
open_out* RPCGENSRVNAME(open_connex_2_svc) (open_in *in, struct svc_req *rqstp)
{
  static open_out out;          /* output response. This could be heap local */
  int           idx;
  static int    one_time = 0;    /* we do one-time setup on back port */
 
  /* need to support in->debug_type, in->flags, and in->destination!!! */
 
  if (!one_time)
  {                             /* only setup one backport socket */
    /* now setup signals and the like for handling process changes */
    setErrno(0);
    TspInit(rqstp->rq_xprt->xp_sock); /* init transport system */
    if (getErrno())
    {                           /* failed in setup */
      out.port = (u_long)-1;
      out.fp = getErrno();              /* error causing to fail */
      return(&out);             /* fail */
    }
    one_time = True;            /* disable doing this again */
  }
 
  DPRINTF(("open_connex_2_svc: Opening connection from '%s'\n",
        in->user_name));
 
  /* now setup a validation of all other connections */
  for (idx = 0; idx < conn_list_cnt; idx++)
    if (conn_list[idx].in_use)
    {                           /* setup retry timer */
      DPRINTF(("open_connex_2_svc: Still have connection %d with port %d\n",
        idx, HL_W(*((UINT16*)&conn_list[idx].back_port.c[2]))));
    }
 
  idx = ConnCreate(rqstp, in);  /* setup the connection */
  out.port = idx;               /* connection number */
  if (idx == -1)
    out.fp = getErrno();                /* error causing to fail */
  else
    out.fp = TARGET_PROC_TYPE;
 
  out.server_vers = SERVER_VERS;
  return(&out);
}
 
/* -----------------------------------------------------------------------
   send_signal_2_svc - send a kill/signal to the specified process.
 
   Notes:
      - this function sends a signal to the process specified. This process
        does not have to be under debug nor attached by this server. The kill
        may be refused on other grounds though.
      - kill(pid, 0) can be used to validate the process still exists if
        needed.
   ----------------------------------------------------------------------- */
 
signal_out *RPCGENSRVNAME(send_signal_2_svc) (signal_in *in, struct svc_req *rqstp)
{
  static signal_out out;        /* return code from kill */
 
  /* we do not care if connected */
  setErrno(0);
  out.kill_return = 0;
  out.errNo = 0;
  TotalReboot = 1;
  return(&out);
}
 
/* -----------------------------------------------------------------------
   close_connex_2_svc - close a connection from a client.
   ----------------------------------------------------------------------- */
 
void *RPCGENSRVNAME(close_connex_2_svc) (close_in *in, struct svc_req *rqstp)
{
  int           conn_idx = TspConnGetIndex(rqstp);
 
  if (conn_idx != -1)           /* found it, clear out */
    ConnDelete(conn_idx, rqstp, in->control);
 
  return (void*) ""; /* need to return something */
}
 
/* -----------------------------------------------------------------------
   ptrace_2_svc - control process under debug.
   ----------------------------------------------------------------------- */
 
#define REG_COUNT \
    (sizeof (xdr_regs) / sizeof (int))
 
ptrace_out *RPCGENSRVNAME(ptrace_2_svc) (ptrace_in *in, struct svc_req *rqstp)
{
  int           conn_idx = rqstp ? TspConnGetIndex(rqstp) : -1;
  static ptrace_out out;        /* outut response (error or data) */
  void          *addr, *addr2;  /* used for actual ptrace call */
  unsigned int  data;
  int           req, pid, ret, pid_idx, idx;
  static union
  {                             /* local buffer for returned data */
    Objects_Id  t_list[UTHREAD_MAX]; /* thread_list return */
    char        t_name[THREADNAMEMAX]; /* thread name return */
  } local_buff;                 /* for return handling of strings and the like */
  PID_LIST      *plst = NULL;   /* current pid_list entry */
 
  DPRINTF (("ptrace_2_svc: entered (%s (%d), %d, XXXX, %d, XXXX)\n",
      PtraceName (in->addr.req), in->addr.req, in->pid,
      in->data));
 
  out.addr.ptrace_addr_data_out_u.addr = 0;
 
  /* validate the connection */
  if (conn_idx == -1  &&  rqstp != NULL)
  {                             /* no connection, error */
    DPRINTF(("ptrace_2_svc: msg from unknown debugger!\n"));
    out.result = -1;
    out.errNo = ECHILD;         /* closest error */
    out.addr.req = 0;            /* to avoid copies that should not occur */
    return(&out);
  }
    /* Consider that the last back-message is acknowledged */
  if (conn_idx >= 0  &&  conn_list[conn_idx].retry) {
    TspMessageReceive(conn_idx, in->pid);
  }
 
  req = in->addr.req;
  out.addr.req = req;           /* needed for RPC */
  pid = in->pid;
  addr = addr2 = NULL;
  data = in->data;
  setErrno(0);                   /* assume works */
  out.result = 0;                /* assume worked ok */
  out.errNo = 0;
 
  /* lookup process to make sure we have under control */
  pid_idx = FindPidEntry (in->pid);
  if (pid_idx >= 0)              /* found it */
  {
    plst = &pid_list[pid_idx];
    if (conn_idx < 0)
      conn_idx = plst->primary_conn;
  }
 
  /* now we handle the special case of ATTACH to a pid we already control */
  if (req == RPT_ATTACH)
  {                             /* look it up first */
    if (plst)
    {                           /* we have controlled , so return ok+show conn */
      ret = 2;                  /* normally secondary connection */
      if (! PIDMAP_TEST (conn_idx, pid_idx))
      {                         /* mark as an owner if not already */
        plst->owners++;
        PIDMAP_SET (conn_idx, pid_idx);         /* mask in */
      }
      else if (plst->primary_conn != NO_PRIMARY)
      {                         /* regrab makes primary */
            /* Only if not primary already */
        if (plst->primary_conn != conn_idx) {
            TspSendWaitChange(plst->primary_conn, BMSG_NOT_PRIM,
                        conn_idx, plst->pid, 0, False); /* tell old owner */
        }
        plst->primary_conn = NO_PRIMARY;
      }
 
      if (plst->primary_conn == NO_PRIMARY)
      {                         /* none now, so take over */
        plst->primary_conn = conn_idx; /* new primary */
        ret = 1;                /* primary */
      }
      out.result = ret;         /* primary or secondary owner */
      return(&out);
    }
    /* else attach process using target code */
    setErrno(ESRCH);            /* assume the worst */
    if (!TgtAttach(conn_idx, pid))
    {                           /* failed */
      out.errNo = getErrno();
      out.result = 0;
    }
    return(&out);
  }
  else if (req == RPT_DETACH)
  {                             /* see which kind of detach */
    if (data == PTRDET_UNOWN)
    {                           /* only want to disconnect from */
      TgtDetachCon(conn_idx, pid_idx, True); /* remove from control */
      return(&out);             /* done */
    }
  }
  else if (plst  &&  (req == RPT_GETNAME  ||  req == RPT_GETBREAK))
  {
    /* do nothing */
  }
 
  else if (plst  &&  req == RPT_CLRBREAK) {
     /* To be able to remove breakpoints from a "running" system */
    DPRINTF (("ptrace_2_svc: allowing RPT_CLRBREAK %d\n", data));
        /* do nothing */
  }
 
  else if (plst && plst->running)
  {                             /* error, process is running and not detach */
    out.result = -1;
    out.errNo = ETXTBSY;        /* closest error */
    DPRINTF (("ptrace_2_svc: failed, still running.\n"));
    return(&out);
  }
  if (plst == NULL) {
    out.result = -1;
    out.errNo = ESRCH;
    DPRINTF (("ptrace_2_svc: No such process.\n"));
    return (&out);
  }
 
  /* now make sure secondary owner is not trying to modify */
  if (!(in->flags & PTRFLG_NON_OWNER)) /* if not overriden */
    if (conn_idx != plst->primary_conn
    &&  ( (req >= RPT_POKETEXT && req <= RPT_SINGLESTEP)
          || (req >= RPT_SETREGS && req <= RPT_SETFPAREGS && (req & 1))
          || (req >= RPT_SYSCALL && req <= RPT_DUMPCORE)
          || (req >= RPT_SETTARGETTHREAD && req <= RPT_THREADRESUME)
          || (req >= RPT_SETTHREADNAME && req <= RPT_SETTHREADREGS)
          || (req >= RPT_STEPRANGE && req <= RPT_CLRBREAK)
          || (req == RPT_STOP)
          || (req >= RPT_PSETREGS && req <= RPT_PSETTHREADREGS)))
    {                           /* not owner */
      out.result = -1;
      out.errNo = EPERM;                /* cannot alter as not primary */
      DPRINTF (("ptrace_2_svc: refused, not owner, flags %d conn_idx %d primary_conn %d\n", in->flags, conn_idx,
        plst->primary_conn));
      return(&out);
    }
 
  addr = (void *)in->addr.ptrace_addr_data_in_u.address; /* default */
  /* now setup normal ptrace request by unpacking. May execute here. */
  switch (req)
  {                             /* handle unpacking or setup for real call */
    /* first the ones where addr points to input data */
    case RPT_SETREGS:
    case RPT_SETTHREADREGS:
      addr = (void *)&in->addr.ptrace_addr_data_in_u.regs; /* reg list */
      break;
 
    case RPT_PSETREGS:
    case RPT_PSETTHREADREGS:
      if (in->addr.ptrace_addr_data_in_u.pregs.pregs_len != REG_COUNT) {
        DPRINTF(("ptrace_2_svc: pid %d got %d expected %d\n", pid,
            in->addr.ptrace_addr_data_in_u.pregs.pregs_len, REG_COUNT));
        setErrno(EINVAL);
        break;
      }
      req = req == RPT_PSETREGS ? RPT_SETREGS : RPT_SETTHREADREGS;
      addr = (void *) in->addr.ptrace_addr_data_in_u.pregs.pregs_val;
      break;
 
    case RPT_SETTHREADNAME:
      addr = (void *)in->addr.ptrace_addr_data_in_u.name;
      break;
    case RPT_WRITETEXT:
    case RPT_WRITEDATA:
      if ((int) data < 0) {
        setErrno(EINVAL);
        break;
      }
      addr = (void *)in->addr.ptrace_addr_data_in_u.mem.addr; /* targ addr */
      addr2 = (void *)in->addr.ptrace_addr_data_in_u.mem.data; /* buff */
 
        /* Forbid writing over breakpoints */
      if (BreakOverwrite (plst, addr, data)) {
        setErrno(EBUSY);
      }
      break;
 
    case RPT_POKETEXT:
    case RPT_POKEDATA:
        /* Forbid writing over breakpoints */
      if (BreakOverwrite (plst, addr, sizeof (int))) {
        setErrno(EBUSY);
      }
      break;
 
    /* now ones where we handle locally */
    case RPT_GETTARGETTHREAD:
      out.result = plst->thread;
      req = 0;                   /* force exit */
      break;
 
    case RPT_PGETREGS:  /* return from our buffer */
      out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
      out.addr.ptrace_addr_data_out_u.pregs.pregs_val = (u_int*) &plst->regs;
      req = 0;                   /* force exit */
      break;
 
    case RPT_GETREGS:
      /* return directly from our buffer */
      /* this buffer is refreshed when changing target thread */
      out.addr.ptrace_addr_data_out_u.regs = plst->regs;
      req = 0;                   /* force exit */
      break;
 
    case RPT_SETBREAK:
      idx = BreakSet (plst, conn_idx, &in->addr.ptrace_addr_data_in_u.breakp);
      if (idx < 0) break;
      req = 0;                   /* force exit */
      out.result = idx;         /* return break index (>0) */
      break;
 
    case RPT_CLRBREAK:
      if (conn_list[conn_idx].flags & DEBUGGER_IS_GDB) {
          data = BreakGetIndex (plst, addr);
      }
      out.result = BreakClear (plst, conn_idx, data);
      /* if errored, errno will still be set */
      req = 0;
      break;
 
    case RPT_GETBREAK:
      /* data=handle, addr=in_buffer, returns next break. Data=0, returns cnt */
      out.result = BreakGet (plst, data, &out.addr.
        ptrace_addr_data_out_u.breakp);
      req = 0;                   /* handle locally */
      break;
 
    case RPT_GETNAME:           /* get the name of the process */
      if (!plst->name)
        out.addr.ptrace_addr_data_out_u.mem.dataNb = 0;
      else
      {
        int maxLen = sizeof out.addr.ptrace_addr_data_out_u.mem.data - 1;
        data = strlen(plst->name);
        if (data > maxLen)
          data = maxLen;
        out.addr.ptrace_addr_data_out_u.mem.dataNb = data+1;
        memcpy(out.addr.ptrace_addr_data_out_u.mem.data, plst->name, data+1);
        out.addr.ptrace_addr_data_out_u.mem.data [maxLen] = '\0';
      }
      req = 0;
      break;
 
    case RPT_CONTTO:
      if (BreakSetAt (plst, conn_idx, (u_long) addr, BRKT_STEPEMUL) < 0)
      {
        DPRINTF(("ptrace_2_svc: BreakSet failed at %x", addr));
        break;
      }
      req = RPT_CONT;
      /* data can contain a signal number, addr2 is unused */
      goto case_RPT_CONT;
 
    case RPT_STEPRANGE:
      /* convert to step */
      if (!data)
        data = 1;               /* should we give an error?? */
      BreakStepRange (plst, addr, data);
      if (getErrno()) break;
 
      req = RPT_SINGLESTEP;     /* do by stepping */
      addr = (void*) 1;         /* start from current PC */
      data = -2;                /* want non-atomic stepping */
      /* fall through to other exec cases */
 
    case RPT_CONT:
    case_RPT_CONT:
    case RPT_SINGLESTEP:
 
      if (BreakStepOff (plst, &addr2))
      {                         /* need clear then step off break */
            /* clear break, step, then do exec */
        if (addr == (void*) 1)
          addr = (void*) plst->regs.REG_PC;/* need for patch */
 
          /* data is always 0, so atomic single-step */
      } else if (req == RPT_SINGLESTEP) {
        data = -2;              /* want non-atomic stepping */
      }
      break;
 
    /* now ones where addr points to an output area */
    case RPT_PGETTHREADREGS:
      addr = (void*) out.addr.ptrace_addr_data_out_u.mem.data;
      if (sizeof out.addr.ptrace_addr_data_out_u.mem.data <
            REG_COUNT * sizeof(int)) {
        setErrno(EINVAL);
        break;
      }
      if (data == plst->thread) {
        out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
        out.addr.ptrace_addr_data_out_u.pregs.pregs_val = (u_int*) &plst->regs;
        req = 0;                 /* force exit */
        break;
      }
      req = RPT_GETTHREADREGS;
      break;
 
    case RPT_GETTHREADREGS:
      addr = (void*) &out.addr.ptrace_addr_data_out_u.regs;
      break;
    case RPT_GETTHREADNAME:
      out.addr.ptrace_addr_data_out_u.name = local_buff.t_name;
      addr = (void*) out.addr.ptrace_addr_data_out_u.name;
      break;
    case RPT_THREADLIST:
      out.addr.ptrace_addr_data_out_u.threads.threads =(ptThreadList) local_buff.t_list;
      addr = (void*) out.addr.ptrace_addr_data_out_u.threads.threads;
      break;
    case RPT_READTEXT:
    case RPT_READDATA:
      if ((int) data < 0) {
        setErrno(EINVAL);
        break;
      }
      addr = (void *)in->addr.ptrace_addr_data_in_u.address;
      addr2 = (void *)out.addr.ptrace_addr_data_out_u.mem.data;
      out.addr.ptrace_addr_data_out_u.mem.dataNb = data;
      break;
    case RPT_DETACH:
      /* Do not allow detaching if breakpoints still there */
      if (BreakGet (plst, 0, NULL))
      {                         /* some bkpts still set */
        setErrno(EINVAL);               /* cannot detach safely */
        break;
      }
      /* fall through */
    case RPT_KILL:
      /* in the event they are trying to detach or kill a terminated process,
         we just delete the entry.                                      */
      if (PROC_TERMINATED (plst))
      {
        TgtDelete(plst, -1, BMSG_KILLED);       /* just blow off */
        req = 0;         /* now exit */
      }
      break;
  }
 
  if (getErrno())
  {                             /* failed in code above */
    out.result = -1;
    out.errNo = getErrno();
    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
    return(&out);
  }
  else if (!req)
  {                             /* bail out now */
    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
    return(&out);
  }
 
  /* OK, make the call */
  out.result = TgtPtrace(req, pid, addr, data, addr2);
  out.errNo = getErrno();
 
  /* if no error, cleanup afterwards */
  if (getErrno())
  {
      /* Remove step-emul breakpoints if any */
    if (req == RPT_SINGLESTEP || req == RPT_CONT) {
      BreakClear (plst, -1, -1);
    }
    DPRINTF(("ptrace_2_svc: result %d errNo %d\n", out.result, out.errNo));
    return(&out);               /* return error */
  }
 
  switch (in->addr.req)
  {                             /* handle some special calls that affect state */
    case RPT_CONT:
    case RPT_STEPRANGE:
      /* change to running */
      if (in->addr.req == RPT_STEPRANGE)
        plst->last_start = LAST_RANGE; /* so range steps */
      else if (addr2)
        plst->last_start = LAST_STEPOFF; /* now continue after wait */
      else
          plst->last_start = LAST_CONT;
      plst->running = 1;        /* mark as running */
      if (!rqstp) /* Called internally to restart bkpt, no msg to anybody */
        break;
      TgtNotifyAll(pid_idx, BMSG_WAIT, 0, 0, (in->flags & PTRFLG_NON_OWNER)
                        ? -1 : conn_idx, True);
      break;
    case RPT_SINGLESTEP:
      /* mark as step */
      plst->last_start = LAST_STEP; /* so we know how started */
      plst->running = 1;        /* mark as running (wait should catch fast) */
      break;
    case RPT_DETACH:            /* mark as disconnected */
    case RPT_KILL:              /* mark as killed */
      if (in->flags & PTRFLG_FREE) /* notify and delete entry */
        TgtDelete(plst, -1, (in->addr.req==RPT_KILL) ? BMSG_KILLED : BMSG_DETACH);
      else
      {                         /* notify and mark */
        plst->last_start = (in->addr.req==RPT_KILL) ?
                LAST_KILLED : LAST_DETACHED;
        plst->state = -1;
        plst->running = False;
        TgtNotifyAll(pid_idx, (in->addr.req==RPT_KILL) ?
                BMSG_KILLED : BMSG_DETACH, 0, 0, -1, True);
      }
      break;
    case RPT_SETTHREADREGS:
    case RPT_PSETTHREADREGS:
        if (data != plst->thread)
          break;
        DPRINTF(("ptrace_2_svc: pid %d target thread regs changed!\n", pid));
 
    case RPT_SETREGS:
    case RPT_PSETREGS:
      /* change our buffer as well */
      if (plst->regs.REG_PC != ((xdr_regs*)addr)->REG_PC)
        BreakPcChanged (plst);
      plst->regs = *(xdr_regs*) addr; /* copy in */
      break;
 
    /* case RPT_PGETREGS has been handled locally above */
    case RPT_PGETTHREADREGS:
        /* We need to update pointer so that XDR works on return */
      out.addr.ptrace_addr_data_out_u.pregs.pregs_len = REG_COUNT;
      out.addr.ptrace_addr_data_out_u.pregs.pregs_val =
          (void*) out.addr.ptrace_addr_data_out_u.mem.data;
      break;
 
    case RPT_PEEKTEXT:
    case RPT_PEEKDATA:
    case RPT_READDATA:
    case RPT_READTEXT:
      if (req < RPT_READDATA)
      {                         /* peek */
        /* addr is start */
        data = sizeof(int);
        addr2 = &out.result;    /* data buffer */
        /* Like read: addr is start, data is length, addr2 is buffer */
      }
      BreakHide (plst, addr, data, addr2);
      break;
 
    case RPT_SETTARGETTHREAD:
      DPRINTF(("ptrace_2_svc: pid %d new target thread %d\n", pid, data));
      TgtPtrace (RPT_GETREGS, pid, (char*) &plst->regs, 0, NULL);
      plst->thread = data;
      if (plst->break_list) {   /* Forget we had to step off breakpoint */
        BASE_BREAK* base = (BASE_BREAK*) plst->break_list;
        DPRINTF(("ptrace_2_svc: clr_step %d last_break %d\n", base->clr_step,
                base->last_break));
        base->clr_step = 0;      /* Not stopped on break */
        base->last_break = 0;
      }
      break;
 
    case RPT_THREADLIST:
      out.addr.ptrace_addr_data_out_u.threads.nbThread = out.result;
      break;
 
    default:
      break;
  }                             /* end switch */
  DPRINTF(("ptrace_2_svc 2: result %d errNo %d\n", out.result, out.errNo));
  return(&out);
}
 
/* -----------------------------------------------------------------------
   wait_info_2_svc - non-blocking wait request to check status.
   ----------------------------------------------------------------------- */
 
wait_out *RPCGENSRVNAME(wait_info_2_svc) (in, rqstp)
     wait_in *in;
     struct svc_req *rqstp;     /* server info */
{
  int           conn_idx = TspConnGetIndex(rqstp);
  static wait_out out;          /* output of pid and status */
  int           idx;
  PID_LIST      *plst;
 
  memset(&out, 0, sizeof(out));  /* zero for safety */
  out.reason = STOP_ERROR;      /* assume the worst */
 
  if (conn_idx == -1)
  {                             /* no connection, error */
    DPRINTF(("wait_info_2_svc: msg from unknown debugger!\n"));
    out.wait_return = -1;
    out.errNo = ECHILD;         /* closest error */
    return(&out);
  }
  else
  {                             /* see if confirming message received */
    if (conn_list[conn_idx].retry)
      TspMessageReceive(conn_idx, in->pid);
  }
 
  if (!in->pid)
  {                             /* warm test verify only */
    /* this call (pid==0) is made to confirm that that connection is still
        active.         */
    /* we let it fall through as an error since any use other than connection
        reset would be an error (there is no pid0).                     */
  }
  else
  {                             /* normal request */
    idx = FindPidEntry (in->pid);
    if (idx >= 0)
    {                           /* found process they requested on */
      plst = &pid_list[idx];
      out.wait_return = plst->running ? 0 : in->pid;
      /* return: 0 is running, pid is stopped/term */
      out.errNo = 0;
      out.status = plst->state; /* last stopped reason if stopped */
      out.thread = plst->thread;/* current thread (or -1 if none) from stop */
      if (!out.wait_return)
        out.reason = STOP_NONE; /* running, no action */
      else if (STS_SIGNALLED (out.status))
      {                 /* stopped on signal */
        out.handle = STS_GETSIG (out.status); /* signal number */
        if (out.handle == SIGTRAP)
          if (plst->is_step)
          {                     /* single step with hitting a break */
            out.reason = STOP_STEP;
            out.handle = 0;      /* no information */
          }
          else
          {                     /* stopped on break */
            out.reason = STOP_BREAK;
            if (plst->break_list)
              out.handle = ((BASE_BREAK*)plst->break_list)->last_break;
            else
              out.handle = 0;    /* no break */
          }
        else
          out.reason = STOP_SIGNAL;
        out.PC = plst->regs.REG_PC; /* copy standard regs */
        out.SP = plst->regs.REG_SP;
        out.FP = plst->regs.REG_FP;
      }
      else
      {                         /* terminated, so lower use count */
        if (plst->last_start == LAST_KILLED)
          out.reason = STOP_KILLED;
        else if (plst->last_start == LAST_DETACHED)
          out.reason = STOP_DETACHED;
        else if (plst->last_start == LAST_START)
        {                       /* failed in exec */
          out.reason = STOP_SPAWN_FAILED;
          out.handle = STS_GETCODE (out.status); /* errno reason */
        }
        else if (STS_TERMONSIG (out.status))
        {                       /* terminated on signal */
          out.reason = STOP_TERM_SIG;
          /* mask off the core-dumped bit 7 */
          out.handle = (int)(unsigned)(u_char) STS_TERMGETSIG (out.status);
        }
        else
        {                       /* exit(2)ed */
          out.reason = STOP_TERM_EXIT;
          out.handle = STS_GETCODE (out.status); /* code */
        }
      }
      DPRINTF(("wait_info_2_svc: pid %d return %d status %x errNo %d"
        " reason %d handle %d pc %x sp %x fp %x thread %d\n",
        in->pid, out.wait_return, out.status, out.errNo, out.reason,
        out.handle, out.PC, out.SP, out.FP, out.thread));
      return(&out);
    }
  }
  /* if not found in list, we return error: no such process */
  out.wait_return = -1;
  out.errNo = ESRCH;            /* no process */
  out.status = 0;
  return(&out);
}
 
/* -----------------------------------------------------------------------
   get_signal_names_2_svc - return names for signals
   ----------------------------------------------------------------------- */
 
static one_signal SignalNames[] = {
    {SIGILL,    "SIGILL/EVT_ILL"},
    {SIGTRAP,   "SIGTRAP/EVT_BKPT"},
    {SIGFPE,    "SIGFPE/EVT_FPE"},
    {SIGKILL,   "SIGKILL/EVT_AKILL"},
    {SIGSEGV,   "SIGSEGV/EVT_SEGV"},
    {17,        "SIGSTOP"},
    {23,        "SIGSTOP"}
};
 
get_signal_names_out* RPCGENSRVNAME(get_signal_names_2_svc) (in, rqstp)
     void* in;
     struct svc_req *rqstp;     /* server info */
{
  static get_signal_names_out out;
 
  out.signals.all_signals_len = sizeof SignalNames / sizeof SignalNames[0];
  out.signals.all_signals_val = SignalNames;
 
  return(&out);
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [rtems/] [c/] [src/] [librdbg/] [src/] [servrpc.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	158	chris	`/*`
2			`**********************************************************************`
3			`*`
4			`* Component: RDBG`
5			`* Module: servrpc.c`
6			`*`
7			`* Synopsis: support routines for RPC dispatch for remote debug server.`
8			`* Main server dispatch routines from RPC to support remote debug.`
9			`*`
10	208	chris	`* $Id: servrpc.c,v 1.2 2001-09-27 12:02:01 chris Exp $`
11	158	chris	`*`
12			`**********************************************************************`
13			`*/`
14
15			`#include <string.h>`
16			`#include <sys/errno.h>`
17			`#include <rdbg/rdbg.h>`
18			`#include <rdbg/remdeb.h>`
19			`#include <rdbg/servrpc.h>`
20
21			`/************************************************************************/`
22
23			`/* -----------------------------------------------------------------------`
24			`open_connex_2_svc - setup a new connection from a client.`
25
26			`Notes:`
27			`- this function creates a new connection to a client. It allocates`
28			`an entry in the connection structure and fills in the information`
29			`sent and implied by the message.`
30			`- a client connection entry is needed for all further messages to work`
31			`properly.`
32			`----------------------------------------------------------------------- */`
33
34			`open_out* RPCGENSRVNAME(open_connex_2_svc) (open_in in, struct svc_req rqstp)`
35			`{`
36			`static open_out out; /* output response. This could be heap local */`
37			`int idx;`
38			`static int one_time = 0; /* we do one-time setup on back port */`
39
40			`/* need to support in->debug_type, in->flags, and in->destination!!! */`