Mail Archives: cygwin/2015/06/26/16:14:04
--kLdbqvpuLRxNeSq5
Content-Type: multipart/mixed; boundary="qxpYSgLynlcP4boX"
Content-Disposition: inline
--qxpYSgLynlcP4boX
Content-Type: text/plain; charset=utf-8
Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
Hi Ken,
On Jun 26 12:55, Ken Brown wrote:
> Hi Corinna,
>=20
> On 6/26/2015 11:36 AM, Corinna Vinschen wrote:
> >Thanks. Another question: How does emacs compute stack_bottom?
>=20
> Very near the beginning of main() it does the following:
>=20
> char stack_bottom_variable;
> [...]
> /* Record (approximately) where the stack begins. */
> stack_bottom =3D &stack_bottom_variable;
Thank you.
I created an STC with your code snippets and it now works for me
(attached for reference).
First problem was the return value of getrlimit(RLIMIT_STACK).
Second problem is emacs. The check for an offset of the offending
address in si_addr being less than 16K (STACK_DANGER_ZONE) is
non-portable, putting it mildly. This might work on 32 bit Cygwin (I
didn't test that), but the value is too low for 64 bit Cygwin. With
STACK_DANGER_ZONE =3D=3D 32K the handler works as desired on 64 bit Cygwin.
Part of the reason is probably the _cygtls area of 12K reserved on each
thread's stack, which moves the address of &stack_bottom_variable to a
pretty low value right from the start. Another the size of the guard
page area on the main thread (16K).
I had a brief email exchange with a collegue of mine. Ben allowed me to
quote him, so here are the important snippets of his replies:
- Rlimits are an old way of doing a job and they were to a certain
extent tied up in the pre-thread world of unix processes. rlimits
have never been fully implemented on linux with a way that reproduces
the unix way in the pre-thread era. rlimits have become a bit of a
historical legacy and are there for posix compliance and code
compatibility. The posix language was designed to be vague enough that
all implementations could be made to conform.
- Rather than making the system implementation conform to some
unspecified behavior, I think it might be a wise idea to fix emacs
instead. Looking at the code fragment you posted below(*), I=E2=80=99m not
entirely convinced that the code would operate as intended on modern
Linux or Unix. Given that, it may be better to make an implementation
which does something like the current behavior was intended to do or
better yet just remove it as a likely latent bug.
(*) Emacs' handle_sigsegv function.
Of course, for testing purposes this is still nice to have, so thank you
for this test, I really appreciate it.
As for getrlimit(RLIMIT_STACK), I changed that as outlined in my former
mail in git. On second thought, I also changed the values of
MINSIGSTKSZ and SIGSTKSZ. Instead of 2K and 8K, they are now defined
as 32K and 64K. The reason is that we then have enough space on the
alternate stack to install a _cygtls area, should the need arise.
I created new developer snapshots on https://cygwin.com/snapshots/
Please give them a try.
Remember to tweak STACK_DANGER_ZONE. You'll have to rebuild emacs
anyway due to the change to [MIN]SIGSTKSZ.
Thanks,
Corinna
--=20
Corinna Vinschen Please, send mails regarding Cygwin to
Cygwin Maintainer cygwin AT cygwin DOT com
Red Hat
--qxpYSgLynlcP4boX
Content-Type: text/plain; charset=utf-8
Content-Disposition: attachment; filename="sigalt.c"
#include <alloca.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>
#include <sys/time.h>
#include <sys/resource.h>
int stack_direction;
char *stack_bottom;
sigjmp_buf return_to_command_loop;
/* Attempt to recover from SIGSEGV caused by C stack overflow. */
static void
handle_sigsegv (int sig, siginfo_t *siginfo, void *arg)
{
struct rlimit rlim;
if (!getrlimit (RLIMIT_STACK, &rlim))
{
enum { STACK_DANGER_ZONE = 32 * 1024 };
char *beg, *end, *addr;
beg = stack_bottom;
end = stack_bottom + stack_direction * rlim.rlim_cur;
if (beg > end)
addr = beg, beg = end, end = addr;
addr = (char *) siginfo->si_addr;
/* If we're somewhere on stack and too close to
one of its boundaries, most likely this is it. */
if (beg < addr && addr < end
&& (addr - beg < STACK_DANGER_ZONE
|| end - addr < STACK_DANGER_ZONE))
siglongjmp (return_to_command_loop, 1);
}
/* Otherwise we can't do anything with this. */
abort ();
}
static int
init_sigsegv (void)
{
struct sigaction sa;
stack_t ss;
stack_direction = ((char *) &ss < stack_bottom) ? -1 : 1;
ss.ss_sp = malloc (SIGSTKSZ);
ss.ss_size = SIGSTKSZ;
ss.ss_flags = 0;
if (sigaltstack (&ss, NULL) < 0)
return 0;
sigfillset (&sa.sa_mask);
sa.sa_sigaction = handle_sigsegv;
sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
return sigaction (SIGSEGV, &sa, NULL) < 0 ? 0 : 1;
}
void foo ()
{
int buf[512];
foo ();
}
int
main ()
{
char stack_bottom_variable;
/* Record (approximately) where the stack begins. */
stack_bottom = &stack_bottom_variable;
init_sigsegv ();
if (!sigsetjmp (return_to_command_loop, 1))
{
printf ("command loop before crash\n");
foo ();
}
else
printf ("command loop after crash\n");
return 0;
}
--qxpYSgLynlcP4boX--
--kLdbqvpuLRxNeSq5
Content-Type: application/pgp-signature
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2
iQIcBAEBCAAGBQJVja7FAAoJEPU2Bp2uRE+gN3QP/2F31yL1mhvel/VhhSLUXrs9
RilJPCKzQpq4Zd6lIZSL1pHj0Isyo1beaGD/MFK1p2izgQxC9hAHIrQX6CqngEMT
gI/zrLEphuu60Cq19T6wf12B4oXO9BxRwCfjz1xhGkm9+993sWsfQ/DSqsJYqmqA
GE1gaqN1SDZkPDiAy8CLMo8VVzl1FJbI9j8ekqIjhAUBrb3e9HdyjisRLSUYyQVL
VtLrRPD8qKD7kwspahk4xWHcUly7B1gO8ExA3eUWVjiMfDZwHBRTP/E9bCF0xFEQ
Ali4u8MT02wpPlSkIHEBXlmtYwplsq9uRg6XEBhFNvybB8porhsDBP9b6sEoH+WU
kpoZvnanepzNN3Gtri7GQilKZLAY8gq4e307UaAhTE1nOfvsS1WCAi4KU1hQ4yDy
5KJNMain/m4d0sG24uJICaKbvf0faIyeNbnpC3yiNv1Zr4PuTl//Eqq4bencdCGn
dM8hoOc12b8lt4Rf3fJf1jxzGjv2OCV1mPV0NcMeFnzAUcasqq4/2odUYw8Uy3ks
9ZWunmIXhsvg5Q7PIPPo93E8vHqEbIpeZKgxpedjt+eM57opiNEj2wbSRjTXGTUo
vy/UkvNEIqNOVyjDDLVhUcKidKgk73gV0uCiV6+CJmU/uXj+OFZrKnZbrSDJ9HYe
l5I9iYdsUqyTmutacSuJ
=tfYg
-----END PGP SIGNATURE-----
--kLdbqvpuLRxNeSq5--
- Raw text -