[lldb] [gdb-remote] Implement fallback to vFile:stat for GetFileSize()

[mgorny]

Summary

Implement a fallback to getting the file size via vFile:stat packet
when the remote server does not implement vFile:size. This makes it
possible to query file sizes from remote gdbserver.

While at it, add a few tests for the 'platform get-size' command.

[mgorny]

This covers client side only, I'm going to work on the server side vFile:stat packet later.

[mgorny]

Fix integer-type related warnings.

[mgorny]

Add a helper Stat method to take care of opening and closing the file. Add a cache variable for whether vFile:size is supported.

[mgorny]

@jasonmolenda, ping.

[mgorny]

Fix lint warnings. Add a note about not-full-replacement as requested in D107811.

[labath]

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

56–70

If we're going to have a struct for this anyway, then I think we should definitely use llvm's endian-specific types here. Then, instead of playing with DataExtractors, we can just memcpy the data here (the memcpy could go away as well with some changes to the StringExtractorGDBRemote interface)..

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

381

If you make a note here that this is only a convenience wrapper around FStat (which opens the file in read mode), then the other comments are probably unnecessary...

[mgorny]

Use LLVM's ubig*_t types. Thanks for the suggestion, @labath!

Also add the comment that Stat() is only a wrapper over open+fstat.

[labath]

cool

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

enum class CompressionType {
   ZlibDeflate, // zlib's deflate compression scheme, requires zlib or Apple's
                // libcompression
   LZFSE,       // an Apple compression scheme, requires Apple's libcompression
   LZ4, // lz compression - called "lz4 raw" in libcompression terms, compat with
        // https://code.google.com/p/lz4/
   LZMA, // Lempel–Ziv–Markov chain algorithm
 };
 
