mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-11 05:40:06 +00:00
04277e02d7
* All files with FSF copyright notices: Update copyright dates using scripts/update-copyrights. * locale/programs/charmap-kw.h: Regenerated. * locale/programs/locfile-kw.h: Likewise.
168 lines
5.2 KiB
C
168 lines
5.2 KiB
C
/* Copyright (C) 2004-2019 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by David Mosberger-Tang <davidm@hpl.hp.com>.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library 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
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* The public __longjmp() implementation is limited to jumping within
|
|
the same stack. That is, in general it is not possible to use this
|
|
__longjmp() implementation to cross from one stack to another.
|
|
In contrast, the __sigstack_longjmp() implemented here allows
|
|
crossing from the alternate signal stack to the normal stack
|
|
as a special case. */
|
|
|
|
#include <assert.h>
|
|
#include <setjmp.h>
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <sysdep.h>
|
|
#include <sys/rse.h>
|
|
|
|
#define JB_SP 0
|
|
#define JB_BSP 17
|
|
|
|
struct rbs_flush_values
|
|
{
|
|
unsigned long bsp;
|
|
unsigned long rsc;
|
|
unsigned long rnat;
|
|
};
|
|
|
|
extern struct rbs_flush_values __ia64_flush_rbs (void);
|
|
extern 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)
|
|
{
|
|
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;
|
|
}
|
|
else
|
|
{
|
|
/* read source value, including NaT bit: */
|
|
src_slot = ia64_rse_slot_num (src);
|
|
if (src_slot == 63)
|
|
{
|
|
/* skip src RNaT slot */
|
|
++src;
|
|
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;
|
|
else
|
|
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);
|
|
else
|
|
dst_rnat &= ~(1UL << dst_slot);
|
|
}
|
|
}
|
|
dst_slot = ia64_rse_slot_num (dst);
|
|
if (dst_slot > 0)
|
|
*ia64_rse_rnat_addr (dst) = dst_rnat;
|
|
}
|
|
|
|
void
|
|
__sigstack_longjmp (__jmp_buf buf, int val)
|
|
{
|
|
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];
|
|
|
|
INTERNAL_SYSCALL_DECL (err);
|
|
(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);
|
|
else
|
|
{
|
|
/* 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;
|
|
else
|
|
rnat = c.rnat;
|
|
__ia64_longjmp (buf, val, rnat, c.rsc);
|
|
}
|