[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–259

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–259

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–259

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–259

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–259

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/source/Core/Disassembler.cpp

 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "lldb/lldb-private-interfaces.h"
 #include "lldb/lldb-private-types.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Compiler.h"
+#include "llvm/Support/Errno.h"
 
 #include <cstdint>
 #include <cstring>
 #include <utility>
 
 #include <assert.h>
 
 #define DEFAULT_DISASM_BYTE_SIZE 32
out_stream->Printf(
         "Instruction::TestEmulation: Attempt to open test file failed.");
     return false;
   }
 
   char buffer[256];
   if (!fgets(buffer, 255, test_file)) {
     out_stream->Printf(
         "Instruction::TestEmulation: Error reading first line of test file.\n");
-    fclose(test_file);
+    llvm::sys::RetryAfterSignal(EOF, fclose, test_file);
     return false;
   }
 
   if (strncmp(buffer, "InstructionEmulationState={", 27) != 0) {
     out_stream->Printf("Instructin::TestEmulation: Test file does not contain "
                        "emulation state dictionary\n");
-    fclose(test_file);
+    llvm::sys::RetryAfterSignal(EOF, fclose, test_file);
     return false;
   }
 
   // Read all the test information from the test file into an
   // OptionValueDictionary.
 
   OptionValueSP data_dictionary_sp(ReadDictionary(test_file, out_stream));
   if (!data_dictionary_sp) {
     out_stream->Printf(
         "Instruction::TestEmulation:  Error reading Dictionary Object.\n");
-    fclose(test_file);
+    llvm::sys::RetryAfterSignal(EOF, fclose, test_file);
     return false;
   }
 
-  fclose(test_file);
+  llvm::sys::RetryAfterSignal(EOF, fclose, test_file);
 
   OptionValueDictionary *data_dictionary =
       data_dictionary_sp->GetAsDictionary();
   static ConstString description_key("assembly_string");
   static ConstString triple_key("triple");
 
   OptionValueSP value_sp = data_dictionary->GetValueForKey(description_key);
 

lldb/source/Host/common/File.cpp

if (fd != kInvalidDescriptor) {
     error.SetErrorString("invalid file descriptor");
   }
   return 0;
 }
 
 Status File::Close() {
   Status error;
   if (StreamIsValid() && m_own_stream) {
-    if (::fclose(m_stream) == EOF)
+    if (llvm::sys::RetryAfterSignal(EOF, ::fclose, m_stream) == EOF)
       error.SetErrorToErrno();
   }
 
   if (DescriptorIsValid() && m_should_close_fd) {
-    if (::close(m_descriptor) != 0)
+    if (llvm::sys::RetryAfterSignal(-1, ::close, m_descriptor) != 0)
       error.SetErrorToErrno();
   }
   m_descriptor = kInvalidDescriptor;
   m_stream = kInvalidStream;
   m_options = 0;
   m_own_stream = false;
   m_should_close_fd = false;
   m_is_interactive = eLazyBoolCalculate;

lldb/source/Host/common/MainLoop.cpp

 //===-- MainLoop.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 "llvm/Config/llvm-config.h"
 
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/Status.h"
+
+#include "llvm/Support/Errno.h"
+
 #include <algorithm>
 #include <cassert>
 #include <cerrno>
 #include <csignal>
 #include <time.h>
 #include <vector>
 
 // Multiplexing is implemented using kqueue on systems that support it (BSD

 MainLoop::MainLoop() {
 #if HAVE_SYS_EVENT_H
   m_kqueue = kqueue();
   assert(m_kqueue >= 0);
 #endif
 }
 MainLoop::~MainLoop() {
 #if HAVE_SYS_EVENT_H
-  close(m_kqueue);
+  llvm::sys::RetryAfterSignal(-1, close, m_kqueue);
 #endif
   assert(m_read_fds.size() == 0);
   assert(m_signals.size() == 0);
 }
 
 MainLoop::ReadHandleUP MainLoop::RegisterReadObject(const IOObjectSP &object_sp,
                                                     const Callback &callback,
                                                     Status &error) {

lldb/source/Host/common/PseudoTerminal.cpp

PseudoTerminal::~PseudoTerminal() {
   CloseSlaveFileDescriptor();
 }
 
 //----------------------------------------------------------------------
 // Close the master file descriptor if it is valid.
 //----------------------------------------------------------------------
 void PseudoTerminal::CloseMasterFileDescriptor() {
   if (m_master_fd >= 0) {
-    ::close(m_master_fd);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_master_fd);
     m_master_fd = invalid_fd;
   }
 }
 
 //----------------------------------------------------------------------
 // Close the slave file descriptor if it is valid.
 //----------------------------------------------------------------------
 void PseudoTerminal::CloseSlaveFileDescriptor() {
   if (m_slave_fd >= 0) {
-    ::close(m_slave_fd);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_slave_fd);
     m_slave_fd = invalid_fd;
   }
 }
 
 //----------------------------------------------------------------------
 // Open the first available pseudo terminal with OFLAG as the permissions. The
 // file descriptor is stored in this object and can be accessed with the
 // MasterFileDescriptor() accessor. The ownership of the master file descriptor

