blob: 1f092f9c714620caa32d70eba90a7ae7c3e6d732 [file] [log] [blame]
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001//===-- Process.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
Eugene Zelenko8f30a652015-10-23 18:39:37 +000010// C Includes
11// C++ Includes
Greg Clayton5cc45e02016-02-26 19:41:49 +000012#include <atomic>
Greg Clayton04df8ee2016-02-26 19:38:18 +000013#include <mutex>
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +000014
Eugene Zelenko8f30a652015-10-23 18:39:37 +000015// Other libraries and framework includes
16// Project includes
Sean Callanan579e70c2016-03-19 00:03:59 +000017#include "Plugins/Process/Utility/InferiorCallPOSIX.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000018#include "lldb/Breakpoint/BreakpointLocation.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000019#include "lldb/Breakpoint/StoppointCallbackContext.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000020#include "lldb/Core/Debugger.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000021#include "lldb/Core/Event.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000022#include "lldb/Core/Log.h"
Greg Clayton1f746072012-08-29 21:13:06 +000023#include "lldb/Core/Module.h"
Tamas Berghammer7cb18bf2015-03-24 11:15:23 +000024#include "lldb/Core/ModuleSpec.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000025#include "lldb/Core/PluginManager.h"
26#include "lldb/Core/State.h"
Greg Clayton44d93782014-01-27 23:43:24 +000027#include "lldb/Core/StreamFile.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000028#include "lldb/Expression/DiagnosticManager.h"
Zachary Turner93749ab2015-03-03 21:51:25 +000029#include "lldb/Expression/IRDynamicChecks.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000030#include "lldb/Expression/UserExpression.h"
Zachary Turner93a66fc2014-10-06 21:22:36 +000031#include "lldb/Host/ConnectionFileDescriptor.h"
Zachary Turner4eff2d32015-10-14 21:37:36 +000032#include "lldb/Host/FileSystem.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000033#include "lldb/Host/Host.h"
Zachary Turner39de3112014-09-09 20:54:56 +000034#include "lldb/Host/HostInfo.h"
Greg Clayton100eb932014-07-02 21:10:39 +000035#include "lldb/Host/Pipe.h"
Greg Clayton44d93782014-01-27 23:43:24 +000036#include "lldb/Host/Terminal.h"
Zachary Turner39de3112014-09-09 20:54:56 +000037#include "lldb/Host/ThreadLauncher.h"
Zachary Turner93a66fc2014-10-06 21:22:36 +000038#include "lldb/Interpreter/CommandInterpreter.h"
Zachary Turner633a29c2015-03-04 01:58:01 +000039#include "lldb/Interpreter/OptionValueProperties.h"
Jason Molenda484900b2015-08-10 07:55:25 +000040#include "lldb/Symbol/Function.h"
Zachary Turner93a66fc2014-10-06 21:22:36 +000041#include "lldb/Symbol/Symbol.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000042#include "lldb/Target/ABI.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000043#include "lldb/Target/CPPLanguageRuntime.h"
Greg Clayton8f343b02010-11-04 01:54:29 +000044#include "lldb/Target/DynamicLoader.h"
Zachary Turner93749ab2015-03-03 21:51:25 +000045#include "lldb/Target/InstrumentationRuntime.h"
Andrew MacPherson17220c12014-03-05 10:12:43 +000046#include "lldb/Target/JITLoader.h"
Zachary Turner93749ab2015-03-03 21:51:25 +000047#include "lldb/Target/JITLoaderList.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000048#include "lldb/Target/LanguageRuntime.h"
Kuba Breckaa51ea382014-09-06 01:33:13 +000049#include "lldb/Target/MemoryHistory.h"
Zachary Turner93749ab2015-03-03 21:51:25 +000050#include "lldb/Target/MemoryRegionInfo.h"
Jim Ingham22777012010-09-23 02:01:19 +000051#include "lldb/Target/ObjCLanguageRuntime.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000052#include "lldb/Target/OperatingSystem.h"
Greg Claytone996fd32011-03-08 22:40:15 +000053#include "lldb/Target/Platform.h"
Sean Callanan579e70c2016-03-19 00:03:59 +000054#include "lldb/Target/Process.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000055#include "lldb/Target/RegisterContext.h"
Greg Claytonf4b47e12010-08-04 01:40:35 +000056#include "lldb/Target/StopInfo.h"
Jason Molendaeef51062013-11-05 03:57:19 +000057#include "lldb/Target/SystemRuntime.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000058#include "lldb/Target/Target.h"
59#include "lldb/Target/TargetList.h"
60#include "lldb/Target/Thread.h"
61#include "lldb/Target/ThreadPlan.h"
Jim Ingham076b3042012-04-10 01:21:57 +000062#include "lldb/Target/ThreadPlanBase.h"
Zachary Turner93749ab2015-03-03 21:51:25 +000063#include "lldb/Target/UnixSignals.h"
Zachary Turner50232572015-03-18 21:31:45 +000064#include "lldb/Utility/NameMatches.h"
Chris Lattner30fdc8d2010-06-08 16:52:24 +000065
66using namespace lldb;
67using namespace lldb_private;
68
Greg Clayton67cc0632012-08-22 17:17:09 +000069// Comment out line below to disable memory caching, overriding the process setting
70// target.process.disable-memory-cache
71#define ENABLE_MEMORY_CACHING
72
73#ifdef ENABLE_MEMORY_CACHING
74#define DISABLE_MEM_CACHE_DEFAULT false
75#else
76#define DISABLE_MEM_CACHE_DEFAULT true
77#endif
78
79class ProcessOptionValueProperties : public OptionValueProperties
80{
81public:
82 ProcessOptionValueProperties (const ConstString &name) :
83 OptionValueProperties (name)
84 {
85 }
86
87 // This constructor is used when creating ProcessOptionValueProperties when it
88 // is part of a new lldb_private::Process instance. It will copy all current
89 // global property values as needed
90 ProcessOptionValueProperties (ProcessProperties *global_properties) :
91 OptionValueProperties(*global_properties->GetValueProperties())
92 {
93 }
94
Eugene Zelenko8f30a652015-10-23 18:39:37 +000095 const Property *
96 GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
Greg Clayton67cc0632012-08-22 17:17:09 +000097 {
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +000098 // When getting the value for a key from the process options, we will always
Greg Clayton67cc0632012-08-22 17:17:09 +000099 // try and grab the setting from the current process if there is one. Else we just
100 // use the one from this instance.
101 if (exe_ctx)
102 {
103 Process *process = exe_ctx->GetProcessPtr();
104 if (process)
105 {
106 ProcessOptionValueProperties *instance_properties = static_cast<ProcessOptionValueProperties *>(process->GetValueProperties().get());
107 if (this != instance_properties)
108 return instance_properties->ProtectedGetPropertyAtIndex (idx);
109 }
110 }
111 return ProtectedGetPropertyAtIndex (idx);
112 }
113};
114
115static PropertyDefinition
116g_properties[] =
117{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000118 { "disable-memory-cache" , OptionValue::eTypeBoolean, false, DISABLE_MEM_CACHE_DEFAULT, nullptr, nullptr, "Disable reading and caching of memory in fixed-size units." },
119 { "extra-startup-command", OptionValue::eTypeArray , false, OptionValue::eTypeString, nullptr, nullptr, "A list containing extra commands understood by the particular process plugin used. "
Jim Ingham8c3f2762012-11-29 00:41:12 +0000120 "For instance, to turn on debugserver logging set this to \"QSetLogging:bitmask=LOG_DEFAULT;\"" },
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000121 { "ignore-breakpoints-in-expressions", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, breakpoints will be ignored during expression evaluation." },
122 { "unwind-on-error-in-expressions", OptionValue::eTypeBoolean, true, true, nullptr, nullptr, "If true, errors in expression evaluation will unwind the stack back to the state before the call." },
123 { "python-os-plugin-path", OptionValue::eTypeFileSpec, false, true, nullptr, nullptr, "A path to a python OS plug-in module file that contains a OperatingSystemPlugIn class." },
124 { "stop-on-sharedlibrary-events" , OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, stop when a shared library is loaded or unloaded." },
125 { "detach-keeps-stopped" , OptionValue::eTypeBoolean, true, false, nullptr, nullptr, "If true, detach will attempt to keep the process stopped." },
126 { "memory-cache-line-size" , OptionValue::eTypeUInt64, false, 512, nullptr, nullptr, "The memory cache line size" },
127 { "optimization-warnings" , OptionValue::eTypeBoolean, false, true, nullptr, nullptr, "If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected." },
128 { nullptr , OptionValue::eTypeInvalid, false, 0, nullptr, nullptr, nullptr }
Greg Clayton67cc0632012-08-22 17:17:09 +0000129};
130
131enum {
132 ePropertyDisableMemCache,
Greg Claytonc9d645d2012-10-18 22:40:37 +0000133 ePropertyExtraStartCommand,
Jim Ingham184e9812013-01-15 02:47:48 +0000134 ePropertyIgnoreBreakpointsInExpressions,
135 ePropertyUnwindOnErrorInExpressions,
Jim Ingham29950772013-01-26 02:19:28 +0000136 ePropertyPythonOSPluginPath,
Jim Inghamacff8952013-05-02 00:27:30 +0000137 ePropertyStopOnSharedLibraryEvents,
Jason Molendaf0340c92014-09-03 22:30:54 +0000138 ePropertyDetachKeepsStopped,
Jason Molendaef7d6412015-08-06 03:27:10 +0000139 ePropertyMemCacheLineSize,
140 ePropertyWarningOptimization
Greg Clayton67cc0632012-08-22 17:17:09 +0000141};
142
Greg Clayton332e8b12015-01-13 21:13:08 +0000143ProcessProperties::ProcessProperties (lldb_private::Process *process) :
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000144 Properties(),
145 m_process(process) // Can be nullptr for global ProcessProperties
Greg Clayton67cc0632012-08-22 17:17:09 +0000146{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000147 if (process == nullptr)
Greg Clayton67cc0632012-08-22 17:17:09 +0000148 {
Greg Clayton332e8b12015-01-13 21:13:08 +0000149 // Global process properties, set them up one time
Greg Clayton67cc0632012-08-22 17:17:09 +0000150 m_collection_sp.reset (new ProcessOptionValueProperties(ConstString("process")));
151 m_collection_sp->Initialize(g_properties);
152 m_collection_sp->AppendProperty(ConstString("thread"),
Jim Ingham29950772013-01-26 02:19:28 +0000153 ConstString("Settings specific to threads."),
Greg Clayton67cc0632012-08-22 17:17:09 +0000154 true,
155 Thread::GetGlobalProperties()->GetValueProperties());
156 }
157 else
Greg Clayton332e8b12015-01-13 21:13:08 +0000158 {
Greg Clayton67cc0632012-08-22 17:17:09 +0000159 m_collection_sp.reset (new ProcessOptionValueProperties(Process::GetGlobalProperties().get()));
Greg Clayton332e8b12015-01-13 21:13:08 +0000160 m_collection_sp->SetValueChangedCallback(ePropertyPythonOSPluginPath, ProcessProperties::OptionValueChangedCallback, this);
161 }
Greg Clayton67cc0632012-08-22 17:17:09 +0000162}
163
Eugene Zelenko8f30a652015-10-23 18:39:37 +0000164ProcessProperties::~ProcessProperties() = default;
Greg Clayton67cc0632012-08-22 17:17:09 +0000165
Greg Clayton332e8b12015-01-13 21:13:08 +0000166void
167ProcessProperties::OptionValueChangedCallback (void *baton, OptionValue *option_value)
168{
169 ProcessProperties *properties = (ProcessProperties *)baton;
170 if (properties->m_process)
171 properties->m_process->LoadOperatingSystemPlugin(true);
172}
173
Greg Clayton67cc0632012-08-22 17:17:09 +0000174bool
175ProcessProperties::GetDisableMemoryCache() const
176{
177 const uint32_t idx = ePropertyDisableMemCache;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000178 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Greg Clayton67cc0632012-08-22 17:17:09 +0000179}
180
Jason Molendaf0340c92014-09-03 22:30:54 +0000181uint64_t
182ProcessProperties::GetMemoryCacheLineSize() const
183{
184 const uint32_t idx = ePropertyMemCacheLineSize;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000185 return m_collection_sp->GetPropertyAtIndexAsUInt64(nullptr, idx, g_properties[idx].default_uint_value);
Jason Molendaf0340c92014-09-03 22:30:54 +0000186}
187
Greg Clayton67cc0632012-08-22 17:17:09 +0000188Args
189ProcessProperties::GetExtraStartupCommands () const
190{
191 Args args;
192 const uint32_t idx = ePropertyExtraStartCommand;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000193 m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
Greg Clayton67cc0632012-08-22 17:17:09 +0000194 return args;
195}
196
197void
198ProcessProperties::SetExtraStartupCommands (const Args &args)
199{
200 const uint32_t idx = ePropertyExtraStartCommand;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000201 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
Greg Clayton67cc0632012-08-22 17:17:09 +0000202}
203
Greg Claytonc9d645d2012-10-18 22:40:37 +0000204FileSpec
205ProcessProperties::GetPythonOSPluginPath () const
206{
207 const uint32_t idx = ePropertyPythonOSPluginPath;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000208 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
Greg Claytonc9d645d2012-10-18 22:40:37 +0000209}
210
211void
212ProcessProperties::SetPythonOSPluginPath (const FileSpec &file)
213{
214 const uint32_t idx = ePropertyPythonOSPluginPath;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000215 m_collection_sp->SetPropertyAtIndexAsFileSpec(nullptr, idx, file);
Greg Claytonc9d645d2012-10-18 22:40:37 +0000216}
217
Jim Ingham184e9812013-01-15 02:47:48 +0000218bool
219ProcessProperties::GetIgnoreBreakpointsInExpressions () const
220{
221 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000222 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Jim Ingham184e9812013-01-15 02:47:48 +0000223}
224
225void
226ProcessProperties::SetIgnoreBreakpointsInExpressions (bool ignore)
227{
228 const uint32_t idx = ePropertyIgnoreBreakpointsInExpressions;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000229 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
Jim Ingham184e9812013-01-15 02:47:48 +0000230}
231
232bool
233ProcessProperties::GetUnwindOnErrorInExpressions () const
234{
235 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000236 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Jim Ingham184e9812013-01-15 02:47:48 +0000237}
238
239void
240ProcessProperties::SetUnwindOnErrorInExpressions (bool ignore)
241{
242 const uint32_t idx = ePropertyUnwindOnErrorInExpressions;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000243 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, ignore);
Jim Ingham184e9812013-01-15 02:47:48 +0000244}
245
Jim Ingham29950772013-01-26 02:19:28 +0000246bool
247ProcessProperties::GetStopOnSharedLibraryEvents () const
248{
249 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000250 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Jim Ingham29950772013-01-26 02:19:28 +0000251}
252
253void
254ProcessProperties::SetStopOnSharedLibraryEvents (bool stop)
255{
256 const uint32_t idx = ePropertyStopOnSharedLibraryEvents;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000257 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
Jim Ingham29950772013-01-26 02:19:28 +0000258}
259
Jim Inghamacff8952013-05-02 00:27:30 +0000260bool
261ProcessProperties::GetDetachKeepsStopped () const
262{
263 const uint32_t idx = ePropertyDetachKeepsStopped;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000264 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Jim Inghamacff8952013-05-02 00:27:30 +0000265}
266
267void
268ProcessProperties::SetDetachKeepsStopped (bool stop)
269{
270 const uint32_t idx = ePropertyDetachKeepsStopped;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000271 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, stop);
Jim Inghamacff8952013-05-02 00:27:30 +0000272}
273
Jason Molendaef7d6412015-08-06 03:27:10 +0000274bool
275ProcessProperties::GetWarningsOptimization () const
276{
277 const uint32_t idx = ePropertyWarningOptimization;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000278 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
Jason Molendaef7d6412015-08-06 03:27:10 +0000279}
280
Greg Clayton32e0a752011-03-30 18:16:51 +0000281void
Greg Clayton8b82f082011-04-12 05:54:46 +0000282ProcessInstanceInfo::Dump (Stream &s, Platform *platform) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000283{
284 const char *cstr;
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000285 if (m_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000286 s.Printf (" pid = %" PRIu64 "\n", m_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000287
288 if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
Daniel Malead01b2952012-11-29 21:49:15 +0000289 s.Printf (" parent = %" PRIu64 "\n", m_parent_pid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000290
291 if (m_executable)
292 {
293 s.Printf (" name = %s\n", m_executable.GetFilename().GetCString());
294 s.PutCString (" file = ");
295 m_executable.Dump(&s);
296 s.EOL();
297 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000298 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000299 if (argc > 0)
300 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000301 for (uint32_t i = 0; i < argc; i++)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000302 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000303 const char *arg = m_arguments.GetArgumentAtIndex(i);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000304 if (i < 10)
Greg Clayton8b82f082011-04-12 05:54:46 +0000305 s.Printf (" arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000306 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000307 s.Printf ("arg[%u] = %s\n", i, arg);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000308 }
309 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000310
311 const uint32_t envc = m_environment.GetArgumentCount();
312 if (envc > 0)
313 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000314 for (uint32_t i = 0; i < envc; i++)
Greg Clayton8b82f082011-04-12 05:54:46 +0000315 {
316 const char *env = m_environment.GetArgumentAtIndex(i);
317 if (i < 10)
318 s.Printf (" env[%u] = %s\n", i, env);
319 else
320 s.Printf ("env[%u] = %s\n", i, env);
321 }
322 }
323
Todd Fiala7df337f2015-10-13 23:41:19 +0000324 if (m_arch.IsValid())
325 {
326 s.Printf (" arch = ");
327 m_arch.DumpTriple(s);
328 s.EOL();
329 }
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000330
Greg Clayton8b82f082011-04-12 05:54:46 +0000331 if (m_uid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000332 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000333 cstr = platform->GetUserName (m_uid);
334 s.Printf (" uid = %-5u (%s)\n", m_uid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000335 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000336 if (m_gid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000337 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000338 cstr = platform->GetGroupName (m_gid);
339 s.Printf (" gid = %-5u (%s)\n", m_gid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000340 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000341 if (m_euid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000342 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000343 cstr = platform->GetUserName (m_euid);
344 s.Printf (" euid = %-5u (%s)\n", m_euid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000345 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000346 if (m_egid != UINT32_MAX)
Greg Clayton32e0a752011-03-30 18:16:51 +0000347 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000348 cstr = platform->GetGroupName (m_egid);
349 s.Printf (" egid = %-5u (%s)\n", m_egid, cstr ? cstr : "");
Greg Clayton32e0a752011-03-30 18:16:51 +0000350 }
351}
352
353void
Greg Clayton8b82f082011-04-12 05:54:46 +0000354ProcessInstanceInfo::DumpTableHeader (Stream &s, Platform *platform, bool show_args, bool verbose)
Greg Clayton32e0a752011-03-30 18:16:51 +0000355{
Greg Clayton8b82f082011-04-12 05:54:46 +0000356 const char *label;
357 if (show_args || verbose)
358 label = "ARGUMENTS";
359 else
360 label = "NAME";
361
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000362 if (verbose)
363 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000364 s.Printf ("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE %s\n", label);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000365 s.PutCString ("====== ====== ========== ========== ========== ========== ======================== ============================\n");
366 }
367 else
368 {
Jim Ingham368ac222014-08-15 17:05:27 +0000369 s.Printf ("PID PARENT USER TRIPLE %s\n", label);
370 s.PutCString ("====== ====== ========== ======================== ============================\n");
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000371 }
Greg Clayton32e0a752011-03-30 18:16:51 +0000372}
373
374void
Greg Clayton8b82f082011-04-12 05:54:46 +0000375ProcessInstanceInfo::DumpAsTableRow (Stream &s, Platform *platform, bool show_args, bool verbose) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000376{
377 if (m_pid != LLDB_INVALID_PROCESS_ID)
378 {
379 const char *cstr;
Daniel Malead01b2952012-11-29 21:49:15 +0000380 s.Printf ("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000381
Todd Fiala7df337f2015-10-13 23:41:19 +0000382 StreamString arch_strm;
383 if (m_arch.IsValid())
384 m_arch.DumpTriple(arch_strm);
385
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000386 if (verbose)
387 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000388 cstr = platform->GetUserName (m_uid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000389 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
390 s.Printf ("%-10s ", cstr);
391 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000392 s.Printf ("%-10u ", m_uid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000393
Greg Clayton8b82f082011-04-12 05:54:46 +0000394 cstr = platform->GetGroupName (m_gid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000395 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
396 s.Printf ("%-10s ", cstr);
397 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000398 s.Printf ("%-10u ", m_gid);
Greg Clayton32e0a752011-03-30 18:16:51 +0000399
Greg Clayton8b82f082011-04-12 05:54:46 +0000400 cstr = platform->GetUserName (m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000401 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
402 s.Printf ("%-10s ", cstr);
403 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000404 s.Printf ("%-10u ", m_euid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000405
Greg Clayton8b82f082011-04-12 05:54:46 +0000406 cstr = platform->GetGroupName (m_egid);
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000407 if (cstr && cstr[0]) // Watch for empty string that indicates lookup failed
408 s.Printf ("%-10s ", cstr);
409 else
Greg Clayton8b82f082011-04-12 05:54:46 +0000410 s.Printf ("%-10u ", m_egid);
Todd Fiala7df337f2015-10-13 23:41:19 +0000411
412 s.Printf ("%-24s ", arch_strm.GetString().c_str());
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000413 }
414 else
415 {
Jim Ingham368ac222014-08-15 17:05:27 +0000416 s.Printf ("%-10s %-24s ",
Greg Clayton8b82f082011-04-12 05:54:46 +0000417 platform->GetUserName (m_euid),
Todd Fiala7df337f2015-10-13 23:41:19 +0000418 arch_strm.GetString().c_str());
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000419 }
420
Greg Clayton8b82f082011-04-12 05:54:46 +0000421 if (verbose || show_args)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000422 {
Greg Clayton8b82f082011-04-12 05:54:46 +0000423 const uint32_t argc = m_arguments.GetArgumentCount();
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000424 if (argc > 0)
425 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000426 for (uint32_t i = 0; i < argc; i++)
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000427 {
428 if (i > 0)
429 s.PutChar (' ');
Greg Clayton8b82f082011-04-12 05:54:46 +0000430 s.PutCString (m_arguments.GetArgumentAtIndex(i));
Greg Clayton95bf0fd2011-04-01 00:29:43 +0000431 }
432 }
433 }
434 else
435 {
436 s.PutCString (GetName());
437 }
438
439 s.EOL();
Greg Clayton32e0a752011-03-30 18:16:51 +0000440 }
441}
442
Greg Clayton8b82f082011-04-12 05:54:46 +0000443Error
Greg Claytonf6b8b582011-04-13 00:18:08 +0000444ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
Greg Clayton8b82f082011-04-12 05:54:46 +0000445{
446 Error error;
Greg Clayton3bcdfc02012-12-04 00:32:51 +0000447 const int short_option = m_getopt_table[option_idx].val;
Greg Clayton8b82f082011-04-12 05:54:46 +0000448
449 switch (short_option)
450 {
451 case 's': // Stop at program entry point
452 launch_info.GetFlags().Set (eLaunchFlagStopAtEntry);
453 break;
454
Greg Clayton8b82f082011-04-12 05:54:46 +0000455 case 'i': // STDIN for read only
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000456 {
457 FileAction action;
Chaoren Lind3173f32015-05-29 19:52:29 +0000458 if (action.Open(STDIN_FILENO, FileSpec{option_arg, false}, true, false))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000459 launch_info.AppendFileAction (action);
Greg Clayton8b82f082011-04-12 05:54:46 +0000460 break;
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000461 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000462
463 case 'o': // Open STDOUT for write only
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000464 {
465 FileAction action;
Chaoren Lind3173f32015-05-29 19:52:29 +0000466 if (action.Open(STDOUT_FILENO, FileSpec{option_arg, false}, false, true))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000467 launch_info.AppendFileAction (action);
Greg Clayton9845a8d2012-03-06 04:01:04 +0000468 break;
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000469 }
Greg Clayton9845a8d2012-03-06 04:01:04 +0000470
471 case 'e': // STDERR for write only
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000472 {
473 FileAction action;
Chaoren Lind3173f32015-05-29 19:52:29 +0000474 if (action.Open(STDERR_FILENO, FileSpec{option_arg, false}, false, true))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000475 launch_info.AppendFileAction (action);
Greg Clayton8b82f082011-04-12 05:54:46 +0000476 break;
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000477 }
Greg Clayton9845a8d2012-03-06 04:01:04 +0000478
Greg Clayton8b82f082011-04-12 05:54:46 +0000479 case 'p': // Process plug-in name
480 launch_info.SetProcessPluginName (option_arg);
481 break;
482
483 case 'n': // Disable STDIO
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000484 {
485 FileAction action;
Zachary Turner4eff2d32015-10-14 21:37:36 +0000486 const FileSpec dev_null{FileSystem::DEV_NULL, false};
Chaoren Lind3173f32015-05-29 19:52:29 +0000487 if (action.Open(STDIN_FILENO, dev_null, true, false))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000488 launch_info.AppendFileAction (action);
Chaoren Lind3173f32015-05-29 19:52:29 +0000489 if (action.Open(STDOUT_FILENO, dev_null, false, true))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000490 launch_info.AppendFileAction (action);
Chaoren Lind3173f32015-05-29 19:52:29 +0000491 if (action.Open(STDERR_FILENO, dev_null, false, true))
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000492 launch_info.AppendFileAction (action);
Greg Clayton8b82f082011-04-12 05:54:46 +0000493 break;
Zachary Turnerc00cf4a2014-08-15 22:04:21 +0000494 }
Greg Clayton8b82f082011-04-12 05:54:46 +0000495
496 case 'w':
Chaoren Lind3173f32015-05-29 19:52:29 +0000497 launch_info.SetWorkingDirectory(FileSpec{option_arg, false});
Greg Clayton8b82f082011-04-12 05:54:46 +0000498 break;
499
500 case 't': // Open process in new terminal window
501 launch_info.GetFlags().Set (eLaunchFlagLaunchInTTY);
502 break;
503
504 case 'a':
Greg Clayton70512312012-05-08 01:45:38 +0000505 if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
506 launch_info.GetArchitecture().SetTriple (option_arg);
Greg Clayton8b82f082011-04-12 05:54:46 +0000507 break;
508
Todd Fiala51637922014-08-19 17:40:43 +0000509 case 'A': // Disable ASLR.
510 {
511 bool success;
512 const bool disable_aslr_arg = Args::StringToBoolean (option_arg, true, &success);
513 if (success)
514 disable_aslr = disable_aslr_arg ? eLazyBoolYes : eLazyBoolNo;
515 else
516 error.SetErrorStringWithFormat ("Invalid boolean value for disable-aslr option: '%s'", option_arg ? option_arg : "<null>");
Greg Clayton8b82f082011-04-12 05:54:46 +0000517 break;
Todd Fiala51637922014-08-19 17:40:43 +0000518 }
519
Enrico Granatab38ef8c2015-02-20 22:20:30 +0000520 case 'X': // shell expand args.
Enrico Granatad7a83a92015-02-10 03:06:24 +0000521 {
522 bool success;
Enrico Granatab38ef8c2015-02-20 22:20:30 +0000523 const bool expand_args = Args::StringToBoolean (option_arg, true, &success);
Enrico Granatad7a83a92015-02-10 03:06:24 +0000524 if (success)
Enrico Granatab38ef8c2015-02-20 22:20:30 +0000525 launch_info.SetShellExpandArguments(expand_args);
Enrico Granatad7a83a92015-02-10 03:06:24 +0000526 else
Enrico Granatab38ef8c2015-02-20 22:20:30 +0000527 error.SetErrorStringWithFormat ("Invalid boolean value for shell-expand-args option: '%s'", option_arg ? option_arg : "<null>");
Enrico Granatad7a83a92015-02-10 03:06:24 +0000528 break;
529 }
530
Todd Fiala51637922014-08-19 17:40:43 +0000531 case 'c':
Greg Clayton144f3a92011-11-15 03:53:30 +0000532 if (option_arg && option_arg[0])
Zachary Turner10687b02014-10-20 17:46:43 +0000533 launch_info.SetShell (FileSpec(option_arg, false));
Greg Clayton144f3a92011-11-15 03:53:30 +0000534 else
Zachary Turner10687b02014-10-20 17:46:43 +0000535 launch_info.SetShell (HostInfo::GetDefaultShell());
Greg Clayton982c9762011-11-03 21:22:33 +0000536 break;
537
Greg Clayton8b82f082011-04-12 05:54:46 +0000538 case 'v':
539 launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
540 break;
541
542 default:
Greg Clayton86edbf42011-10-26 00:56:27 +0000543 error.SetErrorStringWithFormat("unrecognized short option character '%c'", short_option);
Greg Clayton8b82f082011-04-12 05:54:46 +0000544 break;
Greg Clayton8b82f082011-04-12 05:54:46 +0000545 }
546 return error;
547}
548
549OptionDefinition
550ProcessLaunchCommandOptions::g_option_table[] =
551{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000552{ LLDB_OPT_SET_ALL, false, "stop-at-entry", 's', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Stop at the entry point of the program when launching a process." },
553{ LLDB_OPT_SET_ALL, false, "disable-aslr", 'A', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Set whether to disable address space layout randomization when launching a process." },
554{ LLDB_OPT_SET_ALL, false, "plugin", 'p', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePlugin, "Name of the process plugin you want to use." },
555{ LLDB_OPT_SET_ALL, false, "working-dir", 'w', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeDirectoryName, "Set the current working directory to <path> when running the inferior." },
556{ LLDB_OPT_SET_ALL, false, "arch", 'a', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeArchitecture, "Set the architecture for the process to launch when ambiguous." },
557{ LLDB_OPT_SET_ALL, false, "environment", 'v', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "Specify an environment variable name/value string (--environment NAME=VALUE). Can be specified multiple times for subsequent environment entries." },
558{ LLDB_OPT_SET_1|LLDB_OPT_SET_2|LLDB_OPT_SET_3, false, "shell", 'c', OptionParser::eOptionalArgument, nullptr, nullptr, 0, eArgTypeFilename, "Run the process in a shell (not supported on all platforms)." },
Greg Clayton8b82f082011-04-12 05:54:46 +0000559
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000560{ LLDB_OPT_SET_1 , false, "stdin", 'i', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stdin for the process to <filename>." },
561{ LLDB_OPT_SET_1 , false, "stdout", 'o', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stdout for the process to <filename>." },
562{ LLDB_OPT_SET_1 , false, "stderr", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeFilename, "Redirect stderr for the process to <filename>." },
Greg Clayton8b82f082011-04-12 05:54:46 +0000563
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000564{ LLDB_OPT_SET_2 , false, "tty", 't', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Start the process in a terminal (not supported on all platforms)." },
Greg Clayton8b82f082011-04-12 05:54:46 +0000565
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000566{ LLDB_OPT_SET_3 , false, "no-stdio", 'n', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Do not set up for terminal I/O to go to running process." },
567{ LLDB_OPT_SET_4, false, "shell-expand-args", 'X', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Set whether to shell expand arguments to the process when launching." },
568{ 0 , false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
Greg Clayton8b82f082011-04-12 05:54:46 +0000569};
570
Greg Clayton8b82f082011-04-12 05:54:46 +0000571bool
572ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000573{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000574 if (m_name_match_type == eNameMatchIgnore || process_name == nullptr)
Greg Clayton32e0a752011-03-30 18:16:51 +0000575 return true;
576 const char *match_name = m_match_info.GetName();
577 if (!match_name)
578 return true;
579
580 return lldb_private::NameMatches (process_name, m_name_match_type, match_name);
581}
582
583bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000584ProcessInstanceInfoMatch::Matches (const ProcessInstanceInfo &proc_info) const
Greg Clayton32e0a752011-03-30 18:16:51 +0000585{
586 if (!NameMatches (proc_info.GetName()))
587 return false;
588
589 if (m_match_info.ProcessIDIsValid() &&
590 m_match_info.GetProcessID() != proc_info.GetProcessID())
591 return false;
592
593 if (m_match_info.ParentProcessIDIsValid() &&
594 m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
595 return false;
596
Greg Clayton8b82f082011-04-12 05:54:46 +0000597 if (m_match_info.UserIDIsValid () &&
598 m_match_info.GetUserID() != proc_info.GetUserID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000599 return false;
600
Greg Clayton8b82f082011-04-12 05:54:46 +0000601 if (m_match_info.GroupIDIsValid () &&
602 m_match_info.GetGroupID() != proc_info.GetGroupID())
Greg Clayton32e0a752011-03-30 18:16:51 +0000603 return false;
604
605 if (m_match_info.EffectiveUserIDIsValid () &&
606 m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
607 return false;
608
609 if (m_match_info.EffectiveGroupIDIsValid () &&
610 m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
611 return false;
612
613 if (m_match_info.GetArchitecture().IsValid() &&
Sean Callananbf4b7be2012-12-13 22:07:14 +0000614 !m_match_info.GetArchitecture().IsCompatibleMatch(proc_info.GetArchitecture()))
Greg Clayton32e0a752011-03-30 18:16:51 +0000615 return false;
616 return true;
617}
618
619bool
Greg Clayton8b82f082011-04-12 05:54:46 +0000620ProcessInstanceInfoMatch::MatchAllProcesses () const
Greg Clayton32e0a752011-03-30 18:16:51 +0000621{
622 if (m_name_match_type != eNameMatchIgnore)
623 return false;
624
625 if (m_match_info.ProcessIDIsValid())
626 return false;
627
628 if (m_match_info.ParentProcessIDIsValid())
629 return false;
630
Greg Clayton8b82f082011-04-12 05:54:46 +0000631 if (m_match_info.UserIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000632 return false;
633
Greg Clayton8b82f082011-04-12 05:54:46 +0000634 if (m_match_info.GroupIDIsValid ())
Greg Clayton32e0a752011-03-30 18:16:51 +0000635 return false;
636
637 if (m_match_info.EffectiveUserIDIsValid ())
638 return false;
639
640 if (m_match_info.EffectiveGroupIDIsValid ())
641 return false;
642
643 if (m_match_info.GetArchitecture().IsValid())
644 return false;
645
646 if (m_match_all_users)
647 return false;
648
649 return true;
Greg Clayton32e0a752011-03-30 18:16:51 +0000650}
651
652void
Greg Clayton8b82f082011-04-12 05:54:46 +0000653ProcessInstanceInfoMatch::Clear()
Greg Clayton32e0a752011-03-30 18:16:51 +0000654{
655 m_match_info.Clear();
656 m_name_match_type = eNameMatchIgnore;
657 m_match_all_users = false;
658}
Greg Clayton58be07b2011-01-07 06:08:19 +0000659
Greg Claytonc3776bf2012-02-09 06:16:32 +0000660ProcessSP
Jim Ingham583bbb12016-03-07 21:50:25 +0000661Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, ListenerSP listener_sp, const FileSpec *crash_file_path)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000662{
Greg Clayton949e8222013-01-16 17:29:04 +0000663 static uint32_t g_process_unique_id = 0;
664
Greg Claytonc3776bf2012-02-09 06:16:32 +0000665 ProcessSP process_sp;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000666 ProcessCreateInstance create_callback = nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000667 if (plugin_name)
668 {
Greg Clayton57abc5d2013-05-10 21:47:16 +0000669 ConstString const_plugin_name(plugin_name);
670 create_callback = PluginManager::GetProcessCreateCallbackForPluginName (const_plugin_name);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000671 if (create_callback)
672 {
Jim Ingham583bbb12016-03-07 21:50:25 +0000673 process_sp = create_callback(target_sp, listener_sp, crash_file_path);
Greg Claytonc3776bf2012-02-09 06:16:32 +0000674 if (process_sp)
675 {
Zachary Turner7529df92015-09-01 20:02:29 +0000676 if (process_sp->CanDebug(target_sp, true))
Greg Clayton949e8222013-01-16 17:29:04 +0000677 {
678 process_sp->m_process_unique_id = ++g_process_unique_id;
679 }
680 else
Greg Claytonc3776bf2012-02-09 06:16:32 +0000681 process_sp.reset();
682 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000683 }
684 }
685 else
686 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000687 for (uint32_t idx = 0; (create_callback = PluginManager::GetProcessCreateCallbackAtIndex(idx)) != nullptr; ++idx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000688 {
Jim Ingham583bbb12016-03-07 21:50:25 +0000689 process_sp = create_callback(target_sp, listener_sp, crash_file_path);
Greg Claytonc3776bf2012-02-09 06:16:32 +0000690 if (process_sp)
691 {
Zachary Turner7529df92015-09-01 20:02:29 +0000692 if (process_sp->CanDebug(target_sp, false))
Greg Clayton949e8222013-01-16 17:29:04 +0000693 {
694 process_sp->m_process_unique_id = ++g_process_unique_id;
Greg Claytonc3776bf2012-02-09 06:16:32 +0000695 break;
Greg Clayton949e8222013-01-16 17:29:04 +0000696 }
697 else
698 process_sp.reset();
Greg Claytonc3776bf2012-02-09 06:16:32 +0000699 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000700 }
701 }
Greg Claytonc3776bf2012-02-09 06:16:32 +0000702 return process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000703}
704
Jim Ingham4bddaeb2012-02-16 06:50:00 +0000705ConstString &
706Process::GetStaticBroadcasterClass ()
707{
708 static ConstString class_name ("lldb.process");
709 return class_name;
710}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000711
Jim Ingham583bbb12016-03-07 21:50:25 +0000712Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp) :
713 Process(target_sp, listener_sp, UnixSignals::Create(HostInfo::GetArchitecture()))
Todd Fiala4ceced32014-08-29 17:35:57 +0000714{
715 // This constructor just delegates to the full Process constructor,
716 // defaulting to using the Host's UnixSignals.
717}
718
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000719Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, const UnixSignalsSP &unix_signals_sp)
720 : ProcessProperties(this),
721 UserID(LLDB_INVALID_PROCESS_ID),
722 Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()), Process::GetStaticBroadcasterClass().AsCString()),
723 m_target_sp(target_sp),
724 m_public_state(eStateUnloaded),
725 m_private_state(eStateUnloaded),
726 m_private_state_broadcaster(nullptr, "lldb.process.internal_state_broadcaster"),
727 m_private_state_control_broadcaster(nullptr, "lldb.process.internal_state_control_broadcaster"),
728 m_private_state_listener_sp(Listener::MakeListener("lldb.process.internal_state_listener")),
729 m_mod_id(),
730 m_process_unique_id(0),
731 m_thread_index_id(0),
732 m_thread_id_to_index_id_map(),
733 m_exit_status(-1),
734 m_exit_string(),
735 m_exit_status_mutex(),
736 m_thread_mutex(),
737 m_thread_list_real(this),
738 m_thread_list(this),
739 m_extended_thread_list(this),
740 m_extended_thread_stop_id(0),
741 m_queue_list(this),
742 m_queue_list_stop_id(0),
743 m_notifications(),
744 m_image_tokens(),
745 m_listener_sp(listener_sp),
746 m_breakpoint_site_list(),
747 m_dynamic_checkers_ap(),
748 m_unix_signals_sp(unix_signals_sp),
749 m_abi_sp(),
750 m_process_input_reader(),
751 m_stdio_communication("process.stdio"),
752 m_stdio_communication_mutex(),
753 m_stdin_forward(false),
754 m_stdout_data(),
755 m_stderr_data(),
756 m_profile_data_comm_mutex(),
757 m_profile_data(),
758 m_iohandler_sync(0),
759 m_memory_cache(*this),
760 m_allocated_memory_cache(*this),
761 m_should_detach(false),
762 m_next_event_action_ap(),
763 m_public_run_lock(),
764 m_private_run_lock(),
765 m_stop_info_override_callback(nullptr),
766 m_finalizing(false),
767 m_finalize_called(false),
768 m_clear_thread_plans_on_stop(false),
769 m_force_next_event_delivery(false),
770 m_last_broadcast_state(eStateInvalid),
771 m_destroy_in_process(false),
772 m_can_interpret_function_calls(false),
773 m_warnings_issued(),
Jim Ingham3cc425832016-05-24 18:29:36 +0000774 m_run_thread_plan_lock(),
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000775 m_can_jit(eCanJITDontKnow)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000776{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000777 CheckInWithManager();
Caroline Tice1559a462010-09-27 00:30:10 +0000778
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000779 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000780 if (log)
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000781 log->Printf("%p Process::Process()", static_cast<void *>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000782
Todd Fiala4ceced32014-08-29 17:35:57 +0000783 if (!m_unix_signals_sp)
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000784 m_unix_signals_sp = std::make_shared<UnixSignals>();
Todd Fiala4ceced32014-08-29 17:35:57 +0000785
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000786 SetEventName(eBroadcastBitStateChanged, "state-changed");
787 SetEventName(eBroadcastBitInterrupt, "interrupt");
788 SetEventName(eBroadcastBitSTDOUT, "stdout-available");
789 SetEventName(eBroadcastBitSTDERR, "stderr-available");
790 SetEventName(eBroadcastBitProfileData, "profile-data-available");
Chaoren Lin98d0a4b2015-07-14 01:09:28 +0000791
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000792 m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlStop, "control-stop");
793 m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlPause, "control-pause");
794 m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlResume, "control-resume");
Greg Clayton35a4cc52012-10-29 20:52:08 +0000795
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000796 m_listener_sp->StartListeningForEvents(this, eBroadcastBitStateChanged | eBroadcastBitInterrupt |
797 eBroadcastBitSTDOUT | eBroadcastBitSTDERR |
798 eBroadcastBitProfileData);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000799
Jim Ingham583bbb12016-03-07 21:50:25 +0000800 m_private_state_listener_sp->StartListeningForEvents(&m_private_state_broadcaster,
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000801 eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000802
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000803 m_private_state_listener_sp->StartListeningForEvents(
804 &m_private_state_control_broadcaster, eBroadcastInternalStateControlStop | eBroadcastInternalStateControlPause |
805 eBroadcastInternalStateControlResume);
Todd Fiala4ceced32014-08-29 17:35:57 +0000806 // We need something valid here, even if just the default UnixSignalsSP.
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000807 assert(m_unix_signals_sp && "null m_unix_signals_sp after initialization");
Pavel Labathf2991482015-10-20 10:33:17 +0000808
809 // Allow the platform to override the default cache line size
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000810 OptionValueSP value_sp = m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue();
Pavel Labathf2991482015-10-20 10:33:17 +0000811 uint32_t platform_cache_line_size = target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +0000812 if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
Pavel Labathf2991482015-10-20 10:33:17 +0000813 value_sp->SetUInt64Value(platform_cache_line_size);
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000814}
815
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000816Process::~Process()
817{
Greg Clayton5160ce52013-03-27 23:08:40 +0000818 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000819 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +0000820 log->Printf ("%p Process::~Process()", static_cast<void*>(this));
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000821 StopPrivateStateThread();
Zachary Turner39de3112014-09-09 20:54:56 +0000822
823 // ThreadList::Clear() will try to acquire this process's mutex, so
824 // explicitly clear the thread list here to ensure that the mutex
825 // is not destroyed before the thread list.
826 m_thread_list.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000827}
828
Greg Clayton67cc0632012-08-22 17:17:09 +0000829const ProcessPropertiesSP &
830Process::GetGlobalProperties()
831{
Greg Claytoncc2e27f2016-02-26 23:20:08 +0000832 // NOTE: intentional leak so we don't crash if global destructor chain gets
833 // called as other threads still use the result of this function
834 static ProcessPropertiesSP *g_settings_sp_ptr = nullptr;
Greg Clayton04df8ee2016-02-26 19:38:18 +0000835 static std::once_flag g_once_flag;
836 std::call_once(g_once_flag, []() {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000837 g_settings_sp_ptr = new ProcessPropertiesSP(new ProcessProperties(nullptr));
Greg Clayton04df8ee2016-02-26 19:38:18 +0000838 });
Greg Claytoncc2e27f2016-02-26 23:20:08 +0000839 return *g_settings_sp_ptr;
Greg Clayton67cc0632012-08-22 17:17:09 +0000840}
841
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000842void
843Process::Finalize()
844{
Greg Claytonc00ca312015-04-02 18:44:58 +0000845 m_finalizing = true;
846
Ilia Kc7efd562015-03-26 07:40:40 +0000847 // Destroy this process if needed
848 switch (GetPrivateState())
849 {
850 case eStateConnected:
851 case eStateAttaching:
852 case eStateLaunching:
853 case eStateStopped:
854 case eStateRunning:
855 case eStateStepping:
856 case eStateCrashed:
857 case eStateSuspended:
Jason Molendaede31932015-04-17 05:01:58 +0000858 Destroy(false);
Ilia Kc7efd562015-03-26 07:40:40 +0000859 break;
860
861 case eStateInvalid:
862 case eStateUnloaded:
863 case eStateDetached:
864 case eStateExited:
865 break;
866 }
Greg Claytone24c4ac2011-11-17 04:46:02 +0000867
Greg Clayton1ed54f52011-10-01 00:45:15 +0000868 // Clear our broadcaster before we proceed with destroying
869 Broadcaster::Clear();
870
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000871 // Do any cleanup needed prior to being destructed... Subclasses
872 // that override this method should call this superclass method as well.
Jim Inghamd0a3e122011-02-16 17:54:55 +0000873
874 // We need to destroy the loader before the derived Process class gets destroyed
875 // since it is very likely that undoing the loader will require access to the real process.
Greg Clayton894f82f2012-01-20 23:08:34 +0000876 m_dynamic_checkers_ap.reset();
877 m_abi_sp.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +0000878 m_os_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +0000879 m_system_runtime_ap.reset();
Greg Clayton894f82f2012-01-20 23:08:34 +0000880 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +0000881 m_jit_loaders_ap.reset();
Andrew Kaylorba4e61d2013-05-07 18:35:34 +0000882 m_thread_list_real.Destroy();
Greg Claytone1cd1be2012-01-29 20:56:30 +0000883 m_thread_list.Destroy();
Jason Molenda864f1cc2013-11-11 05:20:44 +0000884 m_extended_thread_list.Destroy();
Jason Molenda5e8dce42013-12-13 00:29:16 +0000885 m_queue_list.Clear();
886 m_queue_list_stop_id = 0;
Greg Clayton894f82f2012-01-20 23:08:34 +0000887 std::vector<Notifications> empty_notifications;
888 m_notifications.swap(empty_notifications);
889 m_image_tokens.clear();
890 m_memory_cache.Clear();
891 m_allocated_memory_cache.Clear();
892 m_language_runtimes.clear();
Kuba Breckaafdf8422014-10-10 23:43:03 +0000893 m_instrumentation_runtimes.clear();
Greg Clayton894f82f2012-01-20 23:08:34 +0000894 m_next_event_action_ap.reset();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000895 m_stop_info_override_callback = nullptr;
Greg Clayton08765fa2015-05-28 03:24:30 +0000896 // Clear the last natural stop ID since it has a strong
897 // reference to this process
898 m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
Greg Clayton35a4cc52012-10-29 20:52:08 +0000899//#ifdef LLDB_CONFIGURATION_DEBUG
900// StreamFile s(stdout, false);
901// EventSP event_sp;
Jim Ingham583bbb12016-03-07 21:50:25 +0000902// while (m_private_state_listener_sp->GetNextEvent(event_sp))
Greg Clayton35a4cc52012-10-29 20:52:08 +0000903// {
904// event_sp->Dump (&s);
905// s.EOL();
906// }
907//#endif
908 // We have to be very careful here as the m_private_state_listener might
909 // contain events that have ProcessSP values in them which can keep this
910 // process around forever. These events need to be cleared out.
Jim Ingham583bbb12016-03-07 21:50:25 +0000911 m_private_state_listener_sp->Clear();
Ed Maste64fad602013-07-29 20:58:06 +0000912 m_public_run_lock.TrySetRunning(); // This will do nothing if already locked
913 m_public_run_lock.SetStopped();
914 m_private_run_lock.TrySetRunning(); // This will do nothing if already locked
915 m_private_run_lock.SetStopped();
Jim Ingham4fc6cb92012-08-22 21:34:33 +0000916 m_finalize_called = true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000917}
918
919void
920Process::RegisterNotificationCallbacks (const Notifications& callbacks)
921{
922 m_notifications.push_back(callbacks);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000923 if (callbacks.initialize != nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000924 callbacks.initialize (callbacks.baton, this);
925}
926
927bool
928Process::UnregisterNotificationCallbacks(const Notifications& callbacks)
929{
930 std::vector<Notifications>::iterator pos, end = m_notifications.end();
931 for (pos = m_notifications.begin(); pos != end; ++pos)
932 {
933 if (pos->baton == callbacks.baton &&
934 pos->initialize == callbacks.initialize &&
935 pos->process_state_changed == callbacks.process_state_changed)
936 {
937 m_notifications.erase(pos);
938 return true;
939 }
940 }
941 return false;
942}
943
944void
945Process::SynchronouslyNotifyStateChanged (StateType state)
946{
947 std::vector<Notifications>::iterator notification_pos, notification_end = m_notifications.end();
948 for (notification_pos = m_notifications.begin(); notification_pos != notification_end; ++notification_pos)
949 {
950 if (notification_pos->process_state_changed)
951 notification_pos->process_state_changed (notification_pos->baton, this, state);
952 }
953}
954
955// FIXME: We need to do some work on events before the general Listener sees them.
956// For instance if we are continuing from a breakpoint, we need to ensure that we do
957// the little "insert real insn, step & stop" trick. But we can't do that when the
958// event is delivered by the broadcaster - since that is done on the thread that is
959// waiting for new events, so if we needed more than one event for our handling, we would
960// stall. So instead we do it when we fetch the event off of the queue.
961//
962
963StateType
964Process::GetNextEvent (EventSP &event_sp)
965{
966 StateType state = eStateInvalid;
967
Jim Ingham583bbb12016-03-07 21:50:25 +0000968 if (m_listener_sp->GetNextEventForBroadcaster (this, event_sp) && event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000969 state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
970
971 return state;
972}
973
Pavel Labath44464872015-05-27 12:40:32 +0000974void
975Process::SyncIOHandler (uint32_t iohandler_id, uint64_t timeout_msec)
Todd Fialaa3b89e22014-08-12 14:33:19 +0000976{
Todd Fialaa3b89e22014-08-12 14:33:19 +0000977 // don't sync (potentially context switch) in case where there is no process IO
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +0000978 if (!m_process_input_reader)
Pavel Labath44464872015-05-27 12:40:32 +0000979 return;
Todd Fialaa3b89e22014-08-12 14:33:19 +0000980
Pavel Labath44464872015-05-27 12:40:32 +0000981 TimeValue timeout = TimeValue::Now();
982 timeout.OffsetWithMicroSeconds(timeout_msec*1000);
983 uint32_t new_iohandler_id = 0;
984 m_iohandler_sync.WaitForValueNotEqualTo(iohandler_id, new_iohandler_id, &timeout);
Todd Fialaa3b89e22014-08-12 14:33:19 +0000985
Pavel Labath44464872015-05-27 12:40:32 +0000986 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
987 if (log)
988 log->Printf("Process::%s waited for m_iohandler_sync to change from %u, new value is %u", __FUNCTION__, iohandler_id, new_iohandler_id);
Todd Fialaa3b89e22014-08-12 14:33:19 +0000989}
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000990
991StateType
Greg Claytondc6224e2014-10-21 01:00:42 +0000992Process::WaitForProcessToStop (const TimeValue *timeout,
993 EventSP *event_sp_ptr,
994 bool wait_always,
Jim Ingham583bbb12016-03-07 21:50:25 +0000995 ListenerSP hijack_listener_sp,
Pavel Labath19da1f12015-12-07 12:36:52 +0000996 Stream *stream,
997 bool use_run_lock)
Chris Lattner30fdc8d2010-06-08 16:52:24 +0000998{
Jim Ingham4b536182011-08-09 02:12:22 +0000999 // We can't just wait for a "stopped" event, because the stopped event may have restarted the target.
1000 // We have to actually check each event, and in the case of a stopped event check the restarted flag
1001 // on the event.
Greg Clayton85fb1b92012-09-11 02:33:37 +00001002 if (event_sp_ptr)
1003 event_sp_ptr->reset();
Jim Ingham4b536182011-08-09 02:12:22 +00001004 StateType state = GetState();
1005 // If we are exited or detached, we won't ever get back to any
1006 // other valid state...
1007 if (state == eStateDetached || state == eStateExited)
1008 return state;
1009
Daniel Malea9e9919f2013-10-09 16:56:28 +00001010 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
1011 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001012 log->Printf ("Process::%s (timeout = %p)", __FUNCTION__,
1013 static_cast<const void*>(timeout));
Daniel Malea9e9919f2013-10-09 16:56:28 +00001014
1015 if (!wait_always &&
1016 StateIsStoppedState(state, true) &&
Jim Ingham5b4c5eb2015-04-22 17:48:24 +00001017 StateIsStoppedState(GetPrivateState(), true))
1018 {
Daniel Malea9e9919f2013-10-09 16:56:28 +00001019 if (log)
1020 log->Printf("Process::%s returning without waiting for events; process private and public states are already 'stopped'.",
1021 __FUNCTION__);
Pavel Labath78521ef2015-03-06 10:52:47 +00001022 // We need to toggle the run lock as this won't get done in
1023 // SetPublicState() if the process is hijacked.
Jim Ingham583bbb12016-03-07 21:50:25 +00001024 if (hijack_listener_sp && use_run_lock)
Pavel Labath78521ef2015-03-06 10:52:47 +00001025 m_public_run_lock.SetStopped();
Daniel Malea9e9919f2013-10-09 16:56:28 +00001026 return state;
1027 }
1028
Jim Ingham4b536182011-08-09 02:12:22 +00001029 while (state != eStateInvalid)
1030 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00001031 EventSP event_sp;
Jim Ingham583bbb12016-03-07 21:50:25 +00001032 state = WaitForStateChangedEvents (timeout, event_sp, hijack_listener_sp);
Greg Clayton85fb1b92012-09-11 02:33:37 +00001033 if (event_sp_ptr && event_sp)
1034 *event_sp_ptr = event_sp;
1035
Jim Ingham583bbb12016-03-07 21:50:25 +00001036 bool pop_process_io_handler = (hijack_listener_sp.get() != nullptr);
Greg Claytondc6224e2014-10-21 01:00:42 +00001037 Process::HandleProcessStateChangedEvent (event_sp, stream, pop_process_io_handler);
1038
Jim Ingham4b536182011-08-09 02:12:22 +00001039 switch (state)
1040 {
1041 case eStateCrashed:
1042 case eStateDetached:
1043 case eStateExited:
1044 case eStateUnloaded:
Greg Clayton44d93782014-01-27 23:43:24 +00001045 // We need to toggle the run lock as this won't get done in
1046 // SetPublicState() if the process is hijacked.
Jim Ingham583bbb12016-03-07 21:50:25 +00001047 if (hijack_listener_sp && use_run_lock)
Greg Clayton44d93782014-01-27 23:43:24 +00001048 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +00001049 return state;
1050 case eStateStopped:
1051 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
1052 continue;
1053 else
Greg Clayton44d93782014-01-27 23:43:24 +00001054 {
1055 // We need to toggle the run lock as this won't get done in
1056 // SetPublicState() if the process is hijacked.
Jim Ingham583bbb12016-03-07 21:50:25 +00001057 if (hijack_listener_sp && use_run_lock)
Greg Clayton44d93782014-01-27 23:43:24 +00001058 m_public_run_lock.SetStopped();
Jim Ingham4b536182011-08-09 02:12:22 +00001059 return state;
Greg Clayton44d93782014-01-27 23:43:24 +00001060 }
Jim Ingham4b536182011-08-09 02:12:22 +00001061 default:
1062 continue;
1063 }
1064 }
1065 return state;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001066}
1067
Greg Claytondc6224e2014-10-21 01:00:42 +00001068bool
1069Process::HandleProcessStateChangedEvent (const EventSP &event_sp,
1070 Stream *stream,
1071 bool &pop_process_io_handler)
1072{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001073 const bool handle_pop = pop_process_io_handler;
Greg Claytondc6224e2014-10-21 01:00:42 +00001074
1075 pop_process_io_handler = false;
1076 ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
1077
1078 if (!process_sp)
1079 return false;
1080
1081 StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
1082 if (event_state == eStateInvalid)
1083 return false;
1084
1085 switch (event_state)
1086 {
1087 case eStateInvalid:
1088 case eStateUnloaded:
Greg Claytondc6224e2014-10-21 01:00:42 +00001089 case eStateAttaching:
1090 case eStateLaunching:
1091 case eStateStepping:
1092 case eStateDetached:
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001093 if (stream)
1094 stream->Printf("Process %" PRIu64 " %s\n",
1095 process_sp->GetID(),
1096 StateAsCString (event_state));
1097 if (event_state == eStateDetached)
1098 pop_process_io_handler = true;
Greg Claytondc6224e2014-10-21 01:00:42 +00001099 break;
1100
Stephane Sezerf2ef94e2014-12-13 05:23:51 +00001101 case eStateConnected:
Greg Claytondc6224e2014-10-21 01:00:42 +00001102 case eStateRunning:
1103 // Don't be chatty when we run...
1104 break;
1105
1106 case eStateExited:
1107 if (stream)
1108 process_sp->GetStatus(*stream);
1109 pop_process_io_handler = true;
1110 break;
1111
1112 case eStateStopped:
1113 case eStateCrashed:
1114 case eStateSuspended:
1115 // Make sure the program hasn't been auto-restarted:
1116 if (Process::ProcessEventData::GetRestartedFromEvent (event_sp.get()))
1117 {
1118 if (stream)
1119 {
1120 size_t num_reasons = Process::ProcessEventData::GetNumRestartedReasons(event_sp.get());
1121 if (num_reasons > 0)
1122 {
1123 // FIXME: Do we want to report this, or would that just be annoyingly chatty?
1124 if (num_reasons == 1)
1125 {
1126 const char *reason = Process::ProcessEventData::GetRestartedReasonAtIndex (event_sp.get(), 0);
1127 stream->Printf ("Process %" PRIu64 " stopped and restarted: %s\n",
1128 process_sp->GetID(),
1129 reason ? reason : "<UNKNOWN REASON>");
1130 }
1131 else
1132 {
1133 stream->Printf ("Process %" PRIu64 " stopped and restarted, reasons:\n",
1134 process_sp->GetID());
1135
1136
1137 for (size_t i = 0; i < num_reasons; i++)
1138 {
1139 const char *reason = Process::ProcessEventData::GetRestartedReasonAtIndex (event_sp.get(), i);
1140 stream->Printf("\t%s\n", reason ? reason : "<UNKNOWN REASON>");
1141 }
1142 }
1143 }
1144 }
1145 }
1146 else
1147 {
1148 // Lock the thread list so it doesn't change on us, this is the scope for the locker:
1149 {
1150 ThreadList &thread_list = process_sp->GetThreadList();
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001151 std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex());
Greg Claytondc6224e2014-10-21 01:00:42 +00001152
1153 ThreadSP curr_thread (thread_list.GetSelectedThread());
1154 ThreadSP thread;
1155 StopReason curr_thread_stop_reason = eStopReasonInvalid;
1156 if (curr_thread)
1157 curr_thread_stop_reason = curr_thread->GetStopReason();
1158 if (!curr_thread ||
1159 !curr_thread->IsValid() ||
1160 curr_thread_stop_reason == eStopReasonInvalid ||
1161 curr_thread_stop_reason == eStopReasonNone)
1162 {
1163 // Prefer a thread that has just completed its plan over another thread as current thread.
1164 ThreadSP plan_thread;
1165 ThreadSP other_thread;
Jim Inghamce400d92015-07-08 00:06:30 +00001166
Greg Claytondc6224e2014-10-21 01:00:42 +00001167 const size_t num_threads = thread_list.GetSize();
1168 size_t i;
1169 for (i = 0; i < num_threads; ++i)
1170 {
1171 thread = thread_list.GetThreadAtIndex(i);
1172 StopReason thread_stop_reason = thread->GetStopReason();
1173 switch (thread_stop_reason)
1174 {
1175 case eStopReasonInvalid:
1176 case eStopReasonNone:
1177 break;
1178
Jim Inghamce400d92015-07-08 00:06:30 +00001179 case eStopReasonSignal:
1180 {
1181 // Don't select a signal thread if we weren't going to stop at that
1182 // signal. We have to have had another reason for stopping here, and
1183 // the user doesn't want to see this thread.
1184 uint64_t signo = thread->GetStopInfo()->GetValue();
Chaoren Lin98d0a4b2015-07-14 01:09:28 +00001185 if (process_sp->GetUnixSignals()->GetShouldStop(signo))
Jim Inghamce400d92015-07-08 00:06:30 +00001186 {
1187 if (!other_thread)
1188 other_thread = thread;
1189 }
1190 break;
1191 }
Greg Claytondc6224e2014-10-21 01:00:42 +00001192 case eStopReasonTrace:
1193 case eStopReasonBreakpoint:
1194 case eStopReasonWatchpoint:
Greg Claytondc6224e2014-10-21 01:00:42 +00001195 case eStopReasonException:
1196 case eStopReasonExec:
1197 case eStopReasonThreadExiting:
1198 case eStopReasonInstrumentation:
1199 if (!other_thread)
1200 other_thread = thread;
1201 break;
1202 case eStopReasonPlanComplete:
1203 if (!plan_thread)
1204 plan_thread = thread;
1205 break;
1206 }
1207 }
1208 if (plan_thread)
1209 thread_list.SetSelectedThreadByID (plan_thread->GetID());
1210 else if (other_thread)
1211 thread_list.SetSelectedThreadByID (other_thread->GetID());
1212 else
1213 {
1214 if (curr_thread && curr_thread->IsValid())
1215 thread = curr_thread;
1216 else
1217 thread = thread_list.GetThreadAtIndex(0);
1218
1219 if (thread)
1220 thread_list.SetSelectedThreadByID (thread->GetID());
1221 }
1222 }
1223 }
1224 // Drop the ThreadList mutex by here, since GetThreadStatus below might have to run code,
1225 // e.g. for Data formatters, and if we hold the ThreadList mutex, then the process is going to
1226 // have a hard time restarting the process.
1227 if (stream)
1228 {
1229 Debugger &debugger = process_sp->GetTarget().GetDebugger();
1230 if (debugger.GetTargetList().GetSelectedTarget().get() == &process_sp->GetTarget())
1231 {
1232 const bool only_threads_with_stop_reason = true;
1233 const uint32_t start_frame = 0;
1234 const uint32_t num_frames = 1;
1235 const uint32_t num_frames_with_source = 1;
1236 process_sp->GetStatus(*stream);
1237 process_sp->GetThreadStatus (*stream,
1238 only_threads_with_stop_reason,
1239 start_frame,
1240 num_frames,
1241 num_frames_with_source);
1242 }
1243 else
1244 {
1245 uint32_t target_idx = debugger.GetTargetList().GetIndexOfTarget(process_sp->GetTarget().shared_from_this());
1246 if (target_idx != UINT32_MAX)
1247 stream->Printf ("Target %d: (", target_idx);
1248 else
1249 stream->Printf ("Target <unknown index>: (");
1250 process_sp->GetTarget().Dump (stream, eDescriptionLevelBrief);
1251 stream->Printf (") stopped.\n");
1252 }
1253 }
1254
1255 // Pop the process IO handler
1256 pop_process_io_handler = true;
1257 }
1258 break;
1259 }
1260
1261 if (handle_pop && pop_process_io_handler)
1262 process_sp->PopProcessIOHandler();
1263
1264 return true;
1265}
1266
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001267StateType
Eugene Zelenko8f30a652015-10-23 18:39:37 +00001268Process::WaitForState(const TimeValue *timeout,
1269 const StateType *match_states,
1270 const uint32_t num_match_states)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001271{
1272 EventSP event_sp;
Greg Clayton05faeb72010-10-07 04:19:01 +00001273 StateType state = GetState();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001274 while (state != eStateInvalid)
1275 {
Greg Clayton05faeb72010-10-07 04:19:01 +00001276 // If we are exited or detached, we won't ever get back to any
1277 // other valid state...
1278 if (state == eStateDetached || state == eStateExited)
1279 return state;
1280
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001281 state = WaitForStateChangedEvents(timeout, event_sp, nullptr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001282
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001283 for (uint32_t i = 0; i < num_match_states; ++i)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001284 {
1285 if (match_states[i] == state)
1286 return state;
1287 }
1288 }
1289 return state;
1290}
1291
Jim Ingham30f9b212010-10-11 23:53:14 +00001292bool
Jim Ingham583bbb12016-03-07 21:50:25 +00001293Process::HijackProcessEvents (ListenerSP listener_sp)
Jim Ingham30f9b212010-10-11 23:53:14 +00001294{
Jim Ingham583bbb12016-03-07 21:50:25 +00001295 if (listener_sp)
Jim Ingham30f9b212010-10-11 23:53:14 +00001296 {
Jim Ingham583bbb12016-03-07 21:50:25 +00001297 return HijackBroadcaster(listener_sp, eBroadcastBitStateChanged | eBroadcastBitInterrupt);
Jim Ingham30f9b212010-10-11 23:53:14 +00001298 }
1299 else
1300 return false;
1301}
1302
1303void
1304Process::RestoreProcessEvents ()
1305{
1306 RestoreBroadcaster();
1307}
1308
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001309StateType
Jim Ingham583bbb12016-03-07 21:50:25 +00001310Process::WaitForStateChangedEvents (const TimeValue *timeout, EventSP &event_sp, ListenerSP hijack_listener_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001311{
Greg Clayton5160ce52013-03-27 23:08:40 +00001312 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001313
1314 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001315 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1316 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001317
Jim Ingham583bbb12016-03-07 21:50:25 +00001318 ListenerSP listener_sp = hijack_listener_sp;
1319 if (!listener_sp)
1320 listener_sp = m_listener_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001321
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001322 StateType state = eStateInvalid;
Jim Ingham583bbb12016-03-07 21:50:25 +00001323 if (listener_sp->WaitForEventForBroadcasterWithType (timeout,
1324 this,
1325 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
1326 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001327 {
1328 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1329 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
1330 else if (log)
1331 log->Printf ("Process::%s got no event or was interrupted.", __FUNCTION__);
1332 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001333
1334 if (log)
1335 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001336 __FUNCTION__, static_cast<const void*>(timeout),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001337 StateAsCString(state));
1338 return state;
1339}
1340
1341Event *
1342Process::PeekAtStateChangedEvents ()
1343{
Greg Clayton5160ce52013-03-27 23:08:40 +00001344 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001345
1346 if (log)
1347 log->Printf ("Process::%s...", __FUNCTION__);
1348
1349 Event *event_ptr;
Jim Ingham583bbb12016-03-07 21:50:25 +00001350 event_ptr = m_listener_sp->PeekAtNextEventForBroadcasterWithType (this,
Greg Clayton3fcbed62010-10-19 03:25:40 +00001351 eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001352 if (log)
1353 {
1354 if (event_ptr)
1355 {
1356 log->Printf ("Process::%s (event_ptr) => %s",
1357 __FUNCTION__,
1358 StateAsCString(ProcessEventData::GetStateFromEvent (event_ptr)));
1359 }
1360 else
1361 {
1362 log->Printf ("Process::%s no events found",
1363 __FUNCTION__);
1364 }
1365 }
1366 return event_ptr;
1367}
1368
1369StateType
1370Process::WaitForStateChangedEventsPrivate (const TimeValue *timeout, EventSP &event_sp)
1371{
Greg Clayton5160ce52013-03-27 23:08:40 +00001372 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001373
1374 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001375 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1376 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001377
1378 StateType state = eStateInvalid;
Jim Ingham583bbb12016-03-07 21:50:25 +00001379 if (m_private_state_listener_sp->WaitForEventForBroadcasterWithType (timeout,
Greg Clayton6779606a2011-01-22 23:43:18 +00001380 &m_private_state_broadcaster,
Jim Inghamcfc09352012-07-27 23:57:19 +00001381 eBroadcastBitStateChanged | eBroadcastBitInterrupt,
Greg Clayton6779606a2011-01-22 23:43:18 +00001382 event_sp))
Jim Inghamcfc09352012-07-27 23:57:19 +00001383 if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
1384 state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001385
1386 // This is a bit of a hack, but when we wait here we could very well return
1387 // to the command-line, and that could disable the log, which would render the
1388 // log we got above invalid.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001389 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001390 log->Printf ("Process::%s (timeout = %p, event_sp) => %s",
1391 __FUNCTION__, static_cast<const void *>(timeout),
1392 state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001393 return state;
1394}
1395
1396bool
1397Process::WaitForEventsPrivate (const TimeValue *timeout, EventSP &event_sp, bool control_only)
1398{
Greg Clayton5160ce52013-03-27 23:08:40 +00001399 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001400
1401 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00001402 log->Printf ("Process::%s (timeout = %p, event_sp)...", __FUNCTION__,
1403 static_cast<const void*>(timeout));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001404
1405 if (control_only)
Jim Ingham583bbb12016-03-07 21:50:25 +00001406 return m_private_state_listener_sp->WaitForEventForBroadcaster(timeout, &m_private_state_control_broadcaster, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001407 else
Jim Ingham583bbb12016-03-07 21:50:25 +00001408 return m_private_state_listener_sp->WaitForEvent(timeout, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001409}
1410
1411bool
1412Process::IsRunning () const
1413{
1414 return StateIsRunningState (m_public_state.GetValue());
1415}
1416
1417int
1418Process::GetExitStatus ()
1419{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001420 std::lock_guard<std::mutex> guard(m_exit_status_mutex);
Todd Fiala7b0917a2014-09-15 20:07:33 +00001421
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001422 if (m_public_state.GetValue() == eStateExited)
1423 return m_exit_status;
1424 return -1;
1425}
1426
1427const char *
1428Process::GetExitDescription ()
1429{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001430 std::lock_guard<std::mutex> guard(m_exit_status_mutex);
Todd Fiala7b0917a2014-09-15 20:07:33 +00001431
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001432 if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
1433 return m_exit_string.c_str();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001434 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001435}
1436
Greg Clayton6779606a2011-01-22 23:43:18 +00001437bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001438Process::SetExitStatus (int status, const char *cstr)
1439{
Greg Clayton81e2b6b2015-06-01 23:14:09 +00001440 // Use a mutex to protect setting the exit status.
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001441 std::lock_guard<std::mutex> guard(m_exit_status_mutex);
Greg Clayton81e2b6b2015-06-01 23:14:09 +00001442
Greg Clayton5160ce52013-03-27 23:08:40 +00001443 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Greg Clayton414f5d32011-01-25 02:58:48 +00001444 if (log)
1445 log->Printf("Process::SetExitStatus (status=%i (0x%8.8x), description=%s%s%s)",
1446 status, status,
1447 cstr ? "\"" : "",
1448 cstr ? cstr : "NULL",
1449 cstr ? "\"" : "");
1450
Greg Clayton6779606a2011-01-22 23:43:18 +00001451 // We were already in the exited state
1452 if (m_private_state.GetValue() == eStateExited)
Greg Clayton414f5d32011-01-25 02:58:48 +00001453 {
Greg Clayton385d6032011-01-26 23:47:29 +00001454 if (log)
1455 log->Printf("Process::SetExitStatus () ignoring exit status because state was already set to eStateExited");
Greg Clayton6779606a2011-01-22 23:43:18 +00001456 return false;
Greg Clayton414f5d32011-01-25 02:58:48 +00001457 }
Todd Fiala7b0917a2014-09-15 20:07:33 +00001458
Greg Clayton81e2b6b2015-06-01 23:14:09 +00001459 m_exit_status = status;
1460 if (cstr)
1461 m_exit_string = cstr;
1462 else
1463 m_exit_string.clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001464
Pavel Labatha9a43372015-09-03 09:30:17 +00001465 // When we exit, we don't need the input reader anymore
Greg Clayton5df78fa2015-05-23 03:54:53 +00001466 if (m_process_input_reader)
1467 {
1468 m_process_input_reader->SetIsDone(true);
1469 m_process_input_reader->Cancel();
1470 m_process_input_reader.reset();
1471 }
Greg Clayton10177aa2010-12-08 05:08:21 +00001472
Greg Clayton08765fa2015-05-28 03:24:30 +00001473 // Clear the last natural stop ID since it has a strong
1474 // reference to this process
1475 m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
1476
Greg Clayton6779606a2011-01-22 23:43:18 +00001477 SetPrivateState (eStateExited);
Greg Clayton5df78fa2015-05-23 03:54:53 +00001478
1479 // Allow subclasses to do some cleanup
1480 DidExit ();
1481
Greg Clayton6779606a2011-01-22 23:43:18 +00001482 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001483}
1484
Jason Molendaa814f702015-11-05 23:03:44 +00001485bool
1486Process::IsAlive ()
1487{
1488 switch (m_private_state.GetValue())
1489 {
Jason Molendaa814f702015-11-05 23:03:44 +00001490 case eStateConnected:
1491 case eStateAttaching:
1492 case eStateLaunching:
1493 case eStateStopped:
1494 case eStateRunning:
1495 case eStateStepping:
1496 case eStateCrashed:
1497 case eStateSuspended:
1498 return true;
Davide Italiano13fe2a92016-01-19 22:47:51 +00001499 default:
1500 return false;
Jason Molendaa814f702015-11-05 23:03:44 +00001501 }
1502}
1503
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001504// This static callback can be used to watch for local child processes on
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00001505// the current host. The child process exits, the process will be
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001506// found in the global target list (we want to be completely sure that the
1507// lldb_private::Process doesn't go away before we can deliver the signal.
1508bool
Pavel Labath998bdc52016-05-11 16:59:04 +00001509Process::SetProcessExitStatus(lldb::pid_t pid, bool exited,
1510 int signo, // Zero for no signal
1511 int exit_status // Exit value of process if signal is zero
1512 )
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001513{
Greg Clayton5160ce52013-03-27 23:08:40 +00001514 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytone4e45922011-11-16 05:37:56 +00001515 if (log)
Pavel Labath998bdc52016-05-11 16:59:04 +00001516 log->Printf("Process::SetProcessExitStatus (pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n", pid,
1517 exited, signo, exit_status);
Greg Claytone4e45922011-11-16 05:37:56 +00001518
1519 if (exited)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001520 {
Greg Clayton66111032010-06-23 01:19:29 +00001521 TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001522 if (target_sp)
1523 {
1524 ProcessSP process_sp (target_sp->GetProcessSP());
1525 if (process_sp)
1526 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001527 const char *signal_cstr = nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001528 if (signo)
Chaoren Lin98d0a4b2015-07-14 01:09:28 +00001529 signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001530
1531 process_sp->SetExitStatus (exit_status, signal_cstr);
1532 }
1533 }
1534 return true;
1535 }
1536 return false;
1537}
1538
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001539void
1540Process::UpdateThreadListIfNeeded ()
1541{
1542 const uint32_t stop_id = GetStopID();
1543 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID())
1544 {
Greg Clayton2637f822011-11-17 01:23:07 +00001545 const StateType state = GetPrivateState();
1546 if (StateIsStoppedState (state, true))
1547 {
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001548 std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
Greg Claytone24c4ac2011-11-17 04:46:02 +00001549 // m_thread_list does have its own mutex, but we need to
1550 // hold onto the mutex between the call to UpdateThreadList(...)
1551 // and the os->UpdateThreadList(...) so it doesn't change on us
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001552 ThreadList &old_thread_list = m_thread_list;
1553 ThreadList real_thread_list(this);
Greg Clayton2637f822011-11-17 01:23:07 +00001554 ThreadList new_thread_list(this);
1555 // Always update the thread list with the protocol specific
Greg Clayton9fc13552012-04-10 00:18:59 +00001556 // thread list, but only update if "true" is returned
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001557 if (UpdateThreadList (m_thread_list_real, real_thread_list))
Greg Clayton9fc13552012-04-10 00:18:59 +00001558 {
Jim Ingham09437922013-03-01 20:04:25 +00001559 // Don't call into the OperatingSystem to update the thread list if we are shutting down, since
1560 // that may call back into the SBAPI's, requiring the API lock which is already held by whoever is
1561 // shutting us down, causing a deadlock.
Pavel Labath862432c2015-11-03 16:05:18 +00001562 OperatingSystem *os = GetOperatingSystem ();
1563 if (os && !m_destroy_in_process)
Jim Ingham09437922013-03-01 20:04:25 +00001564 {
Pavel Labath862432c2015-11-03 16:05:18 +00001565 // Clear any old backing threads where memory threads might have been
1566 // backed by actual threads from the lldb_private::Process subclass
1567 size_t num_old_threads = old_thread_list.GetSize(false);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001568 for (size_t i = 0; i < num_old_threads; ++i)
Pavel Labath862432c2015-11-03 16:05:18 +00001569 old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();
Greg Claytonb3ae8762013-04-12 20:07:46 +00001570
Pavel Labath862432c2015-11-03 16:05:18 +00001571 // Turn off dynamic types to ensure we don't run any expressions. Objective C
1572 // can run an expression to determine if a SBValue is a dynamic type or not
1573 // and we need to avoid this. OperatingSystem plug-ins can't run expressions
1574 // that require running code...
Greg Clayton15484402015-05-15 18:40:24 +00001575
Pavel Labath862432c2015-11-03 16:05:18 +00001576 Target &target = GetTarget();
1577 const lldb::DynamicValueType saved_prefer_dynamic = target.GetPreferDynamicValue ();
1578 if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1579 target.SetPreferDynamicValue(lldb::eNoDynamicValues);
Greg Clayton15484402015-05-15 18:40:24 +00001580
Pavel Labath862432c2015-11-03 16:05:18 +00001581 // Now let the OperatingSystem plug-in update the thread list
Greg Clayton15484402015-05-15 18:40:24 +00001582
Pavel Labath862432c2015-11-03 16:05:18 +00001583 os->UpdateThreadList (old_thread_list, // Old list full of threads created by OS plug-in
1584 real_thread_list, // The actual thread list full of threads created by each lldb_private::Process subclass
1585 new_thread_list); // The new thread list that we will show to the user that gets filled in
Greg Clayton15484402015-05-15 18:40:24 +00001586
Pavel Labath862432c2015-11-03 16:05:18 +00001587 if (saved_prefer_dynamic != lldb::eNoDynamicValues)
1588 target.SetPreferDynamicValue(saved_prefer_dynamic);
1589 }
1590 else
1591 {
1592 // No OS plug-in, the new thread list is the same as the real thread list
1593 new_thread_list = real_thread_list;
Jim Ingham09437922013-03-01 20:04:25 +00001594 }
Jim Ingham02ff8e02013-06-22 00:55:02 +00001595
1596 m_thread_list_real.Update(real_thread_list);
Andrew Kaylorba4e61d2013-05-07 18:35:34 +00001597 m_thread_list.Update (new_thread_list);
1598 m_thread_list.SetStopID (stop_id);
Jason Molendaa6e91302013-11-19 05:44:41 +00001599
Jason Molenda4ff13262013-11-20 00:31:38 +00001600 if (GetLastNaturalStopID () != m_extended_thread_stop_id)
1601 {
1602 // Clear any extended threads that we may have accumulated previously
1603 m_extended_thread_list.Clear();
1604 m_extended_thread_stop_id = GetLastNaturalStopID ();
Jason Molenda5e8dce42013-12-13 00:29:16 +00001605
1606 m_queue_list.Clear();
1607 m_queue_list_stop_id = GetLastNaturalStopID ();
Jason Molenda4ff13262013-11-20 00:31:38 +00001608 }
Greg Clayton9fc13552012-04-10 00:18:59 +00001609 }
Greg Clayton2637f822011-11-17 01:23:07 +00001610 }
Greg Clayton56d9a1b2011-08-22 02:49:39 +00001611 }
1612}
1613
Jason Molenda5e8dce42013-12-13 00:29:16 +00001614void
1615Process::UpdateQueueListIfNeeded ()
1616{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001617 if (m_system_runtime_ap)
Jason Molenda5e8dce42013-12-13 00:29:16 +00001618 {
1619 if (m_queue_list.GetSize() == 0 || m_queue_list_stop_id != GetLastNaturalStopID())
1620 {
1621 const StateType state = GetPrivateState();
1622 if (StateIsStoppedState (state, true))
1623 {
1624 m_system_runtime_ap->PopulateQueueList (m_queue_list);
1625 m_queue_list_stop_id = GetLastNaturalStopID();
1626 }
1627 }
1628 }
1629}
1630
Greg Claytona4d87472013-01-18 23:41:08 +00001631ThreadSP
1632Process::CreateOSPluginThread (lldb::tid_t tid, lldb::addr_t context)
1633{
1634 OperatingSystem *os = GetOperatingSystem ();
1635 if (os)
1636 return os->CreateThread(tid, context);
1637 return ThreadSP();
1638}
1639
Han Ming Ongc2c423e2013-01-08 22:10:01 +00001640uint32_t
1641Process::GetNextThreadIndexID (uint64_t thread_id)
1642{
1643 return AssignIndexIDToThread(thread_id);
1644}
1645
1646bool
1647Process::HasAssignedIndexIDToThread(uint64_t thread_id)
1648{
Eugene Zelenko8f30a652015-10-23 18:39:37 +00001649 return (m_thread_id_to_index_id_map.find(thread_id) != m_thread_id_to_index_id_map.end());
Han Ming Ongc2c423e2013-01-08 22:10:01 +00001650}
1651
1652uint32_t
1653Process::AssignIndexIDToThread(uint64_t thread_id)
1654{
1655 uint32_t result = 0;
1656 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
1657 if (iterator == m_thread_id_to_index_id_map.end())
1658 {
1659 result = ++m_thread_index_id;
1660 m_thread_id_to_index_id_map[thread_id] = result;
1661 }
1662 else
1663 {
1664 result = iterator->second;
1665 }
1666
1667 return result;
1668}
1669
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001670StateType
1671Process::GetState()
1672{
1673 // If any other threads access this we will need a mutex for it
1674 return m_public_state.GetValue ();
1675}
1676
Greg Claytondc6224e2014-10-21 01:00:42 +00001677bool
1678Process::StateChangedIsExternallyHijacked()
1679{
1680 if (IsHijackedForEvent(eBroadcastBitStateChanged))
1681 {
Jim Ingham583bbb12016-03-07 21:50:25 +00001682 const char *hijacking_name = GetHijackingListenerName();
1683 if (hijacking_name && strcmp(hijacking_name, "lldb.Process.ResumeSynchronous.hijack"))
Greg Claytondc6224e2014-10-21 01:00:42 +00001684 return true;
1685 }
1686 return false;
1687}
1688
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001689void
Jim Ingham221d51c2013-05-08 00:35:16 +00001690Process::SetPublicState (StateType new_state, bool restarted)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001691{
Greg Clayton5160ce52013-03-27 23:08:40 +00001692 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001693 if (log)
Jim Ingham221d51c2013-05-08 00:35:16 +00001694 log->Printf("Process::SetPublicState (state = %s, restarted = %i)", StateAsCString(new_state), restarted);
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001695 const StateType old_state = m_public_state.GetValue();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001696 m_public_state.SetValue (new_state);
Jim Ingham3b8285d2012-04-19 01:40:33 +00001697
1698 // On the transition from Run to Stopped, we unlock the writer end of the
1699 // run lock. The lock gets locked in Resume, which is the public API
1700 // to tell the program to run.
Greg Claytondc6224e2014-10-21 01:00:42 +00001701 if (!StateChangedIsExternallyHijacked())
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001702 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001703 if (new_state == eStateDetached)
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001704 {
Sean Callanan8b0737f2012-06-02 01:16:20 +00001705 if (log)
1706 log->Printf("Process::SetPublicState (%s) -- unlocking run lock for detach", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001707 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001708 }
1709 else
1710 {
1711 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1712 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
Jim Ingham221d51c2013-05-08 00:35:16 +00001713 if ((old_state_is_stopped != new_state_is_stopped))
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001714 {
Jim Ingham221d51c2013-05-08 00:35:16 +00001715 if (new_state_is_stopped && !restarted)
Sean Callanan8b0737f2012-06-02 01:16:20 +00001716 {
1717 if (log)
1718 log->Printf("Process::SetPublicState (%s) -- unlocking run lock", StateAsCString(new_state));
Ed Maste64fad602013-07-29 20:58:06 +00001719 m_public_run_lock.SetStopped();
Sean Callanan8b0737f2012-06-02 01:16:20 +00001720 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001721 }
Greg Clayton7fdf9ef2012-04-05 16:12:35 +00001722 }
1723 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001724}
1725
Jim Ingham3b8285d2012-04-19 01:40:33 +00001726Error
1727Process::Resume ()
1728{
Greg Clayton5160ce52013-03-27 23:08:40 +00001729 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Jim Ingham3b8285d2012-04-19 01:40:33 +00001730 if (log)
1731 log->Printf("Process::Resume -- locking run lock");
Ed Maste64fad602013-07-29 20:58:06 +00001732 if (!m_public_run_lock.TrySetRunning())
Jim Ingham3b8285d2012-04-19 01:40:33 +00001733 {
1734 Error error("Resume request failed - process still running.");
1735 if (log)
Ed Maste64fad602013-07-29 20:58:06 +00001736 log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
Jim Ingham3b8285d2012-04-19 01:40:33 +00001737 return error;
1738 }
1739 return PrivateResume();
1740}
1741
Greg Claytondc6224e2014-10-21 01:00:42 +00001742Error
1743Process::ResumeSynchronous (Stream *stream)
1744{
1745 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
1746 if (log)
1747 log->Printf("Process::ResumeSynchronous -- locking run lock");
1748 if (!m_public_run_lock.TrySetRunning())
1749 {
1750 Error error("Resume request failed - process still running.");
1751 if (log)
1752 log->Printf ("Process::Resume: -- TrySetRunning failed, not resuming.");
1753 return error;
1754 }
1755
Jim Ingham583bbb12016-03-07 21:50:25 +00001756 ListenerSP listener_sp (Listener::MakeListener("lldb.Process.ResumeSynchronous.hijack"));
1757 HijackProcessEvents(listener_sp);
Greg Claytondc6224e2014-10-21 01:00:42 +00001758
1759 Error error = PrivateResume();
Ilia Kd8c14752015-04-30 13:10:32 +00001760 if (error.Success())
1761 {
Jim Ingham583bbb12016-03-07 21:50:25 +00001762 StateType state = WaitForProcessToStop (NULL, NULL, true, listener_sp, stream);
Ilia Kd8c14752015-04-30 13:10:32 +00001763 const bool must_be_alive = false; // eStateExited is ok, so this must be false
1764 if (!StateIsStoppedState(state, must_be_alive))
1765 error.SetErrorStringWithFormat("process not in stopped state after synchronous resume: %s", StateAsCString(state));
1766 }
Greg Claytondc6224e2014-10-21 01:00:42 +00001767
1768 // Undo the hijacking of process events...
1769 RestoreProcessEvents();
1770
Greg Claytondc6224e2014-10-21 01:00:42 +00001771 return error;
1772}
1773
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001774StateType
1775Process::GetPrivateState ()
1776{
1777 return m_private_state.GetValue();
1778}
1779
1780void
1781Process::SetPrivateState (StateType new_state)
1782{
Greg Claytonfb8b37a2014-07-14 23:09:29 +00001783 if (m_finalize_called)
1784 return;
1785
Greg Clayton5160ce52013-03-27 23:08:40 +00001786 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001787 bool state_changed = false;
1788
1789 if (log)
1790 log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
1791
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00001792 std::lock_guard<std::recursive_mutex> thread_guard(m_thread_list.GetMutex());
Saleem Abdulrasool16ff8602016-05-18 01:59:10 +00001793 std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001794
1795 const StateType old_state = m_private_state.GetValueNoLock ();
1796 state_changed = old_state != new_state;
Ed Mastec29693f2013-07-02 16:35:47 +00001797
Greg Claytonaa49c832013-05-03 22:25:56 +00001798 const bool old_state_is_stopped = StateIsStoppedState(old_state, false);
1799 const bool new_state_is_stopped = StateIsStoppedState(new_state, false);
1800 if (old_state_is_stopped != new_state_is_stopped)
1801 {
1802 if (new_state_is_stopped)
Ed Maste64fad602013-07-29 20:58:06 +00001803 m_private_run_lock.SetStopped();
Greg Claytonaa49c832013-05-03 22:25:56 +00001804 else
Ed Maste64fad602013-07-29 20:58:06 +00001805 m_private_run_lock.SetRunning();
Greg Claytonaa49c832013-05-03 22:25:56 +00001806 }
Andrew Kaylor93132f52013-05-28 23:04:25 +00001807
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001808 if (state_changed)
1809 {
1810 m_private_state.SetValueNoLock (new_state);
Ilia K38810f42015-05-20 10:15:47 +00001811 EventSP event_sp (new Event (eBroadcastBitStateChanged, new ProcessEventData (shared_from_this(), new_state)));
Greg Clayton2637f822011-11-17 01:23:07 +00001812 if (StateIsStoppedState(new_state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001813 {
Andrew Kaylor29d65742013-05-10 17:19:04 +00001814 // Note, this currently assumes that all threads in the list
1815 // stop when the process stops. In the future we will want to
1816 // support a debugging model where some threads continue to run
1817 // while others are stopped. When that happens we will either need
1818 // a way for the thread list to identify which threads are stopping
1819 // or create a special thread list containing only threads which
1820 // actually stopped.
1821 //
1822 // The process plugin is responsible for managing the actual
1823 // behavior of the threads and should have stopped any threads
1824 // that are going to stop before we get here.
1825 m_thread_list.DidStop();
1826
Jim Ingham4b536182011-08-09 02:12:22 +00001827 m_mod_id.BumpStopID();
Ilia K38810f42015-05-20 10:15:47 +00001828 if (!m_mod_id.IsLastResumeForUserExpression())
1829 m_mod_id.SetStopEventForLastNaturalStopID(event_sp);
Greg Clayton58be07b2011-01-07 06:08:19 +00001830 m_memory_cache.Clear();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001831 if (log)
Jim Ingham4b536182011-08-09 02:12:22 +00001832 log->Printf("Process::SetPrivateState (%s) stop_id = %u", StateAsCString(new_state), m_mod_id.GetStopID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001833 }
Ilia K38810f42015-05-20 10:15:47 +00001834
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001835 // Use our target to get a shared pointer to ourselves...
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001836 if (m_finalize_called && !PrivateStateThreadIsValid())
Ilia K38810f42015-05-20 10:15:47 +00001837 BroadcastEvent (event_sp);
Greg Clayton35a4cc52012-10-29 20:52:08 +00001838 else
Ilia K38810f42015-05-20 10:15:47 +00001839 m_private_state_broadcaster.BroadcastEvent (event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001840 }
1841 else
1842 {
1843 if (log)
Jason Molendafd54b362011-09-20 21:44:10 +00001844 log->Printf("Process::SetPrivateState (%s) state didn't change. Ignoring...", StateAsCString(new_state));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001845 }
1846}
1847
Jim Ingham0faa43f2011-11-08 03:00:11 +00001848void
1849Process::SetRunningUserExpression (bool on)
1850{
1851 m_mod_id.SetRunningUserExpression (on);
1852}
1853
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001854addr_t
1855Process::GetImageInfoAddress()
1856{
1857 return LLDB_INVALID_ADDRESS;
1858}
1859
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001860const lldb::ABISP &
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001861Process::GetABI()
1862{
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001863 if (!m_abi_sp)
Zachary Turner7529df92015-09-01 20:02:29 +00001864 m_abi_sp = ABI::FindPlugin(GetTarget().GetArchitecture());
Greg Clayton31f1d2f2011-05-11 18:39:18 +00001865 return m_abi_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001866}
1867
Jim Ingham22777012010-09-23 02:01:19 +00001868LanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001869Process::GetLanguageRuntime(lldb::LanguageType language, bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001870{
Greg Claytonc00ca312015-04-02 18:44:58 +00001871 if (m_finalizing)
1872 return nullptr;
1873
Jim Ingham22777012010-09-23 02:01:19 +00001874 LanguageRuntimeCollection::iterator pos;
1875 pos = m_language_runtimes.find (language);
Jim Inghamab175242012-03-10 00:22:19 +00001876 if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second))
Jim Ingham22777012010-09-23 02:01:19 +00001877 {
Jim Inghamab175242012-03-10 00:22:19 +00001878 lldb::LanguageRuntimeSP runtime_sp(LanguageRuntime::FindPlugin(this, language));
Jim Ingham22777012010-09-23 02:01:19 +00001879
Jim Inghamab175242012-03-10 00:22:19 +00001880 m_language_runtimes[language] = runtime_sp;
1881 return runtime_sp.get();
Jim Ingham22777012010-09-23 02:01:19 +00001882 }
1883 else
1884 return (*pos).second.get();
1885}
1886
1887CPPLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001888Process::GetCPPLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001889{
Jim Inghamab175242012-03-10 00:22:19 +00001890 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001891 if (runtime != nullptr && runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
Jim Ingham22777012010-09-23 02:01:19 +00001892 return static_cast<CPPLanguageRuntime *> (runtime);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001893 return nullptr;
Jim Ingham22777012010-09-23 02:01:19 +00001894}
1895
1896ObjCLanguageRuntime *
Jim Inghamab175242012-03-10 00:22:19 +00001897Process::GetObjCLanguageRuntime (bool retry_if_null)
Jim Ingham22777012010-09-23 02:01:19 +00001898{
Jim Inghamab175242012-03-10 00:22:19 +00001899 LanguageRuntime *runtime = GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001900 if (runtime != nullptr && runtime->GetLanguageType() == eLanguageTypeObjC)
Jim Ingham22777012010-09-23 02:01:19 +00001901 return static_cast<ObjCLanguageRuntime *> (runtime);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00001902 return nullptr;
Jim Ingham22777012010-09-23 02:01:19 +00001903}
1904
Enrico Granatafd4c84e2012-05-21 16:51:35 +00001905bool
1906Process::IsPossibleDynamicValue (ValueObject& in_value)
1907{
Greg Claytonc00ca312015-04-02 18:44:58 +00001908 if (m_finalizing)
1909 return false;
1910
Enrico Granatafd4c84e2012-05-21 16:51:35 +00001911 if (in_value.IsDynamic())
1912 return false;
1913 LanguageType known_type = in_value.GetObjectRuntimeLanguage();
1914
1915 if (known_type != eLanguageTypeUnknown && known_type != eLanguageTypeC)
1916 {
1917 LanguageRuntime *runtime = GetLanguageRuntime (known_type);
1918 return runtime ? runtime->CouldHaveDynamicValue(in_value) : false;
1919 }
1920
1921 LanguageRuntime *cpp_runtime = GetLanguageRuntime (eLanguageTypeC_plus_plus);
1922 if (cpp_runtime && cpp_runtime->CouldHaveDynamicValue(in_value))
1923 return true;
1924
1925 LanguageRuntime *objc_runtime = GetLanguageRuntime (eLanguageTypeObjC);
1926 return objc_runtime ? objc_runtime->CouldHaveDynamicValue(in_value) : false;
1927}
1928
Zachary Turner93749ab2015-03-03 21:51:25 +00001929void
1930Process::SetDynamicCheckers(DynamicCheckerFunctions *dynamic_checkers)
1931{
1932 m_dynamic_checkers_ap.reset(dynamic_checkers);
1933}
1934
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001935BreakpointSiteList &
1936Process::GetBreakpointSiteList()
1937{
1938 return m_breakpoint_site_list;
1939}
1940
1941const BreakpointSiteList &
1942Process::GetBreakpointSiteList() const
1943{
1944 return m_breakpoint_site_list;
1945}
1946
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001947void
1948Process::DisableAllBreakpointSites ()
1949{
Greg Claytond8cf1a12013-06-12 00:46:38 +00001950 m_breakpoint_site_list.ForEach([this](BreakpointSite *bp_site) -> void {
1951// bp_site->SetEnabled(true);
1952 DisableBreakpointSite(bp_site);
1953 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001954}
1955
1956Error
1957Process::ClearBreakpointSiteByID (lldb::user_id_t break_id)
1958{
1959 Error error (DisableBreakpointSiteByID (break_id));
1960
1961 if (error.Success())
1962 m_breakpoint_site_list.Remove(break_id);
1963
1964 return error;
1965}
1966
1967Error
1968Process::DisableBreakpointSiteByID (lldb::user_id_t break_id)
1969{
1970 Error error;
1971 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1972 if (bp_site_sp)
1973 {
1974 if (bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001975 error = DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001976 }
1977 else
1978 {
Daniel Malead01b2952012-11-29 21:49:15 +00001979 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001980 }
1981
1982 return error;
1983}
1984
1985Error
1986Process::EnableBreakpointSiteByID (lldb::user_id_t break_id)
1987{
1988 Error error;
1989 BreakpointSiteSP bp_site_sp = m_breakpoint_site_list.FindByID (break_id);
1990 if (bp_site_sp)
1991 {
1992 if (!bp_site_sp->IsEnabled())
Jim Ingham299c0c12013-02-15 02:06:30 +00001993 error = EnableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001994 }
1995 else
1996 {
Daniel Malead01b2952012-11-29 21:49:15 +00001997 error.SetErrorStringWithFormat("invalid breakpoint site ID: %" PRIu64, break_id);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00001998 }
1999 return error;
2000}
2001
Stephen Wilson50bd94f2010-07-17 00:56:13 +00002002lldb::break_id_t
Greg Claytone1cd1be2012-01-29 20:56:30 +00002003Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002004{
Jim Ingham1460e4b2014-01-10 23:46:59 +00002005 addr_t load_addr = LLDB_INVALID_ADDRESS;
2006
2007 bool show_error = true;
2008 switch (GetState())
2009 {
2010 case eStateInvalid:
2011 case eStateUnloaded:
2012 case eStateConnected:
2013 case eStateAttaching:
2014 case eStateLaunching:
2015 case eStateDetached:
2016 case eStateExited:
2017 show_error = false;
2018 break;
2019
2020 case eStateStopped:
2021 case eStateRunning:
2022 case eStateStepping:
2023 case eStateCrashed:
2024 case eStateSuspended:
2025 show_error = IsAlive();
2026 break;
2027 }
2028
2029 // Reset the IsIndirect flag here, in case the location changes from
2030 // pointing to a indirect symbol to a regular symbol.
2031 owner->SetIsIndirect (false);
2032
2033 if (owner->ShouldResolveIndirectFunctions())
2034 {
2035 Symbol *symbol = owner->GetAddress().CalculateSymbolContextSymbol();
2036 if (symbol && symbol->IsIndirect())
2037 {
2038 Error error;
Greg Clayton358cf1e2015-06-25 21:46:34 +00002039 Address symbol_address = symbol->GetAddress();
2040 load_addr = ResolveIndirectFunction (&symbol_address, error);
Jim Ingham1460e4b2014-01-10 23:46:59 +00002041 if (!error.Success() && show_error)
2042 {
Zachary Turner7529df92015-09-01 20:02:29 +00002043 GetTarget().GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2044 symbol->GetLoadAddress(&GetTarget()),
2045 owner->GetBreakpoint().GetID(),
2046 owner->GetID(),
2047 error.AsCString() ? error.AsCString() : "unknown error");
Jim Ingham1460e4b2014-01-10 23:46:59 +00002048 return LLDB_INVALID_BREAK_ID;
2049 }
2050 Address resolved_address(load_addr);
Zachary Turner7529df92015-09-01 20:02:29 +00002051 load_addr = resolved_address.GetOpcodeLoadAddress (&GetTarget());
Jim Ingham1460e4b2014-01-10 23:46:59 +00002052 owner->SetIsIndirect(true);
2053 }
2054 else
Zachary Turner7529df92015-09-01 20:02:29 +00002055 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&GetTarget());
Jim Ingham1460e4b2014-01-10 23:46:59 +00002056 }
2057 else
Zachary Turner7529df92015-09-01 20:02:29 +00002058 load_addr = owner->GetAddress().GetOpcodeLoadAddress (&GetTarget());
Jim Ingham1460e4b2014-01-10 23:46:59 +00002059
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002060 if (load_addr != LLDB_INVALID_ADDRESS)
2061 {
2062 BreakpointSiteSP bp_site_sp;
2063
2064 // Look up this breakpoint site. If it exists, then add this new owner, otherwise
2065 // create a new breakpoint site and add it.
2066
2067 bp_site_sp = m_breakpoint_site_list.FindByAddress (load_addr);
2068
2069 if (bp_site_sp)
2070 {
2071 bp_site_sp->AddOwner (owner);
2072 owner->SetBreakpointSite (bp_site_sp);
2073 return bp_site_sp->GetID();
2074 }
2075 else
2076 {
Greg Claytonc7bece562013-01-25 18:06:21 +00002077 bp_site_sp.reset (new BreakpointSite (&m_breakpoint_site_list, owner, load_addr, use_hardware));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002078 if (bp_site_sp)
2079 {
Greg Claytoneb023e72013-10-11 19:48:25 +00002080 Error error = EnableBreakpointSite (bp_site_sp.get());
2081 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002082 {
2083 owner->SetBreakpointSite (bp_site_sp);
2084 return m_breakpoint_site_list.Add (bp_site_sp);
2085 }
Greg Claytoneb023e72013-10-11 19:48:25 +00002086 else
2087 {
Greg Claytonfbb76342013-11-20 21:07:01 +00002088 if (show_error)
2089 {
2090 // Report error for setting breakpoint...
Zachary Turner7529df92015-09-01 20:02:29 +00002091 GetTarget().GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",
2092 load_addr,
2093 owner->GetBreakpoint().GetID(),
2094 owner->GetID(),
2095 error.AsCString() ? error.AsCString() : "unknown error");
Greg Claytonfbb76342013-11-20 21:07:01 +00002096 }
Greg Claytoneb023e72013-10-11 19:48:25 +00002097 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002098 }
2099 }
2100 }
2101 // We failed to enable the breakpoint
2102 return LLDB_INVALID_BREAK_ID;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002103}
2104
2105void
2106Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_t owner_loc_id, BreakpointSiteSP &bp_site_sp)
2107{
2108 uint32_t num_owners = bp_site_sp->RemoveOwner (owner_id, owner_loc_id);
2109 if (num_owners == 0)
2110 {
Jim Inghamf1ff3bb2013-04-06 00:16:39 +00002111 // Don't try to disable the site if we don't have a live process anymore.
2112 if (IsAlive())
2113 DisableBreakpointSite (bp_site_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002114 m_breakpoint_site_list.RemoveByAddress(bp_site_sp->GetLoadAddress());
2115 }
2116}
2117
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002118size_t
2119Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
2120{
2121 size_t bytes_removed = 0;
Jim Ingham20c77192011-06-29 19:42:28 +00002122 BreakpointSiteList bp_sites_in_range;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002123
Jim Ingham20c77192011-06-29 19:42:28 +00002124 if (m_breakpoint_site_list.FindInRange (bp_addr, bp_addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002125 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002126 bp_sites_in_range.ForEach([bp_addr, size, buf, &bytes_removed](BreakpointSite *bp_site) -> void {
2127 if (bp_site->GetType() == BreakpointSite::eSoftware)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002128 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002129 addr_t intersect_addr;
2130 size_t intersect_size;
2131 size_t opcode_offset;
2132 if (bp_site->IntersectsRange(bp_addr, size, &intersect_addr, &intersect_size, &opcode_offset))
Jim Ingham20c77192011-06-29 19:42:28 +00002133 {
2134 assert(bp_addr <= intersect_addr && intersect_addr < bp_addr + size);
2135 assert(bp_addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= bp_addr + size);
Greg Claytond8cf1a12013-06-12 00:46:38 +00002136 assert(opcode_offset + intersect_size <= bp_site->GetByteSize());
Jim Ingham20c77192011-06-29 19:42:28 +00002137 size_t buf_offset = intersect_addr - bp_addr;
Greg Claytond8cf1a12013-06-12 00:46:38 +00002138 ::memcpy(buf + buf_offset, bp_site->GetSavedOpcodeBytes() + opcode_offset, intersect_size);
Jim Ingham20c77192011-06-29 19:42:28 +00002139 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002140 }
Greg Claytond8cf1a12013-06-12 00:46:38 +00002141 });
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002142 }
2143 return bytes_removed;
2144}
2145
Greg Claytonded470d2011-03-19 01:12:21 +00002146size_t
2147Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
2148{
Zachary Turner7529df92015-09-01 20:02:29 +00002149 PlatformSP platform_sp (GetTarget().GetPlatform());
Greg Claytonded470d2011-03-19 01:12:21 +00002150 if (platform_sp)
Zachary Turner7529df92015-09-01 20:02:29 +00002151 return platform_sp->GetSoftwareBreakpointTrapOpcode (GetTarget(), bp_site);
Greg Claytonded470d2011-03-19 01:12:21 +00002152 return 0;
2153}
2154
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002155Error
2156Process::EnableSoftwareBreakpoint (BreakpointSite *bp_site)
2157{
2158 Error error;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002159 assert(bp_site != nullptr);
Greg Clayton5160ce52013-03-27 23:08:40 +00002160 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002161 const addr_t bp_addr = bp_site->GetLoadAddress();
2162 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002163 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64, bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002164 if (bp_site->IsEnabled())
2165 {
2166 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002167 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already enabled", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002168 return error;
2169 }
2170
2171 if (bp_addr == LLDB_INVALID_ADDRESS)
2172 {
2173 error.SetErrorString("BreakpointSite contains an invalid load address.");
2174 return error;
2175 }
2176 // Ask the lldb::Process subclass to fill in the correct software breakpoint
2177 // trap for the breakpoint site
2178 const size_t bp_opcode_size = GetSoftwareBreakpointTrapOpcode(bp_site);
2179
2180 if (bp_opcode_size == 0)
2181 {
Daniel Malead01b2952012-11-29 21:49:15 +00002182 error.SetErrorStringWithFormat ("Process::GetSoftwareBreakpointTrapOpcode() returned zero, unable to get breakpoint trap for address 0x%" PRIx64, bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002183 }
2184 else
2185 {
2186 const uint8_t * const bp_opcode_bytes = bp_site->GetTrapOpcodeBytes();
2187
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002188 if (bp_opcode_bytes == nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002189 {
2190 error.SetErrorString ("BreakpointSite doesn't contain a valid breakpoint trap opcode.");
2191 return error;
2192 }
2193
2194 // Save the original opcode by reading it
2195 if (DoReadMemory(bp_addr, bp_site->GetSavedOpcodeBytes(), bp_opcode_size, error) == bp_opcode_size)
2196 {
2197 // Write a software breakpoint in place of the original opcode
2198 if (DoWriteMemory(bp_addr, bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2199 {
2200 uint8_t verify_bp_opcode_bytes[64];
2201 if (DoReadMemory(bp_addr, verify_bp_opcode_bytes, bp_opcode_size, error) == bp_opcode_size)
2202 {
2203 if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) == 0)
2204 {
2205 bp_site->SetEnabled(true);
2206 bp_site->SetType (BreakpointSite::eSoftware);
2207 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002208 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002209 bp_site->GetID(),
2210 (uint64_t)bp_addr);
2211 }
2212 else
Greg Clayton86edbf42011-10-26 00:56:27 +00002213 error.SetErrorString("failed to verify the breakpoint trap in memory.");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002214 }
2215 else
2216 error.SetErrorString("Unable to read memory to verify breakpoint trap.");
2217 }
2218 else
2219 error.SetErrorString("Unable to write breakpoint trap to memory.");
2220 }
2221 else
2222 error.SetErrorString("Unable to read memory at breakpoint address.");
2223 }
Stephen Wilson78a4feb2011-01-12 04:20:03 +00002224 if (log && error.Fail())
Daniel Malead01b2952012-11-29 21:49:15 +00002225 log->Printf ("Process::EnableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002226 bp_site->GetID(),
2227 (uint64_t)bp_addr,
2228 error.AsCString());
2229 return error;
2230}
2231
2232Error
2233Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
2234{
2235 Error error;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002236 assert(bp_site != nullptr);
Greg Clayton5160ce52013-03-27 23:08:40 +00002237 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002238 addr_t bp_addr = bp_site->GetLoadAddress();
2239 lldb::user_id_t breakID = bp_site->GetID();
2240 if (log)
Jim Ingham299c0c12013-02-15 02:06:30 +00002241 log->Printf ("Process::DisableSoftwareBreakpoint (breakID = %" PRIu64 ") addr = 0x%" PRIx64, breakID, (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002242
2243 if (bp_site->IsHardware())
2244 {
2245 error.SetErrorString("Breakpoint site is a hardware breakpoint.");
2246 }
2247 else if (bp_site->IsEnabled())
2248 {
2249 const size_t break_op_size = bp_site->GetByteSize();
2250 const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
2251 if (break_op_size > 0)
2252 {
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00002253 // Clear a software breakpoint instruction
Greg Claytonc982c762010-07-09 20:39:50 +00002254 uint8_t curr_break_op[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002255 assert (break_op_size <= sizeof(curr_break_op));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002256 bool break_op_found = false;
2257
2258 // Read the breakpoint opcode
2259 if (DoReadMemory (bp_addr, curr_break_op, break_op_size, error) == break_op_size)
2260 {
2261 bool verify = false;
Bruce Mitchener58ef3912015-06-18 05:27:05 +00002262 // Make sure the breakpoint opcode exists at this address
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002263 if (::memcmp (curr_break_op, break_op, break_op_size) == 0)
2264 {
2265 break_op_found = true;
2266 // We found a valid breakpoint opcode at this address, now restore
2267 // the saved opcode.
2268 if (DoWriteMemory (bp_addr, bp_site->GetSavedOpcodeBytes(), break_op_size, error) == break_op_size)
2269 {
2270 verify = true;
2271 }
2272 else
2273 error.SetErrorString("Memory write failed when restoring original opcode.");
2274 }
2275 else
2276 {
2277 error.SetErrorString("Original breakpoint trap is no longer in memory.");
2278 // Set verify to true and so we can check if the original opcode has already been restored
2279 verify = true;
2280 }
2281
2282 if (verify)
2283 {
Greg Claytonc982c762010-07-09 20:39:50 +00002284 uint8_t verify_opcode[8];
Stephen Wilson4ab47682010-07-20 18:41:11 +00002285 assert (break_op_size < sizeof(verify_opcode));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002286 // Verify that our original opcode made it back to the inferior
2287 if (DoReadMemory (bp_addr, verify_opcode, break_op_size, error) == break_op_size)
2288 {
2289 // compare the memory we just read with the original opcode
2290 if (::memcmp (bp_site->GetSavedOpcodeBytes(), verify_opcode, break_op_size) == 0)
2291 {
2292 // SUCCESS
2293 bp_site->SetEnabled(false);
2294 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002295 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- SUCCESS", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002296 return error;
2297 }
2298 else
2299 {
2300 if (break_op_found)
2301 error.SetErrorString("Failed to restore original opcode.");
2302 }
2303 }
2304 else
2305 error.SetErrorString("Failed to read memory to verify that breakpoint trap was restored.");
2306 }
2307 }
2308 else
2309 error.SetErrorString("Unable to read memory that should contain the breakpoint trap.");
2310 }
2311 }
2312 else
2313 {
2314 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002315 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- already disabled", bp_site->GetID(), (uint64_t)bp_addr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002316 return error;
2317 }
2318
2319 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002320 log->Printf ("Process::DisableSoftwareBreakpoint (site_id = %d) addr = 0x%" PRIx64 " -- FAILED: %s",
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002321 bp_site->GetID(),
2322 (uint64_t)bp_addr,
2323 error.AsCString());
2324 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002325}
2326
Greg Clayton58be07b2011-01-07 06:08:19 +00002327// Uncomment to verify memory caching works after making changes to caching code
2328//#define VERIFY_MEMORY_READS
2329
Sean Callanan64c0cf22012-06-07 22:26:42 +00002330size_t
2331Process::ReadMemory (addr_t addr, void *buf, size_t size, Error &error)
2332{
Jason Molendaa7b5afa2013-11-15 00:17:32 +00002333 error.Clear();
Sean Callanan64c0cf22012-06-07 22:26:42 +00002334 if (!GetDisableMemoryCache())
2335 {
Greg Clayton58be07b2011-01-07 06:08:19 +00002336#if defined (VERIFY_MEMORY_READS)
Sean Callanan64c0cf22012-06-07 22:26:42 +00002337 // Memory caching is enabled, with debug verification
2338
2339 if (buf && size)
2340 {
2341 // Uncomment the line below to make sure memory caching is working.
2342 // I ran this through the test suite and got no assertions, so I am
2343 // pretty confident this is working well. If any changes are made to
2344 // memory caching, uncomment the line below and test your changes!
2345
2346 // Verify all memory reads by using the cache first, then redundantly
2347 // reading the same memory from the inferior and comparing to make sure
2348 // everything is exactly the same.
2349 std::string verify_buf (size, '\0');
2350 assert (verify_buf.size() == size);
2351 const size_t cache_bytes_read = m_memory_cache.Read (this, addr, buf, size, error);
2352 Error verify_error;
2353 const size_t verify_bytes_read = ReadMemoryFromInferior (addr, const_cast<char *>(verify_buf.data()), verify_buf.size(), verify_error);
2354 assert (cache_bytes_read == verify_bytes_read);
2355 assert (memcmp(buf, verify_buf.data(), verify_buf.size()) == 0);
2356 assert (verify_error.Success() == error.Success());
2357 return cache_bytes_read;
2358 }
2359 return 0;
2360#else // !defined(VERIFY_MEMORY_READS)
2361 // Memory caching is enabled, without debug verification
2362
2363 return m_memory_cache.Read (addr, buf, size, error);
2364#endif // defined (VERIFY_MEMORY_READS)
Greg Clayton58be07b2011-01-07 06:08:19 +00002365 }
Sean Callanan64c0cf22012-06-07 22:26:42 +00002366 else
2367 {
2368 // Memory caching is disabled
2369
2370 return ReadMemoryFromInferior (addr, buf, size, error);
2371 }
Greg Clayton58be07b2011-01-07 06:08:19 +00002372}
Greg Clayton58be07b2011-01-07 06:08:19 +00002373
Greg Clayton4c82d422012-05-18 23:20:01 +00002374size_t
2375Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
2376{
Greg Claytonde87c0f2012-05-19 00:18:00 +00002377 char buf[256];
Greg Clayton4c82d422012-05-18 23:20:01 +00002378 out_str.clear();
2379 addr_t curr_addr = addr;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002380 while (true)
Greg Clayton4c82d422012-05-18 23:20:01 +00002381 {
2382 size_t length = ReadCStringFromMemory (curr_addr, buf, sizeof(buf), error);
2383 if (length == 0)
2384 break;
2385 out_str.append(buf, length);
2386 // If we got "length - 1" bytes, we didn't get the whole C string, we
2387 // need to read some more characters
2388 if (length == sizeof(buf) - 1)
2389 curr_addr += length;
2390 else
2391 break;
2392 }
2393 return out_str.size();
2394}
2395
Greg Clayton58be07b2011-01-07 06:08:19 +00002396size_t
Ashok Thirumurthi6ac9d132013-04-19 15:58:38 +00002397Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
2398 size_t type_width)
2399{
2400 size_t total_bytes_read = 0;
2401 if (dst && max_bytes && type_width && max_bytes >= type_width)
2402 {
2403 // Ensure a null terminator independent of the number of bytes that is read.
2404 memset (dst, 0, max_bytes);
2405 size_t bytes_left = max_bytes - type_width;
2406
2407 const char terminator[4] = {'\0', '\0', '\0', '\0'};
2408 assert(sizeof(terminator) >= type_width &&
2409 "Attempting to validate a string with more than 4 bytes per character!");
2410
2411 addr_t curr_addr = addr;
2412 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2413 char *curr_dst = dst;
2414
2415 error.Clear();
2416 while (bytes_left > 0 && error.Success())
2417 {
2418 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2419 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2420 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2421
2422 if (bytes_read == 0)
2423 break;
2424
2425 // Search for a null terminator of correct size and alignment in bytes_read
2426 size_t aligned_start = total_bytes_read - total_bytes_read % type_width;
2427 for (size_t i = aligned_start; i + type_width <= total_bytes_read + bytes_read; i += type_width)
Ulrich Weigand0501eeb2016-04-14 14:33:47 +00002428 if (::memcmp(&dst[i], terminator, type_width) == 0)
Ashok Thirumurthi6ac9d132013-04-19 15:58:38 +00002429 {
2430 error.Clear();
2431 return i;
2432 }
2433
2434 total_bytes_read += bytes_read;
2435 curr_dst += bytes_read;
2436 curr_addr += bytes_read;
2437 bytes_left -= bytes_read;
2438 }
2439 }
2440 else
2441 {
2442 if (max_bytes)
2443 error.SetErrorString("invalid arguments");
2444 }
2445 return total_bytes_read;
2446}
2447
2448// Deprecated in favor of ReadStringFromMemory which has wchar support and correct code to find
2449// null terminators.
2450size_t
Greg Claytone91b7952011-12-15 03:14:23 +00002451Process::ReadCStringFromMemory (addr_t addr, char *dst, size_t dst_max_len, Error &result_error)
Greg Clayton8b82f082011-04-12 05:54:46 +00002452{
2453 size_t total_cstr_len = 0;
2454 if (dst && dst_max_len)
2455 {
Greg Claytone91b7952011-12-15 03:14:23 +00002456 result_error.Clear();
Greg Clayton8b82f082011-04-12 05:54:46 +00002457 // NULL out everything just to be safe
2458 memset (dst, 0, dst_max_len);
2459 Error error;
2460 addr_t curr_addr = addr;
2461 const size_t cache_line_size = m_memory_cache.GetMemoryCacheLineSize();
2462 size_t bytes_left = dst_max_len - 1;
2463 char *curr_dst = dst;
2464
2465 while (bytes_left > 0)
2466 {
2467 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
2468 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
2469 size_t bytes_read = ReadMemory (curr_addr, curr_dst, bytes_to_read, error);
2470
2471 if (bytes_read == 0)
2472 {
Greg Claytone91b7952011-12-15 03:14:23 +00002473 result_error = error;
Greg Clayton8b82f082011-04-12 05:54:46 +00002474 dst[total_cstr_len] = '\0';
2475 break;
2476 }
2477 const size_t len = strlen(curr_dst);
2478
2479 total_cstr_len += len;
2480
2481 if (len < bytes_to_read)
2482 break;
2483
2484 curr_dst += bytes_read;
2485 curr_addr += bytes_read;
2486 bytes_left -= bytes_read;
2487 }
2488 }
Greg Claytone91b7952011-12-15 03:14:23 +00002489 else
2490 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002491 if (dst == nullptr)
Greg Claytone91b7952011-12-15 03:14:23 +00002492 result_error.SetErrorString("invalid arguments");
2493 else
2494 result_error.Clear();
2495 }
Greg Clayton8b82f082011-04-12 05:54:46 +00002496 return total_cstr_len;
2497}
2498
2499size_t
Greg Clayton58be07b2011-01-07 06:08:19 +00002500Process::ReadMemoryFromInferior (addr_t addr, void *buf, size_t size, Error &error)
2501{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002502 if (buf == nullptr || size == 0)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002503 return 0;
2504
2505 size_t bytes_read = 0;
2506 uint8_t *bytes = (uint8_t *)buf;
2507
2508 while (bytes_read < size)
2509 {
2510 const size_t curr_size = size - bytes_read;
2511 const size_t curr_bytes_read = DoReadMemory (addr + bytes_read,
2512 bytes + bytes_read,
2513 curr_size,
2514 error);
2515 bytes_read += curr_bytes_read;
2516 if (curr_bytes_read == curr_size || curr_bytes_read == 0)
2517 break;
2518 }
2519
2520 // Replace any software breakpoint opcodes that fall into this range back
2521 // into "buf" before we return
2522 if (bytes_read > 0)
2523 RemoveBreakpointOpcodesFromBuffer (addr, bytes_read, (uint8_t *)buf);
2524 return bytes_read;
2525}
2526
Greg Clayton58a4c462010-12-16 20:01:20 +00002527uint64_t
Greg Claytonc2267782016-05-23 20:37:24 +00002528Process::ReadUnsignedIntegerFromMemory(lldb::addr_t vm_addr, size_t integer_byte_size, uint64_t fail_value,
2529 Error &error)
Greg Clayton58a4c462010-12-16 20:01:20 +00002530{
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002531 Scalar scalar;
2532 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, false, scalar, error))
2533 return scalar.ULongLong(fail_value);
2534 return fail_value;
2535}
2536
Greg Claytonc2267782016-05-23 20:37:24 +00002537int64_t
2538Process::ReadSignedIntegerFromMemory(lldb::addr_t vm_addr, size_t integer_byte_size, int64_t fail_value, Error &error)
2539{
2540 Scalar scalar;
2541 if (ReadScalarIntegerFromMemory(vm_addr, integer_byte_size, true, scalar, error))
2542 return scalar.SLongLong(fail_value);
2543 return fail_value;
2544}
2545
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002546addr_t
2547Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
2548{
2549 Scalar scalar;
2550 if (ReadScalarIntegerFromMemory(vm_addr, GetAddressByteSize(), false, scalar, error))
2551 return scalar.ULongLong(LLDB_INVALID_ADDRESS);
2552 return LLDB_INVALID_ADDRESS;
2553}
2554
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002555bool
2556Process::WritePointerToMemory (lldb::addr_t vm_addr,
2557 lldb::addr_t ptr_value,
2558 Error &error)
2559{
2560 Scalar scalar;
2561 const uint32_t addr_byte_size = GetAddressByteSize();
2562 if (addr_byte_size <= 4)
2563 scalar = (uint32_t)ptr_value;
Greg Clayton58a4c462010-12-16 20:01:20 +00002564 else
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002565 scalar = ptr_value;
2566 return WriteScalarToMemory(vm_addr, scalar, addr_byte_size, error) == addr_byte_size;
Greg Clayton58a4c462010-12-16 20:01:20 +00002567}
2568
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002569size_t
2570Process::WriteMemoryPrivate (addr_t addr, const void *buf, size_t size, Error &error)
2571{
2572 size_t bytes_written = 0;
2573 const uint8_t *bytes = (const uint8_t *)buf;
2574
2575 while (bytes_written < size)
2576 {
2577 const size_t curr_size = size - bytes_written;
2578 const size_t curr_bytes_written = DoWriteMemory (addr + bytes_written,
2579 bytes + bytes_written,
2580 curr_size,
2581 error);
2582 bytes_written += curr_bytes_written;
2583 if (curr_bytes_written == curr_size || curr_bytes_written == 0)
2584 break;
2585 }
2586 return bytes_written;
2587}
2588
2589size_t
2590Process::WriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
2591{
Greg Clayton58be07b2011-01-07 06:08:19 +00002592#if defined (ENABLE_MEMORY_CACHING)
2593 m_memory_cache.Flush (addr, size);
2594#endif
2595
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002596 if (buf == nullptr || size == 0)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002597 return 0;
Jim Ingham78a685a2011-04-16 00:01:13 +00002598
Jim Ingham4b536182011-08-09 02:12:22 +00002599 m_mod_id.BumpMemoryID();
Jim Ingham78a685a2011-04-16 00:01:13 +00002600
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002601 // We need to write any data that would go where any current software traps
2602 // (enabled software breakpoints) any software traps (breakpoints) that we
2603 // may have placed in our tasks memory.
2604
Greg Claytond8cf1a12013-06-12 00:46:38 +00002605 BreakpointSiteList bp_sites_in_range;
2606
2607 if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002608 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002609 // No breakpoint sites overlap
2610 if (bp_sites_in_range.IsEmpty())
2611 return WriteMemoryPrivate (addr, buf, size, error);
2612 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002613 {
Greg Claytond8cf1a12013-06-12 00:46:38 +00002614 const uint8_t *ubuf = (const uint8_t *)buf;
2615 uint64_t bytes_written = 0;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002616
Greg Claytond8cf1a12013-06-12 00:46:38 +00002617 bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
2618
2619 if (error.Success())
2620 {
2621 addr_t intersect_addr;
2622 size_t intersect_size;
2623 size_t opcode_offset;
2624 const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
Bruce Mitchener8a67bf72015-07-24 00:23:29 +00002625 UNUSED_IF_ASSERT_DISABLED(intersects);
Greg Claytond8cf1a12013-06-12 00:46:38 +00002626 assert(intersects);
2627 assert(addr <= intersect_addr && intersect_addr < addr + size);
2628 assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
2629 assert(opcode_offset + intersect_size <= bp->GetByteSize());
2630
2631 // Check for bytes before this breakpoint
2632 const addr_t curr_addr = addr + bytes_written;
2633 if (intersect_addr > curr_addr)
2634 {
2635 // There are some bytes before this breakpoint that we need to
2636 // just write to memory
2637 size_t curr_size = intersect_addr - curr_addr;
2638 size_t curr_bytes_written = WriteMemoryPrivate (curr_addr,
2639 ubuf + bytes_written,
2640 curr_size,
2641 error);
2642 bytes_written += curr_bytes_written;
2643 if (curr_bytes_written != curr_size)
2644 {
2645 // We weren't able to write all of the requested bytes, we
2646 // are done looping and will return the number of bytes that
2647 // we have written so far.
2648 if (error.Success())
2649 error.SetErrorToGenericError();
2650 }
2651 }
2652 // Now write any bytes that would cover up any software breakpoints
2653 // directly into the breakpoint opcode buffer
2654 ::memcpy(bp->GetSavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size);
2655 bytes_written += intersect_size;
2656 }
2657 });
2658
2659 if (bytes_written < size)
Jason Molenda8b5f2cf2014-10-16 07:49:27 +00002660 WriteMemoryPrivate (addr + bytes_written,
2661 ubuf + bytes_written,
2662 size - bytes_written,
2663 error);
Greg Claytond8cf1a12013-06-12 00:46:38 +00002664 }
2665 }
2666 else
2667 {
2668 return WriteMemoryPrivate (addr, buf, size, error);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002669 }
2670
2671 // Write any remaining bytes after the last breakpoint if we have any left
Greg Claytond8cf1a12013-06-12 00:46:38 +00002672 return 0; //bytes_written;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002673}
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002674
2675size_t
Greg Claytonc7bece562013-01-25 18:06:21 +00002676Process::WriteScalarToMemory (addr_t addr, const Scalar &scalar, size_t byte_size, Error &error)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002677{
2678 if (byte_size == UINT32_MAX)
2679 byte_size = scalar.GetByteSize();
2680 if (byte_size > 0)
2681 {
2682 uint8_t buf[32];
2683 const size_t mem_size = scalar.GetAsMemoryData (buf, byte_size, GetByteOrder(), error);
2684 if (mem_size > 0)
2685 return WriteMemory(addr, buf, mem_size, error);
2686 else
2687 error.SetErrorString ("failed to get scalar as memory data");
2688 }
2689 else
2690 {
2691 error.SetErrorString ("invalid scalar value");
2692 }
2693 return 0;
2694}
2695
2696size_t
2697Process::ReadScalarIntegerFromMemory (addr_t addr,
2698 uint32_t byte_size,
2699 bool is_signed,
2700 Scalar &scalar,
2701 Error &error)
2702{
Greg Clayton7060f892013-05-01 23:41:30 +00002703 uint64_t uval = 0;
2704 if (byte_size == 0)
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002705 {
Greg Clayton7060f892013-05-01 23:41:30 +00002706 error.SetErrorString ("byte size is zero");
2707 }
2708 else if (byte_size & (byte_size - 1))
2709 {
2710 error.SetErrorStringWithFormat ("byte size %u is not a power of 2", byte_size);
2711 }
2712 else if (byte_size <= sizeof(uval))
2713 {
2714 const size_t bytes_read = ReadMemory (addr, &uval, byte_size, error);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002715 if (bytes_read == byte_size)
2716 {
2717 DataExtractor data (&uval, sizeof(uval), GetByteOrder(), GetAddressByteSize());
Greg Claytonc7bece562013-01-25 18:06:21 +00002718 lldb::offset_t offset = 0;
Greg Clayton7060f892013-05-01 23:41:30 +00002719 if (byte_size <= 4)
2720 scalar = data.GetMaxU32 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002721 else
Greg Clayton7060f892013-05-01 23:41:30 +00002722 scalar = data.GetMaxU64 (&offset, byte_size);
Greg Claytonf3ef3d22011-05-22 22:46:53 +00002723 if (is_signed)
2724 scalar.SignExtend(byte_size * 8);
2725 return bytes_read;
2726 }
2727 }
2728 else
2729 {
2730 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
2731 }
2732 return 0;
2733}
2734
Greg Claytond495c532011-05-17 03:37:42 +00002735#define USE_ALLOCATE_MEMORY_CACHE 1
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002736addr_t
2737Process::AllocateMemory(size_t size, uint32_t permissions, Error &error)
2738{
Jim Inghamf72ce3a2011-06-20 17:32:44 +00002739 if (GetPrivateState() != eStateStopped)
2740 return LLDB_INVALID_ADDRESS;
2741
Greg Claytond495c532011-05-17 03:37:42 +00002742#if defined (USE_ALLOCATE_MEMORY_CACHE)
2743 return m_allocated_memory_cache.AllocateMemory(size, permissions, error);
2744#else
Greg Claytonb2daec92011-01-23 19:58:49 +00002745 addr_t allocated_addr = DoAllocateMemory (size, permissions, error);
Greg Clayton5160ce52013-03-27 23:08:40 +00002746 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002747 if (log)
Greg Clayton45989072013-10-23 18:24:30 +00002748 log->Printf("Process::AllocateMemory(size=%" PRIu64 ", permissions=%s) => 0x%16.16" PRIx64 " (m_stop_id = %u m_memory_id = %u)",
Deepak Panickald66b50c2013-10-22 12:27:43 +00002749 (uint64_t)size,
Greg Claytond495c532011-05-17 03:37:42 +00002750 GetPermissionsAsCString (permissions),
Greg Claytonb2daec92011-01-23 19:58:49 +00002751 (uint64_t)allocated_addr,
Jim Ingham4b536182011-08-09 02:12:22 +00002752 m_mod_id.GetStopID(),
2753 m_mod_id.GetMemoryID());
Greg Claytonb2daec92011-01-23 19:58:49 +00002754 return allocated_addr;
Greg Claytond495c532011-05-17 03:37:42 +00002755#endif
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002756}
2757
Jim Ingham2c381412015-11-04 20:32:27 +00002758addr_t
2759Process::CallocateMemory(size_t size, uint32_t permissions, Error &error)
2760{
2761 addr_t return_addr = AllocateMemory(size, permissions, error);
2762 if (error.Success())
2763 {
2764 std::string buffer(size, 0);
2765 WriteMemory(return_addr, buffer.c_str(), size, error);
2766 }
2767 return return_addr;
2768}
2769
Sean Callanan90539452011-09-20 23:01:51 +00002770bool
2771Process::CanJIT ()
2772{
Sean Callanana7b443a2012-02-14 22:50:38 +00002773 if (m_can_jit == eCanJITDontKnow)
2774 {
Todd Fialaaf245d12014-06-30 21:05:18 +00002775 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Sean Callanana7b443a2012-02-14 22:50:38 +00002776 Error err;
2777
2778 uint64_t allocated_memory = AllocateMemory(8,
2779 ePermissionsReadable | ePermissionsWritable | ePermissionsExecutable,
2780 err);
2781
2782 if (err.Success())
Todd Fialaaf245d12014-06-30 21:05:18 +00002783 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002784 m_can_jit = eCanJITYes;
Todd Fialaaf245d12014-06-30 21:05:18 +00002785 if (log)
2786 log->Printf ("Process::%s pid %" PRIu64 " allocation test passed, CanJIT () is true", __FUNCTION__, GetID ());
2787 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002788 else
Todd Fialaaf245d12014-06-30 21:05:18 +00002789 {
Sean Callanana7b443a2012-02-14 22:50:38 +00002790 m_can_jit = eCanJITNo;
Todd Fialaaf245d12014-06-30 21:05:18 +00002791 if (log)
2792 log->Printf ("Process::%s pid %" PRIu64 " allocation test failed, CanJIT () is false: %s", __FUNCTION__, GetID (), err.AsCString ());
2793 }
Sean Callanana7b443a2012-02-14 22:50:38 +00002794
2795 DeallocateMemory (allocated_memory);
2796 }
2797
Sean Callanan90539452011-09-20 23:01:51 +00002798 return m_can_jit == eCanJITYes;
2799}
2800
2801void
2802Process::SetCanJIT (bool can_jit)
2803{
2804 m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
2805}
2806
Ewan Crawford90ff7912015-07-14 10:56:58 +00002807void
2808Process::SetCanRunCode (bool can_run_code)
2809{
2810 SetCanJIT(can_run_code);
2811 m_can_interpret_function_calls = can_run_code;
2812}
2813
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002814Error
2815Process::DeallocateMemory (addr_t ptr)
2816{
Greg Claytond495c532011-05-17 03:37:42 +00002817 Error error;
2818#if defined (USE_ALLOCATE_MEMORY_CACHE)
2819 if (!m_allocated_memory_cache.DeallocateMemory(ptr))
2820 {
Daniel Malead01b2952012-11-29 21:49:15 +00002821 error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);
Greg Claytond495c532011-05-17 03:37:42 +00002822 }
2823#else
2824 error = DoDeallocateMemory (ptr);
Greg Claytonb2daec92011-01-23 19:58:49 +00002825
Greg Clayton5160ce52013-03-27 23:08:40 +00002826 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Claytonb2daec92011-01-23 19:58:49 +00002827 if (log)
Daniel Malead01b2952012-11-29 21:49:15 +00002828 log->Printf("Process::DeallocateMemory(addr=0x%16.16" PRIx64 ") => err = %s (m_stop_id = %u, m_memory_id = %u)",
Greg Claytonb2daec92011-01-23 19:58:49 +00002829 ptr,
2830 error.AsCString("SUCCESS"),
Jim Ingham4b536182011-08-09 02:12:22 +00002831 m_mod_id.GetStopID(),
2832 m_mod_id.GetMemoryID());
Greg Claytond495c532011-05-17 03:37:42 +00002833#endif
Greg Claytonb2daec92011-01-23 19:58:49 +00002834 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002835}
2836
Greg Claytonc9660542012-02-05 02:38:54 +00002837ModuleSP
Greg Claytonc859e2d2012-02-13 23:10:39 +00002838Process::ReadModuleFromMemory (const FileSpec& file_spec,
Andrew MacPherson17220c12014-03-05 10:12:43 +00002839 lldb::addr_t header_addr,
2840 size_t size_to_read)
Greg Claytonc9660542012-02-05 02:38:54 +00002841{
Jason Molenda08a32582015-07-25 02:39:42 +00002842 Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);
2843 if (log)
2844 {
2845 log->Printf ("Process::ReadModuleFromMemory reading %s binary from memory", file_spec.GetPath().c_str());
2846 }
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002847 ModuleSP module_sp (new Module (file_spec, ArchSpec()));
Greg Claytonc9660542012-02-05 02:38:54 +00002848 if (module_sp)
2849 {
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002850 Error error;
Andrew MacPherson17220c12014-03-05 10:12:43 +00002851 ObjectFile *objfile = module_sp->GetMemoryObjectFile (shared_from_this(), header_addr, error, size_to_read);
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002852 if (objfile)
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002853 return module_sp;
Greg Claytonc9660542012-02-05 02:38:54 +00002854 }
Greg Claytonc7f09cc2012-02-24 21:55:59 +00002855 return ModuleSP();
Greg Claytonc9660542012-02-05 02:38:54 +00002856}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002857
Zachary Turner93749ab2015-03-03 21:51:25 +00002858bool
2859Process::GetLoadAddressPermissions (lldb::addr_t load_addr, uint32_t &permissions)
2860{
2861 MemoryRegionInfo range_info;
2862 permissions = 0;
2863 Error error (GetMemoryRegionInfo (load_addr, range_info));
2864 if (!error.Success())
2865 return false;
2866 if (range_info.GetReadable() == MemoryRegionInfo::eDontKnow
2867 || range_info.GetWritable() == MemoryRegionInfo::eDontKnow
2868 || range_info.GetExecutable() == MemoryRegionInfo::eDontKnow)
2869 {
2870 return false;
2871 }
2872
2873 if (range_info.GetReadable() == MemoryRegionInfo::eYes)
2874 permissions |= lldb::ePermissionsReadable;
2875
2876 if (range_info.GetWritable() == MemoryRegionInfo::eYes)
2877 permissions |= lldb::ePermissionsWritable;
2878
2879 if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
2880 permissions |= lldb::ePermissionsExecutable;
2881
2882 return true;
2883}
2884
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002885Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002886Process::EnableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002887{
2888 Error error;
2889 error.SetErrorString("watchpoints are not supported");
2890 return error;
2891}
2892
2893Error
Jim Ingham1b5792e2012-12-18 02:03:49 +00002894Process::DisableWatchpoint (Watchpoint *watchpoint, bool notify)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002895{
2896 Error error;
2897 error.SetErrorString("watchpoints are not supported");
2898 return error;
2899}
2900
2901StateType
2902Process::WaitForProcessStopPrivate (const TimeValue *timeout, EventSP &event_sp)
2903{
2904 StateType state;
2905 // Now wait for the process to launch and return control to us, and then
2906 // call DidLaunch:
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002907 while (true)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002908 {
Greg Clayton6779606a2011-01-22 23:43:18 +00002909 event_sp.reset();
2910 state = WaitForStateChangedEventsPrivate (timeout, event_sp);
2911
Greg Clayton2637f822011-11-17 01:23:07 +00002912 if (StateIsStoppedState(state, false))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002913 break;
Greg Clayton6779606a2011-01-22 23:43:18 +00002914
2915 // If state is invalid, then we timed out
2916 if (state == eStateInvalid)
2917 break;
2918
2919 if (event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002920 HandlePrivateEvent (event_sp);
2921 }
2922 return state;
2923}
2924
Greg Clayton332e8b12015-01-13 21:13:08 +00002925void
2926Process::LoadOperatingSystemPlugin(bool flush)
2927{
2928 if (flush)
2929 m_thread_list.Clear();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002930 m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr));
Greg Clayton332e8b12015-01-13 21:13:08 +00002931 if (flush)
2932 Flush();
2933}
2934
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002935Error
Greg Claytonfbb76342013-11-20 21:07:01 +00002936Process::Launch (ProcessLaunchInfo &launch_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002937{
2938 Error error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002939 m_abi_sp.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00002940 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00002941 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00002942 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00002943 m_os_ap.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00002944 m_process_input_reader.reset();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002945 m_stop_info_override_callback = nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002946
Zachary Turner7529df92015-09-01 20:02:29 +00002947 Module *exe_module = GetTarget().GetExecutableModulePointer();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002948 if (exe_module)
2949 {
Greg Clayton2289fa42011-04-30 01:09:13 +00002950 char local_exec_file_path[PATH_MAX];
2951 char platform_exec_file_path[PATH_MAX];
2952 exe_module->GetFileSpec().GetPath(local_exec_file_path, sizeof(local_exec_file_path));
2953 exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path, sizeof(platform_exec_file_path));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002954 if (exe_module->GetFileSpec().Exists())
2955 {
Greg Claytonfbb76342013-11-20 21:07:01 +00002956 // Install anything that might need to be installed prior to launching.
2957 // For host systems, this will do nothing, but if we are connected to a
2958 // remote platform it will install any needed binaries
2959 error = GetTarget().Install(&launch_info);
2960 if (error.Fail())
2961 return error;
2962
Greg Clayton71337622011-02-24 22:24:29 +00002963 if (PrivateStateThreadIsValid ())
2964 PausePrivateStateThread ();
2965
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002966 error = WillLaunch (exe_module);
2967 if (error.Success())
2968 {
Jim Ingham221d51c2013-05-08 00:35:16 +00002969 const bool restarted = false;
2970 SetPublicState (eStateLaunching, restarted);
Greg Claytone24c4ac2011-11-17 04:46:02 +00002971 m_should_detach = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002972
Ed Maste64fad602013-07-29 20:58:06 +00002973 if (m_public_run_lock.TrySetRunning())
Greg Clayton69fd4be2012-09-04 20:29:05 +00002974 {
2975 // Now launch using these arguments.
2976 error = DoLaunch (exe_module, launch_info);
2977 }
2978 else
2979 {
2980 // This shouldn't happen
2981 error.SetErrorString("failed to acquire process run lock");
2982 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002983
2984 if (error.Fail())
2985 {
2986 if (GetID() != LLDB_INVALID_PROCESS_ID)
2987 {
2988 SetID (LLDB_INVALID_PROCESS_ID);
2989 const char *error_string = error.AsCString();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00002990 if (error_string == nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00002991 error_string = "launch failed";
2992 SetExitStatus (-1, error_string);
2993 }
2994 }
2995 else
2996 {
2997 EventSP event_sp;
Greg Clayton1a38ea72011-06-22 01:42:17 +00002998 TimeValue timeout_time;
2999 timeout_time = TimeValue::Now();
3000 timeout_time.OffsetWithSeconds(10);
3001 StateType state = WaitForProcessStopPrivate(&timeout_time, event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003002
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003003 if (state == eStateInvalid || !event_sp)
Greg Clayton1a38ea72011-06-22 01:42:17 +00003004 {
3005 // We were able to launch the process, but we failed to
3006 // catch the initial stop.
Tamas Berghammer04e63142015-02-23 10:59:54 +00003007 error.SetErrorString ("failed to catch stop after launch");
Greg Clayton1a38ea72011-06-22 01:42:17 +00003008 SetExitStatus (0, "failed to catch stop after launch");
Jason Molendaede31932015-04-17 05:01:58 +00003009 Destroy(false);
Greg Clayton1a38ea72011-06-22 01:42:17 +00003010 }
3011 else if (state == eStateStopped || state == eStateCrashed)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003012 {
3013 DidLaunch ();
3014
Greg Claytonc859e2d2012-02-13 23:10:39 +00003015 DynamicLoader *dyld = GetDynamicLoader ();
3016 if (dyld)
3017 dyld->DidLaunch();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003018
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003019 GetJITLoaders().DidLaunch();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003020
Jason Molendaeef51062013-11-05 03:57:19 +00003021 SystemRuntime *system_runtime = GetSystemRuntime ();
3022 if (system_runtime)
3023 system_runtime->DidLaunch();
3024
Greg Clayton332e8b12015-01-13 21:13:08 +00003025 LoadOperatingSystemPlugin(false);
Todd Fialaf72fa672014-10-07 16:05:21 +00003026
3027 // Note, the stop event was consumed above, but not handled. This was done
3028 // to give DidLaunch a chance to run. The target is either stopped or crashed.
3029 // Directly set the state. This is done to prevent a stop message with a bunch
3030 // of spurious output on thread status, as well as not pop a ProcessIOHandler.
3031 SetPublicState(state, false);
Greg Clayton71337622011-02-24 22:24:29 +00003032
3033 if (PrivateStateThreadIsValid ())
3034 ResumePrivateStateThread ();
3035 else
3036 StartPrivateStateThread ();
Greg Claytona97c4d22014-12-09 23:31:02 +00003037
3038 m_stop_info_override_callback = GetTarget().GetArchitecture().GetStopInfoOverrideCallback();
Ilia K6af632f2015-02-06 18:15:05 +00003039
3040 // Target was stopped at entry as was intended. Need to notify the listeners
3041 // about it.
Ilia K333fc182015-02-11 11:24:20 +00003042 if (state == eStateStopped && launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
Ilia K6af632f2015-02-06 18:15:05 +00003043 HandlePrivateEvent(event_sp);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003044 }
3045 else if (state == eStateExited)
3046 {
3047 // We exited while trying to launch somehow. Don't call DidLaunch as that's
3048 // not likely to work, and return an invalid pid.
3049 HandlePrivateEvent (event_sp);
3050 }
3051 }
3052 }
3053 }
3054 else
3055 {
Greg Clayton86edbf42011-10-26 00:56:27 +00003056 error.SetErrorStringWithFormat("file doesn't exist: '%s'", local_exec_file_path);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003057 }
3058 }
3059 return error;
3060}
3061
Greg Claytonc3776bf2012-02-09 06:16:32 +00003062Error
3063Process::LoadCore ()
3064{
3065 Error error = DoLoadCore();
3066 if (error.Success())
3067 {
Jim Ingham583bbb12016-03-07 21:50:25 +00003068 ListenerSP listener_sp (Listener::MakeListener("lldb.process.load_core_listener"));
3069 HijackProcessEvents(listener_sp);
Greg Clayton35824e32015-02-20 20:59:47 +00003070
Greg Claytonc3776bf2012-02-09 06:16:32 +00003071 if (PrivateStateThreadIsValid ())
3072 ResumePrivateStateThread ();
3073 else
3074 StartPrivateStateThread ();
3075
Greg Claytonc859e2d2012-02-13 23:10:39 +00003076 DynamicLoader *dyld = GetDynamicLoader ();
3077 if (dyld)
3078 dyld->DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003079
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003080 GetJITLoaders().DidAttach();
Greg Claytonc859e2d2012-02-13 23:10:39 +00003081
Jason Molendaeef51062013-11-05 03:57:19 +00003082 SystemRuntime *system_runtime = GetSystemRuntime ();
3083 if (system_runtime)
3084 system_runtime->DidAttach();
3085
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003086 m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr));
Greg Claytonc3776bf2012-02-09 06:16:32 +00003087 // We successfully loaded a core file, now pretend we stopped so we can
3088 // show all of the threads in the core file and explore the crashed
3089 // state.
3090 SetPrivateState (eStateStopped);
Greg Clayton35824e32015-02-20 20:59:47 +00003091
3092 // Wait indefinitely for a stopped event since we just posted one above...
3093 lldb::EventSP event_sp;
Jim Ingham583bbb12016-03-07 21:50:25 +00003094 listener_sp->WaitForEvent (nullptr, event_sp);
Greg Clayton35824e32015-02-20 20:59:47 +00003095 StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
3096
3097 if (!StateIsStoppedState (state, false))
3098 {
3099 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3100 if (log)
3101 log->Printf("Process::Halt() failed to stop, state is: %s", StateAsCString(state));
3102 error.SetErrorString ("Did not get stopped event after loading the core file.");
3103 }
Greg Clayton338d0bd2015-02-20 21:51:06 +00003104 RestoreProcessEvents ();
Greg Claytonc3776bf2012-02-09 06:16:32 +00003105 }
3106 return error;
3107}
3108
Greg Claytonc859e2d2012-02-13 23:10:39 +00003109DynamicLoader *
3110Process::GetDynamicLoader ()
3111{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003112 if (!m_dyld_ap)
3113 m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr));
Greg Claytonc859e2d2012-02-13 23:10:39 +00003114 return m_dyld_ap.get();
3115}
Greg Claytonc3776bf2012-02-09 06:16:32 +00003116
Todd Fialaaf245d12014-06-30 21:05:18 +00003117const lldb::DataBufferSP
3118Process::GetAuxvData()
3119{
3120 return DataBufferSP ();
3121}
3122
Andrew MacPherson17220c12014-03-05 10:12:43 +00003123JITLoaderList &
3124Process::GetJITLoaders ()
3125{
3126 if (!m_jit_loaders_ap)
3127 {
3128 m_jit_loaders_ap.reset(new JITLoaderList());
3129 JITLoader::LoadPlugins(this, *m_jit_loaders_ap);
3130 }
3131 return *m_jit_loaders_ap;
3132}
3133
Jason Molendaeef51062013-11-05 03:57:19 +00003134SystemRuntime *
3135Process::GetSystemRuntime ()
3136{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003137 if (!m_system_runtime_ap)
3138 m_system_runtime_ap.reset(SystemRuntime::FindPlugin(this));
Jason Molendaeef51062013-11-05 03:57:19 +00003139 return m_system_runtime_ap.get();
3140}
3141
Todd Fiala76e0fc92014-08-27 22:58:26 +00003142Process::AttachCompletionHandler::AttachCompletionHandler (Process *process, uint32_t exec_count) :
3143 NextEventAction (process),
3144 m_exec_count (exec_count)
3145{
3146 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3147 if (log)
3148 log->Printf ("Process::AttachCompletionHandler::%s process=%p, exec_count=%" PRIu32, __FUNCTION__, static_cast<void*>(process), exec_count);
3149}
Greg Claytonc3776bf2012-02-09 06:16:32 +00003150
Jim Inghambb3a2832011-01-29 01:49:25 +00003151Process::NextEventAction::EventActionResult
3152Process::AttachCompletionHandler::PerformAction (lldb::EventSP &event_sp)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003153{
Todd Fiala76e0fc92014-08-27 22:58:26 +00003154 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3155
Jim Inghambb3a2832011-01-29 01:49:25 +00003156 StateType state = ProcessEventData::GetStateFromEvent (event_sp.get());
Todd Fiala76e0fc92014-08-27 22:58:26 +00003157 if (log)
3158 log->Printf ("Process::AttachCompletionHandler::%s called with state %s (%d)", __FUNCTION__, StateAsCString(state), static_cast<int> (state));
3159
3160 switch (state)
Greg Clayton19388cf2010-10-18 01:45:30 +00003161 {
Zachary Turnerc62733b2015-05-20 18:31:17 +00003162 case eStateAttaching:
3163 return eEventActionSuccess;
3164
Greg Clayton513c26c2011-01-29 07:10:55 +00003165 case eStateRunning:
Greg Clayton71337622011-02-24 22:24:29 +00003166 case eStateConnected:
Greg Clayton513c26c2011-01-29 07:10:55 +00003167 return eEventActionRetry;
3168
3169 case eStateStopped:
3170 case eStateCrashed:
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003171 // During attach, prior to sending the eStateStopped event,
3172 // lldb_private::Process subclasses must set the new process ID.
3173 assert (m_process->GetID() != LLDB_INVALID_PROCESS_ID);
3174 // We don't want these events to be reported, so go set the ShouldReportStop here:
3175 m_process->GetThreadList().SetShouldReportStop (eVoteNo);
3176
3177 if (m_exec_count > 0)
Greg Claytonc9ed4782011-11-12 02:10:56 +00003178 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003179 --m_exec_count;
Todd Fiala76e0fc92014-08-27 22:58:26 +00003180
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003181 if (log)
3182 log->Printf ("Process::AttachCompletionHandler::%s state %s: reduced remaining exec count to %" PRIu32 ", requesting resume", __FUNCTION__, StateAsCString(state), m_exec_count);
Todd Fiala76e0fc92014-08-27 22:58:26 +00003183
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003184 RequestResume();
3185 return eEventActionRetry;
3186 }
3187 else
3188 {
3189 if (log)
3190 log->Printf ("Process::AttachCompletionHandler::%s state %s: no more execs expected to start, continuing with attach", __FUNCTION__, StateAsCString(state));
Todd Fiala76e0fc92014-08-27 22:58:26 +00003191
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003192 m_process->CompleteAttach ();
3193 return eEventActionSuccess;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003194 }
Greg Clayton513c26c2011-01-29 07:10:55 +00003195 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00003196
Greg Clayton513c26c2011-01-29 07:10:55 +00003197 default:
3198 case eStateExited:
3199 case eStateInvalid:
Greg Clayton513c26c2011-01-29 07:10:55 +00003200 break;
Jim Inghambb3a2832011-01-29 01:49:25 +00003201 }
Greg Claytonc9ed4782011-11-12 02:10:56 +00003202
3203 m_exit_string.assign ("No valid Process");
3204 return eEventActionExit;
Jim Inghambb3a2832011-01-29 01:49:25 +00003205}
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003206
Jim Inghambb3a2832011-01-29 01:49:25 +00003207Process::NextEventAction::EventActionResult
3208Process::AttachCompletionHandler::HandleBeingInterrupted()
3209{
3210 return eEventActionSuccess;
3211}
3212
3213const char *
3214Process::AttachCompletionHandler::GetExitString ()
3215{
3216 return m_exit_string.c_str();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003217}
3218
Jim Ingham583bbb12016-03-07 21:50:25 +00003219ListenerSP
Greg Clayton8012cad2014-11-17 19:39:20 +00003220ProcessAttachInfo::GetListenerForProcess (Debugger &debugger)
3221{
Jim Ingham583bbb12016-03-07 21:50:25 +00003222 if (m_listener_sp)
3223 return m_listener_sp;
3224 else
3225 return debugger.GetListener();
Greg Clayton8012cad2014-11-17 19:39:20 +00003226}
3227
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003228Error
Greg Clayton144f3a92011-11-15 03:53:30 +00003229Process::Attach (ProcessAttachInfo &attach_info)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003230{
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003231 m_abi_sp.reset();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003232 m_process_input_reader.reset();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003233 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003234 m_jit_loaders_ap.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00003235 m_system_runtime_ap.reset();
Greg Clayton56d9a1b2011-08-22 02:49:39 +00003236 m_os_ap.reset();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003237 m_stop_info_override_callback = nullptr;
Jim Ingham5aee1622010-08-09 23:31:02 +00003238
Greg Clayton144f3a92011-11-15 03:53:30 +00003239 lldb::pid_t attach_pid = attach_info.GetProcessID();
Greg Claytone996fd32011-03-08 22:40:15 +00003240 Error error;
Greg Clayton144f3a92011-11-15 03:53:30 +00003241 if (attach_pid == LLDB_INVALID_PROCESS_ID)
Jim Ingham5aee1622010-08-09 23:31:02 +00003242 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003243 char process_name[PATH_MAX];
Jim Ingham4299fdb2011-09-15 01:10:17 +00003244
Greg Clayton144f3a92011-11-15 03:53:30 +00003245 if (attach_info.GetExecutableFile().GetPath (process_name, sizeof(process_name)))
Jim Ingham2ecb7422010-08-17 21:54:19 +00003246 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003247 const bool wait_for_launch = attach_info.GetWaitForLaunch();
3248
3249 if (wait_for_launch)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003250 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003251 error = WillAttachToProcessWithName(process_name, wait_for_launch);
3252 if (error.Success())
3253 {
Ed Maste64fad602013-07-29 20:58:06 +00003254 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00003255 {
3256 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00003257 const bool restarted = false;
3258 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00003259 // Now attach using these arguments.
Jean-Daniel Dupas9c517c02013-12-23 22:32:54 +00003260 error = DoAttachToProcessWithName (process_name, attach_info);
Greg Clayton926cce72012-10-12 16:10:12 +00003261 }
3262 else
3263 {
3264 // This shouldn't happen
3265 error.SetErrorString("failed to acquire process run lock");
3266 }
Greg Claytone24c4ac2011-11-17 04:46:02 +00003267
Greg Clayton144f3a92011-11-15 03:53:30 +00003268 if (error.Fail())
3269 {
3270 if (GetID() != LLDB_INVALID_PROCESS_ID)
3271 {
3272 SetID (LLDB_INVALID_PROCESS_ID);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003273 if (error.AsCString() == nullptr)
Greg Clayton144f3a92011-11-15 03:53:30 +00003274 error.SetErrorString("attach failed");
3275
3276 SetExitStatus(-1, error.AsCString());
3277 }
3278 }
3279 else
3280 {
3281 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3282 StartPrivateStateThread();
3283 }
3284 return error;
3285 }
Greg Claytone996fd32011-03-08 22:40:15 +00003286 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003287 else
Greg Claytone996fd32011-03-08 22:40:15 +00003288 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003289 ProcessInstanceInfoList process_infos;
Zachary Turner7529df92015-09-01 20:02:29 +00003290 PlatformSP platform_sp (GetTarget().GetPlatform ());
Greg Clayton144f3a92011-11-15 03:53:30 +00003291
3292 if (platform_sp)
3293 {
3294 ProcessInstanceInfoMatch match_info;
3295 match_info.GetProcessInfo() = attach_info;
3296 match_info.SetNameMatchType (eNameMatchEquals);
3297 platform_sp->FindProcesses (match_info, process_infos);
3298 const uint32_t num_matches = process_infos.GetSize();
3299 if (num_matches == 1)
3300 {
3301 attach_pid = process_infos.GetProcessIDAtIndex(0);
3302 // Fall through and attach using the above process ID
3303 }
3304 else
3305 {
3306 match_info.GetProcessInfo().GetExecutableFile().GetPath (process_name, sizeof(process_name));
3307 if (num_matches > 1)
Jim Ingham368ac222014-08-15 17:05:27 +00003308 {
3309 StreamString s;
3310 ProcessInstanceInfo::DumpTableHeader (s, platform_sp.get(), true, false);
3311 for (size_t i = 0; i < num_matches; i++)
3312 {
3313 process_infos.GetProcessInfoAtIndex(i).DumpAsTableRow(s, platform_sp.get(), true, false);
3314 }
3315 error.SetErrorStringWithFormat ("more than one process named %s:\n%s",
3316 process_name,
3317 s.GetData());
3318 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003319 else
3320 error.SetErrorStringWithFormat ("could not find a process named %s", process_name);
3321 }
3322 }
3323 else
3324 {
3325 error.SetErrorString ("invalid platform, can't find processes by name");
3326 return error;
3327 }
Greg Claytone996fd32011-03-08 22:40:15 +00003328 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003329 }
3330 else
Greg Clayton144f3a92011-11-15 03:53:30 +00003331 {
3332 error.SetErrorString ("invalid process name");
Greg Claytone996fd32011-03-08 22:40:15 +00003333 }
3334 }
Greg Clayton144f3a92011-11-15 03:53:30 +00003335
3336 if (attach_pid != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00003337 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003338 error = WillAttachToProcessWithID(attach_pid);
Greg Claytone996fd32011-03-08 22:40:15 +00003339 if (error.Success())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003340 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003341
Ed Maste64fad602013-07-29 20:58:06 +00003342 if (m_public_run_lock.TrySetRunning())
Greg Clayton926cce72012-10-12 16:10:12 +00003343 {
3344 // Now attach using these arguments.
3345 m_should_detach = true;
Jim Ingham221d51c2013-05-08 00:35:16 +00003346 const bool restarted = false;
3347 SetPublicState (eStateAttaching, restarted);
Greg Clayton926cce72012-10-12 16:10:12 +00003348 error = DoAttachToProcessWithID (attach_pid, attach_info);
3349 }
3350 else
3351 {
3352 // This shouldn't happen
3353 error.SetErrorString("failed to acquire process run lock");
3354 }
3355
Greg Clayton144f3a92011-11-15 03:53:30 +00003356 if (error.Success())
3357 {
Greg Clayton144f3a92011-11-15 03:53:30 +00003358 SetNextEventAction(new Process::AttachCompletionHandler(this, attach_info.GetResumeCount()));
3359 StartPrivateStateThread();
3360 }
3361 else
Greg Claytone996fd32011-03-08 22:40:15 +00003362 {
3363 if (GetID() != LLDB_INVALID_PROCESS_ID)
Greg Claytone996fd32011-03-08 22:40:15 +00003364 SetID (LLDB_INVALID_PROCESS_ID);
Greg Claytone996fd32011-03-08 22:40:15 +00003365
Oleksiy Vyalov5d064742014-11-19 18:27:45 +00003366 const char *error_string = error.AsCString();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003367 if (error_string == nullptr)
Oleksiy Vyalov5d064742014-11-19 18:27:45 +00003368 error_string = "attach failed";
3369
3370 SetExitStatus(-1, error_string);
Greg Claytone996fd32011-03-08 22:40:15 +00003371 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003372 }
3373 }
3374 return error;
3375}
3376
Greg Clayton93d3c8332011-02-16 04:46:07 +00003377void
3378Process::CompleteAttach ()
3379{
Jason Molenda7d002762016-04-07 22:00:55 +00003380 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TARGET));
Todd Fiala76e0fc92014-08-27 22:58:26 +00003381 if (log)
3382 log->Printf ("Process::%s()", __FUNCTION__);
3383
Greg Clayton93d3c8332011-02-16 04:46:07 +00003384 // Let the process subclass figure out at much as it can about the process
3385 // before we go looking for a dynamic loader plug-in.
Jim Inghambb006ce2014-08-02 00:33:35 +00003386 ArchSpec process_arch;
3387 DidAttach(process_arch);
3388
3389 if (process_arch.IsValid())
Todd Fiala76e0fc92014-08-27 22:58:26 +00003390 {
Zachary Turner7529df92015-09-01 20:02:29 +00003391 GetTarget().SetArchitecture(process_arch);
Todd Fiala76e0fc92014-08-27 22:58:26 +00003392 if (log)
3393 {
3394 const char *triple_str = process_arch.GetTriple().getTriple().c_str ();
3395 log->Printf ("Process::%s replacing process architecture with DidAttach() architecture: %s",
3396 __FUNCTION__,
3397 triple_str ? triple_str : "<null>");
3398 }
3399 }
Greg Clayton93d3c8332011-02-16 04:46:07 +00003400
Jim Ingham4299fdb2011-09-15 01:10:17 +00003401 // We just attached. If we have a platform, ask it for the process architecture, and if it isn't
3402 // the same as the one we've already set, switch architectures.
Zachary Turner7529df92015-09-01 20:02:29 +00003403 PlatformSP platform_sp (GetTarget().GetPlatform ());
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003404 assert(platform_sp);
Jim Ingham4299fdb2011-09-15 01:10:17 +00003405 if (platform_sp)
3406 {
Zachary Turner7529df92015-09-01 20:02:29 +00003407 const ArchSpec &target_arch = GetTarget().GetArchitecture();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003408 if (target_arch.IsValid() && !platform_sp->IsCompatibleArchitecture(target_arch, false, nullptr))
Greg Clayton70512312012-05-08 01:45:38 +00003409 {
3410 ArchSpec platform_arch;
3411 platform_sp = platform_sp->GetPlatformForArchitecture (target_arch, &platform_arch);
3412 if (platform_sp)
3413 {
Zachary Turner7529df92015-09-01 20:02:29 +00003414 GetTarget().SetPlatform (platform_sp);
3415 GetTarget().SetArchitecture(platform_arch);
Todd Fiala76e0fc92014-08-27 22:58:26 +00003416 if (log)
3417 log->Printf ("Process::%s switching platform to %s and architecture to %s based on info from attach", __FUNCTION__, platform_sp->GetName().AsCString (""), platform_arch.GetTriple().getTriple().c_str ());
Greg Clayton70512312012-05-08 01:45:38 +00003418 }
3419 }
Jim Inghambb006ce2014-08-02 00:33:35 +00003420 else if (!process_arch.IsValid())
Greg Clayton70512312012-05-08 01:45:38 +00003421 {
3422 ProcessInstanceInfo process_info;
Pavel Labatha933d512016-04-05 13:07:16 +00003423 GetProcessInfo(process_info);
Greg Clayton70512312012-05-08 01:45:38 +00003424 const ArchSpec &process_arch = process_info.GetArchitecture();
Zachary Turner7529df92015-09-01 20:02:29 +00003425 if (process_arch.IsValid() && !GetTarget().GetArchitecture().IsExactMatch(process_arch))
Todd Fiala76e0fc92014-08-27 22:58:26 +00003426 {
Zachary Turner7529df92015-09-01 20:02:29 +00003427 GetTarget().SetArchitecture (process_arch);
Todd Fiala76e0fc92014-08-27 22:58:26 +00003428 if (log)
3429 log->Printf ("Process::%s switching architecture to %s based on info the platform retrieved for pid %" PRIu64, __FUNCTION__, process_arch.GetTriple().getTriple().c_str (), GetID ());
3430 }
Greg Clayton70512312012-05-08 01:45:38 +00003431 }
Jim Ingham4299fdb2011-09-15 01:10:17 +00003432 }
3433
3434 // We have completed the attach, now it is time to find the dynamic loader
Greg Clayton93d3c8332011-02-16 04:46:07 +00003435 // plug-in
Greg Claytonc859e2d2012-02-13 23:10:39 +00003436 DynamicLoader *dyld = GetDynamicLoader ();
3437 if (dyld)
Todd Fiala76e0fc92014-08-27 22:58:26 +00003438 {
Greg Claytonc859e2d2012-02-13 23:10:39 +00003439 dyld->DidAttach();
Todd Fiala76e0fc92014-08-27 22:58:26 +00003440 if (log)
3441 {
Zachary Turner7529df92015-09-01 20:02:29 +00003442 ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();
Todd Fiala76e0fc92014-08-27 22:58:26 +00003443 log->Printf ("Process::%s after DynamicLoader::DidAttach(), target executable is %s (using %s plugin)",
3444 __FUNCTION__,
3445 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>",
3446 dyld->GetPluginName().AsCString ("<unnamed>"));
3447 }
3448 }
Greg Clayton93d3c8332011-02-16 04:46:07 +00003449
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00003450 GetJITLoaders().DidAttach();
Andrew MacPherson17220c12014-03-05 10:12:43 +00003451
Jason Molendaeef51062013-11-05 03:57:19 +00003452 SystemRuntime *system_runtime = GetSystemRuntime ();
3453 if (system_runtime)
Todd Fiala76e0fc92014-08-27 22:58:26 +00003454 {
Jason Molendaeef51062013-11-05 03:57:19 +00003455 system_runtime->DidAttach();
Todd Fiala76e0fc92014-08-27 22:58:26 +00003456 if (log)
3457 {
Zachary Turner7529df92015-09-01 20:02:29 +00003458 ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();
Todd Fiala76e0fc92014-08-27 22:58:26 +00003459 log->Printf ("Process::%s after SystemRuntime::DidAttach(), target executable is %s (using %s plugin)",
3460 __FUNCTION__,
3461 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>",
3462 system_runtime->GetPluginName().AsCString("<unnamed>"));
3463 }
3464 }
Jason Molendaeef51062013-11-05 03:57:19 +00003465
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003466 m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr));
Greg Clayton93d3c8332011-02-16 04:46:07 +00003467 // Figure out which one is the executable, and set that in our target:
Zachary Turner7529df92015-09-01 20:02:29 +00003468 const ModuleList &target_modules = GetTarget().GetImages();
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00003469 std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003470 size_t num_modules = target_modules.GetSize();
3471 ModuleSP new_executable_module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003472
Andy Gibbsa297a972013-06-19 19:04:53 +00003473 for (size_t i = 0; i < num_modules; i++)
Greg Clayton93d3c8332011-02-16 04:46:07 +00003474 {
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003475 ModuleSP module_sp (target_modules.GetModuleAtIndexUnlocked (i));
Greg Clayton8b82f082011-04-12 05:54:46 +00003476 if (module_sp && module_sp->IsExecutable())
Greg Clayton93d3c8332011-02-16 04:46:07 +00003477 {
Zachary Turner7529df92015-09-01 20:02:29 +00003478 if (GetTarget().GetExecutableModulePointer() != module_sp.get())
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003479 new_executable_module_sp = module_sp;
Greg Clayton93d3c8332011-02-16 04:46:07 +00003480 break;
3481 }
3482 }
Jim Ingham3ee12ef2012-05-30 02:19:25 +00003483 if (new_executable_module_sp)
Todd Fiala76e0fc92014-08-27 22:58:26 +00003484 {
Zachary Turner7529df92015-09-01 20:02:29 +00003485 GetTarget().SetExecutableModule (new_executable_module_sp, false);
Todd Fiala76e0fc92014-08-27 22:58:26 +00003486 if (log)
3487 {
Zachary Turner7529df92015-09-01 20:02:29 +00003488 ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();
Todd Fiala76e0fc92014-08-27 22:58:26 +00003489 log->Printf ("Process::%s after looping through modules, target executable is %s",
3490 __FUNCTION__,
3491 exe_module_sp ? exe_module_sp->GetFileSpec().GetPath().c_str () : "<none>");
3492 }
3493 }
Greg Claytona97c4d22014-12-09 23:31:02 +00003494
3495 m_stop_info_override_callback = process_arch.GetStopInfoOverrideCallback();
Greg Clayton93d3c8332011-02-16 04:46:07 +00003496}
3497
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003498Error
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003499Process::ConnectRemote (Stream *strm, const char *remote_url)
Greg Claytonb766a732011-02-04 01:58:07 +00003500{
Greg Claytonb766a732011-02-04 01:58:07 +00003501 m_abi_sp.reset();
3502 m_process_input_reader.reset();
3503
3504 // Find the process and its architecture. Make sure it matches the architecture
3505 // of the current Target, and if not adjust it.
3506
Jason Molenda4bd4e7e2012-09-29 04:02:01 +00003507 Error error (DoConnectRemote (strm, remote_url));
Greg Claytonb766a732011-02-04 01:58:07 +00003508 if (error.Success())
3509 {
Greg Clayton71337622011-02-24 22:24:29 +00003510 if (GetID() != LLDB_INVALID_PROCESS_ID)
3511 {
Greg Clayton32e0a752011-03-30 18:16:51 +00003512 EventSP event_sp;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003513 StateType state = WaitForProcessStopPrivate(nullptr, event_sp);
Greg Clayton32e0a752011-03-30 18:16:51 +00003514
3515 if (state == eStateStopped || state == eStateCrashed)
3516 {
3517 // If we attached and actually have a process on the other end, then
3518 // this ended up being the equivalent of an attach.
3519 CompleteAttach ();
3520
3521 // This delays passing the stopped event to listeners till
3522 // CompleteAttach gets a chance to complete...
3523 HandlePrivateEvent (event_sp);
Greg Clayton32e0a752011-03-30 18:16:51 +00003524 }
Greg Clayton71337622011-02-24 22:24:29 +00003525 }
Greg Clayton32e0a752011-03-30 18:16:51 +00003526
3527 if (PrivateStateThreadIsValid ())
3528 ResumePrivateStateThread ();
3529 else
3530 StartPrivateStateThread ();
Greg Claytonb766a732011-02-04 01:58:07 +00003531 }
3532 return error;
3533}
3534
Greg Claytonb766a732011-02-04 01:58:07 +00003535Error
Jim Ingham3b8285d2012-04-19 01:40:33 +00003536Process::PrivateResume ()
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003537{
Greg Clayton5160ce52013-03-27 23:08:40 +00003538 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_STEP));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003539 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003540 log->Printf("Process::PrivateResume() m_stop_id = %u, public state: %s private state: %s",
Jim Ingham4b536182011-08-09 02:12:22 +00003541 m_mod_id.GetStopID(),
Jim Ingham444586b2011-01-24 06:34:17 +00003542 StateAsCString(m_public_state.GetValue()),
3543 StateAsCString(m_private_state.GetValue()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003544
3545 Error error (WillResume());
3546 // Tell the process it is about to resume before the thread list
3547 if (error.Success())
3548 {
Johnny Chenc4221e42010-12-02 20:53:05 +00003549 // Now let the thread list know we are about to resume so it
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003550 // can let all of our threads know that they are about to be
3551 // resumed. Threads will each be called with
3552 // Thread::WillResume(StateType) where StateType contains the state
3553 // that they are supposed to have when the process is resumed
3554 // (suspended/running/stepping). Threads should also check
3555 // their resume signal in lldb::Thread::GetResumeSignal()
Jim Ingham221d51c2013-05-08 00:35:16 +00003556 // to see if they are supposed to start back up with a signal.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003557 if (m_thread_list.WillResume())
3558 {
Jim Ingham372787f2012-04-07 00:00:41 +00003559 // Last thing, do the PreResumeActions.
3560 if (!RunPreResumeActions())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003561 {
Jim Ingham0161b492013-02-09 01:29:05 +00003562 error.SetErrorStringWithFormat ("Process::PrivateResume PreResumeActions failed, not resuming.");
Jim Ingham372787f2012-04-07 00:00:41 +00003563 }
3564 else
3565 {
3566 m_mod_id.BumpResumeID();
3567 error = DoResume();
3568 if (error.Success())
3569 {
3570 DidResume();
3571 m_thread_list.DidResume();
3572 if (log)
3573 log->Printf ("Process thinks the process has resumed.");
3574 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003575 }
3576 }
3577 else
3578 {
Jim Inghamd5ac1ab2015-01-19 23:51:51 +00003579 // Somebody wanted to run without running (e.g. we were faking a step from one frame of a set of inlined
3580 // frames that share the same PC to another.) So generate a continue & a stopped event,
Jim Ingham513c6bb2012-09-01 01:02:41 +00003581 // and let the world handle them.
3582 if (log)
3583 log->Printf ("Process::PrivateResume() asked to simulate a start & stop.");
3584
3585 SetPrivateState(eStateRunning);
3586 SetPrivateState(eStateStopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003587 }
3588 }
Jim Ingham444586b2011-01-24 06:34:17 +00003589 else if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003590 log->Printf ("Process::PrivateResume() got an error \"%s\".", error.AsCString("<unknown error>"));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003591 return error;
3592}
3593
3594Error
Pavel Labath19da1f12015-12-07 12:36:52 +00003595Process::Halt (bool clear_thread_plans, bool use_run_lock)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003596{
Pavel Labath19da1f12015-12-07 12:36:52 +00003597 if (! StateIsRunningState(m_public_state.GetValue()))
3598 return Error("Process is not running.");
3599
Greg Claytonf9b57b92013-05-10 23:48:10 +00003600 // Don't clear the m_clear_thread_plans_on_stop, only set it to true if
3601 // in case it was already set and some thread plan logic calls halt on its
3602 // own.
3603 m_clear_thread_plans_on_stop |= clear_thread_plans;
3604
Jim Ingham583bbb12016-03-07 21:50:25 +00003605 ListenerSP halt_listener_sp (Listener::MakeListener("lldb.process.halt_listener"));
3606 HijackProcessEvents(halt_listener_sp);
Greg Clayton3af9ea52010-11-18 05:57:03 +00003607
Jim Inghambb3a2832011-01-29 01:49:25 +00003608 EventSP event_sp;
Jim Inghambb3a2832011-01-29 01:49:25 +00003609
Pavel Labath19da1f12015-12-07 12:36:52 +00003610 SendAsyncInterrupt();
3611
3612 if (m_public_state.GetValue() == eStateAttaching)
Jim Inghambb3a2832011-01-29 01:49:25 +00003613 {
Pavel Labath19da1f12015-12-07 12:36:52 +00003614 // Don't hijack and eat the eStateExited as the code that was doing
3615 // the attach will be waiting for this event...
3616 RestoreProcessEvents();
3617 SetExitStatus(SIGKILL, "Cancelled async attach.");
3618 Destroy (false);
3619 return Error();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003620 }
Jim Inghambb3a2832011-01-29 01:49:25 +00003621
Pavel Labath19da1f12015-12-07 12:36:52 +00003622 // Wait for 10 second for the process to stop.
3623 TimeValue timeout_time;
3624 timeout_time = TimeValue::Now();
3625 timeout_time.OffsetWithSeconds(10);
Jim Ingham583bbb12016-03-07 21:50:25 +00003626 StateType state = WaitForProcessToStop(&timeout_time, &event_sp, true, halt_listener_sp,
Pavel Labath19da1f12015-12-07 12:36:52 +00003627 nullptr, use_run_lock);
3628 RestoreProcessEvents();
Jim Inghambb3a2832011-01-29 01:49:25 +00003629
Pavel Labath19da1f12015-12-07 12:36:52 +00003630 if (state == eStateInvalid || ! event_sp)
3631 {
3632 // We timed out and didn't get a stop event...
3633 return Error("Halt timed out. State = %s", StateAsCString(GetState()));
3634 }
3635
3636 BroadcastEvent(event_sp);
3637
3638 return Error();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003639}
3640
3641Error
Pavel Labathfcc7f662015-10-07 15:11:11 +00003642Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp)
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003643{
3644 Error error;
3645 if (m_public_state.GetValue() == eStateRunning)
3646 {
3647 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
3648 if (log)
Pavel Labathfcc7f662015-10-07 15:11:11 +00003649 log->Printf("Process::%s() About to stop.", __FUNCTION__);
3650
Jim Ingham583bbb12016-03-07 21:50:25 +00003651 ListenerSP listener_sp (Listener::MakeListener("lldb.Process.StopForDestroyOrDetach.hijack"));
3652 HijackProcessEvents(listener_sp);
Pavel Labathfcc7f662015-10-07 15:11:11 +00003653
3654 SendAsyncInterrupt();
3655
3656 // Consume the interrupt event.
3657 TimeValue timeout (TimeValue::Now());
3658 timeout.OffsetWithSeconds(10);
3659
Jim Ingham583bbb12016-03-07 21:50:25 +00003660 StateType state = WaitForProcessToStop (&timeout, &exit_event_sp, true, listener_sp);
Pavel Labathfcc7f662015-10-07 15:11:11 +00003661
3662 RestoreProcessEvents();
3663
3664 // If the process exited while we were waiting for it to stop, put the exited event into
3665 // the shared pointer passed in and return. Our caller doesn't need to do anything else, since
3666 // they don't have a process anymore...
3667
3668 if (state == eStateExited || m_private_state.GetValue() == eStateExited)
Pavel Labathc8c77d42015-09-28 09:37:51 +00003669 {
3670 if (log)
Pavel Labathfcc7f662015-10-07 15:11:11 +00003671 log->Printf("Process::%s() Process exited while waiting to stop.", __FUNCTION__);
3672 return error;
3673 }
3674 else
3675 exit_event_sp.reset(); // It is ok to consume any non-exit stop events
3676
3677 if (state != eStateStopped)
3678 {
3679 if (log)
3680 log->Printf("Process::%s() failed to stop, state is: %s", __FUNCTION__, StateAsCString(state));
3681 // If we really couldn't stop the process then we should just error out here, but if the
3682 // lower levels just bobbled sending the event and we really are stopped, then continue on.
3683 StateType private_state = m_private_state.GetValue();
3684 if (private_state != eStateStopped)
3685 {
Jim Ingham1d107722016-06-28 16:35:58 +00003686 return Error("Attempt to stop the target in order to detach timed out. State = %s", StateAsCString(GetState()));
Pavel Labathfcc7f662015-10-07 15:11:11 +00003687 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003688 }
3689 }
3690 return error;
3691}
3692
3693Error
Jim Inghamacff8952013-05-02 00:27:30 +00003694Process::Detach (bool keep_stopped)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003695{
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003696 EventSP exit_event_sp;
3697 Error error;
3698 m_destroy_in_process = true;
3699
3700 error = WillDetach();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003701
3702 if (error.Success())
3703 {
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003704 if (DetachRequiresHalt())
3705 {
Pavel Labathfcc7f662015-10-07 15:11:11 +00003706 error = StopForDestroyOrDetach (exit_event_sp);
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003707 if (!error.Success())
3708 {
3709 m_destroy_in_process = false;
3710 return error;
3711 }
3712 else if (exit_event_sp)
3713 {
3714 // We shouldn't need to do anything else here. There's no process left to detach from...
3715 StopPrivateStateThread();
3716 m_destroy_in_process = false;
3717 return error;
3718 }
3719 }
3720
Andrew MacPhersonc3826b52014-03-25 19:59:36 +00003721 m_thread_list.DiscardThreadPlans();
3722 DisableAllBreakpointSites();
3723
Jim Inghamacff8952013-05-02 00:27:30 +00003724 error = DoDetach(keep_stopped);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003725 if (error.Success())
3726 {
3727 DidDetach();
3728 StopPrivateStateThread();
3729 }
Jim Inghamacff8952013-05-02 00:27:30 +00003730 else
3731 {
3732 return error;
3733 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003734 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003735 m_destroy_in_process = false;
3736
3737 // If we exited when we were waiting for a process to stop, then
3738 // forward the event here so we don't lose the event
3739 if (exit_event_sp)
3740 {
3741 // Directly broadcast our exited event because we shut down our
3742 // private state thread above
3743 BroadcastEvent(exit_event_sp);
3744 }
3745
3746 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3747 // the last events through the event system, in which case we might strand the write lock. Unlock
3748 // it here so when we do to tear down the process we don't get an error destroying the lock.
3749
Ed Maste64fad602013-07-29 20:58:06 +00003750 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003751 return error;
3752}
3753
3754Error
Jason Molendaede31932015-04-17 05:01:58 +00003755Process::Destroy (bool force_kill)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003756{
Pavel Labath19da1f12015-12-07 12:36:52 +00003757
Jim Ingham09437922013-03-01 20:04:25 +00003758 // Tell ourselves we are in the process of destroying the process, so that we don't do any unnecessary work
3759 // that might hinder the destruction. Remember to set this back to false when we are done. That way if the attempt
3760 // failed and the process stays around for some reason it won't be in a confused state.
Jason Molendaede31932015-04-17 05:01:58 +00003761
3762 if (force_kill)
3763 m_should_detach = false;
Jim Ingham09437922013-03-01 20:04:25 +00003764
Ilia Kfcc89a02015-03-26 07:08:47 +00003765 if (GetShouldDetach())
3766 {
3767 // FIXME: This will have to be a process setting:
3768 bool keep_stopped = false;
3769 Detach(keep_stopped);
3770 }
3771
Jim Ingham09437922013-03-01 20:04:25 +00003772 m_destroy_in_process = true;
3773
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003774 Error error (WillDestroy());
3775 if (error.Success())
3776 {
Greg Clayton85fb1b92012-09-11 02:33:37 +00003777 EventSP exit_event_sp;
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003778 if (DestroyRequiresHalt())
Jim Ingham04e0a222012-05-23 15:46:31 +00003779 {
Pavel Labathfcc7f662015-10-07 15:11:11 +00003780 error = StopForDestroyOrDetach(exit_event_sp);
Jim Ingham04e0a222012-05-23 15:46:31 +00003781 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003782
Jim Inghamaacc3182012-06-06 00:29:30 +00003783 if (m_public_state.GetValue() != eStateRunning)
3784 {
3785 // Ditch all thread plans, and remove all our breakpoints: in case we have to restart the target to
3786 // kill it, we don't want it hitting a breakpoint...
3787 // Only do this if we've stopped, however, since if we didn't manage to halt it above, then
3788 // we're not going to have much luck doing this now.
3789 m_thread_list.DiscardThreadPlans();
3790 DisableAllBreakpointSites();
3791 }
Jim Ingham8af3b9c2013-03-29 01:18:12 +00003792
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003793 error = DoDestroy();
3794 if (error.Success())
3795 {
3796 DidDestroy();
3797 StopPrivateStateThread();
3798 }
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003799 m_stdio_communication.Disconnect();
Greg Clayton23d54f42015-06-03 00:34:01 +00003800 m_stdio_communication.StopReadThread();
Vince Harrondf3f00f2015-02-10 21:09:04 +00003801 m_stdin_forward = false;
Greg Claytonb4874f12014-02-28 18:22:24 +00003802
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003803 if (m_process_input_reader)
Greg Claytonb4874f12014-02-28 18:22:24 +00003804 {
3805 m_process_input_reader->SetIsDone(true);
3806 m_process_input_reader->Cancel();
Caroline Ticeef5c6d02010-11-16 05:07:41 +00003807 m_process_input_reader.reset();
Greg Claytonb4874f12014-02-28 18:22:24 +00003808 }
3809
Greg Clayton85fb1b92012-09-11 02:33:37 +00003810 // If we exited when we were waiting for a process to stop, then
3811 // forward the event here so we don't lose the event
3812 if (exit_event_sp)
3813 {
3814 // Directly broadcast our exited event because we shut down our
3815 // private state thread above
3816 BroadcastEvent(exit_event_sp);
3817 }
3818
Jim Inghamb1e2e842012-04-12 18:49:31 +00003819 // If we have been interrupted (to kill us) in the middle of running, we may not end up propagating
3820 // the last events through the event system, in which case we might strand the write lock. Unlock
3821 // it here so when we do to tear down the process we don't get an error destroying the lock.
Ed Maste64fad602013-07-29 20:58:06 +00003822 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003823 }
Jim Ingham09437922013-03-01 20:04:25 +00003824
3825 m_destroy_in_process = false;
3826
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003827 return error;
3828}
3829
3830Error
3831Process::Signal (int signal)
3832{
3833 Error error (WillSignal());
3834 if (error.Success())
3835 {
3836 error = DoSignal(signal);
3837 if (error.Success())
3838 DidSignal();
3839 }
3840 return error;
3841}
3842
Zachary Turner93749ab2015-03-03 21:51:25 +00003843void
Chaoren Linc963a222015-09-01 16:58:45 +00003844Process::SetUnixSignals(UnixSignalsSP &&signals_sp)
Zachary Turner93749ab2015-03-03 21:51:25 +00003845{
3846 assert (signals_sp && "null signals_sp");
3847 m_unix_signals_sp = signals_sp;
3848}
3849
Chaoren Lin98d0a4b2015-07-14 01:09:28 +00003850const lldb::UnixSignalsSP &
Zachary Turner93749ab2015-03-03 21:51:25 +00003851Process::GetUnixSignals ()
3852{
3853 assert (m_unix_signals_sp && "null m_unix_signals_sp");
Chaoren Lin98d0a4b2015-07-14 01:09:28 +00003854 return m_unix_signals_sp;
Zachary Turner93749ab2015-03-03 21:51:25 +00003855}
3856
Greg Clayton514487e2011-02-15 21:59:32 +00003857lldb::ByteOrder
3858Process::GetByteOrder () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003859{
Zachary Turner7529df92015-09-01 20:02:29 +00003860 return GetTarget().GetArchitecture().GetByteOrder();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003861}
3862
3863uint32_t
Greg Clayton514487e2011-02-15 21:59:32 +00003864Process::GetAddressByteSize () const
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003865{
Zachary Turner7529df92015-09-01 20:02:29 +00003866 return GetTarget().GetArchitecture().GetAddressByteSize();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003867}
3868
3869bool
3870Process::ShouldBroadcastEvent (Event *event_ptr)
3871{
3872 const StateType state = Process::ProcessEventData::GetStateFromEvent (event_ptr);
3873 bool return_value = true;
Greg Clayton5160ce52013-03-27 23:08:40 +00003874 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS | LIBLLDB_LOG_PROCESS));
Jim Ingham0161b492013-02-09 01:29:05 +00003875
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003876 switch (state)
3877 {
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003878 case eStateDetached:
3879 case eStateExited:
3880 case eStateUnloaded:
Pavel Labath3f5df532015-03-12 10:12:41 +00003881 m_stdio_communication.SynchronizeWithReadThread();
Pavel Labatha9a43372015-09-03 09:30:17 +00003882 m_stdio_communication.Disconnect();
3883 m_stdio_communication.StopReadThread();
3884 m_stdin_forward = false;
3885
Jason Molenda62e06812016-02-16 04:14:33 +00003886 LLVM_FALLTHROUGH;
Pavel Labath3f5df532015-03-12 10:12:41 +00003887 case eStateConnected:
3888 case eStateAttaching:
3889 case eStateLaunching:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003890 // These events indicate changes in the state of the debugging session, always report them.
3891 return_value = true;
3892 break;
3893 case eStateInvalid:
3894 // We stopped for no apparent reason, don't report it.
3895 return_value = false;
3896 break;
3897 case eStateRunning:
3898 case eStateStepping:
3899 // If we've started the target running, we handle the cases where we
3900 // are already running and where there is a transition from stopped to
3901 // running differently.
3902 // running -> running: Automatically suppress extra running events
3903 // stopped -> running: Report except when there is one or more no votes
3904 // and no yes votes.
3905 SynchronouslyNotifyStateChanged (state);
Jim Ingham1460e4b2014-01-10 23:46:59 +00003906 if (m_force_next_event_delivery)
3907 return_value = true;
3908 else
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003909 {
Jim Ingham1460e4b2014-01-10 23:46:59 +00003910 switch (m_last_broadcast_state)
3911 {
3912 case eStateRunning:
3913 case eStateStepping:
3914 // We always suppress multiple runnings with no PUBLIC stop in between.
3915 return_value = false;
3916 break;
3917 default:
3918 // TODO: make this work correctly. For now always report
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00003919 // run if we aren't running so we don't miss any running
Jim Ingham1460e4b2014-01-10 23:46:59 +00003920 // events. If I run the lldb/test/thread/a.out file and
3921 // break at main.cpp:58, run and hit the breakpoints on
3922 // multiple threads, then somehow during the stepping over
3923 // of all breakpoints no run gets reported.
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003924
Jim Ingham1460e4b2014-01-10 23:46:59 +00003925 // This is a transition from stop to run.
3926 switch (m_thread_list.ShouldReportRun (event_ptr))
3927 {
3928 case eVoteYes:
3929 case eVoteNoOpinion:
3930 return_value = true;
3931 break;
3932 case eVoteNo:
3933 return_value = false;
3934 break;
3935 }
3936 break;
3937 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003938 }
3939 break;
3940 case eStateStopped:
3941 case eStateCrashed:
3942 case eStateSuspended:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003943 // We've stopped. First see if we're going to restart the target.
3944 // If we are going to stop, then we always broadcast the event.
3945 // If we aren't going to stop, let the thread plans decide if we're going to report this event.
Jim Inghamb01e7422010-06-19 04:45:32 +00003946 // If no thread has an opinion, we don't report it.
Jim Ingham221d51c2013-05-08 00:35:16 +00003947
Pavel Labath3f5df532015-03-12 10:12:41 +00003948 m_stdio_communication.SynchronizeWithReadThread();
Jim Inghamcb4ca112012-05-16 01:32:14 +00003949 RefreshStateAfterStop ();
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003950 if (ProcessEventData::GetInterruptedFromEvent (event_ptr))
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003951 {
Greg Clayton3af9ea52010-11-18 05:57:03 +00003952 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00003953 log->Printf ("Process::ShouldBroadcastEvent (%p) stopped due to an interrupt, state: %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003954 static_cast<void*>(event_ptr),
Jim Ingham0161b492013-02-09 01:29:05 +00003955 StateAsCString(state));
Jim Ingham35878c42014-04-08 21:33:21 +00003956 // Even though we know we are going to stop, we should let the threads have a look at the stop,
3957 // so they can properly set their state.
3958 m_thread_list.ShouldStop (event_ptr);
Jim Ingham0161b492013-02-09 01:29:05 +00003959 return_value = true;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00003960 }
3961 else
3962 {
Jim Ingham221d51c2013-05-08 00:35:16 +00003963 bool was_restarted = ProcessEventData::GetRestartedFromEvent (event_ptr);
3964 bool should_resume = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003965
Jim Ingham0161b492013-02-09 01:29:05 +00003966 // It makes no sense to ask "ShouldStop" if we've already been restarted...
3967 // Asking the thread list is also not likely to go well, since we are running again.
3968 // So in that case just report the event.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003969
Jim Ingham0161b492013-02-09 01:29:05 +00003970 if (!was_restarted)
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00003971 should_resume = !m_thread_list.ShouldStop(event_ptr);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003972
Jim Ingham221d51c2013-05-08 00:35:16 +00003973 if (was_restarted || should_resume || m_resume_requested)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003974 {
Jim Ingham0161b492013-02-09 01:29:05 +00003975 Vote stop_vote = m_thread_list.ShouldReportStop (event_ptr);
3976 if (log)
Pavel Labath2acc4882016-01-05 17:55:32 +00003977 log->Printf ("Process::ShouldBroadcastEvent: should_resume: %i state: %s was_restarted: %i stop_vote: %d.",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003978 should_resume, StateAsCString(state),
3979 was_restarted, stop_vote);
3980
Jim Ingham0161b492013-02-09 01:29:05 +00003981 switch (stop_vote)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003982 {
3983 case eVoteYes:
Jim Ingham0161b492013-02-09 01:29:05 +00003984 return_value = true;
3985 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003986 case eVoteNoOpinion:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00003987 case eVoteNo:
3988 return_value = false;
3989 break;
3990 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003991
Jim Inghamcb95f342012-09-05 21:13:56 +00003992 if (!was_restarted)
Jim Ingham0161b492013-02-09 01:29:05 +00003993 {
3994 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00003995 log->Printf ("Process::ShouldBroadcastEvent (%p) Restarting process from state: %s",
3996 static_cast<void*>(event_ptr),
3997 StateAsCString(state));
Jim Ingham0161b492013-02-09 01:29:05 +00003998 ProcessEventData::SetRestartedInEvent(event_ptr, true);
Jim Inghamcb95f342012-09-05 21:13:56 +00003999 PrivateResume ();
Jim Ingham0161b492013-02-09 01:29:05 +00004000 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004001 }
4002 else
4003 {
4004 return_value = true;
4005 SynchronouslyNotifyStateChanged (state);
4006 }
4007 }
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004008 break;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004009 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004010
Jim Ingham1460e4b2014-01-10 23:46:59 +00004011 // Forcing the next event delivery is a one shot deal. So reset it here.
4012 m_force_next_event_delivery = false;
4013
Jim Ingham0161b492013-02-09 01:29:05 +00004014 // We do some coalescing of events (for instance two consecutive running events get coalesced.)
4015 // But we only coalesce against events we actually broadcast. So we use m_last_broadcast_state
4016 // to track that. NB - you can't use "m_public_state.GetValue()" for that purpose, as was originally done,
4017 // because the PublicState reflects the last event pulled off the queue, and there may be several
4018 // events stacked up on the queue unserviced. So the PublicState may not reflect the last broadcasted event
4019 // yet. m_last_broadcast_state gets updated here.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004020
Jim Ingham0161b492013-02-09 01:29:05 +00004021 if (return_value)
4022 m_last_broadcast_state = state;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004023
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004024 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00004025 log->Printf ("Process::ShouldBroadcastEvent (%p) => new state: %s, last broadcast state: %s - %s",
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004026 static_cast<void*>(event_ptr), StateAsCString(state),
Jim Ingham0161b492013-02-09 01:29:05 +00004027 StateAsCString(m_last_broadcast_state),
4028 return_value ? "YES" : "NO");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004029 return return_value;
4030}
4031
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004032bool
Jim Ingham60c915e2015-06-23 21:02:45 +00004033Process::StartPrivateStateThread (bool is_secondary_thread)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004034{
Greg Clayton5160ce52013-03-27 23:08:40 +00004035 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004036
Greg Clayton8b82f082011-04-12 05:54:46 +00004037 bool already_running = PrivateStateThreadIsValid ();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004038 if (log)
Greg Clayton8b82f082011-04-12 05:54:46 +00004039 log->Printf ("Process::%s()%s ", __FUNCTION__, already_running ? " already running" : " starting private state thread");
4040
Jim Ingham60c915e2015-06-23 21:02:45 +00004041 if (!is_secondary_thread && already_running)
Greg Clayton8b82f082011-04-12 05:54:46 +00004042 return true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004043
4044 // Create a thread that watches our internal state and controls which
4045 // events make it to clients (into the DCProcess event queue).
Greg Clayton3e06bd92011-01-09 21:07:35 +00004046 char thread_name[1024];
Todd Fiala17096d72014-07-16 19:03:16 +00004047
Zachary Turner39de3112014-09-09 20:54:56 +00004048 if (HostInfo::GetMaxThreadNameLength() <= 30)
Todd Fiala17096d72014-07-16 19:03:16 +00004049 {
Zachary Turner39de3112014-09-09 20:54:56 +00004050 // On platforms with abbreviated thread name lengths, choose thread names that fit within the limit.
4051 if (already_running)
4052 snprintf(thread_name, sizeof(thread_name), "intern-state-OV");
4053 else
4054 snprintf(thread_name, sizeof(thread_name), "intern-state");
Todd Fiala17096d72014-07-16 19:03:16 +00004055 }
Jim Ingham372787f2012-04-07 00:00:41 +00004056 else
Todd Fiala17096d72014-07-16 19:03:16 +00004057 {
4058 if (already_running)
Zachary Turner39de3112014-09-09 20:54:56 +00004059 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
Todd Fiala17096d72014-07-16 19:03:16 +00004060 else
Zachary Turner39de3112014-09-09 20:54:56 +00004061 snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
Todd Fiala17096d72014-07-16 19:03:16 +00004062 }
4063
Jim Ingham076b3042012-04-10 01:21:57 +00004064 // Create the private state thread, and start it running.
Jim Inghama1ca8142016-02-04 01:34:33 +00004065 PrivateStateThreadArgs *args_ptr = new PrivateStateThreadArgs(this, is_secondary_thread);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004066 m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, (void *) args_ptr, nullptr, 8 * 1024 * 1024);
Zachary Turneracee96a2014-09-23 18:32:09 +00004067 if (m_private_state_thread.IsJoinable())
Jim Ingham076b3042012-04-10 01:21:57 +00004068 {
4069 ResumePrivateStateThread();
4070 return true;
4071 }
4072 else
4073 return false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004074}
4075
4076void
4077Process::PausePrivateStateThread ()
4078{
4079 ControlPrivateStateThread (eBroadcastInternalStateControlPause);
4080}
4081
4082void
4083Process::ResumePrivateStateThread ()
4084{
4085 ControlPrivateStateThread (eBroadcastInternalStateControlResume);
4086}
4087
4088void
4089Process::StopPrivateStateThread ()
4090{
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004091 if (m_private_state_thread.IsJoinable ())
Greg Clayton8b82f082011-04-12 05:54:46 +00004092 ControlPrivateStateThread (eBroadcastInternalStateControlStop);
Jim Inghamb1e2e842012-04-12 18:49:31 +00004093 else
4094 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004095 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Jim Inghamb1e2e842012-04-12 18:49:31 +00004096 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00004097 log->Printf ("Went to stop the private state thread, but it was already invalid.");
Jim Inghamb1e2e842012-04-12 18:49:31 +00004098 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004099}
4100
4101void
4102Process::ControlPrivateStateThread (uint32_t signal)
4103{
Greg Clayton5160ce52013-03-27 23:08:40 +00004104 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004105
4106 assert (signal == eBroadcastInternalStateControlStop ||
4107 signal == eBroadcastInternalStateControlPause ||
4108 signal == eBroadcastInternalStateControlResume);
4109
4110 if (log)
Greg Clayton7ecb3a02011-01-22 17:43:17 +00004111 log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004112
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004113 // Signal the private state thread
4114 if (m_private_state_thread.IsJoinable())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004115 {
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004116 // Broadcast the event.
4117 // It is important to do this outside of the if below, because
4118 // it's possible that the thread state is invalid but that the
4119 // thread is waiting on a control event instead of simply being
4120 // on its way out (this should not happen, but it apparently can).
4121 if (log)
4122 log->Printf ("Sending control event of type: %d.", signal);
4123 std::shared_ptr<EventDataReceipt> event_receipt_sp(new EventDataReceipt());
4124 m_private_state_control_broadcaster.BroadcastEvent(signal, event_receipt_sp);
Greg Clayton1e20f022016-05-12 22:58:52 +00004125
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004126 // Wait for the event receipt or for the private state thread to exit
4127 bool receipt_received = false;
4128 if (PrivateStateThreadIsValid())
4129 {
Greg Clayton1e20f022016-05-12 22:58:52 +00004130 while (!receipt_received)
Jim Inghamb1e2e842012-04-12 18:49:31 +00004131 {
Greg Clayton1e20f022016-05-12 22:58:52 +00004132 bool timed_out = false;
4133 TimeValue timeout_time;
4134 timeout_time = TimeValue::Now();
4135 timeout_time.OffsetWithSeconds(2);
4136 // Check for a receipt for 2 seconds and then check if the private state
4137 // thread is still around.
4138 receipt_received = event_receipt_sp->WaitForEventReceived (&timeout_time, &timed_out);
4139 if (!receipt_received)
4140 {
4141 // Check if the private state thread is still around. If it isn't then we are done waiting
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004142 if (!PrivateStateThreadIsValid())
4143 break; // Private state thread exited or is exiting, we are done
Greg Clayton1e20f022016-05-12 22:58:52 +00004144 }
Jim Inghamb1e2e842012-04-12 18:49:31 +00004145 }
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004146 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004147
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004148 if (signal == eBroadcastInternalStateControlStop)
Greg Clayton1e20f022016-05-12 22:58:52 +00004149 {
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004150 thread_result_t result = NULL;
4151 m_private_state_thread.Join(&result);
4152 m_private_state_thread.Reset();
Greg Clayton1e20f022016-05-12 22:58:52 +00004153 }
Jim Inghamb1e2e842012-04-12 18:49:31 +00004154 }
Cameron Desrochers2c00fc42016-06-14 16:22:45 +00004155 else
4156 {
4157 if (log)
4158 log->Printf("Private state thread already dead, no need to signal it to stop.");
4159 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004160}
4161
4162void
Jim Inghamcfc09352012-07-27 23:57:19 +00004163Process::SendAsyncInterrupt ()
4164{
4165 if (PrivateStateThreadIsValid())
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004166 m_private_state_broadcaster.BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
Jim Inghamcfc09352012-07-27 23:57:19 +00004167 else
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004168 BroadcastEvent(Process::eBroadcastBitInterrupt, nullptr);
Jim Inghamcfc09352012-07-27 23:57:19 +00004169}
4170
4171void
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004172Process::HandlePrivateEvent (EventSP &event_sp)
4173{
Greg Clayton5160ce52013-03-27 23:08:40 +00004174 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Jim Ingham221d51c2013-05-08 00:35:16 +00004175 m_resume_requested = false;
4176
Greg Clayton414f5d32011-01-25 02:58:48 +00004177 const StateType new_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Inghambb3a2832011-01-29 01:49:25 +00004178
4179 // First check to see if anybody wants a shot at this event:
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004180 if (m_next_event_action_ap)
Jim Inghambb3a2832011-01-29 01:49:25 +00004181 {
Jim Ingham754ab982011-01-29 04:05:41 +00004182 NextEventAction::EventActionResult action_result = m_next_event_action_ap->PerformAction(event_sp);
Jim Ingham0161b492013-02-09 01:29:05 +00004183 if (log)
4184 log->Printf ("Ran next event action, result was %d.", action_result);
4185
Jim Inghambb3a2832011-01-29 01:49:25 +00004186 switch (action_result)
4187 {
4188 case NextEventAction::eEventActionSuccess:
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004189 SetNextEventAction(nullptr);
Jim Inghambb3a2832011-01-29 01:49:25 +00004190 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00004191
Jim Inghambb3a2832011-01-29 01:49:25 +00004192 case NextEventAction::eEventActionRetry:
4193 break;
Greg Claytonc9ed4782011-11-12 02:10:56 +00004194
Jim Inghambb3a2832011-01-29 01:49:25 +00004195 case NextEventAction::eEventActionExit:
Jim Ingham2a5fdd42011-01-29 01:57:31 +00004196 // Handle Exiting Here. If we already got an exited event,
4197 // we should just propagate it. Otherwise, swallow this event,
4198 // and set our state to exit so the next event will kill us.
4199 if (new_state != eStateExited)
4200 {
4201 // FIXME: should cons up an exited event, and discard this one.
Jim Ingham754ab982011-01-29 04:05:41 +00004202 SetExitStatus(0, m_next_event_action_ap->GetExitString());
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004203 SetNextEventAction(nullptr);
Jim Ingham2a5fdd42011-01-29 01:57:31 +00004204 return;
4205 }
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004206 SetNextEventAction(nullptr);
Jim Inghambb3a2832011-01-29 01:49:25 +00004207 break;
4208 }
4209 }
4210
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004211 // See if we should broadcast this state to external clients?
4212 const bool should_broadcast = ShouldBroadcastEvent (event_sp.get());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004213
4214 if (should_broadcast)
4215 {
Greg Claytonb4874f12014-02-28 18:22:24 +00004216 const bool is_hijacked = IsHijackedForEvent(eBroadcastBitStateChanged);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004217 if (log)
4218 {
Daniel Malead01b2952012-11-29 21:49:15 +00004219 log->Printf ("Process::%s (pid = %" PRIu64 ") broadcasting new state %s (old state %s) to %s",
Greg Clayton414f5d32011-01-25 02:58:48 +00004220 __FUNCTION__,
4221 GetID(),
4222 StateAsCString(new_state),
4223 StateAsCString (GetState ()),
Greg Claytonb4874f12014-02-28 18:22:24 +00004224 is_hijacked ? "hijacked" : "public");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004225 }
Jim Ingham9575d842011-03-11 03:53:59 +00004226 Process::ProcessEventData::SetUpdateStateOnRemoval(event_sp.get());
Greg Clayton414f5d32011-01-25 02:58:48 +00004227 if (StateIsRunningState (new_state))
Greg Clayton44d93782014-01-27 23:43:24 +00004228 {
4229 // Only push the input handler if we aren't fowarding events,
4230 // as this means the curses GUI is in use...
Todd Fialaf72fa672014-10-07 16:05:21 +00004231 // Or don't push it if we are launching since it will come up stopped.
Zachary Turnerc62733b2015-05-20 18:31:17 +00004232 if (!GetTarget().GetDebugger().IsForwardingEvents() && new_state != eStateLaunching &&
4233 new_state != eStateAttaching)
Pavel Labath44464872015-05-27 12:40:32 +00004234 {
Greg Clayton44d93782014-01-27 23:43:24 +00004235 PushProcessIOHandler ();
Pavel Labath44464872015-05-27 12:40:32 +00004236 m_iohandler_sync.SetValue(m_iohandler_sync.GetValue()+1, eBroadcastAlways);
4237 if (log)
4238 log->Printf("Process::%s updated m_iohandler_sync to %d", __FUNCTION__, m_iohandler_sync.GetValue());
4239 }
Greg Clayton44d93782014-01-27 23:43:24 +00004240 }
Greg Claytonb4874f12014-02-28 18:22:24 +00004241 else if (StateIsStoppedState(new_state, false))
4242 {
4243 if (!Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
4244 {
4245 // If the lldb_private::Debugger is handling the events, we don't
4246 // want to pop the process IOHandler here, we want to do it when
4247 // we receive the stopped event so we can carefully control when
4248 // the process IOHandler is popped because when we stop we want to
4249 // display some text stating how and why we stopped, then maybe some
4250 // process/thread/frame info, and then we want the "(lldb) " prompt
4251 // to show up. If we pop the process IOHandler here, then we will
4252 // cause the command interpreter to become the top IOHandler after
4253 // the process pops off and it will update its prompt right away...
4254 // See the Debugger.cpp file where it calls the function as
4255 // "process_sp->PopProcessIOHandler()" to see where I am talking about.
4256 // Otherwise we end up getting overlapping "(lldb) " prompts and
4257 // garbled output.
4258 //
4259 // If we aren't handling the events in the debugger (which is indicated
4260 // by "m_target.GetDebugger().IsHandlingEvents()" returning false) or we
4261 // are hijacked, then we always pop the process IO handler manually.
4262 // Hijacking happens when the internal process state thread is running
4263 // thread plans, or when commands want to run in synchronous mode
4264 // and they call "process->WaitForProcessToStop()". An example of something
4265 // that will hijack the events is a simple expression:
4266 //
4267 // (lldb) expr (int)puts("hello")
4268 //
4269 // This will cause the internal process state thread to resume and halt
4270 // the process (and _it_ will hijack the eBroadcastBitStateChanged
4271 // events) and we do need the IO handler to be pushed and popped
4272 // correctly.
4273
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004274 if (is_hijacked || !GetTarget().GetDebugger().IsHandlingEvents())
Greg Claytonb4874f12014-02-28 18:22:24 +00004275 PopProcessIOHandler ();
4276 }
4277 }
Jim Ingham9575d842011-03-11 03:53:59 +00004278
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004279 BroadcastEvent (event_sp);
4280 }
4281 else
4282 {
4283 if (log)
4284 {
Daniel Malead01b2952012-11-29 21:49:15 +00004285 log->Printf ("Process::%s (pid = %" PRIu64 ") suppressing state %s (old state %s): should_broadcast == false",
Greg Clayton414f5d32011-01-25 02:58:48 +00004286 __FUNCTION__,
4287 GetID(),
4288 StateAsCString(new_state),
Jason Molendafd54b362011-09-20 21:44:10 +00004289 StateAsCString (GetState ()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004290 }
4291 }
Pavel Labath19da1f12015-12-07 12:36:52 +00004292}
4293
4294Error
4295Process::HaltPrivate()
4296{
4297 EventSP event_sp;
4298 Error error (WillHalt());
4299 if (error.Fail())
4300 return error;
4301
4302 // Ask the process subclass to actually halt our process
4303 bool caused_stop;
4304 error = DoHalt(caused_stop);
4305
4306 DidHalt();
4307 return error;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004308}
4309
Virgile Bellob2f1fb22013-08-23 12:44:05 +00004310thread_result_t
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004311Process::PrivateStateThread (void *arg)
4312{
Jim Inghama1ca8142016-02-04 01:34:33 +00004313 PrivateStateThreadArgs real_args = *static_cast<PrivateStateThreadArgs *> (arg);
4314 free (arg);
4315 thread_result_t result = real_args.process->RunPrivateStateThread(real_args.is_secondary_thread);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004316 return result;
4317}
4318
Virgile Bellob2f1fb22013-08-23 12:44:05 +00004319thread_result_t
Jim Ingham60c915e2015-06-23 21:02:45 +00004320Process::RunPrivateStateThread (bool is_secondary_thread)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004321{
Jim Ingham076b3042012-04-10 01:21:57 +00004322 bool control_only = true;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004323
Greg Clayton5160ce52013-03-27 23:08:40 +00004324 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004325 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004326 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread starting...",
4327 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004328
4329 bool exit_now = false;
Pavel Labath19da1f12015-12-07 12:36:52 +00004330 bool interrupt_requested = false;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004331 while (!exit_now)
4332 {
4333 EventSP event_sp;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004334 WaitForEventsPrivate(nullptr, event_sp, control_only);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004335 if (event_sp->BroadcasterIs(&m_private_state_control_broadcaster))
4336 {
Jim Inghamb1e2e842012-04-12 18:49:31 +00004337 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004338 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") got a control event: %d",
4339 __FUNCTION__, static_cast<void*>(this), GetID(),
4340 event_sp->GetType());
Jim Inghamb1e2e842012-04-12 18:49:31 +00004341
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004342 switch (event_sp->GetType())
4343 {
4344 case eBroadcastInternalStateControlStop:
4345 exit_now = true;
Bruce Mitchenerd93c4a32014-07-01 21:22:11 +00004346 break; // doing any internal state management below
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004347
4348 case eBroadcastInternalStateControlPause:
4349 control_only = true;
4350 break;
4351
4352 case eBroadcastInternalStateControlResume:
4353 control_only = false;
4354 break;
4355 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004356
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004357 continue;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004358 }
Jim Inghamcfc09352012-07-27 23:57:19 +00004359 else if (event_sp->GetType() == eBroadcastBitInterrupt)
4360 {
4361 if (m_public_state.GetValue() == eStateAttaching)
4362 {
4363 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004364 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt while attaching - forwarding interrupt.",
4365 __FUNCTION__, static_cast<void*>(this),
4366 GetID());
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004367 BroadcastEvent(eBroadcastBitInterrupt, nullptr);
Jim Inghamcfc09352012-07-27 23:57:19 +00004368 }
Pavel Labath19da1f12015-12-07 12:36:52 +00004369 else if(StateIsRunningState(m_last_broadcast_state))
Jim Inghamcfc09352012-07-27 23:57:19 +00004370 {
4371 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004372 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") woke up with an interrupt - Halting.",
4373 __FUNCTION__, static_cast<void*>(this),
4374 GetID());
Pavel Labath19da1f12015-12-07 12:36:52 +00004375 Error error = HaltPrivate();
4376 if (error.Fail() && log)
4377 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") failed to halt the process: %s",
4378 __FUNCTION__, static_cast<void*>(this),
4379 GetID(), error.AsCString());
4380 // Halt should generate a stopped event. Make a note of the fact that we were
4381 // doing the interrupt, so we can set the interrupted flag after we receive the
4382 // event. We deliberately set this to true even if HaltPrivate failed, so that we
4383 // can interrupt on the next natural stop.
4384 interrupt_requested = true;
4385 }
4386 else
4387 {
4388 // This can happen when someone (e.g. Process::Halt) sees that we are running and
4389 // sends an interrupt request, but the process actually stops before we receive
4390 // it. In that case, we can just ignore the request. We use
4391 // m_last_broadcast_state, because the Stopped event may not have been popped of
4392 // the event queue yet, which is when the public state gets updated.
4393 if (log)
4394 log->Printf("Process::%s ignoring interrupt as we have already stopped.", __FUNCTION__);
Jim Inghamcfc09352012-07-27 23:57:19 +00004395 }
4396 continue;
4397 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004398
4399 const StateType internal_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
4400
4401 if (internal_state != eStateInvalid)
4402 {
Greg Claytonf9b57b92013-05-10 23:48:10 +00004403 if (m_clear_thread_plans_on_stop &&
4404 StateIsStoppedState(internal_state, true))
4405 {
4406 m_clear_thread_plans_on_stop = false;
4407 m_thread_list.DiscardThreadPlans();
4408 }
Pavel Labath19da1f12015-12-07 12:36:52 +00004409
4410 if (interrupt_requested)
4411 {
4412 if (StateIsStoppedState (internal_state, true))
4413 {
4414 // We requested the interrupt, so mark this as such in the stop event so
4415 // clients can tell an interrupted process from a natural stop
4416 ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);
4417 interrupt_requested = false;
4418 }
4419 else if (log)
4420 {
4421 log->Printf("Process::%s interrupt_requested, but a non-stopped state '%s' received.",
4422 __FUNCTION__, StateAsCString(internal_state));
4423 }
4424 }
4425
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004426 HandlePrivateEvent (event_sp);
4427 }
4428
Greg Clayton58d1c9a2010-10-18 04:14:23 +00004429 if (internal_state == eStateInvalid ||
4430 internal_state == eStateExited ||
4431 internal_state == eStateDetached )
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004432 {
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004433 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004434 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") about to exit with internal state %s...",
4435 __FUNCTION__, static_cast<void*>(this), GetID(),
4436 StateAsCString(internal_state));
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004437
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004438 break;
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004439 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004440 }
4441
Caroline Tice20ad3c42010-10-29 21:48:37 +00004442 // Verify log is still enabled before attempting to write to it...
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004443 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004444 log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") thread exiting...",
4445 __FUNCTION__, static_cast<void*>(this), GetID());
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004446
Jim Ingham60c915e2015-06-23 21:02:45 +00004447 // If we are a secondary thread, then the primary thread we are working for will have already
4448 // acquired the public_run_lock, and isn't done with what it was doing yet, so don't
4449 // try to change it on the way out.
4450 if (!is_secondary_thread)
4451 m_public_run_lock.SetStopped();
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004452 return NULL;
4453}
4454
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004455//------------------------------------------------------------------
4456// Process Event Data
4457//------------------------------------------------------------------
4458
4459Process::ProcessEventData::ProcessEventData () :
4460 EventData (),
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004461 m_process_wp (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004462 m_state (eStateInvalid),
Greg Claytonc982c762010-07-09 20:39:50 +00004463 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004464 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004465 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004466{
4467}
4468
4469Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateType state) :
4470 EventData (),
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004471 m_process_wp (),
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004472 m_state (state),
Greg Claytonc982c762010-07-09 20:39:50 +00004473 m_restarted (false),
Jim Inghama8604692011-05-22 21:45:01 +00004474 m_update_state (0),
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004475 m_interrupted (false)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004476{
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004477 if (process_sp)
4478 m_process_wp = process_sp;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004479}
4480
Eugene Zelenko8f30a652015-10-23 18:39:37 +00004481Process::ProcessEventData::~ProcessEventData() = default;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004482
4483const ConstString &
4484Process::ProcessEventData::GetFlavorString ()
4485{
4486 static ConstString g_flavor ("Process::ProcessEventData");
4487 return g_flavor;
4488}
4489
4490const ConstString &
4491Process::ProcessEventData::GetFlavor () const
4492{
4493 return ProcessEventData::GetFlavorString ();
4494}
4495
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004496void
4497Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
4498{
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004499 ProcessSP process_sp(m_process_wp.lock());
4500
4501 if (!process_sp)
4502 return;
4503
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004504 // This function gets called twice for each event, once when the event gets pulled
Jim Inghama8604692011-05-22 21:45:01 +00004505 // off of the private process event queue, and then any number of times, first when it gets pulled off of
4506 // the public event queue, then other times when we're pretending that this is where we stopped at the
4507 // end of expression evaluation. m_update_state is used to distinguish these
4508 // three cases; it is 0 when we're just pulling it off for private handling,
Jim Ingham221d51c2013-05-08 00:35:16 +00004509 // and > 1 for expression evaluation, and we don't want to do the breakpoint command handling then.
Jim Inghama8604692011-05-22 21:45:01 +00004510 if (m_update_state != 1)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004511 return;
Jim Ingham0161b492013-02-09 01:29:05 +00004512
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004513 process_sp->SetPublicState (m_state, Process::ProcessEventData::GetRestartedFromEvent(event_ptr));
Jim Ingham35878c42014-04-08 21:33:21 +00004514
4515 // If this is a halt event, even if the halt stopped with some reason other than a plain interrupt (e.g. we had
4516 // already stopped for a breakpoint when the halt request came through) don't do the StopInfo actions, as they may
4517 // end up restarting the process.
4518 if (m_interrupted)
4519 return;
4520
4521 // If we're stopped and haven't restarted, then do the StopInfo actions here:
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004522 if (m_state == eStateStopped && ! m_restarted)
Greg Clayton2e309072015-07-17 23:42:28 +00004523 {
4524 // Let process subclasses know we are about to do a public stop and
4525 // do anything they might need to in order to speed up register and
4526 // memory accesses.
4527 process_sp->WillPublicStop();
4528
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004529 ThreadList &curr_thread_list = process_sp->GetThreadList();
Greg Clayton61e7a582011-12-01 23:28:38 +00004530 uint32_t num_threads = curr_thread_list.GetSize();
4531 uint32_t idx;
Greg Claytonf4b47e12010-08-04 01:40:35 +00004532
Jim Ingham4b536182011-08-09 02:12:22 +00004533 // The actions might change one of the thread's stop_info's opinions about whether we should
4534 // stop the process, so we need to query that as we go.
Jim Ingham0faa43f2011-11-08 03:00:11 +00004535
4536 // One other complication here, is that we try to catch any case where the target has run (except for expressions)
4537 // and immediately exit, but if we get that wrong (which is possible) then the thread list might have changed, and
4538 // that would cause our iteration here to crash. We could make a copy of the thread list, but we'd really like
4539 // to also know if it has changed at all, so we make up a vector of the thread ID's and check what we get back
4540 // against this list & bag out if anything differs.
Greg Clayton61e7a582011-12-01 23:28:38 +00004541 std::vector<uint32_t> thread_index_array(num_threads);
Jim Ingham0faa43f2011-11-08 03:00:11 +00004542 for (idx = 0; idx < num_threads; ++idx)
4543 thread_index_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetIndexID();
4544
Jim Inghamc7078c22012-12-13 22:24:15 +00004545 // Use this to track whether we should continue from here. We will only continue the target running if
4546 // no thread says we should stop. Of course if some thread's PerformAction actually sets the target running,
4547 // then it doesn't matter what the other threads say...
4548
4549 bool still_should_stop = false;
Jim Ingham4b536182011-08-09 02:12:22 +00004550
Jim Ingham0ad7e052013-04-25 02:04:59 +00004551 // Sometimes - for instance if we have a bug in the stub we are talking to, we stop but no thread has a
4552 // valid stop reason. In that case we should just stop, because we have no way of telling what the right
4553 // thing to do is, and it's better to let the user decide than continue behind their backs.
4554
4555 bool does_anybody_have_an_opinion = false;
4556
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004557 for (idx = 0; idx < num_threads; ++idx)
4558 {
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004559 curr_thread_list = process_sp->GetThreadList();
Jim Ingham0faa43f2011-11-08 03:00:11 +00004560 if (curr_thread_list.GetSize() != num_threads)
4561 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004562 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004563 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004564 log->Printf("Number of threads changed from %u to %u while processing event.", num_threads, curr_thread_list.GetSize());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004565 break;
4566 }
4567
4568 lldb::ThreadSP thread_sp = curr_thread_list.GetThreadAtIndex(idx);
4569
4570 if (thread_sp->GetIndexID() != thread_index_array[idx])
4571 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004572 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Jim Ingham87c665f2011-12-01 20:26:15 +00004573 if (log)
Greg Clayton61e7a582011-12-01 23:28:38 +00004574 log->Printf("The thread at position %u changed from %u to %u while processing event.",
Jim Ingham87c665f2011-12-01 20:26:15 +00004575 idx,
4576 thread_index_array[idx],
4577 thread_sp->GetIndexID());
Jim Ingham0faa43f2011-11-08 03:00:11 +00004578 break;
4579 }
4580
Jim Inghamb15bfc72010-10-20 00:39:53 +00004581 StopInfoSP stop_info_sp = thread_sp->GetStopInfo ();
Jim Ingham5d88a062012-10-16 00:09:33 +00004582 if (stop_info_sp && stop_info_sp->IsValid())
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004583 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004584 does_anybody_have_an_opinion = true;
Jim Ingham0161b492013-02-09 01:29:05 +00004585 bool this_thread_wants_to_stop;
4586 if (stop_info_sp->GetOverrideShouldStop())
Jim Ingham4b536182011-08-09 02:12:22 +00004587 {
Jim Ingham0161b492013-02-09 01:29:05 +00004588 this_thread_wants_to_stop = stop_info_sp->GetOverriddenShouldStopValue();
4589 }
4590 else
4591 {
4592 stop_info_sp->PerformAction(event_ptr);
4593 // The stop action might restart the target. If it does, then we want to mark that in the
4594 // event so that whoever is receiving it will know to wait for the running event and reflect
4595 // that state appropriately.
4596 // We also need to stop processing actions, since they aren't expecting the target to be running.
4597
4598 // FIXME: we might have run.
4599 if (stop_info_sp->HasTargetRunSinceMe())
4600 {
4601 SetRestarted (true);
4602 break;
4603 }
4604
4605 this_thread_wants_to_stop = stop_info_sp->ShouldStop(event_ptr);
Jim Ingham4b536182011-08-09 02:12:22 +00004606 }
Jim Inghamc7078c22012-12-13 22:24:15 +00004607
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004608 if (!still_should_stop)
Jim Inghamc7078c22012-12-13 22:24:15 +00004609 still_should_stop = this_thread_wants_to_stop;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004610 }
4611 }
Ashok Thirumurthicf7c55e2013-04-18 14:38:20 +00004612
Jim Inghama8ca6e22013-05-03 23:04:37 +00004613 if (!GetRestarted())
Jim Ingham9575d842011-03-11 03:53:59 +00004614 {
Jim Ingham0ad7e052013-04-25 02:04:59 +00004615 if (!still_should_stop && does_anybody_have_an_opinion)
Jim Ingham4b536182011-08-09 02:12:22 +00004616 {
4617 // We've been asked to continue, so do that here.
Jim Ingham9575d842011-03-11 03:53:59 +00004618 SetRestarted(true);
Jim Ingham3b8285d2012-04-19 01:40:33 +00004619 // Use the public resume method here, since this is just
4620 // extending a public resume.
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004621 process_sp->PrivateResume();
Jim Ingham4b536182011-08-09 02:12:22 +00004622 }
4623 else
4624 {
4625 // If we didn't restart, run the Stop Hooks here:
4626 // They might also restart the target, so watch for that.
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004627 process_sp->GetTarget().RunStopHooks();
4628 if (process_sp->GetPrivateState() == eStateRunning)
Jim Ingham4b536182011-08-09 02:12:22 +00004629 SetRestarted(true);
4630 }
Jim Ingham9575d842011-03-11 03:53:59 +00004631 }
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004632 }
4633}
4634
4635void
4636Process::ProcessEventData::Dump (Stream *s) const
4637{
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004638 ProcessSP process_sp(m_process_wp.lock());
4639
4640 if (process_sp)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004641 s->Printf(" process = %p (pid = %" PRIu64 "), ",
Greg Claytonaeb3b8b2015-05-29 03:20:37 +00004642 static_cast<void*>(process_sp.get()), process_sp->GetID());
4643 else
4644 s->PutCString(" process = NULL, ");
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004645
Greg Clayton8b82f082011-04-12 05:54:46 +00004646 s->Printf("state = %s", StateAsCString(GetState()));
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004647}
4648
4649const Process::ProcessEventData *
4650Process::ProcessEventData::GetEventDataFromEvent (const Event *event_ptr)
4651{
4652 if (event_ptr)
4653 {
4654 const EventData *event_data = event_ptr->GetData();
4655 if (event_data && event_data->GetFlavor() == ProcessEventData::GetFlavorString())
4656 return static_cast <const ProcessEventData *> (event_ptr->GetData());
4657 }
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004658 return nullptr;
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004659}
4660
4661ProcessSP
4662Process::ProcessEventData::GetProcessFromEvent (const Event *event_ptr)
4663{
4664 ProcessSP process_sp;
4665 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
4666 if (data)
4667 process_sp = data->GetProcessSP();
4668 return process_sp;
4669}
4670
4671StateType
4672Process::ProcessEventData::GetStateFromEvent (const Event *event_ptr)
4673{
4674 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004675 if (data == nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004676 return eStateInvalid;
4677 else
4678 return data->GetState();
4679}
4680
4681bool
4682Process::ProcessEventData::GetRestartedFromEvent (const Event *event_ptr)
4683{
4684 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004685 if (data == nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004686 return false;
4687 else
4688 return data->GetRestarted();
4689}
4690
4691void
4692Process::ProcessEventData::SetRestartedInEvent (Event *event_ptr, bool new_value)
4693{
4694 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004695 if (data != nullptr)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004696 data->SetRestarted(new_value);
4697}
4698
Jim Ingham0161b492013-02-09 01:29:05 +00004699size_t
4700Process::ProcessEventData::GetNumRestartedReasons(const Event *event_ptr)
4701{
4702 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004703 if (data != nullptr)
Jim Ingham0161b492013-02-09 01:29:05 +00004704 return data->GetNumRestartedReasons();
4705 else
4706 return 0;
4707}
4708
4709const char *
4710Process::ProcessEventData::GetRestartedReasonAtIndex(const Event *event_ptr, size_t idx)
4711{
4712 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004713 if (data != nullptr)
Jim Ingham0161b492013-02-09 01:29:05 +00004714 return data->GetRestartedReasonAtIndex(idx);
4715 else
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004716 return nullptr;
Jim Ingham0161b492013-02-09 01:29:05 +00004717}
4718
4719void
4720Process::ProcessEventData::AddRestartedReason (Event *event_ptr, const char *reason)
4721{
4722 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004723 if (data != nullptr)
Jim Ingham0161b492013-02-09 01:29:05 +00004724 data->AddRestartedReason(reason);
4725}
4726
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004727bool
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004728Process::ProcessEventData::GetInterruptedFromEvent (const Event *event_ptr)
4729{
4730 const ProcessEventData *data = GetEventDataFromEvent (event_ptr);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004731 if (data == nullptr)
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004732 return false;
4733 else
4734 return data->GetInterrupted ();
4735}
4736
4737void
4738Process::ProcessEventData::SetInterruptedInEvent (Event *event_ptr, bool new_value)
4739{
4740 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004741 if (data != nullptr)
Jim Ingham0d8bcc72010-11-17 02:32:00 +00004742 data->SetInterrupted(new_value);
4743}
4744
4745bool
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004746Process::ProcessEventData::SetUpdateStateOnRemoval (Event *event_ptr)
4747{
4748 ProcessEventData *data = const_cast<ProcessEventData *>(GetEventDataFromEvent (event_ptr));
4749 if (data)
4750 {
4751 data->SetUpdateStateOnRemoval();
4752 return true;
4753 }
4754 return false;
4755}
4756
Greg Claytond9e416c2012-02-18 05:35:26 +00004757lldb::TargetSP
4758Process::CalculateTarget ()
4759{
Zachary Turner7529df92015-09-01 20:02:29 +00004760 return m_target_sp.lock();
Greg Claytond9e416c2012-02-18 05:35:26 +00004761}
4762
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004763void
Greg Clayton0603aa92010-10-04 01:05:56 +00004764Process::CalculateExecutionContext (ExecutionContext &exe_ctx)
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004765{
Zachary Turner7529df92015-09-01 20:02:29 +00004766 exe_ctx.SetTargetPtr (&GetTarget());
Greg Claytonc14ee322011-09-22 04:58:26 +00004767 exe_ctx.SetProcessPtr (this);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004768 exe_ctx.SetThreadPtr(nullptr);
4769 exe_ctx.SetFramePtr(nullptr);
Chris Lattner30fdc8d2010-06-08 16:52:24 +00004770}
4771
Greg Claytone996fd32011-03-08 22:40:15 +00004772//uint32_t
4773//Process::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids)
4774//{
4775// return 0;
4776//}
4777//
4778//ArchSpec
4779//Process::GetArchSpecForExistingProcess (lldb::pid_t pid)
4780//{
4781// return Host::GetArchSpecForExistingProcess (pid);
4782//}
4783//
4784//ArchSpec
4785//Process::GetArchSpecForExistingProcess (const char *process_name)
4786//{
4787// return Host::GetArchSpecForExistingProcess (process_name);
4788//}
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004789
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004790void
4791Process::AppendSTDOUT (const char * s, size_t len)
4792{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004793 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004794 m_stdout_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004795 BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004796}
4797
4798void
Greg Clayton93e86192011-11-13 04:45:22 +00004799Process::AppendSTDERR (const char * s, size_t len)
4800{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004801 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
Greg Clayton93e86192011-11-13 04:45:22 +00004802 m_stderr_data.append (s, len);
Greg Clayton35a4cc52012-10-29 20:52:08 +00004803 BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
Greg Clayton93e86192011-11-13 04:45:22 +00004804}
4805
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004806void
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004807Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004808{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004809 std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004810 m_profile_data.push_back(one_profile_data);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004811 BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
4812}
4813
4814size_t
4815Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
4816{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004817 std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004818 if (m_profile_data.empty())
4819 return 0;
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004820
4821 std::string &one_profile_data = m_profile_data.front();
4822 size_t bytes_available = one_profile_data.size();
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004823 if (bytes_available > 0)
4824 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004825 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004826 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004827 log->Printf ("Process::GetProfileData (buf = %p, size = %" PRIu64 ")",
4828 static_cast<void*>(buf),
4829 static_cast<uint64_t>(buf_size));
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004830 if (bytes_available > buf_size)
4831 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004832 memcpy(buf, one_profile_data.c_str(), buf_size);
4833 one_profile_data.erase(0, buf_size);
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004834 bytes_available = buf_size;
4835 }
4836 else
4837 {
Han Ming Ong91ed6b82013-06-24 18:15:05 +00004838 memcpy(buf, one_profile_data.c_str(), bytes_available);
Han Ming Ong929a94f2012-11-29 22:14:45 +00004839 m_profile_data.erase(m_profile_data.begin());
Han Ming Ongab3b8b22012-11-17 00:21:04 +00004840 }
4841 }
4842 return bytes_available;
4843}
4844
Greg Clayton93e86192011-11-13 04:45:22 +00004845//------------------------------------------------------------------
4846// Process STDIO
4847//------------------------------------------------------------------
4848
4849size_t
4850Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
4851{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004852 std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
Greg Clayton93e86192011-11-13 04:45:22 +00004853 size_t bytes_available = m_stdout_data.size();
4854 if (bytes_available > 0)
4855 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004856 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004857 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004858 log->Printf ("Process::GetSTDOUT (buf = %p, size = %" PRIu64 ")",
4859 static_cast<void*>(buf),
4860 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004861 if (bytes_available > buf_size)
4862 {
4863 memcpy(buf, m_stdout_data.c_str(), buf_size);
4864 m_stdout_data.erase(0, buf_size);
4865 bytes_available = buf_size;
4866 }
4867 else
4868 {
4869 memcpy(buf, m_stdout_data.c_str(), bytes_available);
4870 m_stdout_data.clear();
4871 }
4872 }
4873 return bytes_available;
4874}
4875
Greg Clayton93e86192011-11-13 04:45:22 +00004876size_t
4877Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
4878{
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00004879 std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex);
Greg Clayton93e86192011-11-13 04:45:22 +00004880 size_t bytes_available = m_stderr_data.size();
4881 if (bytes_available > 0)
4882 {
Greg Clayton5160ce52013-03-27 23:08:40 +00004883 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
Greg Clayton93e86192011-11-13 04:45:22 +00004884 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00004885 log->Printf ("Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
4886 static_cast<void*>(buf),
4887 static_cast<uint64_t>(buf_size));
Greg Clayton93e86192011-11-13 04:45:22 +00004888 if (bytes_available > buf_size)
4889 {
4890 memcpy(buf, m_stderr_data.c_str(), buf_size);
4891 m_stderr_data.erase(0, buf_size);
4892 bytes_available = buf_size;
4893 }
4894 else
4895 {
4896 memcpy(buf, m_stderr_data.c_str(), bytes_available);
4897 m_stderr_data.clear();
4898 }
4899 }
4900 return bytes_available;
4901}
4902
4903void
Caroline Ticeef5c6d02010-11-16 05:07:41 +00004904Process::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
4905{
4906 Process *process = (Process *) baton;
4907 process->AppendSTDOUT (static_cast<const char *>(src), src_len);
4908}
4909
Greg Clayton44d93782014-01-27 23:43:24 +00004910class IOHandlerProcessSTDIO :
4911 public IOHandler
4912{
4913public:
4914 IOHandlerProcessSTDIO (Process *process,
4915 int write_fd) :
Kate Stonee30f11d2014-11-17 19:06:59 +00004916 IOHandler(process->GetTarget().GetDebugger(), IOHandler::Type::ProcessIO),
Greg Clayton44d93782014-01-27 23:43:24 +00004917 m_process (process),
4918 m_read_file (),
4919 m_write_file (write_fd, false),
Greg Clayton100eb932014-07-02 21:10:39 +00004920 m_pipe ()
Greg Clayton44d93782014-01-27 23:43:24 +00004921 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004922 m_pipe.CreateNew(false);
Greg Clayton44d93782014-01-27 23:43:24 +00004923 m_read_file.SetDescriptor(GetInputFD(), false);
4924 }
4925
Eugene Zelenko8f30a652015-10-23 18:39:37 +00004926 ~IOHandlerProcessSTDIO() override = default;
4927
Greg Clayton44d93782014-01-27 23:43:24 +00004928 // Each IOHandler gets to run until it is done. It should read data
4929 // from the "in" and place output into "out" and "err and return
4930 // when done.
Pavel Labath44464872015-05-27 12:40:32 +00004931 void
4932 Run () override
Greg Clayton44d93782014-01-27 23:43:24 +00004933 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004934 if (!m_read_file.IsValid() || !m_write_file.IsValid() || !m_pipe.CanRead() || !m_pipe.CanWrite())
Greg Clayton44d93782014-01-27 23:43:24 +00004935 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004936 SetIsDone(true);
4937 return;
4938 }
4939
4940 SetIsDone(false);
4941 const int read_fd = m_read_file.GetDescriptor();
4942 TerminalState terminal_state;
4943 terminal_state.Save (read_fd, false);
4944 Terminal terminal(read_fd);
4945 terminal.SetCanonical(false);
4946 terminal.SetEcho(false);
Deepak Panickal914b8d92014-01-31 18:48:46 +00004947// FD_ZERO, FD_SET are not supported on windows
Hafiz Abid Qadeer6eff1012014-03-12 10:45:23 +00004948#ifndef _WIN32
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004949 const int pipe_read_fd = m_pipe.GetReadFileDescriptor();
Greg Clayton860582f2016-02-26 17:36:44 +00004950 m_is_running = true;
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004951 while (!GetIsDone())
4952 {
4953 fd_set read_fdset;
4954 FD_ZERO (&read_fdset);
4955 FD_SET (read_fd, &read_fdset);
4956 FD_SET (pipe_read_fd, &read_fdset);
4957 const int nfds = std::max<int>(read_fd, pipe_read_fd) + 1;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00004958 int num_set_fds = select(nfds, &read_fdset, nullptr, nullptr, nullptr);
Greg Clayton860582f2016-02-26 17:36:44 +00004959
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004960 if (num_set_fds < 0)
4961 {
4962 const int select_errno = errno;
4963
4964 if (select_errno != EINTR)
4965 SetIsDone(true);
4966 }
4967 else if (num_set_fds > 0)
4968 {
4969 char ch = 0;
4970 size_t n;
4971 if (FD_ISSET (read_fd, &read_fdset))
Greg Clayton44d93782014-01-27 23:43:24 +00004972 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004973 n = 1;
4974 if (m_read_file.Read(&ch, n).Success() && n == 1)
Greg Clayton44d93782014-01-27 23:43:24 +00004975 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004976 if (m_write_file.Write(&ch, n).Fail() || n != 1)
Greg Clayton44d93782014-01-27 23:43:24 +00004977 SetIsDone(true);
4978 }
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004979 else
4980 SetIsDone(true);
4981 }
4982 if (FD_ISSET (pipe_read_fd, &read_fdset))
4983 {
4984 size_t bytes_read;
4985 // Consume the interrupt byte
4986 Error error = m_pipe.Read(&ch, 1, bytes_read);
4987 if (error.Success())
Greg Clayton44d93782014-01-27 23:43:24 +00004988 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004989 switch (ch)
Greg Clayton44d93782014-01-27 23:43:24 +00004990 {
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004991 case 'q':
Greg Clayton44d93782014-01-27 23:43:24 +00004992 SetIsDone(true);
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004993 break;
4994 case 'i':
4995 if (StateIsRunningState(m_process->GetState()))
Pavel Labathfcc7f662015-10-07 15:11:11 +00004996 m_process->SendAsyncInterrupt();
Pavel Labathfb7d5b82015-05-28 13:41:08 +00004997 break;
Greg Clayton44d93782014-01-27 23:43:24 +00004998 }
4999 }
5000 }
Greg Clayton44d93782014-01-27 23:43:24 +00005001 }
Greg Clayton44d93782014-01-27 23:43:24 +00005002 }
Greg Clayton860582f2016-02-26 17:36:44 +00005003 m_is_running = false;
Pavel Labathfb7d5b82015-05-28 13:41:08 +00005004#endif
5005 terminal_state.Restore();
Greg Clayton44d93782014-01-27 23:43:24 +00005006 }
5007
Pavel Labath44464872015-05-27 12:40:32 +00005008 void
5009 Cancel () override
Greg Clayton44d93782014-01-27 23:43:24 +00005010 {
Greg Clayton860582f2016-02-26 17:36:44 +00005011 SetIsDone(true);
5012 // Only write to our pipe to cancel if we are in IOHandlerProcessSTDIO::Run().
5013 // We can end up with a python command that is being run from the command
5014 // interpreter:
5015 //
5016 // (lldb) step_process_thousands_of_times
5017 //
5018 // In this case the command interpreter will be in the middle of handling
5019 // the command and if the process pushes and pops the IOHandler thousands
5020 // of times, we can end up writing to m_pipe without ever consuming the
5021 // bytes from the pipe in IOHandlerProcessSTDIO::Run() and end up
5022 // deadlocking when the pipe gets fed up and blocks until data is consumed.
5023 if (m_is_running)
5024 {
5025 char ch = 'q'; // Send 'q' for quit
5026 size_t bytes_written = 0;
5027 m_pipe.Write(&ch, 1, bytes_written);
5028 }
Greg Clayton44d93782014-01-27 23:43:24 +00005029 }
Greg Claytone68f5d62014-02-24 22:50:57 +00005030
Pavel Labath44464872015-05-27 12:40:32 +00005031 bool
5032 Interrupt () override
Greg Claytone68f5d62014-02-24 22:50:57 +00005033 {
Greg Clayton19e11352014-02-26 22:47:33 +00005034 // Do only things that are safe to do in an interrupt context (like in
5035 // a SIGINT handler), like write 1 byte to a file descriptor. This will
5036 // interrupt the IOHandlerProcessSTDIO::Run() and we can look at the byte
Pavel Labathfcc7f662015-10-07 15:11:11 +00005037 // that was written to the pipe and then call m_process->SendAsyncInterrupt()
5038 // from a much safer location in code.
Greg Clayton0fdd3ae2014-07-16 21:05:41 +00005039 if (m_active)
5040 {
5041 char ch = 'i'; // Send 'i' for interrupt
Zachary Turner0b9d3ee2014-12-17 18:02:19 +00005042 size_t bytes_written = 0;
5043 Error result = m_pipe.Write(&ch, 1, bytes_written);
5044 return result.Success();
Greg Clayton0fdd3ae2014-07-16 21:05:41 +00005045 }
5046 else
5047 {
5048 // This IOHandler might be pushed on the stack, but not being run currently
5049 // so do the right thing if we aren't actively watching for STDIN by sending
5050 // the interrupt to the process. Otherwise the write to the pipe above would
5051 // do nothing. This can happen when the command interpreter is running and
5052 // gets a "expression ...". It will be on the IOHandler thread and sending
5053 // the input is complete to the delegate which will cause the expression to
5054 // run, which will push the process IO handler, but not run it.
5055
5056 if (StateIsRunningState(m_process->GetState()))
5057 {
5058 m_process->SendAsyncInterrupt();
5059 return true;
5060 }
5061 }
5062 return false;
Greg Claytone68f5d62014-02-24 22:50:57 +00005063 }
Greg Clayton44d93782014-01-27 23:43:24 +00005064
Pavel Labath44464872015-05-27 12:40:32 +00005065 void
5066 GotEOF() override
Greg Clayton44d93782014-01-27 23:43:24 +00005067 {
Greg Clayton44d93782014-01-27 23:43:24 +00005068 }
5069
5070protected:
5071 Process *m_process;
5072 File m_read_file; // Read from this file (usually actual STDIN for LLDB
5073 File m_write_file; // Write to this file (usually the master pty for getting io to debuggee)
Greg Clayton100eb932014-07-02 21:10:39 +00005074 Pipe m_pipe;
Greg Clayton860582f2016-02-26 17:36:44 +00005075 std::atomic<bool> m_is_running;
Greg Clayton44d93782014-01-27 23:43:24 +00005076};
5077
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005078void
Greg Clayton44d93782014-01-27 23:43:24 +00005079Process::SetSTDIOFileDescriptor (int fd)
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005080{
5081 // First set up the Read Thread for reading/handling process I/O
5082
Greg Clayton44d93782014-01-27 23:43:24 +00005083 std::unique_ptr<ConnectionFileDescriptor> conn_ap (new ConnectionFileDescriptor (fd, true));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005084
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005085 if (conn_ap)
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005086 {
5087 m_stdio_communication.SetConnection (conn_ap.release());
5088 if (m_stdio_communication.IsConnected())
5089 {
5090 m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
5091 m_stdio_communication.StartReadThread();
5092
5093 // Now read thread is set up, set up input reader.
5094
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005095 if (!m_process_input_reader)
Greg Clayton44d93782014-01-27 23:43:24 +00005096 m_process_input_reader.reset (new IOHandlerProcessSTDIO (this, fd));
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005097 }
5098 }
5099}
5100
Greg Claytonb4874f12014-02-28 18:22:24 +00005101bool
Greg Clayton6fea17e2014-03-03 19:15:20 +00005102Process::ProcessIOHandlerIsActive ()
5103{
5104 IOHandlerSP io_handler_sp (m_process_input_reader);
5105 if (io_handler_sp)
Zachary Turner7529df92015-09-01 20:02:29 +00005106 return GetTarget().GetDebugger().IsTopIOHandler (io_handler_sp);
Greg Clayton6fea17e2014-03-03 19:15:20 +00005107 return false;
5108}
5109bool
Greg Clayton44d93782014-01-27 23:43:24 +00005110Process::PushProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005111{
Greg Clayton44d93782014-01-27 23:43:24 +00005112 IOHandlerSP io_handler_sp (m_process_input_reader);
5113 if (io_handler_sp)
5114 {
Pavel Labath44464872015-05-27 12:40:32 +00005115 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
5116 if (log)
5117 log->Printf("Process::%s pushing IO handler", __FUNCTION__);
5118
Greg Clayton44d93782014-01-27 23:43:24 +00005119 io_handler_sp->SetIsDone(false);
Zachary Turner7529df92015-09-01 20:02:29 +00005120 GetTarget().GetDebugger().PushIOHandler (io_handler_sp);
Greg Claytonb4874f12014-02-28 18:22:24 +00005121 return true;
Greg Clayton44d93782014-01-27 23:43:24 +00005122 }
Greg Claytonb4874f12014-02-28 18:22:24 +00005123 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005124}
5125
Greg Claytonb4874f12014-02-28 18:22:24 +00005126bool
Greg Clayton44d93782014-01-27 23:43:24 +00005127Process::PopProcessIOHandler ()
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005128{
Greg Clayton44d93782014-01-27 23:43:24 +00005129 IOHandlerSP io_handler_sp (m_process_input_reader);
5130 if (io_handler_sp)
Zachary Turner7529df92015-09-01 20:02:29 +00005131 return GetTarget().GetDebugger().PopIOHandler (io_handler_sp);
Greg Claytonb4874f12014-02-28 18:22:24 +00005132 return false;
Caroline Ticeef5c6d02010-11-16 05:07:41 +00005133}
5134
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00005135// The process needs to know about installed plug-ins
Greg Clayton99d0faf2010-11-18 23:32:35 +00005136void
Caroline Tice20bd37f2011-03-10 22:14:10 +00005137Process::SettingsInitialize ()
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005138{
Greg Clayton6920b522012-08-22 18:39:03 +00005139 Thread::SettingsInitialize ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00005140}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005141
Greg Clayton99d0faf2010-11-18 23:32:35 +00005142void
Caroline Tice20bd37f2011-03-10 22:14:10 +00005143Process::SettingsTerminate ()
Greg Claytonbfe5f3b2011-02-18 01:44:25 +00005144{
Greg Clayton6920b522012-08-22 18:39:03 +00005145 Thread::SettingsTerminate ();
Greg Clayton99d0faf2010-11-18 23:32:35 +00005146}
Caroline Tice3df9a8d2010-09-04 00:03:46 +00005147
Jim Inghamc60963c2015-10-12 19:11:03 +00005148namespace
5149{
5150 // RestorePlanState is used to record the "is private", "is master" and "okay to discard" fields of
5151 // the plan we are running, and reset it on Clean or on destruction.
5152 // It will only reset the state once, so you can call Clean and then monkey with the state and it
5153 // won't get reset on you again.
5154
5155 class RestorePlanState
5156 {
5157 public:
5158 RestorePlanState (lldb::ThreadPlanSP thread_plan_sp) :
5159 m_thread_plan_sp(thread_plan_sp),
5160 m_already_reset(false)
5161 {
5162 if (m_thread_plan_sp)
5163 {
5164 m_private = m_thread_plan_sp->GetPrivate();
5165 m_is_master = m_thread_plan_sp->IsMasterPlan();
5166 m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();
5167 }
5168 }
5169
5170 ~RestorePlanState()
5171 {
5172 Clean();
5173 }
5174
5175 void
5176 Clean ()
5177 {
5178 if (!m_already_reset && m_thread_plan_sp)
5179 {
5180 m_already_reset = true;
5181 m_thread_plan_sp->SetPrivate(m_private);
5182 m_thread_plan_sp->SetIsMasterPlan (m_is_master);
5183 m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
5184 }
5185 }
Eugene Zelenko8f30a652015-10-23 18:39:37 +00005186
Jim Inghamc60963c2015-10-12 19:11:03 +00005187 private:
5188 lldb::ThreadPlanSP m_thread_plan_sp;
5189 bool m_already_reset;
5190 bool m_private;
5191 bool m_is_master;
5192 bool m_okay_to_discard;
5193 };
Eugene Zelenko8f30a652015-10-23 18:39:37 +00005194} // anonymous namespace
Jim Inghamc60963c2015-10-12 19:11:03 +00005195
Jim Ingham1624a2d2014-05-05 02:26:40 +00005196ExpressionResults
Sean Callanan579e70c2016-03-19 00:03:59 +00005197Process::RunThreadPlan(ExecutionContext &exe_ctx, lldb::ThreadPlanSP &thread_plan_sp,
5198 const EvaluateExpressionOptions &options, DiagnosticManager &diagnostic_manager)
Jim Inghamf48169b2010-11-30 02:22:11 +00005199{
Jim Ingham8646d3c2014-05-05 02:47:44 +00005200 ExpressionResults return_value = eExpressionSetupError;
Jim Ingham3cc425832016-05-24 18:29:36 +00005201
5202 std::lock_guard<std::mutex> run_thread_plan_locker(m_run_thread_plan_lock);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005203
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005204 if (!thread_plan_sp)
Jim Ingham77787032011-01-20 02:03:18 +00005205 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005206 diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with empty thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005207 return eExpressionSetupError;
Jim Ingham77787032011-01-20 02:03:18 +00005208 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005209
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005210 if (!thread_plan_sp->ValidatePlan(nullptr))
Jim Ingham7d7931d2013-03-28 00:05:34 +00005211 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005212 diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with an invalid thread plan.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005213 return eExpressionSetupError;
Jim Ingham7d7931d2013-03-28 00:05:34 +00005214 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005215
Greg Claytonc14ee322011-09-22 04:58:26 +00005216 if (exe_ctx.GetProcessPtr() != this)
5217 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005218 diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called on wrong process.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005219 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00005220 }
5221
5222 Thread *thread = exe_ctx.GetThreadPtr();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005223 if (thread == nullptr)
Greg Claytonc14ee322011-09-22 04:58:26 +00005224 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005225 diagnostic_manager.PutCString(eDiagnosticSeverityError, "RunThreadPlan called with invalid thread.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005226 return eExpressionSetupError;
Greg Claytonc14ee322011-09-22 04:58:26 +00005227 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005228
Jim Inghamc60963c2015-10-12 19:11:03 +00005229 // We need to change some of the thread plan attributes for the thread plan runner. This will restore them
5230 // when we are done:
Jim Ingham3cc425832016-05-24 18:29:36 +00005231
Jim Inghamc60963c2015-10-12 19:11:03 +00005232 RestorePlanState thread_plan_restorer(thread_plan_sp);
5233
Jim Ingham17e5c4e2011-05-17 22:24:54 +00005234 // We rely on the thread plan we are running returning "PlanCompleted" if when it successfully completes.
5235 // For that to be true the plan can't be private - since private plans suppress themselves in the
5236 // GetCompletedPlan call.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005237
Jim Ingham17e5c4e2011-05-17 22:24:54 +00005238 thread_plan_sp->SetPrivate(false);
Jim Inghamc60963c2015-10-12 19:11:03 +00005239
5240 // The plans run with RunThreadPlan also need to be terminal master plans or when they are done we will end
5241 // up asking the plan above us whether we should stop, which may give the wrong answer.
5242
5243 thread_plan_sp->SetIsMasterPlan (true);
5244 thread_plan_sp->SetOkayToDiscard(false);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005245
Jim Ingham444586b2011-01-24 06:34:17 +00005246 if (m_private_state.GetValue() != eStateStopped)
5247 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005248 diagnostic_manager.PutCString(eDiagnosticSeverityError,
5249 "RunThreadPlan called while the private state was not stopped.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005250 return eExpressionSetupError;
Jim Ingham444586b2011-01-24 06:34:17 +00005251 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005252
Jim Ingham66243842011-08-13 00:56:10 +00005253 // Save the thread & frame from the exe_ctx for restoration after we run
Greg Claytonc14ee322011-09-22 04:58:26 +00005254 const uint32_t thread_idx_id = thread->GetIndexID();
Jason Molendab57e4a12013-11-04 09:33:30 +00005255 StackFrameSP selected_frame_sp = thread->GetSelectedFrame();
Jim Ingham11b0e052013-02-19 23:22:45 +00005256 if (!selected_frame_sp)
5257 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005258 thread->SetSelectedFrame(nullptr);
Jim Ingham11b0e052013-02-19 23:22:45 +00005259 selected_frame_sp = thread->GetSelectedFrame();
5260 if (!selected_frame_sp)
5261 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005262 diagnostic_manager.Printf(eDiagnosticSeverityError,
5263 "RunThreadPlan called without a selected frame on thread %d", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005264 return eExpressionSetupError;
Jim Ingham11b0e052013-02-19 23:22:45 +00005265 }
5266 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005267
Jim Ingham11b0e052013-02-19 23:22:45 +00005268 StackID ctx_frame_id = selected_frame_sp->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00005269
5270 // N.B. Running the target may unset the currently selected thread and frame. We don't want to do that either,
5271 // so we should arrange to reset them as well.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005272
Greg Claytonc14ee322011-09-22 04:58:26 +00005273 lldb::ThreadSP selected_thread_sp = GetThreadList().GetSelectedThread();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005274
Jim Ingham66243842011-08-13 00:56:10 +00005275 uint32_t selected_tid;
5276 StackID selected_stack_id;
Greg Clayton762f7132011-09-18 18:59:15 +00005277 if (selected_thread_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00005278 {
5279 selected_tid = selected_thread_sp->GetIndexID();
Jim Ingham66243842011-08-13 00:56:10 +00005280 selected_stack_id = selected_thread_sp->GetSelectedFrame()->GetStackID();
Jim Inghamf48169b2010-11-30 02:22:11 +00005281 }
5282 else
5283 {
5284 selected_tid = LLDB_INVALID_THREAD_ID;
5285 }
5286
Zachary Turner39de3112014-09-09 20:54:56 +00005287 HostThread backup_private_state_thread;
Jason Molenda76513fd2014-10-15 23:39:31 +00005288 lldb::StateType old_state = eStateInvalid;
Jim Ingham076b3042012-04-10 01:21:57 +00005289 lldb::ThreadPlanSP stopper_base_plan_sp;
Jim Ingham372787f2012-04-07 00:00:41 +00005290
Greg Clayton5160ce52013-03-27 23:08:40 +00005291 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STEP | LIBLLDB_LOG_PROCESS));
Zachary Turner39de3112014-09-09 20:54:56 +00005292 if (m_private_state_thread.EqualsThread(Host::GetCurrentThread()))
Jim Ingham372787f2012-04-07 00:00:41 +00005293 {
Jim Ingham076b3042012-04-10 01:21:57 +00005294 // Yikes, we are running on the private state thread! So we can't wait for public events on this thread, since
5295 // we are the thread that is generating public events.
Jim Ingham372787f2012-04-07 00:00:41 +00005296 // The simplest thing to do is to spin up a temporary thread to handle private state thread events while
Jim Ingham076b3042012-04-10 01:21:57 +00005297 // we are fielding public events here.
5298 if (log)
Jason Molendad251c9d2012-11-17 01:41:04 +00005299 log->Printf ("Running thread plan on private state thread, spinning up another state thread to handle the events.");
Jim Ingham076b3042012-04-10 01:21:57 +00005300
Jim Ingham372787f2012-04-07 00:00:41 +00005301 backup_private_state_thread = m_private_state_thread;
Jim Ingham076b3042012-04-10 01:21:57 +00005302
5303 // One other bit of business: we want to run just this thread plan and anything it pushes, and then stop,
5304 // returning control here.
5305 // But in the normal course of things, the plan above us on the stack would be given a shot at the stop
5306 // event before deciding to stop, and we don't want that. So we insert a "stopper" base plan on the stack
5307 // before the plan we want to run. Since base plans always stop and return control to the user, that will
5308 // do just what we want.
5309 stopper_base_plan_sp.reset(new ThreadPlanBase (*thread));
5310 thread->QueueThreadPlan (stopper_base_plan_sp, false);
5311 // Have to make sure our public state is stopped, since otherwise the reporting logic below doesn't work correctly.
5312 old_state = m_public_state.GetValue();
5313 m_public_state.SetValueNoLock(eStateStopped);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005314
Jim Ingham076b3042012-04-10 01:21:57 +00005315 // Now spin up the private state thread:
Jim Ingham372787f2012-04-07 00:00:41 +00005316 StartPrivateStateThread(true);
5317 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005318
Jim Ingham372787f2012-04-07 00:00:41 +00005319 thread->QueueThreadPlan(thread_plan_sp, false); // This used to pass "true" does that make sense?
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005320
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005321 if (options.GetDebug())
5322 {
5323 // In this case, we aren't actually going to run, we just want to stop right away.
5324 // Flush this thread so we will refetch the stacks and show the correct backtrace.
5325 // FIXME: To make this prettier we should invent some stop reason for this, but that
5326 // is only cosmetic, and this functionality is only of use to lldb developers who can
5327 // live with not pretty...
5328 thread->Flush();
Jim Ingham8646d3c2014-05-05 02:47:44 +00005329 return eExpressionStoppedForDebug;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005330 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005331
Jim Ingham583bbb12016-03-07 21:50:25 +00005332 ListenerSP listener_sp(Listener::MakeListener("lldb.process.listener.run-thread-plan"));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005333
Sean Callanana46ec452012-07-11 21:31:24 +00005334 lldb::EventSP event_to_broadcast_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005335
Jim Ingham77787032011-01-20 02:03:18 +00005336 {
Sean Callanana46ec452012-07-11 21:31:24 +00005337 // This process event hijacker Hijacks the Public events and its destructor makes sure that the process events get
5338 // restored on exit to the function.
5339 //
5340 // If the event needs to propagate beyond the hijacker (e.g., the process exits during execution), then the event
5341 // is put into event_to_broadcast_sp for rebroadcasting.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005342
Jim Ingham583bbb12016-03-07 21:50:25 +00005343 ProcessEventHijacker run_thread_plan_hijacker (*this, listener_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005344
Jim Inghamf48169b2010-11-30 02:22:11 +00005345 if (log)
Jim Ingham0f16e732011-02-08 05:20:59 +00005346 {
5347 StreamString s;
Sean Callanana46ec452012-07-11 21:31:24 +00005348 thread_plan_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
Daniel Malead01b2952012-11-29 21:49:15 +00005349 log->Printf ("Process::RunThreadPlan(): Resuming thread %u - 0x%4.4" PRIx64 " to run thread plan \"%s\".",
Sean Callanana46ec452012-07-11 21:31:24 +00005350 thread->GetIndexID(),
5351 thread->GetID(),
5352 s.GetData());
5353 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005354
Sean Callanana46ec452012-07-11 21:31:24 +00005355 bool got_event;
5356 lldb::EventSP event_sp;
5357 lldb::StateType stop_state = lldb::eStateInvalid;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005358
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005359 TimeValue* timeout_ptr = nullptr;
Sean Callanana46ec452012-07-11 21:31:24 +00005360 TimeValue real_timeout;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005361
Jim Ingham0161b492013-02-09 01:29:05 +00005362 bool before_first_timeout = true; // This is set to false the first time that we have to halt the target.
Sean Callanana46ec452012-07-11 21:31:24 +00005363 bool do_resume = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005364 bool handle_running_event = true;
Jim Ingham35e1bda2012-10-16 21:41:58 +00005365 const uint64_t default_one_thread_timeout_usec = 250000;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005366
Jim Ingham0161b492013-02-09 01:29:05 +00005367 // This is just for accounting:
5368 uint32_t num_resumes = 0;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005369
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005370 uint32_t timeout_usec = options.GetTimeoutUsec();
Jim Inghamfd95f892014-04-22 01:41:52 +00005371 uint32_t one_thread_timeout_usec;
5372 uint32_t all_threads_timeout_usec = 0;
Jim Inghamfe1c3422014-04-16 02:24:48 +00005373
5374 // If we are going to run all threads the whole time, or if we are only going to run one thread,
5375 // then we don't need the first timeout. So we set the final timeout, and pretend we are after the
5376 // first timeout already.
5377
5378 if (!options.GetStopOthers() || !options.GetTryAllThreads())
Jim Ingham286fb1e2014-02-28 02:52:06 +00005379 {
5380 before_first_timeout = false;
Jim Inghamfd95f892014-04-22 01:41:52 +00005381 one_thread_timeout_usec = 0;
5382 all_threads_timeout_usec = timeout_usec;
Jim Ingham286fb1e2014-02-28 02:52:06 +00005383 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00005384 else
Jim Ingham0161b492013-02-09 01:29:05 +00005385 {
Jim Inghamfd95f892014-04-22 01:41:52 +00005386 uint32_t option_one_thread_timeout = options.GetOneThreadTimeoutUsec();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005387
Jim Ingham914f4e72014-03-28 21:58:28 +00005388 // If the overall wait is forever, then we only need to set the one thread timeout:
5389 if (timeout_usec == 0)
5390 {
Ed Maste801335c2014-03-31 19:28:14 +00005391 if (option_one_thread_timeout != 0)
Jim Inghamfd95f892014-04-22 01:41:52 +00005392 one_thread_timeout_usec = option_one_thread_timeout;
Jim Ingham914f4e72014-03-28 21:58:28 +00005393 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005394 one_thread_timeout_usec = default_one_thread_timeout_usec;
Jim Ingham914f4e72014-03-28 21:58:28 +00005395 }
Jim Ingham0161b492013-02-09 01:29:05 +00005396 else
5397 {
Jim Ingham914f4e72014-03-28 21:58:28 +00005398 // Otherwise, if the one thread timeout is set, make sure it isn't longer than the overall timeout,
5399 // and use it, otherwise use half the total timeout, bounded by the default_one_thread_timeout_usec.
5400 uint64_t computed_one_thread_timeout;
5401 if (option_one_thread_timeout != 0)
5402 {
5403 if (timeout_usec < option_one_thread_timeout)
5404 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005405 diagnostic_manager.PutCString(
5406 eDiagnosticSeverityError,
5407 "RunThreadPlan called without one thread timeout greater than total timeout");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005408 return eExpressionSetupError;
Jim Ingham914f4e72014-03-28 21:58:28 +00005409 }
5410 computed_one_thread_timeout = option_one_thread_timeout;
5411 }
5412 else
5413 {
5414 computed_one_thread_timeout = timeout_usec / 2;
5415 if (computed_one_thread_timeout > default_one_thread_timeout_usec)
5416 computed_one_thread_timeout = default_one_thread_timeout_usec;
5417 }
Jim Inghamfd95f892014-04-22 01:41:52 +00005418 one_thread_timeout_usec = computed_one_thread_timeout;
5419 all_threads_timeout_usec = timeout_usec - one_thread_timeout_usec;
Jim Ingham0161b492013-02-09 01:29:05 +00005420 }
Jim Ingham0161b492013-02-09 01:29:05 +00005421 }
Jim Inghamfe1c3422014-04-16 02:24:48 +00005422
5423 if (log)
Jim Inghamfd95f892014-04-22 01:41:52 +00005424 log->Printf ("Stop others: %u, try all: %u, before_first: %u, one thread: %" PRIu32 " - all threads: %" PRIu32 ".\n",
Jim Inghamfe1c3422014-04-16 02:24:48 +00005425 options.GetStopOthers(),
5426 options.GetTryAllThreads(),
Jim Inghamfd95f892014-04-22 01:41:52 +00005427 before_first_timeout,
5428 one_thread_timeout_usec,
5429 all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005430
Jim Ingham1460e4b2014-01-10 23:46:59 +00005431 // This isn't going to work if there are unfetched events on the queue.
5432 // Are there cases where we might want to run the remaining events here, and then try to
5433 // call the function? That's probably being too tricky for our own good.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005434
Jim Ingham583bbb12016-03-07 21:50:25 +00005435 Event *other_events = listener_sp->PeekAtNextEvent();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005436 if (other_events != nullptr)
Jim Ingham1460e4b2014-01-10 23:46:59 +00005437 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005438 diagnostic_manager.PutCString(eDiagnosticSeverityError,
5439 "RunThreadPlan called with pending events on the queue.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005440 return eExpressionSetupError;
Jim Ingham1460e4b2014-01-10 23:46:59 +00005441 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005442
Jim Ingham1460e4b2014-01-10 23:46:59 +00005443 // We also need to make sure that the next event is delivered. We might be calling a function as part of
5444 // a thread plan, in which case the last delivered event could be the running event, and we don't want
5445 // event coalescing to cause us to lose OUR running event...
5446 ForceNextEventDelivery();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005447
Jim Ingham8559a352012-11-26 23:52:18 +00005448 // This while loop must exit out the bottom, there's cleanup that we need to do when we are done.
5449 // So don't call return anywhere within it.
Jim Ingham35878c42014-04-08 21:33:21 +00005450
5451#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5452 // It's pretty much impossible to write test cases for things like:
5453 // One thread timeout expires, I go to halt, but the process already stopped
5454 // on the function call stop breakpoint. Turning on this define will make us not
5455 // fetch the first event till after the halt. So if you run a quick function, it will have
5456 // completed, and the completion event will be waiting, when you interrupt for halt.
5457 // The expression evaluation should still succeed.
5458 bool miss_first_event = true;
5459#endif
Jim Inghamfd95f892014-04-22 01:41:52 +00005460 TimeValue one_thread_timeout;
5461 TimeValue final_timeout;
Eugene Zelenko8f30a652015-10-23 18:39:37 +00005462
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005463 while (true)
Sean Callanana46ec452012-07-11 21:31:24 +00005464 {
5465 // We usually want to resume the process if we get to the top of the loop.
5466 // The only exception is if we get two running events with no intervening
5467 // stop, which can happen, we will just wait for then next stop event.
Jim Ingham0161b492013-02-09 01:29:05 +00005468 if (log)
5469 log->Printf ("Top of while loop: do_resume: %i handle_running_event: %i before_first_timeout: %i.",
5470 do_resume,
5471 handle_running_event,
5472 before_first_timeout);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005473
Jim Ingham184e9812013-01-15 02:47:48 +00005474 if (do_resume || handle_running_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005475 {
5476 // Do the initial resume and wait for the running event before going further.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005477
Jim Ingham184e9812013-01-15 02:47:48 +00005478 if (do_resume)
Sean Callanana46ec452012-07-11 21:31:24 +00005479 {
Jim Ingham0161b492013-02-09 01:29:05 +00005480 num_resumes++;
Sean Callanan579e70c2016-03-19 00:03:59 +00005481 Error resume_error = PrivateResume();
Jim Ingham184e9812013-01-15 02:47:48 +00005482 if (!resume_error.Success())
5483 {
Sean Callanan579e70c2016-03-19 00:03:59 +00005484 diagnostic_manager.Printf(eDiagnosticSeverityError,
5485 "couldn't resume inferior the %d time: \"%s\".", num_resumes,
5486 resume_error.AsCString());
Jim Ingham8646d3c2014-05-05 02:47:44 +00005487 return_value = eExpressionSetupError;
Jim Ingham184e9812013-01-15 02:47:48 +00005488 break;
5489 }
Sean Callanana46ec452012-07-11 21:31:24 +00005490 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005491
Jim Ingham0161b492013-02-09 01:29:05 +00005492 TimeValue resume_timeout = TimeValue::Now();
5493 resume_timeout.OffsetWithMicroSeconds(500000);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005494
Jim Ingham583bbb12016-03-07 21:50:25 +00005495 got_event = listener_sp->WaitForEvent(&resume_timeout, event_sp);
Sean Callanana46ec452012-07-11 21:31:24 +00005496 if (!got_event)
5497 {
5498 if (log)
Sean Callanan579e70c2016-03-19 00:03:59 +00005499 log->Printf("Process::RunThreadPlan(): didn't get any event after resume %" PRIu32 ", exiting.",
5500 num_resumes);
Sean Callanana46ec452012-07-11 21:31:24 +00005501
Sean Callanan579e70c2016-03-19 00:03:59 +00005502 diagnostic_manager.Printf(eDiagnosticSeverityError,
5503 "didn't get any event after resume %" PRIu32 ", exiting.", num_resumes);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005504 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00005505 break;
5506 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005507
Sean Callanana46ec452012-07-11 21:31:24 +00005508 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
Jim Ingham0161b492013-02-09 01:29:05 +00005509
Sean Callanana46ec452012-07-11 21:31:24 +00005510 if (stop_state != eStateRunning)
5511 {
Jim Ingham0161b492013-02-09 01:29:05 +00005512 bool restarted = false;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005513
Jim Ingham0161b492013-02-09 01:29:05 +00005514 if (stop_state == eStateStopped)
5515 {
5516 restarted = Process::ProcessEventData::GetRestartedFromEvent(event_sp.get());
5517 if (log)
5518 log->Printf("Process::RunThreadPlan(): didn't get running event after "
5519 "resume %d, got %s instead (restarted: %i, do_resume: %i, handle_running_event: %i).",
5520 num_resumes,
5521 StateAsCString(stop_state),
5522 restarted,
5523 do_resume,
5524 handle_running_event);
5525 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005526
Jim Ingham0161b492013-02-09 01:29:05 +00005527 if (restarted)
5528 {
5529 // This is probably an overabundance of caution, I don't think I should ever get a stopped & restarted
5530 // event here. But if I do, the best thing is to Halt and then get out of here.
Pavel Labath19da1f12015-12-07 12:36:52 +00005531 const bool clear_thread_plans = false;
5532 const bool use_run_lock = false;
5533 Halt(clear_thread_plans, use_run_lock);
Jim Ingham0161b492013-02-09 01:29:05 +00005534 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005535
Sean Callanan579e70c2016-03-19 00:03:59 +00005536 diagnostic_manager.Printf(eDiagnosticSeverityError,
5537 "didn't get running event after initial resume, got %s instead.",
5538 StateAsCString(stop_state));
Jim Ingham8646d3c2014-05-05 02:47:44 +00005539 return_value = eExpressionSetupError;
Sean Callanana46ec452012-07-11 21:31:24 +00005540 break;
5541 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005542
Sean Callanana46ec452012-07-11 21:31:24 +00005543 if (log)
5544 log->PutCString ("Process::RunThreadPlan(): resuming succeeded.");
5545 // We need to call the function synchronously, so spin waiting for it to return.
5546 // If we get interrupted while executing, we're going to lose our context, and
5547 // won't be able to gather the result at this point.
5548 // We set the timeout AFTER the resume, since the resume takes some time and we
5549 // don't want to charge that to the timeout.
Sean Callanana46ec452012-07-11 21:31:24 +00005550 }
Jim Ingham0f16e732011-02-08 05:20:59 +00005551 else
5552 {
Sean Callanana46ec452012-07-11 21:31:24 +00005553 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005554 log->PutCString ("Process::RunThreadPlan(): waiting for next event.");
Jim Ingham0f16e732011-02-08 05:20:59 +00005555 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005556
Jim Ingham0161b492013-02-09 01:29:05 +00005557 if (before_first_timeout)
5558 {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005559 if (options.GetTryAllThreads())
Jim Inghamfd95f892014-04-22 01:41:52 +00005560 {
5561 one_thread_timeout = TimeValue::Now();
5562 one_thread_timeout.OffsetWithMicroSeconds(one_thread_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005563 timeout_ptr = &one_thread_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005564 }
Jim Ingham0161b492013-02-09 01:29:05 +00005565 else
5566 {
5567 if (timeout_usec == 0)
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005568 timeout_ptr = nullptr;
Jim Ingham0161b492013-02-09 01:29:05 +00005569 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005570 {
5571 final_timeout = TimeValue::Now();
5572 final_timeout.OffsetWithMicroSeconds (timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005573 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005574 }
Jim Ingham0161b492013-02-09 01:29:05 +00005575 }
5576 }
5577 else
5578 {
5579 if (timeout_usec == 0)
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005580 timeout_ptr = nullptr;
Jim Ingham0161b492013-02-09 01:29:05 +00005581 else
Jim Inghamfd95f892014-04-22 01:41:52 +00005582 {
5583 final_timeout = TimeValue::Now();
5584 final_timeout.OffsetWithMicroSeconds (all_threads_timeout_usec);
Jim Ingham0161b492013-02-09 01:29:05 +00005585 timeout_ptr = &final_timeout;
Jim Inghamfd95f892014-04-22 01:41:52 +00005586 }
Jim Ingham0161b492013-02-09 01:29:05 +00005587 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005588
Jim Ingham0161b492013-02-09 01:29:05 +00005589 do_resume = true;
5590 handle_running_event = true;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005591
Sean Callanana46ec452012-07-11 21:31:24 +00005592 // Now wait for the process to stop again:
Sean Callanana46ec452012-07-11 21:31:24 +00005593 event_sp.reset();
Jim Ingham0f16e732011-02-08 05:20:59 +00005594
Jim Ingham0f16e732011-02-08 05:20:59 +00005595 if (log)
Jim Ingham20829ac2011-08-09 22:24:33 +00005596 {
Sean Callanana46ec452012-07-11 21:31:24 +00005597 if (timeout_ptr)
5598 {
Matt Kopec676a4872013-02-21 23:55:31 +00005599 log->Printf ("Process::RunThreadPlan(): about to wait - now is %" PRIu64 " - endpoint is %" PRIu64,
Jim Ingham0161b492013-02-09 01:29:05 +00005600 TimeValue::Now().GetAsMicroSecondsSinceJan1_1970(),
5601 timeout_ptr->GetAsMicroSecondsSinceJan1_1970());
Sean Callanana46ec452012-07-11 21:31:24 +00005602 }
Jim Ingham20829ac2011-08-09 22:24:33 +00005603 else
Sean Callanana46ec452012-07-11 21:31:24 +00005604 {
5605 log->Printf ("Process::RunThreadPlan(): about to wait forever.");
5606 }
5607 }
Jim Ingham35878c42014-04-08 21:33:21 +00005608
5609#ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
5610 // See comment above...
5611 if (miss_first_event)
5612 {
5613 usleep(1000);
5614 miss_first_event = false;
5615 got_event = false;
5616 }
5617 else
5618#endif
Jim Ingham583bbb12016-03-07 21:50:25 +00005619 got_event = listener_sp->WaitForEvent (timeout_ptr, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005620
Sean Callanana46ec452012-07-11 21:31:24 +00005621 if (got_event)
5622 {
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005623 if (event_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005624 {
5625 bool keep_going = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005626 if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005627 {
Pavel Labath19da1f12015-12-07 12:36:52 +00005628 const bool clear_thread_plans = false;
5629 const bool use_run_lock = false;
5630 Halt(clear_thread_plans, use_run_lock);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005631 return_value = eExpressionInterrupted;
Sean Callanan579e70c2016-03-19 00:03:59 +00005632 diagnostic_manager.PutCString(eDiagnosticSeverityRemark, "execution halted by user interrupt.");
Jim Inghamcfc09352012-07-27 23:57:19 +00005633 if (log)
Sean Callanan579e70c2016-03-19 00:03:59 +00005634 log->Printf(
5635 "Process::RunThreadPlan(): Got interrupted by eBroadcastBitInterrupted, exiting.");
Jim Ingham0161b492013-02-09 01:29:05 +00005636 break;
Jim Inghamcfc09352012-07-27 23:57:19 +00005637 }
5638 else
5639 {
5640 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5641 if (log)
5642 log->Printf("Process::RunThreadPlan(): in while loop, got event: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005643
Jim Inghamcfc09352012-07-27 23:57:19 +00005644 switch (stop_state)
Sean Callanana46ec452012-07-11 21:31:24 +00005645 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005646 case lldb::eStateStopped:
Sean Callanana46ec452012-07-11 21:31:24 +00005647 {
Jim Ingham0161b492013-02-09 01:29:05 +00005648 // We stopped, figure out what we are going to do now.
Jim Inghamcfc09352012-07-27 23:57:19 +00005649 ThreadSP thread_sp = GetThreadList().FindThreadByIndexID (thread_idx_id);
5650 if (!thread_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005651 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005652 // Ooh, our thread has vanished. Unlikely that this was successful execution...
Sean Callanana46ec452012-07-11 21:31:24 +00005653 if (log)
Jim Inghamcfc09352012-07-27 23:57:19 +00005654 log->Printf ("Process::RunThreadPlan(): execution completed but our thread (index-id=%u) has vanished.", thread_idx_id);
Jim Ingham8646d3c2014-05-05 02:47:44 +00005655 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005656 }
5657 else
5658 {
Jim Ingham0161b492013-02-09 01:29:05 +00005659 // If we were restarted, we just need to go back up to fetch another event.
5660 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
Jim Inghamcfc09352012-07-27 23:57:19 +00005661 {
5662 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005663 {
5664 log->Printf ("Process::RunThreadPlan(): Got a stop and restart, so we'll continue waiting.");
5665 }
5666 keep_going = true;
5667 do_resume = false;
5668 handle_running_event = true;
Jim Inghamcfc09352012-07-27 23:57:19 +00005669 }
5670 else
5671 {
Jim Ingham0161b492013-02-09 01:29:05 +00005672 StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
5673 StopReason stop_reason = eStopReasonInvalid;
5674 if (stop_info_sp)
5675 stop_reason = stop_info_sp->GetStopReason();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005676
Jim Ingham0161b492013-02-09 01:29:05 +00005677 // FIXME: We only check if the stop reason is plan complete, should we make sure that
5678 // it is OUR plan that is complete?
5679 if (stop_reason == eStopReasonPlanComplete)
Jim Ingham184e9812013-01-15 02:47:48 +00005680 {
5681 if (log)
Jim Ingham0161b492013-02-09 01:29:05 +00005682 log->PutCString ("Process::RunThreadPlan(): execution completed successfully.");
Jim Inghamc60963c2015-10-12 19:11:03 +00005683
5684 // Restore the plan state so it will get reported as intended when we are done.
5685 thread_plan_restorer.Clean();
5686
Jim Ingham8646d3c2014-05-05 02:47:44 +00005687 return_value = eExpressionCompleted;
Jim Ingham184e9812013-01-15 02:47:48 +00005688 }
5689 else
5690 {
Jim Ingham0161b492013-02-09 01:29:05 +00005691 // Something restarted the target, so just wait for it to stop for real.
Jim Ingham184e9812013-01-15 02:47:48 +00005692 if (stop_reason == eStopReasonBreakpoint)
Jim Ingham0161b492013-02-09 01:29:05 +00005693 {
5694 if (log)
5695 log->Printf ("Process::RunThreadPlan() stopped for breakpoint: %s.", stop_info_sp->GetDescription());
Jim Ingham8646d3c2014-05-05 02:47:44 +00005696 return_value = eExpressionHitBreakpoint;
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005697 if (!options.DoesIgnoreBreakpoints())
Sean Callanan4b388c92013-07-30 19:54:09 +00005698 {
Jim Inghamc60963c2015-10-12 19:11:03 +00005699 // Restore the plan state and then force Private to false. We are
5700 // going to stop because of this plan so we need it to become a public
5701 // plan or it won't report correctly when we continue to its termination
5702 // later on.
5703 thread_plan_restorer.Clean();
5704 if (thread_plan_sp)
5705 thread_plan_sp->SetPrivate(false);
Sean Callanan4b388c92013-07-30 19:54:09 +00005706 event_to_broadcast_sp = event_sp;
5707 }
Jim Ingham0161b492013-02-09 01:29:05 +00005708 }
Jim Ingham184e9812013-01-15 02:47:48 +00005709 else
Jim Ingham0161b492013-02-09 01:29:05 +00005710 {
5711 if (log)
5712 log->PutCString ("Process::RunThreadPlan(): thread plan didn't successfully complete.");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005713 if (!options.DoesUnwindOnError())
Sean Callanan4b388c92013-07-30 19:54:09 +00005714 event_to_broadcast_sp = event_sp;
Jim Ingham8646d3c2014-05-05 02:47:44 +00005715 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005716 }
Jim Ingham184e9812013-01-15 02:47:48 +00005717 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005718 }
Sean Callanana46ec452012-07-11 21:31:24 +00005719 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005720 }
5721 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005722
Jim Inghamcfc09352012-07-27 23:57:19 +00005723 case lldb::eStateRunning:
Jim Ingham0161b492013-02-09 01:29:05 +00005724 // This shouldn't really happen, but sometimes we do get two running events without an
5725 // intervening stop, and in that case we should just go back to waiting for the stop.
Jim Inghamcfc09352012-07-27 23:57:19 +00005726 do_resume = false;
5727 keep_going = true;
Jim Ingham184e9812013-01-15 02:47:48 +00005728 handle_running_event = false;
Jim Inghamcfc09352012-07-27 23:57:19 +00005729 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005730
Jim Inghamcfc09352012-07-27 23:57:19 +00005731 default:
5732 if (log)
5733 log->Printf("Process::RunThreadPlan(): execution stopped with unexpected state: %s.", StateAsCString(stop_state));
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005734
Jim Inghamcfc09352012-07-27 23:57:19 +00005735 if (stop_state == eStateExited)
5736 event_to_broadcast_sp = event_sp;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005737
Sean Callanan579e70c2016-03-19 00:03:59 +00005738 diagnostic_manager.PutCString(eDiagnosticSeverityError,
5739 "execution stopped with unexpected state.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005740 return_value = eExpressionInterrupted;
Jim Inghamcfc09352012-07-27 23:57:19 +00005741 break;
5742 }
Sean Callanana46ec452012-07-11 21:31:24 +00005743 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005744
Sean Callanana46ec452012-07-11 21:31:24 +00005745 if (keep_going)
5746 continue;
5747 else
5748 break;
5749 }
5750 else
5751 {
5752 if (log)
5753 log->PutCString ("Process::RunThreadPlan(): got_event was true, but the event pointer was null. How odd...");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005754 return_value = eExpressionInterrupted;
Sean Callanana46ec452012-07-11 21:31:24 +00005755 break;
5756 }
5757 }
5758 else
5759 {
5760 // If we didn't get an event that means we've timed out...
5761 // We will interrupt the process here. Depending on what we were asked to do we will
5762 // either exit, or try with all threads running for the same timeout.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005763
Sean Callanana46ec452012-07-11 21:31:24 +00005764 if (log) {
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005765 if (options.GetTryAllThreads())
Sean Callanana46ec452012-07-11 21:31:24 +00005766 {
Jim Ingham0161b492013-02-09 01:29:05 +00005767 if (before_first_timeout)
Jim Inghamfe1c3422014-04-16 02:24:48 +00005768 {
5769 if (timeout_usec != 0)
5770 {
Jim Inghamfe1c3422014-04-16 02:24:48 +00005771 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Jim Inghamfd95f892014-04-22 01:41:52 +00005772 "running for %" PRIu32 " usec with all threads enabled.",
5773 all_threads_timeout_usec);
Jim Inghamfe1c3422014-04-16 02:24:48 +00005774 }
5775 else
5776 {
5777 log->Printf ("Process::RunThreadPlan(): Running function with one thread timeout timed out, "
Ed Mastee61c7b02014-04-29 17:48:06 +00005778 "running forever with all threads enabled.");
Jim Inghamfe1c3422014-04-16 02:24:48 +00005779 }
5780 }
Sean Callanana46ec452012-07-11 21:31:24 +00005781 else
5782 log->Printf ("Process::RunThreadPlan(): Restarting function with all threads enabled "
Jason Molenda6a8658a2013-10-27 02:32:23 +00005783 "and timeout: %u timed out, abandoning execution.",
Jim Ingham35e1bda2012-10-16 21:41:58 +00005784 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005785 }
5786 else
Jason Molenda6a8658a2013-10-27 02:32:23 +00005787 log->Printf ("Process::RunThreadPlan(): Running function with timeout: %u timed out, "
Jim Ingham35e1bda2012-10-16 21:41:58 +00005788 "abandoning execution.",
5789 timeout_usec);
Sean Callanana46ec452012-07-11 21:31:24 +00005790 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005791
Jim Ingham0161b492013-02-09 01:29:05 +00005792 // It is possible that between the time we issued the Halt, and we get around to calling Halt the target
5793 // could have stopped. That's fine, Halt will figure that out and send the appropriate Stopped event.
5794 // BUT it is also possible that we stopped & restarted (e.g. hit a signal with "stop" set to false.) In
5795 // that case, we'll get the stopped & restarted event, and we should go back to waiting for the Halt's
5796 // stopped event. That's what this while loop does.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005797
Jim Ingham0161b492013-02-09 01:29:05 +00005798 bool back_to_top = true;
5799 uint32_t try_halt_again = 0;
5800 bool do_halt = true;
5801 const uint32_t num_retries = 5;
5802 while (try_halt_again < num_retries)
Sean Callanana46ec452012-07-11 21:31:24 +00005803 {
Jim Ingham0161b492013-02-09 01:29:05 +00005804 Error halt_error;
5805 if (do_halt)
5806 {
5807 if (log)
5808 log->Printf ("Process::RunThreadPlan(): Running Halt.");
Pavel Labath19da1f12015-12-07 12:36:52 +00005809 const bool clear_thread_plans = false;
5810 const bool use_run_lock = false;
5811 Halt(clear_thread_plans, use_run_lock);
Jim Ingham0161b492013-02-09 01:29:05 +00005812 }
5813 if (halt_error.Success())
5814 {
5815 if (log)
5816 log->PutCString ("Process::RunThreadPlan(): Halt succeeded.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005817
Jim Ingham0161b492013-02-09 01:29:05 +00005818 real_timeout = TimeValue::Now();
5819 real_timeout.OffsetWithMicroSeconds(500000);
5820
Jim Ingham583bbb12016-03-07 21:50:25 +00005821 got_event = listener_sp->WaitForEvent(&real_timeout, event_sp);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005822
Jim Ingham0161b492013-02-09 01:29:05 +00005823 if (got_event)
Sean Callanana46ec452012-07-11 21:31:24 +00005824 {
Jim Ingham0161b492013-02-09 01:29:05 +00005825 stop_state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
5826 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00005827 {
Jim Ingham0161b492013-02-09 01:29:05 +00005828 log->Printf ("Process::RunThreadPlan(): Stopped with event: %s", StateAsCString(stop_state));
5829 if (stop_state == lldb::eStateStopped
5830 && Process::ProcessEventData::GetInterruptedFromEvent(event_sp.get()))
5831 log->PutCString (" Event was the Halt interruption event.");
Sean Callanana46ec452012-07-11 21:31:24 +00005832 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005833
Jim Ingham0161b492013-02-09 01:29:05 +00005834 if (stop_state == lldb::eStateStopped)
Sean Callanana46ec452012-07-11 21:31:24 +00005835 {
Jim Ingham0161b492013-02-09 01:29:05 +00005836 // Between the time we initiated the Halt and the time we delivered it, the process could have
5837 // already finished its job. Check that here:
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005838
Jim Ingham0161b492013-02-09 01:29:05 +00005839 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
5840 {
5841 if (log)
5842 log->PutCString ("Process::RunThreadPlan(): Even though we timed out, the call plan was done. "
5843 "Exiting wait loop.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005844 return_value = eExpressionCompleted;
Jim Ingham0161b492013-02-09 01:29:05 +00005845 back_to_top = false;
5846 break;
5847 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005848
Jim Ingham0161b492013-02-09 01:29:05 +00005849 if (Process::ProcessEventData::GetRestartedFromEvent(event_sp.get()))
5850 {
5851 if (log)
5852 log->PutCString ("Process::RunThreadPlan(): Went to halt but got a restarted event, there must be an un-restarted stopped event so try again... "
5853 "Exiting wait loop.");
5854 try_halt_again++;
5855 do_halt = false;
5856 continue;
5857 }
Sean Callanana46ec452012-07-11 21:31:24 +00005858
Jim Ingham6fbc48b2013-11-07 00:11:47 +00005859 if (!options.GetTryAllThreads())
Jim Ingham0161b492013-02-09 01:29:05 +00005860 {
5861 if (log)
5862 log->PutCString ("Process::RunThreadPlan(): try_all_threads was false, we stopped so now we're quitting.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005863 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005864 back_to_top = false;
5865 break;
5866 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005867
Jim Ingham0161b492013-02-09 01:29:05 +00005868 if (before_first_timeout)
5869 {
5870 // Set all the other threads to run, and return to the top of the loop, which will continue;
5871 before_first_timeout = false;
5872 thread_plan_sp->SetStopOthers (false);
5873 if (log)
5874 log->PutCString ("Process::RunThreadPlan(): about to resume.");
Sean Callanana46ec452012-07-11 21:31:24 +00005875
Jim Ingham0161b492013-02-09 01:29:05 +00005876 back_to_top = true;
5877 break;
5878 }
5879 else
5880 {
5881 // Running all threads failed, so return Interrupted.
5882 if (log)
5883 log->PutCString("Process::RunThreadPlan(): running all threads timed out.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005884 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005885 back_to_top = false;
5886 break;
5887 }
Sean Callanana46ec452012-07-11 21:31:24 +00005888 }
5889 }
5890 else
Jim Ingham0161b492013-02-09 01:29:05 +00005891 { if (log)
5892 log->PutCString("Process::RunThreadPlan(): halt said it succeeded, but I got no event. "
5893 "I'm getting out of here passing Interrupted.");
Jim Ingham8646d3c2014-05-05 02:47:44 +00005894 return_value = eExpressionInterrupted;
Jim Ingham0161b492013-02-09 01:29:05 +00005895 back_to_top = false;
5896 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005897 }
5898 }
Jim Ingham0161b492013-02-09 01:29:05 +00005899 else
5900 {
5901 try_halt_again++;
5902 continue;
5903 }
Sean Callanana46ec452012-07-11 21:31:24 +00005904 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005905
Jim Ingham0161b492013-02-09 01:29:05 +00005906 if (!back_to_top || try_halt_again > num_retries)
5907 break;
5908 else
5909 continue;
Sean Callanana46ec452012-07-11 21:31:24 +00005910 }
Sean Callanana46ec452012-07-11 21:31:24 +00005911 } // END WAIT LOOP
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005912
Sean Callanana46ec452012-07-11 21:31:24 +00005913 // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
Zachary Turneracee96a2014-09-23 18:32:09 +00005914 if (backup_private_state_thread.IsJoinable())
Sean Callanana46ec452012-07-11 21:31:24 +00005915 {
5916 StopPrivateStateThread();
5917 Error error;
5918 m_private_state_thread = backup_private_state_thread;
Sean Callanan9a028512012-08-09 00:50:26 +00005919 if (stopper_base_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005920 {
5921 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
5922 }
Jason Molenda76513fd2014-10-15 23:39:31 +00005923 if (old_state != eStateInvalid)
5924 m_public_state.SetValueNoLock(old_state);
Sean Callanana46ec452012-07-11 21:31:24 +00005925 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005926
Jim Inghamc60963c2015-10-12 19:11:03 +00005927 if (return_value != eExpressionCompleted && log)
5928 {
5929 // Print a backtrace into the log so we can figure out where we are:
5930 StreamString s;
5931 s.PutCString("Thread state after unsuccessful completion: \n");
5932 thread->GetStackFrameStatus (s,
5933 0,
5934 UINT32_MAX,
5935 true,
5936 UINT32_MAX);
5937 log->PutCString(s.GetData());
5938
5939 }
Jim Ingham184e9812013-01-15 02:47:48 +00005940 // Restore the thread state if we are going to discard the plan execution. There are three cases where this
5941 // could happen:
5942 // 1) The execution successfully completed
5943 // 2) We hit a breakpoint, and ignore_breakpoints was true
5944 // 3) We got some other error, and discard_on_error was true
Jim Ingham8646d3c2014-05-05 02:47:44 +00005945 bool should_unwind = (return_value == eExpressionInterrupted && options.DoesUnwindOnError())
5946 || (return_value == eExpressionHitBreakpoint && options.DoesIgnoreBreakpoints());
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005947
Jim Ingham8646d3c2014-05-05 02:47:44 +00005948 if (return_value == eExpressionCompleted
Jim Ingham184e9812013-01-15 02:47:48 +00005949 || should_unwind)
Jim Ingham8559a352012-11-26 23:52:18 +00005950 {
5951 thread_plan_sp->RestoreThreadState();
5952 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005953
Sean Callanana46ec452012-07-11 21:31:24 +00005954 // Now do some processing on the results of the run:
Jim Ingham8646d3c2014-05-05 02:47:44 +00005955 if (return_value == eExpressionInterrupted || return_value == eExpressionHitBreakpoint)
Sean Callanana46ec452012-07-11 21:31:24 +00005956 {
5957 if (log)
5958 {
5959 StreamString s;
5960 if (event_sp)
5961 event_sp->Dump (&s);
5962 else
5963 {
5964 log->PutCString ("Process::RunThreadPlan(): Stop event that interrupted us is NULL.");
5965 }
5966
5967 StreamString ts;
5968
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00005969 const char *event_explanation = nullptr;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005970
Sean Callanana46ec452012-07-11 21:31:24 +00005971 do
5972 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005973 if (!event_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00005974 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005975 event_explanation = "<no event>";
Sean Callanana46ec452012-07-11 21:31:24 +00005976 break;
5977 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005978 else if (event_sp->GetType() == eBroadcastBitInterrupt)
Sean Callanana46ec452012-07-11 21:31:24 +00005979 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005980 event_explanation = "<user interrupt>";
Sean Callanana46ec452012-07-11 21:31:24 +00005981 break;
5982 }
Jim Inghamcfc09352012-07-27 23:57:19 +00005983 else
Sean Callanana46ec452012-07-11 21:31:24 +00005984 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005985 const Process::ProcessEventData *event_data = Process::ProcessEventData::GetEventDataFromEvent (event_sp.get());
5986
5987 if (!event_data)
Sean Callanana46ec452012-07-11 21:31:24 +00005988 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005989 event_explanation = "<no event data>";
5990 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005991 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00005992
Jim Inghamcfc09352012-07-27 23:57:19 +00005993 Process *process = event_data->GetProcessSP().get();
5994
5995 if (!process)
Sean Callanana46ec452012-07-11 21:31:24 +00005996 {
Jim Inghamcfc09352012-07-27 23:57:19 +00005997 event_explanation = "<no process>";
5998 break;
Sean Callanana46ec452012-07-11 21:31:24 +00005999 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006000
Jim Inghamcfc09352012-07-27 23:57:19 +00006001 ThreadList &thread_list = process->GetThreadList();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006002
Jim Inghamcfc09352012-07-27 23:57:19 +00006003 uint32_t num_threads = thread_list.GetSize();
6004 uint32_t thread_index;
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006005
Jim Inghamcfc09352012-07-27 23:57:19 +00006006 ts.Printf("<%u threads> ", num_threads);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006007
Jim Inghamcfc09352012-07-27 23:57:19 +00006008 for (thread_index = 0;
6009 thread_index < num_threads;
6010 ++thread_index)
6011 {
6012 Thread *thread = thread_list.GetThreadAtIndex(thread_index).get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006013
Jim Inghamcfc09352012-07-27 23:57:19 +00006014 if (!thread)
6015 {
6016 ts.Printf("<?> ");
6017 continue;
6018 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006019
Daniel Malead01b2952012-11-29 21:49:15 +00006020 ts.Printf("<0x%4.4" PRIx64 " ", thread->GetID());
Jim Inghamcfc09352012-07-27 23:57:19 +00006021 RegisterContext *register_context = thread->GetRegisterContext().get();
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006022
Jim Inghamcfc09352012-07-27 23:57:19 +00006023 if (register_context)
Daniel Malead01b2952012-11-29 21:49:15 +00006024 ts.Printf("[ip 0x%" PRIx64 "] ", register_context->GetPC());
Jim Inghamcfc09352012-07-27 23:57:19 +00006025 else
6026 ts.Printf("[ip unknown] ");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006027
Jim Inghamc60963c2015-10-12 19:11:03 +00006028 // Show the private stop info here, the public stop info will be from the last natural stop.
6029 lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();
Jim Inghamcfc09352012-07-27 23:57:19 +00006030 if (stop_info_sp)
6031 {
6032 const char *stop_desc = stop_info_sp->GetDescription();
6033 if (stop_desc)
6034 ts.PutCString (stop_desc);
6035 }
6036 ts.Printf(">");
6037 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006038
Jim Inghamcfc09352012-07-27 23:57:19 +00006039 event_explanation = ts.GetData();
Sean Callanana46ec452012-07-11 21:31:24 +00006040 }
Sean Callanana46ec452012-07-11 21:31:24 +00006041 } while (0);
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006042
Jim Inghamcfc09352012-07-27 23:57:19 +00006043 if (event_explanation)
6044 log->Printf("Process::RunThreadPlan(): execution interrupted: %s %s", s.GetData(), event_explanation);
Sean Callanana46ec452012-07-11 21:31:24 +00006045 else
Jim Inghamcfc09352012-07-27 23:57:19 +00006046 log->Printf("Process::RunThreadPlan(): execution interrupted: %s", s.GetData());
6047 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006048
Jim Inghame4483cf2013-09-27 01:13:01 +00006049 if (should_unwind)
Jim Inghamcfc09352012-07-27 23:57:19 +00006050 {
6051 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006052 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - discarding thread plans up to %p.",
6053 static_cast<void*>(thread_plan_sp.get()));
Jim Inghamcfc09352012-07-27 23:57:19 +00006054 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Inghamcfc09352012-07-27 23:57:19 +00006055 }
6056 else
6057 {
6058 if (log)
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006059 log->Printf ("Process::RunThreadPlan: ExecutionInterrupted - for plan: %p not discarding.",
6060 static_cast<void*>(thread_plan_sp.get()));
Sean Callanana46ec452012-07-11 21:31:24 +00006061 }
6062 }
Jim Ingham8646d3c2014-05-05 02:47:44 +00006063 else if (return_value == eExpressionSetupError)
Sean Callanana46ec452012-07-11 21:31:24 +00006064 {
6065 if (log)
6066 log->PutCString("Process::RunThreadPlan(): execution set up error.");
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006067
Jim Ingham6fbc48b2013-11-07 00:11:47 +00006068 if (options.DoesUnwindOnError())
Jim Ingham0f16e732011-02-08 05:20:59 +00006069 {
Greg Claytonc14ee322011-09-22 04:58:26 +00006070 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Jim Ingham0f16e732011-02-08 05:20:59 +00006071 }
Jim Inghamf48169b2010-11-30 02:22:11 +00006072 }
6073 else
6074 {
Sean Callanana46ec452012-07-11 21:31:24 +00006075 if (thread->IsThreadPlanDone (thread_plan_sp.get()))
Jim Inghamf48169b2010-11-30 02:22:11 +00006076 {
Jim Ingham0f16e732011-02-08 05:20:59 +00006077 if (log)
Sean Callanana46ec452012-07-11 21:31:24 +00006078 log->PutCString("Process::RunThreadPlan(): thread plan is done");
Jim Ingham8646d3c2014-05-05 02:47:44 +00006079 return_value = eExpressionCompleted;
Sean Callanana46ec452012-07-11 21:31:24 +00006080 }
6081 else if (thread->WasThreadPlanDiscarded (thread_plan_sp.get()))
6082 {
6083 if (log)
6084 log->PutCString("Process::RunThreadPlan(): thread plan was discarded");
Jim Ingham8646d3c2014-05-05 02:47:44 +00006085 return_value = eExpressionDiscarded;
Sean Callanana46ec452012-07-11 21:31:24 +00006086 }
6087 else
6088 {
6089 if (log)
6090 log->PutCString("Process::RunThreadPlan(): thread plan stopped in mid course");
Jim Ingham6fbc48b2013-11-07 00:11:47 +00006091 if (options.DoesUnwindOnError() && thread_plan_sp)
Sean Callanana46ec452012-07-11 21:31:24 +00006092 {
6093 if (log)
Jim Ingham184e9812013-01-15 02:47:48 +00006094 log->PutCString("Process::RunThreadPlan(): discarding thread plan 'cause unwind_on_error is set.");
Sean Callanana46ec452012-07-11 21:31:24 +00006095 thread->DiscardThreadPlansUpToPlan (thread_plan_sp);
Sean Callanana46ec452012-07-11 21:31:24 +00006096 }
6097 }
6098 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006099
Sean Callanana46ec452012-07-11 21:31:24 +00006100 // Thread we ran the function in may have gone away because we ran the target
6101 // Check that it's still there, and if it is put it back in the context. Also restore the
6102 // frame in the context if it is still present.
6103 thread = GetThreadList().FindThreadByIndexID(thread_idx_id, true).get();
6104 if (thread)
6105 {
6106 exe_ctx.SetFrameSP (thread->GetFrameWithStackID (ctx_frame_id));
6107 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006108
Sean Callanana46ec452012-07-11 21:31:24 +00006109 // Also restore the current process'es selected frame & thread, since this function calling may
6110 // be done behind the user's back.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006111
Sean Callanana46ec452012-07-11 21:31:24 +00006112 if (selected_tid != LLDB_INVALID_THREAD_ID)
6113 {
6114 if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
6115 {
6116 // We were able to restore the selected thread, now restore the frame:
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00006117 std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex());
Jason Molendab57e4a12013-11-04 09:33:30 +00006118 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
Sean Callanana46ec452012-07-11 21:31:24 +00006119 if (old_frame_sp)
6120 GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());
Jim Inghamf48169b2010-11-30 02:22:11 +00006121 }
Jim Inghamf48169b2010-11-30 02:22:11 +00006122 }
6123 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006124
Sean Callanana46ec452012-07-11 21:31:24 +00006125 // If the process exited during the run of the thread plan, notify everyone.
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006126
Sean Callanana46ec452012-07-11 21:31:24 +00006127 if (event_to_broadcast_sp)
Jim Inghamf48169b2010-11-30 02:22:11 +00006128 {
Sean Callanana46ec452012-07-11 21:31:24 +00006129 if (log)
6130 log->PutCString("Process::RunThreadPlan(): rebroadcasting event.");
6131 BroadcastEvent(event_to_broadcast_sp);
Jim Inghamf48169b2010-11-30 02:22:11 +00006132 }
Saleem Abdulrasool324a1032014-04-04 04:06:10 +00006133
Jim Inghamf48169b2010-11-30 02:22:11 +00006134 return return_value;
6135}
6136
6137const char *
Jim Ingham1624a2d2014-05-05 02:26:40 +00006138Process::ExecutionResultAsCString (ExpressionResults result)
Jim Inghamf48169b2010-11-30 02:22:11 +00006139{
6140 const char *result_name;
6141
6142 switch (result)
6143 {
Jim Ingham8646d3c2014-05-05 02:47:44 +00006144 case eExpressionCompleted:
6145 result_name = "eExpressionCompleted";
Jim Inghamf48169b2010-11-30 02:22:11 +00006146 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006147 case eExpressionDiscarded:
6148 result_name = "eExpressionDiscarded";
Jim Inghamf48169b2010-11-30 02:22:11 +00006149 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006150 case eExpressionInterrupted:
6151 result_name = "eExpressionInterrupted";
Jim Inghamf48169b2010-11-30 02:22:11 +00006152 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006153 case eExpressionHitBreakpoint:
6154 result_name = "eExpressionHitBreakpoint";
Jim Ingham184e9812013-01-15 02:47:48 +00006155 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006156 case eExpressionSetupError:
6157 result_name = "eExpressionSetupError";
Jim Inghamf48169b2010-11-30 02:22:11 +00006158 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006159 case eExpressionParseError:
6160 result_name = "eExpressionParseError";
Jim Ingham1624a2d2014-05-05 02:26:40 +00006161 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006162 case eExpressionResultUnavailable:
6163 result_name = "eExpressionResultUnavailable";
Jim Ingham1624a2d2014-05-05 02:26:40 +00006164 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006165 case eExpressionTimedOut:
6166 result_name = "eExpressionTimedOut";
Jim Inghamf48169b2010-11-30 02:22:11 +00006167 break;
Jim Ingham8646d3c2014-05-05 02:47:44 +00006168 case eExpressionStoppedForDebug:
6169 result_name = "eExpressionStoppedForDebug";
Jim Ingham6fbc48b2013-11-07 00:11:47 +00006170 break;
Jim Inghamf48169b2010-11-30 02:22:11 +00006171 }
6172 return result_name;
6173}
6174
Greg Clayton7260f622011-04-18 08:33:37 +00006175void
6176Process::GetStatus (Stream &strm)
6177{
6178 const StateType state = GetState();
Greg Clayton2637f822011-11-17 01:23:07 +00006179 if (StateIsStoppedState(state, false))
Greg Clayton7260f622011-04-18 08:33:37 +00006180 {
6181 if (state == eStateExited)
6182 {
6183 int exit_status = GetExitStatus();
6184 const char *exit_description = GetExitDescription();
Daniel Malead01b2952012-11-29 21:49:15 +00006185 strm.Printf ("Process %" PRIu64 " exited with status = %i (0x%8.8x) %s\n",
Greg Clayton7260f622011-04-18 08:33:37 +00006186 GetID(),
6187 exit_status,
6188 exit_status,
6189 exit_description ? exit_description : "");
6190 }
6191 else
6192 {
6193 if (state == eStateConnected)
6194 strm.Printf ("Connected to remote target.\n");
6195 else
Daniel Malead01b2952012-11-29 21:49:15 +00006196 strm.Printf ("Process %" PRIu64 " %s\n", GetID(), StateAsCString (state));
Greg Clayton7260f622011-04-18 08:33:37 +00006197 }
6198 }
6199 else
6200 {
Daniel Malead01b2952012-11-29 21:49:15 +00006201 strm.Printf ("Process %" PRIu64 " is running.\n", GetID());
Greg Clayton7260f622011-04-18 08:33:37 +00006202 }
6203}
6204
6205size_t
6206Process::GetThreadStatus (Stream &strm,
6207 bool only_threads_with_stop_reason,
6208 uint32_t start_frame,
6209 uint32_t num_frames,
6210 uint32_t num_frames_with_source)
6211{
6212 size_t num_thread_infos_dumped = 0;
6213
Jim Ingham4a65fb12014-03-07 11:20:03 +00006214 // You can't hold the thread list lock while calling Thread::GetStatus. That very well might run code (e.g. if we need it
6215 // to get return values or arguments.) For that to work the process has to be able to acquire it. So instead copy the thread
6216 // ID's, and look them up one by one:
6217
6218 uint32_t num_threads;
Greg Clayton332e8b12015-01-13 21:13:08 +00006219 std::vector<lldb::tid_t> thread_id_array;
Jim Ingham4a65fb12014-03-07 11:20:03 +00006220 //Scope for thread list locker;
6221 {
Saleem Abdulrasoolbb19a132016-05-19 05:13:57 +00006222 std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex());
Jim Ingham4a65fb12014-03-07 11:20:03 +00006223 ThreadList &curr_thread_list = GetThreadList();
6224 num_threads = curr_thread_list.GetSize();
6225 uint32_t idx;
Greg Clayton332e8b12015-01-13 21:13:08 +00006226 thread_id_array.resize(num_threads);
Jim Ingham4a65fb12014-03-07 11:20:03 +00006227 for (idx = 0; idx < num_threads; ++idx)
Greg Clayton332e8b12015-01-13 21:13:08 +00006228 thread_id_array[idx] = curr_thread_list.GetThreadAtIndex(idx)->GetID();
Jim Ingham4a65fb12014-03-07 11:20:03 +00006229 }
6230
Greg Clayton7260f622011-04-18 08:33:37 +00006231 for (uint32_t i = 0; i < num_threads; i++)
6232 {
Greg Clayton332e8b12015-01-13 21:13:08 +00006233 ThreadSP thread_sp(GetThreadList().FindThreadByID(thread_id_array[i]));
Jim Ingham4a65fb12014-03-07 11:20:03 +00006234 if (thread_sp)
Greg Clayton7260f622011-04-18 08:33:37 +00006235 {
6236 if (only_threads_with_stop_reason)
6237 {
Jim Ingham4a65fb12014-03-07 11:20:03 +00006238 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006239 if (!stop_info_sp || !stop_info_sp->IsValid())
Greg Clayton7260f622011-04-18 08:33:37 +00006240 continue;
6241 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00006242 thread_sp->GetStatus (strm,
Greg Clayton7260f622011-04-18 08:33:37 +00006243 start_frame,
6244 num_frames,
6245 num_frames_with_source);
6246 ++num_thread_infos_dumped;
6247 }
Jim Ingham4a65fb12014-03-07 11:20:03 +00006248 else
6249 {
6250 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
6251 if (log)
6252 log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
Jim Ingham4a65fb12014-03-07 11:20:03 +00006253 }
Greg Clayton7260f622011-04-18 08:33:37 +00006254 }
6255 return num_thread_infos_dumped;
6256}
6257
Greg Claytona9f40ad2012-02-22 04:37:26 +00006258void
6259Process::AddInvalidMemoryRegion (const LoadRange &region)
6260{
6261 m_memory_cache.AddInvalidRange(region.GetRangeBase(), region.GetByteSize());
6262}
6263
6264bool
6265Process::RemoveInvalidMemoryRange (const LoadRange &region)
6266{
6267 return m_memory_cache.RemoveInvalidRange(region.GetRangeBase(), region.GetByteSize());
6268}
6269
Jim Ingham372787f2012-04-07 00:00:41 +00006270void
6271Process::AddPreResumeAction (PreResumeActionCallback callback, void *baton)
6272{
6273 m_pre_resume_actions.push_back(PreResumeCallbackAndBaton (callback, baton));
6274}
6275
6276bool
6277Process::RunPreResumeActions ()
6278{
6279 bool result = true;
6280 while (!m_pre_resume_actions.empty())
6281 {
6282 struct PreResumeCallbackAndBaton action = m_pre_resume_actions.back();
6283 m_pre_resume_actions.pop_back();
6284 bool this_result = action.callback (action.baton);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006285 if (result)
Jason Molenda55710932014-11-17 20:10:15 +00006286 result = this_result;
Jim Ingham372787f2012-04-07 00:00:41 +00006287 }
6288 return result;
6289}
6290
6291void
6292Process::ClearPreResumeActions ()
6293{
6294 m_pre_resume_actions.clear();
6295}
Greg Claytona9f40ad2012-02-22 04:37:26 +00006296
Zachary Turner93749ab2015-03-03 21:51:25 +00006297ProcessRunLock &
6298Process::GetRunLock()
6299{
6300 if (m_private_state_thread.EqualsThread(Host::GetCurrentThread()))
6301 return m_private_run_lock;
6302 else
6303 return m_public_run_lock;
6304}
6305
Greg Claytonfa559e52012-05-18 02:38:05 +00006306void
6307Process::Flush ()
6308{
6309 m_thread_list.Flush();
Jason Molenda5e8dce42013-12-13 00:29:16 +00006310 m_extended_thread_list.Flush();
6311 m_extended_thread_stop_id = 0;
6312 m_queue_list.Clear();
6313 m_queue_list_stop_id = 0;
Greg Claytonfa559e52012-05-18 02:38:05 +00006314}
Greg Clayton90ba8112012-12-05 00:16:59 +00006315
6316void
6317Process::DidExec ()
6318{
Todd Fiala76e0fc92014-08-27 22:58:26 +00006319 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
6320 if (log)
6321 log->Printf ("Process::%s()", __FUNCTION__);
6322
Greg Clayton90ba8112012-12-05 00:16:59 +00006323 Target &target = GetTarget();
6324 target.CleanupProcess ();
Greg Claytonb35db632013-11-09 00:03:31 +00006325 target.ClearModules(false);
Greg Clayton90ba8112012-12-05 00:16:59 +00006326 m_dynamic_checkers_ap.reset();
6327 m_abi_sp.reset();
Jason Molendaeef51062013-11-05 03:57:19 +00006328 m_system_runtime_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00006329 m_os_ap.reset();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006330 m_dyld_ap.reset();
Andrew MacPherson17220c12014-03-05 10:12:43 +00006331 m_jit_loaders_ap.reset();
Greg Clayton90ba8112012-12-05 00:16:59 +00006332 m_image_tokens.clear();
6333 m_allocated_memory_cache.Clear();
6334 m_language_runtimes.clear();
Kuba Breckaafdf8422014-10-10 23:43:03 +00006335 m_instrumentation_runtimes.clear();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006336 m_thread_list.DiscardThreadPlans();
Greg Clayton15fc2be2013-05-21 01:00:52 +00006337 m_memory_cache.Clear(true);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006338 m_stop_info_override_callback = nullptr;
Greg Clayton90ba8112012-12-05 00:16:59 +00006339 DoDidExec();
6340 CompleteAttach ();
Greg Clayton095eeaa2013-11-05 23:28:00 +00006341 // Flush the process (threads and all stack frames) after running CompleteAttach()
6342 // in case the dynamic loader loaded things in new locations.
6343 Flush();
Greg Claytonb35db632013-11-09 00:03:31 +00006344
6345 // After we figure out what was loaded/unloaded in CompleteAttach,
6346 // we need to let the target know so it can do any cleanup it needs to.
6347 target.DidExec();
Greg Clayton90ba8112012-12-05 00:16:59 +00006348}
Greg Clayton095eeaa2013-11-05 23:28:00 +00006349
Jim Ingham1460e4b2014-01-10 23:46:59 +00006350addr_t
6351Process::ResolveIndirectFunction(const Address *address, Error &error)
6352{
6353 if (address == nullptr)
6354 {
Jean-Daniel Dupasef37711f2014-02-08 20:22:05 +00006355 error.SetErrorString("Invalid address argument");
Jim Ingham1460e4b2014-01-10 23:46:59 +00006356 return LLDB_INVALID_ADDRESS;
6357 }
6358
6359 addr_t function_addr = LLDB_INVALID_ADDRESS;
6360
6361 addr_t addr = address->GetLoadAddress(&GetTarget());
6362 std::map<addr_t,addr_t>::const_iterator iter = m_resolved_indirect_addresses.find(addr);
6363 if (iter != m_resolved_indirect_addresses.end())
6364 {
6365 function_addr = (*iter).second;
6366 }
6367 else
6368 {
6369 if (!InferiorCall(this, address, function_addr))
6370 {
6371 Symbol *symbol = address->CalculateSymbolContextSymbol();
6372 error.SetErrorStringWithFormat ("Unable to call resolver for indirect function %s",
6373 symbol ? symbol->GetName().AsCString() : "<UNKNOWN>");
6374 function_addr = LLDB_INVALID_ADDRESS;
6375 }
6376 else
6377 {
6378 m_resolved_indirect_addresses.insert(std::pair<addr_t, addr_t>(addr, function_addr));
6379 }
6380 }
6381 return function_addr;
6382}
6383
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00006384void
6385Process::ModulesDidLoad (ModuleList &module_list)
6386{
Kuba Breckaafdf8422014-10-10 23:43:03 +00006387 SystemRuntime *sys_runtime = GetSystemRuntime();
6388 if (sys_runtime)
6389 {
6390 sys_runtime->ModulesDidLoad (module_list);
6391 }
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00006392
Kuba Breckaafdf8422014-10-10 23:43:03 +00006393 GetJITLoaders().ModulesDidLoad (module_list);
6394
6395 // Give runtimes a chance to be created.
6396 InstrumentationRuntime::ModulesDidLoad(module_list, this, m_instrumentation_runtimes);
6397
6398 // Tell runtimes about new modules.
6399 for (auto pos = m_instrumentation_runtimes.begin(); pos != m_instrumentation_runtimes.end(); ++pos)
6400 {
6401 InstrumentationRuntimeSP runtime = pos->second;
6402 runtime->ModulesDidLoad(module_list);
6403 }
6404
Greg Clayton35ca64b2015-04-16 17:13:34 +00006405 // Let any language runtimes we have already created know
6406 // about the modules that loaded.
6407
6408 // Iterate over a copy of this language runtime list in case
6409 // the language runtime ModulesDidLoad somehow causes the language
6410 // riuntime to be unloaded.
6411 LanguageRuntimeCollection language_runtimes(m_language_runtimes);
6412 for (const auto &pair: language_runtimes)
6413 {
6414 // We must check language_runtime_sp to make sure it is not
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006415 // nullptr as we might cache the fact that we didn't have a
Greg Clayton35ca64b2015-04-16 17:13:34 +00006416 // language runtime for a language.
6417 LanguageRuntimeSP language_runtime_sp = pair.second;
6418 if (language_runtime_sp)
6419 language_runtime_sp->ModulesDidLoad(module_list);
6420 }
Ryan Brown65d4d5c2015-09-16 21:20:44 +00006421
Greg Clayton2591fe12016-03-15 22:44:07 +00006422 // If we don't have an operating system plug-in, try to load one since
6423 // loading shared libraries might cause a new one to try and load
6424 if (!m_os_ap)
6425 LoadOperatingSystemPlugin(false);
Andrew MacPhersoneb4d0602014-03-13 09:37:02 +00006426}
Kuba Breckaa51ea382014-09-06 01:33:13 +00006427
Jason Molendaef7d6412015-08-06 03:27:10 +00006428void
Sean Callanan77decf52015-12-09 01:25:01 +00006429Process::PrintWarning (uint64_t warning_type, const void *repeat_key, const char *fmt, ...)
Jason Molendaef7d6412015-08-06 03:27:10 +00006430{
6431 bool print_warning = true;
6432
6433 StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006434 if (!stream_sp)
Jason Molendaef7d6412015-08-06 03:27:10 +00006435 return;
6436 if (warning_type == eWarningsOptimization
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006437 && !GetWarningsOptimization())
Jason Molendaef7d6412015-08-06 03:27:10 +00006438 {
6439 return;
6440 }
6441
6442 if (repeat_key != nullptr)
6443 {
6444 WarningsCollection::iterator it = m_warnings_issued.find (warning_type);
6445 if (it == m_warnings_issued.end())
6446 {
6447 m_warnings_issued[warning_type] = WarningsPointerSet();
6448 m_warnings_issued[warning_type].insert (repeat_key);
6449 }
6450 else
6451 {
6452 if (it->second.find (repeat_key) != it->second.end())
6453 {
6454 print_warning = false;
6455 }
6456 else
6457 {
6458 it->second.insert (repeat_key);
6459 }
6460 }
6461 }
6462
6463 if (print_warning)
6464 {
6465 va_list args;
6466 va_start (args, fmt);
6467 stream_sp->PrintfVarArg (fmt, args);
6468 va_end (args);
6469 }
6470}
6471
Jason Molenda484900b2015-08-10 07:55:25 +00006472void
6473Process::PrintWarningOptimization (const SymbolContext &sc)
6474{
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006475 if (GetWarningsOptimization()
6476 && sc.module_sp
6477 && !sc.module_sp->GetFileSpec().GetFilename().IsEmpty()
Jason Molenda484900b2015-08-10 07:55:25 +00006478 && sc.function
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006479 && sc.function->GetIsOptimized())
Jason Molenda484900b2015-08-10 07:55:25 +00006480 {
6481 PrintWarning (Process::Warnings::eWarningsOptimization, sc.module_sp.get(), "%s was compiled with optimization - stepping may behave oddly; variables may not be available.\n", sc.module_sp->GetFileSpec().GetFilename().GetCString());
6482 }
6483}
6484
Pavel Labatha933d512016-04-05 13:07:16 +00006485bool
6486Process::GetProcessInfo(ProcessInstanceInfo &info)
6487{
6488 info.Clear();
6489
6490 PlatformSP platform_sp = GetTarget().GetPlatform();
6491 if (! platform_sp)
6492 return false;
6493
6494 return platform_sp->GetProcessInfo(GetID(), info);
6495}
6496
Kuba Breckaa51ea382014-09-06 01:33:13 +00006497ThreadCollectionSP
6498Process::GetHistoryThreads(lldb::addr_t addr)
6499{
6500 ThreadCollectionSP threads;
Greg Clayton35ca64b2015-04-16 17:13:34 +00006501
Kuba Breckaa51ea382014-09-06 01:33:13 +00006502 const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(shared_from_this());
6503
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006504 if (!memory_history) {
Kuba Breckaa51ea382014-09-06 01:33:13 +00006505 return threads;
6506 }
6507
6508 threads.reset(new ThreadCollection(memory_history->GetHistoryThreads(addr)));
6509
6510 return threads;
6511}
Kuba Brecka63927542014-10-11 01:59:32 +00006512
6513InstrumentationRuntimeSP
6514Process::GetInstrumentationRuntime(lldb::InstrumentationRuntimeType type)
6515{
6516 InstrumentationRuntimeCollection::iterator pos;
6517 pos = m_instrumentation_runtimes.find (type);
6518 if (pos == m_instrumentation_runtimes.end())
6519 {
6520 return InstrumentationRuntimeSP();
6521 }
6522 else
6523 return (*pos).second;
6524}
Tamas Berghammer7cb18bf2015-03-24 11:15:23 +00006525
6526bool
6527Process::GetModuleSpec(const FileSpec& module_file_spec,
6528 const ArchSpec& arch,
6529 ModuleSpec& module_spec)
6530{
6531 module_spec.Clear();
6532 return false;
6533}
Tamas Berghammer3cb132a2015-12-02 11:58:51 +00006534
6535size_t
6536Process::AddImageToken(lldb::addr_t image_ptr)
6537{
6538 m_image_tokens.push_back(image_ptr);
6539 return m_image_tokens.size() - 1;
6540}
6541
6542lldb::addr_t
6543Process::GetImagePtrFromToken(size_t token) const
6544{
6545 if (token < m_image_tokens.size())
6546 return m_image_tokens[token];
6547 return LLDB_INVALID_IMAGE_TOKEN;
6548}
6549
6550void
6551Process::ResetImageToken(size_t token)
6552{
6553 if (token < m_image_tokens.size())
6554 m_image_tokens[token] = LLDB_INVALID_IMAGE_TOKEN;
Enrico Granataf3129cb2015-12-03 23:53:45 +00006555}
Jason Molendafd4cea52016-01-08 21:40:11 +00006556
6557Address
6558Process::AdvanceAddressToNextBranchInstruction (Address default_stop_addr, AddressRange range_bounds)
6559{
6560 Target &target = GetTarget();
6561 DisassemblerSP disassembler_sp;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006562 InstructionList *insn_list = nullptr;
Jason Molendafd4cea52016-01-08 21:40:11 +00006563
6564 Address retval = default_stop_addr;
6565
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006566 if (!target.GetUseFastStepping())
Jason Molendafd4cea52016-01-08 21:40:11 +00006567 return retval;
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006568 if (!default_stop_addr.IsValid())
Jason Molendafd4cea52016-01-08 21:40:11 +00006569 return retval;
6570
6571 ExecutionContext exe_ctx (this);
6572 const char *plugin_name = nullptr;
6573 const char *flavor = nullptr;
6574 const bool prefer_file_cache = true;
6575 disassembler_sp = Disassembler::DisassembleRange(target.GetArchitecture(),
6576 plugin_name,
6577 flavor,
6578 exe_ctx,
6579 range_bounds,
6580 prefer_file_cache);
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006581 if (disassembler_sp)
Jason Molendafd4cea52016-01-08 21:40:11 +00006582 insn_list = &disassembler_sp->GetInstructionList();
6583
Eugene Zelenkoda8cf8a2016-03-01 00:55:51 +00006584 if (insn_list == nullptr)
Jason Molendafd4cea52016-01-08 21:40:11 +00006585 {
6586 return retval;
6587 }
6588
6589 size_t insn_offset = insn_list->GetIndexOfInstructionAtAddress (default_stop_addr);
6590 if (insn_offset == UINT32_MAX)
6591 {
6592 return retval;
6593 }
6594
6595 uint32_t branch_index = insn_list->GetIndexOfNextBranchInstruction (insn_offset, target);
6596 if (branch_index == UINT32_MAX)
6597 {
6598 return retval;
6599 }
6600
6601 if (branch_index > insn_offset)
6602 {
6603 Address next_branch_insn_address = insn_list->GetInstructionAtIndex (branch_index)->GetAddress();
6604 if (next_branch_insn_address.IsValid() && range_bounds.ContainsFileAddress (next_branch_insn_address))
6605 {
6606 retval = next_branch_insn_address;
6607 }
6608 }
6609
Jason Molendafd4cea52016-01-08 21:40:11 +00006610 return retval;
6611}
Howard Hellyerad007562016-07-07 08:21:28 +00006612
6613Error
6614Process::GetMemoryRegions (std::vector<lldb::MemoryRegionInfoSP>& region_list)
6615{
6616
6617 Error error;
6618
6619 lldb::addr_t range_base = 0;
6620 lldb::addr_t range_end = 0;
6621
6622 region_list.clear();
6623 do
6624 {
6625 lldb::MemoryRegionInfoSP region_info( new lldb_private::MemoryRegionInfo() );
6626 error = GetMemoryRegionInfo (range_end, *region_info);
6627 // GetMemoryRegionInfo should only return an error if it is unimplemented.
6628 if (error.Fail())
6629 {
6630 region_list.clear();
6631 break;
6632 }
6633
6634 range_base = region_info->GetRange().GetRangeBase();
6635 range_end = region_info->GetRange().GetRangeEnd();
6636 if( region_info->GetMapped() == MemoryRegionInfo::eYes )
6637 {
6638 region_list.push_back(region_info);
6639 }
6640 } while (range_end != LLDB_INVALID_ADDRESS);
6641
6642 return error;
6643
6644}