[NativeProcessLinux] Use fast memory reads, if the system supports it

[labath]

Summary

Memory reads using the ptrace API need to be executed on a designated thread
and in 4-byte increments. The process_vm_read syscall has no such requirements
and it is about 50 times faster. This patch makes lldb-server use the faster
API if the target kernel supports it. Kernel support for this feature is
determined at runtime. Using process_vm_writev in the same manner is more
complicated since this syscall (unlike ptrace) respects page protection settings
and so it cannot be used to set a breakpoint, since code pages are typically
read-only. However, memory writes are not currently a performance bottleneck as
they happen much more rarely.

[ovyalov]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

84

Could you wrap check with std::call_once to make sure that it's thread-safe?

85

Indentation.

102

ditto.

3282

indentation.

3299

Please add separation spaces - success?"Success":strerror(errno))

[labath]

• Address review comments.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

84

done.

85

Oops. I blame new editor. :(

102

done.

3282

done.

3299

done.

[ovyalov]

Looks good.

include/lldb/Host/linux/Uio.h

+//===-- Uio.h ---------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Host_linux_Uio_h_
+#define liblldb_Host_linux_Uio_h_
+
+#include <sys/uio.h>
+
+// Android does not define the process_vm_readv wrapper
+#ifdef __ANDROID_NDK__
+ssize_t process_vm_readv(::pid_t pid,
+       const struct iovec *local_iov, unsigned long liovcnt,
+       const struct iovec *remote_iov, unsigned long riovcnt,
+       unsigned long flags);
+#endif
+
+#endif // liblldb_Host_linux_Uio_h_

source/Host/android/LibcGlue.cpp

 //===-- LibcGlue.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This files adds functions missing from libc on earlier versions of Android
 
 #include <android/api-level.h>
 
+#include <sys/syscall.h>
+#include <lldb/Host/linux/Uio.h>
+
 #if __ANDROID_API__ < 21
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <sys/syscall.h>
 #include <signal.h>
 
 #include "lldb/Host/Time.h"
 
 time_t timegm(struct tm* t)
 {
     return (time_t) timegm64(t);
 }
 
 int signalfd (int fd, const sigset_t *mask, int flags)
 {
     return syscall(__NR_signalfd4, fd, mask, _NSIG / 8, flags);
 }
 
 int posix_openpt(int flags)
 {
     return open("/dev/ptmx", flags);
 }
 
 #endif
+
+ssize_t process_vm_readv(::pid_t pid,
+       const struct iovec *local_iov, unsigned long liovcnt,
+       const struct iovec *remote_iov, unsigned long riovcnt,
+       unsigned long flags)
+{
+    return syscall(__NR_process_vm_readv, pid, local_iov, liovcnt, remote_iov, riovcnt, flags);
+}

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include "ProcFileReader.h"
 #include "Procfs.h"
 
 // System includes - They have to be included after framework includes because they define some
 // macros which collide with variable names in other modules
 #include <linux/unistd.h>
 #include <sys/socket.h>
 
+#include <sys/syscall.h>
 #include <sys/types.h>
-#include <sys/uio.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
 #include "lldb/Host/linux/Personality.h"
 #include "lldb/Host/linux/Ptrace.h"
 #include "lldb/Host/linux/Signalfd.h"
+#include "lldb/Host/linux/Uio.h"
 #include "lldb/Host/android/Android.h"
 
 #define LLDB_PERSONALITY_GET_CURRENT_SETTINGS  0xffffffff
 
 // Support hardware breakpoints in case it has not been defined
 #ifndef TRAP_HWBKPT
   #define TRAP_HWBKPT 4
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 using namespace llvm;
 
 // Private bits we only need internally.
+
+static bool ProcessVmReadvSupported()
+{
+    static LazyBool is_supported = eLazyBoolCalculate;
+
+    if (is_supported != eLazyBoolCalculate)
+  return is_supported == eLazyBoolYes;
+
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+
+    uint32_t source = 0x47424742;
+    uint32_t dest = 0;
+
+    struct iovec local, remote;
+    remote.iov_base = &source;
+    local.iov_base = &dest;
+    remote.iov_len = local.iov_len = sizeof source;
+
+    // We shall try if cross-process-memory reads work by attempting to read a value from our own process.
+    ssize_t res = process_vm_readv(getpid(), &local, 1, &remote, 1, 0);
+    is_supported = (res == sizeof(source) && source == dest) ? eLazyBoolYes : eLazyBoolNo;
+    if (log)
+    {
+  if (is_supported == eLazyBoolYes)
+      log->Printf("%s: Detected kernel support for process_vm_readv syscall. Fast memory reads enabled.",
+        __FUNCTION__);
+  else
+      log->Printf("%s: syscall process_vm_readv failed (error: %s). Fast memory reads disabled.",
+        __FUNCTION__, strerror(errno));
+    }
+    return is_supported;
+}
+
 namespace
 {
     const UnixSignals&
     GetUnixSignals ()
     {
         static process_linux::LinuxSignals signals;
         return signals;
     }
DoReadMemory(
             {
                 uintptr_t print_dst = 0;
                 // Format bytes from data by moving into print_dst for log output
                 for (unsigned i = 0; i < remainder; ++i)
                     print_dst |= (((data >> i*8) & 0xFF) << i*8);
                 log->Printf ("NativeProcessLinux::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__,
                         (void*)vm_addr, print_dst, (unsigned long)data);
             }
-
             vm_addr += word_size;
             dst += word_size;
         }
 
         if (log)
             ProcessPOSIXLog::DecNestLevel();
         return bytes_read;
     }
NativeProcessLinux::RemoveWatchpoint (lldb::addr_t addr)
     // for it.
     Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
     return NativeProcessProtocol::RemoveWatchpoint(addr);
 }
 
 Error
 NativeProcessLinux::ReadMemory (lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
 {
+    if (ProcessVmReadvSupported()) {
+  // The process_vm_readv path is about 50 times faster than ptrace api. We want to use
+  // this syscall if it is supported.
+
+  const ::pid_t pid = GetID();
+
+  struct iovec local_iov, remote_iov;
+  local_iov.iov_base = buf;
+  local_iov.iov_len = size;
+  remote_iov.iov_base = reinterpret_cast<void *>(addr);
+  remote_iov.iov_len = size;
+
+  bytes_read = process_vm_readv(pid, &local_iov, 1, &remote_iov, 1, 0);
+  const bool success = bytes_read == size;
+
+  Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+  if (log)
+      log->Printf ("NativeProcessLinux::%s using process_vm_readv to read %zd bytes from inferior address 0x%" PRIx64": %s",
+        __FUNCTION__, size, addr, success?"Success":strerror(errno));
+
+  if (success)
+      return Error();
+  // else
+  //     the call failed for some reason, let's retry the read using ptrace api.
+    }
+
     ReadOperation op(addr, buf, size, bytes_read);
     m_monitor_up->DoOperation(&op);
     return op.GetError ();
 }
 
 Error
 NativeProcessLinux::ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size, size_t &bytes_read)
 {