LLDB mainline
ProcessKDP.cpp
Go to the documentation of this file.
1//===-- ProcessKDP.cpp ----------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include <cerrno>
10#include <cstdlib>
11
12#include <memory>
13#include <mutex>
14
15#include "lldb/Core/Debugger.h"
16#include "lldb/Core/Module.h"
20#include "lldb/Host/Host.h"
32#include "lldb/Target/Target.h"
33#include "lldb/Target/Thread.h"
35#include "lldb/Utility/Log.h"
36#include "lldb/Utility/State.h"
38#include "lldb/Utility/UUID.h"
39
40#include "llvm/Support/Threading.h"
41
42#define USEC_PER_SEC 1000000
43
46#include "ProcessKDP.h"
47#include "ProcessKDPLog.h"
48#include "ThreadKDP.h"
49
50using namespace lldb;
51using namespace lldb_private;
52
53LLDB_PLUGIN_DEFINE_ADV(ProcessKDP, ProcessMacOSXKernel)
54
55namespace {
56
57#define LLDB_PROPERTIES_processkdp
58#include "ProcessKDPProperties.inc"
59
60enum {
61#define LLDB_PROPERTIES_processkdp
62#include "ProcessKDPPropertiesEnum.inc"
63};
64
65class PluginProperties : public Properties {
66public:
67 static llvm::StringRef GetSettingName() {
69 }
70
71 PluginProperties() : Properties() {
72 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
73 m_collection_sp->Initialize(g_processkdp_properties);
74 }
75
76 ~PluginProperties() override = default;
77
78 uint64_t GetPacketTimeout() {
79 const uint32_t idx = ePropertyKDPPacketTimeout;
80 return GetPropertyAtIndexAs<uint64_t>(
81 idx, g_processkdp_properties[idx].default_uint_value);
82 }
83};
84
85} // namespace
86
87static PluginProperties &GetGlobalPluginProperties() {
88 static PluginProperties g_settings;
89 return g_settings;
90}
91
92static const lldb::tid_t g_kernel_tid = 1;
93
95 return "KDP Remote protocol based debugging plug-in for darwin kernel "
96 "debugging.";
97}
98
101}
102
104 ListenerSP listener_sp,
105 const FileSpec *crash_file_path,
106 bool can_connect) {
107 lldb::ProcessSP process_sp;
108 if (crash_file_path == NULL)
109 process_sp = std::make_shared<ProcessKDP>(target_sp, listener_sp);
110 return process_sp;
111}
112
113bool ProcessKDP::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
114 if (plugin_specified_by_name)
115 return true;
116
117 // For now we are just making sure the file exists for a given module
118 Module *exe_module = target_sp->GetExecutableModulePointer();
119 if (exe_module) {
120 const llvm::Triple &triple_ref = target_sp->GetArchitecture().GetTriple();
121 switch (triple_ref.getOS()) {
122 case llvm::Triple::Darwin: // Should use "macosx" for desktop and "ios" for
123 // iOS, but accept darwin just in case
124 case llvm::Triple::MacOSX: // For desktop targets
125 case llvm::Triple::IOS: // For arm targets
126 case llvm::Triple::TvOS:
127 case llvm::Triple::WatchOS:
128 case llvm::Triple::XROS:
129 if (triple_ref.getVendor() == llvm::Triple::Apple) {
130 ObjectFile *exe_objfile = exe_module->GetObjectFile();
131 if (exe_objfile->GetType() == ObjectFile::eTypeExecutable &&
132 exe_objfile->GetStrata() == ObjectFile::eStrataKernel)
133 return true;
134 }
135 break;
136
137 default:
138 break;
139 }
140 }
141 return false;
142}
143
144// ProcessKDP constructor
146 : Process(target_sp, listener_sp),
147 m_comm("lldb.process.kdp-remote.communication"),
148 m_async_broadcaster(NULL, "lldb.process.kdp-remote.async-broadcaster"),
149 m_kernel_load_addr(LLDB_INVALID_ADDRESS), m_command_sp(),
150 m_kernel_thread_wp() {
152 "async thread should exit");
154 "async thread continue");
155 const uint64_t timeout_seconds =
156 GetGlobalPluginProperties().GetPacketTimeout();
157 if (timeout_seconds > 0)
158 m_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds));
159}
160
161// Destructor
163 Clear();
164 // We need to call finalize on the process before destroying ourselves to
165 // make sure all of the broadcaster cleanup goes as planned. If we destruct
166 // this class, then Process::~Process() might have problems trying to fully
167 // destroy the broadcaster.
168 Finalize(true /* destructing */);
169}
170
173 error.SetErrorString("launching not supported in kdp-remote plug-in");
174 return error;
175}
176
179 error.SetErrorString(
180 "attaching to a by process ID not supported in kdp-remote plug-in");
181 return error;
182}
183
185 bool wait_for_launch) {
187 error.SetErrorString(
188 "attaching to a by process name not supported in kdp-remote plug-in");
189 return error;
190}
191
193 uint32_t cpu = m_comm.GetCPUType();
194 if (cpu) {
195 uint32_t sub = m_comm.GetCPUSubtype();
196 arch.SetArchitecture(eArchTypeMachO, cpu, sub);
197 // Leave architecture vendor as unspecified unknown
198 arch.GetTriple().setVendor(llvm::Triple::UnknownVendor);
199 arch.GetTriple().setVendorName(llvm::StringRef());
200 return true;
201 }
202 arch.Clear();
203 return false;
204}
205
206Status ProcessKDP::DoConnectRemote(llvm::StringRef remote_url) {
208
209 // Don't let any JIT happen when doing KDP as we can't allocate memory and we
210 // don't want to be mucking with threads that might already be handling
211 // exceptions
212 SetCanJIT(false);
213
214 if (remote_url.empty()) {
215 error.SetErrorStringWithFormat("empty connection URL");
216 return error;
217 }
218
219 std::unique_ptr<ConnectionFileDescriptor> conn_up(
221 if (conn_up) {
222 // Only try once for now.
223 // TODO: check if we should be retrying?
224 const uint32_t max_retry_count = 1;
225 for (uint32_t retry_count = 0; retry_count < max_retry_count;
226 ++retry_count) {
227 if (conn_up->Connect(remote_url, &error) == eConnectionStatusSuccess)
228 break;
229 usleep(100000);
230 }
231 }
232
233 if (conn_up->IsConnected()) {
234 const TCPSocket &socket =
235 static_cast<const TCPSocket &>(*conn_up->GetReadObject());
236 const uint16_t reply_port = socket.GetLocalPortNumber();
237
238 if (reply_port != 0) {
239 m_comm.SetConnection(std::move(conn_up));
240
241 if (m_comm.SendRequestReattach(reply_port)) {
242 if (m_comm.SendRequestConnect(reply_port, reply_port,
243 "Greetings from LLDB...")) {
245
246 Target &target = GetTarget();
247 ArchSpec kernel_arch;
248 // The host architecture
249 GetHostArchitecture(kernel_arch);
250 ArchSpec target_arch = target.GetArchitecture();
251 // Merge in any unspecified stuff into the target architecture in
252 // case the target arch isn't set at all or incompletely.
253 target_arch.MergeFrom(kernel_arch);
254 target.SetArchitecture(target_arch);
255
256 /* Get the kernel's UUID and load address via KDP_KERNELVERSION
257 * packet. */
258 /* An EFI kdp session has neither UUID nor load address. */
259
260 UUID kernel_uuid = m_comm.GetUUID();
261 addr_t kernel_load_addr = m_comm.GetLoadAddress();
262
263 if (m_comm.RemoteIsEFI()) {
264 // Select an invalid plugin name for the dynamic loader so one
265 // doesn't get used since EFI does its own manual loading via
266 // python scripting
267 m_dyld_plugin_name = "none";
268
269 if (kernel_uuid.IsValid()) {
270 // If EFI passed in a UUID= try to lookup UUID The slide will not
271 // be provided. But the UUID lookup will be used to launch EFI
272 // debug scripts from the dSYM, that can load all of the symbols.
273 ModuleSpec module_spec;
274 module_spec.GetUUID() = kernel_uuid;
275 module_spec.GetArchitecture() = target.GetArchitecture();
276
277 // Lookup UUID locally, before attempting dsymForUUID like action
278 FileSpecList search_paths =
280 module_spec.GetSymbolFileSpec() =
282 search_paths);
283 if (module_spec.GetSymbolFileSpec()) {
284 ModuleSpec executable_module_spec =
286 if (FileSystem::Instance().Exists(
287 executable_module_spec.GetFileSpec())) {
288 module_spec.GetFileSpec() =
289 executable_module_spec.GetFileSpec();
290 }
291 }
292 if (!module_spec.GetSymbolFileSpec() ||
293 !module_spec.GetSymbolFileSpec()) {
294 Status symbl_error;
296 symbl_error, true);
297 }
298
299 if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
300 ModuleSP module_sp(new Module(module_spec));
301 if (module_sp.get() && module_sp->GetObjectFile()) {
302 // Get the current target executable
303 ModuleSP exe_module_sp(target.GetExecutableModule());
304
305 // Make sure you don't already have the right module loaded
306 // and they will be uniqued
307 if (exe_module_sp.get() != module_sp.get())
308 target.SetExecutableModule(module_sp, eLoadDependentsNo);
309 }
310 }
311 }
312 } else if (m_comm.RemoteIsDarwinKernel()) {
315 if (kernel_load_addr != LLDB_INVALID_ADDRESS) {
316 m_kernel_load_addr = kernel_load_addr;
317 }
318 }
319
320 // Set the thread ID
322 SetID(1);
325 StreamSP async_strm_sp(target.GetDebugger().GetAsyncOutputStream());
326 if (async_strm_sp) {
327 const char *cstr;
328 if ((cstr = m_comm.GetKernelVersion()) != NULL) {
329 async_strm_sp->Printf("Version: %s\n", cstr);
330 async_strm_sp->Flush();
331 }
332 // if ((cstr = m_comm.GetImagePath ()) != NULL)
333 // {
334 // async_strm_sp->Printf ("Image Path:
335 // %s\n", cstr);
336 // async_strm_sp->Flush();
337 // }
338 }
339 } else {
340 error.SetErrorString("KDP_REATTACH failed");
341 }
342 } else {
343 error.SetErrorString("KDP_REATTACH failed");
344 }
345 } else {
346 error.SetErrorString("invalid reply port from UDP connection");
347 }
348 } else {
349 if (error.Success())
350 error.SetErrorStringWithFormat("failed to connect to '%s'",
351 remote_url.str().c_str());
352 }
353 if (error.Fail())
355
356 return error;
357}
358
359// Process Control
361 ProcessLaunchInfo &launch_info) {
363 error.SetErrorString("launching not supported in kdp-remote plug-in");
364 return error;
365}
366
367Status
369 const ProcessAttachInfo &attach_info) {
371 error.SetErrorString(
372 "attach to process by ID is not supported in kdp remote debugging");
373 return error;
374}
375
376Status
378 const ProcessAttachInfo &attach_info) {
380 error.SetErrorString(
381 "attach to process by name is not supported in kdp remote debugging");
382 return error;
383}
384
385void ProcessKDP::DidAttach(ArchSpec &process_arch) {
386 Process::DidAttach(process_arch);
387
388 Log *log = GetLog(KDPLog::Process);
389 LLDB_LOGF(log, "ProcessKDP::DidAttach()");
391 GetHostArchitecture(process_arch);
392 }
393}
394
396
398 if (m_dyld_up.get() == NULL)
400 return m_dyld_up.get();
401}
402
404
407 Log *log = GetLog(KDPLog::Process);
408 // Only start the async thread if we try to do any process control
411
412 bool resume = false;
413
414 // With KDP there is only one thread we can tell what to do
416
417 if (kernel_thread_sp) {
418 const StateType thread_resume_state =
419 kernel_thread_sp->GetTemporaryResumeState();
420
421 LLDB_LOGF(log, "ProcessKDP::DoResume() thread_resume_state = %s",
422 StateAsCString(thread_resume_state));
423 switch (thread_resume_state) {
424 case eStateSuspended:
425 // Nothing to do here when a thread will stay suspended we just leave the
426 // CPU mask bit set to zero for the thread
427 LLDB_LOGF(log, "ProcessKDP::DoResume() = suspended???");
428 break;
429
430 case eStateStepping: {
431 lldb::RegisterContextSP reg_ctx_sp(
432 kernel_thread_sp->GetRegisterContext());
433
434 if (reg_ctx_sp) {
435 LLDB_LOGF(
436 log,
437 "ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep (true);");
438 reg_ctx_sp->HardwareSingleStep(true);
439 resume = true;
440 } else {
441 error.SetErrorStringWithFormat(
442 "KDP thread 0x%llx has no register context",
443 kernel_thread_sp->GetID());
444 }
445 } break;
446
447 case eStateRunning: {
448 lldb::RegisterContextSP reg_ctx_sp(
449 kernel_thread_sp->GetRegisterContext());
450
451 if (reg_ctx_sp) {
452 LLDB_LOGF(log, "ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep "
453 "(false);");
454 reg_ctx_sp->HardwareSingleStep(false);
455 resume = true;
456 } else {
457 error.SetErrorStringWithFormat(
458 "KDP thread 0x%llx has no register context",
459 kernel_thread_sp->GetID());
460 }
461 } break;
462
463 default:
464 // The only valid thread resume states are listed above
465 llvm_unreachable("invalid thread resume state");
466 }
467 }
468
469 if (resume) {
470 LLDB_LOGF(log, "ProcessKDP::DoResume () sending resume");
471
475 } else
476 error.SetErrorString("KDP resume failed");
477 } else {
478 error.SetErrorString("kernel thread is suspended");
479 }
480
481 return error;
482}
483
485 // KDP only tells us about one thread/core. Any other threads will usually
486 // be the ones that are read from memory by the OS plug-ins.
487
488 ThreadSP thread_sp(m_kernel_thread_wp.lock());
489 if (!thread_sp) {
490 thread_sp = std::make_shared<ThreadKDP>(*this, g_kernel_tid);
491 m_kernel_thread_wp = thread_sp;
492 }
493 return thread_sp;
494}
495
497 ThreadList &new_thread_list) {
498 // locker will keep a mutex locked until it goes out of scope
499 Log *log = GetLog(KDPLog::Thread);
500 LLDB_LOGV(log, "pid = {0}", GetID());
501
502 // Even though there is a CPU mask, it doesn't mean we can see each CPU
503 // individually, there is really only one. Lets call this thread 1.
504 ThreadSP thread_sp(
505 old_thread_list.FindThreadByProtocolID(g_kernel_tid, false));
506 if (!thread_sp)
507 thread_sp = GetKernelThread();
508 new_thread_list.AddThread(thread_sp);
509
510 return new_thread_list.GetSize(false) > 0;
511}
512
514 // Let all threads recover from stopping and do any clean up based on the
515 // previous thread state (if any).
517}
518
519Status ProcessKDP::DoHalt(bool &caused_stop) {
521
522 if (m_comm.IsRunning()) {
524 // If we are attempting to destroy, we need to not return an error to Halt
525 // or DoDestroy won't get called. We are also currently running, so send
526 // a process stopped event
528 } else {
529 error.SetErrorString("KDP cannot interrupt a running kernel");
530 }
531 }
532 return error;
533}
534
535Status ProcessKDP::DoDetach(bool keep_stopped) {
537 Log *log = GetLog(KDPLog::Process);
538 LLDB_LOGF(log, "ProcessKDP::DoDetach(keep_stopped = %i)", keep_stopped);
539
540 if (m_comm.IsRunning()) {
541 // We are running and we can't interrupt a running kernel, so we need to
542 // just close the connection to the kernel and hope for the best
543 } else {
544 // If we are going to keep the target stopped, then don't send the
545 // disconnect message.
546 if (!keep_stopped && m_comm.IsConnected()) {
547 const bool success = m_comm.SendRequestDisconnect();
548 if (log) {
549 if (success)
550 log->PutCString(
551 "ProcessKDP::DoDetach() detach packet sent successfully");
552 else
553 log->PutCString(
554 "ProcessKDP::DoDetach() connection channel shutdown failed");
555 }
557 }
558 }
560 m_comm.Clear();
561
564
565 // KillDebugserverProcess ();
566 return error;
567}
568
570 // For KDP there really is no difference between destroy and detach
571 bool keep_stopped = false;
572 return DoDetach(keep_stopped);
573}
574
575// Process Queries
576
578 return m_comm.IsConnected() && Process::IsAlive();
579}
580
581// Process Memory
582size_t ProcessKDP::DoReadMemory(addr_t addr, void *buf, size_t size,
583 Status &error) {
584 uint8_t *data_buffer = (uint8_t *)buf;
585 if (m_comm.IsConnected()) {
586 const size_t max_read_size = 512;
587 size_t total_bytes_read = 0;
588
589 // Read the requested amount of memory in 512 byte chunks
590 while (total_bytes_read < size) {
591 size_t bytes_to_read_this_request = size - total_bytes_read;
592 if (bytes_to_read_this_request > max_read_size) {
593 bytes_to_read_this_request = max_read_size;
594 }
595 size_t bytes_read = m_comm.SendRequestReadMemory(
596 addr + total_bytes_read, data_buffer + total_bytes_read,
597 bytes_to_read_this_request, error);
598 total_bytes_read += bytes_read;
599 if (error.Fail() || bytes_read == 0) {
600 return total_bytes_read;
601 }
602 }
603
604 return total_bytes_read;
605 }
606 error.SetErrorString("not connected");
607 return 0;
608}
609
610size_t ProcessKDP::DoWriteMemory(addr_t addr, const void *buf, size_t size,
611 Status &error) {
612 if (m_comm.IsConnected())
613 return m_comm.SendRequestWriteMemory(addr, buf, size, error);
614 error.SetErrorString("not connected");
615 return 0;
616}
617
618lldb::addr_t ProcessKDP::DoAllocateMemory(size_t size, uint32_t permissions,
619 Status &error) {
620 error.SetErrorString(
621 "memory allocation not supported in kdp remote debugging");
623}
624
627 error.SetErrorString(
628 "memory deallocation not supported in kdp remote debugging");
629 return error;
630}
631
633 if (bp_site->HardwareRequired())
634 return Status("Hardware breakpoints are not supported.");
635
638 if (!bp_site->IsEnabled()) {
639 if (m_comm.SendRequestBreakpoint(true, bp_site->GetLoadAddress())) {
640 bp_site->SetEnabled(true);
642 } else {
643 error.SetErrorString("KDP set breakpoint failed");
644 }
645 }
646 return error;
647 }
648 return EnableSoftwareBreakpoint(bp_site);
649}
650
654 if (bp_site->IsEnabled()) {
655 BreakpointSite::Type bp_type = bp_site->GetType();
656 if (bp_type == BreakpointSite::eExternal) {
658 // We are trying to destroy our connection and we are running
659 bp_site->SetEnabled(false);
660 } else {
661 if (m_comm.SendRequestBreakpoint(false, bp_site->GetLoadAddress()))
662 bp_site->SetEnabled(false);
663 else
664 error.SetErrorString("KDP remove breakpoint failed");
665 }
666 } else {
668 }
669 }
670 return error;
671 }
672 return DisableSoftwareBreakpoint(bp_site);
673}
674
676
679 error.SetErrorString(
680 "sending signals is not supported in kdp remote debugging");
681 return error;
682}
683
685 static llvm::once_flag g_once_flag;
686
687 llvm::call_once(g_once_flag, []() {
691
693 });
694}
695
698 debugger, PluginProperties::GetSettingName())) {
699 const bool is_global_setting = true;
702 "Properties for the kdp-remote process plug-in.", is_global_setting);
703 }
704}
705
707 Log *log = GetLog(KDPLog::Process);
708
709 LLDB_LOGF(log, "ProcessKDP::StartAsyncThread ()");
710
712 return true;
713
714 llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread(
715 "<lldb.process.kdp-remote.async>", [this] { return AsyncThread(); });
716 if (!async_thread) {
717 LLDB_LOG_ERROR(GetLog(LLDBLog::Host), async_thread.takeError(),
718 "failed to launch host thread: {0}");
719 return false;
720 }
721 m_async_thread = *async_thread;
722 return m_async_thread.IsJoinable();
723}
724
726 Log *log = GetLog(KDPLog::Process);
727
728 LLDB_LOGF(log, "ProcessKDP::StopAsyncThread ()");
729
731
732 // Stop the stdio thread
734 m_async_thread.Join(nullptr);
735}
736
738 const lldb::pid_t pid = GetID();
739
740 Log *log = GetLog(KDPLog::Process);
741 LLDB_LOGF(log,
742 "ProcessKDP::AsyncThread(pid = %" PRIu64 ") thread starting...",
743 pid);
744
745 ListenerSP listener_sp(Listener::MakeListener("ProcessKDP::AsyncThread"));
746 EventSP event_sp;
747 const uint32_t desired_event_mask =
749
750 if (listener_sp->StartListeningForEvents(
751 &m_async_broadcaster, desired_event_mask) == desired_event_mask) {
752 bool done = false;
753 while (!done) {
754 LLDB_LOGF(log,
755 "ProcessKDP::AsyncThread (pid = %" PRIu64
756 ") listener.WaitForEvent (NULL, event_sp)...",
757 pid);
758 if (listener_sp->GetEvent(event_sp, std::nullopt)) {
759 uint32_t event_type = event_sp->GetType();
760 LLDB_LOGF(log,
761 "ProcessKDP::AsyncThread (pid = %" PRIu64
762 ") Got an event of type: %d...",
763 pid, event_type);
764
765 // When we are running, poll for 1 second to try and get an exception
766 // to indicate the process has stopped. If we don't get one, check to
767 // make sure no one asked us to exit
768 bool is_running = false;
769 DataExtractor exc_reply_packet;
770 do {
771 switch (event_type) {
773 is_running = true;
775 exc_reply_packet, 1 * USEC_PER_SEC)) {
776 ThreadSP thread_sp(GetKernelThread());
777 if (thread_sp) {
778 lldb::RegisterContextSP reg_ctx_sp(
779 thread_sp->GetRegisterContext());
780 if (reg_ctx_sp)
781 reg_ctx_sp->InvalidateAllRegisters();
782 static_cast<ThreadKDP *>(thread_sp.get())
783 ->SetStopInfoFrom_KDP_EXCEPTION(exc_reply_packet);
784 }
785
786 // TODO: parse the stop reply packet
787 is_running = false;
789 } else {
790 // Check to see if we are supposed to exit. There is no way to
791 // interrupt a running kernel, so all we can do is wait for an
792 // exception or detach...
793 if (listener_sp->GetEvent(event_sp,
794 std::chrono::microseconds(0))) {
795 // We got an event, go through the loop again
796 event_type = event_sp->GetType();
797 }
798 }
799 } break;
800
802 LLDB_LOGF(log,
803 "ProcessKDP::AsyncThread (pid = %" PRIu64
804 ") got eBroadcastBitAsyncThreadShouldExit...",
805 pid);
806 done = true;
807 is_running = false;
808 break;
809
810 default:
811 LLDB_LOGF(log,
812 "ProcessKDP::AsyncThread (pid = %" PRIu64
813 ") got unknown event 0x%8.8x",
814 pid, event_type);
815 done = true;
816 is_running = false;
817 break;
818 }
819 } while (is_running);
820 } else {
821 LLDB_LOGF(log,
822 "ProcessKDP::AsyncThread (pid = %" PRIu64
823 ") listener.WaitForEvent (NULL, event_sp) => false",
824 pid);
825 done = true;
826 }
827 }
828 }
829
830 LLDB_LOGF(log, "ProcessKDP::AsyncThread(pid = %" PRIu64 ") thread exiting...",
831 pid);
832
834 return NULL;
835}
836
838private:
842
843 Options *GetOptions() override { return &m_option_group; }
844
845public:
847 : CommandObjectParsed(interpreter, "process plugin packet send",
848 "Send a custom packet through the KDP protocol by "
849 "specifying the command byte and the packet "
850 "payload data. A packet will be sent with a "
851 "correct header and payload, and the raw result "
852 "bytes will be displayed as a string value. ",
853 NULL),
855 m_command_byte(LLDB_OPT_SET_1, true, "command", 'c', 0, eArgTypeNone,
856 "Specify the command byte to use when sending the KDP "
857 "request packet.",
858 0),
859 m_packet_data(LLDB_OPT_SET_1, false, "payload", 'p', 0, eArgTypeNone,
860 "Specify packet payload bytes as a hex ASCII string with "
861 "no spaces or hex prefixes.",
862 NULL) {
866 }
867
869
870 void DoExecute(Args &command, CommandReturnObject &result) override {
872 result.AppendError(
873 "the --command option must be set to a valid command byte");
874 } else {
875 const uint64_t command_byte =
876 m_command_byte.GetOptionValue().GetValueAs<uint64_t>().value_or(0);
877 if (command_byte > 0 && command_byte <= UINT8_MAX) {
878 ProcessKDP *process =
880 if (process) {
881 const StateType state = process->GetState();
882
883 if (StateIsStoppedState(state, true)) {
884 std::vector<uint8_t> payload_bytes;
885 const char *ascii_hex_bytes_cstr =
887 if (ascii_hex_bytes_cstr && ascii_hex_bytes_cstr[0]) {
888 StringExtractor extractor(ascii_hex_bytes_cstr);
889 const size_t ascii_hex_bytes_cstr_len =
890 extractor.GetStringRef().size();
891 if (ascii_hex_bytes_cstr_len & 1) {
892 result.AppendErrorWithFormat("payload data must contain an "
893 "even number of ASCII hex "
894 "characters: '%s'",
895 ascii_hex_bytes_cstr);
896 return;
897 }
898 payload_bytes.resize(ascii_hex_bytes_cstr_len / 2);
899 if (extractor.GetHexBytes(payload_bytes, '\xdd') !=
900 payload_bytes.size()) {
901 result.AppendErrorWithFormat("payload data must only contain "
902 "ASCII hex characters (no "
903 "spaces or hex prefixes): '%s'",
904 ascii_hex_bytes_cstr);
905 return;
906 }
907 }
909 DataExtractor reply;
911 command_byte,
912 payload_bytes.empty() ? NULL : payload_bytes.data(),
913 payload_bytes.size(), reply, error);
914
915 if (error.Success()) {
916 // Copy the binary bytes into a hex ASCII string for the result
917 StreamString packet;
918 packet.PutBytesAsRawHex8(
919 reply.GetDataStart(), reply.GetByteSize(),
921 result.AppendMessage(packet.GetString());
923 return;
924 } else {
925 const char *error_cstr = error.AsCString();
926 if (error_cstr && error_cstr[0])
927 result.AppendError(error_cstr);
928 else
929 result.AppendErrorWithFormat("unknown error 0x%8.8x",
930 error.GetError());
931 return;
932 }
933 } else {
934 result.AppendErrorWithFormat("process must be stopped in order "
935 "to send KDP packets, state is %s",
936 StateAsCString(state));
937 }
938 } else {
939 result.AppendError("invalid process");
940 }
941 } else {
942 result.AppendErrorWithFormat("invalid command byte 0x%" PRIx64
943 ", valid values are 1 - 255",
944 command_byte);
945 }
946 }
947 }
948};
949
951private:
952public:
954 : CommandObjectMultiword(interpreter, "process plugin packet",
955 "Commands that deal with KDP remote packets.",
956 NULL) {
958 "send",
960 }
961
962 ~CommandObjectProcessKDPPacket() override = default;
963};
964
966public:
969 interpreter, "process plugin",
970 "Commands for operating on a ProcessKDP process.",
971 "process plugin <subcommand> [<subcommand-options>]") {
973 interpreter)));
974 }
975
977};
978
980 if (!m_command_sp)
981 m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>(
982 GetTarget().GetDebugger().GetCommandInterpreter());
983 return m_command_sp.get();
984}
static llvm::raw_ostream & error(Stream &strm)
static PluginProperties & GetGlobalPluginProperties()
#define LLDB_LOGF(log,...)
Definition: Log.h:349
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:365
#define LLDB_LOGV(log,...)
Definition: Log.h:356
#define LLDB_PLUGIN_DEFINE_ADV(ClassName, PluginName)
Definition: PluginManager.h:25
static PluginProperties & GetGlobalPluginProperties()
Definition: ProcessKDP.cpp:87
#define USEC_PER_SEC
Definition: ProcessKDP.cpp:42
static const lldb::tid_t g_kernel_tid
Definition: ProcessKDP.cpp:92
CommandObjectMultiwordProcessKDP(CommandInterpreter &interpreter)
Definition: ProcessKDP.cpp:967
~CommandObjectMultiwordProcessKDP() override=default
CommandObjectProcessKDPPacketSend(CommandInterpreter &interpreter)
Definition: ProcessKDP.cpp:846
OptionGroupOptions m_option_group
Definition: ProcessKDP.cpp:839
void DoExecute(Args &command, CommandReturnObject &result) override
Definition: ProcessKDP.cpp:870
Options * GetOptions() override
Definition: ProcessKDP.cpp:843
~CommandObjectProcessKDPPacketSend() override=default
~CommandObjectProcessKDPPacket() override=default
CommandObjectProcessKDPPacket(CommandInterpreter &interpreter)
Definition: ProcessKDP.cpp:953
bool SendRequestBreakpoint(bool set, lldb::addr_t addr)
bool SendRequestConnect(uint16_t reply_port, uint16_t exc_port, const char *greeting)
std::chrono::seconds SetPacketTimeout(std::chrono::seconds packet_timeout)
bool IsRunning() const
uint32_t SendRequestWriteMemory(lldb::addr_t addr, const void *src, uint32_t src_len, lldb_private::Status &error)
bool SendRawRequest(uint8_t command_byte, const void *src, uint32_t src_len, lldb_private::DataExtractor &reply, lldb_private::Status &error)
uint32_t SendRequestReadMemory(lldb::addr_t addr, void *dst, uint32_t dst_size, lldb_private::Status &error)
lldb::addr_t GetLoadAddress()
const char * GetKernelVersion()
lldb_private::UUID GetUUID()
size_t WaitForPacketWithTimeoutMicroSeconds(lldb_private::DataExtractor &response, uint32_t usec)
bool LocalBreakpointsAreSupported()
bool SendRequestReattach(uint16_t reply_port)
static llvm::StringRef GetPluginNameStatic()
lldb_private::Status DoWillLaunch(lldb_private::Module *module) override
Called before launching to a process.
Definition: ProcessKDP.cpp:171
lldb_private::Broadcaster m_async_broadcaster
Definition: ProcessKDP.h:164
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, lldb_private::Status &error) override
Actually do the reading of memory from a process.
Definition: ProcessKDP.cpp:582
lldb::CommandObjectSP m_command_sp
Definition: ProcessKDP.h:168
void DidAttach(lldb_private::ArchSpec &process_arch) override
Called after attaching a process.
Definition: ProcessKDP.cpp:385
ProcessKDP(lldb::TargetSP target_sp, lldb::ListenerSP listener)
Definition: ProcessKDP.cpp:145
static void Terminate()
Definition: ProcessKDP.cpp:99
lldb_private::Status EnableBreakpointSite(lldb_private::BreakpointSite *bp_site) override
Definition: ProcessKDP.cpp:632
lldb::ThreadSP GetKernelThread()
Definition: ProcessKDP.cpp:484
static llvm::StringRef GetPluginDescriptionStatic()
Definition: ProcessKDP.cpp:94
static void Initialize()
Definition: ProcessKDP.cpp:684
llvm::StringRef m_dyld_plugin_name
Definition: ProcessKDP.h:166
bool GetHostArchitecture(lldb_private::ArchSpec &arch)
Definition: ProcessKDP.cpp:192
lldb::ThreadWP m_kernel_thread_wp
Definition: ProcessKDP.h:169
lldb_private::Status DoLaunch(lldb_private::Module *exe_module, lldb_private::ProcessLaunchInfo &launch_info) override
Launch a new process.
Definition: ProcessKDP.cpp:360
void * AsyncThread()
Definition: ProcessKDP.cpp:737
lldb_private::Status DoSignal(int signal) override
Sends a process a UNIX signal signal.
Definition: ProcessKDP.cpp:677
void RefreshStateAfterStop() override
Currently called as part of ShouldStop.
Definition: ProcessKDP.cpp:513
lldb_private::HostThread m_async_thread
Definition: ProcessKDP.h:165
~ProcessKDP() override
Definition: ProcessKDP.cpp:162
lldb_private::DynamicLoader * GetDynamicLoader() override
Get the dynamic loader plug-in for this process.
Definition: ProcessKDP.cpp:397
CommunicationKDP & GetCommunication()
Definition: ProcessKDP.h:127
lldb_private::Status WillResume() override
Called before resuming to a process.
Definition: ProcessKDP.cpp:403
lldb_private::Status DoHalt(bool &caused_stop) override
Halts a running process.
Definition: ProcessKDP.cpp:519
static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const lldb_private::FileSpec *crash_file_path, bool can_connect)
Definition: ProcessKDP.cpp:103
lldb::addr_t m_kernel_load_addr
Definition: ProcessKDP.h:167
void Clear()
Definition: ProcessKDP.cpp:675
lldb_private::Status DoConnectRemote(llvm::StringRef remote_url) override
Attach to a remote system via a URL.
Definition: ProcessKDP.cpp:206
bool IsAlive() override
Check if a process is still alive.
Definition: ProcessKDP.cpp:577
lldb_private::CommandObject * GetPluginCommandObject() override
Return a multi-word command object that can be used to expose plug-in specific commands.
Definition: ProcessKDP.cpp:979
bool StartAsyncThread()
Definition: ProcessKDP.cpp:706
lldb_private::Status DoAttachToProcessWithName(const char *process_name, const lldb_private::ProcessAttachInfo &attach_info) override
Attach to an existing process using a partial process name.
Definition: ProcessKDP.cpp:377
lldb_private::Status DoWillAttachToProcessWithName(const char *process_name, bool wait_for_launch) override
Called before attaching to a process.
Definition: ProcessKDP.cpp:184
lldb::addr_t GetImageInfoAddress() override
Get the image information address for the current process.
Definition: ProcessKDP.cpp:395
@ eBroadcastBitAsyncThreadShouldExit
Definition: ProcessKDP.h:157
@ eBroadcastBitAsyncContinue
Definition: ProcessKDP.h:156
bool DoUpdateThreadList(lldb_private::ThreadList &old_thread_list, lldb_private::ThreadList &new_thread_list) override
Update the thread list following process plug-in's specific logic.
Definition: ProcessKDP.cpp:496
static void DebuggerInitialize(lldb_private::Debugger &debugger)
Definition: ProcessKDP.cpp:696
CommunicationKDP m_comm
Broadcaster event bits definitions.
Definition: ProcessKDP.h:163
lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions, lldb_private::Status &error) override
Actually allocate memory in the process.
Definition: ProcessKDP.cpp:618
lldb_private::Status DisableBreakpointSite(lldb_private::BreakpointSite *bp_site) override
Definition: ProcessKDP.cpp:651
lldb_private::Status DoWillAttachToProcessWithID(lldb::pid_t pid) override
Called before attaching to a process.
Definition: ProcessKDP.cpp:177
lldb_private::Status DoAttachToProcessWithID(lldb::pid_t pid, const lldb_private::ProcessAttachInfo &attach_info) override
Attach to an existing process using a process ID.
Definition: ProcessKDP.cpp:368
size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size, lldb_private::Status &error) override
Actually do the writing of memory to a process.
Definition: ProcessKDP.cpp:610
bool CanDebug(lldb::TargetSP target_sp, bool plugin_specified_by_name) override
Check if a plug-in instance can debug the file in module.
Definition: ProcessKDP.cpp:113
lldb_private::Status DoDetach(bool keep_stopped) override
Detaches from a running or stopped process.
Definition: ProcessKDP.cpp:535
lldb_private::Status DoDeallocateMemory(lldb::addr_t ptr) override
Actually deallocate memory in the process.
Definition: ProcessKDP.cpp:625
lldb_private::Status DoDestroy() override
Definition: ProcessKDP.cpp:569
void StopAsyncThread()
Definition: ProcessKDP.cpp:725
lldb_private::Status DoResume() override
Resumes all of a process's threads as configured using the Thread run control functions.
Definition: ProcessKDP.cpp:405
static llvm::StringRef GetPluginNameStatic()
Definition: ProcessKDP.h:44
size_t GetHexBytes(llvm::MutableArrayRef< uint8_t > dest, uint8_t fail_fill_value)
llvm::StringRef GetStringRef() const
An architecture specification class.
Definition: ArchSpec.h:31
void Clear()
Clears the object state.
Definition: ArchSpec.cpp:542
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:450
bool SetArchitecture(ArchitectureType arch_type, uint32_t cpu, uint32_t sub, uint32_t os=0)
Change the architecture object type, CPU type and OS type.
Definition: ArchSpec.cpp:851
void MergeFrom(const ArchSpec &other)
Merges fields from another ArchSpec into this ArchSpec.
Definition: ArchSpec.cpp:809
A command line argument class.
Definition: Args.h:33
Class that manages the actual breakpoint that will be inserted into the running program.
BreakpointSite::Type GetType() const
void SetType(BreakpointSite::Type type)
bool IsEnabled() const
Tells whether the current breakpoint site is enabled or not.
void SetEnabled(bool enabled)
Sets whether the current breakpoint site is enabled or not.
void SetEventName(uint32_t event_mask, const char *name)
Set the name for an event bit.
Definition: Broadcaster.h:242
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
Definition: Broadcaster.h:167
ExecutionContext GetExecutionContext() const
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
CommandInterpreter & m_interpreter
void AppendMessage(llvm::StringRef in_string)
void void AppendError(llvm::StringRef in_string)
void SetStatus(lldb::ReturnStatus status)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
bool IsConnected() const
Check if the connection is valid.
virtual void SetConnection(std::unique_ptr< Connection > connection)
Sets the connection that it to be used by this class.
virtual lldb::ConnectionStatus Disconnect(Status *error_ptr=nullptr)
Disconnect the communications connection if one is currently connected.
An data extractor class.
Definition: DataExtractor.h:48
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
const uint8_t * GetDataStart() const
Get the data start pointer.
A class to manage flag bits.
Definition: Debugger.h:79
lldb::StreamSP GetAsyncOutputStream()
Definition: Debugger.cpp:1275
A plug-in interface definition class for dynamic loaders.
Definition: DynamicLoader.h:52
static DynamicLoader * FindPlugin(Process *process, llvm::StringRef plugin_name)
Find a dynamic loader plugin for a given process.
Process * GetProcessPtr() const
Returns a pointer to the process object.
A file collection class.
Definition: FileSpecList.h:85
A file utility class.
Definition: FileSpec.h:56
static FileSystem & Instance()
Status Join(lldb::thread_result_t *result)
Definition: HostThread.cpp:20
static lldb::ListenerSP MakeListener(const char *name)
Definition: Listener.cpp:385
void PutCString(const char *cstr)
Definition: Log.cpp:134
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:89
FileSpec & GetSymbolFileSpec()
Definition: ModuleSpec.h:77
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:88
virtual ObjectFile * GetObjectFile()
Get the object file representation for the current architecture.
Definition: Module.cpp:1182
const ArchSpec & GetArchitecture() const
Get const accessor for the module architecture.
Definition: Module.cpp:1033
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:44
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:53
void Append(OptionGroup *group)
Append options from a OptionGroup class.
Definition: Options.cpp:755
OptionValueString & GetOptionValue()
OptionValueUInt64 & GetOptionValue()
const char * GetCurrentValue() const
std::optional< T > GetValueAs() const
Definition: OptionValue.h:273
A command line option parsing protocol class.
Definition: Options.h:58
static bool DownloadObjectAndSymbolFile(ModuleSpec &module_spec, Status &error, bool force_lookup=true, bool copy_executable=true)
static bool RegisterPlugin(llvm::StringRef name, llvm::StringRef description, ABICreateInstance create_callback)
static bool CreateSettingForProcessPlugin(Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, llvm::StringRef description, bool is_global_property)
static ModuleSpec LocateExecutableObjectFile(const ModuleSpec &module_spec)
static lldb::OptionValuePropertiesSP GetSettingForProcessPlugin(Debugger &debugger, llvm::StringRef setting_name)
static FileSpec LocateExecutableSymbolFile(const ModuleSpec &module_spec, const FileSpecList &default_search_paths)
static bool UnregisterPlugin(ABICreateInstance create_callback)
A plug-in interface definition class for debugging a process.
Definition: Process.h:340
virtual Status DisableSoftwareBreakpoint(BreakpointSite *bp_site)
Definition: Process.cpp:1844
lldb::pid_t GetID() const
Returns the pid of the process or LLDB_INVALID_PROCESS_ID if there is no known pid.
Definition: Process.h:537
ThreadList & GetThreadList()
Definition: Process.h:2198
void ResumePrivateStateThread()
Definition: Process.cpp:3616
void SetCanJIT(bool can_jit)
Sets whether executing JIT-compiled code in this process is possible.
Definition: Process.cpp:2341
lldb::DynamicLoaderUP m_dyld_up
Definition: Process.h:3050
void UpdateThreadListIfNeeded()
Definition: Process.cpp:1144
lldb::StateType GetState()
Get accessor for the current process state.
Definition: Process.cpp:1300
virtual Status EnableSoftwareBreakpoint(BreakpointSite *bp_site)
Definition: Process.cpp:1768
virtual bool IsAlive()
Check if a process is still alive.
Definition: Process.cpp:1092
virtual void DidAttach(ArchSpec &process_arch)
Called after attaching a process.
Definition: Process.h:1041
void SetID(lldb::pid_t new_pid)
Sets the stored pid.
Definition: Process.h:542
void SetPrivateState(lldb::StateType state)
Definition: Process.cpp:1419
virtual void Finalize(bool destructing)
This object is about to be destroyed, do any necessary cleanup.
Definition: Process.cpp:521
ThreadList m_thread_list
The threads for this process as the user will see them.
Definition: Process.h:3024
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1276
virtual lldb::OptionValuePropertiesSP GetValueProperties() const
An error handling class.
Definition: Status.h:44
virtual lldb::addr_t GetLoadAddress() const
Definition: StoppointSite.h:27
llvm::StringRef GetString() const
size_t PutBytesAsRawHex8(const void *src, size_t src_len, lldb::ByteOrder src_byte_order=lldb::eByteOrderInvalid, lldb::ByteOrder dst_byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:383
uint16_t GetLocalPortNumber() const
Definition: TCPSocket.cpp:81
Debugger & GetDebugger()
Definition: Target.h:1053
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false, bool merge=true)
Set the architecture for this target.
Definition: Target.cpp:1537
lldb::ModuleSP GetExecutableModule()
Gets the module for the main executable.
Definition: Target.cpp:1421
static FileSpecList GetDefaultDebugFileSearchPaths()
Definition: Target.cpp:2610
const ArchSpec & GetArchitecture() const
Definition: Target.h:1012
void SetExecutableModule(lldb::ModuleSP &module_sp, LoadDependentFiles load_dependent_files=eLoadDependentsDefault)
Set the main executable module.
Definition: Target.cpp:1470
void AddThread(const lldb::ThreadSP &thread_sp)
static llvm::Expected< HostThread > LaunchThread(llvm::StringRef name, std::function< lldb::thread_result_t()> thread_function, size_t min_stack_byte_size=0)
lldb::ThreadSP FindThreadByProtocolID(lldb::tid_t tid, bool can_update=true)
Definition: ThreadList.cpp:121
uint32_t GetSize(bool can_update=true)
Definition: ThreadList.cpp:83
bool IsValid() const
Definition: UUID.h:69
#define LLDB_OPT_SET_1
Definition: lldb-defines.h:111
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:110
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:89
lldb::ByteOrder InlHostByteOrder()
Definition: Endian.h:25
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:314
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Thread > ThreadSP
Definition: lldb-forward.h:438
std::shared_ptr< lldb_private::CommandObject > CommandObjectSP
Definition: lldb-forward.h:325
@ eConnectionStatusSuccess
Success.
StateType
Process and Thread States.
@ eStateDetached
Process has been detached and can't be examined.
@ eStateStopped
Process or thread is stopped and can be examined.
@ eStateSuspended
Process or thread is in a suspended state as far as the debugger is concerned while other processes o...
@ eStateRunning
Process or thread is running and can't be examined.
@ eStateStepping
Process or thread is in the process of stepping and can not be examined.
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:420
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
std::shared_ptr< lldb_private::Event > EventSP
Definition: lldb-forward.h:337
@ eReturnStatusSuccessFinishResult
uint64_t pid_t
Definition: lldb-types.h:81
std::shared_ptr< lldb_private::Listener > ListenerSP
Definition: lldb-forward.h:360
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Target > TargetSP
Definition: lldb-forward.h:436
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
Definition: lldb-forward.h:386
uint64_t tid_t
Definition: lldb-types.h:82
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365