path: root/c/src/librdbg/src/servbkpt.c

/*
 **********************************************************************
 *
 *  Component:	RDB servers
 *  Module:	servbkpt.c
 *
 *  Synopsis:	Management of breakpoints
 *
 * $Id$
 *
 **********************************************************************
 */

#include <sys/errno.h>
#include <assert.h>
#include <rdbg/rdbg.h>
#include <rdbg/servrpc.h>

/*----- Macros -----*/

#define BKPT0(plst)	((BASE_BREAK*)(plst)->break_list)
#define BKPT_INCR	5           /* how many bkpt slots alloc at a time */

#define BKPT_OVER(plst,idx,addr,size) \
    ((plst)->break_list[idx].ee_loc + BREAK_SIZE > (UINT32) (addr) \
    &&  (plst)->break_list[idx].ee_loc < (UINT32) (addr) + (size))

#define BKPT_SLOTS \
	(sizeof ((xdr_break*) 0)->thread_list / \
	 sizeof ((xdr_break*) 0)->thread_list [0])

    /*
     *  BreakAlloc - alloc a breakpoint entry.
     *
     *  This is a generic routine to insert an entry in the
     *  breakpoint list. It returns the number of entry just
     *  created. It returns -1 if failed.
     */

  static int
BreakAlloc (PID_LIST * plst, Boolean normal)
{
  int idx, len;
  xdr_break *blst;

  if (!normal) {                /* want 0 entry */
    if (plst->break_list) {
      return (0);               /* already there */
    }
    idx = 1;                    /* force alloc below */
  } else {
    for (idx = 1; idx < (int) plst->break_alloc; idx++) {
      if (plst->break_list[idx].type == BRKT_NONE) {
        /*
         * got a free one 
         */
        memset (&plst->break_list[idx], 0, sizeof (xdr_break));
        return (idx);           /* found one */
      }
    }
  }
  /*
   * idx is the requested entry 
   */

  if (idx >= (int) plst->break_alloc) { /* need more space */
    len = plst->break_alloc + BKPT_INCR;
    blst = (xdr_break *) Realloc (plst->break_list, len * sizeof (xdr_break));
    if (!blst) {
      return (-1);              /* failed, no space */
    }
    plst->break_alloc = len;    /* got more */
    plst->break_list = blst;

    /*
     * Clear new space 
     */
    memset (blst + len - BKPT_INCR, 0, BKPT_INCR * sizeof (xdr_break));
    idx = len - BKPT_INCR;      /* next available */
    if (!idx) {
      idx = 1;                  /* for normal cases */
    }
  }
  return (normal ? idx : 0);    /* return it */
}

    /*
     *  BreakSet - set a breakpoint in process
     *
     *  Returns the number or -1/errno.
     */

#ifdef DDEBUG
static const char *BreakTypes[] = {
  "NONE", "INSTR", "READ", "WRITE",
  "ACCESS", "EXEC", "OS_CALL", "OS_SWITCH",
  "STEPEMUL"
};

#define BN_MAX		(sizeof BreakTypes / sizeof BreakTypes[0])
#define BREAK_NAME(t)	((unsigned) (t) < BN_MAX ? BreakTypes[t] : "???")
#endif

  int
BreakSet (PID_LIST * plst, int conn_idx, xdr_break * bkpt)
{
  int pid = plst->pid;
  int type = bkpt->type;
  void *addr = (void *) bkpt->ee_loc;
  int idx;
  int data;

  DPRINTF (("BreakSet: type %d (%s) at 0x%x th %d ee_type %d len %d "
            "pass %d curr %d list %d %d %d %d\n", type, BREAK_NAME (type),
            (int) addr,
            bkpt->thread_spec, bkpt->ee_type, bkpt->length, bkpt->pass_count,
            bkpt->curr_pass, bkpt->thread_list[0], bkpt->thread_list[1],
            bkpt->thread_list[2], bkpt->thread_list[3]));

  idx = BreakAlloc (plst, True);    /* get entry */
  if (idx < 0) {                /* no memory */
    setErrno (ENOMEM);          /* set for safety */
    return -1;                  /* return the error */
  }

  data = TgtPtrace (RPT_PEEKTEXT, pid, addr, 0, NULL);  /* current */
  if (getErrno ()) {
    return -1;                  /* failed, return the error */
  }
  if (IS_BREAK (data)) {        /* There is already a break here */
    DPRINTF (("BreakSet: already have soft bkpt at %x\n", addr));
    if (type == BRKT_STEPEMUL) {
      ++BKPT0 (plst)->pad1;
      return 1;                 /* Any non-error value is OK */
    }
    setErrno (EBUSY);
    return -1;
  }

  TgtPtrace (RPT_POKETEXT, pid, addr, SET_BREAK (data), NULL);

  if (getErrno ()) {
    return -1;
  }

  plst->break_list[idx] = *bkpt;
  plst->break_list[idx].ee_type = data; /* saved data */

  /*
   * Inform other owners 
   */
  if (type != BRKT_STEPEMUL) {
    TgtNotifyAll (plst - pid_list, BMSG_BREAK, 1 /*added */ , idx,
                  conn_idx, False);
  } else {
    ++BKPT0 (plst)->pad1;
  }
  /*
   * Return the number 
   */
  setErrno (0);                 /* Just in case */
  return idx;
}

  int
