Implement jAttachWait

[augusto2112]

Summary

jAttachWait provides the same functionality as vAttachWait/vAttachOrWait. Additionaly, it allows for the usage of two new options, 'waitfor-duration' and 'waitfor-interval'

[augusto2112]

As discussed in the vAttachWait patch (https://reviews.llvm.org/D93895), I've implemented a jAttachWait packet with supports two additional parameters (polling interval and polling duration) when attaching to a process by name and waiting for it to appear.

jAttachWait send a json packet of the format: {"process_name": string, "include-existing: bool, "waitfor-interval-usec": microseconds, waitfor-duration-sec: seconds} where waitfor-interval-usec and waitfor-duration-sec are only sent if specified by the user.

For this first implementation I decided to add the arguments as additional flags to process attach, but I can change this if you think that's not a good idea.

I was also wondering if this could/should be expanded in a more general jAttach packet, where the packet contents would specify if lldb-server should wait or not, what are your thoughts on that?

Lastly, this current implementation has a bug I couldn't figure out, where if we're sending l an error response, lldb loses connection to lldb-server (this happens even if the first thing I do in the handle_jAttachWait function is return an error) and, also, CTRL+C from lldb doesn't interrupt lldb-server. If anyone know why this might be happening, I'd be glad to hear it.

[clayborg]

See inlined comment about the packet name issue and let me know what you think

lldb/include/lldb/Target/Process.h

180–181

221–222

Should we attach _usec and sec to these names to make it clear what the units are?

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

136

So we currently have 4 flavors from the old way: vAttach, vAttachWait vAttachOrWait, vAttachName. Do we want to possibly make a "jAttach" that works for all cases? The new "jAttach" could be powerful enough to do it all in one packet if needed. I just worry about attaching the "Wait" to the "jAttachWait" command name in case we want to use it for all of the above cases at a later point.

A "jAttach" could implement all of:

• attach to existing pid
• attach to by name
  • unique existing process
  • wait
    • allow existing (true/false)
    • poll interval (time in usec)
    • wait duration (time in sec)

Not that we need to add support for all of these flavor with this patch, I'm just trying to forward think about the future in case other attach flags are added to any flavor of attach.

[labath]

I'm not sure this new functionality is really worth the new packet (or two), but if it solves a use case you care about, then I suppose that's fine. One alternative could be to just tack on some extra data to the existing vAttach family packets (vAttachWait;foo;interval:47;duration=74).

Lastly, this current implementation has a bug I couldn't figure out, where if we're sending l an error response, lldb loses connection to lldb-server (this happens even if the first thing I do in the handle_jAttachWait function is return an error)

I'm not sure that's a bug (i.e., lldb may be intentionally dropping the connection). What would you expect lldb to do when it gets an error response?

and, also, CTRL+C from lldb doesn't interrupt lldb-server. If anyone know why this might be happening, I'd be glad to hear it.

Seems to work for me (in that I get back to the lldb prompt and the server connection is terminated), if I press ^C twice.

$ bin/lldb
(lldb) process attach --name asdgoijhpweiogjawe -w
^C^C
... Interrupted.
(lldb) ^D

lldb/include/lldb/Target/Process.h

113–114

Just delete this, that's the default. If you really want to be explicit, you can put = llvm::None in the member declaration.

221–222

I'd make that std::chrono::(micro)seconds

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

136

Sounds like a good idea.

lldb/include/lldb/lldb-enumerations.h

600–601

What's up with this? Though this is the first time I see this table, I suspect it is not necessary to create a new command argument....

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

261–273

I'm not sure this is really useful. We could infer that the packet is not supported by the "unsupported" response to the packet itself...

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

388

I think this ought to be steady_clock

394

<= target ? In case of a zero timeout, I guess this should loop at least once. Or, even better:

do {
  ...
} while (std::chrono::steady_clock::now() < target);

(At that point it does not matter whether it's < or <=).

3377–3378

This is not an approved use of auto: https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable.

[augusto2112]

In D96176#2546777, @labath wrote:

One alternative could be to just tack on some extra data to the existing vAttach family packets (vAttachWait;foo;interval:47;duration=74).

This was how I did it originally on https://reviews.llvm.org/D93895. @clayborg pointed out that this might not be compatible with existing lldb-server implementations, and suggested a new packet.

Lastly, this current implementation has a bug I couldn't figure out, where if we're sending l an error response, lldb loses connection to lldb-server (this happens even if the first thing I do in the handle_jAttachWait function is return an error)

I'm not sure that's a bug (i.e., lldb may be intentionally dropping the connection). What would you expect lldb to do when it gets an error response?

To expand on the error, if I change handle_vAttachWait to immediately return an error with string "foo", lldb will print out: error: attach failed: foo, while if I do the same on handle_jAttachWait if will print out: error: attach failed: lost connection, so we lose the error message.

and, also, CTRL+C from lldb doesn't interrupt lldb-server. If anyone know why this might be happening, I'd be glad to hear it.

Seems to work for me (in that I get back to the lldb prompt and the server connection is terminated), if I press ^C twice.

What I mean is that my new packet has these problems, and vAttachWait doesn't. I'm confused because I believe I implemented all the parts the same as the other vAttach functions.

Also, I misunderstood the bug I was having. It looks like two ^C will interrupt my function as well, the problem is that it lags for around 5 seconds before doing so (and I was inputing a third ^C before the interrupt, which killed lldb, and left lldb-server running), whereas the vAttachWait variant interrupts immediately.

lldb/include/lldb/Target/Process.h

221–222

I agree that using chrono would make it evident what the units are.

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

136

Sure! I was considering that as well. I wasn't sure what granularity lldb's packets should have, which is why I decided to start only with the attachWait first and see what you thought. I can include this in this patch, I don't think it's a lot of extra work.

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

261–273

Do you mean the qJAttachWaitSupported packet? I'm mimicking the existing qVAttachOrWaitSupported packet, I think it's good to use the same pattern, no?

[labath]

In D96176#2547324, @augusto2112 wrote:

In D96176#2546777, @labath wrote:

One alternative could be to just tack on some extra data to the existing vAttach family packets (vAttachWait;foo;interval:47;duration=74).

This was how I did it originally on https://reviews.llvm.org/D93895. @clayborg pointed out that this might not be compatible with existing lldb-server implementations, and suggested a new packet.

If we only append the extra fields when the user explicitly requests them, then I don't think this would be a compatibility issue. The way I see it, one of two things can happen in this case:
a) the server ignores the extra fields and completes the attach with the default values
b) the server balks at the packet, and returns an error
I think both of them are reasonable results and they can be fixed/worked around in the same way -- just drop the special requests...

Lastly, this current implementation has a bug I couldn't figure out, where if we're sending l an error response, lldb loses connection to lldb-server (this happens even if the first thing I do in the handle_jAttachWait function is return an error)

I'm not sure that's a bug (i.e., lldb may be intentionally dropping the connection). What would you expect lldb to do when it gets an error response?

To expand on the error, if I change handle_vAttachWait to immediately return an error with string "foo", lldb will print out: error: attach failed: foo, while if I do the same on handle_jAttachWait if will print out: error: attach failed: lost connection, so we lose the error message.

and, also, CTRL+C from lldb doesn't interrupt lldb-server. If anyone know why this might be happening, I'd be glad to hear it.

Seems to work for me (in that I get back to the lldb prompt and the server connection is terminated), if I press ^C twice.

What I mean is that my new packet has these problems, and vAttachWait doesn't. I'm confused because I believe I implemented all the parts the same as the other vAttach functions.

Hm.. I don't know.. I guess you'll have to step through the code to find where it diverges...

[augusto2112]

Address comments

[augusto2112]

In D96176#2546777, @labath wrote:

I'm not sure this new functionality is really worth the new packet (or two), but if it solves a use case you care about, then I suppose that's fine.

To be honest, I started this as I thought it'd be useful to LLDB users. If you think it's more trouble than it's worth, I'd be OK abandoning this change (I'm also OK completing it).

In D96176#2547429, @labath wrote:

In D96176#2547324, @augusto2112 wrote:

In D96176#2546777, @labath wrote:

One alternative could be to just tack on some extra data to the existing vAttach family packets (vAttachWait;foo;interval:47;duration=74).

This was how I did it originally on https://reviews.llvm.org/D93895. @clayborg pointed out that this might not be compatible with existing lldb-server implementations, and suggested a new packet.

If we only append the extra fields when the user explicitly requests them, then I don't think this would be a compatibility issue. The way I see it, one of two things can happen in this case:
a) the server ignores the extra fields and completes the attach with the default values
b) the server balks at the packet, and returns an error
I think both of them are reasonable results and they can be fixed/worked around in the same way -- just drop the special requests...

