But. Suppose we have to attached engines. The first engine gets
UTRACE_SIGNAL_REPORT and returns UTRACE_STOP | UTRACE_SIGNAL_IGN.
Right, that's what it would do. I see, you're saying that the
report.result passed on to the next engine would appear like it had
been a real signal that the previous engine decided to ignore (or
whose sa_handler==SIG_IGN or default action was to ignore). Hmm.
Well, it's also distinguished by having orig_ka==NULL in the callback.
Any real signal has a non-null orig_ka argument.
or yes, it returns UTRACE_SIGNAL_DELIVER after gdb does signal XX.
Now. The second engine gets UTRACE_SIGNAL_DELIVER or UTRACE_SIGNAL_IGN,
not UTRACE_SIGNAL_REPORT.
At least in the UTRACE_SIGNAL_DELIVER case, that's really the true
thing for it to see. The previous engine decided to do a signal
delivery (as directed by return_ka), so the next engine needs to see
this to know what the prevailing state of play is now.
That is why ugdb_signal_report(UTRACE_SIGNAL_REPORT) tries to return
UTRACE_STOP | utrace_signal_action(action) to not change report-result
(passed to the next tracee) inside the reporting loop.
Well, it *can* do that. If UTRACE_SIGNAL_REPORT (or anything else
random) is the ultimate report.result from the whole callback loop, we
treat it just like UTRACE_SIGNAL_IGN.
The worst case is UTRACE_SIGNAL_HANDLER. Single-stepping should know
about this case. This means that any engine should always return
UTRACE_resume_action | UTRACE_SIGNAL_HANDLER.
I see. This is indeed the only way for any engine to know that it's
getting the UTRACE_SIGNAL_HANDLER specific notification rather than
some random fallout of someone else's UTRACE_REPORT request or whatnot.
Probably we can check orig_ka != NULL and treat orig_ka == NULL as
UTRACE_SIGNAL_REPORT. Hopefully this can't be confused with
UTRACE_SIGNAL_HANDLER.
I'm not really sure what you mean here.
If -report_signal(orig_ka) was calles with orig_ka == NULL, then,
whatever utrace_signal_action(action) we see, originally it was
either UTRACE_SIGNAL_HANDLER or UTRACE_SIGNAL_REPORT but another engine
returned, say, UTRACE_SIGNAL_DELIVER/UTRACE_SIGNAL_IGN to deliver/stop.
Right. But this is in fact just the same for either
UTRACE_SIGNAL_REPORT or UTRACE_SIGNAL_HANDLER.
Not sure about UTRACE_SIGNAL_HOLD, but this is very unlikely race.
You probably don't want to use that, but I'm not entirely sure. ptrace
doesn't use it, and the signal interception model is pretty much the same.
Yes, agreed. But there is one corner case. Until we generalize
utrace_stop()-ptrace_notify_stop() hook, the tracee can be reported as
stopped to gdb, but before it actually stops it can recieve a signal.
I don't follow this. If we're stopping, then we don't receive
(dequeue) any other signal until we get resumed. That should be fine
from gdb's point of view. The next signal is just pending for later.
The signal that we just reported was a) in fact reported to gdb and
b) is still sitting in the siginfo_t on stack and the engine can
examine/modify that before letting the thread resume. (The kerneldoc
paragraph about @report_signal in utrace.h makes this guarantee.)
Thanks,
Roland