BreakSetAt (PID_LIST * plst, int conn_idx, unsigned long addr,
            break_type type)
{
  xdr_break xb;

  memset (&xb, 0, sizeof xb);
  xb.type = type;
  xb.ee_loc = addr;
  return BreakSet (plst, conn_idx, &xb);
}

/*----- Find a breakpoint by address -----*/

  int
BreakGetIndex (PID_LIST * plst, void *addr)
{
  int idx;
  int data = -1;

  if (!plst->break_alloc) {
    setErrno (EFAULT);
    return -1;
  }
  for (idx = 1; idx < (int) plst->break_alloc; idx++) {
    if ((u_long) addr == plst->break_list[idx].ee_loc) {
      data = idx;
      break;
    }
  }
  return data;
}

/*----- Getting information about breakpoint -----*/

    /*
     *  If data > 0, fill "bkpt" with information about breakpoint
     *  and return the number of the next one.
     *  If data == 0, return the count of breakpoints.
     */

  int
BreakGet (const PID_LIST * plst, int data, xdr_break * bkpt)
{
  int idx;

  if (!data) {                  /* just count them */
    for (idx = 1; idx < (int) plst->break_alloc; idx++) {
      if (plst->break_list[idx].type != BRKT_NONE) {
        data++;
      }
    }
    return data;                /* count */
  }
  if ((unsigned) data >= plst->break_alloc) {
    /*
     * out of range 
     */
    setErrno (EFAULT);          /* closest match */
    return -1;
  }
  /*
   * get it and say which is next 
   */
  *bkpt = plst->break_list[data];
  for (idx = (int) data + 1; idx < (int) plst->break_alloc; idx++) {
    if (plst->break_list[idx].type != BRKT_NONE) {
      return idx;
    }
  }
  return 0;                     /* otherwise returns 0 for no more */
}

/*----- Clearing bkpts -----*/

    /*
     *  BreakClear - clear one (if data != 0) or all breakpoints
     *  (if data == 0). Return the number of bkpts cleared.
     *  If (data == -1), remove step-emulation breakpoints.
     */

  int
BreakClear (PID_LIST * plst, int conn_idx, int data)
{
  int pid_idx = plst - pid_list;
  int idx;
  int cleared = 0;
  int clearStepEmul = 0;
  int terminated = PROC_TERMINATED (plst);
  int stepEmulCount = 0;

  /*
   * break handle in data 
   */
  if (!plst->break_alloc) {     /* there are no breaks */
    DPRINTF (("BreakClear: no bkpts defined.\n"));
    setErrno (EFAULT);          /* closest match */
    return -1;                  /* return error */
  }
  if (!data) {                  /* clear all */
    idx = 1;
    data = plst->break_alloc - 1;

    /*
     * Inform other owners 
     */
    DPRINTF (("BreakClear: clearing all bkpts.\n"));
    TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr */ , 0, conn_idx, False);

  } else if (data == -1) {      /* clear all step-emul bkpts */
    DPRINTF (("BreakClear: removing %d step-emul bkpts\n",
              BKPT0 (plst)->pad1));

    stepEmulCount = BKPT0 (plst)->pad1;
    BKPT0 (plst)->pad1 = 0;

    clearStepEmul = 1;
    idx = 1;
    data = plst->break_alloc - 1;
  } else if ((unsigned) data >= plst->break_alloc
             || plst->break_list[data].type == BRKT_NONE) {

    /*
     * out of range 
     */
    DPRINTF (("BreakClear: invalid bkpt %d\n", data));
    setErrno (EFAULT);          /* closest match */
    return -1;                  /* return error */
  } else {
    idx = data;
    /*
     * Inform other owners 
     */
    TgtNotifyAll (pid_idx, BMSG_BREAK, 0 /*clr */ , idx, conn_idx, False);
    DPRINTF (("BreakClear: clearing bkpt %d\n", data));
  }

  for (; idx <= data; idx++) {  /* clear each one */
    int type = plst->break_list[idx].type;

    if (clearStepEmul && type != BRKT_STEPEMUL)
      continue;

    if (type == BRKT_INSTR || (clearStepEmul && type == BRKT_STEPEMUL)) {
      /*
       * just patch back 
       */
      char *addr = (char *) plst->break_list[idx].ee_loc;
      int val;

      if (BKPT0 (plst)->clr_step && BKPT0 (plst)->last_break == idx) {
        BKPT0 (plst)->clr_step = 0; /* not needed */
      }
      /*
       * Neighboring bytes can have breakpoints too... 
       */
      if (!terminated) {
        setErrno (0);
        val = TgtPtrace (RPT_PEEKTEXT, plst->pid, addr, 0, NULL);
        if (getErrno ()) {
          DPRINTF (("BreakClear: addr %x not readable!\n", addr));
          setErrno (0);         /* Forget bkpt */
        } else {
          assert (IS_BREAK (val));
          val = ORG_BREAK (val, (int) plst->break_list[idx].ee_type);
          TgtPtrace (RPT_POKETEXT, plst->pid, addr, val, NULL);
          if (getErrno ()) {
            DPRINTF (("BreakClear: addr %x not writable!\n", addr));
            setErrno (0);
          }
        }
      }
      ++cleared;                /* indicate cleared */
    }
    memset (&plst->break_list[idx], 0, sizeof (xdr_break));
  }
  assert (!clearStepEmul || cleared <= stepEmulCount);
  if (stepEmulCount && cleared == 0) {
    DPRINTF (("BreakClear: all STEPEMUL bkpts were shared\n"));
    return 1;
  }
  return cleared;
}