If you guys think that's less messy, I could do that. Although I think it'd be nice to warn users if the parameters they're passing are ignored.

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

136

Actually, it looks like this would be more work than I though. I changed the name to "jAttach" but am keeping only the existing functionality so this patch doesn't get too big.

lldb/include/lldb/lldb-enumerations.h

600–601

Seems like this is necessary when adding arguments to parameters. I think that the name must match whatever is define inside the Arg tag in Options.td:

def process_attach_waitfor_interval : Option<"waitfor-interval", "I">,
  Group<2>, Arg<"WaitforInterval">,
  Desc<"The interval that waitfor uses to poll the list of processes.">;
def process_attach_waitfor_duration : Option<"waitfor-duration", "d">,
  Group<2>, Arg<"WaitforDuration">,

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

394

Good catch!

lldb/include/lldb/Target/Process.h

 //===-- Process.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 LLDB_TARGET_PROCESS_H
 #define LLDB_TARGET_PROCESS_H
 
 #include "lldb/Host/Config.h"
 
 #include <limits.h>
 
 #include <chrono>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <string>

 //
 // Describes any information that is required to attach to a process.
 
 class ProcessAttachInfo : public ProcessInstanceInfo {
 public:
   ProcessAttachInfo()
       : ProcessInstanceInfo(), m_listener_sp(), m_hijack_listener_sp(),
         m_plugin_name(), m_resume_count(0), m_wait_for_launch(false),
         m_ignore_existing(true), m_continue_once_attached(false),
         m_detach_on_error(true), m_async(false) {}
 
   ProcessAttachInfo(const ProcessLaunchInfo &launch_info)
       : ProcessInstanceInfo(), m_listener_sp(), m_hijack_listener_sp(),
         m_plugin_name(), m_resume_count(0), m_wait_for_launch(false),
         m_ignore_existing(true), m_continue_once_attached(false),
         m_detach_on_error(true), m_async(false) {
     ProcessInfo::operator=(launch_info);
     SetProcessPluginName(launch_info.GetProcessPluginName());
     SetResumeCount(launch_info.GetResumeCount());
     SetListener(launch_info.GetListener());
     SetHijackListener(launch_info.GetHijackListener());
     m_detach_on_error = launch_info.GetDetachOnError();
   }
 
   bool GetWaitForLaunch() const { return m_wait_for_launch; }
 
   void SetWaitForLaunch(bool b) { m_wait_for_launch = b; }
 
+  llvm::Optional<std::chrono::microseconds> GetWaitForLaunchInterval() const {
+    return m_wait_for_launch_interval;
+  }
+
+  void SetWaitForLaunchInterval(
+      llvm::Optional<std::chrono::microseconds> new_interval) {
+    m_wait_for_launch_interval = new_interval;
+  }
+
+  llvm::Optional<std::chrono::seconds> GetWaitForLaunchDuration() const {
+    return m_wait_for_launch_duration;
+  }
+
+  void
+  SetWaitForLaunchDuration(llvm::Optional<std::chrono::seconds> new_duration) {
+    m_wait_for_launch_duration = new_duration;
+  }
+
   bool GetAsync() const { return m_async; }
 
   void SetAsync(bool b) { m_async = b; }
 
   bool GetIgnoreExisting() const { return m_ignore_existing; }
 
   void SetIgnoreExisting(bool b) { m_ignore_existing = b; }
 
void SetProcessPluginName(llvm::StringRef plugin) {
     m_plugin_name = std::string(plugin);
   }
 
   void Clear() {
     ProcessInstanceInfo::Clear();
     m_plugin_name.clear();
     m_resume_count = 0;
     m_wait_for_launch = false;
+    m_wait_for_launch_interval = llvm::None;
+    m_wait_for_launch_duration = llvm::None;
     m_ignore_existing = true;
     m_continue_once_attached = false;
   }
 
   bool ProcessInfoSpecified() const {
     if (GetExecutableFile())
       return true;
     if (GetProcessID() != LLDB_INVALID_PROCESS_ID)
public:
   lldb::ListenerSP GetListenerForProcess(Debugger &debugger);
 
 protected:
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
   std::string m_plugin_name;
   uint32_t m_resume_count; // How many times do we resume after launching
   bool m_wait_for_launch;
+  llvm::Optional<std::chrono::microseconds> m_wait_for_launch_interval;
+  llvm::Optional<std::chrono::seconds> m_wait_for_launch_duration;
   bool m_ignore_existing;
   bool m_continue_once_attached; // Supports the use-case scenario of
                                  // immediately continuing the process once
                                  // attached.
   bool m_detach_on_error; // If we are debugging remotely, instruct the stub to
                           // detach rather than killing the target on error.
   bool m_async; // Use an async attach where we start the attach and return
                 // immediately (used by GUI programs with --waitfor so they can

lldb/include/lldb/Utility/StringExtractorGDBRemote.h

 //===-- StringExtractorGDBRemote.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 LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H
 #define LLDB_UTILITY_STRINGEXTRACTORGDBREMOTE_H
 
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringExtractor.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <string>
 
 #include <stddef.h>
 #include <stdint.h>
 
enum ServerPacketType {
     eServerPacketType_qRegisterInfo,
     eServerPacketType_qShlibInfoAddr,
     eServerPacketType_qStepPacketSupported,
     eServerPacketType_qSupported,
     eServerPacketType_qSyncThreadStateSupported,
     eServerPacketType_qThreadExtraInfo,
     eServerPacketType_qThreadStopInfo,
     eServerPacketType_qVAttachOrWaitSupported,
+    eServerPacketType_qJAttachSupported,
     eServerPacketType_qWatchpointSupportInfo,
     eServerPacketType_qWatchpointSupportInfoSupported,
     eServerPacketType_qXfer,
 
     eServerPacketType_jSignalsInfo,
     eServerPacketType_jModulesInfo,
 
     eServerPacketType_vAttach,
     eServerPacketType_vAttachWait,
     eServerPacketType_vAttachOrWait,
+    eServerPacketType_jAttach,
     eServerPacketType_vAttachName,
     eServerPacketType_vCont,
     eServerPacketType_vCont_actions, // vCont?
 
     eServerPacketType_stop_reason, // '?'
 
     eServerPacketType_c,
     eServerPacketType_C,

lldb/include/lldb/lldb-enumerations.h

enum CommandArgumentType {
   eArgTypePlatform,
   eArgTypeWatchpointID,
   eArgTypeWatchpointIDRange,
   eArgTypeWatchType,
   eArgRawInput,
   eArgTypeCommand,
   eArgTypeColumnNum,
   eArgTypeModuleUUID,
+  eArgTypeWaitforInterval,
+  eArgTypeWaitforDuration,
   eArgTypeLastArg // Always keep this entry as the last entry in this
                   // enumeration!!
 };
 
 /// Symbol types.
 // Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63
 // entries you will have to resize that field.
 enum SymbolType {

lldb/source/Commands/CommandObjectProcess.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
       case 'w':
         attach_info.SetWaitForLaunch(true);
         break;
 
       case 'i':
         attach_info.SetIgnoreExisting(false);
         break;
 
+      case 'I': {
+        uint64_t interval;
+        if (option_arg.getAsInteger(0, interval)) {
+          error.SetErrorStringWithFormat("invalid polling interval '%s'",
+                                         option_arg.str().c_str());
+        } else {
+          attach_info.SetWaitForLaunchInterval(
+              std::chrono::microseconds(interval));
+        }
+        break;
+      }
+      case 'd': {
+        uint64_t duration;
+        if (option_arg.getAsInteger(0, duration)) {
+          error.SetErrorStringWithFormat("invalid duration '%s'",
+                                         option_arg.str().c_str());
+        } else {
+          attach_info.SetWaitForLaunchDuration(std::chrono::seconds(duration));
+        }
+        break;
+      }
       default:
         llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       attach_info.Clear();

lldb/source/Commands/Options.td

let Command = "process attach" in {
   def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,
     Desc<"The process ID of an existing process to attach to.">;
   def process_attach_name : Option<"name", "n">, Group<2>, Arg<"ProcessName">,
     Desc<"The name of the process to attach to.">;
   def process_attach_include_existing : Option<"include-existing", "i">,
     Group<2>, Desc<"Include existing processes when doing attach -w.">;
   def process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
     Desc<"Wait for the process with <process-name> to launch.">;
+  def process_attach_waitfor_interval : Option<"waitfor-interval", "I">,
+    Group<2>, Arg<"WaitforInterval">,
+    Desc<"The interval that waitfor uses to poll the list of processes.">;
+  def process_attach_waitfor_duration : Option<"waitfor-duration", "d">,
+    Group<2>, Arg<"WaitforDuration">,
+    Desc<"The interval that waitfor uses to poll the list of processes.">;
 }
 
 let Command = "process continue" in {
   def process_continue_ignore_count : Option<"ignore-count", "i">,
     Arg<"UnsignedInteger">, Desc<"Ignore <N> crossings of the breakpoint (if it"
     " exists) for the currently selected thread.">;
 }
 

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

public:
   bool GetVContSupported(char flavor);
 
   bool GetpPacketSupported(lldb::tid_t tid);
 
   bool GetxPacketSupported();
 
   bool GetVAttachOrWaitSupported();
 
+  bool GetJAttachSupported();
+
   bool GetSyncThreadStateSupported();
 
   void ResetDiscoverableSettings(bool did_exec);
 
   bool GetHostInfo(bool force = false);
 
   bool GetDefaultThreadId(lldb::tid_t &tid);
 
protected:
   LazyBool m_qProcessInfo_is_valid;
   LazyBool m_qGDBServerVersion_is_valid;
   LazyBool m_supports_alloc_dealloc_memory;
   LazyBool m_supports_memory_region_info;
   LazyBool m_supports_watchpoint_support_info;
   LazyBool m_supports_detach_stay_stopped;
   LazyBool m_watchpoints_trigger_after_instruction;
   LazyBool m_attach_or_wait_reply;
+  LazyBool m_j_attach_wait_reply;
   LazyBool m_prepare_for_reg_writing_reply;
   LazyBool m_supports_p;
   LazyBool m_supports_x;
   LazyBool m_avoid_g_packets;
   LazyBool m_supports_QSaveRegisterState;
   LazyBool m_supports_qXfer_auxv_read;
   LazyBool m_supports_qXfer_libraries_read;
   LazyBool m_supports_qXfer_libraries_svr4_read;

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

: GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
       m_qProcessInfo_is_valid(eLazyBoolCalculate),
       m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
       m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
       m_supports_memory_region_info(eLazyBoolCalculate),
       m_supports_watchpoint_support_info(eLazyBoolCalculate),
       m_supports_detach_stay_stopped(eLazyBoolCalculate),
       m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
       m_attach_or_wait_reply(eLazyBoolCalculate),
+      m_j_attach_wait_reply(eLazyBoolCalculate),
       m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
       m_supports_p(eLazyBoolCalculate), m_supports_x(eLazyBoolCalculate),
       m_avoid_g_packets(eLazyBoolCalculate),
       m_supports_QSaveRegisterState(eLazyBoolCalculate),
       m_supports_qXfer_auxv_read(eLazyBoolCalculate),
       m_supports_qXfer_libraries_read(eLazyBoolCalculate),
       m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
       m_supports_qXfer_features_read(eLazyBoolCalculate),
if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response,
                                      false) == PacketResult::Success) {
       if (response.IsOKResponse())
         m_attach_or_wait_reply = eLazyBoolYes;
     }
   }
   return m_attach_or_wait_reply == eLazyBoolYes;
 }
 
