EclLib should allow signals to make LISP code interruptable

[nbruin]

Presently, ecllib does not enable signals when executing ecl code. This makes LISP code uninterruptable:

sage: from sage.libs.ecl import *
sage: ecl_eval("(setf i 0)")
<ECL: 0>
sage: inf_loop=ecl_eval("(defun infinite() (loop (incf i)))")
sage: inf_loop() #DON'T DO THIS! (bye bye)

The signal handling in ECL should be studied a bit more to ensure that we are safely interacting with it.

When testing this patch, absolutely test it to sage-4.7.alpha1 or later since ECL was updated (#10766) and interrupts were completely rewritten (#9678).

Apply attachment: 10818_handlerswap.p4.patch

CC: @kiwifb @jdemeyer @kcrisman

Component: interfaces

Keywords: lisp ecl signal interrupt

Author: Nils Bruin, Jeroen Demeyer

Reviewer: Jean-Pierre Flori

Merged: sage-4.7.1.alpha0

Issue created by migration from https://trac.sagemath.org/ticket/10818

[nbruin]

rudimentary approach to signal handling in Ecllib

[nbruin]

comment:1

Attachment: signal-handling.patch.gz

With the patch, we can indeed interrupt ECL. We should try to do some more critical stuff and see if ECL can get in an inconsistent state due to this (I expect it can). Example session:

sage: from sage.libs.ecl import *
sage: ecl_eval("(setf i 0)")
<ECL: 0>
sage: inf_loop=ecl_eval("(defun infinite() (loop (incf i)))")
sage: inf_loop()
KeyboardInterrupt: 
sage: ecl_eval("i")
<ECL: 5337027>
sage: ecl_eval("(infinite)")
KeyboardInterrupt: 
sage: ecl_eval("i")
<ECL: 15518182>

[nbruin]

Try to swap signal handlers

[nbruin]

Attachment: handlerswap.patch.gz

Attachment: siginttest.c.gz

[nbruin]

comment:3

A simple approach would be to swap in ECL's signal handler for SIGINT upon entry of ECL code and swap back to the sage signal handler afterwards. The patch handlerswap.patch takes this approach. Unfortunately, it doesn't work. For some reason, the SIGINT handler we capture from ECL seems to just exit upon interrupt. This is not ECL's normal behaviour and the attached stand-alone program siginttest.c (also attached) shows that this approach works in principle.

I have no idea why the same approach leads to different results in a sage and cython context.

[nbruin]

comment:4

Apply handlerswap.p2.patch

Another take on swapping handlers and this one seems to work:

sage: from sage.interfaces.maxima_lib import maxima as max
sage: max('sum(1/x^2, x, 1, 100000)')
^C---------------------------------------------------------------------------
[...]
TypeError: ECL says: Console interrupt
sage: #we press Ctrl-C again
KeyboardInterrupt

For reference, ECL prefers to use sigaction (in fact, probably sage should be using sigaction as well. Certain race conditions with signal are avoidable with sigaction). In glibc, signal is implemented via sigaction anyway. sigaction has a richer interface, so signal cannot always properly report what sigaction has done. By using sigaction to record and swap the different SIGINT handlers, it seems to work.

Subtle race conditions still exist: the ECL handler is instated just before entering lisp code and setting up the "unwind-protect stack frame", so an interrupt that gets delivered in that window would cause unspecified behaviour. By running

while True: os.kill(,2)

it is easy to trigger such behaviour, but sage in its present state already cannot handle this.
Therefore, I think the present patch establishes acceptable "best effort" behaviour.

[nbruin]

Changed work issues from investigate ECL interrupt handling to none