[lldb] [gdb-remote] Use standardized GDB errno values

[mgorny]

Summary

GDB uses normalized errno values for vFile errors. Implement
the translation between them and system errno values in the gdb-remote
plugin.

[labath]

I think this would be a good use case for a llvm-style .def file. It would provide a central place listing all the known constants, and one could use it to generate the enum definition and both of the conversion functions (by defining a suitable macro).

[mgorny]

In D108148#2986602, @labath wrote:

I think this would be a good use case for a llvm-style .def file. It would provide a central place listing all the known constants, and one could use it to generate the enum definition and both of the conversion functions (by defining a suitable macro).

So basically a new thingie for lldb's TableGen? or is there some generic thingie I could reuse for this?

[labath]

Nah, tablegen is overkill. I was thinking of something similar to (but simpler than) include/llvm/BinaryFormat/Dwarf.def.

[mgorny]

In D108148#2987460, @labath wrote:

Nah, tablegen is overkill. I was thinking of something similar to (but simpler than) include/llvm/BinaryFormat/Dwarf.def.

Yeah, that looks easier. You got me scared there for a sec!

[mgorny]

Use a .def file.

[labath]

LG, modulo the comment. Keep an eye out on the bots though. I fear some systems (windows, in particular), may not have all errno constants defined, and we'll need to do something smarter.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

3071

Normally, it's the job of the .def file to undef this macro.

[mgorny]

In D108148#2993746, @labath wrote:

LG, modulo the comment. Keep an eye out on the bots though. I fear some systems (windows, in particular), may not have all errno constants defined, and we'll need to do something smarter.

Yeah, I was thinking how to handle this… after all, we can't #ifdef here.

[labath]

Judging by https://docs.microsoft.com/en-us/cpp/c-runtime-library/errno-constants?view=msvc-160, this may just work, so let's cross that bridge when we get to it.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

struct GDBRemoteFStatData {
   llvm::support::ubig64_t gdb_st_blocks;
   llvm::support::ubig32_t gdb_st_atime;
   llvm::support::ubig32_t gdb_st_mtime;
   llvm::support::ubig32_t gdb_st_ctime;
 };
 static_assert(sizeof(GDBRemoteFStatData) == 64,
               "size of GDBRemoteFStatData is not 64");
 
+enum GDBErrno {
+#define HANDLE_ERRNO(name, value) GDB_##name = value,
+#include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
+  GDB_EUNKNOWN = 9999
+};
+
 class ProcessGDBRemote;
 
 class GDBRemoteCommunication : public Communication {
 public:
   enum {
     eBroadcastBitRunPacketSent = kLoUserBroadcastBit,
     eBroadcastBitGdbReadThreadGotNotify =
         kLoUserBroadcastBit << 1 // Sent when we received a notify packet.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success)
     return Status("failed to send '%s' packet", stream.GetData());
 
   if (response.GetChar() != 'F')
     return Status("invalid response to '%s' packet", stream.GetData());
 
   return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
 }
 
+static int gdb_errno_to_system(int err) {
+  switch (err) {
+#define HANDLE_ERRNO(name, value)                                              \
+  case GDB_##name:                                                             \
+    return name;
+#include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
+  default:
+    return -1;
+  }
+}
+
 static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response,
                                           uint64_t fail_result, Status &error) {
   response.SetFilePos(0);
   if (response.GetChar() != 'F')
     return fail_result;
   int32_t result = response.GetS32(-2, 16);
   if (result == -2)
     return fail_result;
   if (response.GetChar() == ',') {
-    int result_errno = response.GetS32(-2, 16);
-    if (result_errno != -2)
+    int result_errno = gdb_errno_to_system(response.GetS32(-1, 16));
+    if (result_errno != -1)
       error.SetError(result_errno, eErrorTypePOSIX);
     else
       error.SetError(-1, eErrorTypeGeneric);
   } else
     error.Clear();
   return result;
 }
 lldb::user_id_t
