[lldb] [gdb-remote] Use hexadecimal numbers in vFile packets for GDB compliance

[mgorny]

Summary

Use hexadecimal numbers rather than decimal in various vFile packets
in order to fix compatibility with gdbserver. This also changes the few
custom LLDB packets -- while technically they do not have to be changed,
it is easier to use the same syntax consistently across LLDB.

[emaste]

LGTM, although in FreeBSD we don't have any backwards- or cross-compatibility issues to worry about.

[jasonmolenda]

LGTM, thanks for updating the docs too. I have a separate platform implementation ("lldb-platform") that I wrote but it's not in wide use outside the apple lldb team, I'm not going to worry about versioning the protocol or falling back to the old buggy behavior. I'll update my impl for https://reviews.llvm.org/D106985 and https://reviews.llvm.org/D106984 once these are landed.

[mgorny]

Add tests for server and client. Fix error handling.

[mgorny]

Fix vFile:pread to actually return the underlying error in client.

[stella.stamenova]

This change is causing failures on the Windows lldb bot:

https://lab.llvm.org/buildbot/#/builders/83/builds/9098

[mgorny]

In D107475#2934924, @stella.stamenova wrote:

This change is causing failures on the Windows lldb bot:

https://lab.llvm.org/buildbot/#/builders/83/builds/9098

I've already attempted to fix this, I'll try more. It doesn't help that buildbot webUI is so shoddy it takes me around 10 minutes to get any results :-(.

[mgorny]

Ok, I've reverted my previous attempts and just marked the tests for skipping on Windows. Hopefully this'll work.

lldb/docs/lldb-platform-packets.txt

 //
 //  request packet has the fields:
 //     1. ASCII hex encoded filename
 //     2. flags passed to the open call, base 16.
 //        Note that these are not the oflags that open(2) takes, but
 //        are the constant values in enum OpenOptions from lldb's File.h
 //     3. mode bits, base 16
 //  
-//  response is F followed by the opened file descriptor in base 10.
+//  response is F followed by the opened file descriptor in base 16.
 //  "F-1,errno" with the errno if an error occurs.
 //
 //----------------------------------------------------------------------
 // vFile:close:
 //
 // BRIEF
 //   Close a previously opened file descriptor.
 //
 // EXAMPLE
 // 
 //  receive: vFile:close:7
 //  send:    F0
 //
-//  File descriptor is in base 10.
+//  File descriptor is in base 16.
 //  "F-1,errno" with the errno if an error occurs.
 
 
 //----------------------------------------------------------------------
 // vFile:pread:
 //
 // BRIEF
 //   Read data from an opened file descriptor.
 //
 // EXAMPLE
 // 
 //  receive: vFile:pread:7,1024,0
 //  send:    F4;a'b\00
 //
 //  request packet has the fields:
-//     1. file descriptor, base 10
-//     2. number of bytes to be read, base 10
-//     3. offset into file to start from, base 10
+//     1. file descriptor, base 16
+//     2. number of bytes to be read, base 16
+//     3. offset into file to start from, base 16
 //
-//  Response is F, followed by the number of bytes read (base 10), a
+//  Response is F, followed by the number of bytes read (base 16), a
 //  semicolon, followed by the data in the binary-escaped-data encoding.
-//
-//  COMPATIBILITY
-//    The gdb-remote serial protocol documentation says that numbers
-//    in "vFile:" packets should be hexadecimal. Instead lldb uses
-//    decimal.
 
 
 //----------------------------------------------------------------------
 // vFile:pwrite:
 //
 // BRIEF
 //   Write data to a previously opened file descriptor.
 //
 // EXAMPLE
 // 
 //  receive: vFile:pwrite:8,0,\cf\fa\ed\fe\0c\00\00
 //  send:    F1024
 //
 //  request packet has the fields:
-//     1. file descriptor, base 10
-//     2. offset into file to start from, base 10
+//     1. file descriptor, base 16
+//     2. offset into file to start from, base 16
 //     3. binary-escaped-data to be written
 //
-//  Response is F, followed by the number of bytes written (base 10)
-//
-//  COMPATIBILITY
-//    The gdb-remote serial protocol documentation says that numbers
-//    in "vFile:" packets should be hexadecimal. Instead lldb uses
-//    decimal.
+//  Response is F, followed by the number of bytes written (base 16)
 
 
 
 
 
 Finally, the platform must be able to launch processes so that debugserver
 can attach to them.  To do this, the following packets should be handled:
 

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

