Simplify and avoid signal-handling races.

* nt/inc/ms-w32.h (emacs_raise): New macro.
* src/alloc.c (die):
* src/sysdep.c (emacs_abort) [HAVE_NTGUI]:
Avoid recursive loop if there's a fatal error in the function itself.
* src/atimer.c (pending_atimers):
* src/blockinput.h: Don't include "atimer.h"; no longer needed.
(interrupt_input_pending): Remove.  All uses removed.
pending_signals now counts both atimers and ordinary interrupts.
This is less racy than having three separate pending-signal flags.
(block_input, unblock_input, totally_unblock_input, unblock_input_to)
(input_blocked_p):
Rename from their upper-case counterparts BLOCK_INPUT,
UNBLOCK_INPUT, TOTALLY_UNBLOCK_INPUT, UNBLOCK_INPUT_TO,
INPUT_BLOCKED_P, and turn into functions.  All uses changed.
This makes it easier to access volatile variables more accurately.
(BLOCK_INPUT_RESIGNAL): Remove.  All uses replaced by unblock_input ().
(input_blocked_p): Prefer this to 'interrupt_input_blocked', as
that's more reliable if the code is buggy and sets
interrupt_input_blocked to a negative value.  All uses changed.
* src/atimer.c (deliver_alarm_signal):
Remove.  No need to deliver this to the parent; any thread can
handle this signal now.  All uses replaced by underlying handler.
* src/atimer.c (turn_on_atimers):
* src/dispnew.c (handle_window_change_signal):
* src/emacs.c (handle_danger_signal):
* src/keyboard.c (kbd_buffer_get_event):
Don't reestablish signal handler; not needed with sigaction.
* src/blockinput.h (UNBLOCK_INPUT_TO, TOTALLY_UNBLOCK_INPUT)
(UNBLOCK_INPUT_TO):
Rework to avoid unnecessary accesses to volatile variables.
(UNBLOCK_INPUT_TO): Now a function.
(totally_unblock_input, unblock_input): New decls.
* src/data.c (handle_arith_signal, deliver_arith_signal): Move to sysdep.c
(init_data): Remove.  Necessary stuff now done in init_signal.
* src/emacs.c, src/xdisp.c: Include "atimer.h", since we invoke atimer functions.
* src/emacs.c (handle_fatal_signal, deliver_fatal_signal): Move to sysdep.c.
(fatal_error_code): Remove; no longer needed.
(terminate_due_to_signal): Rename from fatal_error_backtrace, since
it doesn't always backtrace.  All uses changed.  No need to reset
signal to default, since sigaction and/or die does that for us now.
Use emacs_raise (FOO), not kill (getpid (), FOO).
(main): Check more-accurately whether we're dumping.
Move fatal-error setup to sysdep.c
* src/floatfns.c: Do not include "syssignal.h"; no longer needed.
* src/gtkutil.c (xg_get_file_name, xg_get_font):
Remove no-longer-needed signal-mask manipulation.
* src/keyboard.c, src/process.c (POLL_FOR_INPUT):
Don't depend on USE_ASYNC_EVENTS, a symbol that is never defined.
* src/keyboard.c (read_avail_input): Remove.
All uses replaced by gobble_input.
(Ftop_level): Use TOTALLY_UNBLOCK_INPUT rather than open code.
(kbd_buffer_store_event_hold, gobble_input):
(record_asynch_buffer_change) [USABLE_SIGIO]:
(store_user_signal_events):
No need to mess with signal mask.
(gobble_input): If blocking input and there are terminals, simply
set pending_signals to 1 and return.  All hooks changed to not
worry about whether input is blocked.
(process_pending_signals): Clear pending_signals before processing
them, in case a signal comes in while we're processing.
By convention callers now test pending_signals before calling us.
(UNBLOCK_INPUT_TO, unblock_input, totally_unblock_input):
New functions, to support changes to blockinput.h.
(handle_input_available_signal): Now extern.
(reinvoke_input_signal): Remove.  All uses replaced by
handle_async_input.
(quit_count): Now volatile, since a signal handler uses it.
(handle_interrupt): Now takes bool IN_SIGNAL_HANDLER as arg.  All
callers changed.  Block SIGINT only if not already blocked.
Clear sigmask reliably, even if Fsignal returns, which it can.
Omit unnecessary accesses to volatile var.
(quit_throw_to_read_char): No need to restore sigmask.
* src/keyboard.c (gobble_input, handle_user_signal):
* src/process.c (wait_reading_process_output):
Call signal-handling code rather than killing ourselves.
* src/lisp.h: Include <float.h>, for...
(IEEE_FLOATING_POINT): New macro, moved here to avoid duplication.
(pending_signals): Now volatile.
(syms_of_data): Now const if IEEE floating point.
(handle_input_available_signal) [USABLE_SIGIO]:
(terminate_due_to_signal, record_child_status_change): New decls.
* src/process.c (create_process): Avoid disaster if memory is exhausted
while we're processing a vfork, by tightening the critical section
around the vfork.
(send_process_frame, process_sent_to, handle_pipe_signal)
(deliver_pipe_signal): Remove.  No longer needed, as Emacs now
ignores SIGPIPE.
(send_process): No need for setjmp/longjmp any more, since the
SIGPIPE stuff is now gone.  Instead, report an error if errno
is EPIPE.
(record_child_status_change): Now extern.  PID and W are now args.
Return void, not bool.  All callers changed.
* src/sysdep.c (wait_debugging) [(BSD_SYSTEM || HPUX) && !defined (__GNU__)]:
Remove.  All uses removed.  This bug should be fixed now in a
different way.
(wait_for_termination_1): Use waitpid rather than sigsuspend,
and record the child status change directly.  This avoids the
need to futz with the signal mask.
(process_fatal_action): Move here from emacs.c.
(emacs_sigaction_flags): New function, containing
much of what used to be in emacs_sigaction_init.
(emacs_sigaction_init): Use it.  Block nonfatal system signals that are
caught by emacs, to make races less likely.
(deliver_process_signal): Rename from handle_on_main_thread.
All uses changed.
(BACKTRACE_LIMIT_MAX): Now at top level.
(thread_backtrace_buffer, threadback_backtrace_pointers):
New static vars.
(deliver_thread_signal, deliver_fatal_thread_signal):
New functions, for more-accurate delivery of thread-specific signals.
(handle_fatal_signal, deliver_fatal_signal): Move here from emacs.c.
(deliver_arith_signal): Handle in this thread, not
in the main thread, since it's triggered by this thread.
(maybe_fatal_sig): New function.
(init_signals): New arg DUMPING so that we can be more accurate
about whether we're dumping.  Caller changed.
Treat thread-specific signals differently from process-general signals.
Block all signals while handling fatal error; that's safer.
xsignal from SIGFPE only on non-IEEE hosts, treating it as fatal
on IEEE hosts.
When batch, ignore SIGHUP, SIGINT, SIGTERM if they were already ignored.
Ignore SIGPIPE unless batch.
(emacs_backtrace): Output backtrace for the appropriate thread,
which is not necessarily the main thread.
* src/syssignal.h: Include <stdbool.h>.
(emacs_raise): New macro.
* src/xterm.c (x_connection_signal): Remove; no longer needed
now that we use sigaction.
(x_connection_closed): No need to mess with sigmask now.
(x_initialize): No need to reset SIGPIPE handler here, since
init_signals does this for us now.

