[lldb] Add missing EINTR handling

[labath]

The "problem" I have with this is that (IIRC) retrying close(2) on EINTR is the *wrong* thing to do on linux (because the fd will be closed anyway, and so we may end up closing someone else's file the second time around). I'll try to dig up more info about that tomorrow.

[mgorny]

In D59606#1436796, @labath wrote:

The "problem" I have with this is that (IIRC) retrying close(2) on EINTR is the *wrong* thing to do on linux (because the fd will be closed anyway, and so we may end up closing someone else's file the second time around). I'll try to dig up more info about that tomorrow.

Just found http://alobbs.com/post/54503240599/close-and-eintr and indeed you're right. While I find that behavior really silly and would consider it a bug, I see that POSIX considers it 'undefined' whether the file is closed or not. I guess I'll have to be more careful when deciding which syscalls to wrap.

[mgorny]

Hmm, I also see that LLVM has signal-safe Process::SafelyCloseFileDescriptor(). Should I use that, or just ignore potential issues with close()?

[mgorny]

Got rid of close() and fclose() wrapping, for now.

[clayborg]

LGTM as long as the test suite is happy

[mgorny]

Covered more callsites.

[labath]

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

255–258 ↗

(On Diff #191641)

IIUC, these only manipulate the options struct, so I don't see how they could fail with EINTR. OTOH, the tcsetattr call below is documented to return EINTR at least on NetBSD http://netbsd.gw.com/cgi-bin/man-cgi?cfsetospeed+3+NetBSD-current.

lldb/tools/debugserver/source/DNB.cpp

173 ↗

(On Diff #191641)

You can't use llvm code from debugserver. I am not really sure what darwin-debug is, but the same may be true for that as well. If I were you, I'd just leave these two alone.

lldb/tools/lldb-server/lldb-platform.cpp

319 ↗

(On Diff #191641)

I don't think this is necessary here with WNOHANG and everything.

[labath]

I think this is fine, except for the things I pointed out inline. As for SafelyCloseFileDescriptor (wow) thing, I think we should use that, given that it's already there. I suggest making a separate patch for that.

[mgorny]

Thanks for the review. Addressed comments.

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

255–258 ↗

(On Diff #191641)

Yeah, that's why I covered it, though it looks surprising to me as well. But looking at the code, it can't happen really, so I'll just revert this.

lldb/tools/lldb-server/lldb-platform.cpp

319 ↗

(On Diff #191641)

Yep, sorry, missed this one.

[labath]

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

255–258 ↗

(On Diff #191641)

I think we misunderstood each other. My expectation would be that these two calls don't need EINTR protection, but the tcsetattr call (line 267) does.

lldb/tools/lldb-server/lldb-platform.cpp

22 ↗

(On Diff #191644)

revert this part too?

[mgorny]

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

255–258 ↗

(On Diff #191641)

I'm not sure if it can happen with TCSANOW but I guess better safe than sorry.

[mgorny]

Applied requested changes.

[mgorny]

Now, the curious thing is that so far I have 2 more test failures with this. I'll investigate closer, maybe it's just flakiness.

[labath]

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

255–258 ↗

(On Diff #191641)

Ah, OK, I see. I am not really familiar with this syscall, so if you are reasonably confident that this particular combo of arguments cannot block (and be interrupted), then I'm fine with leaving the EINTR loop out.

lldb/trunk/source/Host/common/PseudoTerminal.cpp

bool PseudoTerminal::OpenSlave(int oflag, char *error_str, size_t error_len) {
   CloseSlaveFileDescriptor();
 
   // Open the master side of a pseudo terminal
   const char *slave_name = GetSlaveName(error_str, error_len);
 
   if (slave_name == nullptr)
     return false;
 
-  m_slave_fd = ::open(slave_name, oflag);
+  m_slave_fd = llvm::sys::RetryAfterSignal(-1, ::open, slave_name, oflag);
 
   if (m_slave_fd < 0) {
     if (error_str)
       ErrnoToStr(error_str, error_len);
     return false;
   }
 
   return true;

lldb/trunk/source/Host/common/Socket.cpp

 #include "lldb/Host/SocketAddress.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "lldb/Host/common/UDPSocket.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Errno.h"
 
 #ifndef LLDB_DISABLE_POSIX
 #include "lldb/Host/posix/DomainSocket.h"
 
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
if (fd >= 0 && !child_processes_inherit) {
     close(fd);
   }
   return fd;
 #elif defined(SOCK_CLOEXEC) && defined(HAVE_ACCEPT4)
   int flags = 0;
   if (!child_processes_inherit) {
     flags |= SOCK_CLOEXEC;
   }
-  NativeSocket fd = ::accept4(sockfd, addr, addrlen, flags);
+  NativeSocket fd = llvm::sys::RetryAfterSignal(-1, ::accept4,
+      sockfd, addr, addrlen, flags);
 #else
-  NativeSocket fd = ::accept(sockfd, addr, addrlen);
+  NativeSocket fd = llvm::sys::RetryAfterSignal(-1, ::accept,
+      sockfd, addr, addrlen);
 #endif
   if (fd == kInvalidSocketValue)
     SetLastError(error);
   return fd;
 }

lldb/trunk/source/Host/common/TCPSocket.cpp

 
 #include "lldb/Host/common/TCPSocket.h"
 
 #include "lldb/Host/Config.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Log.h"
 
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/raw_ostream.h"
 
 #ifndef LLDB_DISABLE_POSIX
 #include <arpa/inet.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 #endif
 
auto addresses = lldb_private::SocketAddress::GetAddressInfo(
       host_str.c_str(), NULL, AF_UNSPEC, SOCK_STREAM, IPPROTO_TCP);
   for (auto address : addresses) {
     error = CreateSocket(address.GetFamily());
     if (error.Fail())
       continue;
 
     address.SetPort(port);
 
-    if (-1 == ::connect(GetNativeSocket(), &address.sockaddr(),
-                        address.GetLength())) {
+    if (-1 == llvm::sys::RetryAfterSignal(-1, ::connect,
+          GetNativeSocket(), &address.sockaddr(), address.GetLength())) {
       CLOSE_SOCKET(GetNativeSocket());
       continue;
     }
 
     SetOptionNoDelay();
 
     error.Clear();
     return error;

lldb/trunk/source/Host/posix/ConnectionFileDescriptorPosix.cpp

else if ((addr = GetURLAddress(path, FD_SCHEME))) {
 
         // Raw input, disable echo and signals
         options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
 
         // Make sure only one character is needed to return from a read
         options.c_cc[VMIN] = 1;
         options.c_cc[VTIME] = 0;
 
-        ::tcsetattr(fd, TCSANOW, &options);
+        llvm::sys::RetryAfterSignal(-1, ::tcsetattr, fd, TCSANOW, &options);
       }
 
       int flags = ::fcntl(fd, F_GETFL, 0);
       if (flags >= 0) {
         if ((flags & O_NONBLOCK) == 0) {
           flags |= O_NONBLOCK;
           ::fcntl(fd, F_SETFL, flags);
         }

lldb/trunk/source/Host/posix/DomainSocket.cpp

 //===-- DomainSocket.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/DomainSocket.h"
 
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/un.h>
 
 using namespace lldb;
 using namespace lldb_private;
Status DomainSocket::Connect(llvm::StringRef name) {
   socklen_t saddr_un_len;
   if (!SetSockAddr(name, GetNameOffset(), &saddr_un, saddr_un_len))
     return Status("Failed to set socket address");
 
   Status error;
   m_socket = CreateSocket(kDomain, kType, 0, m_child_processes_inherit, error);
   if (error.Fail())
     return error;
-  if (::connect(GetNativeSocket(), (struct sockaddr *)&saddr_un, saddr_un_len) <
-      0)
+  if (llvm::sys::RetryAfterSignal(-1, ::connect, GetNativeSocket(),
+        (struct sockaddr *)&saddr_un, saddr_un_len) < 0)
     SetLastError(error);
 
   return error;
 }
 
 Status DomainSocket::Listen(llvm::StringRef name, int backlog) {
   sockaddr_un saddr_un;
   socklen_t saddr_un_len;

lldb/trunk/source/Host/posix/FileSystem.cpp

 #include <sys/statvfs.h>
 #endif
 
 // lldb Includes
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 const char *FileSystem::DEV_NULL = "/dev/null";
 
 Status FileSystem::Symlink(const FileSpec &src, const FileSpec &dst) {
Status FileSystem::ResolveSymbolicLink(const FileSpec &src, FileSpec &dst) {
   }
 
   dst = FileSpec(real_path);
 
   return Status();
 }
 
 FILE *FileSystem::Fopen(const char *path, const char *mode) {
-  return ::fopen(path, mode);
+  return llvm::sys::RetryAfterSignal(nullptr, ::fopen, path, mode);
 }
 
 int FileSystem::Open(const char *path, int flags, int mode) {
-  return ::open(path, flags, mode);
+  return llvm::sys::RetryAfterSignal(-1, ::open, path, flags, mode);
 }

lldb/trunk/source/Host/posix/LockFilePosix.cpp

 //===-- LockFilePosix.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/LockFilePosix.h"
 
+#include "llvm/Support/Errno.h"
+
 #include <fcntl.h>
 #include <unistd.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 
 Status fileLock(int fd, int cmd, int lock_type, const uint64_t start,
                 const uint64_t len) {
   struct flock fl;
 
   fl.l_type = lock_type;
   fl.l_whence = SEEK_SET;
   fl.l_start = start;
   fl.l_len = len;
   fl.l_pid = ::getpid();
 
   Status error;
-  if (::fcntl(fd, cmd, &fl) == -1)
+  if (llvm::sys::RetryAfterSignal(-1, ::fcntl, fd, cmd, &fl) == -1)
     error.SetErrorToErrno();
 
   return error;
 }
 
 } // namespace
 
 LockFilePosix::LockFilePosix(int fd) : LockFileBase(fd) {}

lldb/trunk/source/Host/posix/PipePosix.cpp

 //===-- PipePosix.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/posix/PipePosix.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/SelectHelper.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 
 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
 #ifndef _GLIBCXX_USE_NANOSLEEP
 #define _GLIBCXX_USE_NANOSLEEP
 #endif
 #endif
 
Status PipePosix::OpenAsReader(llvm::StringRef name,
   if (CanRead() || CanWrite())
     return Status("Pipe is already opened");
 
   int flags = O_RDONLY | O_NONBLOCK;
   if (!child_process_inherit)
     flags |= O_CLOEXEC;
 
   Status error;
-  int fd = ::open(name.data(), flags);
+  int fd = llvm::sys::RetryAfterSignal(-1, ::open, name.data(), flags);
   if (fd != -1)
     m_fds[READ] = fd;
   else
     error.SetErrorToErrno();
 
   return error;
 }
 
if (timeout != microseconds::zero()) {
         return Status("timeout exceeded - reader hasn't opened so far");
     }
 
     errno = 0;
     int fd = ::open(name.data(), flags);
     if (fd == -1) {
       const auto errno_copy = errno;
       // We may get ENXIO if a reader side of the pipe hasn't opened yet.
-      if (errno_copy != ENXIO)
+      if (errno_copy != ENXIO && errno_copy != EINTR)
         return Status(errno_copy, eErrorTypePOSIX);
 
       std::this_thread::sleep_for(
           milliseconds(OPEN_WRITER_SLEEP_TIMEOUT_MSECS));
     } else {
       m_fds[WRITE] = fd;
     }
   }
while (error.Success()) {
     error = select_helper.Select();
     if (error.Success()) {
       auto result = ::read(fd, reinterpret_cast<char *>(buf) + bytes_read,
                            size - bytes_read);
       if (result != -1) {
         bytes_read += result;
         if (bytes_read == size || result == 0)
           break;
+      } else if (errno == EINTR) {
+        continue;
       } else {
         error.SetErrorToErrno();
         break;
       }
     }
   }
   return error;
 }
while (error.Success()) {
     if (error.Success()) {
       auto result =
           ::write(fd, reinterpret_cast<const char *>(buf) + bytes_written,
                   size - bytes_written);
       if (result != -1) {
         bytes_written += result;
         if (bytes_written == size)
           break;
+      } else if (errno == EINTR) {
+        continue;
       } else {
         error.SetErrorToErrno();
       }
     }
   }
   return error;
 }

lldb/trunk/source/Host/posix/ProcessLauncherPosixFork.cpp

if (info.GetFlags().Test(lldb::eLaunchFlagDisableASLR)) {
     if (value == -1)
       ExitWithError(error_fd, "personality set");
   }
 #endif
 }
 
 static void DupDescriptor(int error_fd, const FileSpec &file_spec, int fd,
                           int flags) {
-  int target_fd = ::open(file_spec.GetCString(), flags, 0666);
+  int target_fd = llvm::sys::RetryAfterSignal(-1, ::open,
+      file_spec.GetCString(), flags, 0666);
 
   if (target_fd == -1)
     ExitWithError(error_fd, "DupDescriptor-open");
 
   if (target_fd == fd)
     return;
 
   if (::dup2(target_fd, fd) == -1)
ProcessLauncherPosixFork::LaunchProcess(const ProcessLaunchInfo &launch_info,
   char buf[1000];
   int r = read(pipe.GetReadFileDescriptor(), buf, sizeof buf);
 
   if (r == 0)
     return HostProcess(pid); // No error. We're done.
 
   error.SetErrorString(buf);
 
-  waitpid(pid, nullptr, 0);
+  llvm::sys::RetryAfterSignal(-1, waitpid, pid, nullptr, 0);
 
   return HostProcess();
 }

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

if (tid != LLDB_INVALID_THREAD_ID) {
     DetachOperation op(error);
     DoOperation(&op);
   }
   return error;
 }
 
 bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
                                    int flags) {
-  int target_fd = open(file_spec.GetCString(), flags, 0666);
+  int target_fd = llvm::sys::RetryAfterSignal(-1, open,
+      file_spec.GetCString(), flags, 0666);
 
   if (target_fd == -1)
     return false;
 
   if (dup2(target_fd, fd) == -1)
     return false;
 
   return (close(target_fd) == -1) ? false : true;

lldb/trunk/source/Plugins/Process/Linux/SingleStepCheck.cpp

void LLVM_ATTRIBUTE_NORETURN Child() {
   }
 }
 
 struct ChildDeleter {
   ::pid_t pid;
 
   ~ChildDeleter() {
     int status;
-    kill(pid, SIGKILL);            // Kill the child.
-    waitpid(pid, &status, __WALL); // Pick up the remains.
+    // Kill the child.
+    kill(pid, SIGKILL);
+    // Pick up the remains.
+    llvm::sys::RetryAfterSignal(-1, waitpid, pid, &status, __WALL);
   }
 };
 
 bool WorkaroundNeeded() {
   // We shall spawn a child, and use it to verify the debug capabilities of the
   // cpu. We shall iterate through the cpus, bind the child to each one in
   // turn, and verify that single-stepping works on that cpu. A workaround is
   // needed if we find at least one broken cpu.
bool WorkaroundNeeded() {
   if (sched_getaffinity(child_pid, sizeof available_cpus, &available_cpus) ==
       -1) {
     LLDB_LOG(log, "failed to get available cpus: {0}",
              Status(errno, eErrorTypePOSIX));
     return false;
   }
 
   int status;
-  ::pid_t wpid = waitpid(child_pid, &status, __WALL);
+  ::pid_t wpid = llvm::sys::RetryAfterSignal(-1, waitpid,
+      child_pid, &status, __WALL);
   if (wpid != child_pid || !WIFSTOPPED(status)) {
     LLDB_LOG(log, "waitpid() failed (status = {0:x}): {1}", status,
              Status(errno, eErrorTypePOSIX));
     return false;
   }
 
   unsigned cpu;
   for (cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
for (cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
     int status;
     Status error =
         NativeProcessLinux::PtraceWrapper(PTRACE_SINGLESTEP, child_pid);
     if (error.Fail()) {
       LLDB_LOG(log, "single step failed: {0}", error);
       break;
     }
 
-    wpid = waitpid(child_pid, &status, __WALL);
+    wpid = llvm::sys::RetryAfterSignal(-1, waitpid,
+        child_pid, &status, __WALL);
     if (wpid != child_pid || !WIFSTOPPED(status)) {
       LLDB_LOG(log, "waitpid() failed (status = {0:x}): {1}", status,
                Status(errno, eErrorTypePOSIX));
       break;
     }
     if (WSTOPSIG(status) != SIGTRAP) {
       LLDB_LOG(log, "single stepping on cpu {0} failed with status {1:x}", cpu,
                status);

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

Status NativeProcessNetBSD::Attach() {
   // An attach will cause the thread to stop with a SIGSTOP.
   Status status = PtraceWrapper(PT_ATTACH, m_pid);
   if (status.Fail())
     return status;
 
   int wstatus;
   // Need to use WALLSIG otherwise we receive an error with errno=ECHLD At this
   // point we should have a thread stopped if waitpid succeeds.
-  if ((wstatus = waitpid(m_pid, NULL, WALLSIG)) < 0)
+  if ((wstatus = llvm::sys::RetryAfterSignal(-1, waitpid,
+          m_pid, NULL, WALLSIG)) < 0)
     return Status(errno, eErrorTypePOSIX);
 
   /* Initialize threads */
   status = ReinitializeThreads();
   if (status.Fail())
     return status;
 
   for (const auto &thread : m_threads)

lldb/trunk/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

 #include "ScriptInterpreterPython.h"
 
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Errno.h"
 
 #include <stdio.h>
 
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 void StructuredPythonObject::Dump(Stream &s, bool pretty_print) const {
   s << "Python Obj: 0x" << GetValue();
 }
 
 //----------------------------------------------------------------------
 // PythonObject
 //----------------------------------------------------------------------
 
 void PythonObject::Dump(Stream &strm) const {
   if (m_py_obj) {
-    FILE *file = ::tmpfile();
+    FILE *file = llvm::sys::RetryAfterSignal(nullptr, ::tmpfile);
     if (file) {
       ::PyObject_Print(m_py_obj, file, 0);
       const long length = ftell(file);
       if (length) {
         ::rewind(file);
         std::vector<char> file_contents(length, '\0');
         const size_t length_read =
             ::fread(file_contents.data(), 1, file_contents.size(), file);

lldb/trunk/tools/lldb-mi/MIUtilFileStd.cpp

 #include <string.h>
 
 // In-house headers:
 #include "MICmnResources.h"
 #include "MIUtilFileStd.h"
 #include "lldb/Host/FileSystem.h"
 
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Errno.h"
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMIUtilFileStd constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
bool CMIUtilFileStd::CreateWrite(const CMIUtilString &vFileNamePath,
   }
 
   // File is already open so exit
   if (m_pFileHandle != nullptr)
     return MIstatus::success;
 
 #if !defined(_MSC_VER)
   // Open with 'write' and 'binary' mode
-  m_pFileHandle = ::fopen(vFileNamePath.c_str(), "wb");
+  m_pFileHandle = llvm::sys::RetryAfterSignal(nullptr, ::fopen,
+      vFileNamePath.c_str(), "wb");
 #else
   // Open a file with exclusive write and shared read permissions
   std::wstring path;
   if (llvm::ConvertUTF8toWide(vFileNamePath.c_str(), path))
     m_pFileHandle = ::_wfsopen(path.c_str(), L"wb", _SH_DENYWR);
   else {
     errno = EINVAL;
     m_pFileHandle = nullptr;

 //          False - Not found.
 // Throws:  None.
 //--
 bool CMIUtilFileStd::IsFileExist(const CMIUtilString &vFileNamePath) const {
   if (vFileNamePath.empty())
     return false;
 
   FILE *pTmp = nullptr;
-  pTmp = ::fopen(vFileNamePath.c_str(), "wb");
+  pTmp = llvm::sys::RetryAfterSignal(nullptr, ::fopen,
+      vFileNamePath.c_str(), "wb");
   if (pTmp != nullptr) {
     ::fclose(pTmp);
     return true;
   }
 
   return false;
 }
 

lldb/trunk/tools/lldb-vscode/lldb-vscode.cpp

 #include <map>
 #include <memory>
 #include <mutex>
 #include <set>
 #include <sstream>
 #include <thread>
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "VSCode.h"
 
 #if defined(_WIN32)
if (sockfd < 0) {
     serv_addr.sin_port = htons(portno);
     if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
       if (g_vsc.log)
         *g_vsc.log << "error: binding socket (" << strerror(errno) << ")"
                    << std::endl;
     } else {
       listen(sockfd, 5);
       socklen_t clilen = sizeof(cli_addr);
-      newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
+      newsockfd = llvm::sys::RetryAfterSignal(-1, accept,
+          sockfd, (struct sockaddr *)&cli_addr, &clilen);
       if (newsockfd < 0)
         if (g_vsc.log)
           *g_vsc.log << "error: accept (" << strerror(errno) << ")"
                      << std::endl;
     }
 #if defined(_WIN32)
     closesocket(sockfd);
 #else

 // }
 //----------------------------------------------------------------------
 void request_initialize(const llvm::json::Object &request) {
   g_vsc.debugger = lldb::SBDebugger::Create(true /*source_init_files*/);
   // Create an empty target right away since we might get breakpoint requests
   // before we are given an executable to launch in a "launch" request, or a
   // executable when attaching to a process by process ID in a "attach"
   // request.
-  FILE *out = fopen(dev_null_path, "w");
+  FILE *out = llvm::sys::RetryAfterSignal(nullptr, fopen, dev_null_path, "w");
   if (out) {
     // Set the output and error file handles to redirect into nothing otherwise
     // if any code in LLDB prints to the debugger file handles, the output and
     // error file handles are initialized to STDOUT and STDERR and any output
     // will kill our debug session.
     g_vsc.debugger.SetOutputFileHandle(out, true);
     g_vsc.debugger.SetErrorFileHandle(out, false);
   }