Status GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
   StringExtractorGDBRemote response;
 
   if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success)
     return Status("failed to send '%s' packet", packet.str().c_str());
 
   if (response.GetChar() != 'F')
     return Status("invalid response to '%s' packet", packet.str().c_str());
 
-  return Status(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
+  return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
 }
 
 Status
 GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec,
                                                  uint32_t file_permissions) {
   std::string path{file_spec.GetPath(false)};
   lldb_private::StreamString stream;
   stream.PutCString("qPlatform_chmod:");
   stream.PutHex32(file_permissions);
   stream.PutChar(',');
   stream.PutStringAsRawHex8(path);
   llvm::StringRef packet = stream.GetString();
   StringExtractorGDBRemote response;
 
   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.GetU32(UINT32_MAX), eErrorTypePOSIX);
+  return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
 }
 
 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);
+  int32_t result = response.GetS32(-2, 16);
   if (result == -2)
     return fail_result;
   if (response.GetChar() == ',') {
-    int result_errno = response.GetS32(-2);
+    int result_errno = response.GetS32(-2, 16);
     if (result_errno != -2)
       error.SetError(result_errno, eErrorTypePOSIX);
     else
       error.SetError(-1, eErrorTypeGeneric);
   } else
     error.Clear();
   return result;
 }
if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
     return ParseHostIOPacketResponse(response, UINT64_MAX, error);
   }
   return UINT64_MAX;
 }
 
 bool GDBRemoteCommunicationClient::CloseFile(lldb::user_id_t fd,
                                              Status &error) {
   lldb_private::StreamString stream;
-  stream.Printf("vFile:close:%i", (int)fd);
+  stream.Printf("vFile:close:%x", (int)fd);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     return ParseHostIOPacketResponse(response, -1, error) == 0;
   }
   return false;
 }
 
GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec,
   stream.PutStringAsRawHex8(path);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() != 'F') {
       error.SetErrorStringWithFormat("invalid response to '%s' packet",
                                      stream.GetData());
     } else {
-      const uint32_t mode = response.GetS32(-1);
+      const uint32_t mode = response.GetS32(-1, 16);
       if (static_cast<int32_t>(mode) == -1) {
         if (response.GetChar() == ',') {
-          int response_errno = response.GetS32(-1);
+          int response_errno = 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);
       }
     }
   } else {
     error.SetErrorStringWithFormat("failed to send '%s' packet",
                                    stream.GetData());
   }
   return error;
 }
 
 uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd,
                                                 uint64_t offset, void *dst,
                                                 uint64_t dst_len,
                                                 Status &error) {
   lldb_private::StreamString stream;
-  stream.Printf("vFile:pread:%i,%" PRId64 ",%" PRId64, (int)fd, dst_len,
+  stream.Printf("vFile:pread:%x,%" PRIx64 ",%" PRIx64, (int)fd, dst_len,
                 offset);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() != 'F')
       return 0;
-    uint32_t retcode = response.GetHexMaxU32(false, UINT32_MAX);
-    if (retcode == UINT32_MAX)
-      return retcode;
+    int64_t retcode = response.GetS64(-1, 16);
+    if (retcode == -1) {
+      error.SetErrorToGenericError();
+      if (response.GetChar() == ',') {
+        int response_errno = 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 (next == ';') {
       response.GetChar(); // skip the semicolon
       std::string buffer;
       if (response.GetEscapedBinaryData(buffer)) {
         const uint64_t data_to_write =
             std::min<uint64_t>(dst_len, buffer.size());
         if (data_to_write > 0)
           memcpy(dst, &buffer[0], data_to_write);
         return data_to_write;
       }
     }
   }
   return 0;
 }
 
 uint64_t GDBRemoteCommunicationClient::WriteFile(lldb::user_id_t fd,
                                                  uint64_t offset,
                                                  const void *src,
                                                  uint64_t src_len,
                                                  Status &error) {
   lldb_private::StreamGDBRemote stream;
-  stream.Printf("vFile:pwrite:%i,%" PRId64 ",", (int)fd, offset);
+  stream.Printf("vFile:pwrite:%x,%" PRIx64 ",", (int)fd, offset);
   stream.PutEscapedBytes(src, src_len);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() != 'F') {
       error.SetErrorStringWithFormat("write file failed");
       return 0;
     }
-    uint64_t bytes_written = response.GetU64(UINT64_MAX);
-    if (bytes_written == UINT64_MAX) {
+    int64_t bytes_written = response.GetS64(-1, 16);
+    if (bytes_written == -1) {
       error.SetErrorToGenericError();
       if (response.GetChar() == ',') {
-        int response_errno = response.GetS32(-1);
+        int response_errno = response.GetS32(-1, 16);
         if (response_errno > 0)
           error.SetError(response_errno, lldb::eErrorTypePOSIX);
       }
-      return 0;
+      return -1;
     }
     return bytes_written;
   } else {
     error.SetErrorString("failed to send vFile:pwrite packet");
   }
   return 0;
 }
 
 Status GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src,
                                                    const FileSpec &dst) {
   std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)};
   Status error;
   lldb_private::StreamGDBRemote stream;
   stream.PutCString("vFile:symlink:");
   // the unix symlink() command reverses its parameters where the dst if first,
   // so we follow suit here
   stream.PutStringAsRawHex8(dst_path);
   stream.PutChar(',');
   stream.PutStringAsRawHex8(src_path);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() == 'F') {
-      uint32_t result = response.GetU32(UINT32_MAX);
+      uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
       if (result != 0) {
         error.SetErrorToGenericError();
         if (response.GetChar() == ',') {
-          int response_errno = response.GetS32(-1);
+          int response_errno = 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) {
   stream.PutCString("vFile:unlink:");
   // the unix symlink() command reverses its parameters where the dst if first,
   // so we follow suit here
   stream.PutStringAsRawHex8(path);
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     if (response.GetChar() == 'F') {
-      uint32_t result = response.GetU32(UINT32_MAX);
+      uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
       if (result != 0) {
         error.SetErrorToGenericError();
         if (response.GetChar() == ',') {
-          int response_errno = response.GetS32(-1);
+          int response_errno = 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() == ',') {
       auto flags = File::OpenOptions(packet.GetHexMaxU32(false, 0));
       if (packet.GetChar() == ',') {
         mode_t mode = packet.GetHexMaxU32(false, 0600);
         FileSpec path_spec(path);
         FileSystem::Instance().Resolve(path_spec);
         // Do not close fd.
         auto file = FileSystem::Instance().Open(path_spec, flags, mode, false);
 
-        int save_errno = 0;
+        StreamString response;
+        response.PutChar('F');
+
         int descriptor = File::kInvalidDescriptor;
         if (file) {
           descriptor = file.get()->GetDescriptor();
+          response.Printf("%x", descriptor);
         } else {
+          response.PutCString("-1");
           std::error_code code = errorToErrorCode(file.takeError());
           if (code.category() == std::system_category()) {
-            save_errno = code.value();
+            response.Printf(",%x", code.value());
           }
         }
 
-        StreamString response;
-        response.PutChar('F');
-        response.Printf("%i", descriptor);
-        if (save_errno)
-          response.Printf(",%i", save_errno);
         return SendPacketNoLock(response.GetString());
       }
     }
   }
   return SendErrorResponse(18);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Close(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:close:"));
-  int fd = packet.GetS32(-1);
+  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("%i", err);
+  response.Printf("%x", err);
   if (save_errno)
-    response.Printf(",%i", save_errno);
+    response.Printf(",%x", save_errno);
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_pRead(
     StringExtractorGDBRemote &packet) {
   StreamGDBRemote response;
   packet.SetFilePos(::strlen("vFile:pread:"));
-  int fd = packet.GetS32(-1);
+  int fd = packet.GetS32(-1, 16);
   if (packet.GetChar() == ',') {
-    size_t count = packet.GetU64(SIZE_MAX);
+    size_t count = packet.GetHexMaxU64(false, SIZE_MAX);
     if (packet.GetChar() == ',') {
-      off_t offset = packet.GetU64(UINT32_MAX);
+      off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
       if (count == SIZE_MAX) {
-        response.Printf("F-1:%i", EINVAL);
+        response.Printf("F-1:%x", EINVAL);
         return SendPacketNoLock(response.GetString());
       }
 
       std::string buffer(count, 0);
       NativeFile file(fd, File::eOpenOptionReadOnly, false);
       Status error = file.Read(static_cast<void *>(&buffer[0]), count, offset);
-      const ssize_t bytes_read = error.Success() ? count : -1;
       const int save_errno = error.GetError();
       response.PutChar('F');
-      response.Printf("%zi", bytes_read);
-      if (save_errno)
-        response.Printf(",%i", save_errno);
-      else {
+      if (error.Success()) {
+        response.Printf("%zx", count);
         response.PutChar(';');
-        response.PutEscapedBytes(&buffer[0], bytes_read);
+        response.PutEscapedBytes(&buffer[0], count);
+      } else {
+        response.PutCString("-1");
+        if (save_errno)
+          response.Printf(",%x", save_errno);
       }
       return SendPacketNoLock(response.GetString());
     }
   }
   return SendErrorResponse(21);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:pwrite:"));
 
   StreamGDBRemote response;
   response.PutChar('F');
 
-  int fd = packet.GetU32(UINT32_MAX);
+  int fd = packet.GetS32(-1, 16);
   if (packet.GetChar() == ',') {
-    off_t offset = packet.GetU64(UINT32_MAX);
+    off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
     if (packet.GetChar() == ',') {
       std::string buffer;
       if (packet.GetEscapedBinaryData(buffer)) {
         NativeFile file(fd, File::eOpenOptionWriteOnly, false);
         size_t count = buffer.size();
         Status error =
             file.Write(static_cast<const void *>(&buffer[0]), count, offset);
-        const ssize_t bytes_written = error.Success() ? count : -1;
         const int save_errno = error.GetError();
-        response.Printf("%zi", bytes_written);
+        if (error.Success())
+          response.Printf("%zx", count);
+        else {
+          response.PutCString("-1");
           if (save_errno)
-          response.Printf(",%i", save_errno);
+            response.Printf(",%x", save_errno);
+        }
       } else {
-        response.Printf("-1,%i", EINVAL);
+        response.Printf("-1,%x", EINVAL);
       }
       return SendPacketNoLock(response.GetString());
     }
   }
   return SendErrorResponse(27);
 }
 
 GDBRemoteCommunication::PacketResult
GDBRemoteCommunicationServerCommon::Handle_vFile_Mode(
   std::string path;
   packet.GetHexByteString(path);
   if (!path.empty()) {
     FileSpec file_spec(path);
     FileSystem::Instance().Resolve(file_spec);
     std::error_code ec;
     const uint32_t mode = FileSystem::Instance().GetPermissions(file_spec, ec);
     StreamString response;
-    response.Printf("F%u", mode);
+    response.Printf("F%x", mode);
     if (mode == 0 || ec)
-      response.Printf(",%i", (int)Status(ec).GetError());
+      response.Printf(",%x", (int)Status(ec).GetError());
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(23);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_Exists(
     StringExtractorGDBRemote &packet) {
GDBRemoteCommunicationServerCommon::Handle_vFile_symlink(
   packet.GetChar(); // Skip ',' char
   packet.GetHexByteString(src);
 
   FileSpec src_spec(src);
   FileSystem::Instance().Resolve(src_spec);
   Status error = FileSystem::Instance().Symlink(src_spec, FileSpec(dst));
 
   StreamString response;
-  response.Printf("F%u,%u", error.GetError(), error.GetError());
+  response.Printf("F%x,%x", error.GetError(), error.GetError());
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_vFile_unlink(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("vFile:unlink:"));
   std::string path;
   packet.GetHexByteString(path);
   Status error(llvm::sys::fs::remove(path));
   StreamString response;
-  response.Printf("F%u,%u", error.GetError(), error.GetError());
+  response.Printf("F%x,%x", error.GetError(), error.GetError());
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("qPlatform_shell:"));
   std::string path;
GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir(
   packet.SetFilePos(::strlen("qPlatform_mkdir:"));
   mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
   if (packet.GetChar() == ',') {
     std::string path;
     packet.GetHexByteString(path);
     Status error(llvm::sys::fs::create_directory(path, mode));
 
     StreamGDBRemote response;
-    response.Printf("F%u", error.GetError());
+    response.Printf("F%x", error.GetError());
 
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(20);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("qPlatform_chmod:"));
 
   auto perms =
       static_cast<llvm::sys::fs::perms>(packet.GetHexMaxU32(false, UINT32_MAX));
   if (packet.GetChar() == ',') {
     std::string path;
     packet.GetHexByteString(path);
     Status error(llvm::sys::fs::setPermissions(path, perms));
 
     StreamGDBRemote response;
-    response.Printf("F%u", error.GetError());
+    response.Printf("F%x", error.GetError());
 
     return SendPacketNoLock(response.GetString());
   }
   return SendErrorResponse(19);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qSupported(

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

 from gdbclientutils import *
 
 class TestGDBRemotePlatformFile(GDBRemoteTestBase):
 
-    def test_file_open(self):
-        """Test mock-opening a remote file"""
+    def test_file(self):
+        """Test mock operations on a remote file"""
 
         class Responder(MockGDBServerResponder):
             def vFile(self, packet):
+                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"
 
         self.server.responder = Responder()
 
         try:
             self.runCmd("platform select remote-gdb-server")
             self.runCmd("platform connect connect://" +
                         self.server.get_connect_address())
             self.assertTrue(self.dbg.GetSelectedPlatform().IsConnected())
 
-            self.runCmd("platform file open /some/file.txt -v 0755")
+            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,0000020a,000001ed"
+                "vFile:open:2f736f6d652f66696c652e747874,0000020a,000001ed",
+                "vFile:pread:10,d,b",
+                "vFile:pwrite:10,b,teststring",
+                "vFile:close:10",
+                ])
+        finally:
+            self.dbg.GetSelectedPlatform().DisconnectRemote()
+
+    def test_file_fail(self):
+        """Test mocked failures of remote operations"""
+
+        class Responder(MockGDBServerResponder):
+            def vFile(self, packet):
+                return "F-1,16"
+
+        self.server.responder = Responder()
+
+        try:
+            self.runCmd("platform select remote-gdb-server")
+            self.runCmd("platform connect connect://" +
+                        self.server.get_connect_address())
+            self.assertTrue(self.dbg.GetSelectedPlatform().IsConnected())
+
+            self.match("platform file open /some/file.txt -v 0755",
+                       [r"error: Invalid argument"],
+                       error=True)
+            # TODO: fix the commands to fail on unsuccessful result
+            self.match("platform file read 16 -o 11 -c 13",
+                       [r"Return = -1\nData = \"\""])
+            self.match("platform file write 16 -o 11 -d teststring",
+                       [r"Return = -1"])
+            self.match("platform file close 16",
+                       [r"error: Invalid argument"],
+                       error=True)
+            self.assertPacketLogContains([
+                "vFile:open:2f736f6d652f66696c652e747874,0000020a,000001ed",
+                "vFile:pread:10,d,b",
+                "vFile:pwrite:10,b,teststring",
+                "vFile:close:10",
                 ])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()

lldb/test/API/tools/lldb-server/TestGdbRemotePlatformFile.py

+from __future__ import print_function
+
+# lldb test suite imports
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import TestBase
+
+# gdb-remote-specific imports
+import lldbgdbserverutils
+from gdbremote_testcase import GdbRemoteTestCaseBase
+
+import binascii
+import stat
+import tempfile
+
+
+class TestGdbRemotePlatformFile(GdbRemoteTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_platform_file_rdonly(self):
+        self.vFile_test(read=True)
+
+    def test_platform_file_wronly(self):
+        self.vFile_test(write=True)
+
+    def test_platform_file_rdwr(self):
+        self.vFile_test(read=True, write=True)
+
+    def test_platform_file_wronly_append(self):
+        self.vFile_test(write=True, append=True)
+
+    def test_platform_file_rdwr_append(self):
+        self.vFile_test(read=True, write=True, append=True)
+
+    def test_platform_file_wronly_trunc(self):
+        self.vFile_test(write=True, trunc=True)
+
+    def test_platform_file_rdwr_trunc(self):
+        self.vFile_test(read=True, write=True, trunc=True)
+
+    def test_platform_file_wronly_creat(self):
+        self.vFile_test(write=True, creat=True)
+
+    def test_platform_file_wronly_creat_excl(self):
+        self.vFile_test(write=True, creat=True, excl=True)
+
+    def test_platform_file_wronly_fail(self):
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # create a temporary directory
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = os.path.join(temp_dir, "test")
+            self.assertFalse(os.path.exists(temp_path))
+
+            # attempt to open the file without O_CREAT
+            self.do_handshake()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:open:%s,1,0#00" % (
+                    binascii.b2a_hex(temp_path.encode()).decode(),),
+                 {"direction": "send",
+                 "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
+                True)
+            self.expect_gdbremote_sequence()
+
+    def test_platform_file_wronly_creat_excl_fail(self):
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        with tempfile.NamedTemporaryFile() as temp_file:
+            # attempt to open the file with O_CREAT|O_EXCL
+            self.do_handshake()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:open:%s,a01,0#00" % (
+                    binascii.b2a_hex(temp_file.name.encode()).decode(),),
+                 {"direction": "send",
+                 "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
+                True)
+            self.expect_gdbremote_sequence()
+
+    def expect_error(self):
+        self.test_sequence.add_log_lines(
+            [{"direction": "send",
+             "regex": r"^\$F-1,[0-9a-fA-F]+#[0-9a-fA-F]{2}$"}],
+            True)
+        self.expect_gdbremote_sequence()
+
+    def vFile_test(self, read=False, write=False, append=False, trunc=False,
+                   creat=False, excl=False):
+        if read and write:
+            mode = 2
+        elif write:
+            mode = 1
+        else:  # read
+            mode = 0
+        if append:
+            mode |= 8
+        if creat:
+            mode |= 0x200
+        if trunc:
+            mode |= 0x400
+        if excl:
+            mode |= 0x800
+
+        server = self.connect_to_debug_monitor()
+        self.assertIsNotNone(server)
+
+        # create a temporary file with some data
+        test_data = 'some test data longer than 16 bytes\n'
+        if creat:
+            temp_dir = tempfile.TemporaryDirectory()
+        else:
+            temp_file = tempfile.NamedTemporaryFile()
+
+        try:
+            if creat:
+                temp_path = os.path.join(temp_dir.name, "test")
+                self.assertFalse(os.path.exists(temp_path))
+            else:
+                temp_file.write(test_data.encode())
+                temp_file.flush()
+                temp_path = temp_file.name
+
+            # open the file for reading
+            self.do_handshake()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:open:%s,%x,1a0#00" % (
+                    binascii.b2a_hex(temp_path.encode()).decode(),
+                    mode),
+                 {"direction": "send",
+                 "regex": r"^\$F([0-9a-fA-F]+)#[0-9a-fA-F]{2}$",
+                 "capture": {1: "fd"}}],
+                True)
+
+            context = self.expect_gdbremote_sequence()
+            self.assertIsNotNone(context)
+            fd = int(context["fd"], 16)
+
+            # read data from the file
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:pread:%x,11,10#00" % (fd,)],
+                True)
+            if read:
+                self.test_sequence.add_log_lines(
+                    [{"direction": "send",
+                     "regex": r"^\$F([0-9a-fA-F]+);(.*)#[0-9a-fA-F]{2}$",
+                     "capture": {1: "size", 2: "data"}}],
+                    True)
+                context = self.expect_gdbremote_sequence()
+                self.assertIsNotNone(context)
+                if trunc:
+                    self.assertEqual(context["size"], "0")
+                    self.assertEqual(context["data"], "")
+                else:
+                    self.assertEqual(context["size"], "11")  # hex
+                    self.assertEqual(context["data"], test_data[0x10:0x10 + 0x11])
+            else:
+                self.expect_error()
+
+            # another offset
+            if read and not trunc:
+                self.reset_test_sequence()
+                self.test_sequence.add_log_lines(
+                    ["read packet: $vFile:pread:%x,6,3#00" % (fd,),
+                     {"direction": "send",
+                     "regex": r"^\$F([0-9a-fA-F]+);(.+)#[0-9a-fA-F]{2}$",
+                     "capture": {1: "size", 2: "data"}}],
+                    True)
+                context = self.expect_gdbremote_sequence()
+                self.assertIsNotNone(context)
+                self.assertEqual(context["size"], "6")  # hex
+                self.assertEqual(context["data"], test_data[3:3 + 6])
+
+            # write data to the file
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:pwrite:%x,6,somedata#00" % (fd,)],
+                True)
+            if write:
+                self.test_sequence.add_log_lines(
+                    ["send packet: $F8#00"],
+                    True)
+                self.expect_gdbremote_sequence()
+            else:
+                self.expect_error()
+
+            # close the file
+            self.reset_test_sequence()
+            self.test_sequence.add_log_lines(
+                ["read packet: $vFile:close:%x#00" % (fd,),
+                 "send packet: $F0#00"],
+                True)
+            self.expect_gdbremote_sequence()
+
+            if write:
+                # check if the data was actually written
+                if creat:
+                    temp_file = open(temp_path, "rb")
+                    self.assertEqual(os.fstat(temp_file.fileno()).st_mode & 0o7777,
+                                     0o640)
+                temp_file.seek(0)
+                data = test_data.encode()
+                if trunc or creat:
+                    data = b"\0" * 6 + b"somedata"
+                elif append:
+                    data += b"somedata"
+                else:
+                    data = data[:6] + b"somedata" + data[6 + 8:]
+                self.assertEqual(temp_file.read(), data)
+        finally:
+            if creat:
+                temp_dir.cleanup()
+            else:
+                temp_file.close()