+bool GDBRemoteCommunicationClient::GetJAttachSupported() {
+  if (m_j_attach_wait_reply == eLazyBoolCalculate) {
+    m_j_attach_wait_reply = eLazyBoolNo;
+
+    StringExtractorGDBRemote response;
+    if (SendPacketAndWaitForResponse("qJAttachSupported", response, false) ==
+        PacketResult::Success) {
+      if (response.IsOKResponse())
+        m_j_attach_wait_reply = eLazyBoolYes;
+    }
+  }
+  return m_j_attach_wait_reply == eLazyBoolYes;
+}
+
 bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() {
   if (m_prepare_for_reg_writing_reply == eLazyBoolCalculate) {
     m_prepare_for_reg_writing_reply = eLazyBoolNo;
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response,
                                      false) == PacketResult::Success) {
       if (response.IsOKResponse())
if (!did_exec) {
     m_supports_QSaveRegisterState = eLazyBoolCalculate;
     m_qHostInfo_is_valid = eLazyBoolCalculate;
     m_curr_pid_is_valid = eLazyBoolCalculate;
     m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
     m_supports_memory_region_info = eLazyBoolCalculate;
     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
     m_attach_or_wait_reply = eLazyBoolCalculate;
+    m_j_attach_wait_reply = eLazyBoolCalculate;
     m_avoid_g_packets = eLazyBoolCalculate;
     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qXfer_features_read = eLazyBoolCalculate;
     m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_qProcessInfoPID = true;

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

 //===-- GDBRemoteCommunicationServerLLGS.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 LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
 #define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
 
 #include <mutex>
 #include <unordered_map>
 
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
 #include "GDBRemoteCommunicationServerCommon.h"
 
 class StringExtractorGDBRemote;
 
public:
   Status AttachToProcess(lldb::pid_t pid);
 
   /// Wait to attach to a process with a given name.
   ///
   /// This method supports waiting for the next instance of a process
   /// with a given name and attaching llgs to that via the configured
   /// Platform.
   ///
+  /// \param process_name
+  ///     The process we'd like to attach to.
+  /// \param include_existing
+  ///     Look for the process we'd like to attach to among the processes
+  ///     already running.
+  /// \param custom_polling_interval
+  ///     The polling interval the function should use in microseconds. Defaults
+  ///     to 1000.
+  /// \param timeout
+  ///     How long we should look for the process in seconds. Defaults to
+  ///     infinity.
+  ///
   /// \return
   ///     An Status object indicating the success or failure of the
   ///     attach operation.
-  Status AttachWaitProcess(llvm::StringRef process_name, bool include_existing);
+  Status AttachWaitProcess(
+      llvm::StringRef process_name, bool include_existing,
+      llvm::Optional<std::chrono::microseconds> custom_polling_interval =
+          llvm::None,
+      llvm::Optional<std::chrono::seconds> timeout = llvm::None);
 
   // NativeProcessProtocol::NativeDelegate overrides
   void InitializeDelegate(NativeProcessProtocol *process) override;
 
   void ProcessStateChanged(NativeProcessProtocol *process,
                            lldb::StateType state) override;
 
   void DidExec(NativeProcessProtocol *process) override;
protected:
   PacketResult Handle_vAttach(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttachWait(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qVAttachOrWaitSupported(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_vAttachOrWait(StringExtractorGDBRemote &packet);
 
+  PacketResult Handle_qJAttachSupported(StringExtractorGDBRemote &packet);
+
+  PacketResult Handle_jAttach(StringExtractorGDBRemote &packet);
+
   PacketResult Handle_D(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qThreadStopInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jThreadsInfo(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_qWatchpointSupportInfo(StringExtractorGDBRemote &packet);
 

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

 //===-- GDBRemoteCommunicationServerLLGS.cpp ------------------------------===//
 //
 // 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 <errno.h>
 
 #include "lldb/Host/Config.h"
 
 
 #include <chrono>
 #include <cstring>
 #include <thread>
 
 #include "GDBRemoteCommunicationServerLLGS.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
RegisterMemberFunctionHandler(
       &GDBRemoteCommunicationServerLLGS::Handle_vAttachWait);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qVAttachOrWaitSupported,
       &GDBRemoteCommunicationServerLLGS::Handle_qVAttachOrWaitSupported);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vAttachOrWait,
       &GDBRemoteCommunicationServerLLGS::Handle_vAttachOrWait);
   RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_qJAttachSupported,
+      &GDBRemoteCommunicationServerLLGS::Handle_qJAttachSupported);
+  RegisterMemberFunctionHandler(
+      StringExtractorGDBRemote::eServerPacketType_jAttach,
+      &GDBRemoteCommunicationServerLLGS::Handle_jAttach);
+  RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vCont,
       &GDBRemoteCommunicationServerLLGS::Handle_vCont);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_vCont_actions,
       &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_x,
       &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
LLDB_LOGF(log,
               __FUNCTION__, terminal_fd);
   }
 
   printf("Attached to process %" PRIu64 "...\n", pid);
   return Status();
 }
 
 Status GDBRemoteCommunicationServerLLGS::AttachWaitProcess(
-    llvm::StringRef process_name, bool include_existing) {
+    llvm::StringRef process_name, bool include_existing,
+    llvm::Optional<std::chrono::microseconds> custom_polling_interval,
+    llvm::Optional<std::chrono::seconds> timeout) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
-  std::chrono::milliseconds polling_interval = std::chrono::milliseconds(1);
+  auto polling_interval =
+      custom_polling_interval.getValueOr(std::chrono::microseconds(1000));
 
   // Create the matcher used to search the process list.
   ProcessInstanceInfoList exclusion_list;
   ProcessInstanceInfoMatch match_info;
   match_info.GetProcessInfo().GetExecutableFile().SetFile(
       process_name, llvm::sys::path::Style::native);
   match_info.SetNameMatchType(NameMatch::Equals);
 
auto is_in_exclusion_list =
       [&exclusion_list](const ProcessInstanceInfo &info) {
         for (auto &excluded : exclusion_list) {
           if (excluded.GetProcessID() == info.GetProcessID())
             return true;
         }
         return false;
       };
 
+  auto target = std::chrono::steady_clock::now();
+  if (timeout.hasValue())
+    target = std::chrono::steady_clock::now() +
+             std::chrono::seconds(timeout.getValue());
+
   ProcessInstanceInfoList loop_process_list;
-  while (true) {
+  do {
     loop_process_list.clear();
     if (Host::FindProcesses(match_info, loop_process_list)) {
       // Remove all the elements that are in the exclusion list.
       llvm::erase_if(loop_process_list, is_in_exclusion_list);
 
       // One match! We found the desired process.
       if (loop_process_list.size() == 1) {
         auto matching_process_pid = loop_process_list[0].GetProcessID();
if (Host::FindProcesses(match_info, loop_process_list)) {
         error_stream.Format("{0}.", loop_process_list.back().GetProcessID());
 
         Status error;
         error.SetErrorString(error_stream.GetString());
         return error;
       }
     }
     // No matches, we have not found the process. Sleep until next poll.
-    LLDB_LOG(log, "sleep {0} seconds", polling_interval);
+    LLDB_LOG(log, "sleep for {0}", polling_interval);
     std::this_thread::sleep_for(polling_interval);
-  }
+  } while (!timeout.hasValue() || std::chrono::steady_clock::now() < target);
+
+  // Timed out
+  Status error;
+  error.SetErrorString("attach timed out.");
+  return error;
 }
 
 void GDBRemoteCommunicationServerLLGS::InitializeDelegate(
     NativeProcessProtocol *process) {
   assert(process && "process cannot be NULL");
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
   if (log) {
     LLDB_LOGF(log,
if (error.Fail()) {
     return SendErrorResponse(error);
   }
 
   // Notify we attached by sending a stop packet.
   return SendStopReasonForState(m_debugged_process_up->GetState());
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_qJAttachSupported(
+    StringExtractorGDBRemote &packet) {
+  return SendOKResponse();
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServerLLGS::Handle_jAttach(
+    StringExtractorGDBRemote &packet) {
+  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  if (!packet.ConsumeFront("jAttach:"))
+    return SendIllFormedResponse(packet, "jAttach: Ill formed packet ");
+
+  auto json_object = StructuredData::ParseJSON(packet.Peek());
+
+  if (!json_object ||
+      json_object->GetType() != lldb::eStructuredDataTypeDictionary)
+    return SendIllFormedResponse(packet, "jAttach: Ill formed packet ");
+
+  auto *json_dict = json_object->GetAsDictionary();
+
+  StringRef process_name;
+  llvm::Optional<std::chrono::microseconds> polling_interval;
+  llvm::Optional<std::chrono::seconds> polling_duration;
+  bool include_existing = false;
+  uint64_t temp;
+
+  json_dict->GetValueForKeyAsString("process_name", process_name);
+  json_dict->GetValueForKeyAsBoolean("include-existing", include_existing);
+  if (json_dict->GetValueForKeyAsInteger("waitfor-interval-usec", temp))
+    polling_interval = std::chrono::microseconds(temp);
+  if (json_dict->GetValueForKeyAsInteger("waitfor-duration-sec", temp))
+    polling_duration = std::chrono::seconds(temp);
+
+  LLDB_LOG(log, "attempting to attach to process named '{0}'", process_name);
+
+  Status error = AttachWaitProcess(process_name, include_existing,
+                                   polling_interval, polling_duration);
+  if (error.Fail()) {
+    LLDB_LOG(log, "failed to attach to process named '{0}': {1}", process_name,
+             error);
+    return SendErrorResponse(error);
+  }
+
+  // Notify we attached by sending a stop packet.
+  return SendStopReasonForState(m_debugged_process_up->GetState());
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   StopSTDIOForwarding();
 
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {

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

 //===-- ProcessGDBRemote.cpp ----------------------------------------------===//
 //
 // 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/Config.h"
 
 #include <errno.h>
 #include <stdlib.h>
 #if LLDB_ENABLE_POSIX
 #include <netinet/in.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <unistd.h>
if (error.Success()) {
           eBroadcastBitAsyncContinue, new EventDataBytes(packet, packet_len));
     } else
       SetExitStatus(-1, error.AsCString());
   }
 
   return error;
 }
 
+static StreamGDBRemote MakeJAttachPacket(const char *process_name,
+                                         const ProcessAttachInfo &attach_info) {
+
+  StreamString json_string;
+  json_string.PutCString("jAttach:");
+
+  StructuredData::Dictionary json_packet;
+  json_packet.AddStringItem("process_name", process_name);
+
+  if (auto interval = attach_info.GetWaitForLaunchInterval())
+    json_packet.AddIntegerItem("waitfor-interval-usec", interval->count());
+
+  if (auto duration = attach_info.GetWaitForLaunchDuration())
+    json_packet.AddIntegerItem("waitfor-duration-sec", duration->count());
+
+  json_packet.AddBooleanItem("include-existing",
+                             !attach_info.GetIgnoreExisting());
+
+  json_packet.Dump(json_string, false);
+  StreamGDBRemote escaped_packet;
+  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
+  return escaped_packet;
+}
+
 Status ProcessGDBRemote::DoAttachToProcessWithName(
     const char *process_name, const ProcessAttachInfo &attach_info) {
   Status error;
   // Clear out and clean up from any current state
   Clear();
 
-  if (process_name && process_name[0]) {
-    error = EstablishConnectionIfNeeded(attach_info);
-    if (error.Success()) {
-      StreamString packet;
+  if (!process_name || !process_name[0])
+    return error;
+
+  if (!error.Success()) {
+    SetExitStatus(-1, error.AsCString());
+    return error;
+  }
 
-      m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
-
-      if (attach_info.GetWaitForLaunch()) {
-        if (!m_gdb_comm.GetVAttachOrWaitSupported()) {
-          packet.PutCString("vAttachWait");
-        } else {
-          if (attach_info.GetIgnoreExisting())
-            packet.PutCString("vAttachWait");
-          else
-            packet.PutCString("vAttachOrWait");
-        }
-      } else
-        packet.PutCString("vAttachName");
-      packet.PutChar(';');
-      packet.PutBytesAsRawHex8(process_name, strlen(process_name),
-                               endian::InlHostByteOrder(),
-                               endian::InlHostByteOrder());
-
-      m_async_broadcaster.BroadcastEvent(
-          eBroadcastBitAsyncContinue,
-          new EventDataBytes(packet.GetString().data(), packet.GetSize()));
-
-    } else
-      SetExitStatus(-1, error.AsCString());
+  if (attach_info.GetWaitForLaunch() && m_gdb_comm.GetJAttachSupported()) {
+    auto gdb_stream = MakeJAttachPacket(process_name, attach_info);
+    m_async_broadcaster.BroadcastEvent(
+        eBroadcastBitAsyncContinue,
+        new EventDataBytes(gdb_stream.GetString().data(),
+                           gdb_stream.GetSize()));
+  } else {
+    StreamString packet;
   }
   return error;
 }
 
 lldb::user_id_t ProcessGDBRemote::StartTrace(const TraceOptions &options,
                                              Status &error) {
   return m_gdb_comm.SendStartTracePacket(options, error);
 }

lldb/source/Utility/StringExtractorGDBRemote.cpp

 //===-- StringExtractorGDBRemote.cpp --------------------------------------===//
 //
 // 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/Utility/StringExtractorGDBRemote.h"
 
 #include <ctype.h>
 #include <string.h>
 
 StringExtractorGDBRemote::ResponseType
 StringExtractorGDBRemote::GetResponseType() const {
   if (m_packet.empty())
     return eUnsupported;
case 'G':
       if (PACKET_MATCHES("qGDBServerVersion"))
         return eServerPacketType_qGDBServerVersion;
       break;
 
     case 'H':
       if (PACKET_MATCHES("qHostInfo"))
         return eServerPacketType_qHostInfo;
       break;
-
+    case 'J':
+      if (PACKET_MATCHES("qJAttachSupported"))
+        return eServerPacketType_qJAttachSupported;
+      break;
     case 'K':
       if (PACKET_STARTS_WITH("qKillSpawnedProcess"))
         return eServerPacketType_qKillSpawnedProcess;
       break;
 
     case 'L':
       if (PACKET_STARTS_WITH("qLaunchGDBServer"))
         return eServerPacketType_qLaunchGDBServer;
case 'q':
     case 'X':
       if (PACKET_STARTS_WITH("qXfer:"))
         return eServerPacketType_qXfer;
       break;
     }
     break;
 
   case 'j':
+    if (PACKET_STARTS_WITH("jAttach:"))
+      return eServerPacketType_jAttach;
     if (PACKET_STARTS_WITH("jModulesInfo:"))
       return eServerPacketType_jModulesInfo;
     if (PACKET_MATCHES("jSignalsInfo"))
       return eServerPacketType_jSignalsInfo;
     if (PACKET_MATCHES("jThreadsInfo"))
       return eServerPacketType_jThreadsInfo;
     if (PACKET_STARTS_WITH("jTraceBufferRead:"))
       return eServerPacketType_jTraceBufferRead;