lldb/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>
Status Socket::Close() {
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log)
     log->Printf("%p Socket::Close (fd = %i)", static_cast<void *>(this),
                 m_socket);
 
 #if defined(_WIN32)
   bool success = !!closesocket(m_socket);
 #else
-  bool success = !!::close(m_socket);
+  bool success = !!llvm::sys::RetryAfterSignal(-1, ::close, m_socket);
 #endif
   // A reference to a FD was passed in, set it to an invalid value
   m_socket = kInvalidSocketValue;
   if (!success) {
     SetLastError(error);
   }
 
   return error;
#if defined(ANDROID_USE_ACCEPT_WORKAROUND)
   // available in older kernels. Using an older libc would fix this issue, but
   // introduce other ones, as the old libraries were quite buggy.
   int fd = syscall(__NR_accept, sockfd, addr, addrlen);
   if (fd >= 0 && !child_processes_inherit) {
     int flags = ::fcntl(fd, F_GETFD);
     if (flags != -1 && ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1)
       return fd;
     SetLastError(error);
-    close(fd);
+    llvm::sys::RetryAfterSignal(-1, 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/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/source/Host/posix/ConnectionFileDescriptorPosix.cpp

else if ((addr = GetURLAddress(path, FD_SCHEME))) {
       }
 
       if (::isatty(fd)) {
         // Set up serial terminal emulation
         struct termios options;
         ::tcgetattr(fd, &options);
 
         // Set port speed to maximum
-        ::cfsetospeed(&options, B115200);
-        ::cfsetispeed(&options, B115200);
+        llvm::sys::RetryAfterSignal(-1, ::cfsetospeed,
+            &options, B115200);
+        llvm::sys::RetryAfterSignal(-1, ::cfsetispeed,
+            &options, B115200);
 
         // 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);

lldb/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/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
 

 }
 
 bool PipePosix::CanWrite() const {
   return m_fds[WRITE] != PipePosix::kInvalidDescriptor;
 }
 
 void PipePosix::CloseReadFileDescriptor() {
   if (CanRead()) {
-    close(m_fds[READ]);
+    llvm::sys::RetryAfterSignal(-1, close, m_fds[READ]);
     m_fds[READ] = PipePosix::kInvalidDescriptor;
   }
 }
 
 void PipePosix::CloseWriteFileDescriptor() {
   if (CanWrite()) {
-    close(m_fds[WRITE]);
+    llvm::sys::RetryAfterSignal(-1, close, m_fds[WRITE]);
     m_fds[WRITE] = PipePosix::kInvalidDescriptor;
   }
 }
 
 Status PipePosix::ReadWithTimeout(void *buf, size_t size,
                                   const std::chrono::microseconds &timeout,
                                   size_t &bytes_read) {
   bytes_read = 0;

lldb/source/Host/posix/ProcessLauncherPosixFork.cpp

if (target_fd == -1)
     ExitWithError(error_fd, "DupDescriptor-open");
 
   if (target_fd == fd)
     return;
 
   if (::dup2(target_fd, fd) == -1)
     ExitWithError(error_fd, "DupDescriptor-dup2");
 
-  ::close(target_fd);
+  llvm::sys::RetryAfterSignal(-1, ::close, target_fd);
   return;
 }
 
 static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
                                               const ProcessLaunchInfo &info) {
   if (info.GetFlags().Test(eLaunchFlagLaunchInSeparateProcessGroup)) {
     if (setpgid(0, 0) != 0)
       ExitWithError(error_fd, "setpgid");
   }
 
   for (size_t i = 0; i < info.GetNumFileActions(); ++i) {
     const FileAction &action = *info.GetFileActionAtIndex(i);
     switch (action.GetAction()) {
     case FileAction::eFileActionClose:
-      if (close(action.GetFD()) != 0)
+      if (llvm::sys::RetryAfterSignal(-1, close, action.GetFD()) != 0)
         ExitWithError(error_fd, "close");
       break;
     case FileAction::eFileActionDuplicate:
       if (dup2(action.GetFD(), action.GetActionArgument()) == -1)
         ExitWithError(error_fd, "dup2");
       break;
     case FileAction::eFileActionOpen:
       DupDescriptor(error_fd, action.GetFileSpec(), action.GetFD(),
if (setgid(getgid()) != 0)
       ExitWithError(error_fd, "setgid");
 
     // HACK:
     // Close everything besides stdin, stdout, and stderr that has no file
     // action to avoid leaking. Only do this when debugging, as elsewhere we
     // actually rely on passing open descriptors to child processes.
     for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
       if (!info.GetFileActionForFD(fd) && fd != error_fd)
-        close(fd);
+        llvm::sys::RetryAfterSignal(-1, close, fd);
 
     // Start tracing this child that is about to exec.
     if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1)
       ExitWithError(error_fd, "ptrace");
   }
 
   // Execute.  We should never return...
   execve(argv[0], const_cast<char *const *>(argv), envp);

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

bool ProcessMonitor::DupDescriptor(const FileSpec &file_spec, int fd,
   int target_fd = 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;
+  return (llvm::sys::RetryAfterSignal(-1, close, target_fd) == -1) ? false : true;
 }
 
 void ProcessMonitor::StopMonitoringChildProcess() {
   if (m_monitor_thread.IsJoinable()) {
     m_monitor_thread.Cancel();
     m_monitor_thread.Join(nullptr);
     m_monitor_thread.Reset();
   }
 }
 
 void ProcessMonitor::StopMonitor() {
   StopMonitoringChildProcess();
   StopOpThread();
   sem_destroy(&m_operation_pending);
   sem_destroy(&m_operation_done);
   if (m_terminal_fd >= 0) {
-    close(m_terminal_fd);
+    llvm::sys::RetryAfterSignal(-1, close, m_terminal_fd);
     m_terminal_fd = -1;
   }
 }
 
 // FIXME: On Linux, when a new thread is created, we receive to notifications,
 // (1) a SIGTRAP|PTRACE_EVENT_CLONE from the main process thread with the child
 // thread id as additional information, and (2) a SIGSTOP|SI_USER from the new
 // child thread indicating that it has is stopped because we attached. We have

lldb/source/Plugins/Process/Linux/ProcessorTrace.h

 //===-- ProcessorTrace.h -------------------------------------- -*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessorTrace_H_
 #define liblldb_ProcessorTrace_H_
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/Support/Errno.h"
 
 #include <linux/perf_event.h>
 #include <sys/mman.h>
 #include <unistd.h>
 
 namespace lldb_private {
 
 namespace process_linux {
class ProcessorTraceMonitor {
 
   public:
     file_close() = default;
     void operator()(int *ptr) {
       if (ptr == nullptr)
         return;
       if (*ptr == -1)
         return;
-      close(*ptr);
+      llvm::sys::RetryAfterSignal(-1, close, *ptr);
       std::default_delete<int>()(ptr);
     }
   };
 
   std::unique_ptr<perf_event_mmap_page, munmap_delete> m_mmap_meta;
   std::unique_ptr<uint8_t, munmap_delete> m_mmap_aux;
   std::unique_ptr<int, file_close> m_fd;
 

lldb/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);
+            llvm::sys::RetryAfterSignal(0, ::fread,
+                file_contents.data(), 1, file_contents.size(), file);
         if (length_read > 0)
           strm.Write(file_contents.data(), length_read);
       }
-      ::fclose(file);
+      llvm::sys::RetryAfterSignal(EOF, ::fclose, file);
     }
   } else
     strm.PutCString("NULL");
 }
 
 PyObjectType PythonObject::GetObjectType() const {
   if (!IsAllocated())
     return PyObjectType::None;

lldb/tools/darwin-debug/darwin-debug.cpp

 #include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/un.h>
 
 #include <string>
 
+#include "llvm/Support/Errno.h"
+
 #ifndef _POSIX_SPAWN_DISABLE_ASLR
 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
 #endif
 
 #define streq(a, b) strcmp(a, b) == 0
 
 static struct option g_long_options[] = {
     {"arch", required_argument, NULL, 'a'},
#endif
   }
 
   saddr_un.sun_family = AF_UNIX;
   ::strncpy(saddr_un.sun_path, unix_socket_name.c_str(),
             sizeof(saddr_un.sun_path) - 1);
   saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
   saddr_un.sun_len = SUN_LEN(&saddr_un);
 
-  if (::connect(s, (struct sockaddr *)&saddr_un, SUN_LEN(&saddr_un)) < 0) {
+  if (llvm::sys::RetryAfterSignal(-1, ::connect, s,
+        (struct sockaddr *)&saddr_un, SUN_LEN(&saddr_un)) < 0) {
     perror("error: connect (socket, &saddr_un, saddr_un_len)");
     exit(1);
   }
 
   // We were able to connect to the socket, now write our PID so whomever
   // launched us will know this process's ID
   char pid_str[64];
   const int pid_str_len =
       ::snprintf(pid_str, sizeof(pid_str), "%i", ::getpid());
   const int bytes_sent = ::send(s, pid_str, pid_str_len, 0);
 
   if (pid_str_len != bytes_sent) {
     perror("error: send (s, pid_str, pid_str_len, 0)");
     exit(1);
   }
 
   // We are done with the socket
-  close(s);
+  llvm::sys::RetryAfterSignal(-1, close, s);
 
   system("clear");
   printf("Launching: '%s'\n", argv[0]);
   if (working_dir.empty()) {
     char cwd[PATH_MAX];
     const char *cwd_ptr = getcwd(cwd, sizeof(cwd));
     printf("Working directory: '%s'\n", cwd_ptr);
   } else {

lldb/tools/debugserver/source/MacOSX/MachProcess.h

 #include "MachTask.h"
 #include "MachThreadList.h"
 #include "MachVMMemory.h"
 #include "PThreadCondition.h"
 #include "PThreadEvent.h"
 #include "PThreadMutex.h"
 #include "ThreadInfo.h"
 
+#include "llvm/Support/Errno.h"
+
 class DNBThreadResumeActions;
 
 class MachProcess {
 public:
   //----------------------------------------------------------------------
   // Constructors and Destructors
   //----------------------------------------------------------------------
   MachProcess();
#endif // WITH_SPRINGBOARD
   int GetStdinFileDescriptor() const { return m_child_stdin; }
   int GetStdoutFileDescriptor() const { return m_child_stdout; }
   int GetStderrFileDescriptor() const { return m_child_stderr; }
   void AppendSTDOUT(char *s, size_t len);
   size_t GetAvailableSTDOUT(char *buf, size_t buf_size);
   size_t GetAvailableSTDERR(char *buf, size_t buf_size);
   void CloseChildFileDescriptors() {
     if (m_child_stdin >= 0) {
-      ::close(m_child_stdin);
+      llvm::sys::RetryAfterSignal(-1, ::close, m_child_stdin);
       m_child_stdin = -1;
     }
     if (m_child_stdout >= 0) {
-      ::close(m_child_stdout);
+      llvm::sys::RetryAfterSignal(-1, ::close, m_child_stdout);
       m_child_stdout = -1;
     }
     if (m_child_stderr >= 0) {
-      ::close(m_child_stderr);
+      llvm::sys::RetryAfterSignal(-1, ::close, m_child_stderr);
       m_child_stderr = -1;
     }
   }
 
   void CalculateBoardStatus();
 
   bool ProcessUsingBackBoard();
 

lldb/tools/debugserver/source/PseudoTerminal.cpp

 //===-- PseudoTerminal.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
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Greg Clayton on 1/8/08.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PseudoTerminal.h"
+
+#include "llvm/Support/Errno.h"
+
 #include <stdlib.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 
 //----------------------------------------------------------------------
 // PseudoTerminal constructor
 //----------------------------------------------------------------------
 PseudoTerminal::PseudoTerminal()
PseudoTerminal::~PseudoTerminal() {
   CloseSlave();
 }
 
 //----------------------------------------------------------------------
 // Close the master file descriptor if it is valid.
 //----------------------------------------------------------------------
 void PseudoTerminal::CloseMaster() {
   if (m_master_fd > 0) {
-    ::close(m_master_fd);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_master_fd);
     m_master_fd = invalid_fd;
   }
 }
 
 //----------------------------------------------------------------------
 // Close the slave file descriptor if it is valid.
 //----------------------------------------------------------------------
 void PseudoTerminal::CloseSlave() {
   if (m_slave_fd > 0) {
-    ::close(m_slave_fd);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_slave_fd);
     m_slave_fd = invalid_fd;
   }
 }
 
 //----------------------------------------------------------------------
 // Open the first available pseudo terminal with OFLAG as the
 // permissions. The file descriptor is store in the m_master_fd member
 // variable and can be accessed via the MasterFD() or ReleaseMasterFD()

lldb/tools/debugserver/source/RNBSocket.cpp

 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <sys/event.h>
 #include <termios.h>
 #include <vector>
 
 #include "lldb/Host/SocketAddress.h"
+#include "llvm/Support/Errno.h"
 
 #ifdef WITH_LOCKDOWN
 #include "lockdown.h"
 #endif
 
 /* Once we have a RNBSocket object with a port # specified,
    this function is called to wait for an incoming connection.
    This function blocks while waiting for that connection.  */
for (int i = 0; i < num_events; ++i) {
       auto sock_fd = event_list[i].ident;
       auto socket_pair = sockets.find(sock_fd);
       if (socket_pair == sockets.end())
         continue;
 
       lldb_private::SocketAddress &addr_in = socket_pair->second;
       lldb_private::SocketAddress accept_addr;
       socklen_t sa_len = accept_addr.GetMaxLength();
-      m_fd = ::accept(sock_fd, &accept_addr.sockaddr(), &sa_len);
+      m_fd = llvm::sys::RetryAfterSignal(-1, ::accept,
+          sock_fd, &accept_addr.sockaddr(), &sa_len);
 
       if (m_fd == -1) {
         err.SetError(errno, DNBError::POSIX);
         err.LogThreaded("error: Socket accept failed.");
       }
 
       if (addr_in.IsAnyAddr())
         accept_connection = true;
       else {
         if (accept_addr == addr_in)
           accept_connection = true;
         else {
-          ::close(m_fd);
+          llvm::sys::RetryAfterSignal(-1, ::close, m_fd);
           m_fd = -1;
           ::fprintf(
               stderr,
               "error: rejecting incoming connection from %s (expecting %s)\n",
               accept_addr.GetIPAddress().c_str(),
               addr_in.GetIPAddress().c_str());
           DNBLogThreaded("error: rejecting connection from %s (expecting %s)\n",
                          accept_addr.GetIPAddress().c_str(),
for (auto address : addresses) {
     if (m_fd == -1)
       continue;
 
     // Enable local address reuse
     SetSocketOption(m_fd, SOL_SOCKET, SO_REUSEADDR, 1);
 
     address.SetPort(port);
 
-    if (-1 == ::connect(m_fd, &address.sockaddr(), address.GetLength())) {
+    if (-1 == llvm::sys::RetryAfterSignal(-1, ::connect, m_fd,
+          &address.sockaddr(), address.GetLength())) {
       Disconnect(false);
       continue;
     }
     SetSocketOption(m_fd, IPPROTO_TCP, TCP_NODELAY, 1);
 
     result = rnb_success;
     break;
   }
rnb_err_t RNBSocket::Write(const void *buffer, size_t length) {
 
   return rnb_success;
 }
 
 rnb_err_t RNBSocket::ClosePort(int &fd, bool save_errno) {
   int close_err = 0;
   if (fd > 0) {
     errno = 0;
-    close_err = close(fd);
+    close_err = llvm::sys::RetryAfterSignal(-1, close, fd);
     fd = -1;
   }
   return close_err != 0 ? rnb_err : rnb_success;
 }

lldb/tools/debugserver/source/debugserver.cpp

if (unix_socket_name && unix_socket_name[0]) {
     }
 
     saddr_un.sun_family = AF_UNIX;
     ::strlcpy(saddr_un.sun_path, unix_socket_name,
               sizeof(saddr_un.sun_path) - 1);
     saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
     saddr_un.sun_len = SUN_LEN(&saddr_un);
 
-    if (::connect(s, (struct sockaddr *)&saddr_un,
-                  static_cast<socklen_t>(SUN_LEN(&saddr_un))) < 0) {
+    if (llvm::sys::RetryAfterSignal(-1, ::connect, s,
+          (struct sockaddr *)&saddr_un,
       perror("error: connect (socket, &saddr_un, saddr_un_len)");
       exit(1);
     }
 
     //::printf ("connect () sucess!!\n");
 
     // We were able to connect to the socket, now write our PID so whomever
     // launched us will know this process's ID
     RNBLogSTDOUT("Listening to port %i...\n", port);
 
     char pid_str[64];
     const int pid_str_len = ::snprintf(pid_str, sizeof(pid_str), "%u", port);
     const ssize_t bytes_sent = ::send(s, pid_str, pid_str_len, 0);
 
     if (pid_str_len != bytes_sent) {
       perror("error: send (s, pid_str, pid_str_len, 0)");
       exit(1);
     }
 
     //::printf ("send () sucess!!\n");
 
     // We are done with the socket
-    close(s);
+    llvm::sys::RetryAfterSignal(-1, close, s);
   }
 }
 
 static void PortWasBoundCallbackNamedPipe(const void *baton, uint16_t port) {
   const char *named_pipe = (const char *)baton;
   if (named_pipe && named_pipe[0]) {
     int fd = ::open(named_pipe, O_WRONLY);
     if (fd > -1) {
       char port_str[64];
       const ssize_t port_str_len =
           ::snprintf(port_str, sizeof(port_str), "%u", port);
       // Write the port number as a C string with the NULL terminator
       ::write(fd, port_str, port_str_len + 1);
-      close(fd);
+      llvm::sys::RetryAfterSignal(-1, close, fd);
     }
   }
 }
 
 static int ConnectRemote(RNBRemote *remote, const char *host, int port,
                          bool reverse_connect, const char *named_pipe_path,
                          const char *unix_socket_name) {
   if (!remote->Comm().IsConnected()) {

lldb/tools/driver/Driver.cpp

 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBLanguageRuntime.h"
 #include "lldb/API/SBReproducer.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/Errno.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <algorithm>
if (err == 0) {
     } else if (static_cast<size_t>(nrwr) == commands_size) {
 // Close the write end of the pipe so when we give the read end to
 // the debugger/command interpreter it will exit when it consumes all
 // of the data
 #ifdef _WIN32
       _close(fds[WRITE]);
       fds[WRITE] = -1;
 #else
-      close(fds[WRITE]);
+      llvm::sys::RetryAfterSignal(-1, close, fds[WRITE]);
       fds[WRITE] = -1;
 #endif
       // Now open the read file descriptor in a FILE * that we can give to
       // the debugger as an input handle
       commands_file = fdopen(fds[READ], "r");
       if (commands_file != nullptr) {
         fds[READ] = -1; // The FILE * 'commands_file' now owns the read
                         // descriptor Hand ownership if the FILE * over to the
void CleanupAfterCommandSourcing(int fds[2]) {
   enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 
   // Close any pipes that we still have ownership of
   if (fds[WRITE] != -1) {
 #ifdef _WIN32
     _close(fds[WRITE]);
     fds[WRITE] = -1;
 #else
-    close(fds[WRITE]);
+    llvm::sys::RetryAfterSignal(-1, close, fds[WRITE]);
     fds[WRITE] = -1;
 #endif
   }
 
   if (fds[READ] != -1) {
 #ifdef _WIN32
     _close(fds[READ]);
     fds[READ] = -1;
 #else
-    close(fds[READ]);
+    llvm::sys::RetryAfterSignal(-1, close, fds[READ]);
     fds[READ] = -1;
 #endif
   }
 }
 
 std::string EscapeString(std::string arg) {
   std::string::size_type pos = 0;
   while ((pos = arg.find_first_of("\"\\", pos)) != std::string::npos) {
if (m_option_data.m_repl) {
 
     if (go_interactive) {
       m_debugger.SetInputFileHandle(stdin, true);
       m_debugger.RunCommandInterpreter(handle_events, spawn_thread);
     }
   }
 
   reset_stdin_termios();
-  fclose(stdin);
+  llvm::sys::RetryAfterSignal(EOF, fclose, stdin);
 
   int exit_code = sb_interpreter.GetQuitStatus();
   SBDebugger::Destroy(m_debugger);
   return exit_code;
 }
 
 void Driver::ResizeWindow(unsigned short col) {
   GetDebugger().SetTerminalWidth(col);

lldb/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.

 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 void CMIUtilFileStd::Close() {
   if (m_pFileHandle == nullptr)
     return;
 
-  ::fclose(m_pFileHandle);
+  llvm::sys::RetryAfterSignal(EOF, ::fclose, m_pFileHandle);
   m_pFileHandle = nullptr;
   // m_bFileError = false; Do not reset as want to remain until next attempt at
   // open or create
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve state of whether the file is ok.

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

lldb/tools/lldb-perf/common/clang/lldb_perf_clang.cpp

 //===-- lldb_perf_clang.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-perf/lib/Measurement.h"
 #include "lldb-perf/lib/Metric.h"
 #include "lldb-perf/lib/Results.h"
 #include "lldb-perf/lib/TestCase.h"
 #include "lldb-perf/lib/Timer.h"
 #include "lldb-perf/lib/Xcode.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Errno.h"
 #include <fstream>
 #include <getopt.h>
 #include <iostream>
 #include <unistd.h>
 
 using namespace lldb_perf;
 
 #define NUM_EXPR_ITERATIONS 3
int main (int argc, char const *argv[], char const *envp[])
     ints.push_back(i);
     printf ("hello world\n");
     Foo foo = { 12, 13 };
     doit (foo);
     return 0;
 }
 )";
         write(fd, source_content, strlen(source_content));
-        close(fd);
+        llvm::sys::RetryAfterSignal(-1, close, fd);
       } else {
         const char *error_cstr = strerror(errno);
         fprintf(stderr,
                 "error: failed to created temporary source file: '%s' (%s)",
                 temp_source_path, error_cstr);
         exit(2);
       }
 

lldb/tools/lldb-vscode/IOStream.cpp

 #include <sys/socket.h>
 #include <unistd.h>
 #endif
 
 #include <fstream>
 #include <string>
 #include <vector>
 
+#include "llvm/Support/Errno.h"
+
 using namespace lldb_vscode;
 
 StreamDescriptor::StreamDescriptor() {}
 
 StreamDescriptor::StreamDescriptor(StreamDescriptor &&other) {
   *this = std::move(other);
 }
 
 StreamDescriptor::~StreamDescriptor() {
   if (!m_close)
     return;
 
   if (m_is_socket)
 #if defined(_WIN32)
     ::closesocket(m_socket);
 #else
-    ::close(m_socket);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_socket);
 #endif
   else
-    ::close(m_fd);
+    llvm::sys::RetryAfterSignal(-1, ::close, m_fd);
 }
 
 StreamDescriptor &StreamDescriptor::operator=(StreamDescriptor &&other) {
   m_close = other.m_close;
   other.m_close = false;
   m_is_socket = other.m_is_socket;
   if (m_is_socket)
     m_socket = other.m_socket;

lldb/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
-    close(sockfd);
+    llvm::sys::RetryAfterSignal(-1, close, sockfd);
 #endif
   }
   return newsockfd;
 }
 
 std::vector<const char *> MakeArgv(const llvm::ArrayRef<std::string> &strs) {
   // Create and return an array of "const char *", one for each C string in
   // "strs" and terminate the list with a NULL. This can be used for argument