Fixes: debbugs:12471

1 files changed, 50 insertions, 50 deletions

diff --git a/src/xselect.c b/src/xselect.c
index ab199e0b9b9..de9386bd7d9 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -247,9 +247,9 @@ symbol_to_x_atom (struct x_display_info *dpyinfo, Lisp_Object sym)
   if (!SYMBOLP (sym)) emacs_abort ();
 
   TRACE1 (" XInternAtom %s", SSDATA (SYMBOL_NAME (sym)));
-  BLOCK_INPUT;
+  block_input ();
   val = XInternAtom (dpyinfo->display, SSDATA (SYMBOL_NAME (sym)), False);
-  UNBLOCK_INPUT;
+  unblock_input ();
   return val;
 }
 
@@ -307,16 +307,16 @@ x_atom_to_symbol (Display *dpy, Atom atom)
   if (atom == dpyinfo->Xatom_NULL)
     return QNULL;
 
-  BLOCK_INPUT;
+  block_input ();
   str = XGetAtomName (dpy, atom);
-  UNBLOCK_INPUT;
+  unblock_input ();
   TRACE1 ("XGetAtomName --> %s", str);
   if (! str) return Qnil;
   val = intern (str);
-  BLOCK_INPUT;
+  block_input ();
   /* This was allocated by Xlib, so use XFree.  */
   XFree (str);
