Back to index

glibc  2.9
Classes | Defines | Functions
__sigstack_longjmp.c File Reference
#include <assert.h>
#include <setjmp.h>
#include <signal.h>
#include <stdint.h>
#include <stdlib.h>
#include <sysdep.h>
#include <sys/rse.h>

Go to the source code of this file.


struct  rbs_flush_values


#define JB_SP   0
#define JB_BSP   17


struct rbs_flush_values __ia64_flush_rbs (void)
void __ia64_longjmp (__jmp_buf buf, int val, long rnat, long rsc) __attribute__((__noreturn__))
static void copy_rbs (unsigned long *dst, unsigned long *dst_end, unsigned long dst_rnat, unsigned long *src, unsigned long *src_end, unsigned long current_rnat)
void __sigstack_longjmp (__jmp_buf buf, int val)

Class Documentation

struct rbs_flush_values

Definition at line 39 of file __sigstack_longjmp.c.

Class Members
unsigned long bsp
unsigned long rnat
unsigned long rsc

Define Documentation

#define JB_BSP   17

Definition at line 37 of file __sigstack_longjmp.c.

#define JB_SP   0

Definition at line 36 of file __sigstack_longjmp.c.

Function Documentation

struct rbs_flush_values __ia64_flush_rbs ( void  ) [read]

Here is the caller graph for this function:

void __ia64_longjmp ( __jmp_buf  buf,
int  val,
long  rnat,
long  rsc 

Here is the caller graph for this function:

void __sigstack_longjmp ( __jmp_buf  buf,
int  val 

Definition at line 102 of file __sigstack_longjmp.c.

  unsigned long *rbs_base, *bsp, *bspstore, *jb_bsp, jb_sp, ss_sp;
  unsigned long ndirty, rnat, load_rnat, *jb_rnat_addr;
  struct sigcontext *sc;
  stack_t stk;
  struct rbs_flush_values c;

  /* put RSE into enforced-lazy mode and return current bsp/rsc/rnat: */
  c = __ia64_flush_rbs ();

  jb_sp  = ((unsigned long *)  buf)[JB_SP];
  jb_bsp = ((unsigned long **) buf)[JB_BSP];

  (void) INTERNAL_SYSCALL (sigaltstack, err, 2, NULL, &stk);

  ss_sp = (unsigned long) stk.ss_sp;
  jb_rnat_addr = ia64_rse_rnat_addr (jb_bsp);

  if ((stk.ss_flags & SS_ONSTACK) == 0 || jb_sp - ss_sp < stk.ss_size)
    /* Normal non-stack-crossing longjmp; if the RNaT slot for the bsp
       saved in the jump-buffer is the same as the one for the current
       BSP, use the current AR.RNAT value, otherwise, load it from the
       jump-buffer's RNaT-slot.  */
    load_rnat = (ia64_rse_rnat_addr ((unsigned long *) c.bsp) != jb_rnat_addr);
      /* If we are on the alternate signal-stack and the jump-buffer
        lies outside the signal-stack, we may need to copy back the
        dirty partition which was torn off and saved on the
        signal-stack when the signal was delivered.

        Caveat: we assume that the top of the alternate signal-stack
               stores the sigcontext structure of the signal that
               caused the switch to the signal-stack.    This should
               be a fairly safe assumption but the kernel _could_
               do things differently.. */
      sc = ((struct sigcontext *) ((ss_sp + stk.ss_size) & -16) - 1);

      /* As a sanity-check, verify that the register-backing-store base
        of the alternate signal-stack is where we expect it.  */
      rbs_base = (unsigned long *)
       ((ss_sp + sizeof (long) - 1) & -sizeof (long));

      assert ((unsigned long) rbs_base == sc->sc_rbs_base);

      ndirty = ia64_rse_num_regs (rbs_base, rbs_base + (sc->sc_loadrs >> 19));
      bsp = (unsigned long *) sc->sc_ar_bsp;
      bspstore = ia64_rse_skip_regs (bsp, -ndirty);

      if (bspstore < jb_bsp)
       /* AR.BSPSTORE at the time of the signal was below the value
          of AR.BSP saved in the jump-buffer => copy the missing
          portion from the torn off dirty partition which got saved
          on the alternate signal-stack.  */
       copy_rbs (bspstore, jb_bsp, sc->sc_ar_rnat,
                rbs_base, (unsigned long *) c.bsp, c.rnat);

      load_rnat = 1;
  if (load_rnat)
    rnat = *jb_rnat_addr;
    rnat = c.rnat;
  __ia64_longjmp (buf, val, rnat, c.rsc);

Here is the call graph for this function:

Here is the caller graph for this function:

static void copy_rbs ( unsigned long *  dst,
unsigned long *  dst_end,
unsigned long  dst_rnat,
unsigned long *  src,
unsigned long *  src_end,
unsigned long  current_rnat 
) [static]

Definition at line 51 of file __sigstack_longjmp.c.

  unsigned long dst_slot, src_rnat = 0, src_slot, *src_rnat_addr, nat_bit;
  int first_time = 1;

  while (dst < dst_end)
      dst_slot = ia64_rse_slot_num (dst);
      if (dst_slot == 63)
         *dst++ = dst_rnat;
         dst_rnat = 0;
         /* read source value, including NaT bit: */
         src_slot = ia64_rse_slot_num (src);
         if (src_slot == 63)
             /* skip src RNaT slot */
             src_slot = 0;
         if (first_time || src_slot == 0)
             first_time = 0;
             src_rnat_addr = ia64_rse_rnat_addr (src);
             if (src_rnat_addr < src_end)
              src_rnat = *src_rnat_addr;
              src_rnat = current_rnat;
         nat_bit = (src_rnat >> src_slot) & 1;

         assert (src < src_end);

         *dst++ = *src++;
         if (nat_bit)
           dst_rnat |=  (1UL << dst_slot);
           dst_rnat &= ~(1UL << dst_slot);
  dst_slot = ia64_rse_slot_num (dst);
  if (dst_slot > 0)
    *ia64_rse_rnat_addr (dst) = dst_rnat;

Here is the call graph for this function:

Here is the caller graph for this function: