+#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));
+ }
+}