write-or-die.c

   1 #include "git-compat-util.h"
   2 #include "parse.h"
   3 #include "run-command.h"
   4 #include "write-or-die.h"
   5
   6 /*
   7  * Some cases use stdio, but want to flush after the write
   8  * to get error handling (and to get better interactive
   9  * behaviour - not buffering excessively).
  10  *
  11  * Of course, if the flush happened within the write itself,
  12  * we've already lost the error code, and cannot report it any
  13  * more. So we just ignore that case instead (and hope we get
  14  * the right error code on the flush).
  15  *
  16  * If the file handle is stdout, and stdout is a file, then skip the
  17  * flush entirely since it's not needed.
  18  */
  19 void maybe_flush_or_die(FILE *f, const char *desc)
  20 {
  21         static int skip_stdout_flush = -1;
  22
  23         if (f == stdout) {
  24                 if (skip_stdout_flush < 0) {
  25                         skip_stdout_flush = git_env_bool("GIT_FLUSH", -1);
  26                         if (skip_stdout_flush < 0) {
  27                                 struct stat st;
  28                                 if (fstat(fileno(stdout), &st))
  29                                         skip_stdout_flush = 0;
  30                                 else
  31                                         skip_stdout_flush = S_ISREG(st.st_mode);
  32                         }
  33                 }
  34                 if (skip_stdout_flush && !ferror(f))
  35                         return;
  36         }
  37         if (fflush(f)) {
  38                 check_pipe(errno);
  39                 die_errno("write failure on '%s'", desc);
  40         }
  41 }
  42
  43 void fprintf_or_die(FILE *f, const char *fmt, ...)
  44 {
  45         va_list ap;
  46         int ret;
  47
  48         va_start(ap, fmt);
  49         ret = vfprintf(f, fmt, ap);
  50         va_end(ap);
  51
  52         if (ret < 0) {
  53                 check_pipe(errno);
  54                 die_errno("write error");
  55         }
  56 }
  57
  58 static int maybe_fsync(int fd)
  59 {
  60         if (use_fsync < 0)
  61                 use_fsync = git_env_bool("GIT_TEST_FSYNC", 1);
  62         if (!use_fsync)
  63                 return 0;
  64
  65         if (fsync_method == FSYNC_METHOD_WRITEOUT_ONLY &&
  66             git_fsync(fd, FSYNC_WRITEOUT_ONLY) >= 0)
  67                 return 0;
  68
  69         return git_fsync(fd, FSYNC_HARDWARE_FLUSH);
  70 }
  71
  72 void fsync_or_die(int fd, const char *msg)
  73 {
  74         if (maybe_fsync(fd) < 0)
  75                 die_errno("fsync error on '%s'", msg);
  76 }
  77
  78 int fsync_component(enum fsync_component component, int fd)
  79 {
  80         if (fsync_components & component)
  81                 return maybe_fsync(fd);
  82         return 0;
  83 }
  84
  85 void fsync_component_or_die(enum fsync_component component, int fd, const char *msg)
  86 {
  87         if (fsync_components & component)
  88                 fsync_or_die(fd, msg);
  89 }
  90
  91 void write_or_die(int fd, const void *buf, size_t count)
  92 {
  93         if (write_in_full(fd, buf, count) < 0) {
  94                 check_pipe(errno);
  95                 die_errno("write error");
  96         }
  97 }
  98
  99 void fwrite_or_die(FILE *f, const void *buf, size_t count)
 100 {
 101         if (fwrite(buf, 1, count, f) != count)
 102                 die_errno("fwrite error");
 103 }
 104
 105 void fflush_or_die(FILE *f)
 106 {
 107         if (fflush(f))
 108                 die_errno("fflush error");
 109 }