This may not always reproduce, because there is a race between make writing its output to the pipe and the reader exiting.
Sigpipe is sent when the reader exits before make is able to write its output.
However, if you change it like this

echo 'all:; sleep 2' | make -f- -j2 -O |:

it'll reproduce.

Thanks for you report, Frank.
i opened https://savannah.gnu.org/bugs/index.php?63248 and attached a patch.

Frank wrote [

I now found a way to reproduce it quite easily on my system.
As I suspected, it seems to be SIGPIPE:

% rm -f /tmp/G*
% cat Makefile
all: ; sleep 1
% make -j2 -O 2>&1 | :
% ls -l /tmp/G*
prw------- 1 frank frank 0 19. Okt 22:42 /tmp/GMfifo370973
-rw------- 1 frank frank 0 19. Okt 22:42 /tmp/GmFkJIuq
%

].  That looked like just the ticket but sadly it doesn't reproduce it for me, on amd64 Debian Stretch.

It's probably not worth spending a lot of time ruminating on these things.  The reality is that currently make does many non-handler-safe things in its signal handler, and there are Savannah bugs about hangs etc. while catching SIGINT which prove it if you don't want to check the code.

The goal of my rewrite (slated for the next release) is to rework the signal handling so that the handler does nothing but set a variable (volatile sig_atomic_t) and then all the actual handling of the signal will be done in "normal code".

As I'm sure you're aware this means a lot of careful changes to avoid race conditions etc. but once complete these issues will not be relevant.

i think, it is fine (maybe even good) if the changes in comment 11 are abandoned. The whole critical section only lasts while make is reading and parsing the temp stdin file. The duration of this critical section is likely to be a fraction of compilation time of even one source file.
Paul, if you decide to proceed with changes in comment 11, temp_stdin_fileno should probably be of type volatile sig_atomic_t, rather than int.

FWIW, I do consider this a regression, since these things weren't even created before.

Now, after some weeks of trying make 4.3.90, I get a number of empty files and named pipes lying around -- probably from aborted make runs, but such is life (sometimes you realise a mistake while compiling and abort it).

I hope this can be fixed in the next release, otherwise I'll have to go back to 4.3, I'm afraid.

Thank you, Eli.

> If temp_stdin is fclosed, then there's no need to call close on its fileno.

Right. We have to take care of the critical section between fopen and fclose.

The reasoning is the following.
1. The patch works on unices.
2. On windows the patch works if the file is closed.
3. eval_makefile uses fopen and then fclose to open and close the file.
4. On windowns the file is not deleted, if a signal arrives after the file is opened and before the file is closed by eval_makefile.

One option to handle this critical section on windows is to set the fd of the file to a file scope variable and then close this fd in temp_stdin_unlink.
Something like this (Not tested on windows).

diff --git a/src/main.c b/src/main.c
index 129dd661..cf87a6a0 100644
--- a/src/main.c
+++ b/src/main.c
@@ -306,6 +306,7 @@ unsigned long command_count = 1;
 /* Remember the location of the name of the batch file from stdin.  */

 static int stdin_offset = -1;
+static int temp_stdin_fileno = -1;

 ^L
 /* The usage output.  We write it this way to make life easier for the
@@ -3714,12 +3715,33 @@ clean_jobserver (int status)
     }
 }

+void
+temp_stdin_set_fileno (const char *name, FILE *f)
+{
+  if (temp_stdin_fileno == -1 && f &&
+      stdin_offset >= 0 && streq (makefiles->list[stdin_offset], name))
+    temp_stdin_fileno = fileno (f);
+}
+
+void
+temp_stdin_reset_fileno (const char *name)
+{
+  if (temp_stdin_fileno >= 0 &&
+      stdin_offset >= 0 && streq (makefiles->list[stdin_offset], name))
+    temp_stdin_fileno = -1;
+}
+
 void
 temp_stdin_unlink ()
 {
   /* This function is called from a signal handler.
    * Keep async-signal-safe.  */
   /* Get rid of a temp file from reading a makefile from stdin.  */
+#ifdef WINDOWS32
+  /* Windows needs the file to be closed for unlink to succeed.  */
+  if (temp_stdin_fileno >= 0 && close (temp_stdin_fileno) == 0)
+    temp_stdin_fileno = -1;
+#endif
   if (stdin_offset >= 0 && unlink (makefiles->list[stdin_offset]) == 0)
     stdin_offset = -1;
 }
diff --git a/src/makeint.h b/src/makeint.h
index d0e0fab3..cf2975c6 100644
--- a/src/makeint.h
+++ b/src/makeint.h
@@ -530,6 +530,8 @@ void out_of_memory () NORETURN;
                                  (_f), (_n), (_s))

 void decode_env_switches (const char*, size_t line);
+void temp_stdin_set_fileno (const char *name, FILE *f);
+void temp_stdin_reset_fileno (const char *name);
 void temp_stdin_unlink ();
 void die (int) NORETURN;
 void pfatal_with_name (const char *) NORETURN;
diff --git a/src/read.c b/src/read.c
index 79315503..b8e7baed 100644
--- a/src/read.c
+++ b/src/read.c
@@ -353,6 +353,7 @@ eval_makefile (const char *filename, unsigned short flags)
   errno = 0;
   ENULLLOOP (ebuf.fp, fopen (filename, "r"));
   deps->error = errno;
+  temp_stdin_set_fileno (filename, ebuf.fp);

   /* Check for unrecoverable errors: out of mem or FILE slots.  */
   switch (deps->error)
@@ -441,6 +442,7 @@ eval_makefile (const char *filename, unsigned short flags)
   reading_file = curfile;

   fclose (ebuf.fp);
+  temp_stdin_reset_fileno (filename);

   free (ebuf.bufstart);
   free_alloca ();

There is still a smaller critical section. If a signal arrives between fopen and temp_stdin_set_fileno, the file is not deleted. Signals can be blocked during this smaller critical section. But i think, that's an overkill.

> What do you mean by "We won't be able to use fclose, which is okay, since make is exiting."?

Inside temp_stdin_unlink make can only do async signal safe calls. This rules out fclose. Make can call close, because close is async signal safe. Calling close, rather than fclose, leaves the internal FILE bookeeping messed up, which is okay, because make is exiting.

In the case of temp_stdin eval_makefile fcloses this file.
We'll need to store temp_stdin_fileno in a file scope variable (next to stdin_offset) and pass it to close in temp_stdin_unlink.
We won't be able to use fclose, which is okay, since make is exiting.

close is async signal safe and we call close before unlink.
Should make also calls close before unlink in all other places where make unlinks this (or any other) file?

> This should be tested on MS-Windows.  A file can only be deleted on MS-Windows if it isn't open by any program, and the patch (AFAICT) doesn't make sure the files are closed before unlinking them.  I'm especially worried about the temp_stdin_unlink part.

If the file is opened at the time of unlink, only file's name is removed from the directory and the file itself stays. When make exits the last reference to the file is gone and the file is deleted.

> (Btw, why does the patch use `unlink` instead of a more standard `remove`?)

unlink is used, rather than remove, to stay uniform with the rest of the code, which uses unlink.

Also, tested presence of PPID variable in ksh, bash, ash, zsh, sh.
The only shell that i encountered that lacks PPID is tcsh (likely csh as well).
The test uses the default shell. This means that test will likely fail on a system where /bin/sh is csh or tcsh.

Make fails to unlink temporary files upon arrival of a fatal signal. Specifically, the jobserver fifo, output sync lock and the stdin temp file.