POSIX: Add a macro for handling EINTR.

base/process_util_posix.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <limits>
 #include <set>
 
 #include "base/basictypes.h"
+#include "base/eintr_wrappers.h"
 #include "base/logging.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "base/waitable_event.h"
 
 const int kMicrosecondsPerSecond = 1000000;
 
@@ skipping 32 matching lines @@
 // Attempts to kill the process identified by the given process
 // entry structure.  Ignores specified exit_code; posix can't force that.
 // Returns true if this is successful, false otherwise.
 bool KillProcess(ProcessHandle process_id, int exit_code, bool wait) {
   bool result = kill(process_id, SIGTERM) == 0;
 
   if (result && wait) {
     int tries = 60;
     // The process may not end immediately due to pending I/O
     while (tries-- > 0) {
-      int pid = waitpid(process_id, NULL, WNOHANG);
+      int pid = HANDLE_EINTR(waitpid(process_id, NULL, WNOHANG));
       if (pid == process_id)
         break;
 
       sleep(1);
     }
 
     result = kill(process_id, SIGKILL) == 0;
   }
 
   if (!result)
@@ skipping 49 matching lines @@
     }
 
     if (num_fds > INT_MAX)
       num_fds = INT_MAX;
 
     for (rlim_t i = 0; i < num_fds; ++i) {
       const int fd = static_cast<int>(i);
       if (saved_fds.find(fd) != saved_fds.end())
         continue;
 
-      int result;
-      do {
-        result = close(fd);
-      } while (result == -1 && errno == EINTR);
+      HANDLE_EINTR(close(fd));
     }
     return;
   }
 
   struct dirent *ent;
   while ((ent = readdir(dir))) {
     // Skip . and .. entries.
     if (ent->d_name[0] == '.')
       continue;
 
     char *endptr;
     errno = 0;
     const long int fd = strtol(ent->d_name, &endptr, 10);
     if (ent->d_name[0] == 0 || *endptr || fd < 0 || fd >= INT_MAX || errno)
       continue;
     if (saved_fds.find(fd) != saved_fds.end())
       continue;
 
-    int result;
-    do {
-      result = close(fd);
-    } while (result == -1 && errno == EINTR);
+    HANDLE_EINTR(close(fd));
   }
 }
 
 // Sets all file descriptors to close on exec except for stdin, stdout
 // and stderr.
 // TODO(agl): Remove this function. It's fundamentally broken for multithreaded
 // apps.
 void SetAllFDsToCloseOnExec() {
 #if defined(OS_LINUX)
   const char fd_dir[] = "/proc/self/fd";
@@ skipping 41 matching lines @@
   // On POSIX, there nothing to do AFAIK.
 }
 
 void RaiseProcessToHighPriority() {
   // On POSIX, we don't actually do anything here.  We could try to nice() or
   // setpriority() or sched_getscheduler, but these all require extra rights.
 }
 
 bool DidProcessCrash(bool* child_exited, ProcessHandle handle) {
   int status;
-  const int result = waitpid(handle, &status, WNOHANG);
+  const int result = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
   if (result == -1) {
     LOG(ERROR) << "waitpid failed pid:" << handle << " errno:" << errno;
     if (child_exited)
       *child_exited = false;
     return false;
   } else if (result == 0) {
     // the child hasn't exited yet.
     if (child_exited)
       *child_exited = false;
     return false;
@@ skipping 15 matching lines @@
   }
 
   if (WIFEXITED(status))
     return WEXITSTATUS(status) != 0;
 
   return false;
 }
 
 bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
   int status;
-  while (waitpid(handle, &status, 0) == -1) {
-    if (errno != EINTR) {
-      NOTREACHED();
-      return false;
-    }
+  if (HANDLE_EINTR(waitpid(handle, &status, 0)) == -1) {
+    NOTREACHED();
+    return false;
   }
 
   if (WIFEXITED(status)) {
     *exit_code = WEXITSTATUS(status);
     return true;
   }
 
   // If it didn't exit cleanly, it must have been signaled.
   DCHECK(WIFSIGNALED(status));
   return false;
@@ skipping 18 matching lines @@
   // has already exited, otherwise to loop for wait_milliseconds, sleeping for
   // at most 0.25 secs each time using usleep() and then calling waitpid().
   //
   // usleep() is speced to exit if a signal is received for which a handler
   // has been installed.  This means that when a SIGCHLD is sent, it will exit
   // depending on behavior external to this function.
   //
   // This function is used primarily for unit tests, if we want to use it in
   // the application itself it would probably be best to examine other routes.
   int status = -1;
-  pid_t ret_pid = waitpid(handle, &status, WNOHANG);
+  pid_t ret_pid = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
   static const int64 kQuarterSecondInMicroseconds = kMicrosecondsPerSecond/4;
 
   // If the process hasn't exited yet, then sleep and try again.
   Time wakeup_time = Time::Now() + TimeDelta::FromMilliseconds(
       wait_milliseconds);
   while (ret_pid == 0) {
     Time now = Time::Now();
     if (now > wakeup_time)
       break;
     // Guaranteed to be non-negative!
     int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
     // Don't sleep for more than 0.25 secs at a time.
     if (sleep_time_usecs > kQuarterSecondInMicroseconds) {
       sleep_time_usecs = kQuarterSecondInMicroseconds;
     }
 
     // usleep() will return 0 and set errno to EINTR on receipt of a signal
     // such as SIGCHLD.
     usleep(sleep_time_usecs);
-    ret_pid = waitpid(handle, &status, WNOHANG);
+    ret_pid = HANDLE_EINTR(waitpid(handle, &status, WNOHANG));
   }
 
   if (success)
     *success = (ret_pid != -1);
 
   return status;
 }
 
 }  // namespace
 
 bool WaitForSingleProcess(ProcessHandle handle, int wait_milliseconds) {
   bool waitpid_success;
   int status;
   if (wait_milliseconds == base::kNoTimeout)
-    waitpid_success = (waitpid(handle, &status, 0) != -1);
+    waitpid_success = (HANDLE_EINTR(waitpid(handle, &status, 0)) != -1);
   else
     status = WaitpidWithTimeout(handle, wait_milliseconds, &waitpid_success);
   if (status != -1) {
     DCHECK(waitpid_success);
     return WIFEXITED(status);
   } else {
     return false;
   }
 }
 
@@ skipping 102 matching lines @@
 
         int exit_code = EXIT_FAILURE;
         bool success = WaitForExitCode(pid, &exit_code);
         if (!success || exit_code != EXIT_SUCCESS) {
           close(pipe_fd[0]);
           return false;
         }
 
         char buffer[256];
         std::string buf_output;
-        ssize_t bytes_read = 0;
 
         while (true) {
-          bytes_read = read(pipe_fd[0], buffer, sizeof(buffer));
-          if (bytes_read == 0)
+          ssize_t bytes_read =
+              HANDLE_EINTR(read(pipe_fd[0], buffer, sizeof(buffer)));
+          if (bytes_read <= 0)
             break;
-          if (bytes_read == -1 && errno != EINTR)
-            break;
-          if (bytes_read > 0)
-            buf_output.append(buffer, bytes_read);
+          buf_output.append(buffer, bytes_read);
         }
         output->swap(buf_output);
         close(pipe_fd[0]);
         return true;
       }
   }
 }
 
 int GetProcessCount(const std::wstring& executable_name,
                     const ProcessFilter* filter) {
@@ skipping 45 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                            filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base