/*----- Hiding of breakpoints -----*/

    /*
     *  PatchBreak - patch original data from break into data buffer.
     *
     * Notes:
     *  - this routine patches the original data under a break into the data
     *    buffer from a ptrace read/peek. 
     */

  static void
PatchBreak (char *buff, UINT32 bstart, int bsize, UINT32 dstart, char *dvalue)
{
  int size = BREAK_SIZE;        /* default size */

  /*
   * Must deal with all sorts of unalignments
   * * (3 full overlaps, 3 unaligns)
   */
  if (bsize < BREAK_SIZE) {
    /*
     * case where buffer is smaller than data 
     */
    memcpy (buff, dvalue + (bstart - dstart), bsize);   /* copy over */
    return;
  }
  /*
   * buffer larger than data.
   * * we need to see where break fits in buffer and whether
   * * we have part of it off the end. We set bstart to be the
   * * buffer offset, dtart to be the break data offset, and
   * * size to be the amount to copy
   */
  if (dstart < bstart) {
    /*
     * break before actual buffer 
     */
    dstart = bstart - dstart;   /* offset in data */
    size -= dstart;             /* amount to copy */
    bstart = 0;                 /* offset in buffer */

  } else if (dstart + size > bstart + bsize) {
    /*
     * off end 
     */
    bstart += bsize;            /* end of buffer */
    size -= (dstart + size) - bstart;
    bstart = bsize - size;      /* come back into buffer enough */
    dstart = 0;                 /* start of data */

  } else {                      /* normal case */
    bstart = dstart - bstart;   /* offset in buffer */
    dstart = 0;
  }
  memcpy (buff + bstart, dvalue + dstart, size);
}

  void
BreakHide (const PID_LIST * plst, void *addr, int data, void *addr2)
{
  int idx;

  if (!plst->break_list)        /* no breaks exist, so skip this */
    return;

  /*
   * if breakpoints, replace 
   */

  for (idx = 1; idx < (int) plst->break_alloc; idx++) {
    int type = plst->break_list[idx].type;

    if (type != BRKT_INSTR && type != BRKT_STEPEMUL) {
      continue;
    }
    /*
     * break, see if overlaps 
     */
    if (BKPT_OVER (plst, idx, addr, data)) {

      /*
       * overlaps, patch in old value 
       */
      PatchBreak ((char *) addr2, (UINT32) addr, data,
                  plst->break_list[idx].ee_loc,
                  (char *) &plst->break_list[idx].ee_type);
    }
  }
}

/*----- Checking of breakpoint overwrites -----*/

    /*
     *  BreakOverwrite - check if memory write does not involve addresses
     *  having software breakpoints.
     */

  int
BreakOverwrite (const PID_LIST * plst, const char *addr, unsigned int size)
{
  int idx;

  if (!plst->break_list) {      /* No breaks exist */
    return 0;
  }

  for (idx = 1; idx < (int) plst->break_alloc; idx++) {
    int type = plst->break_list[idx].type;

    /*
     * Consider only breakpoints involving modified memory 
     */
    if (type != BRKT_INSTR && type != BRKT_STEPEMUL) {
      continue;
    }
    if (BKPT_OVER (plst, idx, addr, size)) {
      return -1;                /* overlaps */
    }
  }
  return 0;
}

