Ensure EINTR handling is much more consistent across the board

src/coreclr/debug/createdump/crashinfo.cpp

@@ -814,20 +814,32 @@ CrashInfo::PageMappedToPhysicalMemory(uint64_t start)
         }
 
         uint64_t pagemapOffset = (start / PAGE_SIZE) * sizeof(uint64_t);
-        uint64_t seekResult = lseek(m_fdPagemap, (off_t) pagemapOffset, SEEK_SET);
-        if (seekResult != pagemapOffset)
+        int64_t seekResult;
+        while (-1 == (seekResult = lseek(m_fdPagemap, (off_t) pagemapOffset, SEEK_SET)) && errno == EINTR);
+        if ((uint64_t)seekResult != pagemapOffset)
         {
             int seekErrno = errno;
             TRACE("Seeking in pagemap file FAILED, addr: %" PRIA PRIx ", pagemap offset: %" PRIA PRIx ", ERRNO %d: %s\n", start, pagemapOffset, seekErrno, strerror(seekErrno));
             return true;
         }
         uint64_t value;
-        size_t readResult = read(m_fdPagemap, (void*)&value, sizeof(value));
-        if (readResult == (size_t) -1)
+        size_t readSoFar = 0;
+        while (readSoFar < sizeof(value))
         {
-            int readErrno = errno;
-            TRACE("Reading of pagemap file FAILED, addr: %" PRIA PRIx ", pagemap offset: %" PRIA PRIx ", size: %zu, ERRNO %d: %s\n", start, pagemapOffset, sizeof(value), readErrno, strerror(readErrno));
-            return true;
+            ssize_t readResult;
+            while (-1 == (readResult = read(m_fdPagemap, (unsigned char*)&value + readSoFar, sizeof(value) - readSoFar) && errno == EINTR));
+            if (readResult == -1)
+            {
+                int readErrno = errno;
+                TRACE("Reading of pagemap file FAILED, addr: %" PRIA PRIx ", pagemap offset: %" PRIA PRIx ", size: %zu, ERRNO %d: %s\n", start, pagemapOffset, sizeof(value), readErrno, strerror(readErrno));
+                return true;
+            }
+            if (readResult == 0)
+            {
+                TRACE("Reading of pagemap file FAILED, addr: %" PRIA PRIx ", pagemap offset: %" PRIA PRIx ", size: %zu, Read Was Incomplete\n", start, pagemapOffset, sizeof(value));
+                return true;
+            }
+            readSoFar += (size_t)readResult;
         }
 
         bool is_page_present = (value & ((uint64_t)1 << 63)) != 0;

src/coreclr/debug/createdump/crashinfounix.cpp

@@ -25,7 +25,7 @@ CrashInfo::Initialize()
         return false;
     }
 
-    m_fdMem = open(memPath, O_RDONLY);
+    while (-1 == (m_fdMem = open(memPath, O_RDONLY)) && errno == EINTR);
     if (m_fdMem == -1)
     {
         int err = errno;
@@ -54,7 +54,7 @@ CrashInfo::Initialize()
             printf_error("snprintf failed building /proc/<pid>/pagemap name\n");
             return false;
         }
-        m_fdPagemap = open(pagemapPath, O_RDONLY);
+        while (-1 == (m_fdPagemap = open(pagemapPath, O_RDONLY)) && errno == EINTR);
         if (m_fdPagemap == -1)
         {
             TRACE("open(%s) FAILED %d (%s), will fallback to dumping all memory regions without checking if they are committed\n", pagemapPath, errno, strerror(errno));
@@ -84,7 +84,7 @@ CrashInfo::CleanupAndResumeProcess()
         if (ptrace(PTRACE_DETACH, thread->Tid(), nullptr, nullptr) != -1)
         {
             int waitStatus;
-            waitpid(thread->Tid(), &waitStatus, __WALL);
+            while (-1 == waitpid(thread->Tid(), &waitStatus, __WALL) && errno == EINTR);
         }
     }
     if (m_fdMem != -1)
@@ -113,24 +113,34 @@ CrashInfo::EnumerateAndSuspendThreads()
         return false;
     }
 
-    DIR* taskDir = opendir(taskPath);
+    DIR* taskDir;
+    while ((taskDir = opendir(taskPath)) == nullptr && errno == EINTR);
+
     if (taskDir == nullptr)
     {
         printf_error("Problem enumerating threads: opendir(%s) FAILED %s (%d)\n", taskPath, strerror(errno), errno);
         return false;
     }
 
     struct dirent* entry;