-  UNBLOCK_INPUT;
+  unblock_input ();
   return val;
 }
 
@@ -336,12 +336,12 @@ x_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
   Time timestamp = last_event_timestamp;
   Atom selection_atom = symbol_to_x_atom (dpyinfo, selection_name);
 
-  BLOCK_INPUT;
+  block_input ();
   x_catch_errors (display);
   XSetSelectionOwner (display, selection_atom, selecting_window, timestamp);
   x_check_errors (display, "Can't set selection: %s");
   x_uncatch_errors ();
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   /* Now update the local cache */
   {
@@ -469,12 +469,12 @@ x_decline_selection_request (struct input_event *event)
 
   /* The reason for the error may be that the receiver has
      died in the meantime.  Handle that case.  */
-  BLOCK_INPUT;
+  block_input ();
   x_catch_errors (reply->display);
   XSendEvent (reply->display, reply->requestor, False, 0L, &reply_base);
   XFlush (reply->display);
   x_uncatch_errors ();
-  UNBLOCK_INPUT;
+  unblock_input ();
 }
 
 /* This is the selection request currently being processed.
@@ -536,9 +536,9 @@ x_selection_request_lisp_error (Lisp_Object ignore)
 static Lisp_Object
 x_catch_errors_unwind (Lisp_Object dummy)
 {
-  BLOCK_INPUT;
+  block_input ();
   x_uncatch_errors ();
-  UNBLOCK_INPUT;
+  unblock_input ();
   return Qnil;
 }
 
@@ -610,7 +610,7 @@ x_reply_selection_request (struct input_event *event,
   if (reply->property == None)
     reply->property = reply->target;
 
-  BLOCK_INPUT;
+  block_input ();
   /* The protected block contains wait_for_property_change, which can
      run random lisp code (process handlers) or signal.  Therefore, we
      put the x_uncatch_errors call in an unwind.  */
