Handle EINTR on all IO operations

runtime/bin/directory_posix.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/directory.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ skipping 20 matching lines @@
                             bool recursive,
                             Dart_Port dir_port,
                             Dart_Port file_port,
                             Dart_Port done_port,
                             Dart_Port error_port);
 
 
 static void ComputeFullPath(const char* dir_name,
                             char* path,
                             int* path_length) {
-  char* abs_path = realpath(dir_name, path);
+  char* abs_path;
+  do {
+    abs_path = realpath(dir_name, path);
+  } while (abs_path == NULL && errno == EINTR);
   ASSERT(abs_path != NULL);
   *path_length = strlen(path);
   size_t written = snprintf(path + *path_length,
                             PATH_MAX - *path_length,
                             "%s",
                             File::PathSeparator());
   ASSERT(written == strlen(File::PathSeparator()));
   *path_length += written;
 }
 
@@ skipping 68 matching lines @@
   }
 }
 
 
 static bool ListRecursively(const char* dir_name,
                             bool recursive,
                             Dart_Port dir_port,
                             Dart_Port file_port,
                             Dart_Port done_port,
                             Dart_Port error_port) {
-  DIR* dir_pointer = opendir(dir_name);
+  DIR* dir_pointer;
+  do {
+    dir_pointer = opendir(dir_name);
+  } while (dir_pointer == NULL && errno == EINTR);
   if (dir_pointer == NULL) {
     PostError(error_port, "Directory listing failed for: ", dir_name, errno);
     return false;
   }
 
   // Compute full path for the directory currently being listed.
   char *path = static_cast<char*>(malloc(PATH_MAX));
   ASSERT(path != NULL);
   int path_length = 0;
   ComputeFullPath(dir_name, path, &path_length);
 
   // Iterated the directory and post the directories and files to the
   // ports.
   int success = 0;
   bool listing_error = false;
   dirent entry;
   dirent* result;
-  while ((success = readdir_r(dir_pointer, &entry, &result)) == 0 &&
+  while ((success = TEMP_FAILURE_RETRY(readdir_r(dir_pointer,
+                                                 &entry,
+                                                 &result))) == 0 &&
          result != NULL &&
          !listing_error) {
     switch (entry.d_type) {
       case DT_DIR:
         listing_error = listing_error || !HandleDir(entry.d_name,
                                                     path,
                                                     path_length,
                                                     recursive,
                                                     dir_port,
                                                     file_port,
                                                     done_port,
                                                     error_port);
         break;
       case DT_REG:
         HandleFile(entry.d_name, path, path_length, file_port);
         break;
       case DT_UNKNOWN: {
         // On some file systems the entry type is not determined by
         // readdir_r. For those we use lstat to determine the entry
         // type.
         struct stat entry_info;
         size_t written = snprintf(path + path_length,
                                   PATH_MAX - path_length,
                                   "%s",
                                   entry.d_name);
         ASSERT(written == strlen(entry.d_name));
-        int lstat_success = lstat(path, &entry_info);
+        int lstat_success = TEMP_FAILURE_RETRY(lstat(path, &entry_info));
         if (lstat_success == -1) {
           listing_error = true;
           PostError(error_port, "Directory listing failed for: ", path, errno);
           break;
         }
         if ((entry_info.st_mode & S_IFMT) == S_IFDIR) {
           listing_error = listing_error || !HandleDir(entry.d_name,
                                                       path,
                                                       path_length,
                                                       recursive,
@@ skipping 39 matching lines @@
                                    error_port);
   if (done_port != 0) {
     Dart_Handle value = Dart_NewBoolean(completed);
     Dart_Post(done_port, value);
   }
 }
 
 
 Directory::ExistsResult Directory::Exists(const char* dir_name) {
   struct stat entry_info;
-  int lstat_success = lstat(dir_name, &entry_info);
+  int lstat_success = TEMP_FAILURE_RETRY(lstat(dir_name, &entry_info));
   if (lstat_success == 0) {
     if ((entry_info.st_mode & S_IFMT) == S_IFDIR) {
       return EXISTS;
     } else {
       return DOES_NOT_EXIST;
     }
   } else {
     if (errno == EACCES ||
         errno == EBADF ||
         errno == EFAULT ||
         errno == ENOMEM ||
         errno == EOVERFLOW) {
       // Search permissions denied for one of the directories in the
       // path or a low level error occured. We do not know if the
       // directory exists.
       return UNKNOWN;
     }
     ASSERT(errno == ELOOP ||
            errno == ENAMETOOLONG ||
            errno == ENOENT ||
            errno == ENOTDIR);
     return DOES_NOT_EXIST;
   }
 }
 
 
 bool Directory::Create(const char* dir_name) {
   // Create the directory with the permissions specified by the
   // process umask.
-  return (mkdir(dir_name, 0777) == 0);
+  return (TEMP_FAILURE_RETRY(mkdir(dir_name, 0777)) == 0);
 }
 
 
 int Directory::CreateTemp(const char* const_template,
                           char** path,
                           char* os_error_message,
                           int os_error_message_len) {
   // Returns a new, unused directory name, modifying the contents of
   // dir_template.  Creates the directory with the permissions specified
   // by the process umask.
   // The return value must be freed by the caller.
   *path = static_cast<char*>(malloc(PATH_MAX + 1));
   SafeStrNCpy(*path, const_template, PATH_MAX + 1);
   int path_length = strlen(*path);
   if (path_length > 0) {
     if ((*path)[path_length - 1] == '/') {
       snprintf(*path + path_length, PATH_MAX - path_length, "temp_dir_XXXXXX");
     } else {
       snprintf(*path + path_length, PATH_MAX - path_length, "XXXXXX");
     }
   } else {
     snprintf(*path, PATH_MAX, "/tmp/temp_dir1_XXXXXX");
   }
-  char* result = mkdtemp(*path);
+  char* result;
+  do {
+    result = mkdtemp(*path);
+  } while (result == NULL && errno == EINTR);
   if (result == NULL) {
     SetOsErrorMessage(os_error_message, os_error_message_len);
     free(*path);
     *path = NULL;
     return errno;
   }
   return 0;
 }
 
 
 bool Directory::Delete(const char* dir_name) {
-  return (rmdir(dir_name) == 0);
+  return (TEMP_FAILURE_RETRY(rmdir(dir_name)) == 0);
 }