+ FSHOW_SIGNAL((stderr,
+ "/returning from interrupt_handle_now(%d, info, context)\n",
+ signal));
+}
+
+/* This is called at the end of a critical section if the indications
+ * are that some signal was deferred during the section. Note that as
+ * far as C or the kernel is concerned we dealt with the signal
+ * already; we're just doing the Lisp-level processing now that we
+ * put off then */
+static void
+run_deferred_handler(struct interrupt_data *data, void *v_context)
+{
+ /* The pending_handler may enable interrupts and then another
+ * interrupt may hit, overwrite interrupt_data, so reset the
+ * pending handler before calling it. Trust the handler to finish
+ * with the siginfo before enabling interrupts. */
+ void (*pending_handler) (int, siginfo_t*, void*)=data->pending_handler;
+
+ data->pending_handler=0;
+ (*pending_handler)(data->pending_signal,&(data->pending_info), v_context);
+}
+
+#ifndef LISP_FEATURE_WIN32
+boolean
+maybe_defer_handler(void *handler, struct interrupt_data *data,
+ int signal, siginfo_t *info, os_context_t *context)
+{
+ struct thread *thread=arch_os_get_current_thread();
+
+ check_blockables_blocked_or_lose();
+
+ if (SymbolValue(INTERRUPT_PENDING,thread) != NIL)
+ lose("interrupt already pending\n");
+ /* If interrupts are disabled then INTERRUPT_PENDING is set and
+ * not PSEDUO_ATOMIC_INTERRUPTED. This is important for a pseudo
+ * atomic section inside a WITHOUT-INTERRUPTS.
+ */
+ if (SymbolValue(INTERRUPTS_ENABLED,thread) == NIL) {
+ store_signal_data_for_later(data,handler,signal,info,context);
+ SetSymbolValue(INTERRUPT_PENDING, T,thread);
+ FSHOW_SIGNAL((stderr,
+ "/maybe_defer_handler(%x,%d),thread=%lu: deferred\n",
+ (unsigned int)handler,signal,
+ (unsigned long)thread->os_thread));
+ return 1;
+ }
+ /* a slightly confusing test. arch_pseudo_atomic_atomic() doesn't
+ * actually use its argument for anything on x86, so this branch
+ * may succeed even when context is null (gencgc alloc()) */
+ if (arch_pseudo_atomic_atomic(context)) {
+ store_signal_data_for_later(data,handler,signal,info,context);
+ arch_set_pseudo_atomic_interrupted(context);
+ FSHOW_SIGNAL((stderr,
+ "/maybe_defer_handler(%x,%d),thread=%lu: deferred(PA)\n",
+ (unsigned int)handler,signal,
+ (unsigned long)thread->os_thread));
+ return 1;
+ }
+ FSHOW_SIGNAL((stderr,
+ "/maybe_defer_handler(%x,%d),thread=%lu: not deferred\n",
+ (unsigned int)handler,signal,
+ (unsigned long)thread->os_thread));
+ return 0;
+}
+
+static void
+store_signal_data_for_later (struct interrupt_data *data, void *handler,
+ int signal,
+ siginfo_t *info, os_context_t *context)
+{
+ if (data->pending_handler)
+ lose("tried to overwrite pending interrupt handler %x with %x\n",
+ data->pending_handler, handler);
+ if (!handler)
+ lose("tried to defer null interrupt handler\n");
+ data->pending_handler = handler;
+ data->pending_signal = signal;
+ if(info)
+ memcpy(&(data->pending_info), info, sizeof(siginfo_t));
+
+ FSHOW_SIGNAL((stderr, "/store_signal_data_for_later: signal: %d\n", signal));
+
+ if(context) {
+ /* the signal mask in the context (from before we were
+ * interrupted) is copied to be restored when
+ * run_deferred_handler happens. Then the usually-blocked
+ * signals are added to the mask in the context so that we are
+ * running with blocked signals when the handler returns */
+ sigcopyset(&(data->pending_mask),os_context_sigmask_addr(context));
+ sigaddset_deferrable(os_context_sigmask_addr(context));
+ }