if (m_supports_vFileMode) {
     if (!response.IsUnsupportedResponse()) {
       if (response.GetChar() != 'F') {
         error.SetErrorStringWithFormat("invalid response to '%s' packet",
                                        stream.GetData());
       } else {
         const uint32_t mode = response.GetS32(-1, 16);
         if (static_cast<int32_t>(mode) == -1) {
           if (response.GetChar() == ',') {
-            int response_errno = response.GetS32(-1, 16);
+            int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
             if (response_errno > 0)
               error.SetError(response_errno, lldb::eErrorTypePOSIX);
             else
               error.SetErrorToGenericError();
           } else
             error.SetErrorToGenericError();
         } else {
           file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd,
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() != 'F')
       return 0;
     int64_t retcode = response.GetS64(-1, 16);
     if (retcode == -1) {
       error.SetErrorToGenericError();
       if (response.GetChar() == ',') {
-        int response_errno = response.GetS32(-1, 16);
+        int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
         if (response_errno > 0)
           error.SetError(response_errno, lldb::eErrorTypePOSIX);
       }
       return -1;
     }
     const char next = (response.Peek() ? *response.Peek() : 0);
     if (next == ',')
       return 0;
if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
     if (response.GetChar() != 'F') {
       error.SetErrorStringWithFormat("write file failed");
       return 0;
     }
     int64_t bytes_written = response.GetS64(-1, 16);
     if (bytes_written == -1) {
       error.SetErrorToGenericError();
       if (response.GetChar() == ',') {
-        int response_errno = response.GetS32(-1, 16);
+        int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
         if (response_errno > 0)
           error.SetError(response_errno, lldb::eErrorTypePOSIX);
       }
       return -1;
     }
     return bytes_written;
   } else {
     error.SetErrorString("failed to send vFile:pwrite packet");
Status GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src,
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() == 'F') {
       uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
       if (result != 0) {
         error.SetErrorToGenericError();
         if (response.GetChar() == ',') {
-          int response_errno = response.GetS32(-1, 16);
+          int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
           if (response_errno > 0)
             error.SetError(response_errno, lldb::eErrorTypePOSIX);
         }
       }
     } else {
       // Should have returned with 'F<result>[,<errno>]'
       error.SetErrorStringWithFormat("symlink failed");
     }
Status GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec) {
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() == 'F') {
       uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
       if (result != 0) {
         error.SetErrorToGenericError();
         if (response.GetChar() == ',') {
-          int response_errno = response.GetS32(-1, 16);
+          int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
           if (response_errno > 0)
             error.SetError(response_errno, lldb::eErrorTypePOSIX);
         }
       }
     } else {
       // Should have returned with 'F<result>[,<errno>]'
       error.SetErrorStringWithFormat("unlink failed");
     }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

if (packet.GetChar() == ',') {
 
         return SendPacketNoLock(response.GetString());
       }
     }
   }
   return SendErrorResponse(18);
 }
 
+static GDBErrno system_errno_to_gdb(int err) {
+  switch (err) {
+#define HANDLE_ERRNO(name, value)                                              \
+  case name:                                                                   \
+    return GDB_##name;
+#include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
+  default:
+    return GDB_EUNKNOWN;
+  }
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Close(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:close:"));
   int fd = packet.GetS32(-1, 16);
   int err = -1;
   int save_errno = 0;
   if (fd >= 0) {
     NativeFile file(fd, File::OpenOptions(0), true);
     Status error = file.Close();
     err = 0;
     save_errno = error.GetError();
   } else {
     save_errno = EINVAL;
   }
   StreamString response;
   response.PutChar('F');
   response.Printf("%x", err);
   if (save_errno)
-    response.Printf(",%x", save_errno);
+    response.Printf(",%x", system_errno_to_gdb(save_errno));
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_pRead(
     StringExtractorGDBRemote &packet) {
   StreamGDBRemote response;
   packet.SetFilePos(::strlen("vFile:pread:"));
if (packet.GetChar() == ',') {
       response.PutChar('F');
       if (error.Success()) {
         response.Printf("%zx", count);
         response.PutChar(';');
         response.PutEscapedBytes(&buffer[0], count);
       } else {
         response.PutCString("-1");
         if (save_errno)
-          response.Printf(",%x", save_errno);
+          response.Printf(",%x", system_errno_to_gdb(save_errno));
       }
       return SendPacketNoLock(response.GetString());
     }
   }
   return SendErrorResponse(21);
 }
 
 GDBRemoteCommunication::PacketResult
if (packet.GetChar() == ',') {
         Status error =
             file.Write(static_cast<const void *>(&buffer[0]), count, offset);
         const int save_errno = error.GetError();
         if (error.Success())
           response.Printf("%zx", count);
         else {
           response.PutCString("-1");
           if (save_errno)
-            response.Printf(",%x", save_errno);
+            response.Printf(",%x", system_errno_to_gdb(save_errno));
         }
       } else {
         response.Printf("-1,%x", EINVAL);
       }
       return SendPacketNoLock(response.GetString());
     }
   }
   return SendErrorResponse(27);