+// Data included in the vFile:fstat packet.
+// https://sourceware.org/gdb/onlinedocs/gdb/struct-stat.html#struct-stat
+struct GDBRemoteFStatData {
+  llvm::support::ubig32_t gdb_st_dev;
+  llvm::support::ubig32_t gdb_st_ino;
+  llvm::support::ubig32_t gdb_st_mode;
+  llvm::support::ubig32_t gdb_st_nlink;
+  llvm::support::ubig32_t gdb_st_uid;
+  llvm::support::ubig32_t gdb_st_gid;
+  llvm::support::ubig32_t gdb_st_rdev;
+  llvm::support::ubig64_t gdb_st_size;
+  llvm::support::ubig64_t gdb_st_blksize;
+  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");
+
 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.h

public:
   size_t GetCurrentThreadIDs(std::vector<lldb::tid_t> &thread_ids,
                              bool &sequence_mutex_unavailable);
 
   lldb::user_id_t OpenFile(const FileSpec &file_spec, File::OpenOptions flags,
                            mode_t mode, Status &error);
 
   bool CloseFile(lldb::user_id_t fd, Status &error);
 
+  llvm::Optional<GDBRemoteFStatData> FStat(lldb::user_id_t fd);
+
+  // NB: this is just a convenience wrapper over open() + fstat().  It does not
+  // work if the file cannot be opened.
+  llvm::Optional<GDBRemoteFStatData> Stat(const FileSpec &file_spec);
+
   lldb::user_id_t GetFileSize(const FileSpec &file_spec);
 
   void AutoCompleteDiskFileOrDirectory(CompletionRequest &request,
                                        bool only_dir);
 
   Status GetFilePermissions(const FileSpec &file_spec,
                             uint32_t &file_permissions);
 
protected:
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,
-      m_supports_jModulesInfo : 1;
+      m_supports_jModulesInfo : 1, m_supports_vFileSize : 1;
 
   /// Current gdb remote protocol process identifier for all other operations
   lldb::pid_t m_curr_pid = LLDB_INVALID_PROCESS_ID;
   /// Current gdb remote protocol process identifier for continue, step, etc
   lldb::pid_t m_curr_pid_run = LLDB_INVALID_PROCESS_ID;
   /// Current gdb remote protocol thread identifier for all other operations
   lldb::tid_t m_curr_tid = LLDB_INVALID_THREAD_ID;
   /// Current gdb remote protocol thread identifier for continue, step, etc

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

: GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
       m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
       m_supports_qUserName(true), m_supports_qGroupName(true),
       m_supports_qThreadStopInfo(true), m_supports_z0(true),
       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
       m_supports_z4(true), m_supports_QEnvironment(true),
       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
       m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
+      m_supports_vFileSize(true),
 
       m_host_arch(), m_process_arch(), m_os_build(), m_os_kernel(),
       m_hostname(), m_gdb_server_name(), m_default_packet_timeout(0),
       m_qSupported_response(), m_supported_async_json_packets_sp(),
       m_qXfer_memory_map() {}
 
 // Destructor
 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient() {
bool GDBRemoteCommunicationClient::CloseFile(lldb::user_id_t fd,
   StringExtractorGDBRemote response;
   if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
       PacketResult::Success) {
     return ParseHostIOPacketResponse(response, -1, error) == 0;
   }
   return false;
 }
 
+llvm::Optional<GDBRemoteFStatData>
+GDBRemoteCommunicationClient::FStat(lldb::user_id_t fd) {
+  lldb_private::StreamString stream;
+  stream.Printf("vFile:fstat:%" PRIx64, fd);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
+      PacketResult::Success) {
+    if (response.GetChar() != 'F')
+      return llvm::None;
+    int64_t size = response.GetS64(-1, 16);
+    if (size > 0 && response.GetChar() == ';') {
+      std::string buffer;
+      if (response.GetEscapedBinaryData(buffer)) {
+        GDBRemoteFStatData out;
+        if (buffer.size() != sizeof(out))
+          return llvm::None;
+        memcpy(&out, buffer.data(), sizeof(out));
+        return out;
+      }
+    }
+  }
+  return llvm::None;
+}
+
+llvm::Optional<GDBRemoteFStatData>
+GDBRemoteCommunicationClient::Stat(const lldb_private::FileSpec &file_spec) {
+  Status error;
+  lldb::user_id_t fd = OpenFile(file_spec, File::eOpenOptionReadOnly, 0, error);
+  if (fd == UINT64_MAX)
+    return llvm::None;
+  llvm::Optional<GDBRemoteFStatData> st = FStat(fd);
+  CloseFile(fd, error);
+  return st;
+}
+
 // Extension of host I/O packets to get the file size.
 lldb::user_id_t GDBRemoteCommunicationClient::GetFileSize(
     const lldb_private::FileSpec &file_spec) {
+  if (m_supports_vFileSize) {
     std::string path(file_spec.GetPath(false));
     lldb_private::StreamString stream;
     stream.PutCString("vFile:size:");
     stream.PutStringAsRawHex8(path);
     StringExtractorGDBRemote response;
-  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
-      PacketResult::Success) {
+    if (SendPacketAndWaitForResponse(stream.GetString(), response) !=
+        PacketResult::Success)
+      return UINT64_MAX;
+
+    if (!response.IsUnsupportedResponse()) {
       if (response.GetChar() != 'F')
         return UINT64_MAX;
       uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
       return retcode;
     }
-  return UINT64_MAX;
+    m_supports_vFileSize = false;
+  }
+
+  // Fallback to fstat.
+  llvm::Optional<GDBRemoteFStatData> st = Stat(file_spec);
+  return st ? st->gdb_st_size : UINT64_MAX;
 }
 
 void GDBRemoteCommunicationClient::AutoCompleteDiskFileOrDirectory(
     CompletionRequest &request, bool only_dir) {
   lldb_private::StreamString stream;
   stream.PutCString("qPathComplete:");
   stream.PutHex32(only_dir ? 1 : 0);
   stream.PutChar(',');

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

def test_file_fail(self):
             self.assertPacketLogContains([
                 "vFile:open:2f736f6d652f66696c652e747874,00000202,000001ed",
                 "vFile:pread:10,d,b",
                 "vFile:pwrite:10,b,teststring",
                 "vFile:close:10",
                 ])
         finally:
             self.dbg.GetSelectedPlatform().DisconnectRemote()
+
+    def test_file_size(self):
+        """Test 'platform get-size'"""
+
+        class Responder(MockGDBServerResponder):
+            def vFile(self, packet):
+                return "F1000"
+
+        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 get-size /some/file.txt",
+                       [r"File size of /some/file\.txt \(remote\): 4096"])
+            self.assertPacketLogContains([
+                "vFile:size:2f736f6d652f66696c652e747874",
+                ])
+        finally:
+            self.dbg.GetSelectedPlatform().DisconnectRemote()
+
+    def test_file_size_fallback(self):
+        """Test 'platform get-size fallback to vFile:fstat'"""
+
+        class Responder(MockGDBServerResponder):
+            def vFile(self, packet):
+                if packet.startswith("vFile:open:"):
+                    return "F5"
+                elif packet.startswith("vFile:fstat:"):
+                    return "F40;" + 28 * "\0" + "\0\0\0\0\0\1\2\3" + 28 * "\0"
+                if packet.startswith("vFile:close:"):
+                    return "F0"
+                return ""
+
+        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 get-size /some/file.txt",
+                       [r"File size of /some/file\.txt \(remote\): 66051"])
+            self.assertPacketLogContains([
+                "vFile:size:2f736f6d652f66696c652e747874",
+                "vFile:open:2f736f6d652f66696c652e747874,00000000,00000000",
+                "vFile:fstat:5",
+                "vFile:close:5",
+                ])
+        finally:
+            self.dbg.GetSelectedPlatform().DisconnectRemote()