mirror of
https://github.com/git/git.git
synced 2024-10-31 14:27:54 +01:00
9658846ce3
When write_or_die() sees EPIPE, it treats it specially by converting it into a SIGPIPE death. We obviously cannot ignore it, as the write has failed and the caller expects us to die. But likewise, we cannot just call die(), because printing any message at all would be a nuisance during normal operations. However, this is a problem if write_or_die() is called from a thread. Our raised signal ends up killing the whole process, when logically we just need to kill the thread (after all, if we are ignoring SIGPIPE, there is good reason to think that the main thread is expecting to handle it). Inside an async thread, the die() code already does the right thing, because we use our custom die_async() routine, which calls pthread_join(). So ideally we would piggy-back on that, and simply call: die_quietly_with_code(141); or similar. But refactoring the die code to do this is surprisingly non-trivial. The die_routines themselves handle both printing and the decision of the exit code. Every one of them would have to be modified to take new parameters for the code, and to tell us to be quiet. Instead, we can just teach write_or_die() to check for the async case and handle it specially. We do have to build an interface to abstract the async exit, but it's simple and self-contained. If we had many call-sites that wanted to do this die_quietly_with_code(), this approach wouldn't scale as well, but we don't. This is the only place where do this weird exit trick. Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
107 lines
2.2 KiB
C
107 lines
2.2 KiB
C
#include "cache.h"
|
|
#include "run-command.h"
|
|
|
|
static void check_pipe(int err)
|
|
{
|
|
if (err == EPIPE) {
|
|
if (in_async())
|
|
async_exit(141);
|
|
|
|
signal(SIGPIPE, SIG_DFL);
|
|
raise(SIGPIPE);
|
|
/* Should never happen, but just in case... */
|
|
exit(141);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Some cases use stdio, but want to flush after the write
|
|
* to get error handling (and to get better interactive
|
|
* behaviour - not buffering excessively).
|
|
*
|
|
* Of course, if the flush happened within the write itself,
|
|
* we've already lost the error code, and cannot report it any
|
|
* more. So we just ignore that case instead (and hope we get
|
|
* the right error code on the flush).
|
|
*
|
|
* If the file handle is stdout, and stdout is a file, then skip the
|
|
* flush entirely since it's not needed.
|
|
*/
|
|
void maybe_flush_or_die(FILE *f, const char *desc)
|
|
{
|
|
static int skip_stdout_flush = -1;
|
|
struct stat st;
|
|
char *cp;
|
|
|
|
if (f == stdout) {
|
|
if (skip_stdout_flush < 0) {
|
|
cp = getenv("GIT_FLUSH");
|
|
if (cp)
|
|
skip_stdout_flush = (atoi(cp) == 0);
|
|
else if ((fstat(fileno(stdout), &st) == 0) &&
|
|
S_ISREG(st.st_mode))
|
|
skip_stdout_flush = 1;
|
|
else
|
|
skip_stdout_flush = 0;
|
|
}
|
|
if (skip_stdout_flush && !ferror(f))
|
|
return;
|
|
}
|
|
if (fflush(f)) {
|
|
check_pipe(errno);
|
|
die_errno("write failure on '%s'", desc);
|
|
}
|
|
}
|
|
|
|
void fprintf_or_die(FILE *f, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
int ret;
|
|
|
|
va_start(ap, fmt);
|
|
ret = vfprintf(f, fmt, ap);
|
|
va_end(ap);
|
|
|
|
if (ret < 0) {
|
|
check_pipe(errno);
|
|
die_errno("write error");
|
|
}
|
|
}
|
|
|
|
void fsync_or_die(int fd, const char *msg)
|
|
{
|
|
if (fsync(fd) < 0) {
|
|
die_errno("fsync error on '%s'", msg);
|
|
}
|
|
}
|
|
|
|
void write_or_die(int fd, const void *buf, size_t count)
|
|
{
|
|
if (write_in_full(fd, buf, count) < 0) {
|
|
check_pipe(errno);
|
|
die_errno("write error");
|
|
}
|
|
}
|
|
|
|
int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg)
|
|
{
|
|
if (write_in_full(fd, buf, count) < 0) {
|
|
check_pipe(errno);
|
|
fprintf(stderr, "%s: write error (%s)\n",
|
|
msg, strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int write_or_whine(int fd, const void *buf, size_t count, const char *msg)
|
|
{
|
|
if (write_in_full(fd, buf, count) < 0) {
|
|
fprintf(stderr, "%s: write error (%s)\n",
|
|
msg, strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|