@@ -682,7 +682,7 @@ x_reply_selection_request (struct input_event *event,
       {
 	int format_bytes = cs->format / 8;
 	int had_errors = x_had_errors_p (display);
-	UNBLOCK_INPUT;
+	unblock_input ();
 
 	bytes_remaining = cs->size;
 	bytes_remaining *= format_bytes;
@@ -703,7 +703,7 @@ x_reply_selection_request (struct input_event *event,
 	    int i = ((bytes_remaining < max_bytes)
 		     ? bytes_remaining
 		     : max_bytes) / format_bytes;
-	    BLOCK_INPUT;
+	    block_input ();
 
 	    cs->wait_object
 	      = expect_property_change (display, window, cs->property,
@@ -722,7 +722,7 @@ x_reply_selection_request (struct input_event *event,
 			     : format_bytes);
 	    XFlush (display);
 	    had_errors = x_had_errors_p (display);
-	    UNBLOCK_INPUT;
+	    unblock_input ();
 
 	    if (had_errors) break;
 
@@ -735,7 +735,7 @@ x_reply_selection_request (struct input_event *event,
 
 	/* Now write a zero-length chunk to the property to tell the
 	   requestor that we're done.  */
-	BLOCK_INPUT;
+	block_input ();
 	if (! waiting_for_other_props_on_window (display, window))
 	  XSelectInput (display, window, 0L);
 
@@ -757,15 +757,15 @@ x_reply_selection_request (struct input_event *event,
   /* 2004-09-10: XSync and UNBLOCK so that possible protocol errors are
      delivered before uncatch errors.  */
   XSync (display, False);
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   /* GTK queues events in addition to the queue in Xlib.  So we
      UNBLOCK to enter the event loop and get possible errors delivered,
      and then BLOCK again because x_uncatch_errors requires it.  */
-  BLOCK_INPUT;
+  block_input ();
   /* This calls x_uncatch_errors.  */
   unbind_to (count, Qnil);
-  UNBLOCK_INPUT;
+  unblock_input ();
 }
 
 /* Handle a SelectionRequest event EVENT.
@@ -1232,7 +1232,7 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
   if (! NILP (time_stamp))
     CONS_TO_INTEGER (time_stamp, Time, requestor_time);
 
-  BLOCK_INPUT;
+  block_input ();
   TRACE2 ("Get selection %s, type %s",
 	  XGetAtomName (display, type_atom),
 	  XGetAtomName (display, target_property));
@@ -1257,7 +1257,7 @@ x_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
   record_unwind_protect (queue_selection_requests_unwind, Qnil);
 #endif
 
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   /* This allows quits.  Also, don't wait forever.  */
   timeout = max (0, x_selection_timeout);
@@ -1309,7 +1309,7 @@ x_get_window_property (Display *display, Window window, Atom property,
      ? min (PTRDIFF_MAX, SIZE_MAX) - 1
      : LONG_MAX * x_long_size);
 
-  BLOCK_INPUT;
+  block_input ();
 
   /* First probe the thing to find out how big it is.  */
   result = XGetWindowProperty (display, window, property,
@@ -1410,19 +1410,19 @@ x_get_window_property (Display *display, Window window, Atom property,
   data[offset] = '\0';
 
  done:
-  UNBLOCK_INPUT;
+  unblock_input ();
   *data_ret = data;
   *bytes_ret = offset;
   return;
 
  size_overflow:
   free (data);
-  UNBLOCK_INPUT;
+  unblock_input ();
   memory_full (SIZE_MAX);
 
  memory_exhausted:
   free (data);
-  UNBLOCK_INPUT;
+  unblock_input ();
   memory_full (total_size + 1);
 }
 
@@ -1454,7 +1454,7 @@ receive_incremental_selection (Display *display, Window window, Atom property,
      that property, then reading the property, then deleting it to ack.
      We are done when the sender places a property of length 0.
    */
-  BLOCK_INPUT;
+  block_input ();
   XSelectInput (display, window, STANDARD_EVENT_SET | PropertyChangeMask);
   TRACE1 ("  Delete property %s",
 	  SDATA (SYMBOL_NAME (x_atom_to_symbol (display, property))));
@@ -1464,7 +1464,7 @@ receive_incremental_selection (Display *display, Window window, Atom property,
   wait_object = expect_property_change (display, window, property,
 					PropertyNewValue);
   XFlush (display);
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   while (1)
     {
@@ -1496,14 +1496,14 @@ receive_incremental_selection (Display *display, Window window, Atom property,
 	  break;
 	}
 
-      BLOCK_INPUT;
+      block_input ();
       TRACE1 ("  ACK by deleting property %s",
 	      XGetAtomName (display, property));
       XDeleteProperty (display, window, property);
       wait_object = expect_property_change (display, window, property,
 					    PropertyNewValue);
       XFlush (display);
-      UNBLOCK_INPUT;
+      unblock_input ();
 
       if (*size_bytes_ret - offset < tmp_size_bytes)
 	*data_ret = xpalloc (*data_ret, size_bytes_ret,
@@ -1545,10 +1545,10 @@ x_get_window_property_as_lisp_data (Display *display, Window window,
   if (! data)
     {
       int there_is_a_selection_owner;
-      BLOCK_INPUT;
+      block_input ();
       there_is_a_selection_owner
 	= XGetSelectionOwner (display, selection_atom);
-      UNBLOCK_INPUT;
+      unblock_input ();
       if (there_is_a_selection_owner)
 	signal_error ("Selection owner couldn't convert",
 		      actual_type
@@ -1565,22 +1565,22 @@ x_get_window_property_as_lisp_data (Display *display, Window window,
       /* That wasn't really the data, just the beginning.  */
 
       unsigned int min_size_bytes = * ((unsigned int *) data);
-      BLOCK_INPUT;
+      block_input ();
       /* Use xfree, not XFree, because x_get_window_property
 	 calls xmalloc itself.  */
       xfree (data);
-      UNBLOCK_INPUT;
+      unblock_input ();
       receive_incremental_selection (display, window, property, target_type,
 				     min_size_bytes, &data, &bytes,
 				     &actual_type, &actual_format,
 				     &actual_size);
     }
 
-  BLOCK_INPUT;
+  block_input ();
   TRACE1 ("  Delete property %s", XGetAtomName (display, property));
   XDeleteProperty (display, window, property);
   XFlush (display);
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   /* It's been read.  Now convert it to a lisp object in some semi-rational
      manner.  */
@@ -2096,13 +2096,13 @@ On MS-DOS, all this does is return non-nil if we own the selection.  */)
 
   selection_atom = symbol_to_x_atom (dpyinfo, selection);
 
-  BLOCK_INPUT;
+  block_input ();
   if (NILP (time_object))
     timestamp = last_event_timestamp;
   else
     CONS_TO_INTEGER (time_object, Time, timestamp);
   XSetSelectionOwner (dpyinfo->display, selection_atom, None, timestamp);
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   /* It doesn't seem to be guaranteed that a SelectionClear event will be
      generated for a window which owns the selection when that window sets
@@ -2179,9 +2179,9 @@ On Nextstep, TERMINAL is unused.  */)
 
   atom = symbol_to_x_atom (dpyinfo, selection);
   if (atom == 0) return Qnil;
-  BLOCK_INPUT;
+  block_input ();
   owner = XGetSelectionOwner (dpyinfo->display, atom);
-  UNBLOCK_INPUT;
+  unblock_input ();
   return (owner ? Qt : Qnil);
 }
 
@@ -2353,9 +2353,9 @@ x_fill_property_data (Display *dpy, Lisp_Object data, void *ret, int format)
 	val = cons_to_signed (o, LONG_MIN, LONG_MAX);
       else if (STRINGP (o))
         {
-          BLOCK_INPUT;
+          block_input ();
           val = (long) XInternAtom (dpy, SSDATA (o), False);
-          UNBLOCK_INPUT;
+          unblock_input ();
         }
       else
         error ("Wrong type, must be string, number or cons");
@@ -2413,7 +2413,7 @@ mouse_position_for_drop (FRAME_PTR f, int *x, int *y)
   Window root, dummy_window;
   int dummy;
 
-  BLOCK_INPUT;
+  block_input ();
 
   XQueryPointer (FRAME_X_DISPLAY (f),
                  DefaultRootWindow (FRAME_X_DISPLAY (f)),
@@ -2439,7 +2439,7 @@ mouse_position_for_drop (FRAME_PTR f, int *x, int *y)
   *x -= f->left_pos + FRAME_OUTER_TO_INNER_DIFF_X (f);
   *y -= f->top_pos + FRAME_OUTER_TO_INNER_DIFF_Y (f);
 
-  UNBLOCK_INPUT;
+  unblock_input ();
 }
 
 DEFUN ("x-get-atom-name", Fx_get_atom_name,
@@ -2462,7 +2462,7 @@ If the value is 0 or the atom is not known, return the empty string.  */)
 
   CONS_TO_INTEGER (value, Atom, atom);
 
-  BLOCK_INPUT;
+  block_input ();
   x_catch_errors (dpy);
   name = atom ? XGetAtomName (dpy, atom) : empty;
   had_errors = x_had_errors_p (dpy);
@@ -2474,7 +2474,7 @@ If the value is 0 or the atom is not known, return the empty string.  */)
   if (atom && name) XFree (name);
   if (NILP (ret)) ret = empty_unibyte_string;
 
-  UNBLOCK_INPUT;
+  unblock_input ();
 
   return ret;
 }
@@ -2496,9 +2496,9 @@ FRAME is on.  If FRAME is nil, the selected frame is used.  */)
     x_atom = symbol_to_x_atom (dpyinfo, atom);
   else if (STRINGP (atom))
     {
-      BLOCK_INPUT;
+      block_input ();
       x_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (atom), False);
-      UNBLOCK_INPUT;
+      unblock_input ();
     }
   else
     error ("ATOM must be a symbol or a string");
@@ -2657,7 +2657,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
   if (wdest == 0) wdest = dpyinfo->root_window;
   to_root = wdest == dpyinfo->root_window;
 
-  BLOCK_INPUT;
+  block_input ();
 
   event.xclient.message_type = message_type;
   event.xclient.display = dpyinfo->display;
@@ -2683,7 +2683,7 @@ x_send_client_event (Lisp_Object display, Lisp_Object dest, Lisp_Object from,
     XFlush (dpyinfo->display);
   }
   x_uncatch_errors ();
-  UNBLOCK_INPUT;
+  unblock_input ();
 }