/*----- Execution support -----*/

    /*
     *  BreakStepRange - Start stepping in a range.
     *
     *  Range is saved in breakpoint 0.
     */

  int
BreakStepRange (PID_LIST * plst, void *addr, int len)
{
  if (!plst->break_list) {
    /*
     * get list 
     */
    if (BreakAlloc (plst, False) == -1) {   /* must not be any memory */
      setErrno (ENOMEM);        /* to be safe */
      return -1;                /* fails */
    }
  }
  BKPT0 (plst)->range_start = (UINT32) addr;
  BKPT0 (plst)->range_end = (UINT32) addr + (len - 1);
  return 0;
}

    /*
     *  If the Program Counter is changed, consider that the
     *  current breakpoint has not been reached yet.
     */

  void
BreakPcChanged (PID_LIST * plst)
{
  if (plst->break_list) {
    /*
     * clear break stuff 
     */
    BKPT0 (plst)->clr_step = False;
  }
}

    /*
     *  BreakStepOff - prepare stepping off a breakpoint.
     */

  int
BreakStepOff (const PID_LIST * plst, void **paddr2)
{
  if (plst->break_list && BKPT0 (plst)->clr_step) {

    /*
     * need clear then step off break 
     */
    int last = BKPT0 (plst)->last_break;

    /*
     * clear break, step, then do exec 
     */

    *paddr2 = (void *) plst->break_list[last].ee_type;

    /*
     * Need to clr_step after TgtPtrace() when wait() returns 
     */
    return 1;
  }
  return 0;
}

    /*
     *  BreakSteppedOff - check if just stepped off a breakpoint
     *  and re-insert it into the code.
     */

  void
BreakSteppedOff (PID_LIST * plst)
{
  if (plst->break_list && BKPT0 (plst)->clr_step) {
    int idx = BKPT0 (plst)->last_break;
    int data;

    BKPT0 (plst)->clr_step = 0;

    /*
     *  Re-insert the breakpoint.
     */
    data = TgtPtrace (RPT_PEEKTEXT, plst->pid,
                      (char *) plst->break_list[idx].ee_loc, 0, NULL);
    assert (!IS_BREAK (data));
    TgtPtrace (RPT_POKETEXT, plst->pid,
               (char *) plst->break_list[idx].ee_loc,
               (int) SET_BREAK (data), NULL);
  }
}

    /*
     *  Returns whether a thread matches a breakpoint.
     */

  static int
BreakThreadMatch (xdr_break * xb, int thread)
{
  int slot;

  if (thread < 0)
    return 1;                   /* Break existence check only */

  if (xb->thread_list[0] == 0)
    return 1;                   /* Universal break */

  for (slot = 0; slot < BKPT_SLOTS; ++slot) {
    if (xb->thread_list[slot] == 0)
      return 0;                 /* End of list */
    if (xb->thread_list[slot] == thread)
      return 1;                 /* Match */
  }
  return 0;                     /* No matches found */
}

  int
BreakAdjustPC (PID_LIST * plst)
{
  /*
   *  BREAK_ADJ is the value by which the Program Counter
   *  has to be decremented after a software breakpoint
   *  is hit. It must be defined and can be zero.
   */
#if BREAK_ADJ
  /*
   * subtract back if necessary 
   */
  plst->regs.REG_PC -= BREAK_ADJ;   /* now write back */
  TgtPtrace (RPT_SETREGS, plst->pid, (char *) &plst->regs, 0, NULL);
#else
  (void) plst;
#endif
  return 0;
}

/*
 *  Identify the current breakpoint. The process just stopped.
 */

  int
BreakIdentify (PID_LIST * plst, int adjust, int thread)
{
  int foreignBkpt = 0;
  int bidx;

  for (bidx = 1; bidx < (int) plst->break_alloc; bidx++) {
    int type = plst->break_list[bidx].type;

    if ((type == BRKT_INSTR || type == BRKT_STEPEMUL)
        && plst->regs.REG_PC - BREAK_ADJ == plst->break_list[bidx].ee_loc) {    /* found matching */
      if (!BreakThreadMatch (&plst->break_list[bidx], thread)) {
        if (foreignBkpt == 0) {
          foreignBkpt = bidx;
        }
        continue;
      }
      if (adjust) {
        BreakAdjustPC (plst);
      }
      return bidx;
    }
  }
  if (foreignBkpt) {
    if (adjust) {
      BreakAdjustPC (plst);
    }
    return -foreignBkpt;
  }
  return 0;
}