1 //===-- ProcessKDP.cpp ------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 // C Includes
11 #include <errno.h>
12 #include <stdlib.h>
13
14 // C++ Includes
15 // Other libraries and framework includes
16 #include "lldb/Core/ConnectionFileDescriptor.h"
17 #include "lldb/Core/Debugger.h"
18 #include "lldb/Core/PluginManager.h"
19 #include "lldb/Core/Module.h"
20 #include "lldb/Core/ModuleSpec.h"
21 #include "lldb/Core/State.h"
22 #include "lldb/Core/UUID.h"
23 #include "lldb/Host/Host.h"
24 #include "lldb/Host/Symbols.h"
25 #include "lldb/Interpreter/CommandInterpreter.h"
26 #include "lldb/Interpreter/CommandObject.h"
27 #include "lldb/Interpreter/CommandObjectMultiword.h"
28 #include "lldb/Interpreter/CommandReturnObject.h"
29 #include "lldb/Interpreter/OptionGroupString.h"
30 #include "lldb/Interpreter/OptionGroupUInt64.h"
31 #include "lldb/Symbol/ObjectFile.h"
32 #include "lldb/Target/RegisterContext.h"
33 #include "lldb/Target/Target.h"
34 #include "lldb/Target/Thread.h"
35
36 // Project includes
37 #include "ProcessKDP.h"
38 #include "ProcessKDPLog.h"
39 #include "ThreadKDP.h"
40 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h"
41 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
42 #include "Utility/StringExtractor.h"
43
44 using namespace lldb;
45 using namespace lldb_private;
46
47 namespace {
48
49 static PropertyDefinition
50 g_properties[] =
51 {
52 { "packet-timeout" , OptionValue::eTypeUInt64 , true , 5, NULL, NULL, "Specify the default packet timeout in seconds." },
53 { NULL , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL }
54 };
55
56 enum
57 {
58 ePropertyPacketTimeout
59 };
60
61 class PluginProperties : public Properties
62 {
63 public:
64
65 static ConstString
GetSettingName()66 GetSettingName ()
67 {
68 return ProcessKDP::GetPluginNameStatic();
69 }
70
PluginProperties()71 PluginProperties() :
72 Properties ()
73 {
74 m_collection_sp.reset (new OptionValueProperties(GetSettingName()));
75 m_collection_sp->Initialize(g_properties);
76 }
77
78 virtual
~PluginProperties()79 ~PluginProperties()
80 {
81 }
82
83 uint64_t
GetPacketTimeout()84 GetPacketTimeout()
85 {
86 const uint32_t idx = ePropertyPacketTimeout;
87 return m_collection_sp->GetPropertyAtIndexAsUInt64(NULL, idx, g_properties[idx].default_uint_value);
88 }
89 };
90
91 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP;
92
93 static const ProcessKDPPropertiesSP &
GetGlobalPluginProperties()94 GetGlobalPluginProperties()
95 {
96 static ProcessKDPPropertiesSP g_settings_sp;
97 if (!g_settings_sp)
98 g_settings_sp.reset (new PluginProperties ());
99 return g_settings_sp;
100 }
101
102 } // anonymous namespace end
103
104 static const lldb::tid_t g_kernel_tid = 1;
105
106 ConstString
GetPluginNameStatic()107 ProcessKDP::GetPluginNameStatic()
108 {
109 static ConstString g_name("kdp-remote");
110 return g_name;
111 }
112
113 const char *
GetPluginDescriptionStatic()114 ProcessKDP::GetPluginDescriptionStatic()
115 {
116 return "KDP Remote protocol based debugging plug-in for darwin kernel debugging.";
117 }
118
119 void
Terminate()120 ProcessKDP::Terminate()
121 {
122 PluginManager::UnregisterPlugin (ProcessKDP::CreateInstance);
123 }
124
125
126 lldb::ProcessSP
CreateInstance(Target & target,Listener & listener,const FileSpec * crash_file_path)127 ProcessKDP::CreateInstance (Target &target,
128 Listener &listener,
129 const FileSpec *crash_file_path)
130 {
131 lldb::ProcessSP process_sp;
132 if (crash_file_path == NULL)
133 process_sp.reset(new ProcessKDP (target, listener));
134 return process_sp;
135 }
136
137 bool
CanDebug(Target & target,bool plugin_specified_by_name)138 ProcessKDP::CanDebug(Target &target, bool plugin_specified_by_name)
139 {
140 if (plugin_specified_by_name)
141 return true;
142
143 // For now we are just making sure the file exists for a given module
144 Module *exe_module = target.GetExecutableModulePointer();
145 if (exe_module)
146 {
147 const llvm::Triple &triple_ref = target.GetArchitecture().GetTriple();
148 switch (triple_ref.getOS())
149 {
150 case llvm::Triple::Darwin: // Should use "macosx" for desktop and "ios" for iOS, but accept darwin just in case
151 case llvm::Triple::MacOSX: // For desktop targets
152 case llvm::Triple::IOS: // For arm targets
153 if (triple_ref.getVendor() == llvm::Triple::Apple)
154 {
155 ObjectFile *exe_objfile = exe_module->GetObjectFile();
156 if (exe_objfile->GetType() == ObjectFile::eTypeExecutable &&
157 exe_objfile->GetStrata() == ObjectFile::eStrataKernel)
158 return true;
159 }
160 break;
161
162 default:
163 break;
164 }
165 }
166 return false;
167 }
168
169 //----------------------------------------------------------------------
170 // ProcessKDP constructor
171 //----------------------------------------------------------------------
ProcessKDP(Target & target,Listener & listener)172 ProcessKDP::ProcessKDP(Target& target, Listener &listener) :
173 Process (target, listener),
174 m_comm("lldb.process.kdp-remote.communication"),
175 m_async_broadcaster (NULL, "lldb.process.kdp-remote.async-broadcaster"),
176 m_async_thread (LLDB_INVALID_HOST_THREAD),
177 m_dyld_plugin_name (),
178 m_kernel_load_addr (LLDB_INVALID_ADDRESS),
179 m_command_sp(),
180 m_kernel_thread_wp()
181 {
182 m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadShouldExit, "async thread should exit");
183 m_async_broadcaster.SetEventName (eBroadcastBitAsyncContinue, "async thread continue");
184 const uint64_t timeout_seconds = GetGlobalPluginProperties()->GetPacketTimeout();
185 if (timeout_seconds > 0)
186 m_comm.SetPacketTimeout(timeout_seconds);
187 }
188
189 //----------------------------------------------------------------------
190 // Destructor
191 //----------------------------------------------------------------------
~ProcessKDP()192 ProcessKDP::~ProcessKDP()
193 {
194 Clear();
195 // We need to call finalize on the process before destroying ourselves
196 // to make sure all of the broadcaster cleanup goes as planned. If we
197 // destruct this class, then Process::~Process() might have problems
198 // trying to fully destroy the broadcaster.
199 Finalize();
200 }
201
202 //----------------------------------------------------------------------
203 // PluginInterface
204 //----------------------------------------------------------------------
205 lldb_private::ConstString
GetPluginName()206 ProcessKDP::GetPluginName()
207 {
208 return GetPluginNameStatic();
209 }
210
211 uint32_t
GetPluginVersion()212 ProcessKDP::GetPluginVersion()
213 {
214 return 1;
215 }
216
217 Error
WillLaunch(Module * module)218 ProcessKDP::WillLaunch (Module* module)
219 {
220 Error error;
221 error.SetErrorString ("launching not supported in kdp-remote plug-in");
222 return error;
223 }
224
225 Error
WillAttachToProcessWithID(lldb::pid_t pid)226 ProcessKDP::WillAttachToProcessWithID (lldb::pid_t pid)
227 {
228 Error error;
229 error.SetErrorString ("attaching to a by process ID not supported in kdp-remote plug-in");
230 return error;
231 }
232
233 Error
WillAttachToProcessWithName(const char * process_name,bool wait_for_launch)234 ProcessKDP::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch)
235 {
236 Error error;
237 error.SetErrorString ("attaching to a by process name not supported in kdp-remote plug-in");
238 return error;
239 }
240
241 Error
DoConnectRemote(Stream * strm,const char * remote_url)242 ProcessKDP::DoConnectRemote (Stream *strm, const char *remote_url)
243 {
244 Error error;
245
246 // Don't let any JIT happen when doing KDP as we can't allocate
247 // memory and we don't want to be mucking with threads that might
248 // already be handling exceptions
249 SetCanJIT(false);
250
251 if (remote_url == NULL || remote_url[0] == '\0')
252 {
253 error.SetErrorStringWithFormat ("invalid connection URL '%s'", remote_url);
254 return error;
255 }
256
257 std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor());
258 if (conn_ap.get())
259 {
260 // Only try once for now.
261 // TODO: check if we should be retrying?
262 const uint32_t max_retry_count = 1;
263 for (uint32_t retry_count = 0; retry_count < max_retry_count; ++retry_count)
264 {
265 if (conn_ap->Connect(remote_url, &error) == eConnectionStatusSuccess)
266 break;
267 usleep (100000);
268 }
269 }
270
271 if (conn_ap->IsConnected())
272 {
273 const uint16_t reply_port = conn_ap->GetReadPort ();
274
275 if (reply_port != 0)
276 {
277 m_comm.SetConnection(conn_ap.release());
278
279 if (m_comm.SendRequestReattach(reply_port))
280 {
281 if (m_comm.SendRequestConnect(reply_port, reply_port, "Greetings from LLDB..."))
282 {
283 m_comm.GetVersion();
284 uint32_t cpu = m_comm.GetCPUType();
285 uint32_t sub = m_comm.GetCPUSubtype();
286 ArchSpec kernel_arch;
287 kernel_arch.SetArchitecture(eArchTypeMachO, cpu, sub);
288 m_target.SetArchitecture(kernel_arch);
289
290 /* Get the kernel's UUID and load address via KDP_KERNELVERSION packet. */
291 /* An EFI kdp session has neither UUID nor load address. */
292
293 UUID kernel_uuid = m_comm.GetUUID ();
294 addr_t kernel_load_addr = m_comm.GetLoadAddress ();
295
296 if (m_comm.RemoteIsEFI ())
297 {
298 m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
299 }
300 else if (m_comm.RemoteIsDarwinKernel ())
301 {
302 m_dyld_plugin_name = DynamicLoaderDarwinKernel::GetPluginNameStatic();
303 if (kernel_load_addr != LLDB_INVALID_ADDRESS)
304 {
305 m_kernel_load_addr = kernel_load_addr;
306 }
307 }
308
309 // Set the thread ID
310 UpdateThreadListIfNeeded ();
311 SetID (1);
312 GetThreadList ();
313 SetPrivateState (eStateStopped);
314 StreamSP async_strm_sp(m_target.GetDebugger().GetAsyncOutputStream());
315 if (async_strm_sp)
316 {
317 const char *cstr;
318 if ((cstr = m_comm.GetKernelVersion ()) != NULL)
319 {
320 async_strm_sp->Printf ("Version: %s\n", cstr);
321 async_strm_sp->Flush();
322 }
323 // if ((cstr = m_comm.GetImagePath ()) != NULL)
324 // {
325 // async_strm_sp->Printf ("Image Path: %s\n", cstr);
326 // async_strm_sp->Flush();
327 // }
328 }
329 }
330 else
331 {
332 error.SetErrorString("KDP_REATTACH failed");
333 }
334 }
335 else
336 {
337 error.SetErrorString("KDP_REATTACH failed");
338 }
339 }
340 else
341 {
342 error.SetErrorString("invalid reply port from UDP connection");
343 }
344 }
345 else
346 {
347 if (error.Success())
348 error.SetErrorStringWithFormat ("failed to connect to '%s'", remote_url);
349 }
350 if (error.Fail())
351 m_comm.Disconnect();
352
353 return error;
354 }
355
356 //----------------------------------------------------------------------
357 // Process Control
358 //----------------------------------------------------------------------
359 Error
DoLaunch(Module * exe_module,const ProcessLaunchInfo & launch_info)360 ProcessKDP::DoLaunch (Module *exe_module,
361 const ProcessLaunchInfo &launch_info)
362 {
363 Error error;
364 error.SetErrorString ("launching not supported in kdp-remote plug-in");
365 return error;
366 }
367
368
369 Error
DoAttachToProcessWithID(lldb::pid_t attach_pid)370 ProcessKDP::DoAttachToProcessWithID (lldb::pid_t attach_pid)
371 {
372 Error error;
373 error.SetErrorString ("attach to process by ID is not suppported in kdp remote debugging");
374 return error;
375 }
376
377 Error
DoAttachToProcessWithID(lldb::pid_t attach_pid,const ProcessAttachInfo & attach_info)378 ProcessKDP::DoAttachToProcessWithID (lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info)
379 {
380 Error error;
381 error.SetErrorString ("attach to process by ID is not suppported in kdp remote debugging");
382 return error;
383 }
384
385 Error
DoAttachToProcessWithName(const char * process_name,bool wait_for_launch,const ProcessAttachInfo & attach_info)386 ProcessKDP::DoAttachToProcessWithName (const char *process_name, bool wait_for_launch, const ProcessAttachInfo &attach_info)
387 {
388 Error error;
389 error.SetErrorString ("attach to process by name is not suppported in kdp remote debugging");
390 return error;
391 }
392
393
394 void
DidAttach()395 ProcessKDP::DidAttach ()
396 {
397 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PROCESS));
398 if (log)
399 log->Printf ("ProcessKDP::DidAttach()");
400 if (GetID() != LLDB_INVALID_PROCESS_ID)
401 {
402 // TODO: figure out the register context that we will use
403 }
404 }
405
406 addr_t
GetImageInfoAddress()407 ProcessKDP::GetImageInfoAddress()
408 {
409 return m_kernel_load_addr;
410 }
411
412 lldb_private::DynamicLoader *
GetDynamicLoader()413 ProcessKDP::GetDynamicLoader ()
414 {
415 if (m_dyld_ap.get() == NULL)
416 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString()));
417 return m_dyld_ap.get();
418 }
419
420 Error
WillResume()421 ProcessKDP::WillResume ()
422 {
423 return Error();
424 }
425
426 Error
DoResume()427 ProcessKDP::DoResume ()
428 {
429 Error error;
430 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PROCESS));
431 // Only start the async thread if we try to do any process control
432 if (!IS_VALID_LLDB_HOST_THREAD(m_async_thread))
433 StartAsyncThread ();
434
435 bool resume = false;
436
437 // With KDP there is only one thread we can tell what to do
438 ThreadSP kernel_thread_sp (m_thread_list.FindThreadByProtocolID(g_kernel_tid));
439
440 if (kernel_thread_sp)
441 {
442 const StateType thread_resume_state = kernel_thread_sp->GetTemporaryResumeState();
443
444 if (log)
445 log->Printf ("ProcessKDP::DoResume() thread_resume_state = %s", StateAsCString(thread_resume_state));
446 switch (thread_resume_state)
447 {
448 case eStateSuspended:
449 // Nothing to do here when a thread will stay suspended
450 // we just leave the CPU mask bit set to zero for the thread
451 if (log)
452 log->Printf ("ProcessKDP::DoResume() = suspended???");
453 break;
454
455 case eStateStepping:
456 {
457 lldb::RegisterContextSP reg_ctx_sp (kernel_thread_sp->GetRegisterContext());
458
459 if (reg_ctx_sp)
460 {
461 if (log)
462 log->Printf ("ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep (true);");
463 reg_ctx_sp->HardwareSingleStep (true);
464 resume = true;
465 }
466 else
467 {
468 error.SetErrorStringWithFormat("KDP thread 0x%llx has no register context", kernel_thread_sp->GetID());
469 }
470 }
471 break;
472
473 case eStateRunning:
474 {
475 lldb::RegisterContextSP reg_ctx_sp (kernel_thread_sp->GetRegisterContext());
476
477 if (reg_ctx_sp)
478 {
479 if (log)
480 log->Printf ("ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep (false);");
481 reg_ctx_sp->HardwareSingleStep (false);
482 resume = true;
483 }
484 else
485 {
486 error.SetErrorStringWithFormat("KDP thread 0x%llx has no register context", kernel_thread_sp->GetID());
487 }
488 }
489 break;
490
491 default:
492 // The only valid thread resume states are listed above
493 assert (!"invalid thread resume state");
494 break;
495 }
496 }
497
498 if (resume)
499 {
500 if (log)
501 log->Printf ("ProcessKDP::DoResume () sending resume");
502
503 if (m_comm.SendRequestResume ())
504 {
505 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue);
506 SetPrivateState(eStateRunning);
507 }
508 else
509 error.SetErrorString ("KDP resume failed");
510 }
511 else
512 {
513 error.SetErrorString ("kernel thread is suspended");
514 }
515
516 return error;
517 }
518
519 lldb::ThreadSP
GetKernelThread()520 ProcessKDP::GetKernelThread()
521 {
522 // KDP only tells us about one thread/core. Any other threads will usually
523 // be the ones that are read from memory by the OS plug-ins.
524
525 ThreadSP thread_sp (m_kernel_thread_wp.lock());
526 if (!thread_sp)
527 {
528 thread_sp.reset(new ThreadKDP (*this, g_kernel_tid));
529 m_kernel_thread_wp = thread_sp;
530 }
531 return thread_sp;
532 }
533
534
535
536
537 bool
UpdateThreadList(ThreadList & old_thread_list,ThreadList & new_thread_list)538 ProcessKDP::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list)
539 {
540 // locker will keep a mutex locked until it goes out of scope
541 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_THREAD));
542 if (log && log->GetMask().Test(KDP_LOG_VERBOSE))
543 log->Printf ("ProcessKDP::%s (pid = %" PRIu64 ")", __FUNCTION__, GetID());
544
545 // Even though there is a CPU mask, it doesn't mean we can see each CPU
546 // indivudually, there is really only one. Lets call this thread 1.
547 ThreadSP thread_sp (old_thread_list.FindThreadByProtocolID(g_kernel_tid, false));
548 if (!thread_sp)
549 thread_sp = GetKernelThread ();
550 new_thread_list.AddThread(thread_sp);
551
552 return new_thread_list.GetSize(false) > 0;
553 }
554
555 void
RefreshStateAfterStop()556 ProcessKDP::RefreshStateAfterStop ()
557 {
558 // Let all threads recover from stopping and do any clean up based
559 // on the previous thread state (if any).
560 m_thread_list.RefreshStateAfterStop();
561 }
562
563 Error
DoHalt(bool & caused_stop)564 ProcessKDP::DoHalt (bool &caused_stop)
565 {
566 Error error;
567
568 if (m_comm.IsRunning())
569 {
570 if (m_destroy_in_process)
571 {
572 // If we are attemping to destroy, we need to not return an error to
573 // Halt or DoDestroy won't get called.
574 // We are also currently running, so send a process stopped event
575 SetPrivateState (eStateStopped);
576 }
577 else
578 {
579 error.SetErrorString ("KDP cannot interrupt a running kernel");
580 }
581 }
582 return error;
583 }
584
585 Error
DoDetach(bool keep_stopped)586 ProcessKDP::DoDetach(bool keep_stopped)
587 {
588 Error error;
589 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
590 if (log)
591 log->Printf ("ProcessKDP::DoDetach(keep_stopped = %i)", keep_stopped);
592
593 if (m_comm.IsRunning())
594 {
595 // We are running and we can't interrupt a running kernel, so we need
596 // to just close the connection to the kernel and hope for the best
597 }
598 else
599 {
600 DisableAllBreakpointSites ();
601
602 m_thread_list.DiscardThreadPlans();
603
604 // If we are going to keep the target stopped, then don't send the disconnect message.
605 if (!keep_stopped && m_comm.IsConnected())
606 {
607 const bool success = m_comm.SendRequestDisconnect();
608 if (log)
609 {
610 if (success)
611 log->PutCString ("ProcessKDP::DoDetach() detach packet sent successfully");
612 else
613 log->PutCString ("ProcessKDP::DoDetach() connection channel shutdown failed");
614 }
615 m_comm.Disconnect ();
616 }
617 }
618 StopAsyncThread ();
619 m_comm.Clear();
620
621 SetPrivateState (eStateDetached);
622 ResumePrivateStateThread();
623
624 //KillDebugserverProcess ();
625 return error;
626 }
627
628 Error
DoDestroy()629 ProcessKDP::DoDestroy ()
630 {
631 // For KDP there really is no difference between destroy and detach
632 bool keep_stopped = false;
633 return DoDetach(keep_stopped);
634 }
635
636 //------------------------------------------------------------------
637 // Process Queries
638 //------------------------------------------------------------------
639
640 bool
IsAlive()641 ProcessKDP::IsAlive ()
642 {
643 return m_comm.IsConnected() && m_private_state.GetValue() != eStateExited;
644 }
645
646 //------------------------------------------------------------------
647 // Process Memory
648 //------------------------------------------------------------------
649 size_t
DoReadMemory(addr_t addr,void * buf,size_t size,Error & error)650 ProcessKDP::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error)
651 {
652 if (m_comm.IsConnected())
653 return m_comm.SendRequestReadMemory (addr, buf, size, error);
654 error.SetErrorString ("not connected");
655 return 0;
656 }
657
658 size_t
DoWriteMemory(addr_t addr,const void * buf,size_t size,Error & error)659 ProcessKDP::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
660 {
661 if (m_comm.IsConnected())
662 return m_comm.SendRequestWriteMemory (addr, buf, size, error);
663 error.SetErrorString ("not connected");
664 return 0;
665 }
666
667 lldb::addr_t
DoAllocateMemory(size_t size,uint32_t permissions,Error & error)668 ProcessKDP::DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
669 {
670 error.SetErrorString ("memory allocation not suppported in kdp remote debugging");
671 return LLDB_INVALID_ADDRESS;
672 }
673
674 Error
DoDeallocateMemory(lldb::addr_t addr)675 ProcessKDP::DoDeallocateMemory (lldb::addr_t addr)
676 {
677 Error error;
678 error.SetErrorString ("memory deallocation not suppported in kdp remote debugging");
679 return error;
680 }
681
682 Error
EnableBreakpointSite(BreakpointSite * bp_site)683 ProcessKDP::EnableBreakpointSite (BreakpointSite *bp_site)
684 {
685 if (m_comm.LocalBreakpointsAreSupported ())
686 {
687 Error error;
688 if (!bp_site->IsEnabled())
689 {
690 if (m_comm.SendRequestBreakpoint(true, bp_site->GetLoadAddress()))
691 {
692 bp_site->SetEnabled(true);
693 bp_site->SetType (BreakpointSite::eExternal);
694 }
695 else
696 {
697 error.SetErrorString ("KDP set breakpoint failed");
698 }
699 }
700 return error;
701 }
702 return EnableSoftwareBreakpoint (bp_site);
703 }
704
705 Error
DisableBreakpointSite(BreakpointSite * bp_site)706 ProcessKDP::DisableBreakpointSite (BreakpointSite *bp_site)
707 {
708 if (m_comm.LocalBreakpointsAreSupported ())
709 {
710 Error error;
711 if (bp_site->IsEnabled())
712 {
713 BreakpointSite::Type bp_type = bp_site->GetType();
714 if (bp_type == BreakpointSite::eExternal)
715 {
716 if (m_destroy_in_process && m_comm.IsRunning())
717 {
718 // We are trying to destroy our connection and we are running
719 bp_site->SetEnabled(false);
720 }
721 else
722 {
723 if (m_comm.SendRequestBreakpoint(false, bp_site->GetLoadAddress()))
724 bp_site->SetEnabled(false);
725 else
726 error.SetErrorString ("KDP remove breakpoint failed");
727 }
728 }
729 else
730 {
731 error = DisableSoftwareBreakpoint (bp_site);
732 }
733 }
734 return error;
735 }
736 return DisableSoftwareBreakpoint (bp_site);
737 }
738
739 Error
EnableWatchpoint(Watchpoint * wp,bool notify)740 ProcessKDP::EnableWatchpoint (Watchpoint *wp, bool notify)
741 {
742 Error error;
743 error.SetErrorString ("watchpoints are not suppported in kdp remote debugging");
744 return error;
745 }
746
747 Error
DisableWatchpoint(Watchpoint * wp,bool notify)748 ProcessKDP::DisableWatchpoint (Watchpoint *wp, bool notify)
749 {
750 Error error;
751 error.SetErrorString ("watchpoints are not suppported in kdp remote debugging");
752 return error;
753 }
754
755 void
Clear()756 ProcessKDP::Clear()
757 {
758 m_thread_list.Clear();
759 }
760
761 Error
DoSignal(int signo)762 ProcessKDP::DoSignal (int signo)
763 {
764 Error error;
765 error.SetErrorString ("sending signals is not suppported in kdp remote debugging");
766 return error;
767 }
768
769 void
Initialize()770 ProcessKDP::Initialize()
771 {
772 static bool g_initialized = false;
773
774 if (g_initialized == false)
775 {
776 g_initialized = true;
777 PluginManager::RegisterPlugin (GetPluginNameStatic(),
778 GetPluginDescriptionStatic(),
779 CreateInstance,
780 DebuggerInitialize);
781
782 Log::Callbacks log_callbacks = {
783 ProcessKDPLog::DisableLog,
784 ProcessKDPLog::EnableLog,
785 ProcessKDPLog::ListLogCategories
786 };
787
788 Log::RegisterLogChannel (ProcessKDP::GetPluginNameStatic(), log_callbacks);
789 }
790 }
791
792 void
DebuggerInitialize(lldb_private::Debugger & debugger)793 ProcessKDP::DebuggerInitialize (lldb_private::Debugger &debugger)
794 {
795 if (!PluginManager::GetSettingForProcessPlugin(debugger, PluginProperties::GetSettingName()))
796 {
797 const bool is_global_setting = true;
798 PluginManager::CreateSettingForProcessPlugin (debugger,
799 GetGlobalPluginProperties()->GetValueProperties(),
800 ConstString ("Properties for the kdp-remote process plug-in."),
801 is_global_setting);
802 }
803 }
804
805 bool
StartAsyncThread()806 ProcessKDP::StartAsyncThread ()
807 {
808 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
809
810 if (log)
811 log->Printf ("ProcessKDP::StartAsyncThread ()");
812
813 if (IS_VALID_LLDB_HOST_THREAD(m_async_thread))
814 return true;
815
816 m_async_thread = Host::ThreadCreate ("<lldb.process.kdp-remote.async>", ProcessKDP::AsyncThread, this, NULL);
817 return IS_VALID_LLDB_HOST_THREAD(m_async_thread);
818 }
819
820 void
StopAsyncThread()821 ProcessKDP::StopAsyncThread ()
822 {
823 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
824
825 if (log)
826 log->Printf ("ProcessKDP::StopAsyncThread ()");
827
828 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
829
830 // Stop the stdio thread
831 if (IS_VALID_LLDB_HOST_THREAD(m_async_thread))
832 {
833 Host::ThreadJoin (m_async_thread, NULL, NULL);
834 m_async_thread = LLDB_INVALID_HOST_THREAD;
835 }
836 }
837
838
839 void *
AsyncThread(void * arg)840 ProcessKDP::AsyncThread (void *arg)
841 {
842 ProcessKDP *process = (ProcessKDP*) arg;
843
844 const lldb::pid_t pid = process->GetID();
845
846 Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PROCESS));
847 if (log)
848 log->Printf ("ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 ") thread starting...", arg, pid);
849
850 Listener listener ("ProcessKDP::AsyncThread");
851 EventSP event_sp;
852 const uint32_t desired_event_mask = eBroadcastBitAsyncContinue |
853 eBroadcastBitAsyncThreadShouldExit;
854
855
856 if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask)
857 {
858 bool done = false;
859 while (!done)
860 {
861 if (log)
862 log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp)...",
863 pid);
864 if (listener.WaitForEvent (NULL, event_sp))
865 {
866 uint32_t event_type = event_sp->GetType();
867 if (log)
868 log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") Got an event of type: %d...",
869 pid,
870 event_type);
871
872 // When we are running, poll for 1 second to try and get an exception
873 // to indicate the process has stopped. If we don't get one, check to
874 // make sure no one asked us to exit
875 bool is_running = false;
876 DataExtractor exc_reply_packet;
877 do
878 {
879 switch (event_type)
880 {
881 case eBroadcastBitAsyncContinue:
882 {
883 is_running = true;
884 if (process->m_comm.WaitForPacketWithTimeoutMicroSeconds (exc_reply_packet, 1 * USEC_PER_SEC))
885 {
886 ThreadSP thread_sp (process->GetKernelThread());
887 if (thread_sp)
888 {
889 lldb::RegisterContextSP reg_ctx_sp (thread_sp->GetRegisterContext());
890 if (reg_ctx_sp)
891 reg_ctx_sp->InvalidateAllRegisters();
892 static_cast<ThreadKDP *>(thread_sp.get())->SetStopInfoFrom_KDP_EXCEPTION (exc_reply_packet);
893 }
894
895 // TODO: parse the stop reply packet
896 is_running = false;
897 process->SetPrivateState(eStateStopped);
898 }
899 else
900 {
901 // Check to see if we are supposed to exit. There is no way to
902 // interrupt a running kernel, so all we can do is wait for an
903 // exception or detach...
904 if (listener.GetNextEvent(event_sp))
905 {
906 // We got an event, go through the loop again
907 event_type = event_sp->GetType();
908 }
909 }
910 }
911 break;
912
913 case eBroadcastBitAsyncThreadShouldExit:
914 if (log)
915 log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") got eBroadcastBitAsyncThreadShouldExit...",
916 pid);
917 done = true;
918 is_running = false;
919 break;
920
921 default:
922 if (log)
923 log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") got unknown event 0x%8.8x",
924 pid,
925 event_type);
926 done = true;
927 is_running = false;
928 break;
929 }
930 } while (is_running);
931 }
932 else
933 {
934 if (log)
935 log->Printf ("ProcessKDP::AsyncThread (pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp) => false",
936 pid);
937 done = true;
938 }
939 }
940 }
941
942 if (log)
943 log->Printf ("ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 ") thread exiting...",
944 arg,
945 pid);
946
947 process->m_async_thread = LLDB_INVALID_HOST_THREAD;
948 return NULL;
949 }
950
951
952 class CommandObjectProcessKDPPacketSend : public CommandObjectParsed
953 {
954 private:
955
956 OptionGroupOptions m_option_group;
957 OptionGroupUInt64 m_command_byte;
958 OptionGroupString m_packet_data;
959
960 virtual Options *
GetOptions()961 GetOptions ()
962 {
963 return &m_option_group;
964 }
965
966
967 public:
CommandObjectProcessKDPPacketSend(CommandInterpreter & interpreter)968 CommandObjectProcessKDPPacketSend(CommandInterpreter &interpreter) :
969 CommandObjectParsed (interpreter,
970 "process plugin packet send",
971 "Send a custom packet through the KDP protocol by specifying the command byte and the packet payload data. A packet will be sent with a correct header and payload, and the raw result bytes will be displayed as a string value. ",
972 NULL),
973 m_option_group (interpreter),
974 m_command_byte(LLDB_OPT_SET_1, true , "command", 'c', 0, eArgTypeNone, "Specify the command byte to use when sending the KDP request packet.", 0),
975 m_packet_data (LLDB_OPT_SET_1, false, "payload", 'p', 0, eArgTypeNone, "Specify packet payload bytes as a hex ASCII string with no spaces or hex prefixes.", NULL)
976 {
977 m_option_group.Append (&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
978 m_option_group.Append (&m_packet_data , LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
979 m_option_group.Finalize();
980 }
981
~CommandObjectProcessKDPPacketSend()982 ~CommandObjectProcessKDPPacketSend ()
983 {
984 }
985
986 bool
DoExecute(Args & command,CommandReturnObject & result)987 DoExecute (Args& command, CommandReturnObject &result)
988 {
989 const size_t argc = command.GetArgumentCount();
990 if (argc == 0)
991 {
992 if (!m_command_byte.GetOptionValue().OptionWasSet())
993 {
994 result.AppendError ("the --command option must be set to a valid command byte");
995 result.SetStatus (eReturnStatusFailed);
996 }
997 else
998 {
999 const uint64_t command_byte = m_command_byte.GetOptionValue().GetUInt64Value(0);
1000 if (command_byte > 0 && command_byte <= UINT8_MAX)
1001 {
1002 ProcessKDP *process = (ProcessKDP *)m_interpreter.GetExecutionContext().GetProcessPtr();
1003 if (process)
1004 {
1005 const StateType state = process->GetState();
1006
1007 if (StateIsStoppedState (state, true))
1008 {
1009 std::vector<uint8_t> payload_bytes;
1010 const char *ascii_hex_bytes_cstr = m_packet_data.GetOptionValue().GetCurrentValue();
1011 if (ascii_hex_bytes_cstr && ascii_hex_bytes_cstr[0])
1012 {
1013 StringExtractor extractor(ascii_hex_bytes_cstr);
1014 const size_t ascii_hex_bytes_cstr_len = extractor.GetStringRef().size();
1015 if (ascii_hex_bytes_cstr_len & 1)
1016 {
1017 result.AppendErrorWithFormat ("payload data must contain an even number of ASCII hex characters: '%s'", ascii_hex_bytes_cstr);
1018 result.SetStatus (eReturnStatusFailed);
1019 return false;
1020 }
1021 payload_bytes.resize(ascii_hex_bytes_cstr_len/2);
1022 if (extractor.GetHexBytes(&payload_bytes[0], payload_bytes.size(), '\xdd') != payload_bytes.size())
1023 {
1024 result.AppendErrorWithFormat ("payload data must only contain ASCII hex characters (no spaces or hex prefixes): '%s'", ascii_hex_bytes_cstr);
1025 result.SetStatus (eReturnStatusFailed);
1026 return false;
1027 }
1028 }
1029 Error error;
1030 DataExtractor reply;
1031 process->GetCommunication().SendRawRequest (command_byte,
1032 payload_bytes.empty() ? NULL : payload_bytes.data(),
1033 payload_bytes.size(),
1034 reply,
1035 error);
1036
1037 if (error.Success())
1038 {
1039 // Copy the binary bytes into a hex ASCII string for the result
1040 StreamString packet;
1041 packet.PutBytesAsRawHex8(reply.GetDataStart(),
1042 reply.GetByteSize(),
1043 lldb::endian::InlHostByteOrder(),
1044 lldb::endian::InlHostByteOrder());
1045 result.AppendMessage(packet.GetString().c_str());
1046 result.SetStatus (eReturnStatusSuccessFinishResult);
1047 return true;
1048 }
1049 else
1050 {
1051 const char *error_cstr = error.AsCString();
1052 if (error_cstr && error_cstr[0])
1053 result.AppendError (error_cstr);
1054 else
1055 result.AppendErrorWithFormat ("unknown error 0x%8.8x", error.GetError());
1056 result.SetStatus (eReturnStatusFailed);
1057 return false;
1058 }
1059 }
1060 else
1061 {
1062 result.AppendErrorWithFormat ("process must be stopped in order to send KDP packets, state is %s", StateAsCString (state));
1063 result.SetStatus (eReturnStatusFailed);
1064 }
1065 }
1066 else
1067 {
1068 result.AppendError ("invalid process");
1069 result.SetStatus (eReturnStatusFailed);
1070 }
1071 }
1072 else
1073 {
1074 result.AppendErrorWithFormat ("invalid command byte 0x%" PRIx64 ", valid values are 1 - 255", command_byte);
1075 result.SetStatus (eReturnStatusFailed);
1076 }
1077 }
1078 }
1079 else
1080 {
1081 result.AppendErrorWithFormat ("'%s' takes no arguments, only options.", m_cmd_name.c_str());
1082 result.SetStatus (eReturnStatusFailed);
1083 }
1084 return false;
1085 }
1086 };
1087
1088 class CommandObjectProcessKDPPacket : public CommandObjectMultiword
1089 {
1090 private:
1091
1092 public:
CommandObjectProcessKDPPacket(CommandInterpreter & interpreter)1093 CommandObjectProcessKDPPacket(CommandInterpreter &interpreter) :
1094 CommandObjectMultiword (interpreter,
1095 "process plugin packet",
1096 "Commands that deal with KDP remote packets.",
1097 NULL)
1098 {
1099 LoadSubCommand ("send", CommandObjectSP (new CommandObjectProcessKDPPacketSend (interpreter)));
1100 }
1101
~CommandObjectProcessKDPPacket()1102 ~CommandObjectProcessKDPPacket ()
1103 {
1104 }
1105 };
1106
1107 class CommandObjectMultiwordProcessKDP : public CommandObjectMultiword
1108 {
1109 public:
CommandObjectMultiwordProcessKDP(CommandInterpreter & interpreter)1110 CommandObjectMultiwordProcessKDP (CommandInterpreter &interpreter) :
1111 CommandObjectMultiword (interpreter,
1112 "process plugin",
1113 "A set of commands for operating on a ProcessKDP process.",
1114 "process plugin <subcommand> [<subcommand-options>]")
1115 {
1116 LoadSubCommand ("packet", CommandObjectSP (new CommandObjectProcessKDPPacket (interpreter)));
1117 }
1118
~CommandObjectMultiwordProcessKDP()1119 ~CommandObjectMultiwordProcessKDP ()
1120 {
1121 }
1122 };
1123
1124 CommandObject *
GetPluginCommandObject()1125 ProcessKDP::GetPluginCommandObject()
1126 {
1127 if (!m_command_sp)
1128 m_command_sp.reset (new CommandObjectMultiwordProcessKDP (GetTarget().GetDebugger().GetCommandInterpreter()));
1129 return m_command_sp.get();
1130 }
1131
1132