-    while ((entry = readdir(taskDir)) != nullptr)
+    while (true)
     {
+        do
+        {
+            errno = 0;
+            entry = readdir(taskDir);
+        }
+        while (entry == nullptr && errno == EINTR);
+        if (entry == nullptr) break;
+
         pid_t tid = static_cast<pid_t>(strtol(entry->d_name, nullptr, 10));
         if (tid != 0)
         {
             // Reference: http://stackoverflow.com/questions/18577956/how-to-use-ptrace-to-get-a-consistent-view-of-multiple-threads
             if (ptrace(PTRACE_ATTACH, tid, nullptr, nullptr) != -1)
             {
                 int waitStatus;
-                waitpid(tid, &waitStatus, __WALL);
+                while (-1 == waitpid(tid, &waitStatus, __WALL) && errno == EINTR);
             }
             else
             {
@@ -166,7 +176,8 @@ CrashInfo::GetAuxvEntries()
         printf_error("snprintf failed building /proc/<pid>/auxv\n");
         return false;
     }
-    int fd = open(auxvPath, O_RDONLY, 0);
+    int fd;
+    while (-1 == (fd = open(auxvPath, O_RDONLY, 0)) && errno == EINTR);
     if (fd == -1)
     {
         printf_error("Problem reading aux info: open(%s) FAILED %s (%d)\n", auxvPath, strerror(errno), errno);
@@ -175,8 +186,24 @@ CrashInfo::GetAuxvEntries()
     bool result = false;
     elf_aux_entry auxvEntry;
 
-    while (read(fd, &auxvEntry, sizeof(elf_aux_entry)) == sizeof(elf_aux_entry))
+    while (true)
     {
+        size_t readSoFar = 0;
+        while (readSoFar < sizeof(elf_aux_entry))
+        {
+            ssize_t readResult;
+            while (-1 == (readResult = read(fd, (unsigned char*)&auxvEntry + readSoFar, sizeof(elf_aux_entry) - readSoFar) && errno == EINTR));
+            if (readResult == -1)
+            {
+                break;
+            }
+            if (readResult == 0)
+            {
+                break;
+            }
+            readSoFar += (size_t)readResult;
+        }
+        if (readSoFar != sizeof(elf_aux_entry)) break;
         m_auxvEntries.push_back(auxvEntry);
         if (auxvEntry.a_type == AT_NULL)
         {
@@ -532,7 +559,7 @@ CrashInfo::ReadProcessMemory(uint64_t address, void* buffer, size_t size, size_t
         // performance optimization.
         m_canUseProcVmReadSyscall = false;
         assert(m_fdMem != -1);
-        *read = pread(m_fdMem, buffer, size, (off_t)address);
+        while (-1 == (ssize_t)(*read = pread(m_fdMem, buffer, size, (off_t)address)) && errno == EINTR);
     }
 
     if (*read == (size_t)-1)

src/coreclr/debug/createdump/crashreportwriter.cpp

@@ -48,7 +48,7 @@ CrashReportWriter::WriteCrashReport(const std::string& dumpFileName)
         printf_error("Writing the crash report file FAILED\n");
 
         // Delete the partial json file on error
-        remove(crashReportFile.c_str());
+        while (-1 == remove(crashReportFile.c_str()) && errno == EINTR);
     }
 }
 
@@ -270,7 +270,7 @@ CrashReportWriter::WriteStackFrame(const StackFrame& frame)
 bool
 CrashReportWriter::OpenWriter(const char* fileName)
 {
-    m_fd = open(fileName, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR | S_IRUSR);
+    while (-1 == (m_fd = open(fileName, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR | S_IRUSR)) && errno == EINTR);
     if (m_fd == -1)
     {
         printf_error("Could not create json file '%s': %s (%d)\n", fileName, strerror(errno), errno);

src/coreclr/debug/createdump/createdumpunix.cpp

@@ -91,7 +91,7 @@ CreateDump(const CreateDumpOptions& options)
             printf_error("Writing dump FAILED\n");
 
             // Delete the partial dump file on error
-            remove(dumpPath.c_str());
+            while (-1 == remove(dumpPath.c_str()) && errno == EINTR);
             goto exit;
         }
     }

src/coreclr/debug/createdump/dumpwriter.cpp

@@ -23,7 +23,7 @@ DumpWriter::~DumpWriter()
 bool
 DumpWriter::OpenDump(const char* dumpFileName)
 {
-    m_fd = open(dumpFileName, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR | S_IRUSR);
+    while (-1 == (m_fd = open(dumpFileName, O_WRONLY|O_CREAT|O_TRUNC, S_IWUSR | S_IRUSR)) && errno == EINTR);
     if (m_fd == -1)
     {
         printf_error("Could not create output file '%s': %s (%d)\n", dumpFileName, strerror(errno), errno);

src/coreclr/debug/debug-pal/unix/twowaypipe.cpp

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#include <errno.h>
 #include <pal.h>
 #include <unistd.h>
 #include <fcntl.h>
@@ -22,19 +23,22 @@ bool TwoWayPipe::CreateServer(const ProcessDescriptor& pd)
     PAL_GetTransportPipeName(m_inPipeName, pd.m_Pid, pd.m_ApplicationGroupId, "in");
     PAL_GetTransportPipeName(m_outPipeName, pd.m_Pid, pd.m_ApplicationGroupId, "out");
 
-    unlink(m_inPipeName);
+    while (-1 == unlink(m_inPipeName) && errno == EINTR);
 
-    if (mkfifo(m_inPipeName, S_IRWXU) == -1)
+    int mkfifo_result;
+    while (-1 == (mkfifo_result = mkfifo(m_inPipeName, S_IRWXU)) && errno == EINTR);
+    if (mkfifo_result == -1)
     {
         return false;
     }
 
 
-    unlink(m_outPipeName);
+    while (-1 == unlink(m_outPipeName) && errno == EINTR);
 
-    if (mkfifo(m_outPipeName, S_IRWXU) == -1)
+    while (-1 == (mkfifo_result = mkfifo(m_outPipeName, S_IRWXU)) && errno == EINTR);
+    if (mkfifo_result == -1)
     {
-        unlink(m_inPipeName);
+        while (-1 == unlink(m_inPipeName) && errno == EINTR);
         return false;
     }
 
@@ -57,13 +61,13 @@ bool TwoWayPipe::Connect(const ProcessDescriptor& pd)
 
     // Pipe opening order is reversed compared to WaitForConnection()
     // in order to avoid deadlock.
-    m_outboundPipe = open(m_outPipeName, O_WRONLY);
+    while (-1 == (m_outboundPipe = open(m_outPipeName, O_WRONLY)) && errno == EINTR);
     if (m_outboundPipe == INVALID_PIPE)
     {
         return false;
     }
 
-    m_inboundPipe = open(m_inPipeName, O_RDONLY);
+    while (-1 == (m_inboundPipe = open(m_inPipeName, O_RDONLY)) && errno == EINTR);
     if (m_inboundPipe == INVALID_PIPE)
     {
         close(m_outboundPipe);
@@ -84,13 +88,13 @@ bool TwoWayPipe::WaitForConnection()
     if (m_state != Created)
         return false;
 
-    m_inboundPipe = open(m_inPipeName, O_RDONLY);
+    while (-1 == (m_inboundPipe = open(m_inPipeName, O_RDONLY)) && errno == EINTR);
     if (m_inboundPipe == INVALID_PIPE)
     {
         return false;
     }
 
-    m_outboundPipe = open(m_outPipeName, O_WRONLY);
+    while (-1 == (m_outboundPipe = open(m_outPipeName, O_WRONLY)) && errno == EINTR);
     if (m_outboundPipe == INVALID_PIPE)
     {
         close(m_inboundPipe);
@@ -113,8 +117,10 @@ int TwoWayPipe::Read(void *buffer, DWORD bufferSize)
     int bytesRead;
     int cb = bufferSize;
 
-    while ((bytesRead = (int)read(m_inboundPipe, buffer, cb)) > 0)
+    while (true)
     {
+        while (-1 == (bytesRead = (int)read(m_inboundPipe, buffer, cb)) && errno == EINTR);
+        if (bytesRead <= 0) break;
         totalBytesRead += bytesRead;
         _ASSERTE(totalBytesRead <= (int)bufferSize);
         if (totalBytesRead >= (int)bufferSize)
@@ -140,8 +146,10 @@ int TwoWayPipe::Write(const void *data, DWORD dataSize)
     int bytesWritten;
     int cb = dataSize;
 
-    while ((bytesWritten = (int)write(m_outboundPipe, data, cb)) > 0)
+    while (true)
     {
+        while (-1 == (bytesWritten = (int)write(m_outboundPipe, data, cb)) && errno == EINTR);
+        if (bytesWritten <= 0) break;
         totalBytesWritten += bytesWritten;
         _ASSERTE(totalBytesWritten <= (int)dataSize);
         if (totalBytesWritten >= (int)dataSize)
@@ -166,8 +174,8 @@ bool TwoWayPipe::Disconnect()
 
     if (m_state == ServerConnected || m_state == Created)
     {
-        unlink(m_inPipeName);
-        unlink(m_outPipeName);
+        while (-1 == unlink(m_inPipeName) && errno == EINTR);
+        while (-1 == unlink(m_outPipeName) && errno == EINTR);
     }
 
     m_state = NotInitialized;
@@ -178,6 +186,6 @@ bool TwoWayPipe::Disconnect()
 // and semaphores when the debugger detects the debuggee process  exited.
 void TwoWayPipe::CleanupTargetProcess()
 {
-    unlink(m_inPipeName);
-    unlink(m_outPipeName);
+    while (-1 == unlink(m_inPipeName) && errno == EINTR);
+    while (-1 == unlink(m_outPipeName) && errno == EINTR);
 }

src/coreclr/gc/unix/cgroup.cpp

@@ -127,7 +127,8 @@ class CGroup
 #else
 
         struct statfs stats;
-        int result = statfs("/sys/fs/cgroup", &stats);
+        int result;
+        while (-1 == (result = statfs("/sys/fs/cgroup", &stats)) && errno == EINTR);
         if (result != 0)
             return 0;
 

src/coreclr/gc/unix/numasupport.cpp

@@ -28,11 +28,19 @@ static int GetNodeNum(const char* path, bool firstOnly)
     struct dirent *entry;
     int result = -1;
 
-    dir = opendir(path);
+    while ((dir = opendir(path)) == nullptr && errno == EINTR);
     if (dir)
     {
-        while ((entry = readdir(dir)) != NULL)
+        while (true)
         {
+            do
+            {
+                errno = 0;
+                entry = readdir(dir);
+            }
+            while (entry == nullptr && errno == EINTR);
+            if (entry == nullptr) break;
+
             if (strncmp(entry->d_name, "node", STRING_LENGTH("node")))
                 continue;
 

src/coreclr/hosts/corerun/corerun.hpp

@@ -443,7 +443,9 @@ namespace pal
     {
         // Check if the specified path exists
         struct stat sb;
-        if (stat(file_path, &sb) == -1)
+        int result;
+        while (-1 == (result = stat(file_path, &sb)) && errno == EINTR);
+        if (result == -1)
         {
             perror(W("Path not found"));
             return false;
@@ -467,12 +469,15 @@ namespace pal
 
     inline bool try_map_file_readonly(const char* path, void** mapped, int64_t* size)
     {
-        int fd = open(path, O_RDONLY);
+        int fd;
+        while (-1 == (fd = open(path, O_RDONLY)) && errno == EINTR);
         if (fd == -1)
             return false;
 
         struct stat buf;
-        if (fstat(fd, &buf) == -1)
+        int fstat_result;
+        while (-1 == (fstat_result = fstat(fd, &buf)) && errno == EINTR);
+        if (fstat_result == -1)
         {
             close(fd);
             return false;
@@ -506,16 +511,26 @@ namespace pal
         assert(ext != nullptr);
         const size_t ext_len = pal::strlen(ext);
 
-        DIR* dir = opendir(directory.c_str());
+        DIR* dir;
+        while ((dir = opendir(directory.c_str())) == nullptr && errno == EINTR);
+
         if (dir == nullptr)
             return {};
 
         stringstream_t file_list;
 
         // For all entries in the directory
         struct dirent* entry;
-        while ((entry = readdir(dir)) != nullptr)
+        while (true)
         {
+            do
+            {
+                errno = 0;
+                entry = readdir(dir);
+            }
+            while (entry == nullptr && errno == EINTR);
+            if (entry == nullptr) break;
+
 #if HAVE_DIRENT_D_TYPE
             int dirEntryType = entry->d_type;
 #else