GDBRemoteCommunicationServerCommon::Handle_vFile_FStat(
     StringExtractorGDBRemote &packet) {
   StreamGDBRemote response;
   packet.SetFilePos(::strlen("vFile:fstat:"));
   int fd = packet.GetS32(-1, 16);
 
   struct stat file_stats;
   if (::fstat(fd, &file_stats) == -1) {
     const int save_errno = errno;
-    response.Printf("F-1,%x", save_errno);
+    response.Printf("F-1,%x", system_errno_to_gdb(save_errno));
     return SendPacketNoLock(response.GetString());
   }
 
   GDBRemoteFStatData data;
   fill_clamp(data.gdb_st_dev, file_stats.st_dev, 0);
   fill_clamp(data.gdb_st_ino, file_stats.st_ino, 0);
   data.gdb_st_mode = file_stats.st_mode;
   fill_clamp(data.gdb_st_nlink, file_stats.st_nlink, UINT32_MAX);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteErrno.def

+//===-- GDBRemoteErrno.def --------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+// NOTE: NO INCLUDE GUARD DESIRED!
+
+// HANDLE_ERRNO(name, value)
+#ifndef HANDLE_ERRNO
+#error "HANDLE_ERRNO must be defined"
+#endif
+
+// from gdb's include/gdb/fileio.h
+HANDLE_ERRNO(EPERM,             1)
+HANDLE_ERRNO(ENOENT,            2)
+HANDLE_ERRNO(EINTR,             4)
+HANDLE_ERRNO(EIO,               5)
+HANDLE_ERRNO(EBADF,             9)
+HANDLE_ERRNO(EACCES,           13)
+HANDLE_ERRNO(EFAULT,           14)
+HANDLE_ERRNO(EBUSY,            16)
+HANDLE_ERRNO(EEXIST,           17)
+HANDLE_ERRNO(ENODEV,           19)
+HANDLE_ERRNO(ENOTDIR,          20)
+HANDLE_ERRNO(EISDIR,           21)
+HANDLE_ERRNO(EINVAL,           22)
+HANDLE_ERRNO(ENFILE,           23)
+HANDLE_ERRNO(EMFILE,           24)
+HANDLE_ERRNO(EFBIG,            27)
+HANDLE_ERRNO(ENOSPC,           28)
+HANDLE_ERRNO(ESPIPE,           29)
+HANDLE_ERRNO(EROFS,            30)
+HANDLE_ERRNO(ENOSYS,           88)
+HANDLE_ERRNO(ENAMETOOLONG,     91)
+
+#undef HANDLE_ERRNO

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemotePlatformFile.py

def test_file(self):
                 if packet.startswith("vFile:open:"):
                     return "F10"
                 elif packet.startswith("vFile:pread:"):
                     return "Fd;frobnicator"
                 elif packet.startswith("vFile:pwrite:"):
                     return "Fa"
                 elif packet.startswith("vFile:close:"):
                     return "F0"
-                return "F-1,16"
+                return "F-1,58"
 
         self.server.responder = Responder()
 
         self.match("platform file open /some/file.txt -v 0755",
                    [r"File Descriptor = 16"])
         self.match("platform file read 16 -o 11 -c 13",
                    [r"Return = 11\nData = \"frobnicator\""])
         self.match("platform file write 16 -o 11 -d teststring",
                    [r"Return = 10"])
         self.match("platform file close 16",
                    [r"file 16 closed."])
         self.assertPacketLogContains([
             "vFile:open:2f736f6d652f66696c652e747874,00000202,000001ed",
             "vFile:pread:10,d,b",
             "vFile:pwrite:10,b,teststring",
             "vFile:close:10",
             ])
 
     def test_file_fail(self):
         """Test mocked failures of remote operations"""
 
         class Responder(MockGDBServerResponder):
             def vFile(self, packet):
-                return "F-1,16"
+                # use ENOSYS as this constant differs between GDB Remote
+                # Protocol and Linux, so we can test the translation
+                return "F-1,58"
 
         self.server.responder = Responder()
 
         self.match("platform file open /some/file.txt -v 0755",
-                   [r"error: Invalid argument"],
+                   [r"error: Function not implemented"],
                    error=True)
         self.match("platform file read 16 -o 11 -c 13",
-                   [r"error: Invalid argument"],
+                   [r"error: Function not implemented"],
                    error=True)
         self.match("platform file write 16 -o 11 -d teststring",
-                   [r"error: Invalid argument"],
+                   [r"error: Function not implemented"],
                    error=True)
         self.match("platform file close 16",
-                   [r"error: Invalid argument"],
+                   [r"error: Function not implemented"],
                    error=True)
         self.assertPacketLogContains([
             "vFile:open:2f736f6d652f66696c652e747874,00000202,000001ed",
             "vFile:pread:10,d,b",
             "vFile:pwrite:10,b,teststring",
             "vFile:close:10",
             ])